Previous

199869 Revisions

Next

r20629 Thursday 31st January, 2013 at 12:21:12 UTC by Miodrag Milanović
IRQ_CALLBACK modernization part 1 (no whatsnew)

[src/mame/drivers]	aztarac.c dcheese.c mazerbla.c metro.c ms32.c pcxt.c quakeat.c seibuspi.c ssv.c
[src/mame/includes]	aztarac.h dcheese.h galaxold.h metro.h ms32.h seibuspi.h ssv.h
[src/mame/machine]	fd1094.c fd1094.h galaxold.c megacd.c megacd.h mie.c mie.h
[src/mame/video]	dcheese.c
[src/mess/drivers]	apc.c fm7.c fmtowns.c iq151.c pc88va.c pc9801.c pk8000.c prestige.c qx10.c sm1800.c tsispch.c
[src/mess/includes]	fm7.h fmtowns.h tsispch.h

trunk/src/mame/drivers/mazerbla.c

r20628	r20629
149	149	TIMER_CALLBACK_MEMBER(deferred_ls670_0_w);
150	150	TIMER_CALLBACK_MEMBER(deferred_ls670_1_w);
151	151	TIMER_CALLBACK_MEMBER(delayed_sound_w);
	152	IRQ_CALLBACK_MEMBER(irq_callback);
152	153	};
153	154
154	155
r20628	r20629
1394	1395	DEVCB_DRIVER_MEMBER(mazerbla_state,gg_led_ctrl_w)
1395	1396	};
1396	1397
1397		static IRQ_CALLBACK(irq_callback)
	1398	IRQ_CALLBACK_MEMBER(mazerbla_state::irq_callback)
1398	1399	{
1399	1400	/* all data lines are tied to +5V via 10K resistors */
1400	1401	/* D1 is set to GND when INT comes from CFB */
r20628	r20629
1408	1409	note:
1409	1410	1111 11110 (0xfe) - cannot happen and is not handled by game */
1410	1411
1411		mazerbla_state *state = device->machine().driver_data<mazerbla_state>();
1412		return (state->m_zpu_int_vector & ~1);  /* D0->GND is performed on CFB board */
	1412	return (m_zpu_int_vector & ~1);  /* D0->GND is performed on CFB board */
1413	1413	}
1414	1414
1415	1415	/* frequency is 14.318 MHz/16/16/16/16 */
r20628	r20629
1493	1493
1494	1494	memset(m_lookup_ram, 0, ARRAY_LENGTH(m_lookup_ram));
1495	1495
1496		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	1496	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mazerbla_state::irq_callback),this));
1497	1497	}
1498	1498
1499	1499

trunk/src/mame/drivers/ms32.c

r20628	r20629
389	389	return m_f1superb_extraram_16[offset];
390	390	}
391	391
392		static void irq_raise(running_machine &machine, int level);
393
394	392	WRITE32_MEMBER(ms32_state::ms32_irq2_guess_w)
395	393	{
396		irq_raise(machine(), 2);
	394	irq_raise(2);
397	395	}
398	396
399	397	WRITE32_MEMBER(ms32_state::ms32_irq5_guess_w)
400	398	{
401		irq_raise(machine(), 5);
	399	irq_raise(5);
402	400	}
403	401
404	402	static ADDRESS_MAP_START( f1superb_map, AS_PROGRAM, 32, ms32_state )
r20628	r20629
1277	1275	*/
1278	1276
1279	1277
1280		static IRQ_CALLBACK(irq_callback)
	1278	IRQ_CALLBACK_MEMBER(ms32_state::irq_callback)
1281	1279	{
1282		ms32_state *state = device->machine().driver_data<ms32_state>();
1283	1280	int i;
1284		for(i=15; i>=0 && !(state->m_irqreq & (1<<i)); i--);
1285		state->m_irqreq &= ~(1<<i);
1286		if(!state->m_irqreq)
1287		device->execute().set_input_line(0, CLEAR_LINE);
	1281	for(i=15; i>=0 && !(m_irqreq & (1<<i)); i--);
	1282	m_irqreq &= ~(1<<i);
	1283	if(!m_irqreq)
	1284	device.execute().set_input_line(0, CLEAR_LINE);
1288	1285	return i;
1289	1286	}
1290	1287
1291		static void irq_init(running_machine &machine)
	1288	void ms32_state::irq_init()
1292	1289	{
1293		ms32_state *state = machine.driver_data<ms32_state>();
1294		state->m_irqreq = 0;
1295		machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
1296		machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	1290	m_irqreq = 0;
	1291	machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
	1292	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(ms32_state::irq_callback),this));
1297	1293	}
1298	1294
1299		static void irq_raise(running_machine &machine, int level)
	1295	void ms32_state::irq_raise(int level)
1300	1296	{
1301		ms32_state *state = machine.driver_data<ms32_state>();
1302		state->m_irqreq |= (1<<level);
1303		machine.device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
	1297	m_irqreq |= (1<<level);
	1298	machine().device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
1304	1299	}
1305	1300
1306	1301	/* TODO: fix this arrangement (derived from old deprecat lib) */
1307	1302	TIMER_DEVICE_CALLBACK_MEMBER(ms32_state::ms32_interrupt)
1308	1303	{
1309	1304	int scanline = param;
1310		if( scanline == 0) irq_raise(machine(), 10);
1311		if( scanline == 8) irq_raise(machine(), 9);
	1305	if( scanline == 0) irq_raise(10);
	1306	if( scanline == 8) irq_raise(9);
1312	1307	/* hayaosi1 needs at least 12 IRQ 0 per frame to work (see code at FFE02289)
1313	1308	kirarast needs it too, at least 8 per frame, but waits for a variable amount
1314	1309	47pi2 needs ?? per frame (otherwise it hangs when you lose)
r20628	r20629
1317	1312	desertwr
1318	1313	p47aces
1319	1314	*/
1320		if( (scanline % 8) == 0 && scanline <= 224 ) irq_raise(machine(), 0);
	1315	if( (scanline % 8) == 0 && scanline <= 224 ) irq_raise(0);
1321	1316	}
1322	1317
1323	1318
r20628	r20629
1359	1354	WRITE8_MEMBER(ms32_state::to_main_w)
1360	1355	{
1361	1356	m_to_main=data;
1362		irq_raise(machine(), 1);
	1357	irq_raise(1);
1363	1358	}
1364	1359
1365	1360	static ADDRESS_MAP_START( ms32_sound_map, AS_PROGRAM, 8, ms32_state )
r20628	r20629
1384	1379	machine().root_device().membank("bank1")->set_base(machine().root_device().memregion("maincpu")->base());
1385	1380	machine().root_device().membank("bank4")->set_entry(0);
1386	1381	machine().root_device().membank("bank5")->set_entry(1);
1387		irq_init(machine());
	1382	irq_init();
