Previous

199869 Revisions

Next

r22837 Wednesday 15th May, 2013 at 18:45:55 UTC by Andrew Gardner
Had time for a few more. (nw)

[src/mame/drivers]	fuukifg2.c gaplus.c parodius.c tickee.c ultratnk.c videopin.c wolfpack.c zr107.c
[src/mame/includes]	fuukifg2.h gaplus.h parodius.h ultratnk.h videopin.h wolfpack.h

trunk/src/mame/drivers/videopin.c

r22836	r22837
43	43	}
44	44
45	45
	46	void videopin_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	47	{
	48	switch (id)
	49	{
	50	case TIMER_INTERRUPT:
	51	interrupt_callback(ptr, param);
	52	break;
	53	default:
	54	assert_always(FALSE, "Unknown id in videopin_state::device_timer");
	55	}
	56	}
	57
	58
46	59	TIMER_CALLBACK_MEMBER(videopin_state::interrupt_callback)
47	60	{
48	61	int scanline = param;
r22836	r22837
56	69	if (scanline >= 263)
57	70	scanline = 32;
58	71
59		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(scanline), timer_expired_delegate(FUNC(videopin_state::interrupt_callback),this), scanline);
	72	timer_set(machine().primary_screen->time_until_pos(scanline), TIMER_INTERRUPT, scanline);
60	73	}
61	74
62	75
63	76	void videopin_state::machine_reset()
64	77	{
65		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(32), timer_expired_delegate(FUNC(videopin_state::interrupt_callback),this), 32);
	78	timer_set(machine().primary_screen->time_until_pos(32), TIMER_INTERRUPT, 32);
66	79
67	80	/* both output latches are cleared on reset */
68	81

trunk/src/mame/drivers/ultratnk.c

r22836	r22837
41	41	}
42	42
43	43
	44	void ultratnk_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	45	{
	46	switch (id)
	47	{
	48	case TIMER_NMI:
	49	nmi_callback(ptr, param);
	50	break;
	51	default:
	52	assert_always(FALSE, "Unknown id in ultratnk_state::device_timer");
	53	}
	54	}
	55
	56
44	57	TIMER_CALLBACK_MEMBER(ultratnk_state::nmi_callback)
45	58	{
46	59	int scanline = param + 64;
r22836	r22837
55	68	if (ioport("IN0")->read() & 0x40)
56	69	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
57	70
58		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(scanline), timer_expired_delegate(FUNC(ultratnk_state::nmi_callback),this), scanline);
	71	timer_set(machine().primary_screen->time_until_pos(scanline), TIMER_NMI, scanline);
59	72	}
60	73
61	74
62	75	void ultratnk_state::machine_reset()
63	76	{
64		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(32), timer_expired_delegate(FUNC(ultratnk_state::nmi_callback),this), 32);
	77	timer_set(machine().primary_screen->time_until_pos(32), TIMER_NMI, 32);
65	78	}
66	79
67	80

trunk/src/mame/drivers/fuukifg2.c

r22836	r22837
406	406	also used for water effects and titlescreen linescroll on gogomile
407	407	*/
408	408
409		TIMER_CALLBACK_MEMBER(fuuki16_state::level_1_interrupt_callback)
	409	void fuuki16_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
410	410	{
411		m_maincpu->set_input_line(1, HOLD_LINE);
412		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(248), timer_expired_delegate(FUNC(fuuki16_state::level_1_interrupt_callback),this));
	411	switch (id)
	412	{
	413	case TIMER_LEVEL_1_INTERRUPT:
	414	m_maincpu->set_input_line(1, HOLD_LINE);
	415	timer_set(machine().primary_screen->time_until_pos(248), TIMER_LEVEL_1_INTERRUPT);
	416	break;
	417	case TIMER_VBLANK_INTERRUPT:
	418	m_maincpu->set_input_line(3, HOLD_LINE);    // VBlank IRQ
	419	timer_set(machine().primary_screen->time_until_vblank_start(), TIMER_VBLANK_INTERRUPT);
	420	break;
	421	case TIMER_RASTER_INTERRUPT:
	422	m_maincpu->set_input_line(5, HOLD_LINE);    // Raster Line IRQ
	423	machine().primary_screen->update_partial(machine().primary_screen->vpos());
	424	m_raster_interrupt_timer->adjust(machine().primary_screen->frame_period());
	425	break;
	426	default:
	427	assert_always(FALSE, "Unknown id in fuuki16_state::device_timer");
	428	}
