Previous

199869 Revisions

Next

r20641 Thursday 31st January, 2013 at 21:40:26 UTC by Wilbert Pol
Changed LR35902 configuration and tagmap lookup reduction for gameboy.c (nw)

[src/emu/cpu/lr35902]	lr35902.c lr35902.h
[src/mess/drivers]	gb.c
[src/mess/includes]	gb.h
[src/mess/machine]	gb.c
[src/mess/video]	gb.c

trunk/src/mess/machine/gb.c

r20640	r20641
130	130
131	131
132	132	static void gb_machine_stop(running_machine &machine);
133		static void gb_timer_increment( running_machine &machine );
134	133
135	134	#ifdef MAME_DEBUG
136	135	/* #define V_GENERAL*/      /* Display general debug information */
137	136	/* #define V_BANK*/         /* Display bank switching debug information */
138	137	#endif
139	138
140		static void gb_init_regs(running_machine &machine)
	139	void gb_state::gb_init_regs()
141	140	{
142		gb_state *state = machine.driver_data<gb_state>();
143	141	/* Initialize the registers */
144		state->SIODATA = 0x00;
145		state->SIOCONT = 0x7E;
	142	SIODATA = 0x00;
	143	SIOCONT = 0x7E;
146	144
147		state->gb_io_w( machine.device("maincpu")->memory().space(AS_PROGRAM ), 0x05, 0x00 );       /* TIMECNT */
148		state->gb_io_w( machine.device("maincpu")->memory().space(AS_PROGRAM ), 0x06, 0x00 );       /* TIMEMOD */
	145	gb_io_w( m_maincpu->space(AS_PROGRAM ), 0x05, 0x00 );       /* TIMECNT */
	146	gb_io_w( m_maincpu->space(AS_PROGRAM ), 0x06, 0x00 );       /* TIMEMOD */
149	147	}
150	148
151		static void gb_rom16_0000( running_machine &machine, UINT8 *addr )
	149
	150	void gb_state::gb_rom16_0000( UINT8 *addr )
152	151	{
153		gb_state *state = machine.driver_data<gb_state>();
154		state->membank( "bank5" )->set_base( addr );
155		state->membank( "bank10" )->set_base( addr + 0x0100 );
156		state->membank( "bank6" )->set_base( addr + 0x0200 );
157		state->membank( "bank11" )->set_base( addr + 0x0900 );
	152	m_bank5->set_base( addr );
	153	m_bank10->set_base( addr + 0x0100 );
	154	m_bank6->set_base( addr + 0x0200 );
	155	m_bank11->set_base( addr + 0x0900 );
158	156	}
159	157
160		static void gb_rom16_4000( running_machine &machine, UINT8 *addr )
	158
	159	void gb_state::gb_rom16_4000( UINT8 *addr )
161	160	{
162		gb_state *state = machine.driver_data<gb_state>();
163		state->membank( "bank1" )->set_base( addr );
164		state->membank( "bank4" )->set_base( addr + 0x2000 );
	161	m_bank1->set_base( addr );
	162	m_bank4->set_base( addr + 0x2000 );
165	163	}
166	164
167		static void gb_rom8_4000( running_machine &machine, UINT8 *addr )
	165
	166	void gb_state::gb_rom8_4000( UINT8 *addr )
168	167	{
169		gb_state *state = machine.driver_data<gb_state>();
170		state->membank( "bank1" )->set_base( addr );
	168	m_bank1->set_base( addr );
171	169	}
172	170
173		static void gb_rom8_6000( running_machine &machine, UINT8 *addr )
	171
	172	void gb_state::gb_rom8_6000( UINT8 *addr )
174	173	{
175		gb_state *state = machine.driver_data<gb_state>();
176		state->membank( "bank4" )->set_base( addr );
	174	m_bank4->set_base( addr );
177	175	}
178	176
179		static void gb_init(running_machine &machine)
	177
	178	void gb_state::gb_init()
180	179	{
181		gb_state *state = machine.driver_data<gb_state>();
182		address_space &space = machine.device( "maincpu")->memory().space( AS_PROGRAM );
	180	address_space &space = m_maincpu->space( AS_PROGRAM );
183	181
184	182	/* Initialize the memory banks */
185		state->m_MBC1Mode = 0;
186		state->m_MBC3RTCBank = 0;
187		state->m_ROMBank = state->m_ROMBank00 + 1;
188		state->m_RAMBank = 0;
	183	m_MBC1Mode = 0;
	184	m_MBC3RTCBank = 0;
	185	m_ROMBank = m_ROMBank00 + 1;
	186	m_RAMBank = 0;
189	187
190		if (state->m_gb_cart)
	188	if (m_gb_cart)
191	189	{
192		if ( state->m_MBCType != MBC_MEGADUCK )
	190	if ( m_MBCType != MBC_MEGADUCK )
193	191	{
194		gb_rom16_4000( machine, state->m_ROMMap[state->m_ROMBank] );
195		state->membank ("bank2")->set_base (state->m_RAMMap[state->m_RAMBank] ? state->m_RAMMap[state->m_RAMBank] : state->m_gb_dummy_ram_bank);
	192	gb_rom16_4000( m_ROMMap[m_ROMBank] );
	193	m_bank2->set_base( m_RAMMap[m_RAMBank] ? m_RAMMap[m_RAMBank] : m_gb_dummy_ram_bank);
196	194	}
197	195	else
198	196	{
199		state->membank( "bank1" )->set_base( state->m_ROMMap[state->m_ROMBank] );
200		state->membank( "bank10" )->set_base( state->m_ROMMap[0] );
	197	m_bank1->set_base( m_ROMMap[m_ROMBank] );
	198	m_bank10->set_base( m_ROMMap[0] );
201	199	}
202	200	}
203	201
204	202	/* Set handlers based on the Memory Bank Controller in the cart */
205		switch( state->m_MBCType )
	203	switch( m_MBCType )
206	204	{
207	205	case MBC_NONE:
208	206	break;
209	207	case MBC_MMM01:
210		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_0000_w),state) );
211		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_2000_w),state));
212		space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_4000_w),state));
213		space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_6000_w),state));
	208	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_0000_w),this) );
	209	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_2000_w),this));
	210	space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_4000_w),this));
	211	space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_rom_bank_mmm01_6000_w),this));
214	212	break;
215	213	case MBC_MBC1:
216		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),state) );    /* We don't emulate RAM enable yet */
217		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc1),state) );
218		space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc1),state) );
219		space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc1),state) );
	214	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),this) );    /* We don't emulate RAM enable yet */
	215	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc1),this) );
	216	space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc1),this) );
	217	space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc1),this) );
220	218	break;
221	219	case MBC_MBC2:
222		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc2),state) );
	220	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc2),this) );
223	221	break;
224	222	case MBC_MBC3:
225	223	case MBC_HUC1:  /* Possibly wrong */
226	224	case MBC_HUC3:  /* Possibly wrong */
227		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),state) );    /* We don't emulate RAM enable yet */
228		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc3),state) );
229		space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc3),state) );
230		space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc3),state) );
	225	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),this) );    /* We don't emulate RAM enable yet */
	226	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc3),this) );
	227	space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc3),this) );
	228	space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc3),this) );
231	229	break;
232	230	case MBC_MBC5:
233		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),state) );
234		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc5),state) );
235		space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc5),state) );
	231	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),this) );
	232	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc5),this) );
	233	space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc5),this) );
236	234	break;
237	235	case MBC_MBC6:
238		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc6),state) );
239		space.install_write_handler( 0x2000, 0x2fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc6_1),state) );
240		space.install_write_handler( 0x3000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc6_2),state) );
	236	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc6),this) );
	237	space.install_write_handler( 0x2000, 0x2fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc6_1),this) );
	238	space.install_write_handler( 0x3000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc6_2),this) );
241	239	break;
242	240	case MBC_MBC7:
243		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),state) );
244		space.install_write_handler( 0x2000, 0x2fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc7),state) );
245		space.install_write_handler( 0x3000, 0x7fff, write8_delegate(FUNC(gb_state::gb_rom_bank_unknown_mbc7),state) );
	241	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),this) );
	242	space.install_write_handler( 0x2000, 0x2fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc7),this) );
	243	space.install_write_handler( 0x3000, 0x7fff, write8_delegate(FUNC(gb_state::gb_rom_bank_unknown_mbc7),this) );
246	244	break;
247	245	case MBC_TAMA5:
248		space.install_write_handler( 0xA000, 0xBFFF, write8_delegate(FUNC(gb_state::gb_ram_tama5),state) );
	246	space.install_write_handler( 0xA000, 0xBFFF, write8_delegate(FUNC(gb_state::gb_ram_tama5),this) );
249	247	break;
250	248	case MBC_WISDOM:
251		space.install_write_handler( 0x0000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_wisdom),state) );
	249	space.install_write_handler( 0x0000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_wisdom),this) );
252	250	break;
253	251	case MBC_MBC1_KOR:
254		space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),state) ); /* We don't emulate RAM enable yet */
255		space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc1_kor),state) );
256		space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc1_kor),state) );
257		space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc1_kor),state) );
	252	space.install_write_handler( 0x0000, 0x1fff, write8_delegate(FUNC(gb_state::gb_ram_enable),this) ); /* We don't emulate RAM enable yet */
	253	space.install_write_handler( 0x2000, 0x3fff, write8_delegate(FUNC(gb_state::gb_rom_bank_select_mbc1_kor),this) );
	254	space.install_write_handler( 0x4000, 0x5fff, write8_delegate(FUNC(gb_state::gb_ram_bank_select_mbc1_kor),this) );
	255	space.install_write_handler( 0x6000, 0x7fff, write8_delegate(FUNC(gb_state::gb_mem_mode_select_mbc1_kor),this) );
258	256	break;
259	257	case MBC_YONGYONG:
260		space.install_write_handler( 0x2000, 0x2000, write8_delegate(FUNC(gb_state::gb_rom_bank_yongyong_2000),state) );
261		//space.install_write_handler( 0x5000, 0x5003, write8_delegate(FUNC(gb_state::gb_rom_back_yongyong_5000),state) );
	258	space.install_write_handler( 0x2000, 0x2000, write8_delegate(FUNC(gb_state::gb_rom_bank_yongyong_2000),this) );
	259	//space.install_write_handler( 0x5000, 0x5003, write8_delegate(FUNC(gb_state::gb_rom_back_yongyong_5000),this) );
262	260	break;
263	261	case MBC_LASAMA:
264		space.install_write_handler( 0x2080, 0x2080, write8_delegate(FUNC(gb_state::gb_rom_bank_lasama_2080),state) );
265		space.install_write_handler( 0x6000, 0x6000, write8_delegate(FUNC(gb_state::gb_rom_bank_lasama_6000),state) );
	262	space.install_write_handler( 0x2080, 0x2080, write8_delegate(FUNC(gb_state::gb_rom_bank_lasama_2080),this) );
	263	space.install_write_handler( 0x6000, 0x6000, write8_delegate(FUNC(gb_state::gb_rom_bank_lasama_6000),this) );
266	264	break;
267	265	case MBC_ATVRACIN:
268		space.install_write_handler( 0x3F00, 0x3F00, write8_delegate(FUNC(gb_state::gb_rom_bank_atvracin_3f00),state) );
269		space.install_write_handler( 0x3FC0, 0x3FC0, write8_delegate(FUNC(gb_state::gb_rom_bank_atvracin_3fc0),state) );
	266	space.install_write_handler( 0x3F00, 0x3F00, write8_delegate(FUNC(gb_state::gb_rom_bank_atvracin_3f00),this) );
	267	space.install_write_handler( 0x3FC0, 0x3FC0, write8_delegate(FUNC(gb_state::gb_rom_bank_atvracin_3fc0),this) );
270	268	break;
271	269
272	270	case MBC_MEGADUCK:
273		space.install_write_handler( 0x0001, 0x0001, write8_delegate(FUNC(gb_state::megaduck_rom_bank_select_type1),state) );
274		space.install_write_handler( 0xB000, 0xB000, write8_delegate(FUNC(gb_state::megaduck_rom_bank_select_type2),state) );
	271	space.install_write_handler( 0x0001, 0x0001, write8_delegate(FUNC(gb_state::megaduck_rom_bank_select_type1),this) );
	272	space.install_write_handler( 0xB000, 0xB000, write8_delegate(FUNC(gb_state::megaduck_rom_bank_select_type2),this) );
275	273	break;
276	274	}
277	275
278		gb_sound_w(space.machine().device("custom"), space, 0x16, 0x00 );       /* Initialize sound hardware */
	276	gb_sound_w(machine().device("custom"), space, 0x16, 0x00 );       /* Initialize sound hardware */
279	277
280		state->m_divcount = 0;
281		state->m_triggering_irq = 0;
282		state->m_gb_io[0x07] = 0xF8;        /* Upper bits of TIMEFRQ register are set to 1 */
	278	m_divcount = 0;
	279	m_triggering_irq = 0;
	280	m_gb_io[0x07] = 0xF8;        /* Upper bits of TIMEFRQ register are set to 1 */
283	281	}
284	282
	283
285	284	MACHINE_START_MEMBER(gb_state,gb)
286	285	{
287	286	machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(gb_machine_stop),&machine()));
r20640	r20641
306	305
307	306	MACHINE_RESET_MEMBER(gb_state,gb)
308	307	{
309		gb_init(machine());
	308	gb_init();
310	309
311		gb_video_reset( machine(), GB_VIDEO_DMG );
	310	gb_video_reset( GB_VIDEO_DMG );
312	311
313		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] );
	312	gb_rom16_0000( m_ROMMap[m_ROMBank00] );
314	313
315	314	/* Enable BIOS rom */
316		membank("bank5")->set_base(memregion("maincpu")->base() );
	315	m_bank5->set_base(memregion("maincpu")->base() );
317	316
318	317	m_divcount = 0x0004;
319	318	}
r20640	r20641
335	334
336	335	MACHINE_RESET_MEMBER(gb_state,sgb)
337	336	{
338		gb_init(machine());
	337	gb_init();
339	338
340		gb_video_reset( machine(), GB_VIDEO_SGB );
	339	gb_video_reset( GB_VIDEO_SGB );
341	340
342		gb_init_regs(machine());
	341	gb_init_regs();
343	342
344		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
	343	gb_rom16_0000( m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
345	344
346	345	/* Enable BIOS rom */
347		membank("bank5")->set_base(memregion("maincpu")->base() );
	346	m_bank5->set_base(memregion("maincpu")->base() );
348	347
349	348	memset( m_sgb_tile_data, 0, 0x2000 );
350	349
r20640	r20641
369	368
370	369	MACHINE_RESET_MEMBER(gb_state,gbpocket)
371	370	{
372		gb_init(machine());
	371	gb_init();
373	372
374		gb_video_reset( machine(), GB_VIDEO_MGB );
	373	gb_video_reset( GB_VIDEO_MGB );
375	374
376		gb_init_regs(machine());
	375	gb_init_regs();
377	376
378	377	/* Initialize the Sound registers */
379	378	gb_sound_w(machine().device("custom"), generic_space(), 0x16,0x80);
r20640	r20641
381	380	gb_sound_w(machine().device("custom"), generic_space(), 0x14,0x77);
382	381
383	382	/* Enable BIOS rom if we have one */
384		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
	383	gb_rom16_0000( m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
385	384
386	385	m_divcount = 0xABC8;
387	386	}
r20640	r20641
390	389	{
391	390	int ii;
392	391
393		gb_init(machine());
	392	gb_init();
394	393
395		gb_video_reset( machine(), GB_VIDEO_CGB );
	394	gb_video_reset( GB_VIDEO_CGB );
396	395
397		gb_init_regs(machine());
	396	gb_init_regs();
398	397
399		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
	398	gb_rom16_0000( m_ROMMap[m_ROMBank00] ? m_ROMMap[m_ROMBank00] : m_gb_dummy_rom_bank );
400	399
401	400	/* Enable BIOS rom */
402		membank("bank5")->set_base(machine().root_device().memregion("maincpu")->base() );
403		membank("bank6")->set_base(memregion("maincpu")->base() + 0x100 );
	401	m_bank5->set_base(memregion("maincpu")->base() );
	402	m_bank6->set_base(memregion("maincpu")->base() + 0x100 );
404	403
405	404	/* Allocate memory for internal ram */
406	405	for( ii = 0; ii < 8; ii++ )
r20640	r20641
424	423	image->battery_save(state->m_gb_cart_ram, state->m_RAMBanks * 0x2000);
425	424	}
426	425
427		static void gb_set_mbc1_banks( running_machine &machine )
	426	void gb_state::gb_set_mbc1_banks()
428	427	{
429		gb_state *state = machine.driver_data<gb_state>();
430		gb_rom16_4000( machine, state->m_ROMMap[ state->m_ROMBank ] );
431		state->membank( "bank2" )->set_base( state->m_RAMMap[ state->m_MBC1Mode ? ( state->m_ROMBank >> 5 ) : 0 ] );
	428	gb_rom16_4000( m_ROMMap[ m_ROMBank ] );
	429	m_bank2->set_base( m_RAMMap[ m_MBC1Mode ? ( m_ROMBank >> 5 ) : 0 ] );
432	430	}
433	431
434	432	WRITE8_MEMBER(gb_state::gb_rom_bank_select_mbc1)
r20640	r20641
440	438
441	439	m_ROMBank = ( m_ROMBank & 0x01E0 ) | data;
442	440	/* Switch banks */
443		gb_set_mbc1_banks(machine());
	441	gb_set_mbc1_banks();
444	442	}
445	443
446	444	WRITE8_MEMBER(gb_state::gb_rom_bank_select_mbc2)
r20640	r20641
454	452	if( offset & 0x0100 )
455	453	m_ROMBank = ( m_ROMBank & 0x100 ) | data;
456	454	/* Switch banks */
457		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	455	gb_rom16_4000( m_ROMMap[m_ROMBank] );
458	456	}
459	457
460	458	WRITE8_MEMBER(gb_state::gb_rom_bank_select_mbc3)
r20640	r20641
467	465
468	466	m_ROMBank = ( m_ROMBank & 0x0100 ) | data;
469	467	/* Switch banks */
470		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	468	gb_rom16_4000( m_ROMMap[m_ROMBank] );
471	469	}
472	470
473	471	WRITE8_MEMBER(gb_state::gb_rom_bank_select_mbc5)
r20640	r20641
486	484	m_ROMBank = (m_ROMBank & 0x100 ) | data;
487	485	}
488	486	/* Switch banks */
489		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	487	gb_rom16_4000( m_ROMMap[m_ROMBank] );
490	488	}
491	489
492	490	WRITE8_MEMBER(gb_state::gb_ram_bank_select_mbc6)
r20640	r20641
501	499	{
502	500	if ( data == 0x00 )
503	501	{
504		gb_rom8_4000( machine(), m_ROMMap[m_ROMBank>>1] + ( ( m_ROMBank & 0x01 ) ? 0x2000 : 0x0000 ) );
	502	gb_rom8_4000( m_ROMMap[m_ROMBank>>1] + ( ( m_ROMBank & 0x01 ) ? 0x2000 : 0x0000 ) );
505	503	}
506	504	}
507	505	else
r20640	r20641
517	515	{
518	516	if ( data == 0x00 )
519	517	{
520		gb_rom8_6000( machine(), m_ROMMap[m_ROMBank00>>1] + ( ( m_ROMBank00 & 0x01 ) ? 0x2000 : 0x0000 ) );
	518	gb_rom8_6000( m_ROMMap[m_ROMBank00>>1] + ( ( m_ROMBank00 & 0x01 ) ? 0x2000 : 0x0000 ) );
521	519	}
522	520	}
523	521	else
r20640	r20641
533	531	if ( offset & 0x0100 )
534	532	{
535	533	m_ROMBank = data;
536		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	534	gb_rom16_4000( m_ROMMap[m_ROMBank] );
537	535	}
538	536	}
539	537
r20640	r20641
560	558	logerror( "0x%04X: wisdom tree mapper write to address 0x%04X\n", space.device() .safe_pc( ), offset );
561	559	/* The address determines the bank to select */
562	560	m_ROMBank = ( offset << 1 ) & 0x1FF;
563		membank( "bank5" )->set_base( m_ROMMap[ m_ROMBank ] );
564		membank( "bank10" )->set_base( m_ROMMap[ m_ROMBank ] + 0x0100 );
565		membank( "bank6" )->set_base( m_ROMMap[ m_ROMBank ] + 0x0200 );
566		membank( "bank11" )->set_base( m_ROMMap[ m_ROMBank ] + 0x0900 );
567		membank( "bank1" )->set_base( m_ROMMap[ m_ROMBank + 1 ] );
568		membank( "bank4" )->set_base( m_ROMMap[ m_ROMBank + 1 ] + 0x2000 );
	561	m_bank5->set_base( m_ROMMap[ m_ROMBank ] );
	562	m_bank10->set_base( m_ROMMap[ m_ROMBank ] + 0x0100 );
	563	m_bank6->set_base( m_ROMMap[ m_ROMBank ] + 0x0200 );
	564	m_bank11->set_base( m_ROMMap[ m_ROMBank ] + 0x0900 );
	565	m_bank1->set_base( m_ROMMap[ m_ROMBank + 1 ] );
	566	m_bank4->set_base( m_ROMMap[ m_ROMBank + 1 ] + 0x2000 );