1388	1383	}
1389	1384
1390	1385	/********** MACHINE DRIVER **********/

trunk/src/mame/drivers/ssv.c

r20628	r20629
176	176	***************************************************************************/
177	177
178	178	/* Update the IRQ state based on all possible causes */
179		static void update_irq_state(running_machine &machine)
	179	void ssv_state::update_irq_state()
180	180	{
181		ssv_state *state = machine.driver_data<ssv_state>();
182
183		machine.device("maincpu")->execute().set_input_line(0, (state->m_requested_int & state->m_irq_enable)? ASSERT_LINE : CLEAR_LINE);
	181	machine().device("maincpu")->execute().set_input_line(0, (m_requested_int & m_irq_enable)? ASSERT_LINE : CLEAR_LINE);
184	182	}
185	183
186		static IRQ_CALLBACK(ssv_irq_callback)
	184	IRQ_CALLBACK_MEMBER(ssv_state::ssv_irq_callback)
187	185	{
188		ssv_state *state = device->machine().driver_data<ssv_state>();
189
190	186	int i;
191	187	for ( i = 0; i <= 7; i++ )
192	188	{
193		if (state->m_requested_int & (1 << i))
	189	if (m_requested_int & (1 << i))
194	190	{
195		UINT16 vector = state->m_irq_vectors[i * (16/2)] & 7;
	191	UINT16 vector = m_irq_vectors[i * (16/2)] & 7;
196	192	return vector;
197	193	}
198	194	}
r20628	r20629
205	201
206	202	m_requested_int &= ~(1 << level);
207	203
208		update_irq_state(machine());
	204	update_irq_state();
209	205	}
210	206
211	207	/*
r20628	r20629
240	236	if (m_interrupt_ultrax)
241	237	{
242	238	m_requested_int |= 1 << 1;  // needed by ultrax to coin up, breaks cairblad
243		update_irq_state(machine());
	239	update_irq_state();
244	240	}
245	241	}
246	242	else if(scanline == 240)
247	243	{
248	244	m_requested_int |= 1 << 3;  // vblank
249		update_irq_state(machine());
	245	update_irq_state();
250	246	}
251	247	}
252	248
r20628	r20629
257	253	if ((scanline % 64) == 0)
258	254	{
259	255	m_requested_int |= 1 << 6;  // reads lightgun (4 times for 4 axis)
260		update_irq_state(machine());
	256	update_irq_state();
261	257	}
262	258	else if(scanline == 240)
263	259	{
264	260	m_requested_int |= 1 << 3;  // vblank
265		update_irq_state(machine());
	261	update_irq_state();
266	262	}
267	263	}
268	264
r20628	r20629
321	317	void ssv_state::machine_reset()
322	318	{
323	319	m_requested_int = 0;
324		machine().device("maincpu")->execute().set_irq_acknowledge_callback(ssv_irq_callback);
	320	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(ssv_state::ssv_irq_callback),this));
325	321	membank("bank1")->set_base(memregion("user1")->base());
326	322	}
327	323

trunk/src/mame/drivers/pcxt.c

r20628	r20629
125	125	DECLARE_DRIVER_INIT(filetto);
126	126	virtual void machine_reset();
127	127	UINT32 screen_update_tetriskr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	128	IRQ_CALLBACK_MEMBER(irq_callback);
128	129	};
129	130
130	131	UINT32 pcxt_state::screen_update_tetriskr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
r20628	r20629
541	542	DEVCB_NULL
542	543	};
543	544
544		static IRQ_CALLBACK(irq_callback)
	545	IRQ_CALLBACK_MEMBER(pcxt_state::irq_callback)
545	546	{
546		pcxt_state *state = device->machine().driver_data<pcxt_state>();
547		return pic8259_acknowledge(state->m_pic8259_1);
	547	return pic8259_acknowledge(m_pic8259_1);
548	548	}
549	549
550	550	static ADDRESS_MAP_START( filetto_map, AS_PROGRAM, 8, pcxt_state )
r20628	r20629
716	716	device_t *speaker = machine().device("speaker");
717	717	m_bank = -1;
718	718	m_lastvalue = -1;
719		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	719	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pcxt_state::irq_callback),this));
720	720
721	721	m_pc_spkrdata = 0;
722	722	m_pc_input = 0;

trunk/src/mame/drivers/dcheese.c

r20628	r20629
47	47	*
48	48	*************************************/
49	49
50		static void update_irq_state( device_t *cpu )
	50	void dcheese_state::update_irq_state()
51	51	{
52		dcheese_state *state = cpu->machine().driver_data<dcheese_state>();
53
54	52	int i;
55	53	for (i = 1; i < 5; i++)
56		cpu->execute().set_input_line(i, state->m_irq_state[i] ? ASSERT_LINE : CLEAR_LINE);
	54	m_maincpu->set_input_line(i, m_irq_state[i] ? ASSERT_LINE : CLEAR_LINE);
57	55	}
58	56
59	57
60		static IRQ_CALLBACK( irq_callback )
	58	IRQ_CALLBACK_MEMBER(dcheese_state::irq_callback)
61	59	{
62		dcheese_state *state = device->machine().driver_data<dcheese_state>();
63
64	60	/* auto-ack the IRQ */
65		state->m_irq_state[irqline] = 0;
66		update_irq_state(device);
	61	m_irq_state[irqline] = 0;
	62	update_irq_state();
67	63
68	64	/* vector is 0x40 + index */
69	65	return 0x40 + irqline;
70	66	}
71	67
72	68
73		void dcheese_signal_irq( running_machine &machine, int which )
	69	void dcheese_state::dcheese_signal_irq(int which )
