Previous

199869 Revisions

Next

r17998 Tuesday 18th September, 2012 at 14:45:06 UTC by Miodrag Milanović
INTERRUPT_GEN -> INTERRUPT_GEN_MEMBER for MESS part (no whatsnew)

[src/mess/drivers]	alphasma.c apexc.c apple3.c aquarius.c arcadia.c b2m.c bbc.c bmjr.c bml3.c c128.c c64.c c65.c cbmb.c cgenie.c compis.c concept.c elwro800.c fmtowns.c fp1100.c galaxy.c gamecom.c gb.c geniusiq.c gmaster.c h19.c hec2hrp.c homelab.c homez80.c interact.c intv.c ip22.c iq151.c kaypro.c lisa.c mac.c mbee.c microtan.c msx.c mz2500.c newbrain.c ondra.c orion.c p2000t.c pasogo.c pc100.c pc2000.c pc6001.c pc8801.c pc88va.c pc9801.c pdp1.c pet.c pk8000.c pk8020.c plus4.c poly88.c primo.c pyl601.c rainbow.c rx78.c samcoupe.c sgi_ip2.c sgi_ip6.c sm1800.c smc777.c socrates.c spectrum.c supracan.c svision.c ti990_10.c ti990_4.c ti99_2.c tim011.c trs80.c tx0.c vc4000.c vector06.c vic10.c vic20.c vii.c vt100.c vt240.c vtech2.c x68k.c
[src/mess/includes]	apple3.h arcadia.h b2m.h bbc.h c128.h c16.h c64.h c64_legacy.h c65.h cgenie.h compis.h concept.h fmtowns.h galaxy.h gamecom.h gb.h gmaster.h intv.h kaypro.h lisa.h lynx.h mac.h mbee.h microtan.h msx.h newbrain.h ondra.h orion.h p2000t.h pdp1.h pet.h pk8020.h plus4.h poly88.h primo.h samcoupe.h spectrum.h svision.h trs80.h tx0.h vc4000.h vector06.h vic10.h vic20.h vtech2.h x68k.h
[src/mess/machine]	apple3.c b2m.c bbc.c c128.c c64.c c65.c cgenie.c compis.c concept.c galaxy.c gb.c intv.c kay_kbd.c lisa.c mbee.c microtan.c msx.c orion.c pet.c pk8020.c poly88.c primo.c trs80.c vector06.c
[src/mess/video]	arcadia.c fmtowns.c vc4000.c

trunk/src/mess/machine/apple3.c

r17997	r17998
246	246	}
247	247	}
248	248
249		INTERRUPT_GEN( apple3_interrupt )
	249	INTERRUPT_GEN_MEMBER(apple3_state::apple3_interrupt)
250	250	{
251		via6522_device *via_1 = device->machine().device<via6522_device>("via6522_1");
	251	via6522_device *via_1 = machine().device<via6522_device>("via6522_1");
252	252
253		via_1->write_ca2((AY3600_keydata_strobe_r(device->machine()) & 0x80) ? 1 : 0);
254		via_1->write_cb1(device->machine().primary_screen->vblank());
255		via_1->write_cb2(device->machine().primary_screen->vblank());
	253	via_1->write_ca2((AY3600_keydata_strobe_r(machine()) & 0x80) ? 1 : 0);
	254	via_1->write_cb1(machine().primary_screen->vblank());
	255	via_1->write_cb2(machine().primary_screen->vblank());
256	256	}
257	257
258	258

trunk/src/mess/machine/mbee.c

r17997	r17998
559	559	machine().scheduler().timer_set(attotime::from_usec(4), FUNC(mbee_reset));
560	560	}
561	561
562		INTERRUPT_GEN( mbee_interrupt )
	562	INTERRUPT_GEN_MEMBER(mbee_state::mbee_interrupt)
563	563	{
564	564	// Due to the uncertainly and hackage here, this is commented out for now - Robbbert - 05-Oct-2010
565	565	#if 0
566		mbee_state *state = device->machine().driver_data<mbee_state>();
567	566
568		//address_space &space = *device->machine().device("maincpu")->memory().space(AS_PROGRAM);
	567	//address_space &space = *machine().device("maincpu")->memory().space(AS_PROGRAM);
569	568	/* The printer status connects to the pio ASTB pin, and the printer changing to not
570	569	busy should signal an interrupt routine at B61C, (next line) but this doesn't work.
571	570	The line below does what the interrupt should be doing. */
572	571	/* But it would break any program loaded to that area of memory, such as CP/M programs */
573	572
574		//state->m_z80pio->strobe_a(centronics_busy_r(state->m_printer)); /* signal int when not busy (L->H) */
575		//space.write_byte(0x109, centronics_busy_r(state->m_printer));
	573	//m_z80pio->strobe_a(centronics_busy_r(m_printer)); /* signal int when not busy (L->H) */
	574	//space.write_byte(0x109, centronics_busy_r(m_printer));
576	575
577	576
578	577	/* once per frame, pulse the PIO B bit 7 - it is in the schematic as an option,
579	578	but need to find out what it does */
580		state->m_clock_pulse = 0x80;
	579	m_clock_pulse = 0x80;
581	580	irq0_line_hold(device);
582	581
583	582	#endif

trunk/src/mess/machine/orion.c

r17997	r17998
365	365	radio86_init_keyboard(machine());
366	366	}
367	367
368		INTERRUPT_GEN( orionz80_interrupt )
	368	INTERRUPT_GEN_MEMBER(orion_state::orionz80_interrupt)
369	369	{
370		orion_state *state = device->machine().driver_data<orion_state>();
371		if ((state->m_orionz80_dispatcher & 0x40)==0x40)
	370	if ((m_orionz80_dispatcher & 0x40)==0x40)
372	371	{
373		device->execute().set_input_line(0, HOLD_LINE);
	372	device.execute().set_input_line(0, HOLD_LINE);
374	373	}
375	374	}
376	375

trunk/src/mess/machine/microtan.c

r17997	r17998
421	421	microtan_set_irq_line(machine);
422	422	}
423	423
424		INTERRUPT_GEN( microtan_interrupt )
	424	INTERRUPT_GEN_MEMBER(microtan_state::microtan_interrupt)
425	425	{
426		microtan_state *state = device->machine().driver_data<microtan_state>();
427	426	int mod, row, col, chg, newvar;
428	427	static const char *const keynames[] = { "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", "ROW5", "ROW6", "ROW7", "ROW8" };
429	428
430		if( state->m_repeat )
	429	if( m_repeat )
431	430	{
432		if( !--state->m_repeat )
433		state->m_repeater = 4;
	431	if( !--m_repeat )
	432	m_repeater = 4;
434	433	}
435		else if( state->m_repeater )
	434	else if( m_repeater )
436	435	{
437		state->m_repeat = state->m_repeater;
	436	m_repeat = m_repeater;
438	437	}
439	438
440	439
441	440	row = 9;
442		newvar = device->machine().root_device().ioport("ROW8")->read();
443		chg = state->m_keyrows[--row] ^ newvar;
	441	newvar = machine().root_device().ioport("ROW8")->read();
	442	chg = m_keyrows[--row] ^ newvar;
444	443
445	444	while ( !chg && row > 0)
446	445	{
447		newvar = device->machine().root_device().ioport(keynames[row - 1])->read();
448		chg = state->m_keyrows[--row] ^ newvar;
	446	newvar = machine().root_device().ioport(keynames[row - 1])->read();
	447	chg = m_keyrows[--row] ^ newvar;
449	448	}
450	449	if (!chg)
451	450	--row;
452	451
453	452	if (row >= 0)
454	453	{
455		state->m_repeater = 0x00;
456		state->m_mask = 0x00;
457		state->m_key = 0x00;
458		state->m_lastrow = row;
	454	m_repeater = 0x00;
	455	m_mask = 0x00;
	456	m_key = 0x00;
	457	m_lastrow = row;
459	458	/* CapsLock LED */
460	459	if( row == 3 && chg == 0x80 )
461		set_led_status(device->machine(), 1, (state->m_keyrows[3] & 0x80) ? 0 : 1);
	460	set_led_status(machine(), 1, (m_keyrows[3] & 0x80) ? 0 : 1);
462	461
463	462	if (newvar & chg)  /* key(s) pressed ? */
464	463	{
465	464	mod = 0;
466	465
467	466	/* Shift modifier */
468		if ( (state->m_keyrows[5] & 0x10) || (state->m_keyrows[6] & 0x80) )
	467	if ( (m_keyrows[5] & 0x10) || (m_keyrows[6] & 0x80) )
469	468	mod |= 1;
470	469
471	470	/* Control modifier */
472		if (state->m_keyrows[3] & 0x40)
	471	if (m_keyrows[3] & 0x40)
473	472	mod |= 2;
474	473
475	474	/* CapsLock modifier */
476		if (state->m_keyrows[3] & 0x80)
	475	if (m_keyrows[3] & 0x80)
477	476	mod |= 4;
478	477
479	478	/* find newvar key */
480		state->m_mask = 0x01;
	479	m_mask = 0x01;
481	480	for (col = 0; col < 8; col ++)
482	481	{
483		if (chg & state->m_mask)
	482	if (chg & m_mask)
484	483	{
485		newvar &= state->m_mask;
486		state->m_key = keyboard[mod][row][col];
	484	newvar &= m_mask;
	485	m_key = keyboard[mod][row][col];
487	486	break;
488	487	}
489		state->m_mask <<= 1;
	488	m_mask <<= 1;
490	489	}
491		if( state->m_key )   /* normal key */
	490	if( m_key )   /* normal key */
492	491	{
493		state->m_repeater = 30;
494		store_key(device->machine(), state->m_key);
	492	m_repeater = 30;
	493	store_key(machine(), m_key);
495	494	}
496	495	else
497	496	if( (row == 0) && (chg == 0x04) ) /* Ctrl-@ (NUL) */
498		store_key(device->machine(), 0);
499		state->m_keyrows[row] |= newvar;
	497	store_key(machine(), 0);
	498	m_keyrows[row] |= newvar;
500	499	}
501	500	else
502	501	{
503		state->m_keyrows[row] = newvar;
	502	m_keyrows[row] = newvar;
504	503	}
505		state->m_repeat = state->m_repeater;
	504	m_repeat = m_repeater;
506	505	}
507	506	else
508		if ( state->m_key && (state->m_keyrows[state->m_lastrow] & state->m_mask) && state->m_repeat == 0 )
	507	if ( m_key && (m_keyrows[m_lastrow] & m_mask) && m_repeat == 0 )
509	508	{
510		store_key(device->machine(), state->m_key);
	509	store_key(machine(), m_key);
511	510	}
512	511	}
513	512

trunk/src/mess/machine/poly88.c

r17997	r17998
216	216	machine().scheduler().timer_set(attotime::zero, FUNC(setup_machine_state));
217	217	}
218	218
219		INTERRUPT_GEN( poly88_interrupt )
	219	INTERRUPT_GEN_MEMBER(poly88_state::poly88_interrupt)
220	220	{
221		poly88_state *state = device->machine().driver_data<poly88_state>();
222		state->m_int_vector = 0xf7;
223		device->execute().set_input_line(0, HOLD_LINE);
	221	m_int_vector = 0xf7;
	222	device.execute().set_input_line(0, HOLD_LINE);
224	223	}
225	224
226	225	static WRITE_LINE_DEVICE_HANDLER( poly88_usart_rxready )

trunk/src/mess/machine/trs80.c

r17997	r17998
624	624	*
625	625	*************************************/
626	626
627		INTERRUPT_GEN( trs80_rtc_interrupt )
	627	INTERRUPT_GEN_MEMBER(trs80_state::trs80_rtc_interrupt)
628	628	{
629		trs80_state *state = device->machine().driver_data<trs80_state>();
630	629	/* This enables the processing of interrupts for the clock and the flashing cursor.
631	630	The OS counts one tick for each interrupt. The Model I has 40 ticks per
632	631	second, while the Model III/4 has 30. */
633	632
634		if (state->m_model4)   // Model 4
	633	if (m_model4)   // Model 4
635	634	{
636		if (state->m_mask & IRQ_M4_RTC)
	635	if (m_mask & IRQ_M4_RTC)
637	636	{
638		state->m_irq |= IRQ_M4_RTC;
639		device->execute().set_input_line(0, HOLD_LINE);
	637	m_irq |= IRQ_M4_RTC;
	638	device.execute().set_input_line(0, HOLD_LINE);
640	639	}
641	640	}
642	641	else      // Model 1
643	642	{
644		state->m_irq |= IRQ_M1_RTC;
645		device->execute().set_input_line(0, HOLD_LINE);
	643	m_irq |= IRQ_M1_RTC;
	644	device.execute().set_input_line(0, HOLD_LINE);
646	645	}
647	646	}
648	647
r17997	r17998
664	663	}
665	664	}
666	665
667		INTERRUPT_GEN( trs80_fdc_interrupt )   /* not used - should it be? */
	666	INTERRUPT_GEN_MEMBER(trs80_state::trs80_fdc_interrupt)/* not used - should it be? */
668	667	{
669		trs80_fdc_interrupt_internal(device->machine());
	668	trs80_fdc_interrupt_internal(machine());
670	669	}
671	670
672	671	static WRITE_LINE_DEVICE_HANDLER( trs80_fdc_intrq_w )

trunk/src/mess/machine/primo.c

r17997	r17998
31	31
32	32	*******************************************************************************/
33	33
34		INTERRUPT_GEN( primo_vblank_interrupt )
	34	INTERRUPT_GEN_MEMBER(primo_state::primo_vblank_interrupt)
35	35	{
36		primo_state *state = device->machine().driver_data<primo_state>();
37		if (state->m_nmi)
38		device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	36	if (m_nmi)
	37	device.execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
39	38	}
40	39
41	40	/*******************************************************************************

trunk/src/mess/machine/intv.c

r17997	r17998
671	671	state->m_backtab_row += 1;
672	672	}
673	673
674		INTERRUPT_GEN( intv_interrupt )
	674	INTERRUPT_GEN_MEMBER(intv_state::intv_interrupt)
675	675	{
676		intv_state *state = device->machine().driver_data<intv_state>();
677		device->machine().device("maincpu")->execute().set_input_line(CP1610_INT_INTRM, ASSERT_LINE);
678		state->m_sr1_int_pending = 1;
679		state->m_bus_copy_mode = 1;
680		state->m_backtab_row = 0;
	676	machine().device("maincpu")->execute().set_input_line(CP1610_INT_INTRM, ASSERT_LINE);
	677	m_sr1_int_pending = 1;
	678	m_bus_copy_mode = 1;
	679	m_backtab_row = 0;
681	680	UINT8 row;
682		device->machine().device("maincpu")->execute().adjust_icount(-(12*STIC_ROW_BUSRQ+STIC_FRAME_BUSRQ)); // Account for stic cycle stealing
683		device->machine().scheduler().timer_set(device->machine().device<cpu_device>("maincpu")
	681	machine().device("maincpu")->execute().adjust_icount(-(12*STIC_ROW_BUSRQ+STIC_FRAME_BUSRQ)); // Account for stic cycle stealing
	682	machine().scheduler().timer_set(machine().device<cpu_device>("maincpu")
684	683	->cycles_to_attotime(STIC_VBLANK_END), FUNC(intv_interrupt_complete));
685	684	for (row=0; row < STIC_BACKTAB_HEIGHT; row++)
686	685	{
687		device->machine().scheduler().timer_set(device->machine().device<cpu_device>("maincpu")
688		->cycles_to_attotime(STIC_FIRST_FETCH-STIC_FRAME_BUSRQ+STIC_CYCLES_PER_SCANLINE*STIC_Y_SCALE*state->m_row_delay + (STIC_CYCLES_PER_SCANLINE*STIC_Y_SCALE*STIC_CARD_HEIGHT - STIC_ROW_BUSRQ)*row), FUNC(intv_btb_fill));
	686	machine().scheduler().timer_set(machine().device<cpu_device>("maincpu")
	687	->cycles_to_attotime(STIC_FIRST_FETCH-STIC_FRAME_BUSRQ+STIC_CYCLES_PER_SCANLINE*STIC_Y_SCALE*m_row_delay + (STIC_CYCLES_PER_SCANLINE*STIC_Y_SCALE*STIC_CARD_HEIGHT - STIC_ROW_BUSRQ)*row), FUNC(intv_btb_fill));
689	688	}
690	689
691		if (state->m_row_delay == 0)
	690	if (m_row_delay == 0)
692	691	{
693		device->machine().device("maincpu")->execute().adjust_icount(-STIC_ROW_BUSRQ); // extra row fetch occurs if vertical delay == 0
	692	machine().device("maincpu")->execute().adjust_icount(-STIC_ROW_BUSRQ); // extra row fetch occurs if vertical delay == 0
694	693	}
695	694
696		intv_stic_screenrefresh(device->machine());
	695	intv_stic_screenrefresh(machine());
697	696	}
698	697
699	698	/* hand 0 == left, 1 == right, 2 == ECS hand controller 1, 3 == ECS hand controller 2 */

trunk/src/mess/machine/c64.c

r17997	r17998
840	840	c64_bankswitch(machine, 1);
841	841	}
842	842
843		INTERRUPT_GEN( c64_frame_interrupt )
	843	INTERRUPT_GEN_MEMBER(legacy_c64_state::c64_frame_interrupt)
844	844	{
845		c64_nmi(device->machine());
846		cbm_common_interrupt(device);
	845	c64_nmi(machine());
	846	cbm_common_interrupt(&device);
847	847	}
848	848
849	849

trunk/src/mess/machine/bbc.c

r17997	r17998
733	733
734	734
735	735
736		INTERRUPT_GEN( bbcb_keyscan )
	736	INTERRUPT_GEN_MEMBER(bbc_state::bbcb_keyscan)
737	737	{
738		bbc_state *state = device->machine().driver_data<bbc_state>();
739	738	static const char *const colnames[] = {
740	739	"COL0", "COL1", "COL2", "COL3", "COL4",
741	740	"COL5", "COL6", "COL7", "COL8", "COL9"
742	741	};
743		via6522_device *via_0 = device->machine().device<via6522_device>("via6522_0");
	742	via6522_device *via_0 = machine().device<via6522_device>("via6522_0");
744	743
745	744	/* only do auto scan if keyboard is not enabled */
746		if (state->m_b3_keyboard == 1)
	745	if (m_b3_keyboard == 1)
747	746	{
748	747	/* KBD IC1 4 bit addressable counter */
749	748	/* KBD IC3 4 to 10 line decoder */
750	749	/* keyboard not enabled so increment counter */
751		state->m_column = (state->m_column + 1) % 16;
752		if (state->m_column < 10)
	750	m_column = (m_column + 1) % 16;
	751	if (m_column < 10)
753	752	{
754	753	/* KBD IC4 8 input NAND gate */
755	754	/* set the value of via_system ca2, by checking for any keys
756		being pressed on the selected state->m_column */
757		if ((device->machine().root_device().ioport(colnames[state->m_column])->read() | 0x01) != 0xff)
	755	being pressed on the selected m_column */
	756	if ((machine().root_device().ioport(colnames[m_column])->read() | 0x01) != 0xff)
758	757	{
759	758	via_0->write_ca2(1);
760	759	}
r17997	r17998
772	771	}
773	772
774	773
775		INTERRUPT_GEN( bbcm_keyscan )
	774	INTERRUPT_GEN_MEMBER(bbc_state::bbcm_keyscan)
776	775	{
777		bbc_state *state = device->machine().driver_data<bbc_state>();
778	776	static const char *const colnames[] = {
779	777	"COL0", "COL1", "COL2", "COL3", "COL4",
780	778	"COL5", "COL6", "COL7", "COL8", "COL9"
781	779	};
782		via6522_device *via_0 = device->machine().device<via6522_device>("via6522_0");
	780	via6522_device *via_0 = machine().device<via6522_device>("via6522_0");
783	781
784	782	/* only do auto scan if keyboard is not enabled */
785		if (state->m_b3_keyboard == 1)
	783	if (m_b3_keyboard == 1)
786	784	{
787	785	/* KBD IC1 4 bit addressable counter */
788	786	/* KBD IC3 4 to 10 line decoder */
789	787	/* keyboard not enabled so increment counter */
790		state->m_column = (state->m_column + 1) % 16;
	788	m_column = (m_column + 1) % 16;
791	789
792	790	/* this IF should be removed as soon as the dip switches (keyboard keys) are set for the master */
793		if (state->m_column < 10)
	791	if (m_column < 10)
794	792	{
795	793	/* KBD IC4 8 input NAND gate */
796	794	/* set the value of via_system ca2, by checking for any keys
797		being pressed on the selected state->m_column */
798		if ((device->machine().root_device().ioport(colnames[state->m_column])->read() | 0x01) != 0xff)
	795	being pressed on the selected m_column */
	796	if ((machine().root_device().ioport(colnames[m_column])->read() | 0x01) != 0xff)
799	797	{
800	798	via_0->write_ca2(1);
801	799	}

trunk/src/mess/machine/c65.c

r17997	r17998
1023	1023	}
1024	1024
1025	1025
1026		INTERRUPT_GEN( c65_frame_interrupt )
	1026	INTERRUPT_GEN_MEMBER(c65_state::c65_frame_interrupt)
1027	1027	{
1028		c65_state *state = device->machine().driver_data<c65_state>();
1029	1028	int value;
1030	1029
1031		c65_nmi(device->machine());
	1030	c65_nmi(machine());
1032	1031
1033	1032	/* common keys input ports */
1034		cbm_common_interrupt(device);
	1033	cbm_common_interrupt(&device);
1035	1034
1036	1035	/* c65 specific: function keys input ports */
1037	1036	value = 0xff;
1038	1037
1039		value &= ~state->ioport("FUNCT")->read();
1040		state->m_keyline = value;
	1038	value &= ~ioport("FUNCT")->read();
	1039	m_keyline = value;
1041	1040	}

trunk/src/mess/machine/gb.c

r17997	r17998
1892	1892	return IMAGE_INIT_PASS;
1893	1893	}
1894	1894
1895		INTERRUPT_GEN( gb_scanline_interrupt )
	1895	INTERRUPT_GEN_MEMBER(gb_state::gb_scanline_interrupt)
1896	1896	{
1897	1897	}
1898	1898

trunk/src/mess/machine/b2m.c

r17997	r17998
357	357	DEVCB_NULL
358	358	};
359	359
360		INTERRUPT_GEN( b2m_vblank_interrupt )
	360	INTERRUPT_GEN_MEMBER(b2m_state::b2m_vblank_interrupt)
361	361	{
362		b2m_state *state = device->machine().driver_data<b2m_state>();
363		state->m_vblank_state++;
364		if (state->m_vblank_state>1) state->m_vblank_state=0;
365		pic8259_ir0_w(state->m_pic, state->m_vblank_state);
	362	m_vblank_state++;
	363	if (m_vblank_state>1) m_vblank_state=0;
	364	pic8259_ir0_w(m_pic, m_vblank_state);
366	365	}
367	366
368	367	void b2m_state::machine_reset()

trunk/src/mess/machine/kay_kbd.c

r17997	r17998
302	302	* also drives keyboard LEDs and
303	303	* and handles autorepeating keys
304	304	******************************************************/
305		INTERRUPT_GEN( kay_kbd_interrupt )
	305	INTERRUPT_GEN_MEMBER(kaypro_state::kay_kbd_interrupt)
306	306	{
307		kaypro_state *state = device->machine().driver_data<kaypro_state>();
308		kay_kbd_t *kbd = state->m_kbd;
	307	kay_kbd_t *kbd = m_kbd;
309	308	int mod, row, col, chg, newval;
310	309	UINT8 *keyrows = kbd->keyrows;
311	310
r17997	r17998
321	320	}
322	321
323	322	row = 9;
324		newval = device->machine().root_device().ioport("ROW9")->read();
	323	newval = machine().root_device().ioport("ROW9")->read();
325	324	chg = keyrows[row] ^ newval;
326	325
327		if (!chg) { newval = device->machine().root_device().ioport("ROW8")->read(); chg = keyrows[--row] ^ newval; }
328		if (!chg) { newval = device->machine().root_device().ioport("ROW7")->read(); chg = keyrows[--row] ^ newval; }
329		if (!chg) { newval = device->machine().root_device().ioport("ROW6")->read(); chg = keyrows[--row] ^ newval; }
330		if (!chg) { newval = device->machine().root_device().ioport("ROW5")->read(); chg = keyrows[--row] ^ newval; }
331		if (!chg) { newval = device->machine().root_device().ioport("ROW4")->read(); chg = keyrows[--row] ^ newval; }
332		if (!chg) { newval = device->machine().root_device().ioport("ROW3")->read(); chg = keyrows[--row] ^ newval; }
333		if (!chg) { newval = device->machine().root_device().ioport("ROW2")->read(); chg = keyrows[--row] ^ newval; }
334		if (!chg) { newval = device->machine().root_device().ioport("ROW1")->read(); chg = keyrows[--row] ^ newval; }
335		if (!chg) { newval = device->machine().root_device().ioport("ROW0")->read(); chg = keyrows[--row] ^ newval; }
	326	if (!chg) { newval = machine().root_device().ioport("ROW8")->read(); chg = keyrows[--row] ^ newval; }
	327	if (!chg) { newval = machine().root_device().ioport("ROW7")->read(); chg = keyrows[--row] ^ newval; }
	328	if (!chg) { newval = machine().root_device().ioport("ROW6")->read(); chg = keyrows[--row] ^ newval; }
	329	if (!chg) { newval = machine().root_device().ioport("ROW5")->read(); chg = keyrows[--row] ^ newval; }
	330	if (!chg) { newval = machine().root_device().ioport("ROW4")->read(); chg = keyrows[--row] ^ newval; }
	331	if (!chg) { newval = machine().root_device().ioport("ROW3")->read(); chg = keyrows[--row] ^ newval; }
	332	if (!chg) { newval = machine().root_device().ioport("ROW2")->read(); chg = keyrows[--row] ^ newval; }
	333	if (!chg) { newval = machine().root_device().ioport("ROW1")->read(); chg = keyrows[--row] ^ newval; }
	334	if (!chg) { newval = machine().root_device().ioport("ROW0")->read(); chg = keyrows[--row] ^ newval; }
336	335	if (!chg) --row;
337	336
338	337	if (row >= 0)
r17997	r17998
343	342	kbd->lastrow = row;
344	343	/* CapsLock LED */
345	344	if( row == 3 && chg == 0x80 )
346		set_led_status(device->machine(), 1, (kbd->keyrows[3] & 0x80) ? 0 : 1);
	345	set_led_status(machine(), 1, (kbd->keyrows[3] & 0x80) ? 0 : 1);
347	346
348	347	if (newval & chg)   /* key(s) pressed ? */
349	348	{
r17997	r17998
376	375	if( kbd->key )   /* normal key */
377	376	{
378	377	kbd->repeater = 30;
379		kay_kbd_in(device->machine(), kbd->key);
	378	kay_kbd_in(machine(), kbd->key);
380	379	}
381	380	else
382	381	if( (row == 0) && (chg == 0x04) ) /* Ctrl-@ (NUL) */
383		kay_kbd_in(device->machine(), 0);
	382	kay_kbd_in(machine(), 0);
384	383	keyrows[row] |= newval;
385	384	}
386	385	else
r17997	r17998
391	390	}
392	391	else if ( kbd->key && (keyrows[kbd->lastrow] & kbd->mask) && kbd->repeat == 0 )
393	392	{
394		kay_kbd_in(device->machine(), kbd->key);
	393	kay_kbd_in(machine(), kbd->key);
395	394	}
396	395	}
397	396

trunk/src/mess/machine/c128.c

r17997	r17998
1129	1129	}
1130	1130
1131	1131
1132		INTERRUPT_GEN( c128_frame_interrupt )
	1132	INTERRUPT_GEN_MEMBER(c128_state::c128_frame_interrupt)
1133	1133	{
1134		c128_state *state = device->machine().driver_data<c128_state>();
1135	1134	static const char *const c128ports[] = { "KP0", "KP1", "KP2" };
1136	1135	int i, value;
1137		//device_t *vic2e = device->machine().device("vic2e");
1138		//device_t *vdc8563 = device->machine().device("vdc8563");
	1136	//device_t *vic2e = machine().device("vic2e");
	1137	//device_t *vdc8563 = machine().device("vdc8563");
1139	1138
1140		state->nmi();
	1139	nmi();
1141	1140
1142	1141	/* common keys input ports */
1143		cbm_common_interrupt(device);
	1142	cbm_common_interrupt(&device);
1144	1143
1145	1144	/* Fix Me! Currently, neither left Shift nor Shift Lock work in c128, but reading the correspondent input produces a bug!
1146	1145	Hence, we overwrite the actual reading as it never happens */
1147		if ((device->machine().root_device().ioport("SPECIAL")->read() & 0x40))   //
	1146	if ((machine().root_device().ioport("SPECIAL")->read() & 0x40))   //
1148	1147	c64_keyline[1] |= 0x80;
1149	1148
1150	1149	/* c128 specific: keypad input ports */
1151	1150	for (i = 0; i < 3; i++)
1152	1151	{
1153	1152	value = 0xff;
1154		value &= ~device->machine().root_device().ioport(c128ports[i])->read();
1155		state->m_keyline[i] = value;
	1153	value &= ~machine().root_device().ioport(c128ports[i])->read();
	1154	m_keyline[i] = value;
1156	1155	}
1157	1156	}