569	567	}
570	568
571	569	WRITE8_MEMBER(gb_state::gb_ram_bank_select_mbc1)
r20640	r20641
576	574	m_ROMBank = ( m_ROMBank & 0x1F ) | ( data << 5 );
577	575
578	576	/* Switch banks */
579		gb_set_mbc1_banks(machine());
	577	gb_set_mbc1_banks();
580	578	}
581	579
582	580	WRITE8_MEMBER(gb_state::gb_ram_bank_select_mbc3)
r20640	r20641
590	588	if ( data < 5 )
591	589	{
592	590	memset( m_MBC3RTCData, m_MBC3RTCMap[m_MBC3RTCBank], 0x2000 );
593		membank( "bank2" )->set_base( m_MBC3RTCData );
	591	m_bank2->set_base( m_MBC3RTCData );
594	592	}
595	593	}
596	594	}
r20640	r20641
599	597	m_RAMBank = data & 0x3;
600	598	m_MBC3RTCBank = 0xFF;
601	599	/* Switch banks */
602		membank( "bank2" )->set_base( m_RAMMap[m_RAMBank] );
	600	m_bank2->set_base( m_RAMMap[m_RAMBank] );
603	601	}
604	602	}
605	603
r20640	r20641
613	611	}
614	612	m_RAMBank = data;
615	613	/* Switch banks */
616		membank ("bank2")->set_base (m_RAMMap[m_RAMBank] );
	614	m_bank2->set_base( m_RAMMap[m_RAMBank] );
617	615	}
618	616
619	617	WRITE8_MEMBER(gb_state::gb_ram_enable)
r20640	r20641
626	624	WRITE8_MEMBER(gb_state::gb_mem_mode_select_mbc1)
627	625	{
628	626	m_MBC1Mode = data & 0x1;
629		gb_set_mbc1_banks(machine());
	627	gb_set_mbc1_banks();
630	628	}
631	629
632	630	WRITE8_MEMBER(gb_state::gb_mem_mode_select_mbc3)
r20640	r20641
653	651	{
654	652	case 0x00:      /* Bits 0-3 for rom bank selection */
655	653	m_ROMBank = ( m_ROMBank & 0xF0 ) | ( data & 0x0F );
656		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	654	gb_rom16_4000( m_ROMMap[m_ROMBank] );
657	655	break;
658	656	case 0x01:      /* Bit 4(-7?) for rom bank selection */
659	657	m_ROMBank = ( m_ROMBank & 0x0F ) | ( ( data & 0x0F ) << 4 );
660		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	658	gb_rom16_4000( m_ROMMap[m_ROMBank] );
661	659	break;
662	660	case 0x04:      /* Data to write lo */
663	661	m_gbTama5Byte = ( m_gbTama5Byte & 0xF0 ) | ( data & 0x0F );
r20640	r20641
707	705	break;
708	706	case 0x0A:      /* Are we ready for the next command? */
709	707	m_MBC3RTCData[0] = 0x01;
710		membank( "bank2" )->set_base( m_MBC3RTCData );
	708	m_bank2->set_base( m_MBC3RTCData );
711	709	break;
712	710	case 0x0C:      /* Data read register lo */
713	711	m_MBC3RTCData[0] = m_gbTama5Byte & 0x0F;
r20640	r20641
733	731	if ( data & 0x40 )
734	732	{
735	733	m_mmm01_bank_offset = m_mmm01_reg1;
736		membank( "bank5" )->set_base( m_ROMMap[ m_mmm01_bank_offset ] );
737		membank( "bank10" )->set_base( m_ROMMap[ m_mmm01_bank_offset ] + 0x0100 );
738		gb_rom16_4000( machine(), m_ROMMap[ m_mmm01_bank_offset + m_mmm01_bank ] );
	734	m_bank5->set_base( m_ROMMap[ m_mmm01_bank_offset ] );
	735	m_bank10->set_base( m_ROMMap[ m_mmm01_bank_offset ] + 0x0100 );
	736	gb_rom16_4000( m_ROMMap[ m_mmm01_bank_offset + m_mmm01_bank ] );
739	737	}
740	738	}
741	739
r20640	r20641
749	747	{
750	748	m_mmm01_bank = 1;
751	749	}
752		gb_rom16_4000( machine(), m_ROMMap[ m_mmm01_bank_offset + m_mmm01_bank ] );
	750	gb_rom16_4000( m_ROMMap[ m_mmm01_bank_offset + m_mmm01_bank ] );
753	751	}
754	752
755	753	WRITE8_MEMBER(gb_state::gb_rom_bank_mmm01_4000_w)
r20640	r20641
772	770
773	771	/* Korean MBC1 variant mapping */
774	772
775		static void gb_set_mbc1_kor_banks( running_machine &machine )
	773	void gb_state::gb_set_mbc1_kor_banks()
776	774	{
777		gb_state *state = machine.driver_data<gb_state>();
778		if ( state->m_ROMBank & 0x30 )
	775	if ( m_ROMBank & 0x30 )
779	776	{
780		gb_rom16_0000( machine, state->m_ROMMap[ state->m_ROMBank & 0x30 ] );
	777	gb_rom16_0000( m_ROMMap[ m_ROMBank & 0x30 ] );
781	778	}
782		gb_rom16_4000( machine, state->m_ROMMap[ state->m_ROMBank ] );
783		state->membank( "bank2" )->set_base( state->m_RAMMap[ state->m_MBC1Mode ? ( state->m_ROMBank >> 5 ) : 0 ] );
	779	gb_rom16_4000( m_ROMMap[ m_ROMBank ] );
	780	m_bank2->set_base( m_RAMMap[ m_MBC1Mode ? ( m_ROMBank >> 5 ) : 0 ] );
784	781	}
785	782
786	783	WRITE8_MEMBER(gb_state::gb_rom_bank_select_mbc1_kor)
r20640	r20641
792	789
793	790	m_ROMBank = ( m_ROMBank & 0x01F0 ) | data;
794	791	/* Switch banks */
795		gb_set_mbc1_kor_banks(machine());
	792	gb_set_mbc1_kor_banks();
796	793	}
797	794
798	795	WRITE8_MEMBER(gb_state::gb_ram_bank_select_mbc1_kor)
r20640	r20641
803	800	m_ROMBank = ( m_ROMBank & 0x0F ) | ( data << 4 );
804	801
805	802	/* Switch banks */
806		gb_set_mbc1_kor_banks(machine());
	803	gb_set_mbc1_kor_banks();
807	804	}
808	805
809	806	WRITE8_MEMBER(gb_state::gb_mem_mode_select_mbc1_kor)
810	807	{
811	808	m_MBC1Mode = data & 0x1;
812		gb_set_mbc1_kor_banks(machine());
	809	gb_set_mbc1_kor_banks();
813	810	}
814	811
815	812	WRITE8_MEMBER(gb_state::gb_rom_bank_yongyong_2000)
816	813	{
817	814	m_ROMBank = data;
818		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	815	gb_rom16_4000( m_ROMMap[m_ROMBank] );
819	816	}
820	817
821	818	WRITE8_MEMBER(gb_state::gb_rom_bank_lasama_2080)
822	819	{
823	820	// Actual banking?
824	821	m_ROMBank = m_ROMBank00 | ( data & 0x03 );
825		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	822	gb_rom16_4000( m_ROMMap[m_ROMBank] );
826	823	}
827	824
828	825	WRITE8_MEMBER(gb_state::gb_rom_bank_lasama_6000)
r20640	r20641
834	831	if ( ! ( data & 0x80 ) )
835	832	{
836	833	m_ROMBank00 = ( data & 0x02 ) << 1;
837		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] );
	834	gb_rom16_0000( m_ROMMap[m_ROMBank00] );
838	835	}
839	836	}
840	837
r20640	r20641
845	842	data = 1;
846	843	}
847	844	m_ROMBank = m_ROMBank00 | data;
848		gb_rom16_4000( machine(), m_ROMMap[m_ROMBank] );
	845	gb_rom16_4000( m_ROMMap[m_ROMBank] );
849	846	}
850	847
851	848	WRITE8_MEMBER(gb_state::gb_rom_bank_atvracin_3fc0)
852	849	{
853	850	m_ROMBank00 = data * 16;
854		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] );
	851	gb_rom16_0000( m_ROMMap[m_ROMBank00] );
855	852	}
856	853
857	854	WRITE8_MEMBER(gb_state::gb_io_w)
r20640	r20641
863	860	case 0x00:                      /* JOYP - Joypad */
864	861	JOYPAD = 0xCF | data;
865	862	if (!(data & 0x20))
866		JOYPAD &= (ioport("INPUTS")->read() >> 4) | 0xF0;
	863	JOYPAD &= (m_inputs->read() >> 4) | 0xF0;
867	864	if (!(data & 0x10))
868		JOYPAD &= ioport("INPUTS")->read() | 0xF0;
	865	JOYPAD &= m_inputs->read() | 0xF0;
869	866	return;
870	867	case 0x01:                      /* SB - Serial transfer data */
871	868	break;
r20640	r20641
880	877	case 0x81:              /* enabled & internal clock */
881	878	SIODATA = 0xFF;
882	879	m_SIOCount = 8;
883		m_gb_serial_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(512), 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(512));
	880	m_gb_serial_timer->adjust(m_maincpu->cycles_to_attotime(512), 0, m_maincpu->cycles_to_attotime(512));
884	881	m_gb_serial_timer->enable( 1 );
885	882	break;
886	883	}
r20640	r20641
888	885	case 0x04:                      /* DIV - Divider register */
889	886	/* Force increment of TIMECNT register */
890	887	if ( m_divcount >= 16 )
891		gb_timer_increment(machine());
	888	gb_timer_increment();
892	889	m_divcount = 0;
893	890	return;
894	891	case 0x05:                      /* TIMA - Timer counter */
r20640	r20641
913	910	/* Check if TIMECNT should be incremented */
914	911	if ( ( m_divcount & ( m_shift_cycles - 1 ) ) >= ( m_shift_cycles >> 1 ) )
915	912	{
916		gb_timer_increment(machine());
	913	gb_timer_increment();
917	914	}
918	915	}
919	916	m_shift = timer_shifts[data & 0x03];
r20640	r20641
933	930	if ( offset == 0x10 )
934	931	{
935	932	/* disable BIOS ROM */
936		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] );
	933	gb_rom16_0000( m_ROMMap[m_ROMBank00] );
937	934	}
938	935	else
939	936	{
r20640	r20641
988	985	m_sgb_bitcount = 0;
989	986	m_sgb_start = 1;
990	987	m_sgb_rest = 0;
991		JOYPAD = 0x0F & ((ioport("INPUTS")->read() >> 4) | ioport("INPUTS")->read() | 0xF0);
	988	JOYPAD = 0x0F & ((m_inputs->read() >> 4) | m_inputs->read() | 0xF0);
992	989	break;
993	990	case 0x10:                 /* data true */
994	991	if (m_sgb_rest)
r20640	r20641
1012	1009	}
1013	1010	m_sgb_rest = 0;
1014	1011	}
1015		JOYPAD = 0x1F & ((ioport("INPUTS")->read() >> 4) | 0xF0);
	1012	JOYPAD = 0x1F & ((m_inputs->read() >> 4) | 0xF0);
1016	1013	break;
1017	1014	case 0x20:              /* data false */
1018	1015	if (m_sgb_rest)
r20640	r20641
1316	1313	break;
1317	1314	case 0x0B:  /* PAL_TRN */
1318	1315	{
1319		UINT8 *gb_vram = gb_get_vram_ptr(machine());
1320	1316	UINT16 I, col;
1321	1317
1322	1318	for( I = 0; I < 2048; I++ )
1323	1319	{
1324		col = ( gb_vram[ 0x0800 + (I*2) + 1 ] << 8 ) | gb_vram[ 0x0800 + (I*2) ];
	1320	col = ( m_lcd.gb_vram_ptr[ 0x0800 + (I*2) + 1 ] << 8 ) | m_lcd.gb_vram_ptr[ 0x0800 + (I*2) ];
1325	1321	m_sgb_pal_data[I] = col;
1326	1322	}
1327	1323	}
r20640	r20641
1352	1348	break;
1353	1349	case 0x13:  /* CHR_TRN */
1354	1350	if( sgb_data[1] & 0x1 )
1355		memcpy( m_sgb_tile_data + 4096, gb_get_vram_ptr(machine()) + 0x0800, 4096 );
	1351	memcpy( m_sgb_tile_data + 4096, m_lcd.gb_vram_ptr + 0x0800, 4096 );
1356	1352	else
1357		memcpy( m_sgb_tile_data, gb_get_vram_ptr(machine()) + 0x0800, 4096 );
	1353	memcpy( m_sgb_tile_data, m_lcd.gb_vram_ptr + 0x0800, 4096 );
1358	1354	break;
1359	1355	case 0x14:  /* PCT_TRN */
1360	1356	{
1361	1357	int I;
1362	1358	UINT16 col;
1363		UINT8 *gb_vram = gb_get_vram_ptr(machine());
1364	1359	if( m_sgb_hack )
1365	1360	{
1366		memcpy( m_sgb_tile_map, gb_vram + 0x1000, 2048 );
	1361	memcpy( m_sgb_tile_map, m_lcd.gb_vram_ptr + 0x1000, 2048 );
1367	1362	for( I = 0; I < 64; I++ )
1368	1363	{
1369		col = ( gb_vram[ 0x0800 + (I*2) + 1 ] << 8 ) | gb_vram[ 0x0800 + (I*2) ];
	1364	col = ( m_lcd.gb_vram_ptr[ 0x0800 + (I*2) + 1 ] << 8 ) | m_lcd.gb_vram_ptr[ 0x0800 + (I*2) ];
1370	1365	m_sgb_pal[SGB_BORDER_PAL_OFFSET + I] = col;
1371	1366	}
1372	1367	}
1373	1368	else /* Do things normally */
1374	1369	{
1375		memcpy( m_sgb_tile_map, gb_vram + 0x0800, 2048 );
	1370	memcpy( m_sgb_tile_map, m_lcd.gb_vram_ptr + 0x0800, 2048 );
1376	1371	for( I = 0; I < 64; I++ )
1377	1372	{
1378		col = ( gb_vram[ 0x1000 + (I*2) + 1 ] << 8 ) | gb_vram[ 0x1000 + (I*2) ];
	1373	col = ( m_lcd.gb_vram_ptr[ 0x1000 + (I*2) + 1 ] << 8 ) | m_lcd.gb_vram_ptr[ 0x1000 + (I*2) ];
1379	1374	m_sgb_pal[SGB_BORDER_PAL_OFFSET + I] = col;
1380	1375	}
1381	1376	}
1382	1377	}
1383	1378	break;
1384	1379	case 0x15:  /* ATTR_TRN */
1385		memcpy( m_sgb_atf_data, gb_get_vram_ptr(machine()) + 0x0800, 4050 );
	1380	memcpy( m_sgb_atf_data, m_lcd.gb_vram_ptr + 0x0800, 4050 );
1386	1381	break;
1387	1382	case 0x16:  /* ATTR_SET */
1388	1383	{
r20640	r20641
1439	1434	}
1440	1435	m_sgb_rest = 0;
1441	1436	}
1442		JOYPAD = 0x2F & (ioport("INPUTS")->read() | 0xF0);
	1437	JOYPAD = 0x2F & (m_inputs->read() | 0xF0);
1443	1438	break;
1444	1439	case 0x30:                 /* rest condition */
1445	1440	if (m_sgb_start)
r20640	r20641
2044	2039	{
2045	2040	SIOCONT &= 0x7F;
2046	2041	m_gb_serial_timer->enable( 0 );
2047		machine().device("maincpu")->execute().set_input_line(SIO_INT, ASSERT_LINE);
	2042	m_maincpu->set_input_line(SIO_INT, ASSERT_LINE);
2048	2043	}
2049	2044	}
2050	2045
2051		INLINE void gb_timer_check_irq( running_machine &machine )
	2046	void gb_state::gb_timer_check_irq()
2052	2047	{
2053		gb_state *state = machine.driver_data<gb_state>();
2054		state->m_reloading = 0;
2055		if ( state->m_triggering_irq )
	2048	m_reloading = 0;
	2049	if ( m_triggering_irq )
2056	2050	{
2057		state->m_triggering_irq = 0;
2058		if ( state->TIMECNT == 0 )
	2051	m_triggering_irq = 0;
	2052	if ( TIMECNT == 0 )
2059	2053	{
2060		state->TIMECNT = state->TIMEMOD;
2061		machine.device("maincpu")->execute().set_input_line(TIM_INT, ASSERT_LINE );
2062		state->m_reloading = 1;
	2054	TIMECNT = TIMEMOD;
	2055	m_maincpu->set_input_line(TIM_INT, ASSERT_LINE );
	2056	m_reloading = 1;
2063	2057	}
2064	2058	}
2065	2059	}
2066	2060
2067		static void gb_timer_increment( running_machine &machine )
	2061	void gb_state::gb_timer_increment()
2068	2062	{
2069		gb_state *state = machine.driver_data<gb_state>();
2070		gb_timer_check_irq(machine);
	2063	gb_timer_check_irq();
2071	2064
2072		state->TIMECNT += 1;
2073		if ( state->TIMECNT == 0 )
	2065	TIMECNT += 1;
	2066	if ( TIMECNT == 0 )
2074	2067	{
2075		state->m_triggering_irq = 1;
	2068	m_triggering_irq = 1;
2076	2069	}
2077	2070	}
2078	2071
2079		void gb_timer_callback(lr35902_cpu_device *device, int cycles)
	2072	WRITE8_MEMBER( gb_state::gb_timer_callback )
2080	2073	{
2081		gb_state *state = device->machine().driver_data<gb_state>();
2082		UINT16 old_gb_divcount = state->m_divcount;
2083		state->m_divcount += cycles;
	2074	UINT16 old_gb_divcount = m_divcount;
	2075	m_divcount += data;
2084	2076
2085		gb_timer_check_irq(device->machine());
	2077	gb_timer_check_irq();
2086	2078
2087		if ( state->TIMEFRQ & 0x04 )
	2079	if ( TIMEFRQ & 0x04 )
2088	2080	{
2089		UINT16 old_count = old_gb_divcount >> state->m_shift;
2090		UINT16 new_count = state->m_divcount >> state->m_shift;
2091		if ( cycles > state->m_shift_cycles )
	2081	UINT16 old_count = old_gb_divcount >> m_shift;
	2082	UINT16 new_count = m_divcount >> m_shift;
	2083	if ( data > m_shift_cycles )
2092	2084	{
2093		gb_timer_increment(device->machine());
	2085	gb_timer_increment();
2094	2086	old_count++;
2095	2087	}
2096	2088	if ( new_count != old_count )
2097	2089	{
2098		gb_timer_increment(device->machine());
	2090	gb_timer_increment();
2099	2091	}
2100		if ( new_count << state->m_shift < state->m_divcount )
	2092	if ( new_count << m_shift < m_divcount )
2101	2093	{
2102		gb_timer_check_irq(device->machine());
	2094	gb_timer_check_irq();
2103	2095	}
2104	2096	}
2105	2097	}
r20640	r20641
2112	2104	machine().device<lr35902_cpu_device>(":maincpu")->set_speed( data );
2113	2105	return;
2114	2106	case 0x10:  /* BFF - Bios disable */
2115		gb_rom16_0000( machine(), m_ROMMap[m_ROMBank00] );
	2107	gb_rom16_0000( m_ROMMap[m_ROMBank00] );