413	429	}
414	430
415	431
416		TIMER_CALLBACK_MEMBER(fuuki16_state::vblank_interrupt_callback)
417		{
418		m_maincpu->set_input_line(3, HOLD_LINE);    // VBlank IRQ
419		machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_start(), timer_expired_delegate(FUNC(fuuki16_state::vblank_interrupt_callback),this));
420		}
421
422
423		TIMER_CALLBACK_MEMBER(fuuki16_state::raster_interrupt_callback)
424		{
425		m_maincpu->set_input_line(5, HOLD_LINE);    // Raster Line IRQ
426		machine().primary_screen->update_partial(machine().primary_screen->vpos());
427		m_raster_interrupt_timer->adjust(machine().primary_screen->frame_period());
428		}
429
430
431	432	void fuuki16_state::machine_start()
432	433	{
433	434	UINT8 *ROM = memregion("audiocpu")->base();
434	435
435	436	membank("bank1")->configure_entries(0, 3, &ROM[0x10000], 0x8000);
436	437
437
438		m_raster_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(fuuki16_state::raster_interrupt_callback),this));
	438	m_raster_interrupt_timer = timer_alloc(TIMER_RASTER_INTERRUPT);
439	439	}
440	440
441	441
r22836	r22837
443	443	{
444	444	const rectangle &visarea = machine().primary_screen->visible_area();
445	445
446		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(248), timer_expired_delegate(FUNC(fuuki16_state::level_1_interrupt_callback),this));
447		machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_start(), timer_expired_delegate(FUNC(fuuki16_state::vblank_interrupt_callback),this));
	446	timer_set(machine().primary_screen->time_until_pos(248), TIMER_LEVEL_1_INTERRUPT);
	447	timer_set(machine().primary_screen->time_until_vblank_start(), TIMER_LEVEL_1_INTERRUPT);
448	448	m_raster_interrupt_timer->adjust(machine().primary_screen->time_until_pos(0, visarea.max_x + 1));
449	449	}
450	450

trunk/src/mame/drivers/tickee.c

r22836	r22837
31	31	class tickee_state : public driver_device
32	32	{
33	33	public:
	34	enum
	35	{
	36	TIMER_TRIGGER_GUN_INTERRUPT,
	37	TIMER_CLEAR_GUN_INTERRUPT,
	38	TIMER_SETUP_GUN_INTERRUPTS
	39	};
	40
34	41	tickee_state(const machine_config &mconfig, device_type type, const char *tag)
35	42	: driver_device(mconfig, type, tag),
36	43	m_tlc34076(*this, "tlc34076"),
r22836	r22837
65	72	TIMER_CALLBACK_MEMBER(setup_gun_interrupts);
66	73	required_device<cpu_device> m_maincpu;
67	74	optional_device<okim6295_device> m_oki;
	75
	76	protected:
	77	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
68	78	};
69	79
70	80
r22836	r22837
95	105	*
96	106	*************************************/
97	107
	108	void tickee_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	109	{
	110	switch (id)
	111	{
	112	case TIMER_TRIGGER_GUN_INTERRUPT:
	113	trigger_gun_interrupt(ptr, param);
	114	break;
	115	case TIMER_CLEAR_GUN_INTERRUPT:
	116	clear_gun_interrupt(ptr, param);
	117	break;
	118	case TIMER_SETUP_GUN_INTERRUPTS:
	119	setup_gun_interrupts(ptr, param);
	120	break;
	121	default:
	122	assert_always(FALSE, "Unknown id in tickee_state::device_timer");
	123	}
	124	}
	125
	126
98	127	TIMER_CALLBACK_MEMBER(tickee_state::trigger_gun_interrupt)
99	128	{
100	129	int which = param & 1;
r22836	r22837
129	158
130	159	/* generate interrupts for player 1's gun */
131	160	get_crosshair_xy(machine(), 0, &beamx, &beamy);
132		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd, beamx + m_beamxadd), timer_expired_delegate(FUNC(tickee_state::trigger_gun_interrupt),this), 0);
133		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd + 1, beamx + m_beamxadd), timer_expired_delegate(FUNC(tickee_state::clear_gun_interrupt),this), 0);
	161	timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd, beamx + m_beamxadd), TIMER_TRIGGER_GUN_INTERRUPT, 0);
	162	timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd + 1, beamx + m_beamxadd), TIMER_CLEAR_GUN_INTERRUPT, 0);