trunk/src/mess/machine/pet.c

r17997	r17998
762	762	}
763	763
764	764
765		INTERRUPT_GEN( pet_frame_interrupt )
	765	INTERRUPT_GEN_MEMBER(pet_state::pet_frame_interrupt)
766	766	{
767		pet_state *state = device->machine().driver_data<pet_state>();
768		if (state->m_superpet)
	767	if (m_superpet)
769	768	{
770		if (state->ioport("CFG")->read() & 0x04)
	769	if (ioport("CFG")->read() & 0x04)
771	770	{
772		device->execute().set_input_line(INPUT_LINE_HALT, 1);
773		device->execute().set_input_line(INPUT_LINE_HALT, 0);
774		state->m_font |= 2;
	771	device.execute().set_input_line(INPUT_LINE_HALT, 1);
	772	device.execute().set_input_line(INPUT_LINE_HALT, 0);
	773	m_font |= 2;
775	774	}
776	775	else
777	776	{
778		device->execute().set_input_line(INPUT_LINE_HALT, 0);
779		device->execute().set_input_line(INPUT_LINE_HALT, 1);
780		state->m_font &= ~2;
	777	device.execute().set_input_line(INPUT_LINE_HALT, 0);
	778	device.execute().set_input_line(INPUT_LINE_HALT, 1);
	779	m_font &= ~2;
781	780	}
782	781	}
783	782
784		set_led_status (device->machine(),1, device->machine().root_device().ioport("SPECIAL")->read() & 0x80 ? 1 : 0);      /* Shift Lock */
	783	set_led_status (machine(),1, machine().root_device().ioport("SPECIAL")->read() & 0x80 ? 1 : 0);      /* Shift Lock */
785	784	}
786	785
787	786

trunk/src/mess/machine/vector06.c

r17997	r17998
122	122	m_ppi2->write(space, offset^3, data);
123	123	}
124	124
125		INTERRUPT_GEN( vector06_interrupt )
	125	INTERRUPT_GEN_MEMBER(vector06_state::vector06_interrupt)
126	126	{
127		vector06_state *state = device->machine().driver_data<vector06_state>();
128		state->m_vblank_state++;
129		if (state->m_vblank_state>1) state->m_vblank_state=0;
130		device->execute().set_input_line(0,state->m_vblank_state ? HOLD_LINE : CLEAR_LINE);
	127	m_vblank_state++;
	128	if (m_vblank_state>1) m_vblank_state=0;
	129	device.execute().set_input_line(0,m_vblank_state ? HOLD_LINE : CLEAR_LINE);
131	130
132	131	}
133	132

trunk/src/mess/machine/galaxy.c

r17997	r17998
45	45	Interrupts
46	46	***************************************************************************/
47	47
48		INTERRUPT_GEN( galaxy_interrupt )
	48	INTERRUPT_GEN_MEMBER(galaxy_state::galaxy_interrupt)
49	49	{
50		device->execute().set_input_line(0, HOLD_LINE);
	50	device.execute().set_input_line(0, HOLD_LINE);
51	51	}
52	52
53	53	static IRQ_CALLBACK ( galaxy_irq_callback )

trunk/src/mess/machine/compis.c

r17997	r17998
1395	1395	/* Name: compis                                                            */
1396	1396	/* Desc: Interrupt - Vertical Blanking Interrupt                           */
1397	1397	/*-------------------------------------------------------------------------*/
1398		INTERRUPT_GEN( compis_vblank_int )
	1398	INTERRUPT_GEN_MEMBER(compis_state::compis_vblank_int)
1399	1399	{
1400	1400	//  compis_gdc_vblank_int();
1401		compis_keyb_update(device->machine());
	1401	compis_keyb_update(machine());
1402	1402	}

trunk/src/mess/machine/concept.c

r17997	r17998
182	182	}
183	183	}
184	184
185		INTERRUPT_GEN( concept_interrupt )
	185	INTERRUPT_GEN_MEMBER(concept_state::concept_interrupt)
186	186	{
187		poll_keyboard(device->machine());
	187	poll_keyboard(machine());
188	188	}
189	189
190	190	/*

trunk/src/mess/machine/msx.c

r17997	r17998
532	532	state->m_v9938->interrupt();
533	533	}
534	534
535		INTERRUPT_GEN( msx_interrupt )
	535	INTERRUPT_GEN_MEMBER(msx_state::msx_interrupt)
536	536	{
537		msx_state *state = device->machine().driver_data<msx_state>();
538	537	int i;
539	538
540	539	for (i=0; i<2; i++)
541	540	{
542		state->m_mouse[i] = state->ioport(i ? "MOUSE1" : "MOUSE0")->read();
543		state->m_mouse_stat[i] = -1;
	541	m_mouse[i] = ioport(i ? "MOUSE1" : "MOUSE0")->read();
	542	m_mouse_stat[i] = -1;
544	543	}
545	544	}
546	545

trunk/src/mess/machine/lisa.c

r17997	r17998
1086	1086	machine().device("maincpu")->reset();
1087	1087	}
1088	1088
1089		INTERRUPT_GEN( lisa_interrupt )
	1089	INTERRUPT_GEN_MEMBER(lisa_state::lisa_interrupt)
1090	1090	{
1091		lisa_state *state = device->machine().driver_data<lisa_state>();
1092		if ((++state->m_frame_count) == 6)
	1091	if ((++m_frame_count) == 6)
1093	1092	{   /* increment clock every 1/10s */
1094		state->m_frame_count = 0;
	1093	m_frame_count = 0;
1095	1094
1096		if (state->m_clock_regs.clock_mode != clock_timer_disable)
	1095	if (m_clock_regs.clock_mode != clock_timer_disable)
1097	1096	{
1098		if ((++state->m_clock_regs.tenths) == 10)
	1097	if ((++m_clock_regs.tenths) == 10)
1099	1098	{
1100		state->m_clock_regs.tenths = 0;
	1099	m_clock_regs.tenths = 0;
1101	1100
1102		if (state->m_clock_regs.clock_mode != timer_disable)
	1101	if (m_clock_regs.clock_mode != timer_disable)
1103	1102	{
1104		if (state->m_clock_regs.alarm == 0)
	1103	if (m_clock_regs.alarm == 0)
1105	1104	{
1106	1105	/* generate reset (should cause a VIA interrupt...) */
1107	1106	static const UINT8 cmd[2] =
r17997	r17998
1109	1108	0x80,   /* RESET code */
1110	1109	0xFC   /* timer time-out */
1111	1110	};
1112		COPS_queue_data(device->machine(), cmd, 2);
	1111	COPS_queue_data(machine(), cmd, 2);
1113	1112
1114		state->m_clock_regs.alarm = 0xfffffL;
	1113	m_clock_regs.alarm = 0xfffffL;
1115	1114	}
1116	1115	else
1117	1116	{
1118		state->m_clock_regs.alarm--;
	1117	m_clock_regs.alarm--;
1119	1118	}
1120	1119	}
1121	1120
1122		if ((++state->m_clock_regs.seconds2) == 10)
	1121	if ((++m_clock_regs.seconds2) == 10)
1123	1122	{
1124		state->m_clock_regs.seconds2 = 0;
	1123	m_clock_regs.seconds2 = 0;
1125	1124
1126		if ((++state->m_clock_regs.seconds1) == 6)
	1125	if ((++m_clock_regs.seconds1) == 6)
1127	1126	{
1128		state->m_clock_regs.seconds1 = 0;
	1127	m_clock_regs.seconds1 = 0;
1129	1128
1130		if ((++state->m_clock_regs.minutes2) == 10)
	1129	if ((++m_clock_regs.minutes2) == 10)
1131	1130	{
1132		state->m_clock_regs.minutes2 = 0;
	1131	m_clock_regs.minutes2 = 0;
1133	1132
1134		if ((++state->m_clock_regs.minutes1) == 6)
	1133	if ((++m_clock_regs.minutes1) == 6)
1135	1134	{
1136		state->m_clock_regs.minutes1 = 0;
	1135	m_clock_regs.minutes1 = 0;
1137	1136
1138		if ((++state->m_clock_regs.hours2) == 10)
	1137	if ((++m_clock_regs.hours2) == 10)
1139	1138	{
1140		state->m_clock_regs.hours2 = 0;
	1139	m_clock_regs.hours2 = 0;
1141	1140
1142		state->m_clock_regs.hours1++;
	1141	m_clock_regs.hours1++;
1143	1142	}
1144	1143
1145		if ((state->m_clock_regs.hours1*10 + state->m_clock_regs.hours2) == 24)
	1144	if ((m_clock_regs.hours1*10 + m_clock_regs.hours2) == 24)
1146	1145	{
1147		state->m_clock_regs.hours1 = state->m_clock_regs.hours2 = 0;
	1146	m_clock_regs.hours1 = m_clock_regs.hours2 = 0;
1148	1147
1149		if ((++state->m_clock_regs.days3) == 10)
	1148	if ((++m_clock_regs.days3) == 10)
1150	1149	{
1151		state->m_clock_regs.days3 = 0;
	1150	m_clock_regs.days3 = 0;
1152	1151
1153		if ((++state->m_clock_regs.days2) == 10)
	1152	if ((++m_clock_regs.days2) == 10)
1154	1153	{
1155		state->m_clock_regs.days2 = 0;
	1154	m_clock_regs.days2 = 0;
1156	1155
1157		state->m_clock_regs.days1++;
	1156	m_clock_regs.days1++;
1158	1157	}
1159	1158	}
1160	1159
1161		if ((state->m_clock_regs.days1*100 + state->m_clock_regs.days2*10 + state->m_clock_regs.days3) ==
1162		((state->m_clock_regs.years % 4) ? 366 : 367))
	1160	if ((m_clock_regs.days1*100 + m_clock_regs.days2*10 + m_clock_regs.days3) ==
	1161	((m_clock_regs.years % 4) ? 366 : 367))
1163	1162	{
1164		state->m_clock_regs.days1 = state->m_clock_regs.days2 = state->m_clock_regs.days3 = 0;
	1163	m_clock_regs.days1 = m_clock_regs.days2 = m_clock_regs.days3 = 0;
1165	1164
1166		state->m_clock_regs.years = (state->m_clock_regs.years + 1) & 0xf;
	1165	m_clock_regs.years = (m_clock_regs.years + 1) & 0xf;
1167	1166	}
1168	1167	}
1169	1168	}
r17997	r17998
1175	1174	}
1176	1175
1177	1176	/* set VBI */
1178		if (state->m_VTMSK)
1179		set_VTIR(device->machine(), 1);
	1177	if (m_VTMSK)
	1178	set_VTIR(machine(), 1);
1180	1179	else
1181		set_VTIR(device->machine(), 0);
	1180	set_VTIR(machine(), 0);
1182	1181
1183	1182	/* do keyboard scan */
1184		scan_keyboard(device->machine());
	1183	scan_keyboard(machine());
1185	1184	}
1186	1185
1187	1186	/*

trunk/src/mess/machine/cgenie.c

r17997	r17998
411	411	return result;
412	412	}
413	413
414		INTERRUPT_GEN( cgenie_timer_interrupt )
	414	INTERRUPT_GEN_MEMBER(cgenie_state::cgenie_timer_interrupt)
415	415	{
416		cgenie_state *state = device->machine().driver_data<cgenie_state>();
417		if( (state->m_irq_status & IRQ_TIMER) == 0 )
	416	if( (m_irq_status & IRQ_TIMER) == 0 )
418	417	{
419		state->m_irq_status |= IRQ_TIMER;
420		device->machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
	418	m_irq_status |= IRQ_TIMER;
	419	machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
421	420	}
422	421	}
423	422
r17997	r17998
591	590	*
592	591	*************************************/
593	592
594		INTERRUPT_GEN( cgenie_frame_interrupt )
	593	INTERRUPT_GEN_MEMBER(cgenie_state::cgenie_frame_interrupt)
595	594	{
596		cgenie_state *state = device->machine().driver_data<cgenie_state>();
597		if( state->m_tv_mode != (device->machine().root_device().ioport("DSW0")->read() & 0x10) )
	595	if( m_tv_mode != (machine().root_device().ioport("DSW0")->read() & 0x10) )
598	596	{
599		state->m_tv_mode = state->ioport("DSW0")->read() & 0x10;
	597	m_tv_mode = ioport("DSW0")->read() & 0x10;
600	598	/* force setting of background color */
601		state->m_port_ff ^= FF_BGD0;
602		cgenie_port_ff_w(*device->machine().device("maincpu")->memory().space(AS_PROGRAM), 0, state->m_port_ff ^ FF_BGD0);
	599	m_port_ff ^= FF_BGD0;
	600	cgenie_port_ff_w(*machine().device("maincpu")->memory().space(AS_PROGRAM), 0, m_port_ff ^ FF_BGD0);
603	601	}
604	602	}
605	603

trunk/src/mess/machine/pk8020.c

r17997	r17998
1003	1003	m_sound_level = 0;
1004	1004	}
1005	1005
1006		INTERRUPT_GEN( pk8020_interrupt )
	1006	INTERRUPT_GEN_MEMBER(pk8020_state::pk8020_interrupt)
1007	1007	{
1008		pk8020_state *state = device->machine().driver_data<pk8020_state>();
1009		state->m_takt ^= 1;
1010		pic8259_ir4_w(device->machine().device("pic8259"), 1);
	1008	m_takt ^= 1;
	1009	pic8259_ir4_w(machine().device("pic8259"), 1);
1011	1010	}

trunk/src/mess/includes/compis.h

r17997	r17998
187	187	virtual void machine_reset();
188	188	virtual void palette_init();
189	189	UINT32 screen_update_compis2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	190	INTERRUPT_GEN_MEMBER(compis_vblank_int);
190	191	};
191	192
192	193
r17997	r17998
200	201	extern const i8251_interface compis_usart_interface;
201	202	extern const upd765_interface compis_fdc_interface;
202	203
203		INTERRUPT_GEN(compis_vblank_int);
204
205	204	#endif /* COMPIS_H_ */

trunk/src/mess/includes/vtech2.h

r17997	r17998
55	55	DECLARE_MACHINE_RESET(laser500);
56	56	DECLARE_MACHINE_RESET(laser700);
57	57	UINT32 screen_update_laser(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	58	INTERRUPT_GEN_MEMBER(vtech2_interrupt);
58	59	};
59	60
60	61

trunk/src/mess/includes/pdp1.h

r17997	r17998
261	261	virtual void palette_init();
262	262	UINT32 screen_update_pdp1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
263	263	void screen_eof_pdp1(screen_device &screen, bool state);
	264	INTERRUPT_GEN_MEMBER(pdp1_interrupt);
264	265	};
265	266
266	267	/*----------- defined in video/pdp1.c -----------*/

trunk/src/mess/includes/apple3.h

r17997	r17998
60	60	DECLARE_MACHINE_RESET(apple3);
61	61	DECLARE_VIDEO_START(apple3);
62	62	UINT32 screen_update_apple3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	63	INTERRUPT_GEN_MEMBER(apple3_interrupt);
63	64	};
64	65
65	66
r17997	r17998
69	70	extern const via6522_interface apple3_via_0_intf;
70	71	extern const via6522_interface apple3_via_1_intf;
71	72
72
73		INTERRUPT_GEN( apple3_interrupt );
74
75	73	/*----------- defined in video/apple3.c -----------*/
76	74
77	75	void apple3_write_charmem(running_machine &machine);

trunk/src/mess/includes/c65.h

r17997	r17998
65	65	DECLARE_MACHINE_START(c65);
66	66	DECLARE_PALETTE_INIT(c65);
67	67	UINT32 screen_update_c65(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	68	INTERRUPT_GEN_MEMBER(vic3_raster_irq);
	69	INTERRUPT_GEN_MEMBER(c65_frame_interrupt);
68	70	};
69	71
70	72
r17997	r17998
85	87	void c65_vic_interrupt(running_machine &machine, int level);
86	88	void c65_bankswitch_interface(running_machine &machine, int value);
87	89
88
89		INTERRUPT_GEN( c65_frame_interrupt );
90
91	90	extern const mos6526_interface c65_cia0;
92	91	extern const mos6526_interface c65_cia1;
93	92

trunk/src/mess/includes/mac.h

r17997	r17998
522	522	UINT32 screen_update_macdafb(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
523	523	UINT32 screen_update_macrbvvram(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
524	524	UINT32 screen_update_macpbwd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	525	INTERRUPT_GEN_MEMBER(mac_rbv_vbl);
525	526	};
526	527
527	528	#endif /* MAC_H_ */

trunk/src/mess/includes/mbee.h

r17997	r17998
141	141	DECLARE_MACHINE_RESET(mbee256);
142	142	DECLARE_MACHINE_RESET(mbeett);
143	143	UINT32 screen_update_mbee(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	144	INTERRUPT_GEN_MEMBER(mbee_interrupt);
144	145	};
145	146
146	147
r17997	r17998
149	150	extern const wd17xx_interface mbee_wd17xx_interface;
150	151	extern const z80pio_interface mbee_z80pio_intf;
151	152
152		INTERRUPT_GEN( mbee_interrupt );
153	153	QUICKLOAD_LOAD( mbee );
154	154
155	155

trunk/src/mess/includes/gb.h

r17997	r17998
245	245	DECLARE_PALETTE_INIT(gbc);
246	246	DECLARE_MACHINE_START(gb_video);
247	247	DECLARE_MACHINE_START(gbc_video);
	248	INTERRUPT_GEN_MEMBER(gb_scanline_interrupt);
248	249	};
249	250
250	251
r17997	r17998
252	253
253	254	DEVICE_START(gb_cart);
254	255	DEVICE_IMAGE_LOAD(gb_cart);
255		INTERRUPT_GEN( gb_scanline_interrupt );
256	256	void gb_timer_callback(lr35902_cpu_device *device, int cycles);
257	257
258	258

trunk/src/mess/includes/concept.h

r17997	r17998
56	56	virtual void machine_start();
57	57	virtual void video_start();
58	58	UINT32 screen_update_concept(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	59	INTERRUPT_GEN_MEMBER(concept_interrupt);
59	60	};
60	61
61	62
r17997	r17998
64	65	extern const via6522_interface concept_via6522_intf;
65	66	extern const wd17xx_interface concept_wd17xx_interface;
66	67
67		INTERRUPT_GEN( concept_interrupt );
68
69
70	68	#endif /* CONCEPT_H_ */

trunk/src/mess/includes/msx.h

r17997	r17998
124	124	DECLARE_MACHINE_RESET(msx);
125	125	DECLARE_MACHINE_START(msx2);
126	126	DECLARE_MACHINE_RESET(msx2);
	127	INTERRUPT_GEN_MEMBER(msx_interrupt);
127	128	};
128	129
129	130
r17997	r17998
132	133	extern const i8255_interface msx_ppi8255_interface;
133	134	extern const wd17xx_interface msx_wd17xx_interface;
134	135	/* start/stop functions */
135		extern INTERRUPT_GEN( msx_interrupt );
136	136	extern TIMER_DEVICE_CALLBACK( msx2_interrupt );
137	137
138	138	DEVICE_IMAGE_LOAD( msx_cart );

trunk/src/mess/includes/gamecom.h

r17997	r17998
243	243	virtual void machine_reset();
244	244	virtual void video_start();
245	245	virtual void palette_init();
	246	INTERRUPT_GEN_MEMBER(gamecom_interrupt);
246	247	};
247	248
248	249

trunk/src/mess/includes/b2m.h

r17997	r17998
49	49	virtual void video_start();
50	50	virtual void palette_init();
51	51	UINT32 screen_update_b2m(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	52	INTERRUPT_GEN_MEMBER(b2m_vblank_interrupt);
52	53	};
53	54
54	55	/*----------- defined in machine/b2m.c -----------*/
r17997	r17998
60	61	extern const i8255_interface b2m_ppi8255_interface_2;
61	62	extern const i8255_interface b2m_ppi8255_interface_3;
62	63
63		extern INTERRUPT_GEN( b2m_vblank_interrupt );
64
65	64	#endif

trunk/src/mess/includes/vic20.h

r17997	r17998
91	91
92	92	// keyboard state
93	93	int m_key_col;
	94	INTERRUPT_GEN_MEMBER(vic20_raster_interrupt);
94	95	};
95	96
96	97	#endif

trunk/src/mess/includes/arcadia.h

r17997	r17998
81	81	virtual void video_start();
82	82	virtual void palette_init();
83	83	UINT32 screen_update_arcadia(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	84	INTERRUPT_GEN_MEMBER(arcadia_video_line);
84	85	};
85
86		extern INTERRUPT_GEN( arcadia_video_line );
87	86	#endif /* ARCADIA_H_ */

trunk/src/mess/includes/lisa.h

r17997	r17998
164	164	virtual void machine_reset();
165	165	virtual void video_start();
166	166	UINT32 screen_update_lisa(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	167	INTERRUPT_GEN_MEMBER(lisa_interrupt);
167	168	};
168	169
169	170
r17997	r17998
174	175
175	176	extern NVRAM_HANDLER(lisa);
176	177
177		INTERRUPT_GEN( lisa_interrupt );
178	178
179
180	179	#endif /* LISA_H_ */
181	180

trunk/src/mess/includes/lynx.h

r17997	r17998
145	145
146	146	/*----------- defined in machine/lynx.c -----------*/
147	147
148
149
150
151	148	void lynx_timer_count_down(running_machine &machine, int nr);
152	149
153		INTERRUPT_GEN( lynx_frame_int );
154
155	150	/* These functions are also needed for the Quickload */
156	151	int lynx_verify_cart (char *header, int kind);
157	152	void lynx_crc_keyword(device_image_interface &image);

trunk/src/mess/includes/cgenie.h

r17997	r17998
71	71	DECLARE_PALETTE_INIT(cgenie);
72	72	DECLARE_PALETTE_INIT(cgenienz);
73	73	UINT32 screen_update_cgenie(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	74	INTERRUPT_GEN_MEMBER(cgenie_timer_interrupt);
	75	INTERRUPT_GEN_MEMBER(cgenie_frame_interrupt);
74	76	};
75	77
76	78
r17997	r17998
100	102	DECLARE_READ8_HANDLER ( cgenie_port_ff_r );
101	103	int cgenie_port_xx_r(int offset);
102	104
103		INTERRUPT_GEN( cgenie_timer_interrupt );
104		INTERRUPT_GEN( cgenie_frame_interrupt );
105
106	105	DECLARE_READ8_HANDLER ( cgenie_status_r );
107	106	DECLARE_READ8_HANDLER ( cgenie_track_r );
108	107	DECLARE_READ8_HANDLER ( cgenie_sector_r );

trunk/src/mess/includes/x68k.h

r17997	r17998
267	267	DECLARE_VIDEO_START(x68000);
268	268	DECLARE_PALETTE_INIT(x68000);
269	269	UINT32 screen_update_x68000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	270	INTERRUPT_GEN_MEMBER(x68k_vsync_irq);
270	271	};
271	272
272	273

trunk/src/mess/includes/spectrum.h

r17997	r17998
123	123	UINT32 screen_update_tc2048(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
124	124	UINT32 screen_update_ts2068(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
125	125	void screen_eof_spectrum(screen_device &screen, bool state);
	126	INTERRUPT_GEN_MEMBER(spec_interrupt);
126	127	};
127	128
128	129

trunk/src/mess/includes/ondra.h

r17997	r17998
24	24	virtual void machine_reset();
25	25	virtual void video_start();
26	26	UINT32 screen_update_ondra(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	27	INTERRUPT_GEN_MEMBER(ondra_interrupt);
27	28	};
28	29
29	30	#endif

trunk/src/mess/includes/kaypro.h

r17997	r17998
78	78	UINT32 screen_update_kayproii(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
79	79	UINT32 screen_update_kaypro2x(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
80	80	UINT32 screen_update_omni2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	81	INTERRUPT_GEN_MEMBER(kay_kbd_interrupt);
81	82	};
82	83
83	84
r17997	r17998
86	87	UINT8 kay_kbd_c_r( running_machine &machine );
87	88	UINT8 kay_kbd_d_r( running_machine &machine );
88	89	void kay_kbd_d_w( running_machine &machine, UINT8 data );
89		INTERRUPT_GEN( kay_kbd_interrupt );
90	90
91	91	INPUT_PORTS_EXTERN( kay_kbd );
92	92

trunk/src/mess/includes/plus4.h

r17997	r17998
107	107	// keyboard state
108	108	UINT8 m_port6529;
109	109	UINT8 m_keyline[10];
	110	INTERRUPT_GEN_MEMBER(c16_raster_interrupt);
	111	INTERRUPT_GEN_MEMBER(c16_frame_interrupt);
110	112	};
111	113
112	114

trunk/src/mess/includes/tx0.h

r17997	r17998
152	152	virtual void palette_init();
153	153	UINT32 screen_update_tx0(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
154	154	void screen_eof_tx0(screen_device &screen, bool state);
	155	INTERRUPT_GEN_MEMBER(tx0_interrupt);
155	156	};
156	157
157	158

trunk/src/mess/includes/c128.h

r17997	r17998
220	220	DECLARE_DRIVER_INIT(c128d);
221	221	DECLARE_DRIVER_INIT(c128);
222	222	DECLARE_DRIVER_INIT(c128d81);
	223	INTERRUPT_GEN_MEMBER(c128_frame_interrupt);
223	224	};
224	225
225	226
226	227	/*----------- defined in machine/c128.c -----------*/
227	228
228		extern INTERRUPT_GEN( c128_frame_interrupt );
229
230	229	extern const mos6526_interface c128_cia1_intf, c128_cia2_intf;
231	230
232	231	#endif /* __C128_H__ */

trunk/src/mess/includes/p2000t.h

r17997	r17998
44	44	DECLARE_VIDEO_START(p2000m);
45	45	DECLARE_PALETTE_INIT(p2000m);
46	46	UINT32 screen_update_p2000m(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	47	INTERRUPT_GEN_MEMBER(p2000_interrupt);
47	48	};
48	49
49	50	#endif /* P2000T_H_ */

trunk/src/mess/includes/pet.h

r17997	r17998
56	56	virtual void palette_init();
57	57	DECLARE_VIDEO_START(pet_crtc);
58	58	UINT32 screen_update_pet(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	59	INTERRUPT_GEN_MEMBER(pet_frame_interrupt);
59	60	};
60	61
61	62	/*----------- defined in video/pet.c -----------*/
r17997	r17998
82	83	extern DECLARE_READ8_HANDLER(superpet_r);
83	84	extern DECLARE_WRITE8_HANDLER(superpet_w);
84	85
85
86		INTERRUPT_GEN( pet_frame_interrupt );
87
88	86	MACHINE_CONFIG_EXTERN( pet_cartslot );
89	87	MACHINE_CONFIG_EXTERN( pet4_cartslot );
90	88

trunk/src/mess/includes/c16.h

r17997	r17998
75	75	extern int c16_dma_read(running_machine &machine, int offset);
76	76	extern int c16_dma_read_rom(running_machine &machine, int offset);
77	77
78		extern INTERRUPT_GEN( c16_frame_interrupt );
79
80	78	MACHINE_CONFIG_EXTERN( c16_cartslot );
81	79
82	80	#endif /* __C16_H__ */

trunk/src/mess/includes/vector06.h

r17997	r17998
64	64	virtual void video_start();
65	65	virtual void palette_init();
66	66	UINT32 screen_update_vector06(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	67	INTERRUPT_GEN_MEMBER(vector06_interrupt);
67	68	};
68	69
69	70
70	71	/*----------- defined in machine/vector06.c -----------*/
71
72	72	extern const i8255_interface vector06_ppi8255_interface;
73	73	extern const i8255_interface vector06_ppi8255_2_interface;
74	74
75		extern INTERRUPT_GEN( vector06_interrupt );
76
77	75	#endif /* VECTOR06_H_ */

trunk/src/mess/includes/c64_legacy.h

r17997	r17998
90	90	DECLARE_DRIVER_INIT( ultimax );
91	91	DECLARE_DRIVER_INIT( c64gs );
92	92	DECLARE_DRIVER_INIT( sx64 );
	93	INTERRUPT_GEN_MEMBER(c64_frame_interrupt);
93	94	};
94	95
95	96
r17997	r17998
105	106
106	107	MACHINE_START( c64 );
107	108	MACHINE_RESET( c64 );
108		INTERRUPT_GEN( c64_frame_interrupt );
109	109	TIMER_CALLBACK( c64_tape_timer );
110	110
111	111	/* private area */

trunk/src/mess/includes/orion.h