2116	2108	return;
2117	2109	case 0x16:  /* RP - Infrared port */
2118	2110	break;
r20640	r20641
2120	2112	m_GBC_RAMBank = data & 0x7;
2121	2113	if ( ! m_GBC_RAMBank )
2122	2114	m_GBC_RAMBank = 1;
2123		membank ("bank3")->set_base (m_GBC_RAMMap[m_GBC_RAMBank]);
	2115	m_bank3->set_base(m_GBC_RAMMap[m_GBC_RAMBank]);
2124	2116	break;
2125	2117	default:
2126	2118	break;
r20640	r20641
2162	2154	MACHINE_RESET_MEMBER(gb_state,megaduck)
2163	2155	{
2164	2156	/* We may have to add some more stuff here, if not then it can be merged back into gb */
2165		gb_init(machine());
	2157	gb_init();
2166	2158
2167		gb_video_reset( machine(), GB_VIDEO_DMG );
	2159	gb_video_reset( GB_VIDEO_DMG );
2168	2160	}
2169	2161
2170	2162	/*
r20640	r20641
2280	2272	m_ROMBank = data & m_ROMMask;
2281	2273
2282	2274	/* Switch banks */
2283		membank ("bank1")->set_base (m_ROMMap[m_ROMBank]);
	2275	m_bank1->set_base(m_ROMMap[m_ROMBank]);
2284	2276	}
2285	2277	}
2286	2278
r20640	r20641
2291	2283	m_ROMBank = (data << 1) & m_ROMMask;
2292	2284
2293	2285	/* Switch banks */
2294		membank( "bank10" )->set_base( m_ROMMap[m_ROMBank]);
2295		membank( "bank1" )->set_base( m_ROMMap[m_ROMBank + 1]);
	2286	m_bank10->set_base( m_ROMMap[m_ROMBank]);
	2287	m_bank1->set_base( m_ROMMap[m_ROMBank + 1]);
2296	2288	}
2297	2289	}
2298	2290

trunk/src/mess/includes/gb.h

r20640	r20641
109	109	{
110	110	public:
111	111	gb_state(const machine_config &mconfig, device_type type, const char *tag)
112		: driver_device(mconfig, type, tag) { }
	112	: driver_device(mconfig, type, tag)
	113	, m_maincpu(*this, "maincpu")
	114	, m_bank1(*this, "bank1")
	115	, m_bank2(*this, "bank2")
	116	, m_bank3(*this, "bank3")
	117	, m_bank4(*this, "bank4")
	118	, m_bank5(*this, "bank5")
	119	, m_bank6(*this, "bank6")
	120	, m_bank10(*this, "bank10")
	121	, m_bank11(*this, "bank11")
	122	, m_inputs(*this, "INPUTS")
	123	{ }
113	124
114	125	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
115	126
r20640	r20641
178	189	UINT8 m_mmm01_bank;
179	190	UINT8 m_mmm01_bank_mask;
180	191	gb_lcd_t m_lcd;
181		void (*update_scanline)( running_machine &machine );
	192	void (gb_state::*update_scanline) ();
182	193
183	194	bitmap_ind16 m_bitmap;
184	195	DECLARE_WRITE8_MEMBER(gb_rom_bank_select_mbc1);
r20640	r20641
255	266	TIMER_CALLBACK_MEMBER(gb_video_init_vbl);
256	267	TIMER_CALLBACK_MEMBER(gb_lcd_timer_proc);
257	268	TIMER_CALLBACK_MEMBER(gbc_lcd_timer_proc);
	269	DECLARE_WRITE8_MEMBER(gb_timer_callback);
	270
	271	protected:
	272	required_device<lr35902_cpu_device> m_maincpu;
	273	required_memory_bank m_bank1;   // all
	274	optional_memory_bank m_bank2;   // dmg, sgb, cgb
	275	optional_memory_bank m_bank3;   // cgb
	276	optional_memory_bank m_bank4;   // dmg, sgb, cgb
	277	optional_memory_bank m_bank5;   // dmg, sgb, cgb
	278	optional_memory_bank m_bank6;   // dmg, sgb, cgb
	279	required_memory_bank m_bank10;  // all
	280	optional_memory_bank m_bank11;  // dmg, sgb, cgb
	281	required_ioport m_inputs;
	282
	283	void gb_timer_increment();
	284	void gb_timer_check_irq();
	285	void gb_init_regs();
	286	void gb_rom16_0000( UINT8 *addr );
	287	void gb_rom16_4000( UINT8 *addr );
	288	void gb_rom8_4000( UINT8 *addr );
	289	void gb_rom8_6000( UINT8 *addr );
	290	void gb_init();
	291	void gb_set_mbc1_banks();
	292	void gb_set_mbc1_kor_banks();
	293	void gb_select_sprites();
	294	void gb_update_sprites();
	295	void gb_update_scanline();
	296	void sgb_update_sprites();
	297	void sgb_refresh_border();
	298	void sgb_update_scanline();
	299	void cgb_update_sprites();
	300	void cgb_update_scanline();
	301	void gb_video_reset( int mode );
	302	void gbc_hdma(UINT16 length);
	303	void gb_increment_scanline();
	304	void gb_lcd_switch_on();
258	305	};
259	306
260	307
r20640	r20641
262	309
263	310	DEVICE_START(gb_cart);
264	311	DEVICE_IMAGE_LOAD(gb_cart);
265		void gb_timer_callback(lr35902_cpu_device *device, int cycles);
266	312
267	313
268
269
270	314	/* -- Super Game Boy specific -- */
271	315	#define SGB_BORDER_PAL_OFFSET   64  /* Border colours stored from pal 4-7   */
272	316	#define SGB_XOFFSET             48  /* GB screen starts at column 48        */
r20640	r20641
288	332	GB_VIDEO_CGB
289	333	};
290	334
291		void gb_video_reset( running_machine &machine, int mode );
292		UINT8 *gb_get_vram_ptr(running_machine &machine);
293	335
294
295	336	#endif /* GB_H_ */

trunk/src/mess/video/gb.c

r20640	r20641
18	18	#include "cpu/lr35902/lr35902.h"
19	19	#include "includes/gb.h"
20	20
21		#define LCDCONT     state->m_lcd.gb_vid_regs[0x00]  /* LCD control register                       */
22		#define LCDSTAT     state->m_lcd.gb_vid_regs[0x01]  /* LCD status register                        */
23		#define SCROLLY     state->m_lcd.gb_vid_regs[0x02]  /* Starting Y position of the background      */
24		#define SCROLLX     state->m_lcd.gb_vid_regs[0x03]  /* Starting X position of the background      */
25		#define CURLINE     state->m_lcd.gb_vid_regs[0x04]  /* Current screen line being scanned          */
26		#define CMPLINE     state->m_lcd.gb_vid_regs[0x05]  /* Gen. int. when scan reaches this line      */
27		#define BGRDPAL     state->m_lcd.gb_vid_regs[0x07]  /* Background palette                         */
28		#define SPR0PAL     state->m_lcd.gb_vid_regs[0x08]  /* Sprite palette #0                          */
29		#define SPR1PAL     state->m_lcd.gb_vid_regs[0x09]  /* Sprite palette #1                          */
30		#define WNDPOSY     state->m_lcd.gb_vid_regs[0x0A]  /* Window Y position                          */
31		#define WNDPOSX     state->m_lcd.gb_vid_regs[0x0B]  /* Window X position                          */
32		#define KEY1        state->m_lcd.gb_vid_regs[0x0D]  /* Prepare speed switch                       */
33		#define HDMA1       state->m_lcd.gb_vid_regs[0x11]  /* HDMA source high byte                      */
34		#define HDMA2       state->m_lcd.gb_vid_regs[0x12]  /* HDMA source low byte                       */
35		#define HDMA3       state->m_lcd.gb_vid_regs[0x13]  /* HDMA destination high byte                 */
36		#define HDMA4       state->m_lcd.gb_vid_regs[0x14]  /* HDMA destination low byte                  */
37		#define HDMA5       state->m_lcd.gb_vid_regs[0x15]  /* HDMA length/mode/start                     */
38		#define GBCBCPS     state->m_lcd.gb_vid_regs[0x28]  /* Backgound palette spec                     */
39		#define GBCBCPD     state->m_lcd.gb_vid_regs[0x29]  /* Backgound palette data                     */
40		#define GBCOCPS     state->m_lcd.gb_vid_regs[0x2A]  /* Object palette spec                        */
41		#define GBCOCPD     state->m_lcd.gb_vid_regs[0x2B]  /* Object palette data                        */
	21	#define LCDCONT     m_lcd.gb_vid_regs[0x00]  /* LCD control register                       */
	22	#define LCDSTAT     m_lcd.gb_vid_regs[0x01]  /* LCD status register                        */
	23	#define SCROLLY     m_lcd.gb_vid_regs[0x02]  /* Starting Y position of the background      */
	24	#define SCROLLX     m_lcd.gb_vid_regs[0x03]  /* Starting X position of the background      */
	25	#define CURLINE     m_lcd.gb_vid_regs[0x04]  /* Current screen line being scanned          */
	26	#define CMPLINE     m_lcd.gb_vid_regs[0x05]  /* Gen. int. when scan reaches this line      */
	27	#define BGRDPAL     m_lcd.gb_vid_regs[0x07]  /* Background palette                         */
	28	#define SPR0PAL     m_lcd.gb_vid_regs[0x08]  /* Sprite palette #0                          */
	29	#define SPR1PAL     m_lcd.gb_vid_regs[0x09]  /* Sprite palette #1                          */
	30	#define WNDPOSY     m_lcd.gb_vid_regs[0x0A]  /* Window Y position                          */
	31	#define WNDPOSX     m_lcd.gb_vid_regs[0x0B]  /* Window X position                          */
	32	#define KEY1        m_lcd.gb_vid_regs[0x0D]  /* Prepare speed switch                       */
	33	#define HDMA1       m_lcd.gb_vid_regs[0x11]  /* HDMA source high byte                      */
	34	#define HDMA2       m_lcd.gb_vid_regs[0x12]  /* HDMA source low byte                       */
	35	#define HDMA3       m_lcd.gb_vid_regs[0x13]  /* HDMA destination high byte                 */
	36	#define HDMA4       m_lcd.gb_vid_regs[0x14]  /* HDMA destination low byte                  */
	37	#define HDMA5       m_lcd.gb_vid_regs[0x15]  /* HDMA length/mode/start                     */
	38	#define GBCBCPS     m_lcd.gb_vid_regs[0x28]  /* Backgound palette spec                     */
	39	#define GBCBCPD     m_lcd.gb_vid_regs[0x29]  /* Backgound palette data                     */
	40	#define GBCOCPS     m_lcd.gb_vid_regs[0x2A]  /* Object palette spec                        */
	41	#define GBCOCPD     m_lcd.gb_vid_regs[0x2B]  /* Object palette data                        */
42	42
43	43	enum {
44	44	UNLOCKED=0,
r20640	r20641
46	46	};
47	47
48	48
49		/* Prototypes */
50
51
52		static void gb_lcd_switch_on( running_machine &machine );
53
54	49	static const unsigned char palette[] =
55	50	{
56	51	/* Simple black and white palette */
r20640	r20641
156	151	Select which sprites should be drawn for the current scanline and return the
157	152	number of sprites selected.
158	153	*/
159		static void gb_select_sprites( gb_state *state )
	154	void gb_state::gb_select_sprites()
160	155	{
161	156	int i, /*yindex,*/ line, height;
162		UINT8   *oam = state->m_lcd.gb_oam->base() + 39 * 4;
	157	UINT8   *oam = m_lcd.gb_oam->base() + 39 * 4;
163	158
164		state->m_lcd.sprCount = 0;
	159	m_lcd.sprCount = 0;
165	160
166	161	/* If video hardware is enabled and sprites are enabled */
167	162	if ( ( LCDCONT & 0x80 ) && ( LCDCONT & 0x02 ) )
r20640	r20641
176	171	height = 8;
177	172	}
178	173
179		//yindex = state->m_lcd.current_line;
180		line = state->m_lcd.current_line + 16;
	174	//yindex = m_lcd.current_line;
	175	line = m_lcd.current_line + 16;
181	176
182	177	for( i = 39; i >= 0; i-- )
183	178	{
r20640	r20641
185	180	{
186	181	/* We limit the sprite count to max 10 here;
187	182	proper games should not exceed this... */
188		if ( state->m_lcd.sprCount < 10 )
	183	if ( m_lcd.sprCount < 10 )
189	184	{
190		state->m_lcd.sprite[state->m_lcd.sprCount] = i;
191		state->m_lcd.sprCount++;
	185	m_lcd.sprite[m_lcd.sprCount] = i;
	186	m_lcd.sprCount++;
192	187	}
193	188	}
194	189	oam -= 4;
r20640	r20641
196	191	}
197	192	}
198	193
199		INLINE void gb_update_sprites ( running_machine &machine )
	194	void gb_state::gb_update_sprites()
200	195	{
201		gb_state *state = machine.driver_data<gb_state>();
202		bitmap_ind16 &bitmap = state->m_bitmap;
	196	bitmap_ind16 &bitmap = m_bitmap;
203	197	UINT8 height, tilemask, line, *oam, *vram;
204	198	int i, yindex;
205	199
r20640	r20641
214	208	tilemask = 0xFF;
215	209	}
216	210
217		yindex = state->m_lcd.current_line;
218		line = state->m_lcd.current_line + 16;
	211	yindex = m_lcd.current_line;
	212	line = m_lcd.current_line + 16;
219	213
220		oam = state->m_lcd.gb_oam->base() + 39 * 4;
221		vram = state->m_lcd.gb_vram->base();
	214	oam = m_lcd.gb_oam->base() + 39 * 4;
	215	vram = m_lcd.gb_vram->base();