74	70	{
75		dcheese_state *state = machine.driver_data<dcheese_state>();
76
77		state->m_irq_state[which] = 1;
78		update_irq_state(state->m_maincpu);
	71	m_irq_state[which] = 1;
	72	update_irq_state();
79	73	}
80	74
81	75
82	76	INTERRUPT_GEN_MEMBER(dcheese_state::dcheese_vblank)
83	77	{
84	78	logerror("---- VBLANK ----\n");
85		dcheese_signal_irq(machine(), 4);
	79	dcheese_signal_irq(4);
86	80	}
87	81
88	82
r20628	r20629
99	93	m_audiocpu = machine().device<cpu_device>("audiocpu");
100	94	m_bsmt = machine().device("bsmt");
101	95
102		m_maincpu->set_irq_acknowledge_callback(irq_callback);
	96	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(dcheese_state::irq_callback),this));
103	97
104	98	save_item(NAME(m_irq_state));
105	99	save_item(NAME(m_soundlatch_full));

trunk/src/mame/drivers/quakeat.c

r20628	r20629
77	77	virtual void machine_start();
78	78	virtual void video_start();
79	79	UINT32 screen_update_quake(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	80	IRQ_CALLBACK_MEMBER(irq_callback);
80	81	};
81	82
82	83
r20628	r20629
152	153
153	154	/*************************************************************/
154	155
155		static IRQ_CALLBACK(irq_callback)
	156	IRQ_CALLBACK_MEMBER(quakeat_state::irq_callback)
156	157	{
157		quakeat_state *state = device->machine().driver_data<quakeat_state>();
158		return pic8259_acknowledge( state->m_pic8259_1);
	158	return pic8259_acknowledge(m_pic8259_1);
159	159	}
160	160
161	161	void quakeat_state::machine_start()
162	162	{
163		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	163	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(quakeat_state::irq_callback),this));
164	164
165	165	m_pic8259_1 = machine().device( "pic8259_1" );
166	166	m_pic8259_2 = machine().device( "pic8259_2" );

trunk/src/mame/drivers/aztarac.c

r20628	r20629
29	29	*
30	30	*************************************/
31	31
32		static IRQ_CALLBACK(aztarac_irq_callback)
	32	IRQ_CALLBACK_MEMBER(aztarac_state::aztarac_irq_callback)
33	33	{
34	34	return 0xc;
35	35	}
r20628	r20629
37	37
38	38	void aztarac_state::machine_reset()
39	39	{
40		machine().device("maincpu")->execute().set_irq_acknowledge_callback(aztarac_irq_callback);
	40	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(aztarac_state::aztarac_irq_callback),this));
41	41	}
42	42
43	43

trunk/src/mame/drivers/metro.c

r20628	r20629
140	140
141	141
142	142	/* Update the IRQ state based on all possible causes */
143		static void update_irq_state( running_machine &machine )
	143	void metro_state::update_irq_state()
144	144	{
145		metro_state *state = machine.driver_data<metro_state>();
146		address_space &space = state->m_maincpu->space(AS_PROGRAM);
	145	address_space &space = m_maincpu->space(AS_PROGRAM);
147	146
148	147	/*  Get the pending IRQs (only the enabled ones, e.g. where irq_enable is *0*)  */
149		UINT16 irq = state->metro_irq_cause_r(space, 0, 0xffff) & ~*state->m_irq_enable;
	148	UINT16 irq = metro_irq_cause_r(space, 0, 0xffff) & ~*m_irq_enable;
150	149
151		if (state->m_irq_line == -1)    /* mouja, gakusai, gakusai2, dokyusei, dokyusp */
	150	if (m_irq_line == -1)    /* mouja, gakusai, gakusai2, dokyusei, dokyusp */
152	151	{
153	152	/*  This is for games that supply an *IRQ Vector* on the data bus together with an IRQ level for each possible IRQ source */
154	153	UINT8 irq_level[8] = { 0 };
r20628	r20629
156	155
157	156	for (i = 0; i < 8; i++)
158	157	if (BIT(irq, i))
159		irq_level[state->m_irq_levels[i] & 7] = 1;
	158	irq_level[m_irq_levels[i] & 7] = 1;
160	159
161	160	for (i = 0; i < 8; i++)
162		state->m_maincpu->set_input_line(i, irq_level[i] ? ASSERT_LINE : CLEAR_LINE);
	161	m_maincpu->set_input_line(i, irq_level[i] ? ASSERT_LINE : CLEAR_LINE);
163	162	}
164	163	else
165	164	{
r20628	r20629
167	166	then reads the actual source by peeking a register (metro_irq_cause_r) */
168	167
169	168	int irq_state = (irq ? ASSERT_LINE : CLEAR_LINE);
170		state->m_maincpu->set_input_line(state->m_irq_line, irq_state);
	169	m_maincpu->set_input_line(m_irq_line, irq_state);
171	170	}
172	171	}
173	172
174	173
175	174	/* For games that supply an *IRQ Vector* on the data bus */
176		static IRQ_CALLBACK( metro_irq_callback )
	175	IRQ_CALLBACK_MEMBER(metro_state::metro_irq_callback)
177	176	{
178		metro_state *state = device->machine().driver_data<metro_state>();
179
180		// logerror("%s: irq callback returns %04X\n", device->machine().describe_context(), state->m_irq_vectors[int_level]);
181		return state->m_irq_vectors[irqline] & 0xff;
	177	// logerror("%s: irq callback returns %04X\n", device.machine().describe_context(), m_irq_vectors[int_level]);
	178	return m_irq_vectors[irqline] & 0xff;
182	179	}
183	180
184	181
r20628	r20629
194	191	if (BIT(data, i)) m_requested_int[i] = 0;
195	192	}
196	193
197		update_irq_state(machine());
	194	update_irq_state();
198	195	}
199	196
200	197	INTERRUPT_GEN_MEMBER(metro_state::metro_vblank_interrupt)
201	198	{
202	199	m_requested_int[m_vblank_bit] = 1;
203		update_irq_state(machine());
	200	update_irq_state();
204	201	}
205	202
206	203	INTERRUPT_GEN_MEMBER(metro_state::metro_periodic_interrupt)
207	204	{
208	205	m_requested_int[4] = 1;
209		update_irq_state(machine());
	206	update_irq_state();
210	207	}
211	208
212	209	TIMER_CALLBACK_MEMBER(metro_state::karatour_irq_callback)
r20628	r20629
223	220	machine().scheduler().timer_set(attotime::from_usec(2500), timer_expired_delegate(FUNC(metro_state::karatour_irq_callback),this));
224	221	m_requested_int[5] = 1;
225	222
226		update_irq_state(machine());
	223	update_irq_state();