r17997	r17998
63	63	DECLARE_MACHINE_RESET(orionz80);
64	64	DECLARE_MACHINE_RESET(orionpro);
65	65	UINT32 screen_update_orion128(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	66	INTERRUPT_GEN_MEMBER(orionz80_interrupt);
66	67	};
67	68
68
69	69	/*----------- defined in machine/orion.c -----------*/
70
71	70	extern const i8255_interface orion128_ppi8255_interface_1;
72	71
73		extern INTERRUPT_GEN( orionz80_interrupt );
74
75
76	72	#endif /* ORION_H_ */
77	73

trunk/src/mess/includes/fmtowns.h

r17997	r17998
274	274	void poll_keyboard();
275	275	void mouse_timeout();
276	276	void wait_end();
	277	public:
	278	INTERRUPT_GEN_MEMBER(towns_vsync_irq);
277	279	};
278	280
279	281	class marty_state : public towns_state
r17997	r17998
286	288	virtual void driver_start();
287	289	};
288	290
289		INTERRUPT_GEN( towns_vsync_irq );
290		//VIDEO_START( towns );
291		//SCREEN_UPDATE_RGB32( towns );
292
293	291	#endif /*FMTOWNS_H_*/

trunk/src/mess/includes/gmaster.h

r17997	r17998
32	32	DECLARE_DRIVER_INIT(gmaster);
33	33	virtual void palette_init();
34	34	UINT32 screen_update_gmaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	35	INTERRUPT_GEN_MEMBER(gmaster_interrupt);
35	36	};
36	37
37	38

trunk/src/mess/includes/newbrain.h

r17997	r17998
157	157	int m_copstate;
158	158	int m_copbytes;
159	159	int m_copregint;
	160	INTERRUPT_GEN_MEMBER(newbrain_interrupt);
160	161	};
161	162
162	163	class newbrain_eim_state : public newbrain_state

trunk/src/mess/includes/microtan.h

r17997	r17998
52	52	virtual void machine_reset();
53	53	virtual void video_start();
54	54	UINT32 screen_update_microtan(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	55	INTERRUPT_GEN_MEMBER(microtan_interrupt);
55	56	};
56	57
57	58
r17997	r17998
63	64	SNAPSHOT_LOAD( microtan );
64	65	QUICKLOAD_LOAD( microtan_hexfile );
65	66
66		INTERRUPT_GEN( microtan_interrupt );
67
68	67	#endif /* MICROTAN_H_ */

trunk/src/mess/includes/intv.h

r17997	r17998
132	132	DECLARE_MACHINE_RESET(intvecs);
133	133	UINT32 screen_update_intv(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
134	134	UINT32 screen_update_intvkbd(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	135	INTERRUPT_GEN_MEMBER(intv_interrupt2);
	136	INTERRUPT_GEN_MEMBER(intv_interrupt);
135	137	};
136	138
137	139	/*----------- defined in video/intv.c -----------*/
r17997	r17998
144	146	DEVICE_START( intv_cart );
145	147	DEVICE_IMAGE_LOAD( intv_cart );
146	148
147		extern INTERRUPT_GEN( intv_interrupt );
148	149	/* for the console + keyboard component... */
149	150
150	151	DEVICE_IMAGE_LOAD( intvkbd_cart );

trunk/src/mess/includes/poly88.h

r17997	r17998
34	34	virtual void machine_reset();
35	35	virtual void video_start();
36	36	UINT32 screen_update_poly88(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	37	INTERRUPT_GEN_MEMBER(poly88_interrupt);
37	38	};
38	39
39	40
40	41	/*----------- defined in machine/poly88.c -----------*/
41
42
43		INTERRUPT_GEN( poly88_interrupt );
44
45	42	extern const i8251_interface poly88_usart_interface;
46	43
47	44	extern SNAPSHOT_LOAD( poly88 );

trunk/src/mess/includes/samcoupe.h

r17997	r17998
82	82	virtual void machine_start();
83	83	virtual void machine_reset();
84	84	virtual void palette_init();
	85	INTERRUPT_GEN_MEMBER(samcoupe_frame_interrupt);
85	86	};
86	87
87	88

trunk/src/mess/includes/trs80.h

r17997	r17998
122	122	UINT32 screen_update_lnw80(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
123	123	UINT32 screen_update_radionic(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
124	124	UINT32 screen_update_meritum(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	125	INTERRUPT_GEN_MEMBER(trs80_rtc_interrupt);
	126	INTERRUPT_GEN_MEMBER(trs80_fdc_interrupt);
125	127	};
126	128
127	129
r17997	r17998
129	131
130	132	extern const wd17xx_interface trs80_wd17xx_interface;
131	133
132		INTERRUPT_GEN( trs80_rtc_interrupt );
133		INTERRUPT_GEN( trs80_fdc_interrupt );
134
135	134	#endif   /* TRS80_H_ */

trunk/src/mess/includes/primo.h

r17997	r17998
34	34	virtual void machine_reset();
35	35	DECLARE_MACHINE_RESET(primob);
36	36	UINT32 screen_update_primo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	37	INTERRUPT_GEN_MEMBER(primo_vblank_interrupt);
37	38	};
38	39
39	40
40	41	/*----------- defined in machine/primo.c -----------*/
41	42
42		extern INTERRUPT_GEN( primo_vblank_interrupt );
43	43	extern SNAPSHOT_LOAD( primo );
44	44	extern QUICKLOAD_LOAD( primo );
45	45

trunk/src/mess/includes/svision.h

r17997	r17998
56	56	DECLARE_MACHINE_RESET(tvlink);
57	57	UINT32 screen_update_svision(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
58	58	UINT32 screen_update_tvlink(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	59	INTERRUPT_GEN_MEMBER(svision_frame_int);
59	60	};
60	61
61	62

trunk/src/mess/includes/c64.h

r17997	r17998
142	142	int m_cass_rd;
143	143	int m_iec_srq;
144	144	DECLARE_DRIVER_INIT(c64pal);
	145	INTERRUPT_GEN_MEMBER(c64_frame_interrupt);
145	146	};
146	147
147	148

trunk/src/mess/includes/vc4000.h

r17997	r17998
97	97	virtual void video_start();
98	98	virtual void palette_init();
99	99	UINT32 screen_update_vc4000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	100	INTERRUPT_GEN_MEMBER(vc4000_video_line);
100	101	};
101	102
102
103		/*----------- defined in video/vc4000.c -----------*/
104
105		extern INTERRUPT_GEN( vc4000_video_line );
106
107	103	/*----------- defined in audio/vc4000.c -----------*/
108	104
109	105	class vc4000_sound_device : public device_t,

trunk/src/mess/includes/vic10.h

r17997	r17998
83	83	int m_cia_irq;
84	84	int m_vic_irq;
85	85	int m_exp_irq;
	86	INTERRUPT_GEN_MEMBER(vic10_frame_interrupt);
86	87	};
87	88
88	89

trunk/src/mess/includes/pk8020.h

r17997	r17998
45	45	virtual void video_start();
46	46	virtual void palette_init();
47	47	UINT32 screen_update_pk8020(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	48	INTERRUPT_GEN_MEMBER(pk8020_interrupt);
48	49	};
49	50
50	51
r17997	r17998
54	55	extern const i8255_interface pk8020_ppi8255_interface_3;
55	56	extern const struct pit8253_config pk8020_pit8253_intf;
56	57	extern const struct pic8259_interface pk8020_pic8259_config;
57		extern INTERRUPT_GEN( pk8020_interrupt );
58	58
59	59	#endif /* pk8020_H_ */

trunk/src/mess/includes/galaxy.h

r17997	r17998
32	32	DECLARE_MACHINE_RESET(galaxy);
33	33	DECLARE_MACHINE_RESET(galaxyp);
34	34	UINT32 screen_update_galaxy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	35	INTERRUPT_GEN_MEMBER(galaxy_interrupt);
35	36	};
36	37
37	38
38	39	/*----------- defined in machine/galaxy.c -----------*/
39		INTERRUPT_GEN( galaxy_interrupt );
40	40	SNAPSHOT_LOAD( galaxy );
41	41
42	42	/*----------- defined in video/galaxy.c -----------*/

trunk/src/mess/includes/bbc.h

r17997	r17998
282	282	DECLARE_MACHINE_RESET(bbcbp);
283	283	DECLARE_VIDEO_START(bbcbp);
284	284	UINT32 screen_update_bbc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	285	INTERRUPT_GEN_MEMBER(bbcb_vsync);
	286	INTERRUPT_GEN_MEMBER(bbcb_keyscan);
	287	INTERRUPT_GEN_MEMBER(bbcm_keyscan);
285	288	};
286	289
287	290
r17997	r17998
295	298	extern const via6522_interface bbcb_user_via;
296	299	extern const wd17xx_interface bbc_wd17xx_interface;
297	300
298		INTERRUPT_GEN( bbcb_keyscan );
299		INTERRUPT_GEN( bbcm_keyscan );
300
301	301	/* disc support */
302	302
303	303	DEVICE_IMAGE_LOAD ( bbcb_cart );

trunk/src/mess/video/arcadia.c

r17997	r17998
613	613	if (arcadia_sprite_collision(state,2,3)) state->m_reg.d.collision_sprite&=~0x20; //guess
614	614	}
615	615
616		INTERRUPT_GEN( arcadia_video_line )
	616	INTERRUPT_GEN_MEMBER(arcadia_state::arcadia_video_line)
617	617	{
618		arcadia_state *state = device->machine().driver_data<arcadia_state>();
619		screen_device *screen = device->machine().first_screen();
	618	screen_device *screen = machine().first_screen();
620	619	int width = screen->width();
621	620
622		if (state->m_ad_delay<=0)
623		state->m_ad_select=state->m_reg.d.pal[1]&0x40;
624		else state->m_ad_delay--;
	621	if (m_ad_delay<=0)
	622	m_ad_select=m_reg.d.pal[1]&0x40;
	623	else m_ad_delay--;
625	624
626		state->m_line++;
627		state->m_line%=262;
	625	m_line++;
	626	m_line%=262;
628	627	// unbelievable, reflects only charline, but alien invaders uses it for
629	628	// alien scrolling
630	629
631		if (state->m_line<state->m_ypos)
	630	if (m_line<m_ypos)
632	631	{
633		state->m_bitmap->plot_box(0, state->m_line, width, 1, (state->m_reg.d.pal[1])&7);
634		memset(state->m_bg[state->m_line], 0, sizeof(state->m_bg[0]));
	632	m_bitmap->plot_box(0, m_line, width, 1, (m_reg.d.pal[1])&7);
	633	memset(m_bg[m_line], 0, sizeof(m_bg[0]));
635	634	}
636	635	else
637	636	{
638		int h=state->m_doublescan?16:8;
	637	int h=m_doublescan?16:8;
639	638
640		state->m_charline=(state->m_line-state->m_ypos)/h;
	639	m_charline=(m_line-m_ypos)/h;
641	640
642		if (state->m_charline<13)
	641	if (m_charline<13)
643	642	{
644		if (((state->m_line-state->m_ypos)&(h-1))==0)
	643	if (((m_line-m_ypos)&(h-1))==0)
645	644	{
646		arcadia_vh_draw_line(device->machine(), *state->m_bitmap, state->m_charline*h+state->m_ypos,
647		state->m_reg.d.chars1[state->m_charline]);
	645	arcadia_vh_draw_line(machine(), *m_bitmap, m_charline*h+m_ypos,
	646	m_reg.d.chars1[m_charline]);
648	647	}
649	648	}
650	649	else
651		if (state->m_lines26 && (state->m_charline<26))
	650	if (m_lines26 && (m_charline<26))
652	651	{
653		if (((state->m_line-state->m_ypos)&(h-1))==0)
	652	if (((m_line-m_ypos)&(h-1))==0)
654	653	{
655		arcadia_vh_draw_line(device->machine(), *state->m_bitmap, state->m_charline*h+state->m_ypos,
656		state->m_reg.d.chars2[state->m_charline-13]);
	654	arcadia_vh_draw_line(machine(), *m_bitmap, m_charline*h+m_ypos,
	655	m_reg.d.chars2[m_charline-13]);
657	656	}
658		state->m_charline-=13;
	657	m_charline-=13;
659	658	}
660	659	else
661	660	{
662		state->m_charline=0xd;
663		state->m_bitmap->plot_box(0, state->m_line, width, 1, (state->m_reg.d.pal[1])&7);
664		memset(state->m_bg[state->m_line], 0, sizeof(state->m_bg[0]));
	661	m_charline=0xd;
	662	m_bitmap->plot_box(0, m_line, width, 1, (m_reg.d.pal[1])&7);
	663	memset(m_bg[m_line], 0, sizeof(m_bg[0]));
665	664	}
666	665	}
667		if (state->m_line==261)
668		arcadia_draw_sprites(device->machine(), *state->m_bitmap);
	666	if (m_line==261)
	667	arcadia_draw_sprites(machine(), *m_bitmap);
669	668	}
670	669
671	670	READ8_MEMBER( arcadia_state::arcadia_vsync_r )

trunk/src/mess/video/fmtowns.c

r17997	r17998
1787	1787	state->m_video.towns_vblank_flag = 0;
1788	1788	}
1789	1789
1790		INTERRUPT_GEN( towns_vsync_irq )
	1790	INTERRUPT_GEN_MEMBER(towns_state::towns_vsync_irq)
1791	1791	{
1792		towns_state* state = device->machine().driver_data<towns_state>();
1793		device_t* dev = state->m_pic_slave;
	1792	device_t* dev = m_pic_slave;
1794	1793	pic8259_ir3_w(dev, 1);  // IRQ11 = VSync
1795	1794	if(IRQ_LOG) logerror("PIC: IRQ11 (VSync) set high\n");
1796		state->m_video.towns_vblank_flag = 1;
1797		device->machine().scheduler().timer_set(device->machine().primary_screen->time_until_vblank_end(), FUNC(towns_vblank_end), 0, (void*)dev);
1798		if(state->m_video.towns_tvram_enable)
	1795	m_video.towns_vblank_flag = 1;
	1796	machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_end(), FUNC(towns_vblank_end), 0, (void*)dev);
	1797	if(m_video.towns_tvram_enable)
1799	1798	draw_text_layer(dev->machine());
1800		if(state->m_video.towns_sprite_reg[1] & 0x80)
1801		draw_sprites(dev->machine(),&state->m_video.towns_crtc_layerscr[1]);
	1799	if(m_video.towns_sprite_reg[1] & 0x80)
	1800	draw_sprites(dev->machine(),&m_video.towns_crtc_layerscr[1]);
1802	1801	}
1803	1802
1804	1803	void towns_state::video_start()

trunk/src/mess/video/vc4000.c

r17997	r17998
573	573	}
574	574	}
575	575
576		INTERRUPT_GEN( vc4000_video_line )
	576	INTERRUPT_GEN_MEMBER(vc4000_state::vc4000_video_line)
577	577	{
578		vc4000_state *state = device->machine().driver_data<vc4000_state>();
579	578	int x,y,i;
580	579	UINT8 collision[400]={0}; // better alloca or gcc feature of non constant long automatic arrays
581		const rectangle &visarea = device->machine().primary_screen->visible_area();
582		assert(ARRAY_LENGTH(collision) >= device->machine().primary_screen->width());
	580	const rectangle &visarea = machine().primary_screen->visible_area();
	581	assert(ARRAY_LENGTH(collision) >= machine().primary_screen->width());
583	582
584		state->m_video.line++;
585		if (state->m_irq_pause) state->m_irq_pause++;
586		if (state->m_video.line>311) state->m_video.line=0;
	583	m_video.line++;
	584	if (m_irq_pause) m_irq_pause++;
	585	if (m_video.line>311) m_video.line=0;
587	586
588		if (state->m_video.line==0)
	587	if (m_video.line==0)
589	588	{
590		state->m_video.background_collision=0;
591		state->m_video.sprite_collision=0;
592		state->m_video.reg.d.sprite_collision=0;
	589	m_video.background_collision=0;
	590	m_video.sprite_collision=0;
	591	m_video.reg.d.sprite_collision=0;
593	592	//      logerror("begin of frame\n");
594	593	}
595	594
596		if (state->m_irq_pause>10)
	595	if (m_irq_pause>10)
597	596	{
598		device->machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
599		state->m_irq_pause = 0;
	597	machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
	598	m_irq_pause = 0;
600	599	}
601	600
602		if (state->m_video.line <= VC4000_END_LINE)
	601	if (m_video.line <= VC4000_END_LINE)
603	602	{
604		vc4000_draw_grid(device->machine(), collision);
	603	vc4000_draw_grid(machine(), collision);
605	604
606	605	/* init object colours */
607		for (i=visarea.min_x; i<visarea.max_x; i++) state->m_objects[i]=8;
	606	for (i=visarea.min_x; i<visarea.max_x; i++) m_objects[i]=8;
608	607
609	608	/* calculate object colours and OR overlapping object colours */
610		vc4000_sprite_update(state, *state->m_bitmap, collision, &state->m_video.sprites[0]);
611		vc4000_sprite_update(state, *state->m_bitmap, collision, &state->m_video.sprites[1]);
612		vc4000_sprite_update(state, *state->m_bitmap, collision, &state->m_video.sprites[2]);
613		vc4000_sprite_update(state, *state->m_bitmap, collision, &state->m_video.sprites[3]);
	609	vc4000_sprite_update(this, *m_bitmap, collision, &m_video.sprites[0]);
	610	vc4000_sprite_update(this, *m_bitmap, collision, &m_video.sprites[1]);
	611	vc4000_sprite_update(this, *m_bitmap, collision, &m_video.sprites[2]);
	612	vc4000_sprite_update(this, *m_bitmap, collision, &m_video.sprites[3]);
614	613
615	614	for (i=visarea.min_x; i<visarea.max_x; i++)
616	615	{
617		state->m_video.sprite_collision|=state->m_sprite_collision[collision[i]];
618		state->m_video.background_collision|=state->m_background_collision[collision[i]];
	616	m_video.sprite_collision|=m_sprite_collision[collision[i]];
	617	m_video.background_collision|=m_background_collision[collision[i]];
619	618	/* display final object colours */
620		if (state->m_objects[i] < 8)
621		state->m_bitmap->pix16(state->m_video.line, i) = state->m_objects[i];
	619	if (m_objects[i] < 8)
	620	m_bitmap->pix16(m_video.line, i) = m_objects[i];
622	621	}
623	622
624		y = state->m_video.reg.d.score_control&1?200:20;
	623	y = m_video.reg.d.score_control&1?200:20;
625	624
626		if ((state->m_video.line>=y)&&(state->m_video.line<y+20))
	625	if ((m_video.line>=y)&&(m_video.line<y+20))
627	626	{
628	627	x = 60;
629		vc4000_draw_digit(state, *state->m_bitmap, x, y, state->m_video.reg.d.bcd[0]>>4, state->m_video.line-y);
630		vc4000_draw_digit(state, *state->m_bitmap, x+16, y, state->m_video.reg.d.bcd[0]&0xf, state->m_video.line-y);
631		if (state->m_video.reg.d.score_control&2)   x -= 16;
632		vc4000_draw_digit(state, *state->m_bitmap, x+48, y, state->m_video.reg.d.bcd[1]>>4, state->m_video.line-y);
633		vc4000_draw_digit(state, *state->m_bitmap, x+64, y, state->m_video.reg.d.bcd[1]&0xf, state->m_video.line-y);
	628	vc4000_draw_digit(this, *m_bitmap, x, y, m_video.reg.d.bcd[0]>>4, m_video.line-y);
	629	vc4000_draw_digit(this, *m_bitmap, x+16, y, m_video.reg.d.bcd[0]&0xf, m_video.line-y);
	630	if (m_video.reg.d.score_control&2)   x -= 16;
	631	vc4000_draw_digit(this, *m_bitmap, x+48, y, m_video.reg.d.bcd[1]>>4, m_video.line-y);
	632	vc4000_draw_digit(this, *m_bitmap, x+64, y, m_video.reg.d.bcd[1]&0xf, m_video.line-y);
634	633	}
635	634	}
636		if (state->m_video.line==VC4000_END_LINE) state->m_video.reg.d.sprite_collision |=0x40;
	635	if (m_video.line==VC4000_END_LINE) m_video.reg.d.sprite_collision |=0x40;
637	636
638		if (((state->m_video.line == VC4000_END_LINE) |
639		(state->m_video.sprites[3].finished_now) |
640		(state->m_video.sprites[2].finished_now) |
641		(state->m_video.sprites[1].finished_now) |
642		(state->m_video.sprites[0].finished_now)) && (!state->m_irq_pause))
	637	if (((m_video.line == VC4000_END_LINE) |
	638	(m_video.sprites[3].finished_now) |
	639	(m_video.sprites[2].finished_now) |
	640	(m_video.sprites[1].finished_now) |
	641	(m_video.sprites[0].finished_now)) && (!m_irq_pause))
643	642	{
644		device->machine().device("maincpu")->execute().set_input_line_and_vector(0, ASSERT_LINE, 3);
645		state->m_irq_pause=1;
	643	machine().device("maincpu")->execute().set_input_line_and_vector(0, ASSERT_LINE, 3);
	644	m_irq_pause=1;
646	645	}
647	646	}
648	647

trunk/src/mess/drivers/rainbow.c

r17997	r17998
132	132	virtual void machine_reset();
133	133	public:
134	134	UINT32 screen_update_rainbow(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	135	INTERRUPT_GEN_MEMBER(vblank_irq);
135	136	};
136	137
137	138	void rainbow_state::machine_start()
r17997	r17998
316	317	return m_p_ram[offset];
317	318	}
318	319
319		static INTERRUPT_GEN( vblank_irq )
	320	INTERRUPT_GEN_MEMBER(rainbow_state::vblank_irq)
320	321	{
321		device->execute().set_input_line_and_vector(INPUT_LINE_INT0, ASSERT_LINE, 0x20);
	322	device.execute().set_input_line_and_vector(INPUT_LINE_INT0, ASSERT_LINE, 0x20);
322	323	}
323	324
324	325	WRITE8_MEMBER( rainbow_state::clear_video_interrupt )
r17997	r17998
463	464	MCFG_CPU_ADD("maincpu",I8088, XTAL_24_0734MHz / 5)
464	465	MCFG_CPU_PROGRAM_MAP(rainbow8088_map)
465	466	MCFG_CPU_IO_MAP(rainbow8088_io)
466		MCFG_CPU_VBLANK_INT("screen", vblank_irq)
	467	MCFG_CPU_VBLANK_INT_DRIVER("screen", rainbow_state, vblank_irq)
467	468
468	469	MCFG_CPU_ADD("subcpu",Z80, XTAL_24_0734MHz / 6)
469	470	MCFG_CPU_PROGRAM_MAP(rainbowz80_mem)

trunk/src/mess/drivers/pdp1.c

r17997	r17998
1801	1801	/*
1802	1802	Not a real interrupt - just handle keyboard input
1803	1803	*/
1804		INTERRUPT_GEN( pdp1_interrupt )
	1804	INTERRUPT_GEN_MEMBER(pdp1_state::pdp1_interrupt)