134	163
135	164	/* generate interrupts for player 2's gun */
136	165	get_crosshair_xy(machine(), 1, &beamx, &beamy);
137		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd, beamx + m_beamxadd), timer_expired_delegate(FUNC(tickee_state::trigger_gun_interrupt),this), 1);
138		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd + 1, beamx + m_beamxadd), timer_expired_delegate(FUNC(tickee_state::clear_gun_interrupt),this), 1);
	166	timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd, beamx + m_beamxadd), TIMER_TRIGGER_GUN_INTERRUPT, 1);
	167	timer_set(machine().primary_screen->time_until_pos(beamy + m_beamyadd + 1, beamx + m_beamxadd), TIMER_CLEAR_GUN_INTERRUPT, 1);
139	168	}
140	169
141	170
r22836	r22837
149	178	VIDEO_START_MEMBER(tickee_state,tickee)
150	179	{
151	180	/* start a timer going on the first scanline of every frame */
152		m_setup_gun_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tickee_state::setup_gun_interrupts),this));
	181	m_setup_gun_timer = timer_alloc(TIMER_SETUP_GUN_INTERRUPTS);
153	182	m_setup_gun_timer->adjust(machine().primary_screen->time_until_pos(0));
154	183	}
155	184

trunk/src/mame/drivers/parodius.c

r22836	r22837
113	113	}
114	114	#endif
115	115
116		TIMER_CALLBACK_MEMBER(parodius_state::nmi_callback)
	116	void parodius_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
117	117	{
118		m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	118	switch (id)
	119	{
	120	case TIMER_NMI:
	121	m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	122	break;
	123	default:
	124	assert_always(FALSE, "Unknown id in parodius_state::device_timer");
	125	}
119	126	}
120	127
121	128	WRITE8_MEMBER(parodius_state::sound_arm_nmi_w)
122	129	{
123	130	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
124		machine().scheduler().timer_set(attotime::from_usec(50), timer_expired_delegate(FUNC(parodius_state::nmi_callback),this));  /* kludge until the K053260 is emulated correctly */
	131	timer_set(attotime::from_usec(50), TIMER_NMI);  /* kludge until the K053260 is emulated correctly */
125	132	}
126	133
127	134	/********************************************/

trunk/src/mame/drivers/zr107.c

r22836	r22837
180	180	class zr107_state : public driver_device
181	181	{
182	182	public:
	183	enum
	184	{
	185	TIMER_IRQ_OFF
	186	};
	187
183	188	zr107_state(const machine_config &mconfig, device_type type, const char *tag)
184	189	: driver_device(mconfig, type, tag),
185	190	m_workram(*this, "workram"),
r22836	r22837
214	219	UINT32 screen_update_zr107(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
215	220	UINT32 screen_update_jetwave(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
216	221	INTERRUPT_GEN_MEMBER(zr107_vblank);
217		TIMER_CALLBACK_MEMBER(irq_off);
218	222	required_device<cpu_device> m_maincpu;
219	223	required_device<cpu_device> m_audiocpu;
220	224	required_device<cpu_device> m_dsp;
221	225	optional_device<k001604_device> m_k001604;
222	226	optional_device<k056832_device> m_k056832;
	227
	228	protected:
	229	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
223	230	};
224	231
225	232
r22836	r22837
420	427	/* set conservative DRC options */
421	428	ppcdrc_set_options(m_maincpu, PPCDRC_COMPATIBLE_OPTIONS);
422	429
423		m_sound_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(zr107_state::irq_off),this));
	430	m_sound_irq_timer = timer_alloc(TIMER_IRQ_OFF);
424	431
425	432	/* configure fast RAM regions for DRC */
426	433	ppcdrc_add_fastram(m_maincpu, 0x00000000, 0x000fffff, FALSE, m_workram);
r22836	r22837
688	695	};
689	696
690	697
691		TIMER_CALLBACK_MEMBER(zr107_state::irq_off)
	698	void zr107_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