227	224	}
228	225
229	226	TIMER_CALLBACK_MEMBER(metro_state::mouja_irq_callback)
230	227	{
231	228	m_requested_int[0] = 1;
232		update_irq_state(machine());
	229	update_irq_state();
233	230	}
234	231
235	232	WRITE16_MEMBER(metro_state::mouja_irq_timer_ctrl_w)
r20628	r20629
242	239	INTERRUPT_GEN_MEMBER(metro_state::puzzlet_interrupt)
243	240	{
244	241	m_requested_int[m_vblank_bit] = 1;
245		update_irq_state(machine());
	242	update_irq_state();
246	243
247	244	m_maincpu->set_input_line(H8_METRO_TIMER_HACK, HOLD_LINE);
248	245	}
r20628	r20629
558	555	TIMER_CALLBACK_MEMBER(metro_state::metro_blit_done)
559	556	{
560	557	m_requested_int[m_blitter_bit] = 1;
561		update_irq_state(machine());
	558	update_irq_state();
562	559	}
563	560
564	561	INLINE int blt_read( const UINT8 *ROM, const int offs )
r20628	r20629
3581	3578	MACHINE_RESET_MEMBER(metro_state,metro)
3582	3579	{
3583	3580	if (m_irq_line == -1)
3584		machine().device("maincpu")->execute().set_irq_acknowledge_callback(metro_irq_callback);
	3581	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(metro_state::metro_irq_callback),this));
3585	3582	}
3586	3583
3587	3584

trunk/src/mame/drivers/seibuspi.c

r20628	r20629
1794	1794	device.execute().set_input_line(0, ASSERT_LINE );
1795	1795	}
1796	1796
1797		static IRQ_CALLBACK(spi_irq_callback)
	1797	IRQ_CALLBACK_MEMBER(seibuspi_state::spi_irq_callback)
1798	1798	{
1799	1799	return 0x20;
1800	1800	}
r20628	r20629
1815	1815	UINT8 flash_data = rombase[0x1ffffc];
1816	1816
1817	1817	machine().device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE );
1818		machine().device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
	1818	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(seibuspi_state::spi_irq_callback),this));
1819	1819
1820	1820	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x00000680, 0x00000683, read32_delegate(FUNC(seibuspi_state::sound_fifo_r),this));
1821	1821	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x00000688, 0x0000068b, write32_delegate(FUNC(seibuspi_state::z80_prg_fifo_w),this));
r20628	r20629
1902	1902	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x0000068c, 0x0000068f, write32_delegate(FUNC(seibuspi_state::eeprom_w),this));
1903	1903	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x00000680, 0x00000683, read32_delegate(FUNC(seibuspi_state::sb_coin_r),this));
1904	1904
1905		machine().device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
	1905	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(seibuspi_state::spi_irq_callback),this));
1906	1906
1907	1907	m_sb_coin_latch = 0;
1908	1908	}
r20628	r20629
2184	2184
2185	2185	MACHINE_RESET_MEMBER(seibuspi_state,seibu386)
2186	2186	{
2187		machine().device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
	2187	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(seibuspi_state::spi_irq_callback),this));
2188	2188	}
2189	2189
2190	2190	static MACHINE_CONFIG_START( seibu386, seibuspi_state )

trunk/src/mame/machine/megacd.c

r20628	r20629
14	14
15	15	/* Callback when the genesis enters interrupt code */
16	16	// needs to be a member
17		static IRQ_CALLBACK(segacd_sub_int_callback)
	17	IRQ_CALLBACK_MEMBER(sega_segacd_device::segacd_sub_int_callback)
18	18	{
19	19	if (irqline==2)
20	20	{
21	21	// clear this bit
22	22	a12000_halt_reset_reg &= ~0x0100;
23		device->machine().device(":segacd:segacd_68k")->execute().set_input_line(2, CLEAR_LINE);
	23	device.machine().device(":segacd:segacd_68k")->execute().set_input_line(2, CLEAR_LINE);
24	24	}
25	25
26	26	return (0x60+irqline*4)/4; // vector address
r20628	r20629
1609	1609
1610	1610
1611	1611
1612		machine().device(":segacd:segacd_68k")->execute().set_irq_acknowledge_callback(segacd_sub_int_callback);
	1612	machine().device(":segacd:segacd_68k")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(sega_segacd_device::segacd_sub_int_callback),this));
1613	1613
1614	1614	space.install_read_handler (0x0000070, 0x0000073, read16_delegate(FUNC(sega_segacd_device::scd_hint_vector_r),this) );
1615	1615

trunk/src/mame/machine/megacd.h

r20628	r20629
356	356	WRITE16_MEMBER( segacd_font_color_w );
357	357	READ16_MEMBER( segacd_font_converted_r );
358	358	TIMER_DEVICE_CALLBACK_MEMBER( scd_dma_timer_callback );
	359	IRQ_CALLBACK_MEMBER(segacd_sub_int_callback);
359	360
360	361	void SegaCD_CDC_Do_DMA( int &dmacount, UINT8 *CDC_BUFFER, UINT16 &dma_addrc, UINT16 &destination );
361	362	timer_device* scd_dma_timer;

trunk/src/mame/machine/fd1094.c

r20628	r20629
721	721	// register for the state changing callbacks we need in the m68000
722	722	m68k_set_cmpild_callback(this, &fd1094_device::cmp_callback);
723	723	m68k_set_rte_callback(this, &fd1094_device::rte_callback);
724		set_irq_acknowledge_callback(&fd1094_device::irq_callback);
	724	set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fd1094_device::irq_callback),this));
725	725
726	726	// save state
727	727	save_item(NAME(m_state));
r20628	r20629
987	987	//  interrupt code
988	988	//-------------------------------------------------
989	989
990		IRQ_CALLBACK( fd1094_device::irq_callback )
	990	IRQ_CALLBACK_MEMBER( fd1094_device::irq_callback )
991	991	{
992		downcast<fd1094_device *>(device)->change_state(STATE_IRQ);
	992	change_state(STATE_IRQ);
993	993	return (0x60 + irqline * 4) / 4; // vector address
994	994	}
995	995

trunk/src/mame/machine/fd1094.h

r20628	r20629
95	95	UINT16 decrypt_one(offs_t address, UINT16 val, const UINT8 *main_key, UINT8 state, bool vector_fetch);
96	96	void decrypt(offs_t baseaddr, UINT32 size, const UINT16 *srcptr, UINT16 *opcodesptr, UINT8 state);
97	97	void default_state_change(UINT8 state);
	98	IRQ_CALLBACK_MEMBER( irq_callback );
