Previous

199869 Revisions

Next

r22529 Wednesday 24th April, 2013 at 21:46:39 UTC by Fabio Priuli
(MESS) NES IRQ clean up part 1: CPU-driven IRQ now actually tick based on CPU cycles rather than on scanlines. nw.

[src/mess/machine]

nes_bandai.c nes_bandai.h nes_bootleg.c nes_bootleg.h nes_cony.c nes_cony.h nes_irem.c nes_irem.h nes_jaleco.c nes_jaleco.h nes_kaiser.c nes_kaiser.h nes_legacy.c nes_legacy.h nes_namcot.c nes_namcot.h nes_pirate.c nes_pirate.h nes_sunsoft.c nes_sunsoft.h

trunk/src/mess/machine/nes_bootleg.c

r22528	r22529
236	236	void nes_smb3p_device::device_start()
237	237	{
238	238	common_start();
	239	irq_timer = timer_alloc(TIMER_IRQ);
	240	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	241
239	242	save_item(NAME(m_irq_enable));
240	243	save_item(NAME(m_irq_count));
241	244	}
r22528	r22529
287	290	void nes_smb2j_device::device_start()
288	291	{
289	292	common_start();
	293	irq_timer = timer_alloc(TIMER_IRQ);
	294	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	295
290	296	save_item(NAME(m_irq_enable));
291	297	save_item(NAME(m_irq_count));
292	298	}
r22528	r22529
307	313	void nes_smb2ja_device::device_start()
308	314	{
309	315	common_start();
	316	irq_timer = timer_alloc(TIMER_IRQ);
	317	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	318
310	319	save_item(NAME(m_irq_enable));
311	320	save_item(NAME(m_irq_count));
312	321	}
r22528	r22529
327	336	void nes_smb2jb_device::device_start()
328	337	{
329	338	common_start();
	339	irq_timer = timer_alloc(TIMER_IRQ);
	340	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	341
330	342	save_item(NAME(m_irq_enable));
331	343	save_item(NAME(m_irq_count));
332	344	}
r22528	r22529
733	745
734	746	-------------------------------------------------*/
735	747
736		void nes_smb3p_device::hblank_irq(int scanline, int vblank, int blanked)
	748	void nes_smb3p_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
737	749	{
738		if (m_irq_enable)
	750	if (id == TIMER_IRQ)
739	751	{
740		if ((0xffff - m_irq_count) < 114)
	752	if (m_irq_enable)
741	753	{
742		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
743		m_irq_enable = 0;
	754	if (m_irq_count == 0xffff)
	755	{
	756	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	757	m_irq_enable = 0;
	758	}
	759	else
	760	m_irq_count++;
744	761	}
745
746		m_irq_count = (m_irq_count + 114) & 0xffff;
747	762	}
748	763	}
749	764
r22528	r22529
893	908
894	909	-------------------------------------------------*/
895	910
896		void nes_smb2j_device::hblank_irq(int scanline, int vblank, int blanked)
	911	void nes_smb2j_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
897	912	{
898		if (m_irq_enable)
	913	if (id == TIMER_IRQ)
899	914	{
900		if ((0xfff - m_irq_count) < 114)
	915	if (m_irq_enable)
901	916	{
902		m_irq_count = (m_irq_count + 114) & 0xfff;
903		m_irq_enable = 0;
904		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	917	if (m_irq_count == 0xfff)
	918	{
	919	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	920	m_irq_enable = 0;
	921	m_irq_count = 0;
	922	}
	923	else
	924	m_irq_count++;
905	925	}
906		else
907		m_irq_count += 114;
908	926	}
909	927	}
910	928
r22528	r22529
972	990
973	991	-------------------------------------------------*/
974	992
975		void nes_smb2ja_device::hblank_irq(int scanline, int vblank, int blanked)
	993	void nes_smb2ja_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
976	994	{
977		if (m_irq_enable)
	995	if (id == TIMER_IRQ)
978	996	{
979		if ((0xfff - m_irq_count) <= 114)
	997	if (m_irq_enable)
980	998	{
981		m_irq_count = (m_irq_count + 1) & 0xfff;
982		m_irq_enable = 0;
983		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	999	if (m_irq_count == 0xfff)
	1000	{
	1001	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	1002	m_irq_enable = 0;
	1003	m_irq_count = 0;
	1004	}
	1005	else
	1006	m_irq_count++;
984	1007	}
985		else
986		m_irq_count += 114;
987	1008	}
988	1009	}
989	1010
r22528	r22529
1026	1047
1027	1048	-------------------------------------------------*/
1028	1049
1029		void nes_smb2jb_device::hblank_irq(int scanline, int vblank, int blanked)
	1050	void nes_smb2jb_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