1805	1805	{
1806		pdp1_state *state = device->machine().driver_data<pdp1_state>();
1807		running_machine &machine = device->machine();
1808	1806	int control_keys;
1809	1807	int tw_keys;
1810	1808	int ta_keys;
r17997	r17998
1814	1812	int ta_transitions;
1815	1813
1816	1814
1817		device->state().set_state_int(PDP1_SS, device->machine().root_device().ioport("SENSE")->read());
	1815	device.state().set_state_int(PDP1_SS, machine().root_device().ioport("SENSE")->read());
1818	1816
1819	1817	/* read new state of control keys */
1820		control_keys = state->ioport("CSW")->read();
	1818	control_keys = ioport("CSW")->read();
1821	1819
1822	1820	if (control_keys & pdp1_control)
1823	1821	{
1824	1822	/* compute transitions */
1825		control_transitions = control_keys & (~ state->m_old_control_keys);
	1823	control_transitions = control_keys & (~ m_old_control_keys);
1826	1824
1827	1825	if (control_transitions & pdp1_extend)
1828	1826	{
1829		device->state().set_state_int(PDP1_EXTEND_SW, ! device->state().state_int(PDP1_EXTEND_SW));
	1827	device.state().set_state_int(PDP1_EXTEND_SW, ! device.state().state_int(PDP1_EXTEND_SW));
1830	1828	}
1831	1829	if (control_transitions & pdp1_start_nobrk)
1832	1830	{
1833		pdp1_pulse_start_clear(device);   /* pulse Start Clear line */
1834		device->state().set_state_int(PDP1_EXD, device->state().state_int(PDP1_EXTEND_SW));
1835		device->state().set_state_int(PDP1_SBM, (UINT64)0);
1836		device->state().set_state_int(PDP1_OV, (UINT64)0);
1837		device->state().set_state_int(PDP1_PC, device->state().state_int(PDP1_TA));
1838		device->state().set_state_int(PDP1_RUN, 1);
	1831	pdp1_pulse_start_clear(&device);   /* pulse Start Clear line */
	1832	device.state().set_state_int(PDP1_EXD, device.state().state_int(PDP1_EXTEND_SW));
	1833	device.state().set_state_int(PDP1_SBM, (UINT64)0);
	1834	device.state().set_state_int(PDP1_OV, (UINT64)0);
	1835	device.state().set_state_int(PDP1_PC, device.state().state_int(PDP1_TA));
	1836	device.state().set_state_int(PDP1_RUN, 1);
1839	1837	}
1840	1838	if (control_transitions & pdp1_start_brk)
1841	1839	{
1842		pdp1_pulse_start_clear(device);   /* pulse Start Clear line */
1843		device->state().set_state_int(PDP1_EXD, device->state().state_int(PDP1_EXTEND_SW));
1844		device->state().set_state_int(PDP1_SBM, 1);
1845		device->state().set_state_int(PDP1_OV, (UINT64)0);
1846		device->state().set_state_int(PDP1_PC, device->state().state_int(PDP1_TA));
1847		device->state().set_state_int(PDP1_RUN, 1);
	1840	pdp1_pulse_start_clear(&device);   /* pulse Start Clear line */
	1841	device.state().set_state_int(PDP1_EXD, device.state().state_int(PDP1_EXTEND_SW));
	1842	device.state().set_state_int(PDP1_SBM, 1);
	1843	device.state().set_state_int(PDP1_OV, (UINT64)0);
	1844	device.state().set_state_int(PDP1_PC, device.state().state_int(PDP1_TA));
	1845	device.state().set_state_int(PDP1_RUN, 1);
1848	1846	}
1849	1847	if (control_transitions & pdp1_stop)
1850	1848	{
1851		device->state().set_state_int(PDP1_RUN, (UINT64)0);
1852		device->state().set_state_int(PDP1_RIM, (UINT64)0);   /* bug : we stop after reading an even-numbered word
	1849	device.state().set_state_int(PDP1_RUN, (UINT64)0);
	1850	device.state().set_state_int(PDP1_RIM, (UINT64)0);   /* bug : we stop after reading an even-numbered word
1853	1851	(i.e. data), whereas a real pdp-1 stops after reading
1854	1852	an odd-numbered word (i.e. dio instruciton) */
1855	1853	}
1856	1854	if (control_transitions & pdp1_continue)
1857	1855	{
1858		device->state().set_state_int(PDP1_RUN, 1);
	1856	device.state().set_state_int(PDP1_RUN, 1);
1859	1857	}
1860	1858	if (control_transitions & pdp1_examine)
1861	1859	{
1862		pdp1_pulse_start_clear(device);   /* pulse Start Clear line */
1863		device->state().set_state_int(PDP1_PC, device->state().state_int(PDP1_TA));
1864		device->state().set_state_int(PDP1_MA, device->state().state_int(PDP1_PC));
1865		device->state().set_state_int(PDP1_IR, LAC);   /* this instruction is actually executed */
	1860	pdp1_pulse_start_clear(&device);   /* pulse Start Clear line */
	1861	device.state().set_state_int(PDP1_PC, device.state().state_int(PDP1_TA));
	1862	device.state().set_state_int(PDP1_MA, device.state().state_int(PDP1_PC));
	1863	device.state().set_state_int(PDP1_IR, LAC);   /* this instruction is actually executed */
1866	1864
1867		device->state().set_state_int(PDP1_MB, (signed)device->memory().space(AS_PROGRAM)->read_dword(PDP1_MA<<2));
1868		device->state().set_state_int(PDP1_AC, device->state().state_int(PDP1_MB));
	1865	device.state().set_state_int(PDP1_MB, (signed)device.memory().space(AS_PROGRAM)->read_dword(PDP1_MA<<2));
	1866	device.state().set_state_int(PDP1_AC, device.state().state_int(PDP1_MB));
1869	1867	}
1870	1868	if (control_transitions & pdp1_deposit)
1871	1869	{
1872		pdp1_pulse_start_clear(device);   /* pulse Start Clear line */
1873		device->state().set_state_int(PDP1_PC, device->state().state_int(PDP1_TA));
1874		device->state().set_state_int(PDP1_MA, device->state().state_int(PDP1_PC));
1875		device->state().set_state_int(PDP1_AC, device->state().state_int(PDP1_TW));
1876		device->state().set_state_int(PDP1_IR, DAC);   /* this instruction is actually executed */
	1870	pdp1_pulse_start_clear(&device);   /* pulse Start Clear line */
	1871	device.state().set_state_int(PDP1_PC, device.state().state_int(PDP1_TA));
	1872	device.state().set_state_int(PDP1_MA, device.state().state_int(PDP1_PC));
	1873	device.state().set_state_int(PDP1_AC, device.state().state_int(PDP1_TW));
	1874	device.state().set_state_int(PDP1_IR, DAC);   /* this instruction is actually executed */
1877	1875
1878		device->state().set_state_int(PDP1_MB, device->state().state_int(PDP1_AC));
1879		device->memory().space(AS_PROGRAM)->write_dword(device->state().state_int(PDP1_MA)<<2, device->state().state_int(PDP1_MB));
	1876	device.state().set_state_int(PDP1_MB, device.state().state_int(PDP1_AC));
	1877	device.memory().space(AS_PROGRAM)->write_dword(device.state().state_int(PDP1_MA)<<2, device.state().state_int(PDP1_MB));
1880	1878	}
1881	1879	if (control_transitions & pdp1_read_in)
1882	1880	{   /* set cpu to read instructions from perforated tape */
1883		pdp1_pulse_start_clear(device);   /* pulse Start Clear line */
1884		device->state().set_state_int(PDP1_PC, (  device->state().state_int(PDP1_TA) & 0170000)
1885		|  (device->state().state_int(PDP1_PC) & 0007777));   /* transfer ETA to EPC */
	1881	pdp1_pulse_start_clear(&device);   /* pulse Start Clear line */
	1882	device.state().set_state_int(PDP1_PC, (  device.state().state_int(PDP1_TA) & 0170000)
	1883	|  (device.state().state_int(PDP1_PC) & 0007777));   /* transfer ETA to EPC */
1886	1884	/*machine.device("maincpu")->state().set_state_int(PDP1_MA, machine.device("maincpu")->state().state_int(PDP1_PC));*/
1887		device->state().set_state_int(PDP1_EXD, device->state().state_int(PDP1_EXTEND_SW));
1888		device->state().set_state_int(PDP1_OV, (UINT64)0);      /* right??? */
1889		device->state().set_state_int(PDP1_RUN, (UINT64)0);
1890		device->state().set_state_int(PDP1_RIM, 1);
	1885	device.state().set_state_int(PDP1_EXD, device.state().state_int(PDP1_EXTEND_SW));
	1886	device.state().set_state_int(PDP1_OV, (UINT64)0);      /* right??? */
	1887	device.state().set_state_int(PDP1_RUN, (UINT64)0);
	1888	device.state().set_state_int(PDP1_RIM, 1);
1891	1889	}
1892	1890	if (control_transitions & pdp1_reader)
1893	1891	{
r17997	r17998
1897	1895	}
1898	1896	if (control_transitions & pdp1_single_step)
1899	1897	{
1900		device->state().set_state_int(PDP1_SNGL_STEP, ! device->state().state_int(PDP1_SNGL_STEP));
	1898	device.state().set_state_int(PDP1_SNGL_STEP, ! device.state().state_int(PDP1_SNGL_STEP));
1901	1899	}
1902	1900	if (control_transitions & pdp1_single_inst)
1903	1901	{
1904		device->state().set_state_int(PDP1_SNGL_INST, ! device->state().state_int(PDP1_SNGL_INST));
	1902	device.state().set_state_int(PDP1_SNGL_INST, ! device.state().state_int(PDP1_SNGL_INST));
1905	1903	}
1906	1904
1907	1905	/* remember new state of control keys */
1908		state->m_old_control_keys = control_keys;
	1906	m_old_control_keys = control_keys;
1909	1907
1910	1908
1911	1909	/* handle test word keys */
1912		tw_keys = (machine.root_device().ioport("TWDMSB")->read() << 16) | machine.root_device().ioport("TWDLSB")->read();
	1910	tw_keys = (machine().root_device().ioport("TWDMSB")->read() << 16) | machine().root_device().ioport("TWDLSB")->read();
1913	1911
1914	1912	/* compute transitions */
1915		tw_transitions = tw_keys & (~ state->m_old_tw_keys);
	1913	tw_transitions = tw_keys & (~ m_old_tw_keys);
1916	1914
1917	1915	if (tw_transitions)
1918		device->state().set_state_int(PDP1_TW, device->state().state_int(PDP1_TW) ^ tw_transitions);
	1916	device.state().set_state_int(PDP1_TW, device.state().state_int(PDP1_TW) ^ tw_transitions);
1919	1917
1920	1918	/* remember new state of test word keys */
1921		state->m_old_tw_keys = tw_keys;
	1919	m_old_tw_keys = tw_keys;
1922	1920
1923	1921
1924	1922	/* handle address keys */
1925		ta_keys = machine.root_device().ioport("TSTADD")->read();
	1923	ta_keys = machine().root_device().ioport("TSTADD")->read();
1926	1924
1927	1925	/* compute transitions */
1928		ta_transitions = ta_keys & (~ state->m_old_ta_keys);
	1926	ta_transitions = ta_keys & (~ m_old_ta_keys);
1929	1927
1930	1928	if (ta_transitions)
1931		device->state().set_state_int(PDP1_TA, device->state().state_int(PDP1_TA) ^ ta_transitions);
	1929	device.state().set_state_int(PDP1_TA, device.state().state_int(PDP1_TA) ^ ta_transitions);
1932	1930
1933	1931	/* remember new state of test word keys */
1934		state->m_old_ta_keys = ta_keys;
	1932	m_old_ta_keys = ta_keys;
1935	1933
1936	1934	}
1937	1935	else
1938	1936	{
1939		state->m_old_control_keys = 0;
1940		state->m_old_tw_keys = 0;
1941		state->m_old_ta_keys = 0;
	1937	m_old_control_keys = 0;
	1938	m_old_tw_keys = 0;
	1939	m_old_ta_keys = 0;
1942	1940
1943		pdp1_keyboard(machine);
	1941	pdp1_keyboard(machine());
1944	1942	}
1945	1943
1946		pdp1_lightpen(machine);
	1944	pdp1_lightpen(machine());
1947	1945	}
1948	1946
1949	1947
r17997	r17998
1954	1952	MCFG_CPU_ADD("maincpu", PDP1, 1000000/*the CPU core uses microsecond counts*/)
1955	1953	MCFG_CPU_CONFIG(pdp1_reset_param)
1956	1954	MCFG_CPU_PROGRAM_MAP(pdp1_map)
1957		MCFG_CPU_VBLANK_INT("screen", pdp1_interrupt)   /* dummy interrupt: handles input */
	1955	MCFG_CPU_VBLANK_INT_DRIVER("screen", pdp1_state, pdp1_interrupt)   /* dummy interrupt: handles input */
1958	1956
1959	1957
1960	1958	/* video hardware (includes the control panel and typewriter output) */

trunk/src/mess/drivers/homelab.c

r17997	r17998
73	73	DECLARE_VIDEO_START(brailab4);
74	74	UINT32 screen_update_homelab2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
75	75	UINT32 screen_update_homelab3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	76	INTERRUPT_GEN_MEMBER(homelab_frame);
76	77	};
77	78
78		static INTERRUPT_GEN( homelab_frame )
	79	INTERRUPT_GEN_MEMBER(homelab_state::homelab_frame)
79	80	{
80		homelab_state *state = device->machine().driver_data<homelab_state>();
81		if (state->m_nmi)
82		state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	81	if (m_nmi)
	82	m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
83	83	}
84	84
85	85	READ8_MEMBER( homelab_state::key_r ) // offset 27F-2FE
r17997	r17998
741	741	/* basic machine hardware */
742	742	MCFG_CPU_ADD("maincpu", Z80, XTAL_8MHz / 2)
743	743	MCFG_CPU_PROGRAM_MAP(homelab2_mem)
744		MCFG_CPU_VBLANK_INT("screen", homelab_frame)
	744	MCFG_CPU_VBLANK_INT_DRIVER("screen", homelab_state, homelab_frame)
745	745
746	746	/* video hardware */
747	747	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/pc100.c

r17997	r17998
64	64	virtual void machine_reset();
65	65	virtual void video_start();
66	66	UINT32 screen_update_pc100(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	67	INTERRUPT_GEN_MEMBER(pc100_vblank_irq);
67	68	};
68	69
69	70	void pc100_state::video_start()
r17997	r17998
342	343	{
343	344	}
344	345
345		static INTERRUPT_GEN(pc100_vblank_irq)
	346	INTERRUPT_GEN_MEMBER(pc100_state::pc100_vblank_irq)
346	347	{
347		pic8259_ir4_w(device->machine().device("pic8259"), 1);
	348	pic8259_ir4_w(machine().device("pic8259"), 1);
348	349	}
349	350
350	351	static TIMER_DEVICE_CALLBACK( pc100_600hz_irq )
r17997	r17998
386	387	MCFG_CPU_ADD("maincpu", I8086, MASTER_CLOCK)
387	388	MCFG_CPU_PROGRAM_MAP(pc100_map)
388	389	MCFG_CPU_IO_MAP(pc100_io)
389		MCFG_CPU_VBLANK_INT("screen",pc100_vblank_irq)
	390	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc100_state, pc100_vblank_irq)
390	391
391	392
392	393	/* video hardware */

trunk/src/mess/drivers/pc9801.c

r17997	r17998
415	415	DECLARE_PALETTE_INIT(pc9801);
416	416	DECLARE_MACHINE_RESET(pc9801rs);
417	417	DECLARE_MACHINE_START(pc9821);
	418	INTERRUPT_GEN_MEMBER(pc9801_vrtc_irq);
418	419	};
419	420
420	421
r17997	r17998
2607	2608	state_save_register_global_pointer(machine(), m_sdip, 24);
2608	2609	}
2609	2610
2610		static INTERRUPT_GEN(pc9801_vrtc_irq)
	2611	INTERRUPT_GEN_MEMBER(pc9801_state::pc9801_vrtc_irq)
2611	2612	{
2612		pc9801_state *state = device->machine().driver_data<pc9801_state>();
2613	2613	#if 0
2614		address_space &space = *device->machine().device("maincpu")->memory().space(AS_PROGRAM);
	2614	address_space &space = *machine().device("maincpu")->memory().space(AS_PROGRAM);
2615	2615	static UINT8 test;
2616	2616
2617		if(device->machine().input().code_pressed_once(JOYCODE_BUTTON1))
	2617	if(machine().input().code_pressed_once(JOYCODE_BUTTON1))
2618	2618	test^=1;
2619	2619
2620	2620	if(test)
r17997	r17998
2624	2624	}
2625	2625	#endif
2626	2626
2627		if(state->m_vrtc_irq_mask)
	2627	if(m_vrtc_irq_mask)
2628	2628	{
2629		pic8259_ir2_w(device->machine().device("pic8259_master"), 1);
2630		state->m_vrtc_irq_mask = 0; // TODO: this irq auto-masks?
	2629	pic8259_ir2_w(machine().device("pic8259_master"), 1);
	2630	m_vrtc_irq_mask = 0; // TODO: this irq auto-masks?
2631	2631	}
2632	2632	else
2633		pic8259_ir2_w(device->machine().device("pic8259_master"), 0);
	2633	pic8259_ir2_w(machine().device("pic8259_master"), 0);
2634	2634	}
2635	2635
2636	2636
r17997	r17998
2639	2639	MCFG_CPU_ADD("maincpu", I8086, 5000000) //unknown clock
2640	2640	MCFG_CPU_PROGRAM_MAP(pc9801_map)
2641	2641	MCFG_CPU_IO_MAP(pc9801_io)
2642		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2642	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2643	2643
2644	2644	MCFG_MACHINE_START_OVERRIDE(pc9801_state,pc9801)
2645	2645	MCFG_MACHINE_RESET_OVERRIDE(pc9801_state,pc9801f)
r17997	r17998
2694	2694	MCFG_CPU_REPLACE("maincpu",V30,10000000)
2695	2695	MCFG_CPU_PROGRAM_MAP(pc9801_map)
2696	2696	MCFG_CPU_IO_MAP(pc9801_io)
2697		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2697	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2698	2698	MACHINE_CONFIG_END
2699	2699	#endif
2700	2700
r17997	r17998
2702	2702	MCFG_CPU_ADD("maincpu", I386, 16000000)
2703	2703	MCFG_CPU_PROGRAM_MAP(pc9801rs_map)
2704	2704	MCFG_CPU_IO_MAP(pc9801rs_io)
2705		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2705	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2706	2706
2707	2707	MCFG_MACHINE_START_OVERRIDE(pc9801_state,pc9801)
2708	2708	MCFG_MACHINE_RESET_OVERRIDE(pc9801_state,pc9801rs)
r17997	r17998
2755	2755	MCFG_CPU_CONFIG(i286_address_mask)
2756	2756	MCFG_CPU_PROGRAM_MAP(pc9801ux_map)
2757	2757	MCFG_CPU_IO_MAP(pc9801ux_io)
2758		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2758	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2759	2759	MACHINE_CONFIG_END
2760	2760
2761	2761	static MACHINE_CONFIG_START( pc9821, pc9801_state )
2762	2762	MCFG_CPU_ADD("maincpu", I486, 16000000)
2763	2763	MCFG_CPU_PROGRAM_MAP(pc9821_map)
2764	2764	MCFG_CPU_IO_MAP(pc9821_io)
2765		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2765	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2766	2766
2767	2767	MCFG_MACHINE_START_OVERRIDE(pc9801_state,pc9821)
2768	2768	MCFG_MACHINE_RESET_OVERRIDE(pc9801_state,pc9801rs)
r17997	r17998
2812	2812	MCFG_CPU_REPLACE("maincpu",PENTIUM,32000000) /* TODO: clock */
2813	2813	MCFG_CPU_PROGRAM_MAP(pc9821_map)
2814	2814	MCFG_CPU_IO_MAP(pc9821_io)
2815		MCFG_CPU_VBLANK_INT("screen",pc9801_vrtc_irq)
	2815	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc9801_state, pc9801_vrtc_irq)
2816	2816	MACHINE_CONFIG_END
2817	2817
2818	2818	/*

trunk/src/mess/drivers/apple3.c

r17997	r17998
71	71	MCFG_CPU_ADD("maincpu", M6502, 2000000)        /* 2 MHz */
72	72	MCFG_CPU_PROGRAM_MAP(apple3_map)
73	73	MCFG_CPU_CONFIG( apple3_m6502_interface )
74		MCFG_CPU_PERIODIC_INT(apple3_interrupt, 192)
	74	MCFG_CPU_PERIODIC_INT_DRIVER(apple3_state, apple3_interrupt, 192)
75	75	MCFG_QUANTUM_TIME(attotime::from_hz(60))
76	76
77	77	MCFG_MACHINE_RESET_OVERRIDE(apple3_state, apple3 )

trunk/src/mess/drivers/c65.c

r17997	r17998
289	289	c65_c64_mem_r
290	290	};
291	291
292		static INTERRUPT_GEN( vic3_raster_irq )
	292	INTERRUPT_GEN_MEMBER(c65_state::vic3_raster_irq)
293	293	{
294		device_t *vic3 = device->machine().device("vic3");
	294	device_t *vic3 = machine().device("vic3");
295	295
296	296	vic3_raster_interrupt_gen(vic3);
297	297	}
r17997	r17998
306	306	/* basic machine hardware */
307	307	MCFG_CPU_ADD("maincpu", M4510, 3500000)  /* or VIC6567_CLOCK, */
308	308	MCFG_CPU_PROGRAM_MAP(c65_mem)
309		MCFG_CPU_VBLANK_INT("screen", c65_frame_interrupt)
310		MCFG_CPU_PERIODIC_INT(vic3_raster_irq, VIC6567_HRETRACERATE)
	309	MCFG_CPU_VBLANK_INT_DRIVER("screen", c65_state,  c65_frame_interrupt)
	310	MCFG_CPU_PERIODIC_INT_DRIVER(c65_state, vic3_raster_irq,  VIC6567_HRETRACERATE)
311	311
312	312	MCFG_MACHINE_START_OVERRIDE(c65_state, c65 )
313	313

trunk/src/mess/drivers/cbmb.c

r17997	r17998
498	498	/* basic machine hardware */
499	499	MCFG_CPU_ADD("maincpu", M6509, VIC6567_CLOCK)        /* 7.8336 MHz */
500	500	MCFG_CPU_PROGRAM_MAP(p500_mem)
501		//MCFG_CPU_PERIODIC_INT(vic2_raster_irq, VIC6567_HRETRACERATE)
	501	//MCFG_CPU_PERIODIC_INT_DRIVER(cbmb_state, vic2_raster_irq, VIC6567_HRETRACERATE)
502	502
503	503	MCFG_MACHINE_RESET_OVERRIDE(cbmb_state, cbmb )
504	504

trunk/src/mess/drivers/mbee.c

r17997	r17998
712	712	MCFG_CPU_PROGRAM_MAP(mbeeic_mem)
713	713	MCFG_CPU_IO_MAP(mbeeic_io)
714	714	MCFG_CPU_CONFIG(mbee_daisy_chain)
715		//MCFG_CPU_VBLANK_INT("screen", mbee_interrupt)
	715	//MCFG_CPU_VBLANK_INT_DRIVER("screen", mbee_state, mbee_interrupt)
716	716
717	717	MCFG_MACHINE_RESET_OVERRIDE(mbee_state, mbee )
718	718

trunk/src/mess/drivers/pc88va.c

r17997	r17998
102	102	virtual void machine_reset();
103	103	virtual void video_start();
104	104	UINT32 screen_update_pc88va(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	105	INTERRUPT_GEN_MEMBER(pc88va_vrtc_irq);
105	106	};
106	107
107	108
r17997	r17998
1562	1563	machine().device("fdccpu")->execute().set_input_line_vector(0, 0);
1563	1564	}
1564	1565
1565		static INTERRUPT_GEN( pc88va_vrtc_irq )
	1566	INTERRUPT_GEN_MEMBER(pc88va_state::pc88va_vrtc_irq)
1566	1567	{
1567		pic8259_ir2_w(device->machine().device("pic8259_master"), 1);
	1568	pic8259_ir2_w(machine().device("pic8259_master"), 1);
1568	1569	}
1569	1570
1570	1571	/* Not sure if parameters are correct for pc88va (copied from x68k) */
r17997	r17998
1657	1658	MCFG_CPU_ADD("maincpu", V30, 8000000)        /* 8 MHz */
1658	1659	MCFG_CPU_PROGRAM_MAP(pc88va_map)
1659	1660	MCFG_CPU_IO_MAP(pc88va_io_map)
1660		MCFG_CPU_VBLANK_INT("screen",pc88va_vrtc_irq)
	1661	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc88va_state, pc88va_vrtc_irq)
1661	1662
1662	1663	MCFG_CPU_ADD("fdccpu", Z80, 8000000)        /* 8 MHz */
1663	1664	MCFG_CPU_PROGRAM_MAP(pc88va_z80_map)

trunk/src/mess/drivers/pc6001.c

r17997	r17998
233	233	UINT32 screen_update_pc6001(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
234	234	UINT32 screen_update_pc6001m2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
235	235	UINT32 screen_update_pc6001sr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	236	INTERRUPT_GEN_MEMBER(pc6001_interrupt);
	237	INTERRUPT_GEN_MEMBER(pc6001sr_interrupt);
236	238	};
237	239
238	240
r17997	r17998
1846	1848
1847	1849	static UINT8 check_joy_press(running_machine &machine);
1848	1850
1849		static INTERRUPT_GEN( pc6001_interrupt )
	1851	INTERRUPT_GEN_MEMBER(pc6001_state::pc6001_interrupt)
1850	1852	{
1851		pc6001_state *state = device->machine().driver_data<pc6001_state>();
1852		state->m_cur_keycode = check_joy_press(device->machine());
	1853	m_cur_keycode = check_joy_press(machine());
1853	1854	if(IRQ_LOG) printf("Stick IRQ called 0x16\n");
1854		state->m_irq_vector = 0x16;
1855		device->execute().set_input_line(0, ASSERT_LINE);
	1855	m_irq_vector = 0x16;
	1856	device.execute().set_input_line(0, ASSERT_LINE);
1856	1857	}
1857	1858
1858		static INTERRUPT_GEN( pc6001sr_interrupt )
	1859	INTERRUPT_GEN_MEMBER(pc6001_state::pc6001sr_interrupt)
1859	1860	{
1860		pc6001_state *state = device->machine().driver_data<pc6001_state>();
1861		state->m_kludge^= 1;
	1861	m_kludge^= 1;
1862	1862
1863		state->m_cur_keycode = check_joy_press(device->machine());
	1863	m_cur_keycode = check_joy_press(machine());
1864	1864	if(IRQ_LOG) printf("VRTC IRQ called 0x16\n");
1865		state->m_irq_vector = (state->m_kludge) ? 0x22 : 0x16;
1866		device->execute().set_input_line(0, ASSERT_LINE);
	1865	m_irq_vector = (m_kludge) ? 0x22 : 0x16;
	1866	device.execute().set_input_line(0, ASSERT_LINE);
1867	1867	}
1868	1868
1869	1869	static IRQ_CALLBACK ( pc6001_irq_callback )
r17997	r17998
2326	2326	MCFG_CPU_ADD("maincpu",Z80, PC6001_MAIN_CLOCK / 2) // ~4 Mhz
2327	2327	MCFG_CPU_PROGRAM_MAP(pc6001_map)
2328	2328	MCFG_CPU_IO_MAP(pc6001_io)
2329		MCFG_CPU_VBLANK_INT("screen", pc6001_interrupt)
	2329	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc6001_state, pc6001_interrupt)
2330	2330
2331	2331	//  MCFG_CPU_ADD("subcpu", I8049, 7987200)
2332	2332
r17997	r17998
2398	2398	MCFG_CPU_REPLACE("maincpu", Z80, PC6001_MAIN_CLOCK / 2)
2399	2399	MCFG_CPU_PROGRAM_MAP(pc6001m2_map)
2400	2400	MCFG_CPU_IO_MAP(pc6601_io)
2401		MCFG_CPU_VBLANK_INT("screen", pc6001_interrupt)
	2401	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc6001_state, pc6001_interrupt)
2402	2402	MACHINE_CONFIG_END
2403	2403
2404	2404	static MACHINE_CONFIG_DERIVED( pc6001sr, pc6001m2 )
r17997	r17998
2412	2412	MCFG_CPU_REPLACE("maincpu", Z80, XTAL_3_579545MHz) //*Yes*, PC-6001 SR Z80 CPU is actually slower than older models
2413	2413	MCFG_CPU_PROGRAM_MAP(pc6001sr_map)
2414	2414	MCFG_CPU_IO_MAP(pc6001sr_io)
2415		MCFG_CPU_VBLANK_INT("screen", pc6001sr_interrupt)
	2415	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc6001_state, pc6001sr_interrupt)
2416	2416	MACHINE_CONFIG_END
2417	2417
2418	2418	/* ROM definition */

trunk/src/mess/drivers/vii.c

r17997	r17998
140	140	virtual void machine_reset();
141	141	virtual void video_start();
142	142	UINT32 screen_update_vii(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	143	INTERRUPT_GEN_MEMBER(vii_vblank);
143	144	};
144	145
145	146	enum
r17997	r17998
1021	1022	{
1022	1023	}
1023	1024
1024		static INTERRUPT_GEN( vii_vblank )
	1025	INTERRUPT_GEN_MEMBER(vii_state::vii_vblank)
1025	1026	{
1026		vii_state *state = device->machine().driver_data<vii_state>();
1027		UINT32 x = device->machine().rand() & 0x3ff;
1028		UINT32 y = device->machine().rand() & 0x3ff;
1029		UINT32 z = device->machine().rand() & 0x3ff;
	1027	UINT32 x = machine().rand() & 0x3ff;
	1028	UINT32 y = machine().rand() & 0x3ff;
	1029	UINT32 z = machine().rand() & 0x3ff;
1030	1030
1031	1031
1032		state->m_controller_input[0] = state->ioport("P1")->read();
1033		state->m_controller_input[1] = (UINT8)x;
1034		state->m_controller_input[2] = (UINT8)y;
1035		state->m_controller_input[3] = (UINT8)z;
1036		state->m_controller_input[4] = 0;
	1032	m_controller_input[0] = ioport("P1")->read();
	1033	m_controller_input[1] = (UINT8)x;
	1034	m_controller_input[2] = (UINT8)y;
	1035	m_controller_input[3] = (UINT8)z;
	1036	m_controller_input[4] = 0;
1037	1037	x >>= 8;
1038	1038	y >>= 8;
1039	1039	z >>= 8;
1040		state->m_controller_input[5] = (z << 4) | (y << 2) | x;
1041		state->m_controller_input[6] = 0xff;
1042		state->m_controller_input[7] = 0;
	1040	m_controller_input[5] = (z << 4) | (y << 2) | x;
	1041	m_controller_input[6] = 0xff;
	1042	m_controller_input[7] = 0;
1043	1043
1044		state->m_uart_rx_count = 0;
	1044	m_uart_rx_count = 0;
1045	1045
1046		state->VII_VIDEO_IRQ_STATUS = state->VII_VIDEO_IRQ_ENABLE & 1;
1047		if(state->VII_VIDEO_IRQ_STATUS)
	1046	VII_VIDEO_IRQ_STATUS = VII_VIDEO_IRQ_ENABLE & 1;
	1047	if(VII_VIDEO_IRQ_STATUS)
1048	1048	{
1049		verboselog(device->machine(), 0, "Video IRQ\n");
1050		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ0_LINE, ASSERT_LINE);
	1049	verboselog(machine(), 0, "Video IRQ\n");
	1050	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ0_LINE, ASSERT_LINE);
1051	1051	}
1052	1052
1053	1053	//  {
1054		//      verboselog(device->machine(), 0, "audio 1 IRQ\n");
1055		//      device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ1_LINE, ASSERT_LINE);
	1054	//      verboselog(machine(), 0, "audio 1 IRQ\n");
	1055	//      machine().device("maincpu")->execute().set_input_line(UNSP_IRQ1_LINE, ASSERT_LINE);
1056	1056	//  }
1057		if(state->m_io_regs[0x22] & state->m_io_regs[0x21] & 0x0c00)
	1057	if(m_io_regs[0x22] & m_io_regs[0x21] & 0x0c00)
1058	1058	{
1059		verboselog(device->machine(), 0, "timerA, timer B IRQ\n");
1060		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ2_LINE, ASSERT_LINE);
	1059	verboselog(machine(), 0, "timerA, timer B IRQ\n");
	1060	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ2_LINE, ASSERT_LINE);
1061	1061	}
1062	1062
1063		//if(state->m_io_regs[0x22] & state->m_io_regs[0x21] & 0x2100)
	1063	//if(m_io_regs[0x22] & m_io_regs[0x21] & 0x2100)
1064	1064	// For now trigger always if any enabled
1065		if(state->VII_CTLR_IRQ_ENABLE)
	1065	if(VII_CTLR_IRQ_ENABLE)
1066	1066	{
1067		verboselog(device->machine(), 0, "UART, ADC IRQ\n");
1068		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ3_LINE, ASSERT_LINE);
	1067	verboselog(machine(), 0, "UART, ADC IRQ\n");
	1068	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ3_LINE, ASSERT_LINE);
1069	1069	}
1070	1070	//  {
1071		//      verboselog(device->machine(), 0, "audio 4 IRQ\n");
1072		//      device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ4_LINE, ASSERT_LINE);
	1071	//      verboselog(machine(), 0, "audio 4 IRQ\n");
	1072	//      machine().device("maincpu")->execute().set_input_line(UNSP_IRQ4_LINE, ASSERT_LINE);
1073	1073	//  }
1074	1074
1075		if(state->m_io_regs[0x22] & state->m_io_regs[0x21] & 0x1200)
	1075	if(m_io_regs[0x22] & m_io_regs[0x21] & 0x1200)
1076	1076	{
1077		verboselog(device->machine(), 0, "External IRQ\n");
1078		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ5_LINE, ASSERT_LINE);
	1077	verboselog(machine(), 0, "External IRQ\n");
	1078	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ5_LINE, ASSERT_LINE);
1079	1079	}
1080		if(state->m_io_regs[0x22] & state->m_io_regs[0x21] & 0x0070)
	1080	if(m_io_regs[0x22] & m_io_regs[0x21] & 0x0070)
1081	1081	{
1082		verboselog(device->machine(), 0, "1024Hz, 2048HZ, 4096HZ IRQ\n");
1083		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ6_LINE, ASSERT_LINE);
	1082	verboselog(machine(), 0, "1024Hz, 2048HZ, 4096HZ IRQ\n");
	1083	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ6_LINE, ASSERT_LINE);
1084	1084	}
1085		if(state->m_io_regs[0x22] & state->m_io_regs[0x21] & 0x008b)
	1085	if(m_io_regs[0x22] & m_io_regs[0x21] & 0x008b)