98	99
99	100	// static helpers
100	101	static void cmp_callback(device_t *device, UINT32 val, UINT8 reg);
101		static IRQ_CALLBACK( irq_callback );
102	102	static void rte_callback(device_t *device);
103	103
104	104	// internal state

trunk/src/mame/machine/galaxold.c

r20628	r20629
12	12	#include "includes/galaxold.h"
13	13
14	14
15		static IRQ_CALLBACK(hunchbkg_irq_callback)
	15	IRQ_CALLBACK_MEMBER(galaxold_state::hunchbkg_irq_callback)
16	16	{
17	17	//galaxold_state *state = device->machine().driver_data<galaxold_state>();
18	18	/* for some reason a call to cputag_set_input_line
r20628	r20629
22	22	*
23	23	* Therefore we reset the line without any detour ....
24	24	*/
25		device->machine().firstcpu->set_input_line(0, CLEAR_LINE);
	25	device.machine().firstcpu->set_input_line(0, CLEAR_LINE);
26	26	//cpu_set_info(device->machine().firstcpu, CPUINFO_INT_INPUT_STATE + state->m_irq_line, CLEAR_LINE);
27	27	return 0x03;
28	28	}
r20628	r20629
97	97	MACHINE_RESET_MEMBER(galaxold_state,hunchbkg)
98	98	{
99	99	machine_reset_common(machine(), 0);
100		machine().device("maincpu")->execute().set_irq_acknowledge_callback(hunchbkg_irq_callback);
	100	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(galaxold_state::hunchbkg_irq_callback),this));
101	101	}
102	102
103	103	WRITE8_MEMBER(galaxold_state::galaxold_coin_lockout_w)

trunk/src/mame/machine/mie.c

r20628	r20629
91	91	jvs = 0;
92	92	}
93	93
94		IRQ_CALLBACK(mie_device::irq_callback_1)
95		{
96		return downcast<mie_device *>(device->owner())->irq_callback();
97		}
98
99	94	void mie_device::device_start()
100	95	{
101	96	maple_device::device_start();
102	97	cpu = subdevice<z80_device>("mie");
103	98	timer = timer_alloc(0);
104		cpu->set_irq_acknowledge_callback(irq_callback_1);
	99	cpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mie_device::irq_callback),this));
105	100	jvs = machine().device<mie_jvs_device>(jvs_name);
106	101
107	102	save_item(NAME(gpiodir));
r20628	r20629
270	265	cpu->set_input_line(0, irq_enable & irq_pending & 0x7f ? ASSERT_LINE : CLEAR_LINE);
271	266	}
272	267
273		int mie_device::irq_callback()
	268	IRQ_CALLBACK_MEMBER(mie_device::irq_callback)
274	269	{
275	270	if(!(irq_enable & irq_pending & 0x7f))
276	271	throw emu_fatalerror("MIE irq callback called with enable=%02x, pending=%02x", irq_enable, irq_pending);

trunk/src/mame/machine/mie.h

r20628	r20629
66	66	DECLARE_READ8_MEMBER(read_00);
67	67	DECLARE_READ8_MEMBER(read_78xx);
68	68
69		static IRQ_CALLBACK(irq_callback_1);
	69	IRQ_CALLBACK_MEMBER(irq_callback);
70	70
71	71	void maple_w(const UINT32 *data, UINT32 in_size);
72	72	virtual void maple_reset();
r20628	r20629
109	109
110	110	void raise_irq(int level);
111	111	void recalc_irq();
112		int irq_callback();
113	112	};
114	113
115	114	// Trampoline class, required for device discovery

trunk/src/mame/video/dcheese.c

r20628	r20629
47	47	*
48	48	*************************************/
49	49
50		static void update_scanline_irq( running_machine &machine )
	50	void dcheese_state::update_scanline_irq()
51	51	{
52		dcheese_state *state = machine.driver_data<dcheese_state>();
53
54	52	/* if not in range, don't bother */
55		if (state->m_blitter_vidparam[0x22/2] <= state->m_blitter_vidparam[0x1e/2])
	53	if (m_blitter_vidparam[0x22/2] <= m_blitter_vidparam[0x1e/2])
56	54	{
57	55	int effscan;
58	56	attotime time;
59	57
60	58	/* compute the effective scanline of the interrupt */
61		effscan = state->m_blitter_vidparam[0x22/2] - state->m_blitter_vidparam[0x1a/2];
	59	effscan = m_blitter_vidparam[0x22/2] - m_blitter_vidparam[0x1a/2];
62	60	if (effscan < 0)
63		effscan += state->m_blitter_vidparam[0x1e/2];
	61	effscan += m_blitter_vidparam[0x1e/2];
64	62
65	63	/* determine the time; if it's in this scanline, bump to the next frame */
66		time = machine.primary_screen->time_until_pos(effscan);
67		if (time < machine.primary_screen->scan_period())
68		time += machine.primary_screen->frame_period();
69		state->m_blitter_timer->adjust(time);
	64	time = machine().primary_screen->time_until_pos(effscan);
	65	if (time < machine().primary_screen->scan_period())
	66	time += machine().primary_screen->frame_period();
	67	m_blitter_timer->adjust(time);
70	68	}
71	69	}
72	70
73	71
74	72	TIMER_CALLBACK_MEMBER(dcheese_state::blitter_scanline_callback)
75	73	{
76		dcheese_signal_irq(machine(), 3);
77		update_scanline_irq(machine());
	74	dcheese_signal_irq(3);
	75	update_scanline_irq();
78	76	}
79	77
80	78
81	79	TIMER_CALLBACK_MEMBER(dcheese_state::dcheese_signal_irq_callback)
82	80	{
83		dcheese_signal_irq(machine(), param);
	81	dcheese_signal_irq(param);
84	82	}
85	83
86	84
r20628	r20629
267	265	break;
268	266
269	267	case 0x22/2:        /* scanline interrupt */
270		update_scanline_irq(machine());
	268	update_scanline_irq();
271	269	break;
272	270
273	271	case 0x24/2:        /* writes here after writing to 0x28 */

trunk/src/mame/includes/galaxold.h

r20628	r20629
187	187	DECLARE_WRITE_LINE_MEMBER(galaxold_7474_9m_2_q_callback);
188	188	DECLARE_WRITE_LINE_MEMBER(galaxold_7474_9m_1_callback);
189	189	DECLARE_VIDEO_START(bagmanmc);
	190	IRQ_CALLBACK_MEMBER(hunchbkg_irq_callback);