1030	1051	{
1031		if (m_irq_enable)
	1052	if (id == TIMER_IRQ)
1032	1053	{
1033		if ((0xfff - m_irq_count) < 114)
	1054	if (m_irq_enable)
1034	1055	{
1035		m_irq_count = (m_irq_count + 114) & 0xfff;
1036		m_irq_enable = 0;
1037		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	1056	if (m_irq_count == 0xfff)
	1057	{
	1058	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	1059	m_irq_enable = 0;
	1060	m_irq_count = 0;
	1061	}
	1062	else
	1063	m_irq_count++;
1038	1064	}
1039		else
1040		m_irq_count += 114;
1041	1065	}
1042	1066	}
1043	1067

trunk/src/mess/machine/nes_bootleg.h

r22528	r22529
102	102
103	103	// device-level overrides
104	104	virtual void device_start();
	105	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
105	106	virtual DECLARE_WRITE8_MEMBER(write_h);
106	107
107		virtual void hblank_irq(int scanline, int vblank, int blanked);
108	108	virtual void pcb_reset();
109	109
110	110	private:
111	111	UINT16 m_irq_count;
112	112	int m_irq_enable;
	113
	114	static const device_timer_id TIMER_IRQ = 0;
	115	emu_timer *irq_timer;
113	116	};
114	117
115	118
r22528	r22529
163	166
164	167	// device-level overrides
165	168	virtual void device_start();
	169	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
166	170	virtual DECLARE_READ8_MEMBER(read_l);
167	171	virtual DECLARE_READ8_MEMBER(read_m);
168	172	virtual DECLARE_WRITE8_MEMBER(write_ex);
169	173	virtual DECLARE_WRITE8_MEMBER(write_l);
170	174	virtual DECLARE_WRITE8_MEMBER(write_h);
171	175
172		virtual void hblank_irq(int scanline, int vblank, int blanked);
173	176	virtual void pcb_reset();
174	177
175	178	private:
176	179	UINT16 m_irq_count;
177	180	int m_irq_enable;
	181
	182	static const device_timer_id TIMER_IRQ = 0;
	183	emu_timer *irq_timer;
178	184	};
179	185
180	186
r22528	r22529
188	194
189	195	// device-level overrides
190	196	virtual void device_start();
	197	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
191	198	virtual DECLARE_READ8_MEMBER(read_m);
192	199	virtual DECLARE_WRITE8_MEMBER(write_h);
193	200
194		virtual void hblank_irq(int scanline, int vblank, int blanked);
195	201	virtual void pcb_reset();
196	202
197	203	private:
198	204	UINT16 m_irq_count;
199	205	int m_irq_enable;
	206
	207	static const device_timer_id TIMER_IRQ = 0;
	208	emu_timer *irq_timer;
200	209	};
201	210
202	211
r22528	r22529
210	219
211	220	// device-level overrides
212	221	virtual void device_start();
	222	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
213	223	virtual DECLARE_READ8_MEMBER(read_m);
214	224	virtual DECLARE_WRITE8_MEMBER(write_l);
215	225	virtual DECLARE_WRITE8_MEMBER(write_ex);
216	226
217		virtual void hblank_irq(int scanline, int vblank, int blanked);
218	227	virtual void pcb_reset();
219	228
220	229	private:
221	230	UINT16 m_irq_count;
222	231	int m_irq_enable;
	232
	233	static const device_timer_id TIMER_IRQ = 0;
	234	emu_timer *irq_timer;
223	235	};
224	236
225	237

trunk/src/mess/machine/nes_cony.c