692	699	{
693		m_audiocpu->set_input_line(param, CLEAR_LINE);
	700	switch (id)
	701	{
	702	case TIMER_IRQ_OFF:
	703	m_audiocpu->set_input_line(param, CLEAR_LINE);
	704	break;
	705	default:
	706	assert_always(FALSE, "Unknown id in zr107_state::device_timer");
	707	}
694	708	}
695	709
696	710	static void sound_irq_callback( running_machine &machine, int irq )
r22836	r22837
699	713	int line = (irq == 0) ? INPUT_LINE_IRQ1 : INPUT_LINE_IRQ2;
700	714
701	715	state->m_audiocpu->set_input_line(line, ASSERT_LINE);
702		machine.scheduler().timer_set(attotime::from_usec(5), timer_expired_delegate(FUNC(zr107_state::irq_off),state), line);
	716	state->timer_set(attotime::from_usec(5), zr107_state::TIMER_IRQ_OFF, line);
703	717	}
704	718
705	719	static const k056800_interface zr107_k056800_interface =

trunk/src/mame/drivers/wolfpack.c

r22836	r22837
9	9	#include "sound/s14001a.h"
10	10	#include "includes/wolfpack.h"
11	11
	12
	13	void wolfpack_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	14	{
	15	switch (id)
	16	{
	17	case TIMER_PERIODIC:
	18	periodic_callback(ptr, param);
	19	break;
	20	default:
	21	assert_always(FALSE, "Unknown id in wolfpack_state::device_timer");
	22	}
	23	}
	24
	25
12	26	TIMER_CALLBACK_MEMBER(wolfpack_state::periodic_callback)
13	27	{
14	28	int scanline = param;
r22836	r22837
20	34	if (scanline >= 262)
21	35	scanline = 0;
22	36
23		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(scanline), timer_expired_delegate(FUNC(wolfpack_state::periodic_callback),this), scanline);
	37	timer_set(machine().primary_screen->time_until_pos(scanline), TIMER_PERIODIC, scanline);
24	38	}
25	39
26	40
27	41	void wolfpack_state::machine_reset()
28	42	{
29		machine().scheduler().timer_set(machine().primary_screen->time_until_pos(0), timer_expired_delegate(FUNC(wolfpack_state::periodic_callback),this));
	43	timer_set(machine().primary_screen->time_until_pos(0), TIMER_PERIODIC);
30	44	}
31	45
32	46

trunk/src/mame/drivers/gaplus.c

r22836	r22837
234	234	m_subcpu->set_input_line(0, CLEAR_LINE);
235	235	}
236	236
	237	void gaplus_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	238	{
	239	switch (id)
	240	{
	241	case TIMER_NAMCOIO_RUN:
	242	namcoio_run(ptr, param);
	243	break;
	244	default:
	245	assert_always(FALSE, "Unknown id in gaplus_state::device_timer");
	246	}
	247	}
	248
237	249	TIMER_CALLBACK_MEMBER(gaplus_state::namcoio_run)
238	250	{
239	251	device_t *io58xx = machine().device("58xx");
r22836	r22837
259	271	m_maincpu->set_input_line(0, ASSERT_LINE);
260	272
261	273	if (!namcoio_read_reset_line(io58xx))       /* give the cpu a tiny bit of time to write the command before processing it */
262		machine().scheduler().timer_set(attotime::from_usec(50), timer_expired_delegate(FUNC(gaplus_state::namcoio_run),this));
	274	timer_set(attotime::from_usec(50), TIMER_NAMCOIO_RUN);
263	275
264	276	if (!namcoio_read_reset_line(io56xx))       /* give the cpu a tiny bit of time to write the command before processing it */
265		machine().scheduler().timer_set(attotime::from_usec(50), timer_expired_delegate(FUNC(gaplus_state::namcoio_run),this), 1);
	277	timer_set(attotime::from_usec(50), TIMER_NAMCOIO_RUN, 1);
266	278	}
267	279
268	280	INTERRUPT_GEN_MEMBER(gaplus_state::gaplus_vblank_sub_irq)

trunk/src/mame/includes/gaplus.h

r22836	r22837
10	10	class gaplus_state : public driver_device
11	11	{
12	12	public:
	13	enum
	14	{
	15	TIMER_NAMCOIO_RUN
	16	};
	17
13	18	gaplus_state(const machine_config &mconfig, device_type type, const char *tag)
14	19	: driver_device(mconfig, type, tag),
15	20	m_customio_3(*this,"customio_3"),
r22836	r22837
63	68	required_device<cpu_device> m_subcpu;
64	69	required_device<cpu_device> m_subcpu2;
65	70	required_device<samples_device> m_samples;
	71
	72	protected:
	73	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
66	74	};

trunk/src/mame/includes/videopin.h