190	191	};
191	192
192	193	/*----------- defined in video/galaxold.c -----------*/

trunk/src/mame/includes/ssv.h

r20628	r20629
130	130	UINT32 screen_update_eaglshot(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
131	131	TIMER_DEVICE_CALLBACK_MEMBER(ssv_interrupt);
132	132	TIMER_DEVICE_CALLBACK_MEMBER(gdfs_interrupt);
	133	void update_irq_state();
	134	IRQ_CALLBACK_MEMBER(ssv_irq_callback);
133	135	};
134	136
135	137	/*----------- defined in video/ssv.c -----------*/

trunk/src/mame/includes/metro.h

r20628	r20629
176	176	TIMER_CALLBACK_MEMBER(karatour_irq_callback);
177	177	TIMER_CALLBACK_MEMBER(mouja_irq_callback);
178	178	TIMER_CALLBACK_MEMBER(metro_blit_done);
	179	void update_irq_state();
	180	IRQ_CALLBACK_MEMBER(metro_irq_callback);
179	181	};
180	182
181	183

trunk/src/mame/includes/aztarac.h

r20628	r20629
28	28	virtual void machine_reset();
29	29	virtual void video_start();
30	30	INTERRUPT_GEN_MEMBER(aztarac_snd_timed_irq);
	31	IRQ_CALLBACK_MEMBER(aztarac_irq_callback);
31	32	};

trunk/src/mame/includes/dcheese.h

r20628	r20629
50	50	INTERRUPT_GEN_MEMBER(dcheese_vblank);
51	51	TIMER_CALLBACK_MEMBER(blitter_scanline_callback);
52	52	TIMER_CALLBACK_MEMBER(dcheese_signal_irq_callback);
	53	void dcheese_signal_irq(int which);
	54	void update_irq_state();
	55	IRQ_CALLBACK_MEMBER(irq_callback);
	56	void update_scanline_irq();
53	57	};
54	58
55	59	/*----------- defined in drivers/dcheese.c -----------*/
56		void dcheese_signal_irq(running_machine &machine, int which);

trunk/src/mame/includes/seibuspi.h

r20628	r20629
116	116	UINT32 screen_update_spi(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
117	117	UINT32 screen_update_sys386f2(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
118	118	INTERRUPT_GEN_MEMBER(spi_interrupt);
	119	IRQ_CALLBACK_MEMBER(spi_irq_callback);
119	120	};
120	121	/*----------- defined in machine/spisprit.c -----------*/
121	122	void seibuspi_sprite_decrypt(UINT8 *src, int romsize);

trunk/src/mame/includes/ms32.h

r20628	r20629
89	89	DECLARE_VIDEO_START(f1superb);
90	90	UINT32 screen_update_ms32(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
91	91	TIMER_DEVICE_CALLBACK_MEMBER(ms32_interrupt);
	92	IRQ_CALLBACK_MEMBER(irq_callback);
	93	void irq_init();
	94	void irq_raise(int level);
92	95	};

trunk/src/mess/includes/fm7.h

r20628	r20629
250	250	DECLARE_WRITE_LINE_MEMBER(fm7_fdc_drq_w);
251	251	DECLARE_READ8_MEMBER(fm77av_joy_1_r);
252	252	DECLARE_READ8_MEMBER(fm77av_joy_2_r);
	253	IRQ_CALLBACK_MEMBER(fm7_irq_ack);
	254	IRQ_CALLBACK_MEMBER(fm7_sub_irq_ack);
253	255	};
254	256
255	257	#endif /*FM7_H_*/

trunk/src/mess/includes/fmtowns.h

r20628	r20629
265	265	DECLARE_WRITE_LINE_MEMBER(towns_pit_out0_changed);
266	266	DECLARE_WRITE_LINE_MEMBER(towns_pit_out1_changed);
267	267	DECLARE_READ8_MEMBER(get_slave_ack);
	268	IRQ_CALLBACK_MEMBER(towns_irq_callback);
268	269	};
269	270
270	271	class marty_state : public towns_state

trunk/src/mess/includes/tsispch.h

r20628	r20629
49	49	DECLARE_WRITE_LINE_MEMBER(i8251_txempty_int);
50	50	DECLARE_WRITE_LINE_MEMBER(i8251_txrdy_int);
51	51	DECLARE_WRITE_LINE_MEMBER(pic8259_set_int_line);
	52	IRQ_CALLBACK_MEMBER(irq_callback);
52	53	};
53	54
54	55

trunk/src/mess/drivers/pc9801.c

r20628	r20629
654	654	inline UINT32 m_calc_grcg_addr(int i,UINT32 offset);
655	655
656	656	DECLARE_DRIVER_INIT(pc9801_kanji);
	657	IRQ_CALLBACK_MEMBER(irq_callback);
657	658	};
658	659
659	660
r20628	r20629
3330	3331	palette_set_color_rgb(machine(), i, pal1bit(0), pal1bit(0), pal1bit(0));
3331	3332	}
3332	3333
3333		static IRQ_CALLBACK(irq_callback)
	3334	IRQ_CALLBACK_MEMBER(pc9801_state::irq_callback)
3334	3335	{
3335		return pic8259_acknowledge( device->machine().device( "pic8259_master" ));
	3336	return pic8259_acknowledge( machine().device( "pic8259_master" ));
3336	3337	}
3337	3338
3338	3339	MACHINE_START_MEMBER(pc9801_state,pc9801_common)
3339	3340	{
3340		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	3341	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc9801_state::irq_callback),this));
3341	3342
3342	3343	m_rtc->cs_w(1);
3343	3344	m_rtc->oe_w(0); // TODO: unknown connection, MS-DOS 6.2x wants this low somehow with the test mode

trunk/src/mess/drivers/tsispch.c

r20628	r20629
180	180	DEVCB_NULL
181	181	};
182	182
183		static IRQ_CALLBACK(irq_callback)
	183	IRQ_CALLBACK_MEMBER(tsispch_state::irq_callback)