222	216	for (i = 39; i >= 0; i--)
223	217	{
224	218	/* if sprite is on current line && x-coordinate && x-coordinate is < 168 */
r20640	r20641
228	222	UINT8 bit, *spal;
229	223	int xindex, adr;
230	224
231		spal = (oam[3] & 0x10) ? state->m_lcd.gb_spal1 : state->m_lcd.gb_spal0;
	225	spal = (oam[3] & 0x10) ? m_lcd.gb_spal1 : m_lcd.gb_spal0;
232	226	xindex = oam[1] - 8;
233	227	if (oam[3] & 0x40)         /* flip y ? */
234	228	{
r20640	r20641
246	240	for (bit = 0; bit < 8; bit++, xindex++)
247	241	{
248	242	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
249		if (colour && !state->m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
	243	if (colour && !m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
250	244	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
251	245	data >>= 1;
252	246	}
r20640	r20641
264	258	for (bit = 0; bit < 8 && xindex < 160; bit++, xindex++)
265	259	{
266	260	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
267		if (colour && !state->m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
	261	if (colour && !m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
268	262	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
269	263	data <<= 1;
270	264	}
r20640	r20641
284	278	}
285	279	}
286	280
287		static void gb_update_scanline( running_machine &machine )
	281	void gb_state::gb_update_scanline()
288	282	{
289		gb_state *state = machine.driver_data<gb_state>();
290		bitmap_ind16 &bitmap = state->m_bitmap;
	283	bitmap_ind16 &bitmap = m_bitmap;
291	284
292	285	g_profiler.start(PROFILER_VIDEO);
293	286
r20640	r20641
295	288	if ( ( LCDSTAT & 0x03 ) == 0x03 )
296	289	{
297	290	/* Calculate number of pixels to render based on time still left on the timer */
298		UINT32 cycles_to_go = machine.device<cpu_device>("maincpu")->attotime_to_cycles(state->m_lcd.lcd_timer ->remaining( ) );
	291	UINT32 cycles_to_go = m_maincpu->attotime_to_cycles(m_lcd.lcd_timer->remaining( ) );
299	292	int l = 0;
300	293
301		if ( state->m_lcd.start_x < 0 )
	294	if ( m_lcd.start_x < 0 )
302	295	{
303	296	/* Window is enabled if the hardware says so AND the current scanline is
304	297	* within the window AND the window X coordinate is <=166 */
305		state->m_lcd.layer[1].enabled = ( ( LCDCONT & 0x20 ) && ( state->m_lcd.current_line >= WNDPOSY ) && ( WNDPOSX <= 166 ) ) ? 1 : 0;
	298	m_lcd.layer[1].enabled = ( ( LCDCONT & 0x20 ) && ( m_lcd.current_line >= WNDPOSY ) && ( WNDPOSX <= 166 ) ) ? 1 : 0;
306	299
307	300	/* BG is enabled if the hardware says so AND (window_off OR (window_on
308	301	* AND window's X position is >=7 ) ) */
309		state->m_lcd.layer[0].enabled = ( ( LCDCONT & 0x01 ) && ( ( ! state->m_lcd.layer[1].enabled ) || ( state->m_lcd.layer[1].enabled && ( WNDPOSX >= 7 ) ) ) ) ? 1 : 0;
	302	m_lcd.layer[0].enabled = ( ( LCDCONT & 0x01 ) && ( ( ! m_lcd.layer[1].enabled ) || ( m_lcd.layer[1].enabled && ( WNDPOSX >= 7 ) ) ) ) ? 1 : 0;
310	303
311		if ( state->m_lcd.layer[0].enabled )
	304	if ( m_lcd.layer[0].enabled )
312	305	{
313		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
314		state->m_lcd.layer[0].bg_map = state->m_lcd.gb_bgdtab;
315		state->m_lcd.layer[0].bg_tiles = state->m_lcd.gb_chrgen;
316		state->m_lcd.layer[0].xindex = SCROLLX >> 3;
317		state->m_lcd.layer[0].xshift = SCROLLX & 7;
318		state->m_lcd.layer[0].xstart = 0;
319		state->m_lcd.layer[0].xend = 160;
	306	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	307	m_lcd.layer[0].bg_map = m_lcd.gb_bgdtab;
	308	m_lcd.layer[0].bg_tiles = m_lcd.gb_chrgen;
	309	m_lcd.layer[0].xindex = SCROLLX >> 3;
	310	m_lcd.layer[0].xshift = SCROLLX & 7;
	311	m_lcd.layer[0].xstart = 0;
	312	m_lcd.layer[0].xend = 160;
320	313	}
321	314
322		if ( state->m_lcd.layer[1].enabled )
	315	if ( m_lcd.layer[1].enabled )
323	316	{
324	317	int xpos;
325	318
r20640	r20641
327	320	if ( xpos < 0 )
328	321	xpos = 0;
329	322
330		state->m_lcd.layer[1].bgline = state->m_lcd.window_lines_drawn;
331		state->m_lcd.layer[1].bg_map = state->m_lcd.gb_wndtab;
332		state->m_lcd.layer[1].bg_tiles = state->m_lcd.gb_chrgen;
333		state->m_lcd.layer[1].xindex = 0;
334		state->m_lcd.layer[1].xshift = 0;
335		state->m_lcd.layer[1].xstart = xpos;
336		state->m_lcd.layer[1].xend = 160;
337		state->m_lcd.layer[0].xend = xpos;
	323	m_lcd.layer[1].bgline = m_lcd.window_lines_drawn;
	324	m_lcd.layer[1].bg_map = m_lcd.gb_wndtab;
	325	m_lcd.layer[1].bg_tiles = m_lcd.gb_chrgen;
	326	m_lcd.layer[1].xindex = 0;
	327	m_lcd.layer[1].xshift = 0;
	328	m_lcd.layer[1].xstart = xpos;
	329	m_lcd.layer[1].xend = 160;
	330	m_lcd.layer[0].xend = xpos;
338	331	}
339		state->m_lcd.start_x = 0;
	332	m_lcd.start_x = 0;
340	333	}
341	334
342	335	if ( cycles_to_go < 160 )
343	336	{
344		state->m_lcd.end_x = MIN(160 - cycles_to_go,160);
	337	m_lcd.end_x = MIN(160 - cycles_to_go,160);
345	338	/* Draw empty pixels when the background is disabled */
346	339	if ( ! ( LCDCONT & 0x01 ) )
347	340	{
348		rectangle r(state->m_lcd.start_x, state->m_lcd.end_x - 1, state->m_lcd.current_line, state->m_lcd.current_line);
349		bitmap.fill(state->m_lcd.gb_bpal[0], r );
	341	rectangle r(m_lcd.start_x, m_lcd.end_x - 1, m_lcd.current_line, m_lcd.current_line);
	342	bitmap.fill(m_lcd.gb_bpal[0], r );
350	343	}
351	344	while ( l < 2 )
352	345	{
r20640	r20641
354	347	UINT16  data;
355	348	int i, tile_index;
356	349
357		if ( ! state->m_lcd.layer[l].enabled )
	350	if ( ! m_lcd.layer[l].enabled )
358	351	{
359	352	l++;
360	353	continue;
361	354	}
362		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
363		tiles = state->m_lcd.layer[l].bg_tiles + ( ( state->m_lcd.layer[l].bgline & 7 ) << 1 );
364		xindex = state->m_lcd.start_x;
365		if ( xindex < state->m_lcd.layer[l].xstart )
366		xindex = state->m_lcd.layer[l].xstart;
367		i = state->m_lcd.end_x;
368		if ( i > state->m_lcd.layer[l].xend )
369		i = state->m_lcd.layer[l].xend;
	355	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	356	tiles = m_lcd.layer[l].bg_tiles + ( ( m_lcd.layer[l].bgline & 7 ) << 1 );
	357	xindex = m_lcd.start_x;
	358	if ( xindex < m_lcd.layer[l].xstart )
	359	xindex = m_lcd.layer[l].xstart;
	360	i = m_lcd.end_x;
	361	if ( i > m_lcd.layer[l].xend )
	362	i = m_lcd.layer[l].xend;
370	363	i = i - xindex;
371	364
372		tile_index = ( map[ state->m_lcd.layer[l].xindex ] ^ state->m_lcd.gb_tile_no_mod ) * 16;
	365	tile_index = ( map[ m_lcd.layer[l].xindex ] ^ m_lcd.gb_tile_no_mod ) * 16;
373	366	data = tiles[ tile_index ] | ( tiles[ tile_index+1 ] << 8 );
374		data <<= state->m_lcd.layer[l].xshift;
	367	data <<= m_lcd.layer[l].xshift;
375	368
376	369	while ( i > 0 )
377	370	{
378		while ( ( state->m_lcd.layer[l].xshift < 8 ) && i )
	371	while ( ( m_lcd.layer[l].xshift < 8 ) && i )
379	372	{
380	373	register int colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 );
381		gb_plot_pixel( bitmap, xindex, state->m_lcd.current_line, state->m_lcd.gb_bpal[ colour ] );
382		state->m_lcd.bg_zbuf[ xindex ] = colour;
	374	gb_plot_pixel( bitmap, xindex, m_lcd.current_line, m_lcd.gb_bpal[ colour ] );
	375	m_lcd.bg_zbuf[ xindex ] = colour;
383	376	xindex++;
384	377	data <<= 1;
385		state->m_lcd.layer[l].xshift++;
	378	m_lcd.layer[l].xshift++;
386	379	i--;
387	380	}
388		if ( state->m_lcd.layer[l].xshift == 8 )
	381	if ( m_lcd.layer[l].xshift == 8 )
389	382	{
390	383	/* Take possible changes to SCROLLY into account */
391	384	if ( l == 0 )
392	385	{
393		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
394		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
395		tiles = state->m_lcd.layer[l].bg_tiles + ( ( state->m_lcd.layer[l].bgline & 7 ) << 1 );
	386	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	387	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	388	tiles = m_lcd.layer[l].bg_tiles + ( ( m_lcd.layer[l].bgline & 7 ) << 1 );
396	389	}
397	390
398		state->m_lcd.layer[l].xindex = ( state->m_lcd.layer[l].xindex + 1 ) & 31;
399		state->m_lcd.layer[l].xshift = 0;
400		tile_index = ( map[ state->m_lcd.layer[l].xindex ] ^ state->m_lcd.gb_tile_no_mod ) * 16;
	391	m_lcd.layer[l].xindex = ( m_lcd.layer[l].xindex + 1 ) & 31;
	392	m_lcd.layer[l].xshift = 0;
	393	tile_index = ( map[ m_lcd.layer[l].xindex ] ^ m_lcd.gb_tile_no_mod ) * 16;
401	394	data = tiles[ tile_index ] | ( tiles[ tile_index+1 ] << 8 );
402	395	}
403	396	}
404	397	l++;
405	398	}
406		if ( state->m_lcd.end_x == 160 && LCDCONT & 0x02 )
	399	if ( m_lcd.end_x == 160 && LCDCONT & 0x02 )
407	400	{
408		gb_update_sprites(machine);
	401	gb_update_sprites();
409	402	}
410		state->m_lcd.start_x = state->m_lcd.end_x;
	403	m_lcd.start_x = m_lcd.end_x;
411	404	}
412	405	}
413	406	else
r20640	r20641
415	408	if ( ! ( LCDCONT & 0x80 ) )
416	409	{
417	410	/* Draw an empty line when LCD is disabled */
418		if ( state->m_lcd.previous_line != state->m_lcd.current_line )
	411	if ( m_lcd.previous_line != m_lcd.current_line )
419	412	{
420		if ( state->m_lcd.current_line < 144 )
	413	if ( m_lcd.current_line < 144 )
421	414	{
422		screen_device *screen = machine.first_screen();
	415	screen_device *screen = machine().first_screen();
423	416	const rectangle &r = screen->visible_area();
424		rectangle r1(r.min_x, r.max_x, state->m_lcd.current_line, state->m_lcd.current_line);
	417	rectangle r1(r.min_x, r.max_x, m_lcd.current_line, m_lcd.current_line);
425	418	bitmap.fill(0, r1 );
426	419	}
427		state->m_lcd.previous_line = state->m_lcd.current_line;
	420	m_lcd.previous_line = m_lcd.current_line;
428	421	}
429	422	}
430	423	}
r20640	r20641
434	427
435	428	/* --- Super Game Boy Specific --- */
436	429
437		INLINE void sgb_update_sprites (running_machine &machine)
	430	void gb_state::sgb_update_sprites()
438	431	{
439		gb_state *state = machine.driver_data<gb_state>();
440		bitmap_ind16 &bitmap = state->m_bitmap;
	432	bitmap_ind16 &bitmap = m_bitmap;
441	433	UINT8 height, tilemask, line, *oam, *vram, pal;
442	434	INT16 i, yindex;
443	435
r20640	r20641
453	445	}
454	446
455	447	/* Offset to center of screen */
456		yindex = state->m_lcd.current_line + SGB_YOFFSET;
457		line = state->m_lcd.current_line + 16;
	448	yindex = m_lcd.current_line + SGB_YOFFSET;
	449	line = m_lcd.current_line + 16;
458	450
459		oam = state->m_lcd.gb_oam->base() + 39 * 4;
460		vram = state->m_lcd.gb_vram->base();
	451	oam = m_lcd.gb_oam->base() + 39 * 4;
	452	vram = m_lcd.gb_vram->base();
461	453	for (i = 39; i >= 0; i--)
462	454	{
463	455	/* if sprite is on current line && x-coordinate && x-coordinate is < 168 */
r20640	r20641
468	460	INT16 xindex;
469	461	int adr;
470	462
471		spal = (oam[3] & 0x10) ? state->m_lcd.gb_spal1 : state->m_lcd.gb_spal0;
	463	spal = (oam[3] & 0x10) ? m_lcd.gb_spal1 : m_lcd.gb_spal0;
472	464	xindex = oam[1] - 8;
473	465	if (oam[3] & 0x40)         /* flip y ? */
474	466	{
r20640	r20641
481	473	data = (vram[adr + 1] << 8) | vram[adr];
482	474
483	475	/* Find the palette to use */
484		pal = state->m_sgb_pal_map[(xindex >> 3)][((yindex - SGB_YOFFSET) >> 3)] << 2;
	476	pal = m_sgb_pal_map[(xindex >> 3)][((yindex - SGB_YOFFSET) >> 3)] << 2;
485	477
486	478	/* Offset to center of screen */
487	479	xindex += SGB_XOFFSET;
r20640	r20641
492	484	for (bit = 0; bit < 8; bit++, xindex++)
493	485	{
494	486	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
495		if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour && !state->m_lcd.bg_zbuf[xindex - SGB_XOFFSET])
496		gb_plot_pixel(bitmap, xindex, yindex, state->m_sgb_pal[pal + spal[colour]]);
	487	if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour && !m_lcd.bg_zbuf[xindex - SGB_XOFFSET])
	488	gb_plot_pixel(bitmap, xindex, yindex, m_sgb_pal[pal + spal[colour]]);
497	489	data >>= 1;
498	490	}
499	491	break;
r20640	r20641
502	494	{
503	495	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
504	496	if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour)
505		gb_plot_pixel(bitmap, xindex, yindex, state->m_sgb_pal[pal + spal[colour]]);
	497	gb_plot_pixel(bitmap, xindex, yindex, m_sgb_pal[pal + spal[colour]]);
506	498	data >>= 1;
507	499	}
508	500	break;
r20640	r20641
510	502	for (bit = 0; bit < 8; bit++, xindex++)
511	503	{
512	504	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
513		if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour && !state->m_lcd.bg_zbuf[xindex - SGB_XOFFSET])
514		gb_plot_pixel(bitmap, xindex, yindex, state->m_sgb_pal[pal + spal[colour]]);
	505	if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour && !m_lcd.bg_zbuf[xindex - SGB_XOFFSET])
	506	gb_plot_pixel(bitmap, xindex, yindex, m_sgb_pal[pal + spal[colour]]);
515	507	data <<= 1;
516	508	}
517	509	break;
r20640	r20641
520	512	{
521	513	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
522	514	if ((xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160) && colour)
523		gb_plot_pixel(bitmap, xindex, yindex, state->m_sgb_pal[pal + spal[colour]]);
	515	gb_plot_pixel(bitmap, xindex, yindex, m_sgb_pal[pal + spal[colour]]);
524	516	data <<= 1;
525	517	}
526	518	break;
r20640	r20641
530	522	}
531	523	}
532	524
533		static void sgb_refresh_border(running_machine &machine)
	525
	526	void gb_state::sgb_refresh_border()
534	527	{
535		gb_state *state = machine.driver_data<gb_state>();
536	528	UINT16 data, data2;
537	529	UINT16 yidx, xidx, xindex;
538	530	UINT8 *map, *tiles, *tiles2;
539	531	UINT8 pal, i;
540		bitmap_ind16 &bitmap = state->m_bitmap;
	532	bitmap_ind16 &bitmap = m_bitmap;
541	533
542		map = state->m_sgb_tile_map - 64;
	534	map = m_sgb_tile_map - 64;
543	535
544	536	for( yidx = 0; yidx < 224; yidx++ )
545	537	{
r20640	r20641
548	540	for( xidx = 0; xidx < 64; xidx+=2 )
549	541	{
550	542	if( map[xidx+1] & 0x80 ) /* Vertical flip */
551		tiles = state->m_sgb_tile_data + ( ( 7 - ( yidx % 8 ) ) << 1 );
	543	tiles = m_sgb_tile_data + ( ( 7 - ( yidx % 8 ) ) << 1 );
552	544	else /* No vertical flip */
553		tiles = state->m_sgb_tile_data + ( ( yidx % 8 ) << 1 );
	545	tiles = m_sgb_tile_data + ( ( yidx % 8 ) << 1 );
554	546	tiles2 = tiles + 16;
555	547
556	548	pal = (map[xidx+1] & 0x1C) >> 2;
r20640	r20641
558	550	pal = 1;
559	551	pal <<= 4;
560	552
561		if( state->m_sgb_hack )
	553	if( m_sgb_hack )
562	554	{ /* A few games do weird stuff */
563	555	UINT8 tileno = map[xidx];
564	556	if( tileno >= 128 ) tileno = ((64 + tileno) % 128) + 128;
r20640	r20641
596	588	if( !((yidx >= SGB_YOFFSET && yidx < SGB_YOFFSET + 144) &&
597	589	(xindex >= SGB_XOFFSET && xindex < SGB_XOFFSET + 160)) )
598	590	{
599		gb_plot_pixel(bitmap, xindex, yidx, state->m_sgb_pal[pal + colour]);
	591	gb_plot_pixel(bitmap, xindex, yidx, m_sgb_pal[pal + colour]);
600	592	}
601	593	xindex++;
602	594	}
r20640	r20641
604	596	}
605	597	}
606	598
607		static void sgb_update_scanline( running_machine &machine )
	599	void gb_state::sgb_update_scanline()
608	600	{
609		gb_state *state = machine.driver_data<gb_state>();
610		bitmap_ind16 &bitmap = state->m_bitmap;
	601	bitmap_ind16 &bitmap = m_bitmap;
611	602
612	603	g_profiler.start(PROFILER_VIDEO);
613	604
614	605	if ( ( LCDSTAT & 0x03 ) == 0x03 )
615	606	{
616	607	/* Calcuate number of pixels to render based on time still left on the timer */
617		UINT32 cycles_to_go = machine.device<cpu_device>("maincpu")->attotime_to_cycles(state->m_lcd.lcd_timer ->remaining( ) );
	608	UINT32 cycles_to_go = m_maincpu->attotime_to_cycles(m_lcd.lcd_timer->remaining( ) );
618	609	int l = 0;
619	610
620		if ( state->m_lcd.start_x < 0 )
	611	if ( m_lcd.start_x < 0 )
621	612	{
622	613	/* Window is enabled if the hardware says so AND the current scanline is
623	614	* within the window AND the window X coordinate is <=166 */
624		state->m_lcd.layer[1].enabled = ((LCDCONT & 0x20) && state->m_lcd.current_line >= WNDPOSY && WNDPOSX <= 166) ? 1 : 0;
	615	m_lcd.layer[1].enabled = ((LCDCONT & 0x20) && m_lcd.current_line >= WNDPOSY && WNDPOSX <= 166) ? 1 : 0;
625	616
626	617	/* BG is enabled if the hardware says so AND (window_off OR (window_on
627	618	* AND window's X position is >=7 ) ) */
628		state->m_lcd.layer[0].enabled = ((LCDCONT & 0x01) && ((!state->m_lcd.layer[1].enabled) || (state->m_lcd.layer[1].enabled && WNDPOSX >= 7))) ? 1 : 0;
	619	m_lcd.layer[0].enabled = ((LCDCONT & 0x01) && ((!m_lcd.layer[1].enabled) || (m_lcd.layer[1].enabled && WNDPOSX >= 7))) ? 1 : 0;
629	620
630		if ( state->m_lcd.layer[0].enabled )
	621	if ( m_lcd.layer[0].enabled )
631	622	{
632		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
633		state->m_lcd.layer[0].bg_map = state->m_lcd.gb_bgdtab;
634		state->m_lcd.layer[0].bg_tiles = state->m_lcd.gb_chrgen;
635		state->m_lcd.layer[0].xindex = SCROLLX >> 3;
636		state->m_lcd.layer[0].xshift = SCROLLX & 7;
637		state->m_lcd.layer[0].xstart = 0;
638		state->m_lcd.layer[0].xend = 160;
	623	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	624	m_lcd.layer[0].bg_map = m_lcd.gb_bgdtab;
	625	m_lcd.layer[0].bg_tiles = m_lcd.gb_chrgen;
	626	m_lcd.layer[0].xindex = SCROLLX >> 3;
	627	m_lcd.layer[0].xshift = SCROLLX & 7;
	628	m_lcd.layer[0].xstart = 0;
	629	m_lcd.layer[0].xend = 160;
639	630	}
640	631
641		if ( state->m_lcd.layer[1].enabled )
	632	if ( m_lcd.layer[1].enabled )
642	633	{
643	634	int xpos;
644	635
r20640	r20641
647	638	if (xpos < 0)
648	639	xpos = 0;
649	640
650		state->m_lcd.layer[1].bgline = state->m_lcd.window_lines_drawn;
651		state->m_lcd.layer[1].bg_map = state->m_lcd.gb_wndtab;
652		state->m_lcd.layer[1].bg_tiles = state->m_lcd.gb_chrgen;
653		state->m_lcd.layer[1].xindex = 0;
654		state->m_lcd.layer[1].xshift = 0;
655		state->m_lcd.layer[1].xstart = xpos;
656		state->m_lcd.layer[1].xend = 160;
657		state->m_lcd.layer[0].xend = xpos;
	641	m_lcd.layer[1].bgline = m_lcd.window_lines_drawn;
	642	m_lcd.layer[1].bg_map = m_lcd.gb_wndtab;
	643	m_lcd.layer[1].bg_tiles = m_lcd.gb_chrgen;
	644	m_lcd.layer[1].xindex = 0;
	645	m_lcd.layer[1].xshift = 0;
	646	m_lcd.layer[1].xstart = xpos;
	647	m_lcd.layer[1].xend = 160;
	648	m_lcd.layer[0].xend = xpos;
658	649	}
659		state->m_lcd.start_x = 0;
	650	m_lcd.start_x = 0;
660	651	}
661	652
662	653	if ( cycles_to_go == 0 )
663	654	{
664	655	/* Does this belong here? or should it be moved to the else block */
665	656	/* Handle SGB mask */
666		switch( state->m_sgb_window_mask )
	657	switch( m_sgb_window_mask )
667	658	{
668	659	case 1: /* Freeze screen */
669	660	return;
r20640	r20641
680	671	}
681	672
682	673	/* Draw the "border" if we're on the first line */
683		if ( state->m_lcd.current_line == 0 )
	674	if ( m_lcd.current_line == 0 )
684	675	{
685		sgb_refresh_border(machine);
	676	sgb_refresh_border();
686	677	}
687	678	}
688	679	if ( cycles_to_go < 160 )
689	680	{
690		state->m_lcd.end_x = MIN(160 - cycles_to_go,160);
	681	m_lcd.end_x = MIN(160 - cycles_to_go,160);
691	682
692	683	/* if background or screen disabled clear line */
693	684	if ( ! ( LCDCONT & 0x01 ) )
694	685	{
695		rectangle r(SGB_XOFFSET, SGB_XOFFSET + 160 - 1, state->m_lcd.current_line + SGB_YOFFSET, state->m_lcd.current_line + SGB_YOFFSET);
	686	rectangle r(SGB_XOFFSET, SGB_XOFFSET + 160 - 1, m_lcd.current_line + SGB_YOFFSET, m_lcd.current_line + SGB_YOFFSET);
696	687	bitmap.fill(0, r );
697	688	}
698	689	while( l < 2 )
r20640	r20641
701	692	UINT16  data;
702	693	int i, tile_index;
703	694
704		if ( ! state->m_lcd.layer[l].enabled )
	695	if ( ! m_lcd.layer[l].enabled )
705	696	{
706	697	l++;
707	698	continue;
708	699	}
709		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
710		tiles = state->m_lcd.layer[l].bg_tiles + ( ( state->m_lcd.layer[l].bgline & 7 ) << 1 );
711		xindex = state->m_lcd.start_x;
712		if ( xindex < state->m_lcd.layer[l].xstart )
713		xindex = state->m_lcd.layer[l].xstart;
714		i = state->m_lcd.end_x;
715		if ( i > state->m_lcd.layer[l].xend )
716		i = state->m_lcd.layer[l].xend;
	700	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	701	tiles = m_lcd.layer[l].bg_tiles + ( ( m_lcd.layer[l].bgline & 7 ) << 1 );
	702	xindex = m_lcd.start_x;
	703	if ( xindex < m_lcd.layer[l].xstart )
	704	xindex = m_lcd.layer[l].xstart;
	705	i = m_lcd.end_x;
	706	if ( i > m_lcd.layer[l].xend )
	707	i = m_lcd.layer[l].xend;
717	708	i = i - xindex;
718	709
719		tile_index = (map[state->m_lcd.layer[l].xindex] ^ state->m_lcd.gb_tile_no_mod) * 16;
	710	tile_index = (map[m_lcd.layer[l].xindex] ^ m_lcd.gb_tile_no_mod) * 16;
720	711	data = tiles[tile_index] | ( tiles[tile_index + 1] << 8 );
721		data <<= state->m_lcd.layer[l].xshift;
	712	data <<= m_lcd.layer[l].xshift;
722	713
723	714	/* Figure out which palette we're using */
724		sgb_palette = state->m_sgb_pal_map[ ( state->m_lcd.end_x - i ) >> 3 ][ state->m_lcd.current_line >> 3 ] << 2;
	715	sgb_palette = m_sgb_pal_map[ ( m_lcd.end_x - i ) >> 3 ][ m_lcd.current_line >> 3 ] << 2;
725	716
726	717	while( i > 0 )
727	718	{
728		while( ( state->m_lcd.layer[l].xshift < 8 ) && i )
	719	while( ( m_lcd.layer[l].xshift < 8 ) && i )
729	720	{
730	721	register int colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 );
731		gb_plot_pixel( bitmap, xindex + SGB_XOFFSET, state->m_lcd.current_line + SGB_YOFFSET, state->m_sgb_pal[ sgb_palette + state->m_lcd.gb_bpal[colour]] );
732		state->m_lcd.bg_zbuf[xindex] = colour;
	722	gb_plot_pixel( bitmap, xindex + SGB_XOFFSET, m_lcd.current_line + SGB_YOFFSET, m_sgb_pal[ sgb_palette + m_lcd.gb_bpal[colour]] );
	723	m_lcd.bg_zbuf[xindex] = colour;
733	724	xindex++;
734	725	data <<= 1;
735		state->m_lcd.layer[l].xshift++;
	726	m_lcd.layer[l].xshift++;
736	727	i--;
737	728	}
738		if ( state->m_lcd.layer[l].xshift == 8 )
	729	if ( m_lcd.layer[l].xshift == 8 )
739	730	{
740	731	/* Take possible changes to SCROLLY into account */
741	732	if ( l == 0 )
742	733	{
743		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
744		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
745		tiles = state->m_lcd.layer[l].bg_tiles + ( ( state->m_lcd.layer[l].bgline & 7 ) << 1 );
	734	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	735	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	736	tiles = m_lcd.layer[l].bg_tiles + ( ( m_lcd.layer[l].bgline & 7 ) << 1 );
746	737	}
747	738
748		state->m_lcd.layer[l].xindex = ( state->m_lcd.layer[l].xindex + 1 ) & 31;
749		state->m_lcd.layer[l].xshift = 0;
750		tile_index = ( map[ state->m_lcd.layer[l].xindex ] ^ state->m_lcd.gb_tile_no_mod ) * 16;
	739	m_lcd.layer[l].xindex = ( m_lcd.layer[l].xindex + 1 ) & 31;
	740	m_lcd.layer[l].xshift = 0;
	741	tile_index = ( map[ m_lcd.layer[l].xindex ] ^ m_lcd.gb_tile_no_mod ) * 16;
751	742	data = tiles[ tile_index ] | ( tiles[ tile_index + 1 ] << 8 );
752		sgb_palette = state->m_sgb_pal_map[ ( state->m_lcd.end_x - i ) >> 3 ][ state->m_lcd.current_line >> 3 ] << 2;
	743	sgb_palette = m_sgb_pal_map[ ( m_lcd.end_x - i ) >> 3 ][ m_lcd.current_line >> 3 ] << 2;
753	744	}
754	745	}
755	746	l++;
756	747	}
757		if ( ( state->m_lcd.end_x == 160 ) && ( LCDCONT & 0x02 ) )
	748	if ( ( m_lcd.end_x == 160 ) && ( LCDCONT & 0x02 ) )
758	749	{
759		sgb_update_sprites(machine);
	750	sgb_update_sprites();
760	751	}
761		state->m_lcd.start_x = state->m_lcd.end_x;
	752	m_lcd.start_x = m_lcd.end_x;
762	753	}
763	754	}
764	755	else
r20640	r20641
766	757	if ( ! ( LCDCONT * 0x80 ) )
767	758	{
768	759	/* if screen disabled clear line */
769		if ( state->m_lcd.previous_line != state->m_lcd.current_line )
	760	if ( m_lcd.previous_line != m_lcd.current_line )
770	761	{
771	762	/* Also refresh border here??? */
772		if ( state->m_lcd.current_line < 144 )
	763	if ( m_lcd.current_line < 144 )
773	764	{
774		rectangle r(SGB_XOFFSET, SGB_XOFFSET + 160 - 1, state->m_lcd.current_line + SGB_YOFFSET, state->m_lcd.current_line + SGB_YOFFSET);
	765	rectangle r(SGB_XOFFSET, SGB_XOFFSET + 160 - 1, m_lcd.current_line + SGB_YOFFSET, m_lcd.current_line + SGB_YOFFSET);
775	766	bitmap.fill(0, r);
776	767	}
777		state->m_lcd.previous_line = state->m_lcd.current_line;
	768	m_lcd.previous_line = m_lcd.current_line;
778	769	}
779	770	}
780	771	}
r20640	r20641
784	775
785	776	/* --- Game Boy Color Specific --- */
786	777
787		INLINE void cgb_update_sprites ( running_machine &machine )
	778	void gb_state::cgb_update_sprites()