1086	1086	{
1087		verboselog(device->machine(), 0, "TMB1, TMB2, 4Hz, key change IRQ\n");
1088		device->machine().device("maincpu")->execute().set_input_line(UNSP_IRQ7_LINE, ASSERT_LINE);
	1087	verboselog(machine(), 0, "TMB1, TMB2, 4Hz, key change IRQ\n");
	1088	machine().device("maincpu")->execute().set_input_line(UNSP_IRQ7_LINE, ASSERT_LINE);
1089	1089	}
1090	1090
1091	1091	}
r17997	r17998
1094	1094
1095	1095	MCFG_CPU_ADD( "maincpu", UNSP, XTAL_27MHz)
1096	1096	MCFG_CPU_PROGRAM_MAP( vii_mem )
1097		MCFG_CPU_VBLANK_INT("screen", vii_vblank)
	1097	MCFG_CPU_VBLANK_INT_DRIVER("screen", vii_state, vii_vblank)
1098	1098
1099	1099
1100	1100	MCFG_SCREEN_ADD( "screen", RASTER )
r17997	r17998
1116	1116
1117	1117	MCFG_CPU_ADD( "maincpu", UNSP, XTAL_27MHz)
1118	1118	MCFG_CPU_PROGRAM_MAP( vii_mem )
1119		MCFG_CPU_VBLANK_INT("screen", vii_vblank)
	1119	MCFG_CPU_VBLANK_INT_DRIVER("screen", vii_state, vii_vblank)
1120	1120
1121	1121
1122	1122	MCFG_SCREEN_ADD( "screen", RASTER )
r17997	r17998
1141	1141
1142	1142	MCFG_CPU_ADD( "maincpu", UNSP, XTAL_27MHz)
1143	1143	MCFG_CPU_PROGRAM_MAP( vii_mem )
1144		MCFG_CPU_VBLANK_INT("screen", vii_vblank)
	1144	MCFG_CPU_VBLANK_INT_DRIVER("screen", vii_state, vii_vblank)
1145	1145
1146	1146
1147	1147	MCFG_I2CMEM_ADD("i2cmem",i2cmem_interface)

trunk/src/mess/drivers/gb.c

r17997	r17998
562	562	MCFG_CPU_ADD("maincpu", LR35902, 4194304)         /* 4.194304 MHz */
563	563	MCFG_CPU_PROGRAM_MAP(gb_map)
564	564	MCFG_LR35902_CONFIG(dmg_cpu_reset)
565		MCFG_CPU_VBLANK_INT("screen", gb_scanline_interrupt)   /* 1 dummy int each frame */
	565	MCFG_CPU_VBLANK_INT_DRIVER("screen", gb_state, gb_scanline_interrupt)   /* 1 dummy int each frame */
566	566
567	567	MCFG_QUANTUM_TIME(attotime::from_hz(60))
568	568
r17997	r17998
659	659	/* basic machine hardware */
660	660	MCFG_CPU_ADD("maincpu", LR35902, 4194304)         /* 4.194304 MHz */
661	661	MCFG_CPU_PROGRAM_MAP( megaduck_map)
662		MCFG_CPU_VBLANK_INT("screen", gb_scanline_interrupt)   /* 1 int each scanline ! */
	662	MCFG_CPU_VBLANK_INT_DRIVER("screen", gb_state, gb_scanline_interrupt)   /* 1 int each scanline ! */
663	663	MCFG_LR35902_CONFIG(megaduck_cpu_reset)
664	664
665	665	MCFG_SCREEN_ADD("screen", LCD)

trunk/src/mess/drivers/sgi_ip6.c

r17997	r17998
42	42	virtual void machine_reset();
43	43	virtual void video_start();
44	44	UINT32 screen_update_sgi_ip6(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	45	INTERRUPT_GEN_MEMBER(sgi_ip6_vbl);
45	46	};
46	47
47	48
r17997	r17998
192	193	verboselog(machine(), 0, "ip6_unk3_w: Unknown address: %08x = %08x & %08x\n", 0x1fb00000 + (offset << 2), data, mem_mask );
193	194	}
194	195
195		static INTERRUPT_GEN( sgi_ip6_vbl )
	196	INTERRUPT_GEN_MEMBER(sgi_ip6_state::sgi_ip6_vbl)
196	197	{
197	198	}
198	199
r17997	r17998
233	234	MCFG_CPU_ADD( "maincpu", R3000BE, 20000000 ) // FIXME: Should be R2000
234	235	MCFG_CPU_CONFIG( config )
235	236	MCFG_CPU_PROGRAM_MAP( sgi_ip6_map )
236		MCFG_CPU_VBLANK_INT("screen", sgi_ip6_vbl)
	237	MCFG_CPU_VBLANK_INT_DRIVER("screen", sgi_ip6_state, sgi_ip6_vbl)
237	238
238	239
239	240	/* video hardware */

trunk/src/mess/drivers/fp1100.c

r17997	r17998
115	115	virtual void machine_start();
116	116	virtual void machine_reset();
117	117	virtual void video_start();
	118	INTERRUPT_GEN_MEMBER(fp1100_vblank_irq);
118	119	};
119	120
120	121	void fp1100_state::video_start()
r17997	r17998
394	395	NULL      /* update address callback */
395	396	};
396	397
397		static INTERRUPT_GEN( fp1100_vblank_irq )
	398	INTERRUPT_GEN_MEMBER(fp1100_state::fp1100_vblank_irq)
398	399	{
399		fp1100_state *state = device->machine().driver_data<fp1100_state>();
400	400
401		if(state->irq_mask & 0x10)
402		device->machine().device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE, 0xf0);
	401	if(irq_mask & 0x10)
	402	machine().device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE, 0xf0);
403	403	}
404	404
405	405	static MACHINE_CONFIG_START( fp1100, fp1100_state )
r17997	r17998
407	407	MCFG_CPU_ADD("maincpu", Z80, XTAL_4MHz) //unknown clock
408	408	MCFG_CPU_PROGRAM_MAP(fp1100_map)
409	409	MCFG_CPU_IO_MAP(fp1100_io)
410		MCFG_CPU_VBLANK_INT("screen",fp1100_vblank_irq)
	410	MCFG_CPU_VBLANK_INT_DRIVER("screen", fp1100_state, fp1100_vblank_irq)
411	411
412	412	MCFG_CPU_ADD( "sub", UPD7801, XTAL_4MHz ) //unknown clock
413	413	MCFG_CPU_PROGRAM_MAP( fp1100_slave_map )

trunk/src/mess/drivers/gamecom.c

r17997	r17998
89	89	return 0;
90	90	}
91	91
92		static INTERRUPT_GEN( gamecom_interrupt )
	92	INTERRUPT_GEN_MEMBER(gamecom_state::gamecom_interrupt)
93	93	{
94		device->machine().device("maincpu")->execute().set_input_line(LCDC_INT, ASSERT_LINE );
	94	machine().device("maincpu")->execute().set_input_line(LCDC_INT, ASSERT_LINE );
95	95	}
96	96
97	97	static MACHINE_CONFIG_START( gamecom, gamecom_state )
r17997	r17998
99	99	MCFG_CPU_ADD( "maincpu", SM8500, XTAL_11_0592MHz/2 )   /* actually it's an sm8521 microcontroller containing an sm8500 cpu */
100	100	MCFG_CPU_PROGRAM_MAP( gamecom_mem_map)
101	101	MCFG_CPU_CONFIG( gamecom_cpu_config )
102		MCFG_CPU_VBLANK_INT("screen", gamecom_interrupt)
	102	MCFG_CPU_VBLANK_INT_DRIVER("screen", gamecom_state, gamecom_interrupt)
103	103
104	104	MCFG_QUANTUM_TIME(attotime::from_hz(60))
105	105

trunk/src/mess/drivers/b2m.c

r17997	r17998
204	204	MCFG_CPU_ADD("maincpu", I8080, 2000000)
205	205	MCFG_CPU_PROGRAM_MAP(b2m_mem)
206	206	MCFG_CPU_IO_MAP(b2m_io)
207		MCFG_CPU_VBLANK_INT("screen", b2m_vblank_interrupt)
	207	MCFG_CPU_VBLANK_INT_DRIVER("screen", b2m_state, b2m_vblank_interrupt)
208	208
209	209
210	210	/* video hardware */

trunk/src/mess/drivers/vic20.c

r17997	r17998
308	308	//  VIDEO
309	309	//**************************************************************************
310	310
311		static INTERRUPT_GEN( vic20_raster_interrupt )
	311	INTERRUPT_GEN_MEMBER(vic20_state::vic20_raster_interrupt)
312	312	{
313		vic20_state *state = device->machine().driver_data<vic20_state>();
314		state->m_vic->raster_interrupt_gen();
	313	m_vic->raster_interrupt_gen();
315	314	}
316	315
317	316
r17997	r17998
756	755	// basic machine hardware
757	756	MCFG_CPU_ADD(M6502_TAG, M6502, MOS6560_CLOCK)
758	757	MCFG_CPU_PROGRAM_MAP(vic20_mem)
759		MCFG_CPU_PERIODIC_INT(vic20_raster_interrupt, MOS656X_HRETRACERATE)
	758	MCFG_CPU_PERIODIC_INT_DRIVER(vic20_state, vic20_raster_interrupt, MOS656X_HRETRACERATE)
760	759
761	760	// video/sound hardware
762	761	MCFG_SPEAKER_STANDARD_MONO("mono")
r17997	r17998
782	781	// basic machine hardware
783	782	MCFG_CPU_ADD(M6502_TAG, M6502, MOS6561_CLOCK)
784	783	MCFG_CPU_PROGRAM_MAP(vic20_mem)
785		MCFG_CPU_PERIODIC_INT(vic20_raster_interrupt, MOS656X_HRETRACERATE)
	784	MCFG_CPU_PERIODIC_INT_DRIVER(vic20_state, vic20_raster_interrupt, MOS656X_HRETRACERATE)
786	785
787	786	// video/sound hardware
788	787	MCFG_SPEAKER_STANDARD_MONO("mono")

trunk/src/mess/drivers/arcadia.c

r17997	r17998
530	530	MCFG_CPU_ADD("maincpu", S2650, 3580000/4)        /* 0.895 MHz */
531	531	MCFG_CPU_PROGRAM_MAP(arcadia_mem)
532	532	MCFG_CPU_IO_MAP(arcadia_io)
533		MCFG_CPU_PERIODIC_INT(arcadia_video_line, 262*60)
	533	MCFG_CPU_PERIODIC_INT_DRIVER(arcadia_state, arcadia_video_line, 262*60)
534	534	MCFG_QUANTUM_TIME(attotime::from_hz(60))
535	535
536	536	/* video hardware */

trunk/src/mess/drivers/smc777.c

r17997	r17998
87	87	virtual void video_start();
88	88	virtual void palette_init();
89	89	UINT32 screen_update_smc777(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	90	INTERRUPT_GEN_MEMBER(smc777_vblank_irq);
90	91	};
91	92
92	93
r17997	r17998
1046	1047	NULL
1047	1048	};
1048	1049
1049		static INTERRUPT_GEN( smc777_vblank_irq )
	1050	INTERRUPT_GEN_MEMBER(smc777_state::smc777_vblank_irq)
1050	1051	{
1051		smc777_state *state = device->machine().driver_data<smc777_state>();
1052	1052
1053		if(state->m_irq_mask)
1054		device->execute().set_input_line(0,HOLD_LINE);
	1053	if(m_irq_mask)
	1054	device.execute().set_input_line(0,HOLD_LINE);
1055	1055	}
1056	1056
1057	1057
r17997	r17998
1079	1079	MCFG_CPU_ADD("maincpu",Z80, MASTER_CLOCK)
1080	1080	MCFG_CPU_PROGRAM_MAP(smc777_mem)
1081	1081	MCFG_CPU_IO_MAP(smc777_io)
1082		MCFG_CPU_VBLANK_INT("screen",smc777_vblank_irq)
	1082	MCFG_CPU_VBLANK_INT_DRIVER("screen", smc777_state, smc777_vblank_irq)
1083	1083
1084	1084
1085	1085	/* video hardware */

trunk/src/mess/drivers/spectrum.c

r17997	r17998
660	660	GFXDECODE_END
661	661
662	662
663		static INTERRUPT_GEN( spec_interrupt )
	663	INTERRUPT_GEN_MEMBER(spectrum_state::spec_interrupt)
664	664	{
665		device->execute().set_input_line(0, HOLD_LINE);
	665	device.execute().set_input_line(0, HOLD_LINE);
666	666	}
667	667
668	668	static const cassette_interface spectrum_cassette_interface =
r17997	r17998
708	708	MCFG_CPU_ADD("maincpu", Z80, X1 / 4)        /* This is verified only for the ZX Spectum. Other clones are reported to have different clocks */
709	709	MCFG_CPU_PROGRAM_MAP(spectrum_mem)
710	710	MCFG_CPU_IO_MAP(spectrum_io)
711		MCFG_CPU_VBLANK_INT("screen", spec_interrupt)
	711	MCFG_CPU_VBLANK_INT_DRIVER("screen", spectrum_state, spec_interrupt)
712	712	MCFG_QUANTUM_TIME(attotime::from_hz(60))
713	713
714	714	MCFG_MACHINE_RESET_OVERRIDE(spectrum_state, spectrum )

trunk/src/mess/drivers/plus4.c

r17997	r17998
566	566	//  ted7360_interface ted_intf
567	567	//-------------------------------------------------
568	568
569		static INTERRUPT_GEN( c16_raster_interrupt )
	569	INTERRUPT_GEN_MEMBER(plus4_state::c16_raster_interrupt)
570	570	{
571		plus4_state *state = device->machine().driver_data<plus4_state>();
572	571
573		state->m_ted->raster_interrupt_gen();
	572	m_ted->raster_interrupt_gen();
574	573	}
575	574
576		static INTERRUPT_GEN( c16_frame_interrupt )
	575	INTERRUPT_GEN_MEMBER(plus4_state::c16_frame_interrupt)
577	576	{
578		plus4_state *state = device->machine().driver_data<plus4_state>();
579	577
580	578	int value, i;
581	579	static const char *const c16ports[] = { "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", "ROW5", "ROW6", "ROW7" };
r17997	r17998
584	582	for (i = 0; i < 8; i++)
585	583	{
586	584	value = 0xff;
587		value &= ~device->machine().root_device().ioport(c16ports[i])->read();
	585	value &= ~machine().root_device().ioport(c16ports[i])->read();
588	586
589	587	/* Shift Lock is mapped on Left/Right Shift */
590		if ((i == 1) && (device->machine().root_device().ioport("SPECIAL")->read() & 0x80))
	588	if ((i == 1) && (machine().root_device().ioport("SPECIAL")->read() & 0x80))
591	589	value &= ~0x80;
592	590
593		state->m_keyline[i] = value;
	591	m_keyline[i] = value;
594	592	}
595	593
596		if (device->machine().root_device().ioport("CTRLSEL")->read() & 0x01)
	594	if (machine().root_device().ioport("CTRLSEL")->read() & 0x01)
597	595	{
598	596	value = 0xff;
599		if (device->machine().root_device().ioport("JOY0")->read() & 0x10)         /* Joypad1_Button */
	597	if (machine().root_device().ioport("JOY0")->read() & 0x10)         /* Joypad1_Button */
600	598	{
601		if (device->machine().root_device().ioport("SPECIAL")->read() & 0x40)
	599	if (machine().root_device().ioport("SPECIAL")->read() & 0x40)
602	600	value &= ~0x80;
603	601	else
604	602	value &= ~0x40;
605	603	}
606	604
607		value &= ~(device->machine().root_device().ioport("JOY0")->read() & 0x0f);   /* Other Inputs Joypad1 */
	605	value &= ~(machine().root_device().ioport("JOY0")->read() & 0x0f);   /* Other Inputs Joypad1 */
608	606
609		if (device->machine().root_device().ioport("SPECIAL")->read() & 0x40)
610		state->m_keyline[9] = value;
	607	if (machine().root_device().ioport("SPECIAL")->read() & 0x40)
	608	m_keyline[9] = value;
611	609	else
612		state->m_keyline[8] = value;
	610	m_keyline[8] = value;
613	611	}
614	612
615		if (device->machine().root_device().ioport("CTRLSEL")->read() & 0x10)
	613	if (machine().root_device().ioport("CTRLSEL")->read() & 0x10)
616	614	{
617	615	value = 0xff;
618		if (device->machine().root_device().ioport("JOY1")->read() & 0x10)         /* Joypad2_Button */
	616	if (machine().root_device().ioport("JOY1")->read() & 0x10)         /* Joypad2_Button */
619	617	{
620		if (device->machine().root_device().ioport("SPECIAL")->read() & 0x40)
	618	if (machine().root_device().ioport("SPECIAL")->read() & 0x40)
621	619	value &= ~0x40;
622	620	else
623	621	value &= ~0x80;
624	622	}
625	623
626		value &= ~(device->machine().root_device().ioport("JOY1")->read() & 0x0f);   /* Other Inputs Joypad2 */
	624	value &= ~(machine().root_device().ioport("JOY1")->read() & 0x0f);   /* Other Inputs Joypad2 */
627	625
628		if (device->machine().root_device().ioport("SPECIAL")->read() & 0x40)
629		state->m_keyline[8] = value;
	626	if (machine().root_device().ioport("SPECIAL")->read() & 0x40)
	627	m_keyline[8] = value;
630	628	else
631		state->m_keyline[9] = value;
	629	m_keyline[9] = value;
632	630	}
633	631
634		state->m_ted->frame_interrupt_gen();
	632	m_ted->frame_interrupt_gen();
635	633	}
636	634
637	635	WRITE_LINE_MEMBER( plus4_state::ted_irq_w )
r17997	r17998
905	903	MCFG_CPU_ADD(MOS7501_TAG, M7501, XTAL_14_31818MHz/16)
906	904	MCFG_CPU_PROGRAM_MAP(plus4_mem)
907	905	MCFG_CPU_CONFIG(cpu_intf)
908		MCFG_CPU_VBLANK_INT(SCREEN_TAG, c16_frame_interrupt)
909		MCFG_CPU_PERIODIC_INT(c16_raster_interrupt, TED7360_HRETRACERATE)
	906	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, plus4_state,  c16_frame_interrupt)
	907	MCFG_CPU_PERIODIC_INT_DRIVER(plus4_state, c16_raster_interrupt,  TED7360_HRETRACERATE)
910	908	MCFG_QUANTUM_TIME(attotime::from_hz(60))
911	909
912	910	// video and sound hardware
r17997	r17998
944	942	MCFG_CPU_ADD(MOS7501_TAG, M7501, XTAL_17_73447MHz/20)
945	943	MCFG_CPU_PROGRAM_MAP(plus4_mem)
946	944	MCFG_CPU_CONFIG(cpu_intf)
947		MCFG_CPU_VBLANK_INT(SCREEN_TAG, c16_frame_interrupt)
948		MCFG_CPU_PERIODIC_INT(c16_raster_interrupt, TED7360_HRETRACERATE)
	945	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, plus4_state,  c16_frame_interrupt)
	946	MCFG_CPU_PERIODIC_INT_DRIVER(plus4_state, c16_raster_interrupt,  TED7360_HRETRACERATE)
949	947	MCFG_QUANTUM_TIME(attotime::from_hz(60))
950	948
951	949	// video and sound hardware

trunk/src/mess/drivers/tx0.c

r17997	r17998
1498	1498	/*
1499	1499	Not a real interrupt - just handle keyboard input
1500	1500	*/
1501		static INTERRUPT_GEN( tx0_interrupt )
	1501	INTERRUPT_GEN_MEMBER(tx0_state::tx0_interrupt)
1502	1502	{
1503		tx0_state *state = device->machine().driver_data<tx0_state>();
1504	1503	int control_keys;
1505	1504	int tsr_keys;
1506	1505
r17997	r17998
1509	1508
1510	1509
1511	1510	/* read new state of control keys */
1512		control_keys = state->ioport("CSW")->read();
	1511	control_keys = ioport("CSW")->read();
1513	1512
1514	1513	if (control_keys & tx0_control)
1515	1514	{
1516	1515	/* compute transitions */
1517		control_transitions = control_keys & (~ state->m_old_control_keys);
	1516	control_transitions = control_keys & (~ m_old_control_keys);
1518	1517
1519	1518	if (control_transitions & tx0_stop_cyc0)
1520	1519	{
1521		device->machine().device("maincpu")->state().set_state_int(TX0_STOP_CYC0, !device->machine().device("maincpu")->state().state_int(TX0_STOP_CYC0));
	1520	machine().device("maincpu")->state().set_state_int(TX0_STOP_CYC0, !machine().device("maincpu")->state().state_int(TX0_STOP_CYC0));
1522	1521	}
1523	1522	if (control_transitions & tx0_stop_cyc1)
1524	1523	{
1525		device->machine().device("maincpu")->state().set_state_int(TX0_STOP_CYC1, !device->machine().device("maincpu")->state().state_int(TX0_STOP_CYC1));
	1524	machine().device("maincpu")->state().set_state_int(TX0_STOP_CYC1, !machine().device("maincpu")->state().state_int(TX0_STOP_CYC1));
1526	1525	}
1527	1526	if (control_transitions & tx0_gbl_cm_sel)
1528	1527	{
1529		device->machine().device("maincpu")->state().set_state_int(TX0_GBL_CM_SEL, !device->machine().device("maincpu")->state().state_int(TX0_GBL_CM_SEL));
	1528	machine().device("maincpu")->state().set_state_int(TX0_GBL_CM_SEL, !machine().device("maincpu")->state().state_int(TX0_GBL_CM_SEL));
1530	1529	}
1531	1530	if (control_transitions & tx0_stop)
1532	1531	{
1533		device->machine().device("maincpu")->state().set_state_int(TX0_RUN, (UINT64)0);
1534		device->machine().device("maincpu")->state().set_state_int(TX0_RIM, (UINT64)0);
	1532	machine().device("maincpu")->state().set_state_int(TX0_RUN, (UINT64)0);
	1533	machine().device("maincpu")->state().set_state_int(TX0_RIM, (UINT64)0);
1535	1534	}
1536	1535	if (control_transitions & tx0_restart)
1537	1536	{
1538		device->machine().device("maincpu")->state().set_state_int(TX0_RUN, 1);
1539		device->machine().device("maincpu")->state().set_state_int(TX0_RIM, (UINT64)0);
	1537	machine().device("maincpu")->state().set_state_int(TX0_RUN, 1);
	1538	machine().device("maincpu")->state().set_state_int(TX0_RIM, (UINT64)0);
1540	1539	}
1541	1540	if (control_transitions & tx0_read_in)
1542	1541	{   /* set cpu to read instructions from perforated tape */
1543		device->machine().device("maincpu")->state().set_state_int(TX0_RESET, (UINT64)0);
1544		device->machine().device("maincpu")->state().set_state_int(TX0_RUN, (UINT64)0);
1545		device->machine().device("maincpu")->state().set_state_int(TX0_RIM, 1);
	1542	machine().device("maincpu")->state().set_state_int(TX0_RESET, (UINT64)0);
	1543	machine().device("maincpu")->state().set_state_int(TX0_RUN, (UINT64)0);
	1544	machine().device("maincpu")->state().set_state_int(TX0_RIM, 1);
1546	1545	}
1547	1546	if (control_transitions & tx0_toggle_dn)
1548	1547	{
1549		state->m_tsr_index++;
1550		if (state->m_tsr_index == 18)
1551		state->m_tsr_index = 0;
	1548	m_tsr_index++;
	1549	if (m_tsr_index == 18)
	1550	m_tsr_index = 0;
1552	1551	}
1553	1552	if (control_transitions & tx0_toggle_up)
1554	1553	{
1555		state->m_tsr_index--;
1556		if (state->m_tsr_index == -1)
1557		state->m_tsr_index = 17;
	1554	m_tsr_index--;
	1555	if (m_tsr_index == -1)
	1556	m_tsr_index = 17;
1558	1557	}
1559	1558	if (control_transitions & tx0_cm_sel)
1560	1559	{
1561		if (state->m_tsr_index >= 2)
	1560	if (m_tsr_index >= 2)
1562	1561	{
1563		UINT32 cm_sel = (UINT32) device->machine().device("maincpu")->state().state_int(TX0_CM_SEL);
1564		device->machine().device("maincpu")->state().set_state_int(TX0_CM_SEL, cm_sel ^ (1 << (state->m_tsr_index - 2)));
	1562	UINT32 cm_sel = (UINT32) machine().device("maincpu")->state().state_int(TX0_CM_SEL);
	1563	machine().device("maincpu")->state().set_state_int(TX0_CM_SEL, cm_sel ^ (1 << (m_tsr_index - 2)));
1565	1564	}
1566	1565	}
1567	1566	if (control_transitions & tx0_lr_sel)
1568	1567	{
1569		if (state->m_tsr_index >= 2)
	1568	if (m_tsr_index >= 2)
1570	1569	{
1571		UINT32 lr_sel = (UINT32) device->machine().device("maincpu")->state().state_int(TX0_LR_SEL);
1572		device->machine().device("maincpu")->state().set_state_int(TX0_LR_SEL, (lr_sel ^ (1 << (state->m_tsr_index - 2))));
	1570	UINT32 lr_sel = (UINT32) machine().device("maincpu")->state().state_int(TX0_LR_SEL);
	1571	machine().device("maincpu")->state().set_state_int(TX0_LR_SEL, (lr_sel ^ (1 << (m_tsr_index - 2))));
1573	1572	}
1574	1573	}
1575	1574
1576	1575	/* remember new state of control keys */
1577		state->m_old_control_keys = control_keys;
	1576	m_old_control_keys = control_keys;
1578	1577
1579	1578
1580	1579	/* handle toggle switch register keys */
1581		tsr_keys = (device->machine().root_device().ioport("MSW")->read() << 16) | device->machine().root_device().ioport("LSW")->read();
	1580	tsr_keys = (machine().root_device().ioport("MSW")->read() << 16) | machine().root_device().ioport("LSW")->read();
1582	1581
1583	1582	/* compute transitions */
1584		tsr_transitions = tsr_keys & (~ state->m_old_tsr_keys);
	1583	tsr_transitions = tsr_keys & (~ m_old_tsr_keys);
1585	1584
1586	1585	/* update toggle switch register */
1587	1586	if (tsr_transitions)
1588		device->machine().device("maincpu")->state().set_state_int(TX0_TBR+state->m_tsr_index, device->machine().device("maincpu")->state().state_int(TX0_TBR+state->m_tsr_index) ^ tsr_transitions);
	1587	machine().device("maincpu")->state().set_state_int(TX0_TBR+m_tsr_index, machine().device("maincpu")->state().state_int(TX0_TBR+m_tsr_index) ^ tsr_transitions);
1589	1588
1590	1589	/* remember new state of toggle switch register keys */
1591		state->m_old_tsr_keys = tsr_keys;
	1590	m_old_tsr_keys = tsr_keys;
1592	1591	}
1593	1592	else
1594	1593	{
1595		state->m_old_control_keys = 0;
1596		state->m_old_tsr_keys = 0;
	1594	m_old_control_keys = 0;
	1595	m_old_tsr_keys = 0;
1597	1596
1598		tx0_keyboard(device->machine());
	1597	tx0_keyboard(machine());
1599	1598	}
1600	1599	}
1601	1600
r17997	r17998
1606	1605	MCFG_CPU_CONFIG(tx0_reset_param)
1607	1606	MCFG_CPU_PROGRAM_MAP(tx0_64kw_map)
1608	1607	/* dummy interrupt: handles input */
1609		MCFG_CPU_VBLANK_INT("screen", tx0_interrupt)
	1608	MCFG_CPU_VBLANK_INT_DRIVER("screen", tx0_state, tx0_interrupt)
1610	1609
1611	1610
1612	1611	/* video hardware (includes the control panel and typewriter output) */

trunk/src/mess/drivers/ip22.c

r17997	r17998
131	131	DECLARE_DRIVER_INIT(ip225015);
132	132	virtual void machine_start();
133	133	virtual void machine_reset();
	134	INTERRUPT_GEN_MEMBER(ip22_vbl);
134	135	};
135	136
136	137
r17997	r17998
1609	1610	}
1610	1611	}
1611	1612
1612		static INTERRUPT_GEN( ip22_vbl )
	1613	INTERRUPT_GEN_MEMBER(ip22_state::ip22_vbl)
1613	1614	{
1614		ip22_state *state = device->machine().driver_data<ip22_state>();
1615		state->m_nIntCounter++;
1616		//  if( state->m_nIntCounter == 60 )
	1615	m_nIntCounter++;
	1616	//  if( m_nIntCounter == 60 )
1617	1617	{
1618		state->m_nIntCounter = 0;
1619		rtc_update(state);
	1618	m_nIntCounter = 0;
	1619	rtc_update(this);
1620	1620	}
1621	1621	}
1622	1622
r17997	r17998
1635	1635	MCFG_CPU_ADD( "maincpu", R5000BE, 50000000*3 )
1636	1636	MCFG_CPU_CONFIG( config )
1637	1637	MCFG_CPU_PROGRAM_MAP( ip225015_map)
1638		MCFG_CPU_VBLANK_INT("screen", ip22_vbl)
	1638	MCFG_CPU_VBLANK_INT_DRIVER("screen", ip22_state, ip22_vbl)