r22836	r22837
18	18	class videopin_state : public driver_device
19	19	{
20	20	public:
	21	enum
	22	{
	23	TIMER_INTERRUPT
	24	};
	25
21	26	videopin_state(const machine_config &mconfig, device_type type, const char *tag)
22	27	: driver_device(mconfig, type, tag),
23	28	m_video_ram(*this, "video_ram"),
r22836	r22837
49	54	double calc_plunger_pos();
50	55	required_device<cpu_device> m_maincpu;
51	56	required_device<discrete_device> m_discrete;
	57
	58	protected:
	59	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
52	60	};
53	61
54	62	/*----------- defined in audio/videopin.c -----------*/

trunk/src/mame/includes/ultratnk.h

r22836	r22837
9	9	class ultratnk_state : public driver_device
10	10	{
11	11	public:
	12	enum
	13	{
	14	TIMER_NMI
	15	};
	16
12	17	ultratnk_state(const machine_config &mconfig, device_type type, const char *tag)
13	18	: driver_device(mconfig, type, tag),
14	19	m_videoram(*this, "videoram"),
r22836	r22837
47	52	TIMER_CALLBACK_MEMBER(nmi_callback);
48	53	required_device<cpu_device> m_maincpu;
49	54	required_device<discrete_device> m_discrete;
	55
	56	protected:
	57	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
50	58	};

trunk/src/mame/includes/parodius.h

r22836	r22837
8	8	class parodius_state : public driver_device
9	9	{
10	10	public:
	11	enum
	12	{
	13	TIMER_NMI
	14	};
	15
11	16	parodius_state(const machine_config &mconfig, device_type type, const char *tag)
12	17	: driver_device(mconfig, type, tag),
13	18	m_ram(*this, "ram"),
r22836	r22837
51	56	virtual void machine_reset();
52	57	UINT32 screen_update_parodius(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
53	58	INTERRUPT_GEN_MEMBER(parodius_interrupt);
54		TIMER_CALLBACK_MEMBER(nmi_callback);
	59
	60	protected:
	61	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
55	62	};
56	63
57	64	/*----------- defined in video/parodius.c -----------*/

trunk/src/mame/includes/fuukifg2.h

r22836	r22837
3	3	class fuuki16_state : public driver_device
4	4	{
5	5	public:
	6	enum
	7	{
	8	TIMER_LEVEL_1_INTERRUPT,
	9	TIMER_VBLANK_INTERRUPT,
	10	TIMER_RASTER_INTERRUPT
	11	};
	12
6	13	fuuki16_state(const machine_config &mconfig, device_type type, const char *tag)
7	14	: driver_device(mconfig, type, tag),
8	15	m_vram(*this, "vram"),
r22836	r22837
47	54	virtual void machine_reset();
48	55	virtual void video_start();
49	56	UINT32 screen_update_fuuki16(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50		TIMER_CALLBACK_MEMBER(level_1_interrupt_callback);
51		TIMER_CALLBACK_MEMBER(vblank_interrupt_callback);
52		TIMER_CALLBACK_MEMBER(raster_interrupt_callback);
53	57	inline void get_tile_info(tile_data &tileinfo, tilemap_memory_index tile_index, int _N_);
54	58	inline void fuuki16_vram_w(offs_t offset, UINT16 data, UINT16 mem_mask, int _N_);
55	59	void draw_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect );
56	60	void fuuki16_draw_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, int i, int flag, int pri );
57	61	DECLARE_WRITE_LINE_MEMBER(soundirq);
58	62	required_device<okim6295_device> m_oki;
	63
	64	protected:
	65	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
59	66	};

trunk/src/mame/includes/wolfpack.h

r22836	r22837
1	1	class wolfpack_state : public driver_device
2	2	{
3	3	public:
	4	enum
	5	{
	6	TIMER_PERIODIC
	7	};
	8
4	9	wolfpack_state(const machine_config &mconfig, device_type type, const char *tag)
5	10	: driver_device(mconfig, type, tag),
6	11	m_alpha_num_ram(*this, "alpha_num_ram"),
r22836	r22837
63	68	void draw_pt(bitmap_ind16 &bitmap, const rectangle &cliprect);
64	69	void draw_water(colortable_t *colortable, bitmap_ind16 &bitmap, const rectangle &cliprect);
65	70	required_device<cpu_device> m_maincpu;
	71
	72	protected:
	73	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
66	74	};

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team