788	779	{
789		gb_state *state = machine.driver_data<gb_state>();
790		bitmap_ind16 &bitmap = state->m_bitmap;
	780	bitmap_ind16 &bitmap = m_bitmap;
791	781	UINT8 height, tilemask, line, *oam;
792	782	int i, xindex, yindex;
793	783
r20640	r20641
802	792	tilemask = 0xFF;
803	793	}
804	794
805		yindex = state->m_lcd.current_line;
806		line = state->m_lcd.current_line + 16;
	795	yindex = m_lcd.current_line;
	796	line = m_lcd.current_line + 16;
807	797
808		oam = state->m_lcd.gb_oam->base() + 39 * 4;
	798	oam = m_lcd.gb_oam->base() + 39 * 4;
809	799	for (i = 39; i >= 0; i--)
810	800	{
811	801	/* if sprite is on current line && x-coordinate && x-coordinate is < 168 */
r20640	r20641
815	805	UINT8 bit, pal;
816	806
817	807	/* Handle mono mode for GB games */
818		if( ! state->m_lcd.gbc_mode )
	808	if( ! m_lcd.gbc_mode )
819	809	pal = (oam[3] & 0x10) ? 4 : 0;
820	810	else
821	811	pal = ((oam[3] & 0x7) * 4);
r20640	r20641
823	813	xindex = oam[1] - 8;
824	814	if (oam[3] & 0x40)         /* flip y ? */
825	815	{
826		data = *((UINT16 *) &state->m_lcd.gb_vram->base()[ ((oam[3] & 0x8)<<10) + (oam[2] & tilemask) * 16 + (height - 1 - line + oam[0]) * 2]);
	816	data = *((UINT16 *) &m_lcd.gb_vram->base()[ ((oam[3] & 0x8)<<10) + (oam[2] & tilemask) * 16 + (height - 1 - line + oam[0]) * 2]);
827	817	}
828	818	else
829	819	{
830		data = *((UINT16 *) &state->m_lcd.gb_vram->base()[ ((oam[3] & 0x8)<<10) + (oam[2] & tilemask) * 16 + (line - oam[0]) * 2]);
	820	data = *((UINT16 *) &m_lcd.gb_vram->base()[ ((oam[3] & 0x8)<<10) + (oam[2] & tilemask) * 16 + (line - oam[0]) * 2]);
831	821	}
832	822	#ifndef LSB_FIRST
833	823	data = (data << 8) | (data >> 8);
r20640	r20641
839	829	for (bit = 0; bit < 8; bit++, xindex++)
840	830	{
841	831	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
842		if (colour && !state->m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
	832	if (colour && !m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
843	833	{
844		if ( ! state->m_lcd.gbc_mode )
845		colour = pal ? state->m_lcd.gb_spal1[colour] : state->m_lcd.gb_spal0[colour];
846		gb_plot_pixel(bitmap, xindex, yindex, state->m_lcd.cgb_spal[pal + colour]);
	834	if ( ! m_lcd.gbc_mode )
	835	colour = pal ? m_lcd.gb_spal1[colour] : m_lcd.gb_spal0[colour];
	836	gb_plot_pixel(bitmap, xindex, yindex, m_lcd.cgb_spal[pal + colour]);
847	837	}
848	838	data >>= 1;
849	839	}
r20640	r20641
852	842	for (bit = 0; bit < 8; bit++, xindex++)
853	843	{
854	844	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
855		if((state->m_lcd.bg_zbuf[xindex] & 0x80) && (state->m_lcd.bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
	845	if((m_lcd.bg_zbuf[xindex] & 0x80) && (m_lcd.bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
856	846	colour = 0;
857	847	if (colour && xindex >= 0 && xindex < 160)
858	848	{
859		if ( ! state->m_lcd.gbc_mode )
860		colour = pal ? state->m_lcd.gb_spal1[colour] : state->m_lcd.gb_spal0[colour];
861		gb_plot_pixel(bitmap, xindex, yindex, state->m_lcd.cgb_spal[pal + colour]);
	849	if ( ! m_lcd.gbc_mode )
	850	colour = pal ? m_lcd.gb_spal1[colour] : m_lcd.gb_spal0[colour];
	851	gb_plot_pixel(bitmap, xindex, yindex, m_lcd.cgb_spal[pal + colour]);
862	852	}
863	853	data >>= 1;
864	854	}
r20640	r20641
867	857	for (bit = 0; bit < 8; bit++, xindex++)
868	858	{
869	859	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
870		if (colour && !state->m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
	860	if (colour && !m_lcd.bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
871	861	{
872		if ( ! state->m_lcd.gbc_mode )
873		colour = pal ? state->m_lcd.gb_spal1[colour] : state->m_lcd.gb_spal0[colour];
874		gb_plot_pixel(bitmap, xindex, yindex, state->m_lcd.cgb_spal[pal + colour]);
	862	if ( ! m_lcd.gbc_mode )
	863	colour = pal ? m_lcd.gb_spal1[colour] : m_lcd.gb_spal0[colour];
	864	gb_plot_pixel(bitmap, xindex, yindex, m_lcd.cgb_spal[pal + colour]);
875	865	}
876	866	data <<= 1;
877	867	}
r20640	r20641
880	870	for (bit = 0; bit < 8; bit++, xindex++)
881	871	{
882	872	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
883		if((state->m_lcd.bg_zbuf[xindex] & 0x80) && (state->m_lcd.bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
	873	if((m_lcd.bg_zbuf[xindex] & 0x80) && (m_lcd.bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
884	874	colour = 0;
885	875	if (colour && xindex >= 0 && xindex < 160)
886	876	{
887		if ( ! state->m_lcd.gbc_mode )
888		colour = pal ? state->m_lcd.gb_spal1[colour] : state->m_lcd.gb_spal0[colour];
889		gb_plot_pixel(bitmap, xindex, yindex, state->m_lcd.cgb_spal[pal + colour]);
	877	if ( ! m_lcd.gbc_mode )
	878	colour = pal ? m_lcd.gb_spal1[colour] : m_lcd.gb_spal0[colour];
	879	gb_plot_pixel(bitmap, xindex, yindex, m_lcd.cgb_spal[pal + colour]);
890	880	}
891	881	data <<= 1;
892	882	}
r20640	r20641
897	887	}
898	888	}
899	889
900		static void cgb_update_scanline ( running_machine &machine )
	890	void gb_state::cgb_update_scanline()
901	891	{
902		gb_state *state = machine.driver_data<gb_state>();
903		bitmap_ind16 &bitmap = state->m_bitmap;
	892	bitmap_ind16 &bitmap = m_bitmap;
904	893
905	894	g_profiler.start(PROFILER_VIDEO);
906	895
907	896	if ( ( LCDSTAT & 0x03 ) == 0x03 )
908	897	{
909	898	/* Calcuate number of pixels to render based on time still left on the timer */
910		UINT32 cycles_to_go = machine.device<cpu_device>("maincpu")->attotime_to_cycles(state->m_lcd.lcd_timer ->remaining( ) );
	899	UINT32 cycles_to_go = m_maincpu->attotime_to_cycles(m_lcd.lcd_timer->remaining( ) );
911	900	int l = 0;
912	901
913		if ( state->m_lcd.start_x < 0 )
	902	if ( m_lcd.start_x < 0 )
914	903	{
915	904	/* Window is enabled if the hardware says so AND the current scanline is
916	905	* within the window AND the window X coordinate is <=166 */
917		state->m_lcd.layer[1].enabled = ( ( LCDCONT & 0x20 ) && ( state->m_lcd.current_line >= WNDPOSY ) && ( WNDPOSX <= 166 ) ) ? 1 : 0;
	906	m_lcd.layer[1].enabled = ( ( LCDCONT & 0x20 ) && ( m_lcd.current_line >= WNDPOSY ) && ( WNDPOSX <= 166 ) ) ? 1 : 0;
918	907
919	908	/* BG is enabled if the hardware says so AND (window_off OR (window_on
920	909	* AND window's X position is >=7 ) ) */
921		state->m_lcd.layer[0].enabled = ( ( LCDCONT & 0x01 ) && ( ( ! state->m_lcd.layer[1].enabled ) || ( state->m_lcd.layer[1].enabled && ( WNDPOSX >= 7 ) ) ) ) ? 1 : 0;
	910	m_lcd.layer[0].enabled = ( ( LCDCONT & 0x01 ) && ( ( ! m_lcd.layer[1].enabled ) || ( m_lcd.layer[1].enabled && ( WNDPOSX >= 7 ) ) ) ) ? 1 : 0;
922	911
923		if ( state->m_lcd.layer[0].enabled )
	912	if ( m_lcd.layer[0].enabled )
924	913	{
925		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
926		state->m_lcd.layer[0].bg_map = state->m_lcd.gb_bgdtab;
927		state->m_lcd.layer[0].gbc_map = state->m_lcd.gbc_bgdtab;
928		state->m_lcd.layer[0].xindex = SCROLLX >> 3;
929		state->m_lcd.layer[0].xshift = SCROLLX & 7;
930		state->m_lcd.layer[0].xstart = 0;
931		state->m_lcd.layer[0].xend = 160;
	914	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	915	m_lcd.layer[0].bg_map = m_lcd.gb_bgdtab;
	916	m_lcd.layer[0].gbc_map = m_lcd.gbc_bgdtab;
	917	m_lcd.layer[0].xindex = SCROLLX >> 3;
	918	m_lcd.layer[0].xshift = SCROLLX & 7;
	919	m_lcd.layer[0].xstart = 0;
	920	m_lcd.layer[0].xend = 160;
932	921	}
933	922
934		if ( state->m_lcd.layer[1].enabled )
	923	if ( m_lcd.layer[1].enabled )
935	924	{
936	925	int xpos;
937	926
r20640	r20641
940	929	if (xpos < 0)
941	930	xpos = 0;
942	931
943		state->m_lcd.layer[1].bgline = state->m_lcd.window_lines_drawn;
944		state->m_lcd.layer[1].bg_map = state->m_lcd.gb_wndtab;
945		state->m_lcd.layer[1].gbc_map = state->m_lcd.gbc_wndtab;
946		state->m_lcd.layer[1].xindex = 0;
947		state->m_lcd.layer[1].xshift = 0;
948		state->m_lcd.layer[1].xstart = xpos;
949		state->m_lcd.layer[1].xend = 160;
950		state->m_lcd.layer[0].xend = xpos;
	932	m_lcd.layer[1].bgline = m_lcd.window_lines_drawn;
	933	m_lcd.layer[1].bg_map = m_lcd.gb_wndtab;
	934	m_lcd.layer[1].gbc_map = m_lcd.gbc_wndtab;
	935	m_lcd.layer[1].xindex = 0;
	936	m_lcd.layer[1].xshift = 0;
	937	m_lcd.layer[1].xstart = xpos;
	938	m_lcd.layer[1].xend = 160;
	939	m_lcd.layer[0].xend = xpos;
951	940	}
952		state->m_lcd.start_x = 0;
	941	m_lcd.start_x = 0;
953	942	}
954	943
955	944	if ( cycles_to_go < 160 )
956	945	{
957		state->m_lcd.end_x = MIN(160 - cycles_to_go,160);
	946	m_lcd.end_x = MIN(160 - cycles_to_go,160);
958	947	/* Draw empty line when the background is disabled */
959	948	if ( ! ( LCDCONT & 0x01 ) )
960	949	{
961		rectangle r(state->m_lcd.start_x, state->m_lcd.end_x - 1, state->m_lcd.current_line, state->m_lcd.current_line);
962		bitmap.fill(( ! state->m_lcd.gbc_mode ) ? 0 : 32767 , r);
	950	rectangle r(m_lcd.start_x, m_lcd.end_x - 1, m_lcd.current_line, m_lcd.current_line);
	951	bitmap.fill(( ! m_lcd.gbc_mode ) ? 0 : 32767 , r);
963	952	}
964	953	while ( l < 2 )
965	954	{
r20640	r20641
967	956	UINT16  data;
968	957	int i, tile_index;
969	958
970		if ( ! state->m_lcd.layer[l].enabled )
	959	if ( ! m_lcd.layer[l].enabled )
971	960	{
972	961	l++;
973	962	continue;
974	963	}
975		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
976		gbcmap = state->m_lcd.layer[l].gbc_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
977		tiles = ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x08 ) ? state->m_lcd.gbc_chrgen : state->m_lcd.gb_chrgen;
	964	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	965	gbcmap = m_lcd.layer[l].gbc_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	966	tiles = ( gbcmap[ m_lcd.layer[l].xindex ] & 0x08 ) ? m_lcd.gbc_chrgen : m_lcd.gb_chrgen;
978	967
979	968	/* Check for vertical flip */
980		if ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x40 )
	969	if ( gbcmap[ m_lcd.layer[l].xindex ] & 0x40 )
981	970	{
982		tiles += ( ( 7 - ( state->m_lcd.layer[l].bgline & 0x07 ) ) << 1 );
	971	tiles += ( ( 7 - ( m_lcd.layer[l].bgline & 0x07 ) ) << 1 );
983	972	}
984	973	else
985	974	{
986		tiles += ( ( state->m_lcd.layer[l].bgline & 0x07 ) << 1 );
	975	tiles += ( ( m_lcd.layer[l].bgline & 0x07 ) << 1 );
987	976	}
988		xindex = state->m_lcd.start_x;
989		if ( xindex < state->m_lcd.layer[l].xstart )
990		xindex = state->m_lcd.layer[l].xstart;
991		i = state->m_lcd.end_x;
992		if ( i > state->m_lcd.layer[l].xend )
993		i = state->m_lcd.layer[l].xend;
	977	xindex = m_lcd.start_x;
	978	if ( xindex < m_lcd.layer[l].xstart )
	979	xindex = m_lcd.layer[l].xstart;
	980	i = m_lcd.end_x;
	981	if ( i > m_lcd.layer[l].xend )
	982	i = m_lcd.layer[l].xend;
994	983	i = i - xindex;
995	984
996		tile_index = ( map[ state->m_lcd.layer[l].xindex ] ^ state->m_lcd.gb_tile_no_mod ) * 16;
	985	tile_index = ( map[ m_lcd.layer[l].xindex ] ^ m_lcd.gb_tile_no_mod ) * 16;
997	986	data = tiles[ tile_index ] | ( tiles[ tile_index + 1 ] << 8 );
998	987	/* Check for horinzontal flip */
999		if ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x20 )
	988	if ( gbcmap[ m_lcd.layer[l].xindex ] & 0x20 )
1000	989	{
1001		data >>= state->m_lcd.layer[l].xshift;
	990	data >>= m_lcd.layer[l].xshift;
1002	991	}
1003	992	else
1004	993	{
1005		data <<= state->m_lcd.layer[l].xshift;
	994	data <<= m_lcd.layer[l].xshift;
1006	995	}
1007	996
1008	997	while ( i > 0 )
1009	998	{
1010		while ( ( state->m_lcd.layer[l].xshift < 8 ) && i )
	999	while ( ( m_lcd.layer[l].xshift < 8 ) && i )
1011	1000	{
1012	1001	int colour;
1013	1002	/* Check for horinzontal flip */
1014		if ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x20 )
	1003	if ( gbcmap[ m_lcd.layer[l].xindex ] & 0x20 )
1015	1004	{
1016	1005	colour = ( ( data & 0x0100 ) ? 2 : 0 ) | ( ( data & 0x0001 ) ? 1 : 0 );
1017	1006	data >>= 1;
r20640	r20641
1021	1010	colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 );
1022	1011	data <<= 1;
1023	1012	}
1024		gb_plot_pixel( bitmap, xindex, state->m_lcd.current_line, state->m_lcd.cgb_bpal[ ( ! state->m_lcd.gbc_mode ) ? state->m_lcd.gb_bpal[colour] : ( ( ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ) ] );
1025		state->m_lcd.bg_zbuf[ xindex ] = colour + ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x80 );
	1013	gb_plot_pixel( bitmap, xindex, m_lcd.current_line, m_lcd.cgb_bpal[ ( ! m_lcd.gbc_mode ) ? m_lcd.gb_bpal[colour] : ( ( ( gbcmap[ m_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ) ] );
	1014	m_lcd.bg_zbuf[ xindex ] = colour + ( gbcmap[ m_lcd.layer[l].xindex ] & 0x80 );
1026	1015	xindex++;
1027		state->m_lcd.layer[l].xshift++;
	1016	m_lcd.layer[l].xshift++;
1028	1017	i--;
1029	1018	}
1030		if ( state->m_lcd.layer[l].xshift == 8 )
	1019	if ( m_lcd.layer[l].xshift == 8 )
1031	1020	{
1032	1021	/* Take possible changes to SCROLLY into account */
1033	1022	if ( l == 0 )
1034	1023	{
1035		state->m_lcd.layer[0].bgline = ( SCROLLY + state->m_lcd.current_line ) & 0xFF;
1036		map = state->m_lcd.layer[l].bg_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
1037		gbcmap = state->m_lcd.layer[l].gbc_map + ( ( state->m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	1024	m_lcd.layer[0].bgline = ( SCROLLY + m_lcd.current_line ) & 0xFF;
	1025	map = m_lcd.layer[l].bg_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
	1026	gbcmap = m_lcd.layer[l].gbc_map + ( ( m_lcd.layer[l].bgline << 2 ) & 0x3E0 );
1038	1027	}
1039	1028
1040		state->m_lcd.layer[l].xindex = ( state->m_lcd.layer[l].xindex + 1 ) & 31;
1041		state->m_lcd.layer[l].xshift = 0;
1042		tiles = ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x08 ) ? state->m_lcd.gbc_chrgen : state->m_lcd.gb_chrgen;
	1029	m_lcd.layer[l].xindex = ( m_lcd.layer[l].xindex + 1 ) & 31;
	1030	m_lcd.layer[l].xshift = 0;
	1031	tiles = ( gbcmap[ m_lcd.layer[l].xindex ] & 0x08 ) ? m_lcd.gbc_chrgen : m_lcd.gb_chrgen;
1043	1032
1044	1033	/* Check for vertical flip */
1045		if ( gbcmap[ state->m_lcd.layer[l].xindex ] & 0x40 )
	1034	if ( gbcmap[ m_lcd.layer[l].xindex ] & 0x40 )
1046	1035	{
1047		tiles += ( ( 7 - ( state->m_lcd.layer[l].bgline & 0x07 ) ) << 1 );
	1036	tiles += ( ( 7 - ( m_lcd.layer[l].bgline & 0x07 ) ) << 1 );
1048	1037	}
1049	1038	else
1050	1039	{
1051		tiles += ( ( state->m_lcd.layer[l].bgline & 0x07 ) << 1 );
	1040	tiles += ( ( m_lcd.layer[l].bgline & 0x07 ) << 1 );
1052	1041	}
1053		tile_index = ( map[ state->m_lcd.layer[l].xindex ] ^ state->m_lcd.gb_tile_no_mod ) * 16;
	1042	tile_index = ( map[ m_lcd.layer[l].xindex ] ^ m_lcd.gb_tile_no_mod ) * 16;
1054	1043	data = tiles[ tile_index ] | ( tiles[ tile_index + 1 ] << 8 );
1055	1044	}
1056	1045	}
1057	1046	l++;
1058	1047	}
1059		if ( state->m_lcd.end_x == 160 && ( LCDCONT & 0x02 ) )
	1048	if ( m_lcd.end_x == 160 && ( LCDCONT & 0x02 ) )
1060	1049	{
1061		cgb_update_sprites( machine );
	1050	cgb_update_sprites();
1062	1051	}
1063		state->m_lcd.start_x = state->m_lcd.end_x;
	1052	m_lcd.start_x = m_lcd.end_x;
1064	1053	}
1065	1054	}
1066	1055	else
r20640	r20641
1068	1057	if ( ! ( LCDCONT & 0x80 ) )
1069	1058	{
1070	1059	/* Draw an empty line when LCD is disabled */
1071		if ( state->m_lcd.previous_line != state->m_lcd.current_line )
	1060	if ( m_lcd.previous_line != m_lcd.current_line )
1072	1061	{
1073		if ( state->m_lcd.current_line < 144 )
	1062	if ( m_lcd.current_line < 144 )
1074	1063	{
1075		screen_device *screen = machine.first_screen();
	1064	screen_device *screen = machine().first_screen();
1076	1065	const rectangle &r1 = screen->visible_area();
1077		rectangle r(r1.min_x, r1.max_x, state->m_lcd.current_line, state->m_lcd.current_line);
1078		bitmap.fill(( ! state->m_lcd.gbc_mode ) ? 0 : 32767 , r);
	1066	rectangle r(r1.min_x, r1.max_x, m_lcd.current_line, m_lcd.current_line);
	1067	bitmap.fill(( ! m_lcd.gbc_mode ) ? 0 : 32767 , r);
1079	1068	}
1080		state->m_lcd.previous_line = state->m_lcd.current_line;
	1069	m_lcd.previous_line = m_lcd.current_line;
1081	1070	}
1082	1071	}
1083	1072	}
r20640	r20641
1195	1184
1196	1185	TIMER_CALLBACK_MEMBER(gb_state::gb_video_init_vbl)
1197	1186	{
1198		machine().device("maincpu")->execute().set_input_line(VBL_INT, ASSERT_LINE );
	1187	m_maincpu->set_input_line(VBL_INT, ASSERT_LINE );
1199	1188	}
1200	1189
1201	1190	MACHINE_START_MEMBER(gb_state,gb_video)
r20640	r20641
1216	1205	return 0;
1217	1206	}
1218	1207
1219		void gb_video_reset( running_machine &machine, int mode )
	1208	void gb_state::gb_video_reset( int mode )
1220	1209	{
1221		gb_state *state = machine.driver_data<gb_state>();
1222	1210	int i;
1223	1211	int vram_size = 0x2000;
1224		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
1225		emu_timer *old_timer = state->m_lcd.lcd_timer;
	1212	address_space &space = m_maincpu->space(AS_PROGRAM);
	1213	emu_timer *old_timer = m_lcd.lcd_timer;
1226	1214
1227		memset( &state->m_lcd, 0, sizeof(state->m_lcd) );
1228		state->m_lcd.lcd_timer = old_timer;
	1215	memset( &m_lcd, 0, sizeof(m_lcd) );
	1216	m_lcd.lcd_timer = old_timer;
1229	1217
1230	1218	if (mode == GB_VIDEO_CGB) vram_size = 0x4000;
1231	1219
1232	1220	/* free regions if already allocated */
1233		if (state->memregion("gfx1")->base())       machine.memory().region_free(":gfx1");
1234		if (state->memregion("gfx2")->base())       machine.memory().region_free(":gfx2");
	1221	if (memregion("gfx1")->base())       machine().memory().region_free(":gfx1");
	1222	if (memregion("gfx2")->base())       machine().memory().region_free(":gfx2");
1235	1223
1236		state->m_lcd.gb_vram = machine.memory().region_alloc(":gfx1", vram_size, 1, ENDIANNESS_LITTLE );
1237		state->m_lcd.gb_oam = machine.memory().region_alloc(":gfx2", 0x100, 1, ENDIANNESS_LITTLE );
1238		memset( state->m_lcd.gb_vram->base(), 0, vram_size );
	1224	m_lcd.gb_vram = machine().memory().region_alloc(":gfx1", vram_size, 1, ENDIANNESS_LITTLE );
	1225	m_lcd.gb_oam = machine().memory().region_alloc(":gfx2", 0x100, 1, ENDIANNESS_LITTLE );
	1226	memset( m_lcd.gb_vram->base(), 0, vram_size );
1239	1227
1240		state->m_lcd.gb_vram_ptr = state->m_lcd.gb_vram->base();
1241		state->m_lcd.gb_chrgen = state->m_lcd.gb_vram->base();
1242		state->m_lcd.gb_bgdtab = state->m_lcd.gb_vram->base() + 0x1C00;
1243		state->m_lcd.gb_wndtab = state->m_lcd.gb_vram->base() + 0x1C00;
	1228	m_lcd.gb_vram_ptr = m_lcd.gb_vram->base();
	1229	m_lcd.gb_chrgen = m_lcd.gb_vram->base();
	1230	m_lcd.gb_bgdtab = m_lcd.gb_vram->base() + 0x1C00;
	1231	m_lcd.gb_wndtab = m_lcd.gb_vram->base() + 0x1C00;
1244	1232
1245		state->m_lcd.gb_vid_regs[0x06] = 0xFF;
	1233	m_lcd.gb_vid_regs[0x06] = 0xFF;
1246	1234	for( i = 0x0c; i < _NR_GB_VID_REGS; i++ )
1247	1235	{
1248		state->m_lcd.gb_vid_regs[i] = 0xFF;
	1236	m_lcd.gb_vid_regs[i] = 0xFF;
1249	1237	}
1250	1238
1251	1239	LCDSTAT = 0x80;
1252	1240	LCDCONT = 0x00;     /* Video hardware is turned off at boot time */
1253		state->m_lcd.current_line = CURLINE = CMPLINE = 0x00;
	1241	m_lcd.current_line = CURLINE = CMPLINE = 0x00;
1254	1242	SCROLLX = SCROLLY = 0x00;
1255	1243	SPR0PAL = SPR1PAL = 0xFF;
1256	1244	WNDPOSX = WNDPOSY = 0x00;
r20640	r20641
1258	1246	/* Initialize palette arrays */
1259	1247	for( i = 0; i < 4; i++ )
1260	1248	{
1261		state->m_lcd.gb_bpal[i] = state->m_lcd.gb_spal0[i] = state->m_lcd.gb_spal1[i] = i;
	1249	m_lcd.gb_bpal[i] = m_lcd.gb_spal0[i] = m_lcd.gb_spal1[i] = i;
1262	1250	}
1263	1251
1264	1252	switch( mode )
1265	1253	{
1266	1254	case GB_VIDEO_DMG:
1267		state->m_lcd.lcd_timer->adjust(machine.device<cpu_device>("maincpu")->cycles_to_attotime(456));
	1255	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(456));
1268	1256
1269	1257	/* set the scanline update function */
1270		state->update_scanline = gb_update_scanline;
	1258	update_scanline = &gb_state::gb_update_scanline;
1271	1259
1272		memcpy( state->m_lcd.gb_oam->base(), dmg_oam_fingerprint, 0x100 );
	1260	memcpy( m_lcd.gb_oam->base(), dmg_oam_fingerprint, 0x100 );
1273	1261
1274	1262	break;
1275	1263	case GB_VIDEO_MGB:
1276	1264	/* set the scanline update function */
1277		state->update_scanline = gb_update_scanline;
	1265	update_scanline = &gb_state::gb_update_scanline;
1278	1266	/* Initialize part of VRAM. This code must be deleted when we have added the bios dump */
1279	1267	for( i = 1; i < 0x0D; i++ )
1280	1268	{
1281		state->m_lcd.gb_vram->base()[ 0x1903 + i ] = i;
1282		state->m_lcd.gb_vram->base()[ 0x1923 + i ] = i + 0x0C;
	1269	m_lcd.gb_vram->base()[ 0x1903 + i ] = i;
	1270	m_lcd.gb_vram->base()[ 0x1923 + i ] = i + 0x0C;
1283	1271	}
1284		state->m_lcd.gb_vram->base()[ 0x1910 ] = 0x19;
	1272	m_lcd.gb_vram->base()[ 0x1910 ] = 0x19;
1285	1273
1286	1274
1287		memcpy( state->m_lcd.gb_oam->base(), mgb_oam_fingerprint, 0x100 );
	1275	memcpy( m_lcd.gb_oam->base(), mgb_oam_fingerprint, 0x100 );
1288	1276
1289	1277	/* Make sure the VBlank interrupt is set when the first instruction gets executed */
1290		machine.scheduler().timer_set(machine.device<cpu_device>("maincpu")->cycles_to_attotime(1), timer_expired_delegate(FUNC(gb_state::gb_video_init_vbl),state));
	1278	machine().scheduler().timer_set(m_maincpu->cycles_to_attotime(1), timer_expired_delegate(FUNC(gb_state::gb_video_init_vbl),this));
1291	1279
1292	1280	/* Initialize some video registers */
1293		state->gb_video_w( space, 0x0, 0x91 );    /* LCDCONT */
1294		state->gb_video_w( space, 0x7, 0xFC );    /* BGRDPAL */
1295		state->gb_video_w( space, 0x8, 0xFC );    /* SPR0PAL */
1296		state->gb_video_w( space, 0x9, 0xFC );    /* SPR1PAL */
	1281	gb_video_w( space, 0x0, 0x91 );    /* LCDCONT */
	1282	gb_video_w( space, 0x7, 0xFC );    /* BGRDPAL */
	1283	gb_video_w( space, 0x8, 0xFC );    /* SPR0PAL */
	1284	gb_video_w( space, 0x9, 0xFC );    /* SPR1PAL */
1297	1285
1298		CURLINE = state->m_lcd.current_line = 0;
	1286	CURLINE = m_lcd.current_line = 0;
1299	1287	LCDSTAT = ( LCDSTAT & 0xF8 ) | 0x05;
1300		state->m_lcd.mode = 1;
1301		state->m_lcd.lcd_timer->adjust(machine.device<cpu_device>("maincpu")->cycles_to_attotime(60), GB_LCD_STATE_LY00_M0);
	1288	m_lcd.mode = 1;
	1289	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(60), GB_LCD_STATE_LY00_M0);
1302	1290
1303	1291	break;
1304	1292	case GB_VIDEO_SGB:
1305	1293	/* set the scanline update function */
1306		state->update_scanline = sgb_update_scanline;
	1294	update_scanline = &gb_state::sgb_update_scanline;
1307	1295
1308	1296	break;
1309	1297
1310	1298	case GB_VIDEO_CGB:
1311	1299	/* set the scanline update function */
1312		state->update_scanline = cgb_update_scanline;
	1300	update_scanline = &gb_state::cgb_update_scanline;
1313	1301
1314		memcpy( state->m_lcd.gb_oam->base(), cgb_oam_fingerprint, 0x100 );
	1302	memcpy( m_lcd.gb_oam->base(), cgb_oam_fingerprint, 0x100 );
1315	1303
1316		state->m_lcd.gb_chrgen = state->m_lcd.gb_vram->base();
1317		state->m_lcd.gbc_chrgen = state->m_lcd.gb_vram->base() + 0x2000;
1318		state->m_lcd.gb_bgdtab = state->m_lcd.gb_wndtab = state->m_lcd.gb_vram->base() + 0x1C00;
1319		state->m_lcd.gbc_bgdtab = state->m_lcd.gbc_wndtab = state->m_lcd.gb_vram->base() + 0x3C00;
	1304	m_lcd.gb_chrgen = m_lcd.gb_vram->base();
	1305	m_lcd.gbc_chrgen = m_lcd.gb_vram->base() + 0x2000;
	1306	m_lcd.gb_bgdtab = m_lcd.gb_wndtab = m_lcd.gb_vram->base() + 0x1C00;
	1307	m_lcd.gbc_bgdtab = m_lcd.gbc_wndtab = m_lcd.gb_vram->base() + 0x3C00;
1320	1308
1321	1309	/* HDMA disabled */
1322		state->m_lcd.hdma_enabled = 0;
1323		state->m_lcd.hdma_possible = 0;
	1310	m_lcd.hdma_enabled = 0;
	1311	m_lcd.hdma_possible = 0;
1324	1312
1325		state->m_lcd.gbc_mode = 1;
	1313	m_lcd.gbc_mode = 1;
1326	1314	break;
1327	1315	}
1328	1316	}
1329	1317
1330		static void gbc_hdma(running_machine &machine, UINT16 length)
	1318
	1319	void gb_state::gbc_hdma(UINT16 length)
1331	1320	{
1332		gb_state *state = machine.driver_data<gb_state>();
1333	1321	UINT16 src, dst;
1334		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1322	address_space &space = m_maincpu->space(AS_PROGRAM);
1335	1323
1336	1324	src = ((UINT16)HDMA1 << 8) | (HDMA2 & 0xF0);
1337	1325	dst = ((UINT16)(HDMA3 & 0x1F) << 8) | (HDMA4 & 0xF0);
r20640	r20641
1349	1337	if( (HDMA5 & 0x7f) == 0x7f )
1350	1338	{
1351	1339	HDMA5 = 0xff;
1352		state->m_lcd.hdma_enabled = 0;
	1340	m_lcd.hdma_enabled = 0;
1353	1341	}
1354	1342	}
1355	1343
1356		static void gb_increment_scanline( gb_state *state )
	1344
	1345	void gb_state::gb_increment_scanline()
1357	1346	{
1358		state->m_lcd.current_line = ( state->m_lcd.current_line + 1 ) % 154;
	1347	m_lcd.current_line = ( m_lcd.current_line + 1 ) % 154;
1359	1348	if ( LCDCONT & 0x80 )
1360	1349	{
1361		CURLINE = state->m_lcd.current_line;
	1350	CURLINE = m_lcd.current_line;
1362	1351	}
1363		if ( state->m_lcd.current_line == 0 )
	1352	if ( m_lcd.current_line == 0 )
1364	1353	{
1365		state->m_lcd.window_lines_drawn = 0;
	1354	m_lcd.window_lines_drawn = 0;
1366	1355	}
1367	1356	}
1368	1357
1369	1358	TIMER_CALLBACK_MEMBER(gb_state::gb_lcd_timer_proc)
1370	1359	{
1371		gb_state *state = machine().driver_data<gb_state>();
1372	1360	static const int sprite_cycles[] = { 0, 8, 20, 32, 44, 52, 64, 76, 88, 96, 108 };
1373	1361
1374	1362	m_lcd.state = param;
r20640	r20641
1386	1374	if ( ! m_lcd.line_irq && ! m_lcd.delayed_line_irq )
1387	1375	{
1388	1376	m_lcd.mode_irq = 1;
1389		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1377	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1390	1378	}
1391	1379	}
1392	1380	else
r20640	r20641
1394	1382	m_lcd.mode_irq = 0;
1395	1383	}
1396	1384	}
1397		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0);
	1385	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0);
1398	1386	break;
1399	1387	case GB_LCD_STATE_LYXX_M0:      /* Switch to mode 0 */
1400	1388	/* update current scanline */
1401		(*update_scanline)( machine() );
	1389	(this->*update_scanline)();
1402	1390	/* Increment the number of window lines drawn if enabled */
1403	1391	if ( m_lcd.layer[1].enabled )
1404	1392	{
r20640	r20641
1419	1407	if ( ( SCROLLX & 0x03 ) == 0x03 )
1420	1408	{
1421	1409	m_lcd.scrollx_adjust += 4;
1422		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_SCX3);
	1410	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_SCX3);
1423	1411	break;
1424	1412	}
1425	1413	case GB_LCD_STATE_LYXX_M0_SCX3:
r20640	r20641
1427	1415	if ( ! m_lcd.mode_irq && ( LCDSTAT & 0x08 ) &&
1428	1416	( ( ! m_lcd.line_irq && m_lcd.delayed_line_irq ) || ! ( LCDSTAT & 0x40 ) ) )
1429	1417	{
1430		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1418	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1431	1419	}
1432		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(196 - m_lcd.scrollx_adjust - m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_M0_PRE_INC);
	1420	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(196 - m_lcd.scrollx_adjust - m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_M0_PRE_INC);
1433	1421	break;
1434	1422	case GB_LCD_STATE_LYXX_M0_PRE_INC:  /* Just before incrementing the line counter go to mode 2 internally */
1435	1423	if ( CURLINE < 143 )
r20640	r20641
1443	1431	if ( ! m_lcd.line_irq && ! m_lcd.delayed_line_irq )
1444	1432	{
1445	1433	m_lcd.mode_irq = 1;
1446		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1434	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1447	1435	}
1448	1436	}
1449	1437	else
r20640	r20641
1452	1440	}
1453	1441	}
1454	1442	}
1455		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_INC);
	1443	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_INC);