1639	1639
1640	1640
1641	1641	MCFG_NVRAM_ADD_0FILL("nvram")
r17997	r17998
1676	1676	MCFG_CPU_REPLACE( "maincpu", R4600BE, 133333333 )
1677	1677	MCFG_CPU_CONFIG( config )
1678	1678	MCFG_CPU_PROGRAM_MAP( ip225015_map)
1679		MCFG_CPU_VBLANK_INT("screen", ip22_vbl)
	1679	MCFG_CPU_VBLANK_INT_DRIVER("screen", ip22_state, ip22_vbl)
1680	1680	MACHINE_CONFIG_END
1681	1681
1682	1682	static MACHINE_CONFIG_DERIVED( ip244415, ip225015 )
1683	1683	MCFG_CPU_REPLACE( "maincpu", R4600BE, 150000000 )
1684	1684	MCFG_CPU_CONFIG( config )
1685	1685	MCFG_CPU_PROGRAM_MAP( ip225015_map)
1686		MCFG_CPU_VBLANK_INT("screen", ip22_vbl)
	1686	MCFG_CPU_VBLANK_INT_DRIVER("screen", ip22_state, ip22_vbl)
1687	1687	MACHINE_CONFIG_END
1688	1688
1689	1689	ROM_START( ip225015 )

trunk/src/mess/drivers/c128.c

r17997	r17998
1085	1085	MCFG_CPU_ADD(Z80A_TAG, Z80, VIC6567_CLOCK)
1086	1086	MCFG_CPU_PROGRAM_MAP( z80_mem)
1087	1087	MCFG_CPU_IO_MAP( z80_io)
1088		MCFG_CPU_VBLANK_INT(SCREEN_VIC_TAG, c128_frame_interrupt)
	1088	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_VIC_TAG, c128_state, c128_frame_interrupt)
1089	1089	MCFG_QUANTUM_PERFECT_CPU(Z80A_TAG)
1090	1090
1091	1091	MCFG_CPU_ADD(M8502_TAG, M8502, VIC6567_CLOCK)
1092	1092	MCFG_CPU_PROGRAM_MAP( m8502_mem)
1093	1093	MCFG_CPU_CONFIG( cpu_intf )
1094		MCFG_CPU_VBLANK_INT(SCREEN_VIC_TAG, c128_frame_interrupt)
	1094	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_VIC_TAG, c128_state, c128_frame_interrupt)
1095	1095	MCFG_QUANTUM_PERFECT_CPU(M8502_TAG)
1096	1096
1097	1097	// video hardware
r17997	r17998
1192	1192	MCFG_CPU_ADD(Z80A_TAG, Z80, VIC6569_CLOCK)
1193	1193	MCFG_CPU_PROGRAM_MAP( z80_mem)
1194	1194	MCFG_CPU_IO_MAP(z80_io)
1195		MCFG_CPU_VBLANK_INT(SCREEN_VIC_TAG, c128_frame_interrupt)
	1195	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_VIC_TAG, c128_state, c128_frame_interrupt)
1196	1196	MCFG_QUANTUM_PERFECT_CPU(Z80A_TAG)
1197	1197
1198	1198	MCFG_CPU_ADD(M8502_TAG, M8502, VIC6569_CLOCK)
1199	1199	MCFG_CPU_PROGRAM_MAP( m8502_mem)
1200	1200	MCFG_CPU_CONFIG( cpu_intf )
1201		MCFG_CPU_VBLANK_INT(SCREEN_VIC_TAG, c128_frame_interrupt)
	1201	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_VIC_TAG, c128_state, c128_frame_interrupt)
1202	1202	MCFG_QUANTUM_PERFECT_CPU(M8502_TAG)
1203	1203
1204	1204	// video hardware

trunk/src/mess/drivers/p2000t.c

r17997	r17998
202	202	INPUT_PORTS_END
203	203
204	204
205		static INTERRUPT_GEN( p2000_interrupt )
	205	INTERRUPT_GEN_MEMBER(p2000t_state::p2000_interrupt)
206	206	{
207		device->machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
	207	machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
208	208	}
209	209
210	210	READ8_MEMBER( p2000t_state::videoram_r )
r17997	r17998
224	224	MCFG_CPU_ADD("maincpu", Z80, 2500000)
225	225	MCFG_CPU_PROGRAM_MAP(p2000t_mem)
226	226	MCFG_CPU_IO_MAP(p2000t_io)
227		MCFG_CPU_VBLANK_INT("screen", p2000_interrupt)
	227	MCFG_CPU_VBLANK_INT_DRIVER("screen", p2000t_state, p2000_interrupt)
228	228
229	229	/* video hardware */
230	230	MCFG_SCREEN_ADD("screen", RASTER)
r17997	r17998
249	249	MCFG_CPU_ADD("maincpu", Z80, 2500000)
250	250	MCFG_CPU_PROGRAM_MAP(p2000m_mem)
251	251	MCFG_CPU_IO_MAP(p2000t_io)
252		MCFG_CPU_VBLANK_INT("screen", p2000_interrupt)
	252	MCFG_CPU_VBLANK_INT_DRIVER("screen", p2000t_state, p2000_interrupt)
253	253	MCFG_QUANTUM_TIME(attotime::from_hz(60))
254	254
255	255	/* video hardware */

trunk/src/mess/drivers/pet.c

r17997	r17998
659	659	/* basic machine hardware */
660	660	MCFG_CPU_ADD("maincpu", M6502, XTAL_8MHz/8)
661	661	MCFG_CPU_PROGRAM_MAP(pet_mem)
662		MCFG_CPU_VBLANK_INT("screen", pet_frame_interrupt)
	662	MCFG_CPU_VBLANK_INT_DRIVER("screen", pet_state, pet_frame_interrupt)
663	663
664	664
665	665	/* video hardware */
r17997	r17998
783	783	/* m6809 cpu */
784	784	MCFG_CPU_ADD("m6809", M6809, 1000000)
785	785	MCFG_CPU_PROGRAM_MAP(superpet_m6809_mem)
786		MCFG_CPU_VBLANK_INT("screen", pet_frame_interrupt)
	786	MCFG_CPU_VBLANK_INT_DRIVER("screen", pet_state, pet_frame_interrupt)
787	787
788	788	MCFG_SCREEN_MODIFY("screen")
789	789	MCFG_SCREEN_REFRESH_RATE(50)

trunk/src/mess/drivers/vector06.c

r17997	r17998
163	163	//  MCFG_CPU_ADD("maincpu", Z80, 3000000)
164	164	MCFG_CPU_PROGRAM_MAP(vector06_mem)
165	165	MCFG_CPU_IO_MAP(vector06_io)
166		MCFG_CPU_VBLANK_INT("screen", vector06_interrupt)
	166	MCFG_CPU_VBLANK_INT_DRIVER("screen", vector06_state, vector06_interrupt)
167	167
168	168
169	169	/* video hardware */

trunk/src/mess/drivers/ti990_10.c

r17997	r17998
89	89	virtual void machine_reset();
90	90	virtual void video_start();
91	91	UINT32 screen_update_ti990_10(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	92	INTERRUPT_GEN_MEMBER(ti990_10_line_interrupt);
92	93	};
93	94
94	95
r17997	r17998
106	107	ti990_hdc_init(machine(), ti990_set_int13);
107	108	}
108	109
109		static INTERRUPT_GEN( ti990_10_line_interrupt )
	110	INTERRUPT_GEN_MEMBER(ti990_10_state::ti990_10_line_interrupt)
110	111	{
111		ti990_10_state *state = device->machine().driver_data<ti990_10_state>();
112		vdt911_keyboard(state->m_terminal);
	112	vdt911_keyboard(m_terminal);
113	113
114		ti990_line_interrupt(device->machine());
	114	ti990_line_interrupt(machine());
115	115	}
116	116
117	117	#ifdef UNUSED_FUNCTION
r17997	r17998
215	215	MCFG_CPU_CONFIG(reset_params)
216	216	MCFG_CPU_PROGRAM_MAP(ti990_10_memmap)
217	217	MCFG_CPU_IO_MAP(ti990_10_io)
218		MCFG_CPU_PERIODIC_INT(ti990_10_line_interrupt, 120/*or 100 in Europe*/)
	218	MCFG_CPU_PERIODIC_INT_DRIVER(ti990_10_state, ti990_10_line_interrupt, 120/*or 100 in Europe*/)
219	219
220	220
221	221	/* video hardware - we emulate a single 911 vdt display */

trunk/src/mess/drivers/orion.c

r17997	r17998
183	183	MCFG_CPU_ADD("maincpu", Z80, 2500000)
184	184	MCFG_CPU_PROGRAM_MAP(orionz80_mem)
185	185	MCFG_CPU_IO_MAP(orionz80_io)
186		MCFG_CPU_VBLANK_INT("screen",orionz80_interrupt)
	186	MCFG_CPU_VBLANK_INT_DRIVER("screen", orion_state, orionz80_interrupt)
187	187
188	188	MCFG_MACHINE_START_OVERRIDE(orion_state, orionz80 )
189	189	MCFG_MACHINE_RESET_OVERRIDE(orion_state, orionz80 )

trunk/src/mess/drivers/mz2500.c

r17997	r17998
164	164	virtual void video_start();
165	165	virtual void palette_init();
166	166	UINT32 screen_update_mz2500(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	167	INTERRUPT_GEN_MEMBER(mz2500_vbl);
167	168	};
168	169
169	170
r17997	r17998
1821	1822	GFXDECODE_ENTRY("pcg", 0, mz2500_pcg_layout_3bpp, 0, 4)
1822	1823	GFXDECODE_END
1823	1824
1824		static INTERRUPT_GEN( mz2500_vbl )
	1825	INTERRUPT_GEN_MEMBER(mz2500_state::mz2500_vbl)
1825	1826	{
1826		mz2500_state *state = device->machine().driver_data<mz2500_state>();
1827		if(state->m_irq_mask[0])
1828		device->execute().set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[0]);
	1827	if(m_irq_mask[0])
	1828	device.execute().set_input_line_and_vector(0, HOLD_LINE, m_irq_vector[0]);
1829	1829
1830		state->m_cg_clear_flag = 0;
	1830	m_cg_clear_flag = 0;
1831	1831	}
1832	1832
1833	1833	static READ8_DEVICE_HANDLER( mz2500_porta_r )
r17997	r17998
2097	2097	MCFG_CPU_ADD("maincpu", Z80, 6000000)
2098	2098	MCFG_CPU_PROGRAM_MAP(mz2500_map)
2099	2099	MCFG_CPU_IO_MAP(mz2500_io)
2100		MCFG_CPU_VBLANK_INT("screen", mz2500_vbl)
	2100	MCFG_CPU_VBLANK_INT_DRIVER("screen", mz2500_state, mz2500_vbl)
2101	2101
2102	2102
2103	2103	MCFG_I8255_ADD( "i8255_0", ppi8255_intf )

trunk/src/mess/drivers/fmtowns.c

r17997	r17998
2670	2670	MCFG_CPU_ADD("maincpu",I386, 16000000)
2671	2671	MCFG_CPU_PROGRAM_MAP(towns_mem)
2672	2672	MCFG_CPU_IO_MAP(towns_io)
2673		MCFG_CPU_VBLANK_INT("screen", towns_vsync_irq)
	2673	MCFG_CPU_VBLANK_INT_DRIVER("screen", towns_state, towns_vsync_irq)
2674	2674
2675	2675	//    MCFG_MACHINE_RESET_OVERRIDE(towns_state,towns)
2676	2676
r17997	r17998
2741	2741	MCFG_CPU_REPLACE("maincpu",I386, 16000000)
2742	2742	MCFG_CPU_PROGRAM_MAP(ux_mem)
2743	2743	MCFG_CPU_IO_MAP(towns_io)
2744		MCFG_CPU_VBLANK_INT("screen", towns_vsync_irq)
	2744	MCFG_CPU_VBLANK_INT_DRIVER("screen", towns_state, towns_vsync_irq)
2745	2745
2746	2746	MCFG_RAM_MODIFY(RAM_TAG)
2747	2747	MCFG_RAM_DEFAULT_SIZE("2M")
r17997	r17998
2753	2753	MCFG_CPU_REPLACE("maincpu",I486, 66000000)
2754	2754	MCFG_CPU_PROGRAM_MAP(towns_mem)
2755	2755	MCFG_CPU_IO_MAP(towns_io)
2756		MCFG_CPU_VBLANK_INT("screen", towns_vsync_irq)
	2756	MCFG_CPU_VBLANK_INT_DRIVER("screen", towns_state, towns_vsync_irq)
2757	2757
2758	2758	MCFG_RAM_MODIFY(RAM_TAG)
2759	2759	MCFG_RAM_DEFAULT_SIZE("8M")
r17997	r17998
2765	2765	MCFG_CPU_REPLACE("maincpu",I486, 20000000)
2766	2766	MCFG_CPU_PROGRAM_MAP(towns_mem)
2767	2767	MCFG_CPU_IO_MAP(towns_io)
2768		MCFG_CPU_VBLANK_INT("screen", towns_vsync_irq)
	2768	MCFG_CPU_VBLANK_INT_DRIVER("screen", towns_state, towns_vsync_irq)
2769	2769
2770	2770	MCFG_RAM_MODIFY(RAM_TAG)
2771	2771	MCFG_RAM_DEFAULT_SIZE("4M")
r17997	r17998
2778	2778	MCFG_CPU_REPLACE("maincpu",I386, 16000000)
2779	2779	MCFG_CPU_PROGRAM_MAP(marty_mem)
2780	2780	MCFG_CPU_IO_MAP(towns_io)
2781		MCFG_CPU_VBLANK_INT("screen", towns_vsync_irq)
	2781	MCFG_CPU_VBLANK_INT_DRIVER("screen", towns_state, towns_vsync_irq)
2782	2782
2783	2783	MCFG_RAM_MODIFY(RAM_TAG)
2784	2784	MCFG_RAM_DEFAULT_SIZE("6M")

trunk/src/mess/drivers/gmaster.c

r17997	r17998
205	205	}
206	206
207	207
208		static INTERRUPT_GEN( gmaster_interrupt )
	208	INTERRUPT_GEN_MEMBER(gmaster_state::gmaster_interrupt)
209	209	{
210		device->machine().device("maincpu")->execute().set_input_line(UPD7810_INTFE1, ASSERT_LINE);
	210	machine().device("maincpu")->execute().set_input_line(UPD7810_INTFE1, ASSERT_LINE);
211	211	}
212	212
213	213	static const UPD7810_CONFIG config = {
r17997	r17998
221	221	MCFG_CPU_PROGRAM_MAP(gmaster_mem)
222	222	MCFG_CPU_IO_MAP( gmaster_io)
223	223	MCFG_CPU_CONFIG( config )
224		MCFG_CPU_VBLANK_INT("screen", gmaster_interrupt)
	224	MCFG_CPU_VBLANK_INT_DRIVER("screen", gmaster_state, gmaster_interrupt)
225	225
226	226	MCFG_SCREEN_ADD("screen", LCD)
227	227	MCFG_SCREEN_REFRESH_RATE(60)

trunk/src/mess/drivers/newbrain.c

r17997	r17998
1329	1329	timer_set(attotime::from_usec(get_reset_t()), TIMER_ID_RESET);
1330	1330	}
1331	1331
1332		static INTERRUPT_GEN( newbrain_interrupt )
	1332	INTERRUPT_GEN_MEMBER(newbrain_state::newbrain_interrupt)
1333	1333	{
1334		newbrain_state *state = device->machine().driver_data<newbrain_state>();
1335	1334
1336		if (!(state->m_enrg1 & NEWBRAIN_ENRG1_CLK))
	1335	if (!(m_enrg1 & NEWBRAIN_ENRG1_CLK))
1337	1336	{
1338		state->m_clkint = 0;
1339		state->check_interrupt();
	1337	m_clkint = 0;
	1338	check_interrupt();
1340	1339	}
1341	1340	}
1342	1341
r17997	r17998
1381	1380	MCFG_CPU_ADD(Z80_TAG, Z80, XTAL_16MHz/8)
1382	1381	MCFG_CPU_PROGRAM_MAP(newbrain_map)
1383	1382	MCFG_CPU_IO_MAP(newbrain_a_io_map)
1384		MCFG_CPU_VBLANK_INT(SCREEN_TAG, newbrain_interrupt)
	1383	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, newbrain_state, newbrain_interrupt)
1385	1384
1386	1385	MCFG_CPU_ADD(COP420_TAG, COP420, XTAL_16MHz/8) // COP420-GUW/N
1387	1386	MCFG_CPU_IO_MAP(newbrain_cop_io_map)

trunk/src/mess/drivers/microtan.c

r17997	r17998
219	219	/* basic machine hardware */
220	220	MCFG_CPU_ADD("maincpu", M6502, 750000)   // 750 kHz
221	221	MCFG_CPU_PROGRAM_MAP(microtan_map)
222		MCFG_CPU_VBLANK_INT("screen", microtan_interrupt)
	222	MCFG_CPU_VBLANK_INT_DRIVER("screen", microtan_state, microtan_interrupt)
223	223
224	224
225	225	/* video hardware - include overscan */

trunk/src/mess/drivers/ti99_2.c

r17997	r17998
102	102	virtual void machine_reset();
103	103	virtual void palette_init();
104	104	UINT32 screen_update_ti99_2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	105	INTERRUPT_GEN_MEMBER(ti99_2_vblank_interrupt);
105	106	};
106	107
107	108
r17997	r17998
130	131	membank("bank1")->set_base((memregion("maincpu")->base()+0x4000));
131	132	}
132	133
133		static INTERRUPT_GEN( ti99_2_vblank_interrupt )
	134	INTERRUPT_GEN_MEMBER(ti99_2_state::ti99_2_vblank_interrupt)
134	135	{
135		ti99_2_state *state = device->machine().driver_data<ti99_2_state>();
136		device->execute().set_input_line(1, state->m_irq_state);
137		state->m_irq_state = (state->m_irq_state == ASSERT_LINE) ? CLEAR_LINE : ASSERT_LINE;
	136	device.execute().set_input_line(1, m_irq_state);
	137	m_irq_state = (m_irq_state == ASSERT_LINE) ? CLEAR_LINE : ASSERT_LINE;
138	138	}
139	139
140	140
r17997	r17998
380	380	MCFG_CPU_CONFIG(ti99_2_processor_config)
381	381	MCFG_CPU_PROGRAM_MAP(ti99_2_memmap)
382	382	MCFG_CPU_IO_MAP(ti99_2_io)
383		MCFG_CPU_VBLANK_INT("screen", ti99_2_vblank_interrupt)
	383	MCFG_CPU_VBLANK_INT_DRIVER("screen", ti99_2_state, ti99_2_vblank_interrupt)
384	384
385	385
386	386	/* video hardware */

trunk/src/mess/drivers/bml3.c

r17997	r17998
113	113	virtual void palette_init();
114	114	public:
115	115	UINT32 screen_update_bml3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	116	INTERRUPT_GEN_MEMBER(bml3_irq);
	117	INTERRUPT_GEN_MEMBER(bml3_timer_firq);
116	118	};
117	119
118	120	#define mc6845_h_char_total    (m_crtc_vreg[0])
r17997	r17998
600	602	}
601	603
602	604	#if 0
603		static INTERRUPT_GEN( bml3_irq )
	605	INTERRUPT_GEN_MEMBER(bml3_state::bml3_irq)
604	606	{
605		device->machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE);
	607	machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE);
606	608	}
607	609	#endif
608	610
609	611
610		static INTERRUPT_GEN( bml3_timer_firq )
	612	INTERRUPT_GEN_MEMBER(bml3_state::bml3_timer_firq)
611	613	{
612		bml3_state *state = device->machine().driver_data<bml3_state>();
613	614
614		if(!state->m_firq_mask)
	615	if(!m_firq_mask)
615	616	{
616		state->m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
617		state->m_firq_status = 1;
	617	m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
	618	m_firq_status = 1;
618	619	}
619	620	}
620	621
r17997	r17998
889	890	/* basic machine hardware */
890	891	MCFG_CPU_ADD("maincpu",M6809, XTAL_1MHz)
891	892	MCFG_CPU_PROGRAM_MAP(bml3_mem)
892		MCFG_CPU_VBLANK_INT("screen", bml3_timer_firq )
893		//  MCFG_CPU_PERIODIC_INT(bml3_firq,45)
	893	MCFG_CPU_VBLANK_INT_DRIVER("screen", bml3_state,  bml3_timer_firq)
	894	//   MCFG_CPU_PERIODIC_INT_DRIVER(bml3_state, bml3_firq, 45)
894	895
895	896	//  MCFG_MACHINE_RESET_OVERRIDE(bml3_state,bml3)
896	897

trunk/src/mess/drivers/poly88.c

r17997	r17998
169	169	MCFG_CPU_ADD("maincpu",I8080, 1853000)
170	170	MCFG_CPU_PROGRAM_MAP(poly88_mem)
171	171	MCFG_CPU_IO_MAP(poly88_io)
172		MCFG_CPU_VBLANK_INT("screen", poly88_interrupt)
	172	MCFG_CPU_VBLANK_INT_DRIVER("screen", poly88_state, poly88_interrupt)
173	173
174	174
175	175	/* video hardware */

trunk/src/mess/drivers/samcoupe.c

r17997	r17998
349	349	state->m_status &= ~src;
350	350	}
351	351
352		static INTERRUPT_GEN( samcoupe_frame_interrupt )
	352	INTERRUPT_GEN_MEMBER(samcoupe_state::samcoupe_frame_interrupt)
353	353	{
354	354	/* signal frame interrupt */
355		samcoupe_irq(device, SAM_FRAME_INT);
	355	samcoupe_irq(&device, SAM_FRAME_INT);
356	356	}
357	357
358	358
r17997	r17998
530	530	MCFG_CPU_ADD("maincpu", Z80, SAMCOUPE_XTAL_X1 / 4) /* 6 MHz */
531	531	MCFG_CPU_PROGRAM_MAP(samcoupe_mem)
532	532	MCFG_CPU_IO_MAP(samcoupe_io)
533		MCFG_CPU_VBLANK_INT("screen", samcoupe_frame_interrupt)
	533	MCFG_CPU_VBLANK_INT_DRIVER("screen", samcoupe_state, samcoupe_frame_interrupt)
534	534
535	535
536	536	/* video hardware */

trunk/src/mess/drivers/trs80.c

r17997	r17998
610	610	MCFG_CPU_MODIFY( "maincpu" )
611	611	MCFG_CPU_PROGRAM_MAP( model1_map)
612	612	MCFG_CPU_IO_MAP( model1_io)
613		MCFG_CPU_PERIODIC_INT(trs80_rtc_interrupt, 40)
	613	MCFG_CPU_PERIODIC_INT_DRIVER(trs80_state, trs80_rtc_interrupt, 40)
614	614
615	615	/* devices */
616	616	MCFG_CASSETTE_MODIFY( CASSETTE_TAG, trs80l2_cassette_interface )
r17997	r17998
625	625	MCFG_CPU_MODIFY( "maincpu" )
626	626	MCFG_CPU_PROGRAM_MAP( model3_map)
627	627	MCFG_CPU_IO_MAP( model3_io)
628		MCFG_CPU_PERIODIC_INT(trs80_rtc_interrupt, 30)
	628	MCFG_CPU_PERIODIC_INT_DRIVER(trs80_state, trs80_rtc_interrupt, 30)
629	629
630	630	MCFG_MACHINE_RESET_OVERRIDE(trs80_state, trs80m4 )
631	631

trunk/src/mess/drivers/primo.c

r17997	r17998
262	262	MCFG_CPU_ADD( "maincpu", Z80, 2500000 )
263	263	MCFG_CPU_PROGRAM_MAP( primo32_mem)
264	264	MCFG_CPU_IO_MAP( primoa_port)
265		MCFG_CPU_VBLANK_INT("screen", primo_vblank_interrupt)
	265	MCFG_CPU_VBLANK_INT_DRIVER("screen", primo_state, primo_vblank_interrupt)
266	266
267	267
268	268	/* video hardware */

trunk/src/mess/drivers/homez80.c

r17997	r17998
39	39	virtual void machine_reset();
40	40	virtual void video_start();
41	41	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	42	INTERRUPT_GEN_MEMBER(homez80_interrupt);
42	43	};
43	44
44	45
r17997	r17998
271	272	GFXDECODE_END
272	273
273	274
274		static INTERRUPT_GEN( homez80_interrupt )
	275	INTERRUPT_GEN_MEMBER(homez80_state::homez80_interrupt)
275	276	{
276		homez80_state *state = device->machine().driver_data<homez80_state>();
277		device->execute().set_input_line(0, (state->m_irq) ? HOLD_LINE : CLEAR_LINE);
278		state->m_irq ^= 1;
	277	device.execute().set_input_line(0, (m_irq) ? HOLD_LINE : CLEAR_LINE);
	278	m_irq ^= 1;
279	279	}
280	280
281	281	static MACHINE_CONFIG_START( homez80, homez80_state )
r17997	r17998
283	283	MCFG_CPU_ADD("maincpu",Z80, XTAL_8MHz / 2)
284	284	MCFG_CPU_PROGRAM_MAP(homez80_mem)
285	285	MCFG_CPU_IO_MAP(homez80_io)
286		MCFG_CPU_PERIODIC_INT(homez80_interrupt, 50)
	286	MCFG_CPU_PERIODIC_INT_DRIVER(homez80_state, homez80_interrupt, 50)
287	287
288	288	/* video hardware */
289	289	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/interact.c

r17997	r17998
143	143	/* basic machine hardware */
144	144	MCFG_CPU_ADD("maincpu", I8080, XTAL_2MHz)
145	145	MCFG_CPU_PROGRAM_MAP(interact_mem)
146		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) /*  put on the I8080 irq in Hz*/
	146	MCFG_CPU_PERIODIC_INT_DRIVER(interact_state, irq0_line_hold, 50) /*  put on the I8080 irq in Hz*/
147	147
148	148	MCFG_MACHINE_RESET_OVERRIDE(interact_state,interact)
149	149	MCFG_MACHINE_START_OVERRIDE(interact_state,interact)
r17997	r17998
184	184	/* basic machine hardware */
185	185	MCFG_CPU_ADD("maincpu", Z80, XTAL_1_75MHz)
186	186	MCFG_CPU_PROGRAM_MAP(interact_mem)
187		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) /*  put on the I8080 irq in Hz*/
	187	MCFG_CPU_PERIODIC_INT_DRIVER(interact_state, irq0_line_hold, 50) /*  put on the I8080 irq in Hz*/
188	188
189	189	MCFG_MACHINE_RESET_OVERRIDE(interact_state,interact)
190	190	MCFG_MACHINE_START_OVERRIDE(interact_state,interact)

trunk/src/mess/drivers/galaxy.c

r17997	r17998
187	187	/* basic machine hardware */
188	188	MCFG_CPU_ADD("maincpu", Z80, XTAL / 2)
189	189	MCFG_CPU_PROGRAM_MAP(galaxy_mem)
190		MCFG_CPU_VBLANK_INT("screen", galaxy_interrupt)
	190	MCFG_CPU_VBLANK_INT_DRIVER("screen", galaxy_state, galaxy_interrupt)
191	191	MCFG_SCREEN_ADD("screen", RASTER)
192	192	MCFG_SCREEN_REFRESH_RATE(50)
193	193
r17997	r17998
223	223	MCFG_CPU_ADD("maincpu", Z80, XTAL / 2)
224	224	MCFG_CPU_PROGRAM_MAP(galaxyp_mem)
225	225	MCFG_CPU_IO_MAP(galaxyp_io)
226		MCFG_CPU_VBLANK_INT("screen", galaxy_interrupt)
	226	MCFG_CPU_VBLANK_INT_DRIVER("screen", galaxy_state, galaxy_interrupt)
227	227	MCFG_SCREEN_ADD("screen", RASTER)
228	228	MCFG_SCREEN_REFRESH_RATE(50)
229	229

trunk/src/mess/drivers/sm1800.c

r17997	r17998
45	45	virtual void video_start();
46	46	virtual void palette_init();
47	47	UINT32 screen_update_sm1800(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	48	INTERRUPT_GEN_MEMBER(sm1800_vblank_interrupt);
48	49	};
49	50
50	51	static ADDRESS_MAP_START(sm1800_mem, AS_PROGRAM, 8, sm1800_state)
r17997	r17998
92	93	return 0;
93	94	}
94	95
95		static INTERRUPT_GEN( sm1800_vblank_interrupt )
	96	INTERRUPT_GEN_MEMBER(sm1800_state::sm1800_vblank_interrupt)