184	184	{
185		return pic8259_acknowledge(device->machine().device("pic8259"));
	185	return pic8259_acknowledge(machine().device("pic8259"));
186	186	}
187	187
188	188	/*****************************************************************************
r20628	r20629
272	272	int i;
273	273	for (i=0; i<32; i++) m_infifo[i] = 0;
274	274	m_infifo_tail_ptr = m_infifo_head_ptr = 0;
275		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	275	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(tsispch_state::irq_callback),this));
276	276	fprintf(stderr,"machine reset\n");
277	277	}
278	278

trunk/src/mess/drivers/apc.c

r20628	r20629
148	148
149	149	int m_dack;
150	150	UINT8 m_dma_offset[4];
	151
	152	IRQ_CALLBACK_MEMBER(irq_callback);
151	153
152	154	protected:
153	155	// driver_device overrides
r20628	r20629
741	743	pic8259_ir4_w(machine().device("pic8259_slave"), state);
742	744	}
743	745
744		static IRQ_CALLBACK(irq_callback)
	746	IRQ_CALLBACK_MEMBER(apc_state::irq_callback)
745	747	{
746		return pic8259_acknowledge( device->machine().device( "pic8259_master" ));
	748	return pic8259_acknowledge( machine().device( "pic8259_master" ));
747	749	}
748	750
749	751	void apc_state::machine_start()
750	752	{
751		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	753	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(apc_state::irq_callback),this));
752	754
753	755	m_fdc->set_rate(500000);
754	756	m_fdc->setup_intrq_cb(upd765a_device::line_cb(FUNC(apc_state::fdc_irq), this));

trunk/src/mess/drivers/prestige.c

r20628	r20629
112	112	DECLARE_WRITE8_MEMBER( mouse_w );
113	113	virtual void palette_init();
114	114	TIMER_DEVICE_CALLBACK_MEMBER(irq_timer);
	115	IRQ_CALLBACK_MEMBER(prestige_int_ack);
115	116	};
116	117
117	118
r20628	r20629
393	394
394	395	INPUT_PORTS_END
395	396
396		static IRQ_CALLBACK( prestige_int_ack )
	397	IRQ_CALLBACK_MEMBER(prestige_state::prestige_int_ack)
397	398	{
398	399	UINT32 vector;
399		prestige_state *state = device->machine().driver_data<prestige_state>();
400	400
401		state->m_maincpu->set_input_line(0, CLEAR_LINE);
	401	m_maincpu->set_input_line(0, CLEAR_LINE);
402	402
403		if (state->m_irq_counter == 0x02)
	403	if (m_irq_counter == 0x02)
404	404	{
405		state->m_irq_counter = 0;
	405	m_irq_counter = 0;
406	406	vector = 0x0020;
407	407	}
408	408	else
409	409	{
410		state->m_irq_counter++;
	410	m_irq_counter++;
411	411	vector = 0x0030;
412	412	}
413	413
r20628	r20629
419	419	UINT8 *ram = m_ram->pointer();
420	420	memset(ram, 0x00, m_ram->size());
421	421
422		m_maincpu->set_irq_acknowledge_callback(prestige_int_ack);
	422	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(prestige_state::prestige_int_ack),this));
423	423
424	424	membank("bank1")->configure_entries(0, 64, memregion("maincpu")->base(), 0x4000);
425	425	membank("bank2")->configure_entries(0, 64, memregion("maincpu")->base(), 0x4000);

trunk/src/mess/drivers/sm1800.c

r20628	r20629
43	43	virtual void machine_reset();
44	44	virtual void palette_init();
45	45	INTERRUPT_GEN_MEMBER(sm1800_vblank_interrupt);
	46	IRQ_CALLBACK_MEMBER(sm1800_irq_callback);
46	47	};
47	48
48	49	static ADDRESS_MAP_START(sm1800_mem, AS_PROGRAM, 8, sm1800_state)
r20628	r20629
66	67	static INPUT_PORTS_START( sm1800 )
67	68	INPUT_PORTS_END
68	69
69		static IRQ_CALLBACK(sm1800_irq_callback)
	70	IRQ_CALLBACK_MEMBER(sm1800_state::sm1800_irq_callback)
70	71	{
71	72	return 0xff;
72	73	}
73	74
74	75	void sm1800_state::machine_reset()
75	76	{
76		m_maincpu->set_irq_acknowledge_callback(sm1800_irq_callback);
	77	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(sm1800_state::sm1800_irq_callback),this));
77	78	}
78	79
79	80	INTERRUPT_GEN_MEMBER(sm1800_state::sm1800_vblank_interrupt)

trunk/src/mess/drivers/iq151.c

r20628	r20629
98	98	INTERRUPT_GEN_MEMBER(iq151_vblank_interrupt);
99	99	DECLARE_INPUT_CHANGED_MEMBER(iq151_break);
100	100	TIMER_DEVICE_CALLBACK_MEMBER(cassette_timer);
	101	IRQ_CALLBACK_MEMBER(iq151_irq_callback);
101	102	};
102	103
103	104	READ8_MEMBER(iq151_state::keyboard_row_r)
r20628	r20629
327	328	m_vblank_irq_state ^= 1;
328	329	}
329	330
330		static IRQ_CALLBACK(iq151_irq_callback)
	331	IRQ_CALLBACK_MEMBER(iq151_state::iq151_irq_callback)
331	332	{
332		iq151_state *state = device->machine().driver_data<iq151_state>();
333
334		return pic8259_acknowledge(state->m_pic);
	333	return pic8259_acknowledge(m_pic);
335	334	}
336	335
337	336	TIMER_DEVICE_CALLBACK_MEMBER(iq151_state::cassette_timer)
r20628	r20629
347	346	membank("boot")->configure_entry(0, RAM + 0xf800);
348	347	membank("boot")->configure_entry(1, RAM + 0x0000);
349	348
350		m_maincpu->set_irq_acknowledge_callback(iq151_irq_callback);
	349	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(iq151_state::iq151_irq_callback),this));
351	350
352	351	// keep machine pointers to slots
353	352	m_carts[0] = machine().device<iq151cart_slot_device>("slot1");

trunk/src/mess/drivers/qx10.c

r20628	r20629
146	146	virtual void palette_init();
147	147	DECLARE_INPUT_CHANGED_MEMBER(key_stroke);
148	148	DECLARE_WRITE_LINE_MEMBER(dma_hrq_changed);
	149	IRQ_CALLBACK_MEMBER(irq_callback);
149	150	};
150	151
151	152	static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
r20628	r20629
576	577	DEVCB_NULL
577	578	};
578	579
579		static IRQ_CALLBACK( irq_callback )
	580	IRQ_CALLBACK_MEMBER(qx10_state::irq_callback)
580	581	{
581		return pic8259_acknowledge(device->machine().driver_data<qx10_state>()->m_pic_m );
	582	return pic8259_acknowledge(m_pic_m);
582	583	}
583	584
584	585	READ8_MEMBER( qx10_state::upd7201_r )
r20628	r20629
908	909
909	910	void qx10_state::machine_start()
910	911	{
911		machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
	912	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(qx10_state::irq_callback),this));
912	913	m_fdc->setup_intrq_cb(upd765a_device::line_cb(FUNC(qx10_state::qx10_upd765_interrupt), this));
913	914	m_fdc->setup_drq_cb(upd765a_device::line_cb(FUNC(qx10_state::drq_w), this));
914	915	}

trunk/src/mess/drivers/pk8000.c

r20628	r20629
37	37	DECLARE_READ8_MEMBER(pk8000_84_porta_r);
38	38	DECLARE_WRITE8_MEMBER(pk8000_84_porta_w);
39	39	DECLARE_WRITE8_MEMBER(pk8000_84_portc_w);
	40	IRQ_CALLBACK_MEMBER(pk8000_irq_callback);
40	41	};
41	42
42	43
r20628	r20629
318	319	device.execute().set_input_line(0, HOLD_LINE);
319	320	}
320	321
321		static IRQ_CALLBACK(pk8000_irq_callback)
	322	IRQ_CALLBACK_MEMBER(pk8000_state::pk8000_irq_callback)
322	323	{
323	324	return 0xff;
324	325	}
r20628	r20629
327	328	void pk8000_state::machine_reset()
328	329	{
329	330	pk8000_set_bank(machine(),0);
330		machine().device("maincpu")->execute().set_irq_acknowledge_callback(pk8000_irq_callback);
	331	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pk8000_state::pk8000_irq_callback),this));
331	332	}
332	333
333	334	void pk8000_state::video_start()

trunk/src/mess/drivers/fmtowns.c

r20628	r20629
2016	2016	return 0x01;
2017	2017	}
2018	2018
2019		static IRQ_CALLBACK( towns_irq_callback )
	2019	IRQ_CALLBACK_MEMBER(towns_state::towns_irq_callback)
2020	2020	{
2021		towns_state* state = device->machine().driver_data<towns_state>();
2022		return pic8259_acknowledge(state->m_pic_master);
	2021	return pic8259_acknowledge(m_pic_master);
2023	2022	}
2024	2023
2025	2024	// YM3438 interrupt (IRQ 13)
r20628	r20629
2511	2510	// CD-ROM init
2512	2511	m_towns_cd.read_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(towns_state::towns_cdrom_read_byte),this), (void*)machine().device("dma_1"));
2513	2512
2514		machine().device("maincpu")->execute().set_irq_acknowledge_callback(towns_irq_callback);
	2513	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(towns_state::towns_irq_callback),this));
2515	2514	machine().device("maincpu")->memory().space(AS_PROGRAM).install_ram(0x100000,machine().device<ram_device>(RAM_TAG)->size()-1,0xffffffff,0,NULL);
2516	2515
2517	2516	}

trunk/src/mess/drivers/pc88va.c

r20628	r20629
151	151	void fdc_drq(bool state);
152	152	DECLARE_FLOPPY_FORMATS( floppy_formats );
153	153	void pc88va_fdc_update_ready(floppy_image_device *, int);
	154	IRQ_CALLBACK_MEMBER(pc88va_irq_callback);
154	155	};
155	156
156	157
r20628	r20629
1612	1613	DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_portc_w)                     /* Port C write */
1613	1614	};
1614	1615
1615		static IRQ_CALLBACK(pc88va_irq_callback)
	1616	IRQ_CALLBACK_MEMBER(pc88va_state::pc88va_irq_callback)