1456	1444	break;
1457	1445	case GB_LCD_STATE_LYXX_M0_INC:  /* Increment LY, stay in M0 for 4 more cycles */
1458		gb_increment_scanline(this);
	1446	gb_increment_scanline();
1459	1447	m_lcd.delayed_line_irq = m_lcd.line_irq;
1460	1448	m_lcd.triggering_line_irq = ( ( CMPLINE == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1461	1449	m_lcd.line_irq = 0;
1462	1450	if ( ! m_lcd.mode_irq && ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq && ! m_lcd.triggering_mode_irq )
1463	1451	{
1464	1452	m_lcd.line_irq = m_lcd.triggering_line_irq;
1465		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1453	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1466	1454	}
1467	1455	/* Reset LY==LYC STAT bit */
1468	1456	LCDSTAT &= 0xFB;
1469	1457	/* Check if we're going into VBlank next */
1470	1458	if ( CURLINE == 144 )
1471	1459	{
1472		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
	1460	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
1473	1461	}
1474	1462	else
1475	1463	{
r20640	r20641
1480	1468	( ( ! m_lcd.triggering_line_irq && ! m_lcd.delayed_line_irq ) || ! ( LCDSTAT & 0x40 ) ) )
1481	1469	{
1482	1470	m_lcd.mode_irq = 1;
1483		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1471	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1484	1472	}
1485		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M2);
	1473	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M2);