96	97	{
97		sm1800_state *state = device->machine().driver_data<sm1800_state>();
98		device->machine().device("maincpu")->execute().set_input_line(0, state->m_irq_state ?  HOLD_LINE : CLEAR_LINE);
99		state->m_irq_state ^= 1;
	98	machine().device("maincpu")->execute().set_input_line(0, m_irq_state ?  HOLD_LINE : CLEAR_LINE);
	99	m_irq_state ^= 1;
100	100	}
101	101
102	102	static I8275_DISPLAY_PIXELS(sm1800_display_pixels)
r17997	r17998
189	189	MCFG_CPU_ADD("maincpu",I8080, XTAL_2MHz)
190	190	MCFG_CPU_PROGRAM_MAP(sm1800_mem)
191	191	MCFG_CPU_IO_MAP(sm1800_io)
192		MCFG_CPU_VBLANK_INT("screen", sm1800_vblank_interrupt)
	192	MCFG_CPU_VBLANK_INT_DRIVER("screen", sm1800_state, sm1800_vblank_interrupt)
193	193
194	194	/* video hardware */
195	195	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/compis.c

r17997	r17998
357	357	MCFG_CPU_ADD("maincpu", I80186, 8000000)   /* 8 MHz */
358	358	MCFG_CPU_PROGRAM_MAP(compis_mem)
359	359	MCFG_CPU_IO_MAP(compis_io)
360		MCFG_CPU_VBLANK_INT("screen", compis_vblank_int)
	360	MCFG_CPU_VBLANK_INT_DRIVER("screen", compis_state, compis_vblank_int)
361	361	MCFG_CPU_CONFIG(i86_address_mask)
362	362
363	363	//MCFG_QUANTUM_TIME(attotime::from_hz(60))
r17997	r17998
400	400	MCFG_CPU_ADD("maincpu", I80186, 8000000)   /* 8 MHz */
401	401	MCFG_CPU_PROGRAM_MAP(compis_mem)
402	402	MCFG_CPU_IO_MAP(compis_io)
403		MCFG_CPU_VBLANK_INT("screen", compis_vblank_int)
	403	MCFG_CPU_VBLANK_INT_DRIVER("screen", compis_state, compis_vblank_int)
404	404	MCFG_CPU_CONFIG(i86_address_mask)
405	405
406	406	//MCFG_QUANTUM_TIME(attotime::from_hz(60))

trunk/src/mess/drivers/vtech2.c

r17997	r17998
398	398	colortable_entry_set_value(machine().colortable, 512+i, i);
399	399	}
400	400
401		static INTERRUPT_GEN( vtech2_interrupt )
	401	INTERRUPT_GEN_MEMBER(vtech2_state::vtech2_interrupt)
402	402	{
403		device->machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
	403	machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
404	404	}
405	405
406	406	static const cassette_interface laser_cassette_interface =
r17997	r17998
430	430	MCFG_CPU_ADD("maincpu", Z80, 3694700)        /* 3.694700 MHz */
431	431	MCFG_CPU_PROGRAM_MAP(vtech2_mem)
432	432	MCFG_CPU_IO_MAP(vtech2_io)
433		MCFG_CPU_VBLANK_INT("screen", vtech2_interrupt)
	433	MCFG_CPU_VBLANK_INT_DRIVER("screen", vtech2_state, vtech2_interrupt)
434	434	MCFG_QUANTUM_TIME(attotime::from_hz(60))
435	435
436	436

trunk/src/mess/drivers/mac.c

r17997	r17998
78	78	// CA2: SCSI interrupt     = 0x01
79	79	// CB1: ASC interrupt      = 0x10
80	80
81		static INTERRUPT_GEN( mac_rbv_vbl )
	81	INTERRUPT_GEN_MEMBER(mac_state::mac_rbv_vbl)
82	82	{
83		mac_state *mac = device->machine().driver_data<mac_state>();
84	83
85		mac->m_rbv_regs[2] &= ~0x40;   // set vblank signal
86		mac->m_rbv_vbltime = 10;
	84	m_rbv_regs[2] &= ~0x40;   // set vblank signal
	85	m_rbv_vbltime = 10;
87	86
88	87	//  printf("RBV: raising VBL!\n");
89	88
90		if (mac->m_rbv_regs[0x12] & 0x40)
	89	if (m_rbv_regs[0x12] & 0x40)
91	90	{
92		mac->rbv_recalc_irqs();
	91	rbv_recalc_irqs();
93	92	}
94	93	}
95	94
r17997	r17998
1110	1109
1111	1110	MCFG_CPU_REPLACE("maincpu", M68020HMMU, C15M)
1112	1111	MCFG_CPU_PROGRAM_MAP(maclc_map)
1113		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1112	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1114	1113
1115	1114	MCFG_PALETTE_LENGTH(256)
1116	1115
r17997	r17998
1147	1146
1148	1147	MCFG_CPU_REPLACE("maincpu", M68030, C15M)
1149	1148	MCFG_CPU_PROGRAM_MAP(maclc_map)
1150		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1149	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1151	1150
1152	1151	MCFG_RAM_MODIFY(RAM_TAG)
1153	1152	MCFG_RAM_DEFAULT_SIZE("4M")
r17997	r17998
1164	1163
1165	1164	MCFG_CPU_REPLACE("maincpu", M68030, 25000000)
1166	1165	MCFG_CPU_PROGRAM_MAP(maclc3_map)
1167		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1166	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1168	1167
1169	1168	MCFG_VIDEO_START_OVERRIDE(mac_state,macsonora)
1170	1169	MCFG_VIDEO_RESET_OVERRIDE(mac_state,macsonora)
r17997	r17998
1193	1192
1194	1193	MCFG_CPU_REPLACE("maincpu", M68030, C32M)
1195	1194	MCFG_CPU_PROGRAM_MAP(maclc3_map)
1196		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1195	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1197	1196
1198	1197	MCFG_VIDEO_START_OVERRIDE(mac_state,macv8)
1199	1198	MCFG_VIDEO_RESET_OVERRIDE(mac_state,macrbv)
r17997	r17998
1217	1216
1218	1217	MCFG_CPU_REPLACE("maincpu", M68030, C15M)
1219	1218	MCFG_CPU_PROGRAM_MAP(maclc3_map)
1220		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1219	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1221	1220
1222	1221	MCFG_VIDEO_START_OVERRIDE(mac_state,macv8)
1223	1222	MCFG_VIDEO_RESET_OVERRIDE(mac_state,macrbv)
r17997	r17998
1486	1485
1487	1486	MCFG_CPU_REPLACE("maincpu", M68030, 25000000)
1488	1487	MCFG_CPU_PROGRAM_MAP(maciici_map)
1489		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1488	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1490	1489
1491	1490	MCFG_PALETTE_LENGTH(256)
1492	1491
r17997	r17998
1515	1514
1516	1515	MCFG_CPU_REPLACE("maincpu", M68030, 20000000)
1517	1516	MCFG_CPU_PROGRAM_MAP(maciici_map)
1518		MCFG_CPU_VBLANK_INT(MAC_SCREEN_NAME, mac_rbv_vbl)
	1517	MCFG_CPU_VBLANK_INT_DRIVER(MAC_SCREEN_NAME, mac_state, mac_rbv_vbl)
1519	1518
1520	1519	MCFG_PALETTE_LENGTH(256)
1521	1520

trunk/src/mess/drivers/tim011.c

r17997	r17998
56	56	MCFG_CPU_ADD("maincpu",Z180, XTAL_12_288MHz / 2)
57	57	MCFG_CPU_PROGRAM_MAP(tim011_mem)
58	58	MCFG_CPU_IO_MAP(tim011_io)
59		MCFG_CPU_VBLANK_INT("screen",irq0_line_hold)
	59	MCFG_CPU_VBLANK_INT_DRIVER("screen", tim011_state, irq0_line_hold)
60	60
61	61
62	62	/* video hardware */

trunk/src/mess/drivers/pk8000.c

r17997	r17998
30	30	virtual void machine_reset();
31	31	virtual void video_start();
32	32	UINT32 screen_update_pk8000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	33	INTERRUPT_GEN_MEMBER(pk8000_interrupt);
33	34	};
34	35
35	36
r17997	r17998
308	309	PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_UNUSED)
309	310	INPUT_PORTS_END
310	311
311		static INTERRUPT_GEN( pk8000_interrupt )
	312	INTERRUPT_GEN_MEMBER(pk8000_state::pk8000_interrupt)
312	313	{
313		device->execute().set_input_line(0, HOLD_LINE);
	314	device.execute().set_input_line(0, HOLD_LINE);
314	315	}
315	316
316	317	static IRQ_CALLBACK(pk8000_irq_callback)
r17997	r17998
349	350	MCFG_CPU_ADD("maincpu",I8080, 1780000)
350	351	MCFG_CPU_PROGRAM_MAP(pk8000_mem)
351	352	MCFG_CPU_IO_MAP(pk8000_io)
352		MCFG_CPU_VBLANK_INT("screen", pk8000_interrupt)
	353	MCFG_CPU_VBLANK_INT_DRIVER("screen", pk8000_state, pk8000_interrupt)
353	354
354	355
355	356	/* video hardware */

trunk/src/mess/drivers/concept.c

r17997	r17998
119	119	/* basic machine hardware */
120	120	MCFG_CPU_ADD("maincpu", M68000, 8182000)        /* 16.364 MHz / 2 */
121	121	MCFG_CPU_PROGRAM_MAP(concept_memmap)
122		MCFG_CPU_VBLANK_INT("screen", concept_interrupt)
	122	MCFG_CPU_VBLANK_INT_DRIVER("screen", concept_state, concept_interrupt)
123	123
124	124	MCFG_QUANTUM_TIME(attotime::from_hz(60))
125	125

trunk/src/mess/drivers/sgi_ip2.c

r17997	r17998
102	102	DECLARE_DRIVER_INIT(sgi_ip2);
103	103	virtual void machine_start();
104	104	virtual void machine_reset();
	105	INTERRUPT_GEN_MEMBER(sgi_ip2_vbl);
105	106	};
106	107
107	108
r17997	r17998
367	368	};
368	369
369	370
370		static INTERRUPT_GEN( sgi_ip2_vbl )
	371	INTERRUPT_GEN_MEMBER(sgi_ip2_state::sgi_ip2_vbl)
371	372	{
372	373	}
373	374
r17997	r17998
477	478	/* basic machine hardware */
478	479	MCFG_CPU_ADD("maincpu", M68020, 16000000)
479	480	MCFG_CPU_PROGRAM_MAP(sgi_ip2_map)
480		MCFG_CPU_VBLANK_INT(TERMINAL_TAG ":" TERMINAL_SCREEN_TAG, sgi_ip2_vbl)
	481	MCFG_CPU_VBLANK_INT_DRIVER(TERMINAL_TAG ":" TERMINAL_SCREEN_TAG, sgi_ip2_state, sgi_ip2_vbl)
481	482
482	483
483	484	/* video hardware */

trunk/src/mess/drivers/ti990_4.c

r17997	r17998
62	62	virtual void machine_reset();
63	63	virtual void video_start();
64	64	UINT32 screen_update_ti990_4(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	65	INTERRUPT_GEN_MEMBER(ti990_4_line_interrupt);
65	66	};
66	67
67	68
r17997	r17998
75	76	}
76	77
77	78
78		static INTERRUPT_GEN( ti990_4_line_interrupt )
	79	INTERRUPT_GEN_MEMBER(ti990_4_state::ti990_4_line_interrupt)
79	80	{
80		ti990_4_state *state = device->machine().driver_data<ti990_4_state>();
81	81
82	82	#if VIDEO_911
83		vdt911_keyboard(state->m_terminal);
	83	vdt911_keyboard(m_terminal);
84	84	#else
85		asr733_keyboard(state->m_terminal);
	85	asr733_keyboard(m_terminal);
86	86	#endif
87	87
88		ti990_line_interrupt(device->machine());
	88	ti990_line_interrupt(machine());
89	89	}
90	90
91	91	#ifdef UNUSED_FUNCTION
r17997	r17998
245	245	MCFG_CPU_ADD("maincpu", TMS9900L, 3000000)
246	246	MCFG_CPU_PROGRAM_MAP(ti990_4_memmap)
247	247	MCFG_CPU_IO_MAP(ti990_4_cru_map)
248		MCFG_CPU_PERIODIC_INT(ti990_4_line_interrupt, 120/*or TIME_IN_HZ(100) in Europe*/)
	248	MCFG_CPU_PERIODIC_INT_DRIVER(ti990_4_state, ti990_4_line_interrupt, 120/*or TIME_IN_HZ(100) in Europe*/)
249	249
250	250
251	251	/* video hardware - we emulate a single 911 vdt display */

trunk/src/mess/drivers/msx.c

r17997	r17998
1069	1069	MCFG_CPU_ADD("maincpu", Z80, XTAL_10_738635MHz/3)        /* 3.579545 MHz */
1070	1070	MCFG_CPU_PROGRAM_MAP(msx_memory_map)
1071	1071	MCFG_CPU_IO_MAP(msx_io_map)
1072		MCFG_CPU_VBLANK_INT("screen", msx_interrupt)   /* Needed for mouse updates */
	1072	MCFG_CPU_VBLANK_INT_DRIVER("screen", msx_state, msx_interrupt)   /* Needed for mouse updates */
1073	1073	MCFG_QUANTUM_TIME(attotime::from_hz(60))
1074	1074
1075	1075	MCFG_MACHINE_START_OVERRIDE(msx_state, msx )

trunk/src/mess/drivers/vt100.c

r17997	r17998
57	57	virtual void machine_start();
58	58	virtual void machine_reset();
59	59	UINT32 screen_update_vt100(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	60	INTERRUPT_GEN_MEMBER(vt100_vertical_interrupt);
60	61	};
61	62
62	63
r17997	r17998
379	380	DEVCB_DRIVER_MEMBER(vt100_state, vt100_clear_video_interrupt)
380	381	};
381	382
382		static INTERRUPT_GEN( vt100_vertical_interrupt )
	383	INTERRUPT_GEN_MEMBER(vt100_state::vt100_vertical_interrupt)
383	384	{
384		vt100_state *state = device->machine().driver_data<vt100_state>();
385		state->m_vertical_int = 1;
386		device->execute().set_input_line(0, HOLD_LINE);
	385	m_vertical_int = 1;
	386	device.execute().set_input_line(0, HOLD_LINE);
387	387	}
388	388
389	389	/* F4 Character Displayer */
r17997	r17998
412	412	MCFG_CPU_ADD("maincpu",I8080, XTAL_24_8832MHz / 9)
413	413	MCFG_CPU_PROGRAM_MAP(vt100_mem)
414	414	MCFG_CPU_IO_MAP(vt100_io)
415		MCFG_CPU_VBLANK_INT("screen", vt100_vertical_interrupt)
	415	MCFG_CPU_VBLANK_INT_DRIVER("screen", vt100_state, vt100_vertical_interrupt)
416	416
417	417
418	418	/* video hardware */

trunk/src/mess/drivers/vt240.c

r17997	r17998
47	47	required_shared_ptr<UINT8> m_video_ram;
48	48	DECLARE_DRIVER_INIT(vt240);
49	49	virtual void machine_reset();
	50	INTERRUPT_GEN_MEMBER(vt240_irq);
50	51	};
51	52
52	53	/* TODO */
r17997	r17998
140	141	DEVCB_NULL
141	142	};
142	143
143		static INTERRUPT_GEN( vt240_irq )
	144	INTERRUPT_GEN_MEMBER(vt240_state::vt240_irq)
144	145	{
145		//device->execute().set_input_line(I8085_RST65_LINE, ASSERT_LINE);
	146	//device.execute().set_input_line(I8085_RST65_LINE, ASSERT_LINE);
146	147	}
147	148
148	149	static const gfx_layout vt240_chars_8x8 =
r17997	r17998
165	166	MCFG_CPU_ADD("maincpu", I8085A, XTAL_16MHz / 4)
166	167	MCFG_CPU_PROGRAM_MAP(vt240_mem)
167	168	MCFG_CPU_IO_MAP(vt240_io)
168		MCFG_CPU_VBLANK_INT("screen",vt240_irq)
	169	MCFG_CPU_VBLANK_INT_DRIVER("screen", vt240_state, vt240_irq)
169	170
170	171
171	172	/* video hardware */

trunk/src/mess/drivers/pasogo.c

r17997	r17998
70	70	virtual void machine_reset();
71	71	virtual void palette_init();
72	72	UINT32 screen_update_pasogo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	73	INTERRUPT_GEN_MEMBER(pasogo_interrupt);
73	74	};
74	75
75	76
r17997	r17998
449	450	return 0;
450	451	}
451	452
452		static INTERRUPT_GEN( pasogo_interrupt )
	453	INTERRUPT_GEN_MEMBER(pasogo_state::pasogo_interrupt)
453	454	{
454	455	//  machine.device("maincpu")->execute().set_input_line(UPD7810_INTFE1, PULSE_LINE);
455	456	}
r17997	r17998
504	505	MCFG_CPU_ADD("maincpu", I80188/*V30HL in vadem vg230*/, 10000000/*?*/)
505	506	MCFG_CPU_PROGRAM_MAP(pasogo_mem)
506	507	MCFG_CPU_IO_MAP( pasogo_io)
507		MCFG_CPU_VBLANK_INT("screen", pasogo_interrupt)
	508	MCFG_CPU_VBLANK_INT_DRIVER("screen", pasogo_state, pasogo_interrupt)
508	509	//  MCFG_CPU_CONFIG(i86_address_mask)
509	510
510	511	MCFG_PIT8254_ADD( "pit8254", pc_pit8254_config )

trunk/src/mess/drivers/lisa.c

r17997	r17998
135	135	/* basic machine hardware */
136	136	MCFG_CPU_ADD("maincpu", M68000, 5093760)        /* 20.37504 MHz / 4 */
137	137	MCFG_CPU_PROGRAM_MAP(lisa_map)
138		MCFG_CPU_VBLANK_INT("screen", lisa_interrupt)
	138	MCFG_CPU_VBLANK_INT_DRIVER("screen", lisa_state, lisa_interrupt)
139	139
140	140	MCFG_CPU_ADD(COP421_TAG, COP421, 3900000)
141	141	MCFG_CPU_IO_MAP(lisa_cop_io_map)

trunk/src/mess/drivers/aquarius.c

r17997	r17998
397	397	MCFG_CPU_ADD("maincpu", Z80, XTAL_3_579545MHz) // ???
398	398	MCFG_CPU_PROGRAM_MAP(aquarius_mem)
399	399	MCFG_CPU_IO_MAP(aquarius_io)
400		MCFG_CPU_VBLANK_INT("screen", irq0_line_hold)
	400	MCFG_CPU_VBLANK_INT_DRIVER("screen", aquarius_state, irq0_line_hold)
401	401
402	402	/* video hardware */
403	403	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/cgenie.c

r17997	r17998
523	523	MCFG_CPU_ADD("maincpu", Z80, XTAL_17_73447MHz/8)        /* 2,2168 MHz */
524	524	MCFG_CPU_PROGRAM_MAP(cgenie_mem)
525	525	MCFG_CPU_IO_MAP(cgenie_io)
526		MCFG_CPU_VBLANK_INT("screen", cgenie_frame_interrupt)
527		MCFG_CPU_PERIODIC_INT(cgenie_timer_interrupt, 40)
	526	MCFG_CPU_VBLANK_INT_DRIVER("screen", cgenie_state,  cgenie_frame_interrupt)
	527	MCFG_CPU_PERIODIC_INT_DRIVER(cgenie_state, cgenie_timer_interrupt,  40)
528	528	MCFG_QUANTUM_TIME(attotime::from_hz(240))
529	529
530	530

trunk/src/mess/drivers/apexc.c

r17997	r17998
32	32	virtual void video_start();
33	33	virtual void palette_init();
34	34	UINT32 screen_update_apexc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	35	INTERRUPT_GEN_MEMBER(apexc_interrupt);
35	36	};
36	37
37	38
r17997	r17998
395	396	/*
396	397	Not a real interrupt - just handle keyboard input
397	398	*/
398		static INTERRUPT_GEN( apexc_interrupt )
	399	INTERRUPT_GEN_MEMBER(apexc_state::apexc_interrupt)
399	400	{
400		apexc_state *state = device->machine().driver_data<apexc_state>();
401		address_space& space = *device->machine().device("maincpu")->memory().space(AS_PROGRAM);
	401	address_space& space = *machine().device("maincpu")->memory().space(AS_PROGRAM);
402	402	UINT32 edit_keys;
403	403	int control_keys;
404	404
r17997	r17998
406	406
407	407
408	408	/* read new state of edit keys */
409		edit_keys = device->machine().root_device().ioport("data")->read();
	409	edit_keys = machine().root_device().ioport("data")->read();
410	410
411	411	/* toggle data reg according to transitions */
412		state->m_panel_data_reg ^= edit_keys & (~state->m_old_edit_keys);
	412	m_panel_data_reg ^= edit_keys & (~m_old_edit_keys);
413	413
414	414	/* remember new state of edit keys */
415		state->m_old_edit_keys = edit_keys;
	415	m_old_edit_keys = edit_keys;
416	416
417	417
418	418	/* read new state of control keys */
419		control_keys = state->ioport("panel")->read();
	419	control_keys = ioport("panel")->read();
420	420
421	421	/* compute transitions */
422		control_transitions = control_keys & (~state->m_old_control_keys);
	422	control_transitions = control_keys & (~m_old_control_keys);
423	423
424	424	/* process commands */
425	425
426	426	if (control_transitions & panel_run)
427	427	{   /* toggle run/stop state */
428		device->state().set_state_int(APEXC_STATE, ! device->state().state_int(APEXC_STATE));
	428	device.state().set_state_int(APEXC_STATE, ! device.state().state_int(APEXC_STATE));
429	429	}
430	430
431	431	while (control_transitions & (panel_CR | panel_A | panel_R | panel_ML | panel_HB))
r17997	r17998
467	467	/* read/write register #reg_id */
468	468	if (control_keys & panel_write)
469	469	/* write reg */
470		device->state().set_state_int(reg_id, state->m_panel_data_reg);
	470	device.state().set_state_int(reg_id, m_panel_data_reg);
471	471	else
472	472	/* read reg */
473		state->m_panel_data_reg = device->state().state_int(reg_id);
	473	m_panel_data_reg = device.state().state_int(reg_id);
474	474	}
475	475	}
476	476
r17997	r17998
479	479
480	480	if (control_keys & panel_write) {
481	481	/* write memory */
482		space.write_dword(device->state().state_int(APEXC_ML_FULL)<<2, state->m_panel_data_reg);
	482	space.write_dword(device.state().state_int(APEXC_ML_FULL)<<2, m_panel_data_reg);
483	483	}
484	484	else {
485	485	/* read memory */
486		state->m_panel_data_reg = space.read_dword(device->state().state_int(APEXC_ML_FULL)<<2);
	486	m_panel_data_reg = space.read_dword(device.state().state_int(APEXC_ML_FULL)<<2);
487	487	}
488	488	}
489	489
490	490	/* remember new state of control keys */
491		state->m_old_control_keys = control_keys;
	491	m_old_control_keys = control_keys;
492	492	}
493	493
494	494	/*
r17997	r17998
869	869	MCFG_CPU_PROGRAM_MAP(apexc_mem_map)
870	870	MCFG_CPU_IO_MAP(apexc_io_map)
871	871	/* dummy interrupt: handles the control panel */
872		MCFG_CPU_VBLANK_INT("screen", apexc_interrupt)
	872	MCFG_CPU_VBLANK_INT_DRIVER("screen", apexc_state, apexc_interrupt)
873	873	/*MCFG_CPU_PERIODIC_INT(func, rate)*/
874	874
875	875

trunk/src/mess/drivers/x68k.c

r17997	r17998
1895	1895	drvstate->m_mfp_prev = state;
1896	1896	}
1897	1897
1898		static INTERRUPT_GEN( x68k_vsync_irq )
	1898	INTERRUPT_GEN_MEMBER(x68k_state::x68k_vsync_irq)
1899	1899	{
1900	1900	#if 0
1901	1901	x68k_state *state = machine.driver_data<x68k_state>();
1902		if(state->m_mfp.ierb & 0x40)
	1902	if(m_mfp.ierb & 0x40)
1903	1903	{
1904		state->m_mfp.isrb |= 0x40;
1905		state->m_current_vector[6] = (state->m_mfp.vr & 0xf0) | 0x06;  // GPIP4 (V-DISP)
1906		state->m_current_irq_line = 6;
	1904	m_mfp.isrb |= 0x40;
	1905	m_current_vector[6] = (m_mfp.vr & 0xf0) | 0x06;  // GPIP4 (V-DISP)
	1906	m_current_irq_line = 6;
1907	1907	mfp_timer_a_callback(0);  // Timer A is usually always in event count mode, and is tied to V-DISP
1908	1908	mfp_trigger_irq(MFP_IRQ_GPIP4);
1909	1909	}
1910		if(state->m_crtc.height == 256)
1911		machine.primary_screen->update_partial(256);//state->m_crtc.reg[4]/2);
	1910	if(m_crtc.height == 256)
	1911	machine.primary_screen->update_partial(256);//m_crtc.reg[4]/2);
1912	1912	else
1913		machine.primary_screen->update_partial(512);//state->m_crtc.reg[4]);
	1913	machine.primary_screen->update_partial(512);//m_crtc.reg[4]);
1914	1914	#endif
1915	1915	}
1916	1916
r17997	r17998
2741	2741	/* basic machine hardware */
2742	2742	MCFG_CPU_ADD("maincpu", M68000, 10000000)  /* 10 MHz */
2743	2743	MCFG_CPU_PROGRAM_MAP(x68k_map)
2744		MCFG_CPU_VBLANK_INT("screen", x68k_vsync_irq)
	2744	MCFG_CPU_VBLANK_INT_DRIVER("screen", x68k_state, x68k_vsync_irq)
2745	2745	MCFG_QUANTUM_TIME(attotime::from_hz(60))
2746	2746
2747	2747	MCFG_MACHINE_START_OVERRIDE(x68k_state, x68000 )

trunk/src/mess/drivers/ondra.c

r17997	r17998
105	105	PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("NMI") PORT_CODE(KEYCODE_ESC)
106	106	INPUT_PORTS_END
107	107
108		static INTERRUPT_GEN( ondra_interrupt )
	108	INTERRUPT_GEN_MEMBER(ondra_state::ondra_interrupt)
109	109	{
110		device->execute().set_input_line(0, HOLD_LINE);
	110	device.execute().set_input_line(0, HOLD_LINE);
111	111	}
112	112
113	113	static const cassette_interface ondra_cassette_interface =
r17997	r17998
125	125	MCFG_CPU_ADD("maincpu", Z80, 2000000)
126	126	MCFG_CPU_PROGRAM_MAP(ondra_mem)
127	127	MCFG_CPU_IO_MAP(ondra_io)
128		MCFG_CPU_VBLANK_INT("screen", ondra_interrupt)
	128	MCFG_CPU_VBLANK_INT_DRIVER("screen", ondra_state, ondra_interrupt)
129	129
130	130
131	131	/* video hardware */

trunk/src/mess/drivers/pc2000.c

r17997	r17998
329	329	MCFG_CPU_ADD("maincpu",Z80, XTAL_4MHz) /* probably not accurate */
330	330	MCFG_CPU_PROGRAM_MAP(pc2000_mem)
331	331	MCFG_CPU_IO_MAP(pc2000_io)
332		MCFG_CPU_VBLANK_INT("screen",irq0_line_hold)
	332	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc2000_state, irq0_line_hold)
333	333
334	334	/* video hardware */
335	335	MCFG_SCREEN_ADD("screen", LCD)

trunk/src/mess/drivers/kaypro.c

r17997	r17998
239	239	MCFG_CPU_ADD("maincpu", Z80, XTAL_2_5MHz)
240	240	MCFG_CPU_PROGRAM_MAP(kaypro_map)
241	241	MCFG_CPU_IO_MAP(kayproii_io)
242		MCFG_CPU_VBLANK_INT("screen", kay_kbd_interrupt)   /* this doesn't actually exist, it is to run the keyboard */
	242	MCFG_CPU_VBLANK_INT_DRIVER("screen", kaypro_state, kay_kbd_interrupt)   /* this doesn't actually exist, it is to run the keyboard */
243	243	MCFG_CPU_CONFIG(kayproii_daisy_chain)
244	244
245	245	MCFG_MACHINE_START_OVERRIDE(kaypro_state, kayproii )
r17997	r17998
284	284	MCFG_CPU_ADD("maincpu", Z80, XTAL_4MHz)
285	285	MCFG_CPU_PROGRAM_MAP(kaypro_map)
286	286	MCFG_CPU_IO_MAP(kaypro2x_io)
287		MCFG_CPU_VBLANK_INT("screen", kay_kbd_interrupt)
	287	MCFG_CPU_VBLANK_INT_DRIVER("screen", kaypro_state, kay_kbd_interrupt)
288	288	MCFG_CPU_CONFIG(kaypro2x_daisy_chain)
289	289
290	290	MCFG_MACHINE_RESET_OVERRIDE(kaypro_state, kaypro2x )