r22528	r22529
61	61	void nes_cony_device::device_start()
62	62	{
63	63	common_start();
	64	irq_timer = timer_alloc(TIMER_IRQ);
	65	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	66
64	67	save_item(NAME(m_irq_enable));
65	68	save_item(NAME(m_irq_count));
66	69
r22528	r22529
94	97	void nes_yoko_device::device_start()
95	98	{
96	99	common_start();
	100	irq_timer = timer_alloc(TIMER_IRQ);
	101	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	102
97	103	save_item(NAME(m_irq_enable));
98	104	save_item(NAME(m_irq_count));
99	105
r22528	r22529
147	153
148	154	-------------------------------------------------*/
149	155
150		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
151		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
152		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
153		void nes_cony_device::hblank_irq( int scanline, int vblank, int blanked )
	156	void nes_cony_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
154	157	{
155		if (m_irq_enable)
	158	if (id == TIMER_IRQ)
156	159	{
157		if (m_irq_count <= 114)
	160	if (m_irq_enable)
158	161	{
159		m_irq_enable = 0;
160		m_irq_count = 0xffff;
161		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	162	if (!m_irq_count)
	163	{
	164	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	165	m_irq_enable = 0;
	166	m_irq_count = 0xffff;
	167	}
	168	else
	169	m_irq_count--;
162	170	}
163		else
164		m_irq_count -= 114;
165	171	}
166	172	}
167	173

trunk/src/mess/machine/nes_cony.h

r22528	r22529
15	15
16	16	// device-level overrides
17	17	virtual void device_start();
	18	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
18	19	virtual DECLARE_READ8_MEMBER(read_l);
19	20	virtual DECLARE_WRITE8_MEMBER(write_l);
20	21	virtual DECLARE_WRITE8_MEMBER(write_h);
21	22
22		virtual void hblank_irq(int scanline, int vblank, int blanked);
23	23	virtual void pcb_reset();
24	24
25	25	protected:
r22528	r22529
28	28
29	29	UINT16 m_irq_count;
30	30	int m_irq_enable;
31
	31
	32	static const device_timer_id TIMER_IRQ = 0;
	33	emu_timer *irq_timer;
	34
32	35	UINT8 m_latch1, m_latch2;
33	36	UINT8 m_low_reg[4];
34	37	UINT8 m_reg[10];

trunk/src/mess/machine/nes_bandai.c

r22528	r22529
144	144	void nes_lz93d50_device::device_start()
145	145	{
146	146	common_start();
	147	irq_timer = timer_alloc(TIMER_IRQ);
	148	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	149
147	150	save_item(NAME(m_irq_enable));
148	151	save_item(NAME(m_irq_count));
149	152	}
r22528	r22529
162	165	void nes_lz93d50_24c01_device::device_start()
163	166	{
164	167	common_start();
	168	irq_timer = timer_alloc(TIMER_IRQ);
	169	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	170
165	171	save_item(NAME(m_irq_enable));
166	172	save_item(NAME(m_irq_count));
167	173	save_item(NAME(m_i2c_mem));
r22528	r22529
184	190	void nes_fjump2_device::device_start()
185	191	{
186	192	common_start();
	193	irq_timer = timer_alloc(TIMER_IRQ);
	194	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	195
187	196	save_item(NAME(m_reg));
188	197	}
189	198
r22528	r22529
316	325
317	326	-------------------------------------------------*/
318	327
319		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
320		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
321		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
322		void nes_lz93d50_device::hblank_irq(int scanline, int vblank, int blanked)
	328	void nes_lz93d50_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
323	329	{
324		/* 114 is the number of cycles per scanline */
325		/* TODO: change to reflect the actual number of cycles spent */
326		if (m_irq_enable)
	330	if (id == TIMER_IRQ)
327	331	{
328		if (m_irq_count <= 114)
	332	if (m_irq_enable)
329	333	{
330		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
331		m_irq_count = (0xffff - 114 + m_irq_count);   // wrap around the 16 bits counter
	334	// 16bit counter, IRQ fired when the counter goes from 1 to 0
	335	// after firing, the counter is *not* reloaded, but next clock
	336	// counter wraps around from 0 to 0xffff
	337	if (!m_irq_count)
	338	m_irq_count = 0xffff;
	339	else
	340	m_irq_count--;
	341
	342	if (!m_irq_count)
	343	{
	344	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	345	m_irq_enable = 0;
	346	}
332	347	}
333		m_irq_count -= 114;
334	348	}
335	349	}
336	350
r22528	r22529
472	486	prg16_cdef(prg_base | 0x0f);
473	487	}
474	488
	489	READ8_MEMBER(nes_fjump2_device::read_m)
	490	{
	491	LOG_MMC(("fjump2 read_m, offset: %04x\n", offset));
	492	return m_battery[offset & (m_battery_size - 1)];
	493	}
	494
	495	WRITE8_MEMBER(nes_fjump2_device::write_m)
	496	{
	497	LOG_MMC(("fjump2 write_m, offset: %04x, data: %02x\n", offset, data));
	498	m_battery[offset & (m_battery_size - 1)] = data;
	499	}
	500
475	501	WRITE8_MEMBER(nes_fjump2_device::write_h)
476	502	{
477	503	LOG_MMC(("fjump2 write_h, offset: %04x, data: %02x\n", offset, data));

trunk/src/mess/machine/nes_bandai.h

r22528	r22529
59	59
60	60	// device-level overrides
61	61	virtual void device_start();
	62	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
62	63	virtual DECLARE_WRITE8_MEMBER(lz93d50_write);
63	64	virtual DECLARE_WRITE8_MEMBER(write_h) { lz93d50_write(space, offset, data, mem_mask); }
64	65	virtual DECLARE_WRITE8_MEMBER(write_m);
65	66
66		virtual void hblank_irq(int scanline, int vblank, int blanked);
67	67	virtual void pcb_reset();
68	68
69	69	protected:
70	70	UINT16     m_irq_count;
71	71	int        m_irq_enable;
	72
	73	static const device_timer_id TIMER_IRQ = 0;
	74	emu_timer *irq_timer;
72	75	};
73	76
74	77
r22528	r22529
138	141
139	142	// device-level overrides
140	143	virtual void device_start();
	144	virtual DECLARE_READ8_MEMBER(read_m);
	145	virtual DECLARE_WRITE8_MEMBER(write_m);
141	146	virtual DECLARE_WRITE8_MEMBER(write_h);
142	147
143	148	virtual void pcb_reset();

trunk/src/mess/machine/nes_kaiser.c

r22528	r22529
132	132	void nes_ks7032_device::device_start()
133	133	{
134	134	common_start();
	135	irq_timer = timer_alloc(TIMER_IRQ);
	136	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	137
135	138	save_item(NAME(m_latch));
136	139	save_item(NAME(m_irq_enable));
137	140	save_item(NAME(m_irq_count));
r22528	r22529
155	158	void nes_ks7017_device::device_start()
156	159	{
157	160	common_start();
	161	irq_timer = timer_alloc(TIMER_IRQ);
	162	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	163
158	164	save_item(NAME(m_latch));
159	165	save_item(NAME(m_irq_enable));
160	166	save_item(NAME(m_irq_count));
r22528	r22529
291	297
292	298	-------------------------------------------------*/
293	299
	300	void nes_ks7032_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	301	{
	302	if (id == TIMER_IRQ)
	303	{
	304	if (m_irq_enable)
	305	{
	306	if (m_irq_count == 0xffff)
	307	{
	308	m_irq_enable = 0;
	309	m_irq_count = 0;
	310	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	311	}
	312	else
	313	m_irq_count++;
	314	}
	315	}
	316	}
	317
294	318	void nes_ks7032_device::prg_update()
295	319	{
296	320	prg8_89(m_reg[1]);
r22528	r22529
298	322	prg8_cd(m_reg[3]);
299	323	}
300	324
301		void nes_ks7032_device::hblank_irq(int scanline, int vblank, int blanked)
302		{
303		if (m_irq_enable)
304		{
305		if (m_irq_count >= (0xffff - 114))
306		{
307		m_irq_enable = 0;
308		m_irq_count = 0;
309		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
310		}
311		else
312		m_irq_count += 114;
313		}
314		}
315
316	325	WRITE8_MEMBER(nes_ks7032_device::ks7032_write)
317	326	{
318	327	LOG_MMC(("ks7032_write, offset: %04x, data: %02x\n", offset, data));
r22528	r22529
406	415
407	416	-------------------------------------------------*/
408	417
409		void nes_ks7017_device::hblank_irq(int scanline, int vblank, int blanked)
	418	void nes_ks7017_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
410	419	{
411		if (m_irq_enable)
	420	if (id == TIMER_IRQ)
412	421	{
413		if (m_irq_count <= 114)
	422	if (m_irq_enable)
414	423	{
415		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
416		m_irq_enable = 0;
417		m_irq_status |= 0x01;
	424	if (!m_irq_count)
	425	{
	426	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	427	m_irq_enable = 0;
	428	m_irq_status |= 0x01;
	429	}
	430	else
	431	m_irq_count--;
418	432	}
419		else
420		m_irq_count -= 114;
421	433	}
422	434	}
423	435

trunk/src/mess/machine/nes_kaiser.h

r22528	r22529
51	51
52	52	// device-level overrides
53	53	virtual void device_start();
	54	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
54	55	virtual DECLARE_READ8_MEMBER(read_m);
55	56	virtual DECLARE_WRITE8_MEMBER(ks7032_write);
56	57	virtual DECLARE_WRITE8_MEMBER(write_h) { ks7032_write(space, offset, data, mem_mask); }
57	58
58		virtual void hblank_irq(int scanline, int vblank, int blanked);
59	59	virtual void pcb_reset();
60	60
61	61	protected:
r22528	r22529
66	66
67	67	UINT16 m_irq_count;
68	68	int m_irq_enable;
	69
	70	static const device_timer_id TIMER_IRQ = 0;
	71	emu_timer *irq_timer;
69	72	};
70	73
71	74
r22528	r22529
93	96
94	97	// device-level overrides
95	98	virtual void device_start();
	99	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
96	100	virtual DECLARE_READ8_MEMBER(read_ex);
97	101	virtual DECLARE_WRITE8_MEMBER(write_ex);
98	102	virtual DECLARE_WRITE8_MEMBER(write_l);
99	103
100		virtual void hblank_irq(int scanline, int vblank, int blanked);
101	104	virtual void pcb_reset();
102	105
103	106	private:
r22528	r22529
106	109	UINT16 m_irq_count;
107	110	UINT8 m_irq_status;
108	111	int m_irq_enable;
	112
	113	static const device_timer_id TIMER_IRQ = 0;
	114	emu_timer *irq_timer;
109	115	};
110	116
111	117

trunk/src/mess/machine/nes_jaleco.c

r22528	r22529
208	208	void nes_ss88006_device::device_start()
209	209	{
210	210	common_start();
	211	irq_timer = timer_alloc(TIMER_IRQ);
	212	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	213
211	214	save_item(NAME(m_mmc_prg_bank));
212	215	save_item(NAME(m_mmc_vrom_bank));
213	216	save_item(NAME(m_irq_enable));
r22528	r22529
421	424
422	425	-------------------------------------------------*/
423	426
424		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
425		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
426		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
427		void nes_ss88006_device::hblank_irq(int scanline, int vblank, int blanked)
	427	void nes_ss88006_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
428	428	{
429		/* Increment & check the IRQ scanline counter */
430		if (m_irq_enable)
	429	if (id == TIMER_IRQ)
431	430	{
432		LOG_MMC(("scanline: %d, irq count: %04x\n", scanline, m_irq_count));
433		if (m_irq_mode & 0x08)
	431	if (m_irq_enable)
434	432	{
435		if ((m_irq_count & 0x000f) < 114)    // always true, but we only update the IRQ once per scanlines so we cannot be more precise :(
	433	if (m_irq_mode & 0x08)   // 4bits counter
436	434	{
437		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
438		m_irq_count = (m_irq_count & ~0x000f) | (0x0f - (114 & 0x0f) + (m_irq_count & 0x000f)); // sort of wrap around the counter
	435	if (!(m_irq_count & 0x000f))
	436	{
	437	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	438	m_irq_count = (m_irq_count & 0xfff0) | 0x000f;
	439	}
	440	else
	441	m_irq_count = (m_irq_count & 0xfff0) | ((m_irq_count & 0x000f) - 1);
439	442	}
440		// decrements should not affect upper bits, so we don't do anything here (114 > 0x0f)
441		}
442		else if (m_irq_mode & 0x04)
443		{
444		if ((m_irq_count & 0x00ff) < 114)
	443	else if (m_irq_mode & 0x04)   // 8bits counter
445	444	{
446		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
447		m_irq_count = (m_irq_count & ~0x00ff) | (0xff - 114 + (m_irq_count & 0x00ff)); // wrap around the 8 bits counter
	445	if (!(m_irq_count & 0x00ff))
	446	{
	447	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	448	m_irq_count = (m_irq_count & 0xff00) | 0x00ff;
	449	}
	450	else
	451	m_irq_count = (m_irq_count & 0xff00) | ((m_irq_count & 0x00ff) - 1);
448	452	}
449		else
450		m_irq_count -= 114;
451		}
452		else if (m_irq_mode & 0x02)
453		{
454		if ((m_irq_count & 0x0fff)  < 114)
	453	else if (m_irq_mode & 0x02)   // 12bits counter
455	454	{
456		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
457		m_irq_count = (m_irq_count & ~0x0fff) | (0xfff - 114 + (m_irq_count & 0x0fff));    // wrap around the 12 bits counter
	455	if (!(m_irq_count & 0x0fff))
	456	{
	457	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	458	m_irq_count = (m_irq_count & 0xf000) | 0x0fff;
	459	}
	460	else
	461	m_irq_count = (m_irq_count & 0xf000) | ((m_irq_count & 0x0fff) - 1);
458	462	}
459		else
460		m_irq_count -= 114;
	463	else    // 16bits counter
	464	{
	465	if (!m_irq_count)
	466	{
	467	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	468	m_irq_count = 0xffff;
	469	}
	470	else
	471	m_irq_count = m_irq_count - 1;
	472	}
461	473	}
462		else if (m_irq_count < 114)
463		{
464		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
465		m_irq_count = (0xffff - 114 + m_irq_count);   // wrap around the 16 bits counter
466		}
467		else
468		m_irq_count -= 114;
469	474	}
470	475	}
471	476
r22528	r22529
529	534	case 0x6003:
530	535	m_irq_count_latch = (m_irq_count_latch & 0x0fff) | ((data & 0x0f) << 12);
531	536	break;
532
533	537	case 0x7000:
534	538	m_irq_count = m_irq_count_latch;
535	539	break;

trunk/src/mess/machine/nes_jaleco.h

r22528	r22529
137	137
138	138	// device-level overrides
139	139	virtual void device_start();
	140	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
140	141	virtual DECLARE_WRITE8_MEMBER(ss88006_write);
141	142	virtual DECLARE_WRITE8_MEMBER(write_h) { ss88006_write(space, offset, data, mem_mask); }
142	143
143		virtual void hblank_irq(int scanline, int vblank, int blanked);
144	144	virtual void pcb_reset();
145	145
146	146	protected:
147	147	UINT16 m_irq_count, m_irq_count_latch;
148	148	UINT8 m_irq_mode;
149	149	int m_irq_enable;
150
	150
	151	static const device_timer_id TIMER_IRQ = 0;
	152	emu_timer *irq_timer;
	153
151	154	UINT8 m_mmc_prg_bank[3];
152	155	UINT8 m_mmc_vrom_bank[8];
153	156

trunk/src/mess/machine/nes_irem.c

r22528	r22529
130	130	void nes_h3001_device::device_start()
131	131	{
132	132	common_start();
	133	irq_timer = timer_alloc(TIMER_IRQ);
	134	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	135
133	136	save_item(NAME(m_irq_enable));
134	137	save_item(NAME(m_irq_count));
135	138	save_item(NAME(m_irq_count_latch));
r22528	r22529
270	273
271	274	-------------------------------------------------*/
272	275
273		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
274		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
275		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
276		void nes_h3001_device::hblank_irq(int scanline, int vblank, int blanked)
	276
	277	void nes_h3001_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
277	278	{
278		if (m_irq_enable)
	279	if (id == TIMER_IRQ)
279	280	{
280		m_irq_count -= 114;
281
282		if (m_irq_count <= 114)
	281	if (m_irq_enable)
283	282	{
284		m_irq_enable = 0;
285		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	283	// 16bit counter, IRQ fired when the counter reaches 0
	284	// after firing, the counter is *not* reloaded and does not wrap
	285	if (m_irq_count > 0)
	286	m_irq_count--;
	287
	288	if (!m_irq_count)
	289	{
	290	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	291	m_irq_enable = 0;
	292	}
286	293	}
287	294	}
288	295	}

trunk/src/mess/machine/nes_irem.h

r22528	r22529
81	81
82	82	// device-level overrides
83	83	virtual void device_start();
	84	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
84	85	virtual DECLARE_WRITE8_MEMBER(write_h);
85	86
86		virtual void hblank_irq(int scanline, int vblank, int blanked);
87	87	virtual void pcb_reset();
88	88
89	89	protected:
90	90	UINT16     m_irq_count, m_irq_count_latch;
91	91	int        m_irq_enable;
	92
	93	static const device_timer_id TIMER_IRQ = 0;
	94	emu_timer *irq_timer;
92	95	};
93	96
94	97

trunk/src/mess/machine/nes_legacy.c

r22528	r22529
78	78	void nes_ffe4_device::device_start()
79	79	{
80	80	common_start();
81
	81	irq_timer = timer_alloc(TIMER_IRQ);
	82	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	83
82	84	m_exram = auto_alloc_array_clear(machine(), UINT8, 0x8000);
83	85	save_pointer(NAME(m_exram), 0x8000);
84	86	save_item(NAME(m_exram_enabled));
r22528	r22529
158	160
159	161	-------------------------------------------------*/
160	162
161		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
162		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
163		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
164
165		void nes_ffe4_device::hblank_irq(int scanline, int vblank, int blanked)
	163	void nes_ffe4_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
166	164	{
167		// 114 is the number of cycles per scanline
168		// TODO: change to reflect the actual number of cycles spent
169		if (m_irq_enable)
	165	if (id == TIMER_IRQ)
170	166	{
171		if ((0xffff - m_irq_count) < 114)
	167	if (m_irq_enable)
172	168	{
173		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
174		m_irq_count = 0;
175		m_irq_enable = 0;
	169	if (m_irq_count == 0xffff)
	170	{
	171	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	172	m_irq_count = 0;
	173	m_irq_enable = 0;
	174	}
	175	else
	176	m_irq_count++;
176	177	}
177		m_irq_count += 114;
178	178	}
179	179	}
180	180

trunk/src/mess/machine/nes_legacy.h

r22528	r22529
31	31
32	32	// device-level overrides
33	33	virtual void device_start();
	34	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
34	35	virtual DECLARE_WRITE8_MEMBER(write_l);
35	36	virtual DECLARE_WRITE8_MEMBER(write_h);
36	37	virtual DECLARE_READ8_MEMBER(chr_r);
37	38	virtual DECLARE_WRITE8_MEMBER(chr_w);
38	39
39		virtual void hblank_irq(int scanline, int vblank, int blanked);
40	40	virtual void pcb_reset();
41	41
42	42	protected:
43	43	UINT16 m_irq_count;
44	44	int m_irq_enable;
45
	45
	46	static const device_timer_id TIMER_IRQ = 0;
	47	emu_timer *irq_timer;
	48
46	49	UINT8 m_latch;
47	50	UINT8 *m_exram;
48	51	int m_exram_enabled;

trunk/src/mess/machine/nes_namcot.c

r22528	r22529
145	145	void nes_namcot340_device::device_start()
146	146	{
147	147	common_start();
	148	irq_timer = timer_alloc(TIMER_IRQ);
	149	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	150
148	151	save_item(NAME(m_irq_enable));
149	152	save_item(NAME(m_irq_count));
150	153
r22528	r22529
170	173	void nes_namcot175_device::device_start()
171	174	{
172	175	common_start();
	176	irq_timer = timer_alloc(TIMER_IRQ);
	177	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	178
173	179	save_item(NAME(m_irq_enable));
174	180	save_item(NAME(m_irq_count));
175	181	save_item(NAME(m_wram_enable));
r22528	r22529
197	203	void nes_namcot163_device::device_start()
198	204	{
199	205	common_start();
	206	irq_timer = timer_alloc(TIMER_IRQ);
	207	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	208
200	209	save_item(NAME(m_irq_enable));
201	210	save_item(NAME(m_irq_count));
202	211	save_item(NAME(m_wram_protect));
r22528	r22529
393	402
394	403	-------------------------------------------------*/
395	404
396		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
397		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
398		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
399		void nes_namcot340_device::hblank_irq(int scanline, int vblank, int blanked)
	405	void nes_namcot340_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
400	406	{
401		if (m_irq_enable)
	407	if (id == TIMER_IRQ)
402	408	{
403		if (m_irq_count >= (0x7fff - 114))
	409	if (m_irq_enable)
404	410	{
405		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
406		m_irq_count = 0;
	411	if (m_irq_count == 0x7fff)   // counter does not wrap to 0!
	412	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	413	else
	414	m_irq_count++;
407	415	}
408		else
409		m_irq_count += 114;
410	416	}
411	417	}
412	418

trunk/src/mess/machine/nes_pirate.c

r22528	r22529
427	427	void nes_cityfight_device::device_start()
428	428	{
429	429	common_start();
	430	irq_timer = timer_alloc(TIMER_IRQ);
	431	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	432
430	433	save_item(NAME(m_prg_reg));
431	434	save_item(NAME(m_prg_mode));
432	435	save_item(NAME(m_irq_enable));
r22528	r22529
1235	1238
1236	1239	-------------------------------------------------*/
1237	1240
1238		void nes_cityfight_device::hblank_irq(int scanline, int vblank, int blanked)
	1241	void nes_cityfight_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
1239	1242	{
1240		if (m_irq_enable)
	1243	if (id == TIMER_IRQ)
1241	1244	{
1242		if (m_irq_count <= 114)
	1245	if (m_irq_enable)
1243	1246	{
1244		m_irq_count = 0xffff;
1245		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	1247	if (!m_irq_count)
	1248	{
	1249	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	1250	m_irq_count = 0xffff;
	1251	}
	1252	else
	1253	m_irq_count--;
1246	1254	}
1247		else
1248		m_irq_count -= 114;
1249	1255	}
1250	1256	}
1251	1257

trunk/src/mess/machine/nes_namcot.h

r22528	r22529
75	75
76	76	// device-level overrides
77	77	virtual void device_start();
	78	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
78	79	virtual DECLARE_READ8_MEMBER(n340_loread);
79	80	virtual DECLARE_WRITE8_MEMBER(n340_lowrite);
80	81	virtual DECLARE_WRITE8_MEMBER(n340_hiwrite);
r22528	r22529
82	83	virtual DECLARE_WRITE8_MEMBER(write_l) { n340_lowrite(space, offset, data, mem_mask); }
83	84	virtual DECLARE_WRITE8_MEMBER(write_h) { n340_hiwrite(space, offset, data, mem_mask); }
84	85
85		virtual void hblank_irq(int scanline, int vblank, int blanked);
86	86	virtual void pcb_reset();
87	87
88	88	protected:
89	89	UINT16 m_irq_count;
90	90	int m_irq_enable;
91
	91
	92	static const device_timer_id TIMER_IRQ = 0;
	93	emu_timer *irq_timer;
	94
92	95	// Namcot-163 chip contains 8K of internal ram, possibly battery backed up (not emulated yet)
93	96	// was it also present in 175 & 340 chips?
94	97	UINT8 *m_n163_ram;

trunk/src/mess/machine/nes_pirate.h

r22528	r22529
333	333
334	334	// device-level overrides
335	335	virtual void device_start();
	336	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
336	337	virtual DECLARE_WRITE8_MEMBER(write_h);
337	338
338		virtual void hblank_irq(int scanline, int vblank, int blanked);
339	339	virtual void pcb_reset();
340	340
341	341	private:
r22528	r22529
343	343	UINT8 m_prg_reg, m_prg_mode;
344	344	UINT16 m_irq_count;
345	345	int m_irq_enable;
346
	346
	347	static const device_timer_id TIMER_IRQ = 0;
	348	emu_timer *irq_timer;
	349
347	350	UINT8 m_mmc_vrom_bank[8];
348	351	};
349	352

trunk/src/mess/machine/nes_sunsoft.c

r22528	r22529
122	122	void nes_sunsoft_3_device::device_start()
123	123	{
124	124	common_start();
	125	irq_timer = timer_alloc(TIMER_IRQ);
	126	irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	127
125	128	save_item(NAME(m_irq_enable));
126	129	save_item(NAME(m_irq_toggle));
127	130	save_item(NAME(m_irq_count));
r22528	r22529
163	166	void nes_sunsoft_fme7_device::device_start()
164	167	{
165	168	common_start();
	169	irq_timer = timer_alloc(TIMER_IRQ);
	170	// this has to be hardcoded because some some scanline code only suits NTSC... it will be fixed with PPU rewrite
	171	irq_timer->adjust(attotime::zero, 0, attotime::from_hz((21477272.724 / 12)));
	172	//   irq_timer->adjust(attotime::zero, 0, machine().device<cpu_device>("maincpu")->cycles_to_attotime(1));
	173
166	174	save_item(NAME(m_wram_bank));
167	175	save_item(NAME(m_latch));
168	176	save_item(NAME(m_irq_enable));
r22528	r22529
255	263
256	264	-------------------------------------------------*/
257	265
258		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
259		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
260		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
261		void nes_sunsoft_3_device::hblank_irq( int scanline, int vblank, int blanked )
	266
	267	void nes_sunsoft_3_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
262	268	{
263		/* TODO: change to reflect the actual number of cycles spent: both using 114 or cycling 114,114,113
264		produces a 1-line glitch in Fantasy Zone 2: it really requires the counter to be updated each CPU cycle! */
265		if (m_irq_enable)
	269	if (id == TIMER_IRQ)
266	270	{
267		if (m_irq_count <= 114)
	271	if (m_irq_enable)
268	272	{
269		m_irq_enable = 0;
270		m_irq_count = 0xffff;
271		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	273	if (!m_irq_count)
	274	{
	275	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	276	m_irq_count = 0xffff;
	277	m_irq_enable = 0;
	278	}
	279	else
	280	m_irq_count--;
272	281	}
273		else
274		m_irq_count -= 114;
275	282	}
276	283	}
277	284
r22528	r22529
449	456
450	457	-------------------------------------------------*/
451	458
452		/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
453		we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
454		there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
455		void nes_sunsoft_fme7_device::hblank_irq( int scanline, int vblank, int blanked )
	459	void nes_sunsoft_fme7_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
456	460	{
457		/* TODO: change to reflect the actual number of cycles spent */
458		if ((m_irq_enable & 0x80) && (m_irq_enable & 0x01))
	461	if (id == TIMER_IRQ)
459	462	{
460		if (m_irq_count <= 114)
	463	if ((m_irq_enable & 0x80)) // bit7, counter decrement
461	464	{
462		m_irq_count = 0xffff;
463		machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	465	if (!m_irq_count)
	466	{
	467	m_irq_count = 0xffff;
	468	if (m_irq_enable & 0x01) // bit0, trigger enable
	469	machine().device("maincpu")->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);
	470	}
	471	else
	472	m_irq_count--;
464	473	}
465		else
466		m_irq_count -= 114;
467	474	}
468		else if (m_irq_enable & 0x01)    // if enable bit 7 is not set, only decrement the counter!
469		{
470		if (m_irq_count <= 114)
471		m_irq_count = 0xffff;
472		else
473		m_irq_count -= 114;
474		}
475	475	}
476	476
477	477	WRITE8_MEMBER(nes_sunsoft_fme7_device::fme7_write)

trunk/src/mess/machine/nes_sunsoft.h

r22528	r22529
47	47
48	48	// device-level overrides
49	49	virtual void device_start();
	50	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
50	51	virtual DECLARE_WRITE8_MEMBER(write_h);
51	52
52		virtual void hblank_irq(int scanline, int vblank, int blanked);
53	53	virtual void pcb_reset();
54	54
55	55	private:
56
57	56	UINT16 m_irq_count;
58	57	int m_irq_enable, m_irq_toggle;
	58
	59	static const device_timer_id TIMER_IRQ = 0;
	60	emu_timer *irq_timer;
59	61	};
60	62
61	63
r22528	r22529
93	95
94	96	// device-level overrides
95	97	virtual void device_start();
	98	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
96	99	virtual DECLARE_READ8_MEMBER(read_m);
97	100	virtual DECLARE_WRITE8_MEMBER(write_m);
98	101	virtual DECLARE_WRITE8_MEMBER(fme7_write);
99	102	virtual DECLARE_WRITE8_MEMBER(write_h) { fme7_write(space, offset, data, mem_mask); }
100	103
101		virtual void hblank_irq( int scanline, int vblank, int blanked );
102	104	virtual void pcb_reset();
103	105
104	106	private:
105		UINT8 m_latch;
106	107	UINT16 m_irq_count;
107	108	int m_irq_enable;
108
	109
	110	static const device_timer_id TIMER_IRQ = 0;
	111	emu_timer *irq_timer;
	112
	113	UINT8 m_latch;
109	114	UINT8 m_wram_bank;
110	115	};
111	116

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team