1486	1474	}
1487	1475	break;
1488	1476	case GB_LCD_STATE_LY00_M2:      /* Switch to mode 2 on line #0 */
r20640	r20641
1493	1481	/* Generate lcd interrupt if requested */
1494	1482	if ( ( LCDSTAT & 0x20 ) && ! m_lcd.line_irq )
1495	1483	{
1496		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1484	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1497	1485	}
1498	1486	/* Check for regular compensation of x-scroll register */
1499	1487	m_lcd.scrollx_adjust = ( SCROLLX & 0x04 ) ? 4 : 0;
1500	1488	/* Mode 2 lasts approximately 80 clock cycles */
1501		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
	1489	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
1502	1490	break;
1503	1491	case GB_LCD_STATE_LYXX_M2:      /* Switch to mode 2 */
1504	1492	/* Update STAT register to the correct state */
r20640	r20641
1508	1496	if ( ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq && ! ( LCDSTAT & 0x20 ) ) ||
1509	1497	( ! m_lcd.mode_irq && ! m_lcd.line_irq && ! m_lcd.delayed_line_irq && m_lcd.triggering_mode_irq ) )
1510	1498	{
1511		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1499	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1512	1500	}
1513	1501	m_lcd.line_irq = m_lcd.triggering_line_irq;
1514	1502	m_lcd.triggering_mode_irq = 0;
r20640	r20641
1520	1508	/* Check for regular compensation of x-scroll register */
1521	1509	m_lcd.scrollx_adjust = ( SCROLLX & 0x04 ) ? 4 : 0;
1522	1510	/* Mode 2 last for approximately 80 clock cycles */
1523		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
	1511	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
1524	1512	break;
1525	1513	case GB_LCD_STATE_LYXX_M3:      /* Switch to mode 3 */
1526		gb_select_sprites(this);
	1514	gb_select_sprites();
1527	1515	m_lcd.sprite_cycles = sprite_cycles[ m_lcd.sprCount ];
1528	1516	/* Set Mode 3 lcdstate */
1529	1517	m_lcd.mode = 3;
r20640	r20641
1531	1519	m_lcd.vram_locked = LOCKED;
1532	1520	/* Check for compensations of x-scroll register */
1533	1521	/* Mode 3 lasts for approximately 172+cycles needed to handle sprites clock cycles */
1534		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(168 + m_lcd.scrollx_adjust + m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_PRE_M0);
	1522	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(168 + m_lcd.scrollx_adjust + m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_PRE_M0);
1535	1523	m_lcd.start_x = -1;
1536	1524	break;
1537	1525	case GB_LCD_STATE_LY9X_M1:      /* Switch to or stay in mode 1 */
1538	1526	if ( CURLINE == 144 )
1539	1527	{
1540	1528	/* Trigger VBlank interrupt */
1541		machine().device("maincpu")->execute().set_input_line(VBL_INT, ASSERT_LINE );
	1529	m_maincpu->set_input_line(VBL_INT, ASSERT_LINE );
1542	1530	/* Set VBlank lcdstate */
1543	1531	m_lcd.mode = 1;
1544	1532	LCDSTAT = (LCDSTAT & 0xFC) | 0x01;
1545	1533	/* Trigger LCD interrupt if requested */
1546	1534	if ( LCDSTAT & 0x10 )
1547	1535	{
1548		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1536	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1549	1537	}
1550	1538	}
1551	1539	/* Check if LY==LYC STAT bit should be set */
r20640	r20641
1555	1543	}
1556	1544	if ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1557	1545	{
1558		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1546	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1559	1547	}
1560		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(452), GB_LCD_STATE_LY9X_M1_INC);
	1548	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(452), GB_LCD_STATE_LY9X_M1_INC);
1561	1549	break;
1562	1550	case GB_LCD_STATE_LY9X_M1_INC:      /* Increment scanline counter */
1563		gb_increment_scanline(this);
	1551	gb_increment_scanline();
1564	1552	m_lcd.delayed_line_irq = m_lcd.line_irq;
1565	1553	m_lcd.triggering_line_irq = ( ( CMPLINE == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1566	1554	m_lcd.line_irq = 0;
1567	1555	if ( ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1568	1556	{
1569	1557	m_lcd.line_irq = m_lcd.triggering_line_irq;
1570		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1558	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1571	1559	}
1572	1560	/* Reset LY==LYC STAT bit */
1573	1561	LCDSTAT &= 0xFB;
1574	1562	if ( m_lcd.current_line == 153 )
1575	1563	{
1576		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1);
	1564	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1);
1577	1565	}
1578	1566	else
1579	1567	{
1580		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
	1568	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
1581	1569	}
1582	1570	break;
1583	1571	case GB_LCD_STATE_LY00_M1:      /* we stay in VBlank but current line counter should already be incremented */
r20640	r20641
1586	1574	{
1587	1575	if ( m_lcd.triggering_line_irq )
1588	1576	{
1589		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1577	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1590	1578	}
1591	1579	}
1592	1580	m_lcd.delayed_line_irq = m_lcd.delayed_line_irq | m_lcd.line_irq;
r20640	r20641
1594	1582	{
1595	1583	LCDSTAT |= 0x04;
1596	1584	}
1597		gb_increment_scanline(this);
	1585	gb_increment_scanline();
1598	1586	m_lcd.triggering_line_irq = ( ( CMPLINE == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1599	1587	m_lcd.line_irq = 0;
1600	1588	LCDSTAT &= 0xFB;
1601		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4/*8*/), GB_LCD_STATE_LY00_M1_1);
	1589	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4/*8*/), GB_LCD_STATE_LY00_M1_1);
1602	1590	break;
1603	1591	case GB_LCD_STATE_LY00_M1_1:
1604	1592	if ( ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1605	1593	{
1606	1594	m_lcd.line_irq = m_lcd.triggering_line_irq;
1607		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1595	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1608	1596	}
1609		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_2);
	1597	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_2);
1610	1598	break;
1611	1599	case GB_LCD_STATE_LY00_M1_2:    /* Rest of line #0 during VBlank */
1612	1600	if ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1613	1601	{
1614	1602	m_lcd.line_irq = m_lcd.triggering_line_irq;
1615		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1603	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1616	1604	}
1617	1605	if ( CURLINE == CMPLINE )
1618	1606	{
1619	1607	LCDSTAT |= 0x04;
1620	1608	}
1621		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(444), GB_LCD_STATE_LY00_M0);
	1609	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(444), GB_LCD_STATE_LY00_M0);
1622	1610	break;
1623	1611	case GB_LCD_STATE_LY00_M0:      /* The STAT register seems to go to 0 for about 4 cycles */
1624	1612	/* Set Mode 0 lcdstat */
1625	1613	m_lcd.mode = 0;
1626	1614	LCDSTAT = ( LCDSTAT & 0xFC );
1627		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M2);
	1615	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M2);
1628	1616	break;
1629	1617	}
1630	1618	}
1631	1619	else
1632	1620	{
1633		gb_increment_scanline(this);
	1621	gb_increment_scanline();
1634	1622	if ( m_lcd.current_line < 144 )
1635	1623	{
1636		(*update_scanline)( machine() );
	1624	(this->*update_scanline)();
1637	1625	}
1638		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(456));
	1626	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(456));
1639	1627	}
1640	1628	}
1641	1629
1642	1630	TIMER_CALLBACK_MEMBER(gb_state::gbc_lcd_timer_proc)
1643	1631	{
1644		gb_state *state = machine().driver_data<gb_state>();
1645	1632	static const int sprite_cycles[] = { 0, 8, 20, 32, 44, 52, 64, 76, 88, 96, 108 };
1646	1633
1647	1634	m_lcd.state = param;
r20640	r20641
1659	1646	if ( ! m_lcd.line_irq && ! m_lcd.delayed_line_irq )
1660	1647	{
1661	1648	m_lcd.mode_irq = 1;
1662		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1649	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1663	1650	}
1664	1651	}
1665	1652	else
r20640	r20641
1667	1654	m_lcd.mode_irq = 0;
1668	1655	}
1669	1656	}
1670		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0);
	1657	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0);
1671	1658	break;
1672	1659	case GB_LCD_STATE_LYXX_M0:      /* Switch to mode 0 */
1673	1660	/* update current scanline */
1674		(*update_scanline)( machine() );
	1661	(this->*update_scanline)();
1675	1662	/* Increment the number of window lines drawn if enabled */
1676	1663	if ( m_lcd.layer[1].enabled )
1677	1664	{
r20640	r20641
1693	1680	if ( ( SCROLLX & 0x03 ) == 0x03 )
1694	1681	{
1695	1682	m_lcd.scrollx_adjust += 4;
1696		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_SCX3);
	1683	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_SCX3);
1697	1684	break;
1698	1685	}
1699	1686	case GB_LCD_STATE_LYXX_M0_SCX3:
r20640	r20641
1701	1688	if ( ! m_lcd.mode_irq && m_lcd.triggering_mode_irq &&
1702	1689	( ( ! m_lcd.line_irq && m_lcd.delayed_line_irq ) || ! ( LCDSTAT & 0x40 ) ) )
1703	1690	{
1704		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1691	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1705	1692	m_lcd.triggering_mode_irq = 0;
1706	1693	}
1707	1694	if ( ( SCROLLX & 0x03 ) == 0x03 )
1708	1695	{
1709	1696	m_lcd.pal_locked = UNLOCKED;
1710	1697	}
1711		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_GBC_PAL);
	1698	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_GBC_PAL);
1712	1699	break;
1713	1700	case GB_LCD_STATE_LYXX_M0_GBC_PAL:
1714	1701	m_lcd.pal_locked = UNLOCKED;
1715	1702	/* Check for HBLANK DMA */
1716	1703	if( m_lcd.hdma_enabled )
1717	1704	{
1718		gbc_hdma(machine(), 0x10);
	1705	gbc_hdma(0x10);
1719	1706	//              cpunum_set_reg( 0, LR35902_DMA_CYCLES, 36 );
1720	1707	}
1721	1708	else
1722	1709	{
1723	1710	m_lcd.hdma_possible = 1;
1724	1711	}
1725		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(192 - m_lcd.scrollx_adjust - m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_M0_PRE_INC);
	1712	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(192 - m_lcd.scrollx_adjust - m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_M0_PRE_INC);
1726	1713	break;
1727	1714	case GB_LCD_STATE_LYXX_M0_PRE_INC:  /* Just before incrementing the line counter go to mode 2 internally */
1728	1715	m_lcd.cmp_line = CMPLINE;
r20640	r20641
1736	1723	if ( ! m_lcd.line_irq && ! m_lcd.delayed_line_irq )
1737	1724	{
1738	1725	m_lcd.mode_irq = 1;
1739		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1726	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1740	1727	}
1741	1728	}
1742	1729	else
r20640	r20641
1745	1732	}
1746	1733	}
1747	1734	}
1748		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_INC);
	1735	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M0_INC);
1749	1736	break;
1750	1737	case GB_LCD_STATE_LYXX_M0_INC:  /* Increment LY, stay in M0 for 4 more cycles */
1751		gb_increment_scanline(this);
	1738	gb_increment_scanline();
1752	1739	m_lcd.delayed_line_irq = m_lcd.line_irq;
1753	1740	m_lcd.triggering_line_irq = ( ( m_lcd.cmp_line == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1754	1741	m_lcd.line_irq = 0;
1755	1742	if ( ! m_lcd.mode_irq && ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq && ! ( LCDSTAT & 0x20 ) )
1756	1743	{
1757	1744	m_lcd.line_irq = m_lcd.triggering_line_irq;
1758		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1745	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1759	1746	}
1760	1747	m_lcd.hdma_possible = 0;
1761	1748	/* Check if we're going into VBlank next */
1762	1749	if ( CURLINE == 144 )
1763	1750	{
1764		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
	1751	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
1765	1752	}
1766	1753	else
1767	1754	{
r20640	r20641
1772	1759	( ( ! m_lcd.triggering_line_irq && ! m_lcd.delayed_line_irq ) || ! ( LCDSTAT & 0x40 ) ) )
1773	1760	{
1774	1761	m_lcd.mode_irq = 1;
1775		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1762	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1776	1763	}
1777		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M2);
	1764	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LYXX_M2);
1778	1765	}
1779	1766	break;
1780	1767	case GB_LCD_STATE_LY00_M2:      /* Switch to mode 2 on line #0 */
r20640	r20641
1785	1772	/* Generate lcd interrupt if requested */
1786	1773	if ( ( LCDSTAT & 0x20 ) && ! m_lcd.line_irq )
1787	1774	{
1788		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1775	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1789	1776	}
1790	1777	/* Check for regular compensation of x-scroll register */
1791	1778	m_lcd.scrollx_adjust = ( SCROLLX & 0x04 ) ? 4 : 0;
1792	1779	/* Mode 2 lasts approximately 80 clock cycles */
1793		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
	1780	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
1794	1781	break;
1795	1782	case GB_LCD_STATE_LYXX_M2:      /* Switch to mode 2 */
1796	1783	/* Update STAT register to the correct state */
r20640	r20641
1800	1787	if ( ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq && ! ( LCDSTAT & 0x20 ) ) ||
1801	1788	( !m_lcd.mode_irq && ! m_lcd.line_irq && ! m_lcd.delayed_line_irq && ( LCDSTAT & 0x20 ) ) )
1802	1789	{
1803		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1790	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1804	1791	}
1805	1792	m_lcd.line_irq = m_lcd.triggering_line_irq;
1806	1793	/* Check if LY==LYC STAT bit should be set */
r20640	r20641
1815	1802	/* Check for regular compensation of x-scroll register */
1816	1803	m_lcd.scrollx_adjust = ( SCROLLX & 0x04 ) ? 4 : 0;
1817	1804	/* Mode 2 last for approximately 80 clock cycles */
1818		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
	1805	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
1819	1806	break;
1820	1807	case GB_LCD_STATE_LYXX_M3:      /* Switch to mode 3 */
1821		gb_select_sprites(this);
	1808	gb_select_sprites();
1822	1809	m_lcd.sprite_cycles = sprite_cycles[ m_lcd.sprCount ];
1823	1810	/* Set Mode 3 lcdstate */
1824	1811	m_lcd.mode = 3;
r20640	r20641
1827	1814	m_lcd.pal_locked = LOCKED;
1828	1815	/* Check for compensations of x-scroll register */
1829	1816	/* Mode 3 lasts for approximately 172+cycles needed to handle sprites clock cycles */
1830		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(168 + m_lcd.scrollx_adjust + m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_PRE_M0);
	1817	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(168 + m_lcd.scrollx_adjust + m_lcd.sprite_cycles), GB_LCD_STATE_LYXX_PRE_M0);
1831	1818	m_lcd.start_x = -1;
1832	1819	break;
1833	1820	case GB_LCD_STATE_LY9X_M1:      /* Switch to or stay in mode 1 */
1834	1821	if ( CURLINE == 144 )
1835	1822	{
1836	1823	/* Trigger VBlank interrupt */
1837		machine().device("maincpu")->execute().set_input_line(VBL_INT, ASSERT_LINE );
	1824	m_maincpu->set_input_line(VBL_INT, ASSERT_LINE );
1838	1825	/* Set VBlank lcdstate */
1839	1826	m_lcd.mode = 1;
1840	1827	LCDSTAT = (LCDSTAT & 0xFC) | 0x01;
1841	1828	/* Trigger LCD interrupt if requested */
1842	1829	if ( LCDSTAT & 0x10 )
1843	1830	{
1844		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1831	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1845	1832	}
1846	1833	}
1847	1834	/* Check if LY==LYC STAT bit should be set */
r20640	r20641
1855	1842	}
1856	1843	if ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1857	1844	{
1858		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1845	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1859	1846	}
1860		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(452), GB_LCD_STATE_LY9X_M1_INC);
	1847	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(452), GB_LCD_STATE_LY9X_M1_INC);
1861	1848	break;
1862	1849	case GB_LCD_STATE_LY9X_M1_INC:      /* Increment scanline counter */
1863		gb_increment_scanline(this);
	1850	gb_increment_scanline();
1864	1851	m_lcd.delayed_line_irq = m_lcd.line_irq;
1865	1852	m_lcd.triggering_line_irq = ( ( CMPLINE == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1866	1853	m_lcd.line_irq = 0;
1867	1854	if ( ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1868	1855	{
1869	1856	m_lcd.line_irq = m_lcd.triggering_line_irq;
1870		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1857	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1871	1858	}
1872	1859	if ( m_lcd.current_line == 153 )
1873	1860	{
1874		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1);
	1861	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1);
1875	1862	}
1876	1863	else
1877	1864	{
1878		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
	1865	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY9X_M1);
1879	1866	}
1880	1867	break;
1881	1868	case GB_LCD_STATE_LY00_M1:      /* we stay in VBlank but current line counter should already be incremented */
r20640	r20641
1884	1871	{
1885	1872	if ( m_lcd.triggering_line_irq )
1886	1873	{
1887		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1874	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1888	1875	}
1889	1876	}
1890	1877	m_lcd.delayed_line_irq = m_lcd.delayed_line_irq | m_lcd.line_irq;
r20640	r20641
1896	1883	{
1897	1884	LCDSTAT &= ~0x04;
1898	1885	}
1899		gb_increment_scanline(this);
	1886	gb_increment_scanline();
1900	1887	m_lcd.triggering_line_irq = ( ( CMPLINE == CURLINE ) && ( LCDSTAT & 0x40 ) ) ? 1 : 0;
1901	1888	m_lcd.line_irq = 0;
1902	1889	LCDSTAT &= 0xFB;
1903		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_1);
	1890	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_1);
1904	1891	break;
1905	1892	case GB_LCD_STATE_LY00_M1_1:
1906	1893	if ( ! m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1907	1894	{
1908	1895	m_lcd.line_irq = m_lcd.triggering_line_irq;
1909		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1896	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1910	1897	}
1911		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_2);
	1898	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M1_2);