trunk/src/mess/drivers/socrates.c

r17997	r17998
128	128	virtual void video_start();
129	129	virtual void palette_init();
130	130	UINT32 screen_update_socrates(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	131	INTERRUPT_GEN_MEMBER(assert_irq);
131	132	};
132	133
133	134
r17997	r17998
909	910	state->m_vblankstate = 0;
910	911	}
911	912
912		static INTERRUPT_GEN( assert_irq )
	913	INTERRUPT_GEN_MEMBER(socrates_state::assert_irq)
913	914	{
914		socrates_state *state = device->machine().driver_data<socrates_state>();
915		device->execute().set_input_line(0, ASSERT_LINE);
916		device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(44), FUNC(clear_irq_cb));
	915	device.execute().set_input_line(0, ASSERT_LINE);
	916	machine().scheduler().timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(44), FUNC(clear_irq_cb));
917	917	// 44 is a complete and total guess, need to properly measure how many clocks/microseconds the int line is high for.
918		state->m_vblankstate = 1;
919		state->m_kbmcu_rscount = 0; // clear the mcu poke count
	918	m_vblankstate = 1;
	919	m_kbmcu_rscount = 0; // clear the mcu poke count
920	920	}
921	921
922	922	static MACHINE_CONFIG_START( socrates, socrates_state )
r17997	r17998
925	925	MCFG_CPU_PROGRAM_MAP(z80_mem)
926	926	MCFG_CPU_IO_MAP(z80_io)
927	927	MCFG_QUANTUM_TIME(attotime::from_hz(60))
928		MCFG_CPU_VBLANK_INT("screen", assert_irq)
	928	MCFG_CPU_VBLANK_INT_DRIVER("screen", socrates_state, assert_irq)
929	929	//MCFG_MACHINE_START_OVERRIDE(socrates_state,socrates)
930	930
931	931	/* video hardware */

trunk/src/mess/drivers/pc8801.c

r17997	r17998
451	451	DECLARE_MACHINE_RESET(pc8801_clock_speed);
452	452	DECLARE_MACHINE_RESET(pc8801_dic);
453	453	DECLARE_MACHINE_RESET(pc8801_cdrom);
	454	INTERRUPT_GEN_MEMBER(pc8801_vrtc_irq);
454	455	};
455	456
456	457
r17997	r17998
2344	2345	pc8801_raise_irq(timer.machine(),1<<(2),1);
2345	2346	}
2346	2347
2347		static INTERRUPT_GEN( pc8801_vrtc_irq )
	2348	INTERRUPT_GEN_MEMBER(pc8801_state::pc8801_vrtc_irq)
2348	2349	{
2349		pc8801_state *state = device->machine().driver_data<pc8801_state>();
2350		if(state->m_vblank_irq_mask)
2351		pc8801_raise_irq(device->machine(),1<<(1),1);
	2350	if(m_vblank_irq_mask)
	2351	pc8801_raise_irq(machine(),1<<(1),1);
2352	2352	}
2353	2353
2354	2354	#else
r17997	r17998
2411	2411	}
2412	2412	}
2413	2413
2414		static INTERRUPT_GEN( pc8801_vrtc_irq )
	2414	INTERRUPT_GEN_MEMBER(pc8801_state::pc8801_vrtc_irq)
2415	2415	{
2416		pc8801_state *state = device->machine().driver_data<pc8801_state>();
2417		if(state->m_vrtc_irq_mask && state->m_i8214_irq_level >= 2)
	2416	if(m_vrtc_irq_mask && m_i8214_irq_level >= 2)
2418	2417	{
2419		state->m_vrtc_irq_latch = 1;
	2418	m_vrtc_irq_latch = 1;
2420	2419	//IRQ_LOG(("vrtc\n"));
2421		device->execute().set_input_line(0,HOLD_LINE);
	2420	device.execute().set_input_line(0,HOLD_LINE);
2422	2421	}
2423	2422	}
2424	2423	#endif
r17997	r17998
2663	2662	MCFG_CPU_ADD("maincpu", Z80, MASTER_CLOCK)        /* 4 MHz */
2664	2663	MCFG_CPU_PROGRAM_MAP(pc8801_mem)
2665	2664	MCFG_CPU_IO_MAP(pc8801_io)
2666		MCFG_CPU_VBLANK_INT("screen", pc8801_vrtc_irq)
	2665	MCFG_CPU_VBLANK_INT_DRIVER("screen", pc8801_state, pc8801_vrtc_irq)
2667	2666
2668	2667	/* sub CPU(5 inch floppy drive) */
2669	2668	MCFG_CPU_ADD("fdccpu", Z80, MASTER_CLOCK)      /* 4 MHz */

trunk/src/mess/drivers/rx78.c

r17997	r17998
476	476	MCFG_CPU_ADD("maincpu",Z80, MASTER_CLOCK/7)   // unknown divider
477	477	MCFG_CPU_PROGRAM_MAP(rx78_mem)
478	478	MCFG_CPU_IO_MAP(rx78_io)
479		MCFG_CPU_VBLANK_INT("screen",irq0_line_hold)
	479	MCFG_CPU_VBLANK_INT_DRIVER("screen", rx78_state, irq0_line_hold)
480	480
481	481	/* video hardware */
482	482	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/supracan.c

r17997	r17998
201	201	virtual void video_start();
202	202	virtual void palette_init();
203	203	UINT32 screen_update_supracan(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	204	INTERRUPT_GEN_MEMBER(supracan_irq);
	205	INTERRUPT_GEN_MEMBER(supracan_sound_irq);
204	206	};
205	207
206	208
r17997	r17998
1870	1872	GFXDECODE_ENTRY( "ram_gfx3",  0, supracan_gfx1bpp_alt,   0, 0x80 )
1871	1873	GFXDECODE_END
1872	1874
1873		static INTERRUPT_GEN( supracan_irq )
	1875	INTERRUPT_GEN_MEMBER(supracan_state::supracan_irq)
1874	1876	{
1875	1877	#if 0
1876		supracan_state *state = (supracan_state *)device->machine().driver_data<supracan_state>();
1877	1878
1878		if(state->m_irq_mask)
	1879	if(m_irq_mask)
1879	1880	{
1880		device->execute().set_input_line(7, HOLD_LINE);
	1881	device.execute().set_input_line(7, HOLD_LINE);
1881	1882	}
1882	1883	#endif
1883	1884	}
1884	1885
1885		static INTERRUPT_GEN( supracan_sound_irq )
	1886	INTERRUPT_GEN_MEMBER(supracan_state::supracan_sound_irq)
1886	1887	{
1887		supracan_state *state = (supracan_state *)device->machine().driver_data<supracan_state>();
1888	1888
1889		state->m_sound_irq_source_reg |= 0x80;
	1889	m_sound_irq_source_reg |= 0x80;
1890	1890
1891		if(state->m_sound_irq_enable_reg & state->m_sound_irq_source_reg)
	1891	if(m_sound_irq_enable_reg & m_sound_irq_source_reg)
1892	1892	{
1893		device->machine().device("soundcpu")->execute().set_input_line(0, ASSERT_LINE);
	1893	machine().device("soundcpu")->execute().set_input_line(0, ASSERT_LINE);
1894	1894	}
1895	1895	else
1896	1896	{
1897		device->machine().device("soundcpu")->execute().set_input_line(0, CLEAR_LINE);
	1897	machine().device("soundcpu")->execute().set_input_line(0, CLEAR_LINE);
1898	1898	}
1899	1899	}
1900	1900
r17997	r17998
1902	1902
1903	1903	MCFG_CPU_ADD( "maincpu", M68000, XTAL_10_738635MHz )      /* Correct frequency unknown */
1904	1904	MCFG_CPU_PROGRAM_MAP( supracan_mem )
1905		MCFG_CPU_VBLANK_INT("screen", supracan_irq)
	1905	MCFG_CPU_VBLANK_INT_DRIVER("screen", supracan_state, supracan_irq)
1906	1906
1907	1907	MCFG_CPU_ADD( "soundcpu", M6502, XTAL_3_579545MHz )      /* TODO: Verify actual clock */
1908	1908	MCFG_CPU_PROGRAM_MAP( supracan_sound_mem )
1909		MCFG_CPU_VBLANK_INT("screen", supracan_sound_irq)
	1909	MCFG_CPU_VBLANK_INT_DRIVER("screen", supracan_state, supracan_sound_irq)
1910	1910
1911	1911	#if !(SOUNDCPU_BOOT_HACK)
1912	1912	MCFG_QUANTUM_PERFECT_CPU("maincpu")

trunk/src/mess/drivers/hec2hrp.c

r17997	r17998
440	440	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
441	441	MCFG_CPU_PROGRAM_MAP(hec2hrp_mem)
442	442	MCFG_CPU_IO_MAP(hec2hrp_io)
443		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) /*  put on the Z80 irq in Hz*/
	443	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) /*  put on the Z80 irq in Hz*/
444	444	MCFG_MACHINE_RESET_OVERRIDE(hec2hrp_state,hec2hrp)
445	445	MCFG_MACHINE_START_OVERRIDE(hec2hrp_state,hec2hrp)
446	446
r17997	r17998
483	483	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
484	484	MCFG_CPU_PROGRAM_MAP(hec2hrp_mem)
485	485	MCFG_CPU_IO_MAP(hec2hrp_io)
486		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) /*  put on the Z80 irq in Hz*/
	486	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) /*  put on the Z80 irq in Hz*/
487	487	MCFG_MACHINE_RESET_OVERRIDE(hec2hrp_state,hec2hrp)
488	488	MCFG_MACHINE_START_OVERRIDE(hec2hrp_state,hec2hrp)
489	489
r17997	r17998
526	526	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
527	527	MCFG_CPU_PROGRAM_MAP(hec2hrx_mem)
528	528	MCFG_CPU_IO_MAP(hec2mx40_io)
529		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) //  put on the Z80 irq in Hz
	529	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) //  put on the Z80 irq in Hz
530	530
531	531	/* Disc II unit */
532	532	MCFG_CPU_ADD("disc2cpu",Z80, XTAL_4MHz)
r17997	r17998
575	575	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
576	576	MCFG_CPU_PROGRAM_MAP(hec2hrx_mem)
577	577	MCFG_CPU_IO_MAP(hec2hrx_io)
578		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) //  put on the Z80 irq in Hz
	578	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) //  put on the Z80 irq in Hz
579	579	MCFG_MACHINE_RESET_OVERRIDE(hec2hrp_state,hec2hrx)
580	580	MCFG_MACHINE_START_OVERRIDE(hec2hrp_state,hec2hrx)
581	581
r17997	r17998
625	625	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
626	626	MCFG_CPU_PROGRAM_MAP(hec2hrx_mem)
627	627	MCFG_CPU_IO_MAP(hec2mdhrx_io)
628		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) //  put on the Z80 irq in Hz
	628	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) //  put on the Z80 irq in Hz
629	629	MCFG_MACHINE_RESET_OVERRIDE(hec2hrp_state,hec2mdhrx)
630	630	MCFG_MACHINE_START_OVERRIDE(hec2hrp_state,hec2mdhrx)
631	631
r17997	r17998
673	673	MCFG_CPU_ADD("maincpu",Z80, XTAL_5MHz)
674	674	MCFG_CPU_PROGRAM_MAP(hec2hrx_mem)
675	675	MCFG_CPU_IO_MAP(hec2mx80_io)
676		MCFG_CPU_PERIODIC_INT(irq0_line_hold,50) //  put on the Z80 irq in Hz
	676	MCFG_CPU_PERIODIC_INT_DRIVER(hec2hrp_state, irq0_line_hold, 50) //  put on the Z80 irq in Hz
677	677	MCFG_MACHINE_RESET_OVERRIDE(hec2hrp_state,hec2hrx)
678	678	MCFG_MACHINE_START_OVERRIDE(hec2hrp_state,hec2hrx)
679	679

trunk/src/mess/drivers/intv.c

r17997	r17998
801	801	machine.device("keyboard")->execute().set_input_line(0, CLEAR_LINE);
802	802	}
803	803
804		static INTERRUPT_GEN( intv_interrupt2 )
	804	INTERRUPT_GEN_MEMBER(intv_state::intv_interrupt2)
805	805	{
806		device->machine().device("keyboard")->execute().set_input_line(0, ASSERT_LINE);
807		device->machine().scheduler().timer_set(device->machine().device<cpu_device>("keyboard")->cycles_to_attotime(100), FUNC(intv_interrupt2_complete));
	806	machine().device("keyboard")->execute().set_input_line(0, ASSERT_LINE);
	807	machine().scheduler().timer_set(machine().device<cpu_device>("keyboard")->cycles_to_attotime(100), FUNC(intv_interrupt2_complete));
808	808	}
809	809
810	810	static MACHINE_CONFIG_START( intv, intv_state )
811	811	/* basic machine hardware */
812	812	MCFG_CPU_ADD("maincpu", CP1610, XTAL_3_579545MHz/4)        /* Colorburst/4 */
813	813	MCFG_CPU_PROGRAM_MAP(intv_mem)
814		MCFG_CPU_VBLANK_INT("screen", intv_interrupt)
	814	MCFG_CPU_VBLANK_INT_DRIVER("screen", intv_state, intv_interrupt)
815	815	MCFG_QUANTUM_TIME(attotime::from_hz(60))
816	816
817	817
r17997	r17998
874	874
875	875	MCFG_CPU_ADD("keyboard", M6502, XTAL_3_579545MHz/2)   /* Colorburst/2 */
876	876	MCFG_CPU_PROGRAM_MAP(intvkbd2_mem)
877		MCFG_CPU_VBLANK_INT("screen", intv_interrupt2)
	877	MCFG_CPU_VBLANK_INT_DRIVER("screen", intv_state, intv_interrupt2)
878	878
879	879	MCFG_QUANTUM_TIME(attotime::from_hz(6000))
880	880

trunk/src/mess/drivers/elwro800.c

r17997	r17998
50	50	DECLARE_READ8_MEMBER(elwro800jr_io_r);
51	51	DECLARE_WRITE8_MEMBER(elwro800jr_io_w);
52	52	DECLARE_MACHINE_RESET(elwro800);
	53	INTERRUPT_GEN_MEMBER(elwro800jr_interrupt);
53	54	};
54	55
55	56
r17997	r17998
535	536	NULL
536	537	};
537	538
538		static INTERRUPT_GEN( elwro800jr_interrupt )
	539	INTERRUPT_GEN_MEMBER(elwro800_state::elwro800jr_interrupt)
539	540	{
540		device->execute().set_input_line(0, HOLD_LINE);
	541	device.execute().set_input_line(0, HOLD_LINE);
541	542	}
542	543
543	544	static const floppy_interface elwro800jr_floppy_interface =
r17997	r17998
578	579	MCFG_CPU_ADD("maincpu",Z80, 3500000)   /* 3.5 MHz */
579	580	MCFG_CPU_PROGRAM_MAP(elwro800_mem)
580	581	MCFG_CPU_IO_MAP(elwro800_io)
581		MCFG_CPU_VBLANK_INT("screen", elwro800jr_interrupt)
	582	MCFG_CPU_VBLANK_INT_DRIVER("screen", elwro800_state, elwro800jr_interrupt)
582	583
583	584	MCFG_MACHINE_RESET_OVERRIDE(elwro800_state,elwro800)
584	585

trunk/src/mess/drivers/pyl601.c

r17997	r17998
82	82	DECLARE_DRIVER_INIT(pyl601);
83	83	virtual void machine_reset();
84	84	virtual void video_start();
	85	INTERRUPT_GEN_MEMBER(pyl601_interrupt);
85	86	};
86	87
87	88
r17997	r17998
515	516	memset(machine().device<ram_device>(RAM_TAG)->pointer(), 0, 64 * 1024);
516	517	}
517	518
518		static INTERRUPT_GEN( pyl601_interrupt )
	519	INTERRUPT_GEN_MEMBER(pyl601_state::pyl601_interrupt)
519	520	{
520		pyl601_state *state = device->machine().driver_data<pyl601_state>();
521		state->m_tick50_mark = 0x80;
522		device->execute().set_input_line(0, HOLD_LINE);
	521	m_tick50_mark = 0x80;
	522	device.execute().set_input_line(0, HOLD_LINE);
523	523	}
524	524
525	525	static LEGACY_FLOPPY_OPTIONS_START(pyldin)
r17997	r17998
583	583	/* basic machine hardware */
584	584	MCFG_CPU_ADD("maincpu",M6800, XTAL_1MHz)
585	585	MCFG_CPU_PROGRAM_MAP(pyl601_mem)
586		MCFG_CPU_VBLANK_INT("screen", pyl601_interrupt)
	586	MCFG_CPU_VBLANK_INT_DRIVER("screen", pyl601_state, pyl601_interrupt)
587	587
588	588
589	589	/* video hardware */

trunk/src/mess/drivers/iq151.c

r17997	r17998
95	95	UINT8 m_cassette_data;
96	96	iq151cart_slot_device * m_carts[5];
97	97	DECLARE_DRIVER_INIT(iq151);
	98	INTERRUPT_GEN_MEMBER(iq151_vblank_interrupt);
98	99	};
99	100
100	101	READ8_MEMBER(iq151_state::keyboard_row_r)
r17997	r17998
319	320	m_maincpu->set_input_line(0, state ?  HOLD_LINE : CLEAR_LINE);
320	321	}
321	322
322		static INTERRUPT_GEN( iq151_vblank_interrupt )
	323	INTERRUPT_GEN_MEMBER(iq151_state::iq151_vblank_interrupt)
323	324	{
324		iq151_state *state = device->machine().driver_data<iq151_state>();
325	325
326		pic8259_ir6_w(state->m_pic, state->m_vblank_irq_state & 1);
327		state->m_vblank_irq_state ^= 1;
	326	pic8259_ir6_w(m_pic, m_vblank_irq_state & 1);
	327	m_vblank_irq_state ^= 1;
328	328	}
329	329
330	330	static IRQ_CALLBACK(iq151_irq_callback)
r17997	r17998
435	435	MCFG_CPU_ADD("maincpu",I8080, XTAL_2MHz)
436	436	MCFG_CPU_PROGRAM_MAP(iq151_mem)
437	437	MCFG_CPU_IO_MAP(iq151_io)
438		MCFG_CPU_VBLANK_INT("screen", iq151_vblank_interrupt)
	438	MCFG_CPU_VBLANK_INT_DRIVER("screen", iq151_state, iq151_vblank_interrupt)
439	439
440	440	/* video hardware */
441	441	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/h19.c

r17997	r17998
397	397	MCFG_CPU_ADD("maincpu",Z80, H19_CLOCK) // From schematics
398	398	MCFG_CPU_PROGRAM_MAP(h19_mem)
399	399	MCFG_CPU_IO_MAP(h19_io)
400		//MCFG_DEVICE_PERIODIC_INT(irq0_line_hold, 50) // for testing, causes a keyboard scan
	400	//MCFG_DEVICE_PERIODIC_INT_DRIVER(h19_state, irq0_line_hold, 50) // for testing, causes a keyboard scan
401	401
402	402	/* video hardware */
403	403	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/geniusiq.c

r17997	r17998
576	576	/* basic machine hardware */
577	577	MCFG_CPU_ADD("maincpu", M68000, XTAL_32MHz/2) // The main crystal is at 32MHz, not sure whats the CPU freq
578	578	MCFG_CPU_PROGRAM_MAP(geniusiq_mem)
579		MCFG_CPU_PERIODIC_INT(irq6_line_hold, 125)   // the internal clock is increased by 1 sec every 125 interrupts
	579	MCFG_CPU_PERIODIC_INT_DRIVER(geniusiq_state, irq6_line_hold, 125)   // the internal clock is increased by 1 sec every 125 interrupts
580	580
581	581	/* video hardware */
582	582	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/svision.c

r17997	r17998
414	414	return 0;
415	415	}
416	416
417		static INTERRUPT_GEN( svision_frame_int )
	417	INTERRUPT_GEN_MEMBER(svision_state::svision_frame_int)
418	418	{
419		svision_state *state = device->machine().driver_data<svision_state>();
420		if (state->BANK&1)
421		device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	419	if (BANK&1)
	420	device.execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
422	421
423		svision_sound_decrement(state->m_sound);
	422	svision_sound_decrement(m_sound);
424	423	}
425	424
426	425	DRIVER_INIT_MEMBER(svision_state,svision)
r17997	r17998
514	513	/* basic machine hardware */
515	514	MCFG_CPU_ADD("maincpu", M65C02, 4000000)        /* ? stz used! speed? */
516	515	MCFG_CPU_PROGRAM_MAP(svision_mem)
517		MCFG_CPU_VBLANK_INT("screen", svision_frame_int)
	516	MCFG_CPU_VBLANK_INT_DRIVER("screen", svision_state, svision_frame_int)
518	517
519	518
520	519	/* video hardware */

trunk/src/mess/drivers/c64.c

r17997	r17998
373	373	//  vic2_interface vic_intf
374	374	//-------------------------------------------------
375	375
376		static INTERRUPT_GEN( c64_frame_interrupt )
	376	INTERRUPT_GEN_MEMBER(c64_state::c64_frame_interrupt)
377	377	{
378		c64_state *state = device->machine().driver_data<c64_state>();
379	378
380		state->check_interrupts();
381		cbm_common_interrupt(device);
	379	check_interrupts();
	380	cbm_common_interrupt(&device);
382	381	}
383	382
384	383	WRITE_LINE_MEMBER( c64_state::vic_irq_w )
r17997	r17998
991	990	MCFG_CPU_ADD(M6510_TAG, M6510, VIC6567_CLOCK)
992	991	MCFG_CPU_PROGRAM_MAP(c64_mem)
993	992	MCFG_CPU_CONFIG(cpu_intf)
994		MCFG_CPU_VBLANK_INT(SCREEN_TAG, c64_frame_interrupt)
	993	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, c64_state, c64_frame_interrupt)
995	994	MCFG_QUANTUM_PERFECT_CPU(M6510_TAG)
996	995
997	996	// video hardware
r17997	r17998
1090	1089	MCFG_CPU_ADD(M6510_TAG, M6510, VIC6569_CLOCK)
1091	1090	MCFG_CPU_PROGRAM_MAP(c64_mem)
1092	1091	MCFG_CPU_CONFIG(cpu_intf)
1093		MCFG_CPU_VBLANK_INT(SCREEN_TAG, c64_frame_interrupt)
	1092	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, c64_state, c64_frame_interrupt)
1094	1093	MCFG_QUANTUM_PERFECT_CPU(M6510_TAG)
1095	1094
1096	1095	// video hardware
r17997	r17998
1167	1166	MCFG_CPU_ADD(M6510_TAG, M6510, VIC6569_CLOCK)
1168	1167	MCFG_CPU_PROGRAM_MAP(c64_mem)
1169	1168	MCFG_CPU_CONFIG(c64gs_cpu_intf)
1170		MCFG_CPU_VBLANK_INT(SCREEN_TAG, c64_frame_interrupt)
	1169	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, c64_state, c64_frame_interrupt)
1171	1170	MCFG_QUANTUM_PERFECT_CPU(M6510_TAG)
1172	1171
1173	1172	// video hardware

trunk/src/mess/drivers/vc4000.c

r17997	r17998
392	392	MCFG_CPU_ADD("maincpu", S2650, 3546875/4)
393	393	MCFG_CPU_PROGRAM_MAP(vc4000_mem)
394	394	MCFG_CPU_IO_MAP(vc4000_io)
395		MCFG_CPU_PERIODIC_INT(vc4000_video_line, 312*53)   // GOLF needs this exact value
	395	MCFG_CPU_PERIODIC_INT_DRIVER(vc4000_state, vc4000_video_line, 312*53)   // GOLF needs this exact value
396	396
397	397	/* video hardware */
398	398	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mess/drivers/vic10.c

r17997	r17998
202	202	//  vic2_interface vic_intf
203	203	//-------------------------------------------------
204	204
205		static INTERRUPT_GEN( vic10_frame_interrupt )
	205	INTERRUPT_GEN_MEMBER(vic10_state::vic10_frame_interrupt)
206	206	{
207		cbm_common_interrupt(device);
	207	cbm_common_interrupt(&device);
208	208	}
209	209
210	210	READ8_MEMBER( vic10_state::vic_lightpen_x_cb )
r17997	r17998
614	614	MCFG_CPU_ADD(M6510_TAG, M6510, VIC6566_CLOCK)
615	615	MCFG_CPU_PROGRAM_MAP(vic10_mem)
616	616	MCFG_CPU_CONFIG(cpu_intf)
617		MCFG_CPU_VBLANK_INT(SCREEN_TAG, vic10_frame_interrupt)
	617	MCFG_CPU_VBLANK_INT_DRIVER(SCREEN_TAG, vic10_state, vic10_frame_interrupt)
618	618	MCFG_QUANTUM_PERFECT_CPU(M6510_TAG)
619	619
620	620	// video hardware

trunk/src/mess/drivers/pk8020.c

r17997	r17998
205	205	MCFG_CPU_ADD("maincpu", I8080, XTAL_20MHz / 8)
206	206	MCFG_CPU_PROGRAM_MAP(pk8020_mem)
207	207	MCFG_CPU_IO_MAP(pk8020_io)
208		MCFG_CPU_VBLANK_INT("screen", pk8020_interrupt)
	208	MCFG_CPU_VBLANK_INT_DRIVER("screen", pk8020_state, pk8020_interrupt)
209	209
210	210
211	211	/* video hardware */

trunk/src/mess/drivers/bbc.c

r17997	r17998
691	691
692	692
693	693
694		static INTERRUPT_GEN( bbcb_vsync )
	694	INTERRUPT_GEN_MEMBER(bbc_state::bbcb_vsync)
695	695	{
696		via6522_device *via_0 = device->machine().device<via6522_device>("via6522_0");
	696	via6522_device *via_0 = machine().device<via6522_device>("via6522_0");
697	697	via_0->write_ca1(1);
698	698	via_0->write_ca1(0);
699	699	}
r17997	r17998
841	841	/* basic machine hardware */
842	842	MCFG_CPU_ADD("maincpu", M6502, 2000000)        /* 2.00 MHz */
843	843	MCFG_CPU_PROGRAM_MAP( bbca_mem)
844		MCFG_CPU_VBLANK_INT("screen", bbcb_vsync)      /* screen refresh interrupts */
845		MCFG_CPU_PERIODIC_INT(bbcb_keyscan, 1000)      /* scan keyboard */
	844	MCFG_CPU_VBLANK_INT_DRIVER("screen", bbc_state,  bbcb_vsync)      /* screen refresh interrupts */
	845	MCFG_CPU_PERIODIC_INT_DRIVER(bbc_state, bbcb_keyscan,  1000)      /* scan keyboard */
846	846	MCFG_QUANTUM_TIME(attotime::from_hz(60))
847	847
848	848	MCFG_MACHINE_START_OVERRIDE(bbc_state, bbca )
r17997	r17998
933	933	/* basic machine hardware */
934	934	MCFG_CPU_ADD("maincpu", M65SC02, 2000000)        /* 2.00 MHz */
935	935	MCFG_CPU_PROGRAM_MAP( bbcm_mem)
936		MCFG_CPU_VBLANK_INT("screen", bbcb_vsync)            /* screen refresh interrupts */
937		MCFG_CPU_PERIODIC_INT(bbcm_keyscan, 1000)      /* scan keyboard */
	936	MCFG_CPU_VBLANK_INT_DRIVER("screen", bbc_state,  bbcb_vsync)            /* screen refresh interrupts */
	937	MCFG_CPU_PERIODIC_INT_DRIVER(bbc_state, bbcm_keyscan,  1000)      /* scan keyboard */
938	938	MCFG_QUANTUM_TIME(attotime::from_hz(60))
939	939
940	940	MCFG_MACHINE_START_OVERRIDE(bbc_state, bbcm )

trunk/src/mess/drivers/alphasma.c

r17997	r17998
66	66	MCFG_CPU_PROGRAM_MAP(alphasmart_mem)
67	67	MCFG_CPU_IO_MAP(alphasmart_io)
68	68	MCFG_CPU_CONFIG(alphasmart_hc11_config)
69		MCFG_CPU_PERIODIC_INT(irq0_line_hold, 50)
	69	MCFG_CPU_PERIODIC_INT_DRIVER(alphasmart_state, irq0_line_hold, 50)
70	70
71	71	/* video hardware */
72	72	MCFG_SCREEN_ADD("screen", LCD)

trunk/src/mess/drivers/bmjr.c

r17997	r17998
347	347	/* basic machine hardware */
348	348	MCFG_CPU_ADD("maincpu",M6800, XTAL_4MHz/4) //unknown clock / divider
349	349	MCFG_CPU_PROGRAM_MAP(bmjr_mem)
350		MCFG_CPU_VBLANK_INT("screen", irq0_line_hold)
	350	MCFG_CPU_VBLANK_INT_DRIVER("screen", bmjr_state, irq0_line_hold)
351	351
352	352
353	353	/* video hardware */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team