1616	1617	{
1617		return pic8259_acknowledge( device->machine().device( "pic8259_master" ) );
	1618	return pic8259_acknowledge( machine().device( "pic8259_master" ) );
1618	1619	}
1619	1620
1620	1621	WRITE_LINE_MEMBER(pc88va_state::pc88va_pic_irq)
r20628	r20629
1647	1648
1648	1649	void pc88va_state::machine_start()
1649	1650	{
1650		machine().device("maincpu")->execute().set_irq_acknowledge_callback(pc88va_irq_callback);
	1651	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc88va_state::pc88va_irq_callback),this));
1651	1652
1652	1653	m_t3_mouse_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pc88va_state::t3_mouse_callback),this));
1653	1654	m_t3_mouse_timer->adjust(attotime::never);

trunk/src/mess/drivers/fm7.c

r20628	r20629
1336	1336	}
1337	1337	}
1338	1338
1339		static IRQ_CALLBACK(fm7_irq_ack)
	1339	IRQ_CALLBACK_MEMBER(fm7_state::fm7_irq_ack)
1340	1340	{
1341	1341	if(irqline == M6809_FIRQ_LINE)
1342		device->machine().device("maincpu")->execute().set_input_line(irqline,CLEAR_LINE);
	1342	machine().device("maincpu")->execute().set_input_line(irqline,CLEAR_LINE);
1343	1343	return -1;
1344	1344	}
1345	1345
1346		static IRQ_CALLBACK(fm7_sub_irq_ack)
	1346	IRQ_CALLBACK_MEMBER(fm7_state::fm7_sub_irq_ack)
1347	1347	{
1348		device->machine().device("sub")->execute().set_input_line(irqline,CLEAR_LINE);
	1348	machine().device("sub")->execute().set_input_line(irqline,CLEAR_LINE);
1349	1349	return -1;
1350	1350	}
1351	1351
r20628	r20629
1832	1832	m_subtimer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(fm7_state::fm7_subtimer_irq),this));
1833	1833	m_keyboard_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(fm7_state::fm7_keyboard_poll),this));
1834	1834	m_fm77av_vsync_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(fm7_state::fm77av_vsync),this));
1835		machine().device("maincpu")->execute().set_irq_acknowledge_callback(fm7_irq_ack);
1836		machine().device("sub")->execute().set_irq_acknowledge_callback(fm7_sub_irq_ack);
	1835	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fm7_state::fm7_irq_ack),this));
	1836	machine().device("sub")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fm7_state::fm7_sub_irq_ack),this));
1837	1837	}
1838	1838
1839	1839	MACHINE_START_MEMBER(fm7_state,fm7)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team