1912	1899	break;
1913	1900	case GB_LCD_STATE_LY00_M1_2:    /* Rest of line #0 during VBlank */
1914	1901	if ( m_lcd.delayed_line_irq && m_lcd.triggering_line_irq )
1915	1902	{
1916	1903	m_lcd.line_irq = m_lcd.triggering_line_irq;
1917		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1904	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
1918	1905	}
1919	1906	if ( CURLINE == CMPLINE )
1920	1907	{
r20640	r20641
1924	1911	{
1925	1912	LCDSTAT &= ~0x04;
1926	1913	}
1927		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(444), GB_LCD_STATE_LY00_M0);
	1914	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(444), GB_LCD_STATE_LY00_M0);
1928	1915	break;
1929	1916	case GB_LCD_STATE_LY00_M0:      /* The STAT register seems to go to 0 for about 4 cycles */
1930	1917	/* Set Mode 0 lcdstat */
1931	1918	m_lcd.mode = 0;
1932		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(4), GB_LCD_STATE_LY00_M2);
	1919	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(4), GB_LCD_STATE_LY00_M2);
1933	1920	break;
1934	1921	}
1935	1922	}
1936	1923	else
1937	1924	{
1938		gb_increment_scanline(this);
	1925	gb_increment_scanline();
1939	1926	if ( m_lcd.current_line < 144 )
1940	1927	{
1941		(*update_scanline)( machine() );
	1928	(this->*update_scanline)();
1942	1929	}
1943		m_lcd.lcd_timer->adjust(machine().device<cpu_device>("maincpu")->cycles_to_attotime(456));
	1930	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(456));
1944	1931	}
1945	1932	}
1946	1933
1947		static void gb_lcd_switch_on( running_machine &machine )
	1934
	1935	void gb_state::gb_lcd_switch_on()
1948	1936	{
1949		gb_state *state = machine.driver_data<gb_state>();
1950		state->m_lcd.current_line = 0;
1951		state->m_lcd.previous_line = 153;
1952		state->m_lcd.window_lines_drawn = 0;
1953		state->m_lcd.line_irq = 0;
1954		state->m_lcd.delayed_line_irq = 0;
1955		state->m_lcd.mode = 0;
1956		state->m_lcd.oam_locked = LOCKED;   /* TODO: Investigate whether this OAM locking is correct. */
	1937	m_lcd.current_line = 0;
	1938	m_lcd.previous_line = 153;
	1939	m_lcd.window_lines_drawn = 0;
	1940	m_lcd.line_irq = 0;
	1941	m_lcd.delayed_line_irq = 0;
	1942	m_lcd.mode = 0;
	1943	m_lcd.oam_locked = LOCKED;   /* TODO: Investigate whether this OAM locking is correct. */
1957	1944	/* Check for LY=LYC coincidence */
1958	1945	if ( CURLINE == CMPLINE )
1959	1946	{
r20640	r20641
1961	1948	/* Generate lcd interrupt if requested */
1962	1949	if ( LCDSTAT & 0x40 )
1963	1950	{
1964		machine.device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	1951	m_maincpu->set_input_line( LCD_INT, ASSERT_LINE );
1965	1952	}
1966	1953	}
1967		state->m_lcd.state = GB_LCD_STATE_LY00_M2;
1968		state->m_lcd.lcd_timer->adjust(machine.device<cpu_device>("maincpu")->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
	1954	m_lcd.state = GB_LCD_STATE_LY00_M2;
	1955	m_lcd.lcd_timer->adjust(m_maincpu->cycles_to_attotime(80), GB_LCD_STATE_LYXX_M3);
1969	1956	}
1970	1957
1971	1958	READ8_MEMBER(gb_state::gb_video_r)
r20640	r20641
2003	1990
2004	1991	WRITE8_MEMBER(gb_state::gb_video_w)
2005	1992	{
2006		gb_state *state = machine().driver_data<gb_state>();
2007	1993	switch (offset)
2008	1994	{
2009	1995	case 0x00:                      /* LCDC - LCD Control */
r20640	r20641
2022	2008	/* If LCD is being switched on */
2023	2009	if ( !( LCDCONT & 0x80 ) && ( data & 0x80 ) )
2024	2010	{
2025		gb_lcd_switch_on(machine());
	2011	gb_lcd_switch_on();
2026	2012	}
2027	2013	break;
2028	2014	case 0x01:                      /* STAT - LCD Status */
r20640	r20641
2056	2042	( ( LCDSTAT & 0x60 ) == 0x20 && ( data & 0x40 ) )
2057	2043	) )
2058	2044	{
2059		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2045	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2060	2046	}
2061	2047	/*
2062	2048	- 0x20 -> 0x08/0x18/0x28/0x48 (mode 0, after m2int) - trigger
r20640	r20641
2065	2051	*/
2066	2052	if ( m_lcd.mode_irq && m_lcd.mode == 0 )
2067	2053	{
2068		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2054	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2069	2055	}
2070	2056	}
2071	2057	break;
r20640	r20641
2082	2068	/* Generate lcd interrupt if requested */
2083	2069	if ( LCDSTAT & 0x40 )
2084	2070	{
2085		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2071	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2086	2072	}
2087	2073	}
2088	2074	}
r20640	r20641
2102	2088	}
2103	2089	return;
2104	2090	case 0x07:                      /* BGP - Background Palette */
2105		(*update_scanline)(machine());
	2091	(this->*update_scanline)();
2106	2092	m_lcd.gb_bpal[0] = data & 0x3;
2107	2093	m_lcd.gb_bpal[1] = (data & 0xC) >> 2;
2108	2094	m_lcd.gb_bpal[2] = (data & 0x30) >> 4;
2109	2095	m_lcd.gb_bpal[3] = (data & 0xC0) >> 6;
2110	2096	break;
2111	2097	case 0x08:                      /* OBP0 - Object Palette 0 */
2112		//      (*update_scanline)( machine );
	2098	//      (this->*update_scanline)();
2113	2099	m_lcd.gb_spal0[0] = data & 0x3;
2114	2100	m_lcd.gb_spal0[1] = (data & 0xC) >> 2;
2115	2101	m_lcd.gb_spal0[2] = (data & 0x30) >> 4;
2116	2102	m_lcd.gb_spal0[3] = (data & 0xC0) >> 6;
2117	2103	break;
2118	2104	case 0x09:                      /* OBP1 - Object Palette 1 */
2119		//      (*update_scanline)( machine );
	2105	//      (this->*update_scanline)();
2120	2106	m_lcd.gb_spal1[0] = data & 0x3;
2121	2107	m_lcd.gb_spal1[1] = (data & 0xC) >> 2;
2122	2108	m_lcd.gb_spal1[2] = (data & 0x30) >> 4;
r20640	r20641
2124	2110	break;
2125	2111	case 0x02:                      /* SCY - Scroll Y */
2126	2112	case 0x03:                      /* SCX - Scroll X */
2127		(*update_scanline)(machine());
	2113	(this->*update_scanline)();
2128	2114	case 0x0A:                      /* WY - Window Y position */
2129	2115	case 0x0B:                      /* WX - Window X position */
2130	2116	break;
r20640	r20641
2156	2142
2157	2143	WRITE8_MEMBER(gb_state::gbc_video_w)
2158	2144	{
2159		gb_state *state = machine().driver_data<gb_state>();
2160	2145	switch( offset )
2161	2146	{
2162	2147	case 0x00:      /* LCDC - LCD Control */
r20640	r20641
2179	2164	/* If LCD is being switched on */
2180	2165	if ( !( LCDCONT & 0x80 ) && ( data & 0x80 ) )
2181	2166	{
2182		gb_lcd_switch_on(machine());
	2167	gb_lcd_switch_on();
2183	2168	}
2184	2169	break;
2185	2170	case 0x01:      /* STAT - LCD Status */
r20640	r20641
2191	2176	*/
2192	2177	if ( m_lcd.mode_irq && m_lcd.mode == 0 && ( LCDSTAT & 0x28 ) == 0x20 && ( data & 0x08 ) )
2193	2178	{
2194		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2179	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2195	2180	}
2196	2181	/* Check if line irqs are being disabled */
2197	2182	if ( ! ( data & 0x40 ) )
r20640	r20641
2204	2189	if ( CMPLINE == CURLINE )
2205	2190	{
2206	2191	m_lcd.line_irq = 1;
2207		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2192	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2208	2193	}
2209	2194	}
2210	2195	}
r20640	r20641
2219	2204	/* Generate lcd interrupt if requested */
2220	2205	if ( LCDSTAT & 0x40 )
2221	2206	{
2222		machine().device("maincpu")->execute().set_input_line(LCD_INT, ASSERT_LINE );
	2207	m_maincpu->set_input_line(LCD_INT, ASSERT_LINE );
2223	2208	}
2224	2209	}
2225	2210	else
r20640	r20641
2231	2216	}
2232	2217	break;
2233	2218	case 0x07:      /* BGP - GB background palette */
2234		(*update_scanline)(machine());
	2219	(this->*update_scanline)();
2235	2220	m_lcd.gb_bpal[0] = data & 0x3;
2236	2221	m_lcd.gb_bpal[1] = (data & 0xC) >> 2;
2237	2222	m_lcd.gb_bpal[2] = (data & 0x30) >> 4;
r20640	r20641
2278	2263	else
2279	2264	{
2280	2265	/* General DMA */
2281		gbc_hdma( machine(), ((data & 0x7F) + 1) * 0x10 );
	2266	gbc_hdma( ((data & 0x7F) + 1) * 0x10 );
2282	2267	//              cpunum_set_reg( 0, LR35902_DMA_CYCLES, 4 + ( ( ( data & 0x7F ) + 1 ) * 32 ) );
2283	2268	data = 0xff;
2284	2269	}
r20640	r20641
2292	2277	/* Check if HDMA should be immediately performed */
2293	2278	if ( m_lcd.hdma_possible )
2294	2279	{
2295		gbc_hdma( machine(), 0x10 );
	2280	gbc_hdma( 0x10 );
2296	2281	//              cpunum_set_reg( 0, LR35902_DMA_CYCLES, 36 );
2297	2282	m_lcd.hdma_possible = 0;
2298	2283	}
r20640	r20641
2378	2363	m_lcd.gb_vid_regs[offset] = data;
2379	2364	}
2380	2365
2381
2382		UINT8 *gb_get_vram_ptr(running_machine &machine)
2383		{
2384		gb_state *state = machine.driver_data<gb_state>();
2385		return state->m_lcd.gb_vram_ptr;
2386		}

trunk/src/mess/drivers/gb.c

r20640	r20641
453	453	static const UINT16 mgb_cpu_regs[6] = { 0xFFB0, 0x0013, 0x00D8, 0x014D, 0xFFFE, 0x0100 };   /* Game Boy Pocket / Super Game Boy 2 */
454	454	static const UINT16 megaduck_cpu_regs[6] = { 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFE, 0x0000 };  /* Megaduck */
455	455
456		static const struct lr35902_config dmg_cpu_reset = { NULL, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
457		static const struct lr35902_config sgb_cpu_reset = { NULL, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
458		static const struct lr35902_config mgb_cpu_reset = { mgb_cpu_regs, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
459		static const struct lr35902_config cgb_cpu_reset = { NULL, 0, gb_timer_callback };
460		static const struct lr35902_config megaduck_cpu_reset = { megaduck_cpu_regs, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
461
462	456	static ADDRESS_MAP_START(gb_map, AS_PROGRAM, 8, gb_state )
463	457	ADDRESS_MAP_UNMAP_HIGH
464	458	AM_RANGE(0x0000, 0x00ff) AM_ROMBANK("bank5")                    /* BIOS or ROM */
r20640	r20641
561	555	/* basic machine hardware */
562	556	MCFG_CPU_ADD("maincpu", LR35902, 4194304)           /* 4.194304 MHz */
563	557	MCFG_CPU_PROGRAM_MAP(gb_map)
564		MCFG_LR35902_CONFIG(dmg_cpu_reset)
	558	MCFG_LR35902_TIMER_CB( WRITE8( gb_state, gb_timer_callback ) )
	559	MCFG_LR35902_HALT_BUG
565	560	MCFG_CPU_VBLANK_INT_DRIVER("screen", gb_state,  gb_scanline_interrupt)  /* 1 dummy int each frame */
566	561
567	562	MCFG_QUANTUM_TIME(attotime::from_hz(60))
r20640	r20641
606	601	MCFG_CPU_PROGRAM_MAP(sgb_map)
607	602
608	603	MCFG_CPU_MODIFY("maincpu")
609		MCFG_LR35902_CONFIG(sgb_cpu_reset)
	604	MCFG_LR35902_TIMER_CB( WRITE8( gb_state, gb_timer_callback ) )
	605	MCFG_LR35902_HALT_BUG
610	606
611	607	MCFG_MACHINE_START_OVERRIDE(gb_state, sgb )
612	608	MCFG_MACHINE_RESET_OVERRIDE(gb_state, sgb )
r20640	r20641
622	618
623	619	static MACHINE_CONFIG_DERIVED( gbpocket, gameboy )
624	620	MCFG_CPU_MODIFY("maincpu")
625		MCFG_LR35902_CONFIG(mgb_cpu_reset)
	621	MCFG_LR35902_TIMER_CB( WRITE8( gb_state, gb_timer_callback ) )
	622	MCFG_LR35902_HALT_BUG
	623	MCFG_LR35902_RESET_VALUES(mgb_cpu_regs)
	624
626	625	MCFG_MACHINE_RESET_OVERRIDE(gb_state, gbpocket )
627	626	MCFG_PALETTE_INIT_OVERRIDE(gb_state,gbp)
628	627
r20640	r20641
633	632	static MACHINE_CONFIG_DERIVED( gbcolor, gb_common )
634	633	MCFG_CPU_MODIFY("maincpu")
635	634	MCFG_CPU_PROGRAM_MAP( gbc_map)
636		MCFG_LR35902_CONFIG(cgb_cpu_reset)
	635	MCFG_LR35902_TIMER_CB( WRITE8( gb_state, gb_timer_callback ) )
637	636
638	637	MCFG_MACHINE_START_OVERRIDE(gb_state,gbc)
639	638	MCFG_MACHINE_RESET_OVERRIDE(gb_state,gbc)
r20640	r20641
659	658	/* basic machine hardware */
660	659	MCFG_CPU_ADD("maincpu", LR35902, 4194304)           /* 4.194304 MHz */
661	660	MCFG_CPU_PROGRAM_MAP( megaduck_map)
	661	MCFG_LR35902_TIMER_CB( WRITE8( gb_state, gb_timer_callback ) )
	662	MCFG_LR35902_HALT_BUG
	663	MCFG_LR35902_RESET_VALUES(megaduck_cpu_regs)
662	664	MCFG_CPU_VBLANK_INT_DRIVER("screen", gb_state,  gb_scanline_interrupt)  /* 1 int each scanline ! */
663		MCFG_LR35902_CONFIG(megaduck_cpu_reset)
664	665
665	666	MCFG_SCREEN_ADD("screen", LCD)
666	667	MCFG_SCREEN_REFRESH_RATE(DMG_FRAMES_PER_SECOND)

trunk/src/emu/cpu/lr35902/lr35902.c

r20640	r20641
54	54
55	55
56	56	lr35902_cpu_device::lr35902_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
57		: cpu_device(mconfig, LR35902, "LR35902", tag, owner, clock),
58		m_program_config("program", ENDIANNESS_LITTLE, 8, 16, 0)
	57	: cpu_device(mconfig, LR35902, "LR35902", tag, owner, clock)
	58	, m_program_config("program", ENDIANNESS_LITTLE, 8, 16, 0)
	59	, m_timer_func(*this)
	60	, m_features(0)
	61	, c_regs(NULL)
59	62	{
60		c_regs = NULL;
61		c_features = 0;
62		c_timer_expired_func = NULL;
63	63	}
64	64
65	65
66		void lr35902_cpu_device::static_set_config(device_t &device, const lr35902_config &config)
67		{
68		lr35902_cpu_device &conf = downcast<lr35902_cpu_device &>(device);
69		static_cast<lr35902_config &>(conf) = config;
70		}
71
72
73	66	/****************************************************************************/
74	67	/* Memory functions                                                         */
75	68	/****************************************************************************/
r20640	r20641
77	70	inline void lr35902_cpu_device::cycles_passed(UINT8 cycles)
78	71	{
79	72	m_icount -= cycles / m_gb_speed;
80		if ( m_timer_expired_func )
81		{
82		m_timer_expired_func( this, cycles );
83		}
	73	m_timer_func( cycles );
84	74	}
85	75
86	76
r20640	r20641
119	109	m_device = this;
120	110	m_program = &space(AS_PROGRAM);
121	111
	112	m_timer_func.resolve_safe();
	113
122	114	save_item(NAME(m_A));
123	115	save_item(NAME(m_F));
124	116	save_item(NAME(m_B));
r20640	r20641
210	202	m_SP = c_regs[4];
211	203	m_PC = c_regs[5];
212	204	}
213		m_timer_expired_func = c_timer_expired_func;
214		m_features = c_features;
215	205
216	206	m_enable = 0;
217	207	m_IE = 0;

trunk/src/emu/cpu/lr35902/lr35902.h

r20640	r20641
4	4	#define __LR35902_H__
5	5
6	6
7		#define MCFG_LR35902_CONFIG(_config) \
8		lr35902_cpu_device::static_set_config(*device, _config);
	7	#define MCFG_LR35902_TIMER_CB(_devcb) \
	8	lr35902_cpu_device::set_timer_cb(*device, DEVCB2_##_devcb); \
9	9
10		class lr35902_cpu_device;
	10	#define MCFG_LR35902_HALT_BUG \
	11	lr35902_cpu_device::set_halt_bug(*device); \
11	12
12		// Perhaps replace this with a standard device callback
13		typedef void (*lr35902_timer_fired_func)(lr35902_cpu_device *device, int cycles);
	13	// This should be removed/improved once all gameboy boot roms have been dumped
	14	#define MCFG_LR35902_RESET_VALUES(_regs) \
	15	lr35902_cpu_device::set_reset_values(*device, _regs); \
14	16
15		struct lr35902_config
16		{
17		const UINT16    *c_regs;
18		UINT8           c_features;
19		lr35902_timer_fired_func c_timer_expired_func;
20		};
21	17
22	18	enum
23	19	{
r20640	r20641
29	25	LR35902_SPEED,
30	26	};
31	27
32		// This and the features configuration could be removed if we introduce proper subclasses
33		#define LR35902_FEATURE_HALT_BUG    0x01
34	28
35
36		class lr35902_cpu_device :  public cpu_device,
37		public lr35902_config
	29	class lr35902_cpu_device :  public cpu_device
38	30	{
39	31	public:
40	32	// construction/destruction
41	33	lr35902_cpu_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
42	34
43		static void static_set_config(device_t &device, const lr35902_config &config);
	35	// static configuration helpers
	36	template<class _Object> static devcb2_base &set_timer_cb(device_t &device, _Object object) { return downcast<lr35902_cpu_device &>(device).m_timer_func.set_callback(object); }
	37	static void set_halt_bug(device_t &device) { downcast<lr35902_cpu_device &>(device).m_features |= LR35902_FEATURE_HALT_BUG; }
	38	static void set_reset_values(device_t &device, const UINT16 *regs) { downcast<lr35902_cpu_device &>(device).c_regs = regs; }
44	39
45	40	UINT8 get_speed();
46	41	void set_speed( UINT8 speed_request );
r20640	r20641
52	47	void set_if( UINT8 data ) { m_IF = data; }
53	48
54	49	protected:
	50	static const UINT8 LR35902_FEATURE_HALT_BUG = 0x01;
	51
55	52	// device-level overrides
56	53	virtual void device_start();
57	54	virtual void device_reset();
r20640	r20641
103	100	lr35902_cpu_device *m_device;
104	101	address_space *m_program;
105	102	int m_icount;
106		/* Timer stuff */
107		lr35902_timer_fired_func m_timer_expired_func;
	103	/* Timer callback */
	104	devcb2_write8 m_timer_func;
108	105	/* Fetch & execute related */
109	106	int     m_execution_state;
110	107	UINT8   m_op;
r20640	r20641
114	111	int m_enable;
115	112	int m_doHALTbug;
116	113	UINT8   m_features;
	114	const UINT16 *c_regs;
117	115	const struct lr35902_config *m_config;
118	116
119	117	/* Flag bit definitions */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team