Previous

199869 Revisions

Next

r22823 Tuesday 14th May, 2013 at 20:48:27 UTC by Wilbert Pol
pic8259.c: Continue modernization. (nw)

[src/emu/machine]	pic8259.c pic8259.h
[src/mame/drivers]	calchase.c chihiro.c fruitpc.c funkball.c gamecstl.c gammagic.c magtouch.c mediagx.c midqslvr.c pcat_nit.c pcxt.c photoply.c pinball2k.c quakeat.c queen.c savquest.c su2000.c taitowlf.c voyager.c xtom3d.c
[src/mame/machine]	pcshare.c
[src/mess/drivers]	amstr_pc.c apc.c apricot.c apricotp.c at.c b2m.c bebox.c compis.c fmtowns.c iq151.c irisha.c m20.c multi16.c paso1600.c pasogo.c pc.c pc100.c pc1512.c pc88va.c pc9801.c qx10.c sage2.c tandy2k.c tsispch.c victor9k.c wangpc.c z100.c
[src/mess/includes]	apollo.h b2m.h bebox.h fmtowns.h pc.h pk8020.h
[src/mess/machine]	apollo.c at.c b2m.c bebox.c compis.c genpc.c mbc55x.c pc.c pc9801_118.c pc9801_26.c pc9801_86.c pk8020.c southbridge.c
[src/mess/video]	fmtowns.c pc_t1t.c

trunk/src/emu/machine/pic8259.c

r22822	r22823
20	20	#define LOG_OCW     0
21	21	#define LOG_GENERAL  0
22	22
23		enum pic8259_state_t
24		{
25		STATE_ICW1,
26		STATE_ICW2,
27		STATE_ICW3,
28		STATE_ICW4,
29		STATE_READY
30		};
31	23
32		struct pic8259_t
	24	TIMER_CALLBACK_MEMBER( pic8259_device::timerproc )
33	25	{
34		devcb_resolved_write_line out_int_func;
35
36		devcb_resolved_read_line sp_en_func;
37
38		devcb_resolved_read8 read_slave_ack_func;
39
40		emu_timer *timer;
41
42		pic8259_state_t state;
43
44		UINT8 isr;
45		UINT8 irr;
46		UINT8 prio;
47		UINT8 imr;
48		UINT8 irq_lines;
49
50		UINT8 input;
51		UINT8 ocw3;
52
53		UINT8 master;
54		/* ICW1 state */
55		UINT32 level_trig_mode : 1;
56		UINT32 vector_size : 1;
57		UINT32 cascade : 1;
58		UINT32 icw4_needed : 1;
59		UINT32 vector_addr_low;
60		/* ICW2 state */
61		UINT8 base;
62		UINT8 vector_addr_high;
63
64		/* ICW3 state */
65		UINT8 slave;
66
67		/* ICW4 state */
68		UINT32 nested : 1;
69		UINT32 mode : 2;
70		UINT32 auto_eoi : 1;
71		UINT32 is_x86 : 1;
72		};
73
74
75		INLINE pic8259_t *get_safe_token(device_t *device) {
76		assert( device != NULL );
77		assert( device->type() == PIC8259 );
78		return ( pic8259_t *) downcast<pic8259_device *>(device)->token();
79		}
80
81
82		static TIMER_CALLBACK( pic8259_timerproc )
83		{
84		device_t *device = (device_t *)ptr;
85		pic8259_t   *pic8259 = get_safe_token(device);
86	26	int irq;
87	27	UINT8 mask;
88	28
r22822	r22823
92	32	mask = 1 << irq;
93	33
94	34	/* is this IRQ in service? */
95		if (pic8259->isr & mask)
	35	if (m_isr & mask)
96	36	{
97	37	if (LOG_GENERAL)
	38	{
98	39	logerror("pic8259_timerproc(): PIC IRQ #%d still in service\n", irq);
	40	}
99	41	break;
100	42	}
101	43
102	44	/* is this IRQ pending and enabled? */
103		if ((pic8259->state == STATE_READY) && (pic8259->irr & mask) && !(pic8259->imr & mask))
	45	if ((m_state == STATE_READY) && (m_irr & mask) && !(m_imr & mask))
104	46	{
105	47	if (LOG_GENERAL)
	48	{
106	49	logerror("pic8259_timerproc(): PIC triggering IRQ #%d\n", irq);
107		if (!BIT(pic8259->ocw3, 2))
108		pic8259->out_int_func(1);
	50	}
	51	if (!BIT(m_ocw3, 2))
	52	{
	53	m_out_int_func(1);
	54	}
109	55	return;
110	56	}
111	57	}
112		if (!BIT(pic8259->ocw3, 2))
113		pic8259->out_int_func(0);
	58	if (!BIT(m_ocw3, 2))
	59	{
	60	m_out_int_func(0);
	61	}
114	62	}
115	63
116	64
117		INLINE void pic8259_set_timer(pic8259_t *pic8259)
	65	void pic8259_device::set_irq_line(int irq, int state)
118	66	{
119		pic8259->timer->adjust(attotime::zero);
120		}
121
122
123		static void pic8259_set_irq_line(device_t *device, int irq, int state)
124		{
125		pic8259_t   *pic8259 = get_safe_token(device);
126	67	UINT8 mask = (1 << irq);
127	68
128	69	if (state)
r22822	r22823
131	72	if (LOG_GENERAL)
132	73	logerror("pic8259_set_irq_line(): PIC set IRQ line #%d\n", irq);
133	74
134		if(pic8259->level_trig_mode || (!pic8259->level_trig_mode && !(pic8259->irq_lines & mask)))
135		pic8259->irr |= mask;
136		pic8259->irq_lines |= mask;
	75	if(m_level_trig_mode || (!m_level_trig_mode && !(m_irq_lines & mask)))
	76	{
	77	m_irr |= mask;
	78	}
	79	m_irq_lines |= mask;
137	80	}
138	81	else
139	82	{
140	83	/* clearing IRQ line */
141	84	if (LOG_GENERAL)
142		logerror("pic8259_set_irq_line(): PIC cleared IRQ line #%d\n", irq);
	85	{
	86	logerror("pic8259_device::set_irq_line(): PIC cleared IRQ line #%d\n", irq);
	87	}
143	88
144		pic8259->irq_lines &= ~mask;
145		pic8259->irr &= ~mask;
	89	m_irq_lines &= ~mask;
	90	m_irr &= ~mask;
146	91	}
147		pic8259_set_timer(pic8259);
	92	set_timer();
148	93	}
149	94
150		WRITE_LINE_DEVICE_HANDLER( pic8259_ir0_w ) { pic8259_set_irq_line(device, 0, state); }
151		WRITE_LINE_DEVICE_HANDLER( pic8259_ir1_w ) { pic8259_set_irq_line(device, 1, state); }
152		WRITE_LINE_DEVICE_HANDLER( pic8259_ir2_w ) { pic8259_set_irq_line(device, 2, state); }
153		WRITE_LINE_DEVICE_HANDLER( pic8259_ir3_w ) { pic8259_set_irq_line(device, 3, state); }
154		WRITE_LINE_DEVICE_HANDLER( pic8259_ir4_w ) { pic8259_set_irq_line(device, 4, state); }
155		WRITE_LINE_DEVICE_HANDLER( pic8259_ir5_w ) { pic8259_set_irq_line(device, 5, state); }
156		WRITE_LINE_DEVICE_HANDLER( pic8259_ir6_w ) { pic8259_set_irq_line(device, 6, state); }
157		WRITE_LINE_DEVICE_HANDLER( pic8259_ir7_w ) { pic8259_set_irq_line(device, 7, state); }
158	95
159		WRITE_LINE_MEMBER( pic8259_device::ir0_w ) { pic8259_set_irq_line(this, 0, state); }
160		WRITE_LINE_MEMBER( pic8259_device::ir1_w ) { pic8259_set_irq_line(this, 1, state); }
161		WRITE_LINE_MEMBER( pic8259_device::ir2_w ) { pic8259_set_irq_line(this, 2, state); }
162		WRITE_LINE_MEMBER( pic8259_device::ir3_w ) { pic8259_set_irq_line(this, 3, state); }
163		WRITE_LINE_MEMBER( pic8259_device::ir4_w ) { pic8259_set_irq_line(this, 4, state); }
164		WRITE_LINE_MEMBER( pic8259_device::ir5_w ) { pic8259_set_irq_line(this, 5, state); }
165		WRITE_LINE_MEMBER( pic8259_device::ir6_w ) { pic8259_set_irq_line(this, 6, state); }
166		WRITE_LINE_MEMBER( pic8259_device::ir7_w ) { pic8259_set_irq_line(this, 7, state); }
167
168		int pic8259_acknowledge(device_t *device)
	96	UINT32 pic8259_device::acknowledge()
169	97	{
170		pic8259_t   *pic8259 = get_safe_token(device);
171	98	UINT8 mask;
172	99	int irq;
173	100
r22822	r22823
176	103	mask = 1 << irq;
177	104
178	105	/* is this IRQ pending and enabled? */
179		if ((pic8259->irr & mask) && !(pic8259->imr & mask))
	106	if ((m_irr & mask) && !(m_imr & mask))
180	107	{
181	108	if (LOG_GENERAL)
	109	{
182	110	logerror("pic8259_acknowledge(): PIC acknowledge IRQ #%d\n", irq);
183		if (!pic8259->level_trig_mode)
184		pic8259->irr &= ~mask;
	111	}
	112	if (!m_level_trig_mode)
	113	{
	114	m_irr &= ~mask;
	115	}
185	116
186		if (!pic8259->auto_eoi)
187		pic8259->isr |= mask;
	117	if (!m_auto_eoi)
	118	{
	119	m_isr |= mask;
	120	}
188	121
189		pic8259_set_timer(pic8259);
	122	set_timer();
190	123
191		if ((pic8259->cascade!=0) && (pic8259->master!=0) && (mask & pic8259->slave)) {
	124	if ((m_cascade!=0) && (m_master!=0) && (mask & m_slave))
	125	{
192	126	// it's from slave device
193		return pic8259->read_slave_ack_func(irq);
194		} else {
195		if (pic8259->is_x86) {
	127	return m_read_slave_ack_func(irq);
	128	}
	129	else
	130	{
	131	if (m_is_x86)
	132	{
196	133	/* For x86 mode*/
197		return irq + pic8259->base;
198		} else {
	134	return irq + m_base;
	135	}
	136	else
	137	{
199	138	/* in case of 8080/85) */
200		return 0xcd0000 + (pic8259->vector_addr_high << 8) + pic8259->vector_addr_low + (irq << (3-pic8259->vector_size));
	139	return 0xcd0000 + (m_vector_addr_high << 8) + m_vector_addr_low + (irq << (3-m_vector_size));
201	140	}
202	141	}
203	142	}
r22822	r22823
205	144	return 0;
206	145	}
207	146
	147
208	148	UINT8 pic8259_device::inta_r()
209	149	{
210		return pic8259_acknowledge(this);
	150	return acknowledge();
211	151	}
212	152
213		READ8_DEVICE_HANDLER( pic8259_r )
214		{
215		pic8259_t   *pic8259 = get_safe_token(device);
216	153
	154	READ8_MEMBER( pic8259_device::read )
	155	{
217	156	/* NPW 18-May-2003 - Changing 0xFF to 0x00 as per Ruslan */
218	157	UINT8 data = 0x00;
219	158
220	159	switch(offset)
221	160	{
222	161	case 0: /* PIC acknowledge IRQ */
223		if ( pic8259->ocw3 & 0x04 )
	162	if ( m_ocw3 & 0x04 )
224	163	{
225	164	/* Polling mode */
226		if ( pic8259->isr & ~pic8259->imr )
227		pic8259_acknowledge( device );
	165	if ( m_isr & ~m_imr )
	166	{
	167	acknowledge();
	168	}
228	169
229		if ( pic8259->irr & ~pic8259->imr )
	170	if ( m_irr & ~m_imr )
230	171	{
231	172	int irq;
232	173	for ( irq = 0; irq < IRQ_COUNT; irq++ )
233	174	{
234		if ( ( 1 << irq ) & pic8259->irr & ~pic8259->imr )
	175	if ( ( 1 << irq ) & m_irr & ~m_imr )
235	176	{
236	177	data = 0x80 | irq;
237	178	break;
r22822	r22823
241	182	}
242	183	else
243	184	{
244		switch ( pic8259->ocw3 & 0x03 )
	185	switch ( m_ocw3 & 0x03 )
245	186	{
246	187	case 2:
247		data = pic8259->irr;
	188	data = m_irr;
248	189	break;
249	190	case 3:
250		data = pic8259->isr & ~pic8259->imr;
	191	data = m_isr & ~m_imr;
251	192	break;
252	193	default:
253	194	data = 0x00;
r22822	r22823
257	198	break;
258	199
259	200	case 1: /* PIC mask register */
260		data = pic8259->imr;
	201	data = m_imr;
261	202	break;
262	203	}
263	204	return data;
264	205	}
265	206
266	207
267		READ8_MEMBER( pic8259_device::read )
	208	WRITE8_MEMBER( pic8259_device::write )
268	209	{
269		return pic8259_r(this, space, offset);
270		}
271
272
273		WRITE8_DEVICE_HANDLER( pic8259_w )
274		{
275		pic8259_t   *pic8259 = get_safe_token(device);
276
277	210	switch(offset)
278	211	{
279	212	case 0:    /* PIC acknowledge IRQ */
r22822	r22823
281	214	{
282	215	/* write ICW1 - this pretty much resets the chip */
283	216	if (LOG_ICW)
284		logerror("pic8259_w(): ICW1; data=0x%02X\n", data);
	217	{
	218	logerror("pic8259_device::write(): ICW1; data=0x%02X\n", data);
	219	}
285	220
286		pic8259->imr                = 0x00;
287		pic8259->isr                = 0x00;
288		pic8259->irr                = 0x00;
289		pic8259->level_trig_mode    = (data & 0x08) ? 1 : 0;
290		pic8259->vector_size        = (data & 0x04) ? 1 : 0;
291		pic8259->cascade            = (data & 0x02) ? 0 : 1;
292		pic8259->icw4_needed        = (data & 0x01) ? 1 : 0;
293		pic8259->vector_addr_low    = (data & 0xe0);
294		pic8259->state          = STATE_ICW2;
295		pic8259->out_int_func(0);
	221	m_imr                = 0x00;
	222	m_isr                = 0x00;
	223	m_irr                = 0x00;
	224	m_level_trig_mode    = (data & 0x08) ? 1 : 0;
	225	m_vector_size        = (data & 0x04) ? 1 : 0;
	226	m_cascade            = (data & 0x02) ? 0 : 1;
	227	m_icw4_needed        = (data & 0x01) ? 1 : 0;
	228	m_vector_addr_low    = (data & 0xe0);
	229	m_state          = STATE_ICW2;
	230	m_out_int_func(0);
296	231	}
297		else if (pic8259->state == STATE_READY)
	232	else if (m_state == STATE_READY)
298	233	{
299	234	if ((data & 0x98) == 0x08)
300	235	{
301	236	/* write OCW3 */
302	237	if (LOG_OCW)
303		logerror("pic8259_w(): OCW3; data=0x%02X\n", data);
	238	{
	239	logerror("pic8259_device::write(): OCW3; data=0x%02X\n", data);
	240	}
304	241
305		pic8259->ocw3 = data;
	242	m_ocw3 = data;
306	243	}
307	244	else if ((data & 0x18) == 0x00)
308	245	{
r22822	r22823
311	248
312	249	/* write OCW2 */
313	250	if (LOG_OCW)
314		logerror("pic8259_w(): OCW2; data=0x%02X\n", data);
	251	{
	252	logerror("pic8259_device::write(): OCW2; data=0x%02X\n", data);
	253	}
315	254
316	255	switch (data & 0xe0)
317	256	{
318	257	case 0x00:
319		pic8259->prio = 0;
	258	m_prio = 0;
320	259	break;
321	260	case 0x20:
322		for (n = 0, mask = 1<<pic8259->prio; n < 8; n++, mask = (mask<<1) | (mask>>7))
	261	for (n = 0, mask = 1<<m_prio; n < 8; n++, mask = (mask<<1) | (mask>>7))
323	262	{
324		if (pic8259->isr & mask)
	263	if (m_isr & mask)
325	264	{
326		pic8259->isr &= ~mask;
	265	m_isr &= ~mask;
327	266	break;
328	267	}
329	268	}
r22822	r22823
331	270	case 0x40:
332	271	break;
333	272	case 0x60:
334		if( pic8259->isr & mask )
	273	if( m_isr & mask )
335	274	{
336		pic8259->isr &= ~mask;
	275	m_isr &= ~mask;
337	276	}
338	277	break;
339	278	case 0x80:
340		pic8259->prio = (pic8259->prio + 1) & 7;
	279	m_prio = (m_prio + 1) & 7;
341	280	break;
342	281	case 0xa0:
343		for (n = 0, mask = 1<<pic8259->prio; n < 8; n++, mask = (mask<<1) | (mask>>7))
	282	for (n = 0, mask = 1<<m_prio; n < 8; n++, mask = (mask<<1) | (mask>>7))
344	283	{
345		if( pic8259->isr & mask )
	284	if( m_isr & mask )
346	285	{
347		pic8259->isr &= ~mask;
348		pic8259->prio = (pic8259->prio + 1) & 7;
	286	m_isr &= ~mask;
	287	m_prio = (m_prio + 1) & 7;
349	288	break;
350	289	}
351	290	}
352	291	break;
353	292	case 0xc0:
354		pic8259->prio = n & 7;
	293	m_prio = n & 7;
355	294	break;
356	295	case 0xe0:
357		if( pic8259->isr & mask )
	296	if( m_isr & mask )
358	297	{
359		pic8259->isr &= ~mask;
360		pic8259->prio = (pic8259->prio + 1) & 7;
	298	m_isr &= ~mask;
	299	m_prio = (m_prio + 1) & 7;
361	300	}
362	301	break;
363	302	}
r22822	r22823
366	305	break;
367	306
368	307	case 1:
369		switch(pic8259->state)
	308	switch(m_state)
370	309	{
371	310	case STATE_ICW1:
372	311	break;
r22822	r22823
374	313	case STATE_ICW2:
375	314	/* write ICW2 */
376	315	if (LOG_ICW)
377		logerror("pic8259_w(): ICW2; data=0x%02X\n", data);
	316	{
	317	logerror("pic8259_device::write(): ICW2; data=0x%02X\n", data);
	318	}
378	319
379		pic8259->base = data & 0xf8;
380		pic8259->vector_addr_high = data ;
381		if (pic8259->cascade)
382		pic8259->state = STATE_ICW3;
	320	m_base = data & 0xf8;
	321	m_vector_addr_high = data ;
	322	if (m_cascade)
	323	{
	324	m_state = STATE_ICW3;
	325	}
383	326	else
384		pic8259->state = pic8259->icw4_needed ? STATE_ICW4 : STATE_READY;
	327	{
	328	m_state = m_icw4_needed ? STATE_ICW4 : STATE_READY;
	329	}
385	330	break;
386	331
387	332	case STATE_ICW3:
388	333	/* write ICW3 */
389	334	if (LOG_ICW)
390		logerror("pic8259_w(): ICW3; data=0x%02X\n", data);
	335	{
	336	logerror("pic8259_device::write(): ICW3; data=0x%02X\n", data);
	337	}
391	338
392		pic8259->slave = data;
393		pic8259->state = pic8259->icw4_needed ? STATE_ICW4 : STATE_READY;
	339	m_slave = data;
	340	m_state = m_icw4_needed ? STATE_ICW4 : STATE_READY;
394	341	break;
395	342
396	343	case STATE_ICW4:
397	344	/* write ICW4 */
398	345	if (LOG_ICW)
399		logerror("pic8259_w(): ICW4; data=0x%02X\n", data);
	346	{
	347	logerror("pic8259_device::write(): ICW4; data=0x%02X\n", data);
	348	}
400	349
401		pic8259->nested = (data & 0x10) ? 1 : 0;
402		pic8259->mode = (data >> 2) & 3;
403		pic8259->auto_eoi = (data & 0x02) ? 1 : 0;
404		pic8259->is_x86 = (data & 0x01) ? 1 : 0;
405		pic8259->state = STATE_READY;
	350	m_nested = (data & 0x10) ? 1 : 0;
	351	m_mode = (data >> 2) & 3;
	352	m_auto_eoi = (data & 0x02) ? 1 : 0;
	353	m_is_x86 = (data & 0x01) ? 1 : 0;
	354	m_state = STATE_READY;
406	355	break;
407	356
408	357	case STATE_READY:
409	358	/* write OCW1 - set interrupt mask register */
410	359	if (LOG_OCW)
411		logerror("pic8259_w(): OCW1; data=0x%02X\n", data);
	360	{
	361	logerror("pic8259_device::write(): OCW1; data=0x%02X\n", data);
	362	}
412	363
413		//printf("%s %02x\n",pic8259->master ? "master pic8259 mask" : "slave pic8259 mask",data);
414		pic8259->imr = data;
	364	//printf("%s %02x\n",m_master ? "master pic8259 mask" : "slave pic8259 mask",data);
	365	m_imr = data;
415	366	break;
416	367	}
417	368	break;
418	369	}
419		pic8259_set_timer(pic8259);
	370	set_timer();
420	371	}
421	372
422	373
423		WRITE8_MEMBER( pic8259_device::write )
424		{
425		pic8259_w(this, space, offset, data);
426		}
	374	//-------------------------------------------------
	375	//  device_start - device-specific startup
	376	//-------------------------------------------------
427	377
428
429		static DEVICE_START( pic8259 )
	378	void pic8259_device::device_start()
430	379	{
431		pic8259_t   *pic8259 = get_safe_token(device);
432		const struct pic8259_interface *intf = (const struct pic8259_interface *)device->static_config();
	380	const struct pic8259_interface *intf = (const struct pic8259_interface *)this->static_config();
433	381
434	382	assert(intf != NULL);
435	383
436		pic8259->timer = device->machine().scheduler().timer_alloc( FUNC(pic8259_timerproc), (void *)device );
	384	m_timer = machine().scheduler().timer_alloc( timer_expired_delegate( FUNC(pic8259_device::timerproc), this) );
437	385
438	386	/* resolve callbacks */
439		pic8259->out_int_func.resolve(intf->out_int_func, *device);
440		pic8259->sp_en_func.resolve(intf->sp_en_func, *device);
441		pic8259->read_slave_ack_func.resolve(intf->read_slave_ack_func, *device);
	387	m_out_int_func.resolve(intf->out_int_func, *this);
	388	m_sp_en_func.resolve(intf->sp_en_func, *this);
	389	m_read_slave_ack_func.resolve(intf->read_slave_ack_func, *this);
442	390	}
443	391
444	392
445		static DEVICE_RESET( pic8259 ) {
446		pic8259_t   *pic8259 = get_safe_token(device);
	393	//-------------------------------------------------
	394	//  device_reset - device-specific reset
	395	//-------------------------------------------------
447	396
448		pic8259->state = STATE_READY;
449		pic8259->isr = 0;
450		pic8259->irr = 0;
451		pic8259->irq_lines = 0;
452		pic8259->prio = 0;
453		pic8259->imr = 0;
454		pic8259->input = 0;
455		pic8259->ocw3 = 2;
456		pic8259->level_trig_mode = 0;
457		pic8259->vector_size = 0;
458		pic8259->cascade = 0;
459		pic8259->icw4_needed = 0;
460		pic8259->base = 0;
461		pic8259->slave = 0;
462		pic8259->nested = 0;
463		pic8259->mode = 0;
464		pic8259->auto_eoi = 0;
465		pic8259->is_x86 = 0;
466		pic8259->vector_addr_low = 0;
467		pic8259->vector_addr_high = 0;
	397	void pic8259_device::device_reset()
	398	{
	399	m_state = STATE_READY;
	400	m_isr = 0;
	401	m_irr = 0;
	402	m_irq_lines = 0;
	403	m_prio = 0;
	404	m_imr = 0;
	405	m_input = 0;
	406	m_ocw3 = 2;
	407	m_level_trig_mode = 0;
	408	m_vector_size = 0;
	409	m_cascade = 0;
	410	m_icw4_needed = 0;
	411	m_base = 0;
	412	m_slave = 0;
	413	m_nested = 0;
	414	m_mode = 0;
	415	m_auto_eoi = 0;
	416	m_is_x86 = 0;
	417	m_vector_addr_low = 0;
	418	m_vector_addr_high = 0;
468	419
469		pic8259->master = pic8259->sp_en_func();
	420	m_master = m_sp_en_func();
470	421	}
471	422
472	423	const device_type PIC8259 = &device_creator<pic8259_device>;
r22822	r22823
474	425	pic8259_device::pic8259_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
475	426	: device_t(mconfig, PIC8259, "Intel PIC8259", tag, owner, clock)
476	427	{
477		m_token = global_alloc_clear(pic8259_t);
478	428	}
479	429
480	430	//-------------------------------------------------
r22822	r22823
487	437	{
488	438	}
489	439
490		//-------------------------------------------------
491		//  device_start - device-specific startup
492		//-------------------------------------------------
493
494		void pic8259_device::device_start()
495		{
496		DEVICE_START_NAME( pic8259 )(this);
497		}
498
499		//-------------------------------------------------
500		//  device_reset - device-specific reset
501		//-------------------------------------------------
502
503		void pic8259_device::device_reset()
504		{
505		DEVICE_RESET_NAME( pic8259 )(this);
506		}

trunk/src/emu/machine/pic8259.h

r22822	r22823
32	32	{
33	33	public:
34	34	pic8259_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
35		~pic8259_device() { global_free(m_token); }
36	35
37	36	DECLARE_READ8_MEMBER( read );
38	37	DECLARE_WRITE8_MEMBER( write );
	38	UINT32 acknowledge();
39	39
40		DECLARE_WRITE_LINE_MEMBER( ir0_w );
41		DECLARE_WRITE_LINE_MEMBER( ir1_w );
42		DECLARE_WRITE_LINE_MEMBER( ir2_w );
43		DECLARE_WRITE_LINE_MEMBER( ir3_w );
44		DECLARE_WRITE_LINE_MEMBER( ir4_w );
45		DECLARE_WRITE_LINE_MEMBER( ir5_w );
46		DECLARE_WRITE_LINE_MEMBER( ir6_w );
47		DECLARE_WRITE_LINE_MEMBER( ir7_w );
	40	DECLARE_WRITE_LINE_MEMBER( ir0_w ) { set_irq_line(0, state); }
	41	DECLARE_WRITE_LINE_MEMBER( ir1_w ) { set_irq_line(1, state); }
	42	DECLARE_WRITE_LINE_MEMBER( ir2_w ) { set_irq_line(2, state); }
	43	DECLARE_WRITE_LINE_MEMBER( ir3_w ) { set_irq_line(3, state); }
	44	DECLARE_WRITE_LINE_MEMBER( ir4_w ) { set_irq_line(4, state); }
	45	DECLARE_WRITE_LINE_MEMBER( ir5_w ) { set_irq_line(5, state); }
	46	DECLARE_WRITE_LINE_MEMBER( ir6_w ) { set_irq_line(6, state); }
	47	DECLARE_WRITE_LINE_MEMBER( ir7_w ) { set_irq_line(7, state); }
48	48
49	49	UINT8 inta_r();
50	50
51		// access to legacy token
52		void *token() const { assert(m_token != NULL); return m_token; }
	51	TIMER_CALLBACK_MEMBER( timerproc );
	52
53	53	protected:
54	54	// device-level overrides
55	55	virtual void device_config_complete();
56	56	virtual void device_start();
57	57	virtual void device_reset();
	58
58	59	private:
59		// internal state
60		void *m_token;
	60	inline void set_timer() { m_timer->adjust(attotime::zero); }
	61	void set_irq_line(int irq, int state);
	62
	63
	64	enum pic8259_state_t
	65	{
	66	STATE_ICW1,
	67	STATE_ICW2,
	68	STATE_ICW3,
	69	STATE_ICW4,
	70	STATE_READY
	71	};
	72
	73	devcb_resolved_write_line m_out_int_func;
	74	devcb_resolved_read_line m_sp_en_func;
	75	devcb_resolved_read8 m_read_slave_ack_func;
	76
	77	emu_timer *m_timer;
	78
	79	pic8259_state_t m_state;
	80
	81	UINT8 m_isr;
	82	UINT8 m_irr;
	83	UINT8 m_prio;
	84	UINT8 m_imr;
	85	UINT8 m_irq_lines;
	86
	87	UINT8 m_input;
	88	UINT8 m_ocw3;
	89
	90	UINT8 m_master;
	91	/* ICW1 state */
	92	UINT32 m_level_trig_mode : 1;
	93	UINT32 m_vector_size : 1;
	94	UINT32 m_cascade : 1;
	95	UINT32 m_icw4_needed : 1;
	96	UINT32 m_vector_addr_low;
	97	/* ICW2 state */
	98	UINT8 m_base;
	99	UINT8 m_vector_addr_high;
	100
	101	/* ICW3 state */
	102	UINT8 m_slave;
	103
	104	/* ICW4 state */
	105	UINT32 m_nested : 1;
	106	UINT32 m_mode : 2;
	107	UINT32 m_auto_eoi : 1;
	108	UINT32 m_is_x86 : 1;
61	109	};
62	110
63	111	extern const device_type PIC8259;
r22822	r22823
87	135	MCFG_DEVICE_CONFIG(_intrf)
88	136
89	137
90		/* device interface */
91		DECLARE_READ8_DEVICE_HANDLER( pic8259_r );
92		DECLARE_WRITE8_DEVICE_HANDLER( pic8259_w );
93		int pic8259_acknowledge(device_t *device);
94
95		/* interrupt requests */
96		WRITE_LINE_DEVICE_HANDLER( pic8259_ir0_w );
97		WRITE_LINE_DEVICE_HANDLER( pic8259_ir1_w );
98		WRITE_LINE_DEVICE_HANDLER( pic8259_ir2_w );
99		WRITE_LINE_DEVICE_HANDLER( pic8259_ir3_w );
100		WRITE_LINE_DEVICE_HANDLER( pic8259_ir4_w );
101		WRITE_LINE_DEVICE_HANDLER( pic8259_ir5_w );
102		WRITE_LINE_DEVICE_HANDLER( pic8259_ir6_w );
103		WRITE_LINE_DEVICE_HANDLER( pic8259_ir7_w );
104
105
106	138	#endif /* __PIC8259_H__ */

trunk/src/mess/machine/pc9801_86.c

r22822	r22823
38	38	WRITE_LINE_MEMBER(pc9801_86_device::pc9801_sound_irq)
39	39	{
40	40	/* TODO: seems to die very often */
41		pic8259_ir4_w(machine().device("pic8259_slave"), state);
	41	machine().device<pic8259_device>(":pic8259_slave")->ir4_w(state);
42	42	}
43	43
44	44	static const ay8910_interface ay8910_config =

trunk/src/mess/machine/at.c

r22822	r22823
66	66	WRITE_LINE_MEMBER( at_state::at_pit8254_out0_changed )
67	67	{
68	68	if (m_pic8259_master)
69		pic8259_ir0_w(m_pic8259_master, state);
	69	m_pic8259_master->ir0_w(state);
70	70	}
71	71
72	72

trunk/src/mess/machine/b2m.c

r22822	r22823
324	324
325	325	void b2m_state::machine_start()
326	326	{
327		m_pic = machine().device("pic8259");
	327	m_pic = machine().device<pic8259_device>("pic8259");
328	328	m_fdc = machine().device<fd1793_t>("fd1793");
329	329
330	330	m_fdc->setup_drq_cb(fd1793_t::line_cb(FUNC(b2m_state::b2m_fdc_drq), this));
r22822	r22823
347	347
348	348	IRQ_CALLBACK_MEMBER(b2m_state::b2m_irq_callback)
349	349	{
350		return pic8259_acknowledge(m_pic);
	350	return m_pic->acknowledge();
351	351	}
352	352
353	353	const struct pic8259_interface b2m_pic8259_config =
r22822	r22823
361	361	{
362	362	m_vblank_state++;
363	363	if (m_vblank_state>1) m_vblank_state=0;
364		pic8259_ir0_w(m_pic, m_vblank_state);
	364	m_pic->ir0_w(m_vblank_state);
365	365	}
366	366
367	367	void b2m_state::machine_reset()

trunk/src/mess/machine/compis.c

r22822	r22823
1263	1263	WRITE_LINE_MEMBER( compis_state::compis_pic8259_slave_set_int_line )
1264	1264	{
1265	1265	if (m_8259m)
1266		pic8259_ir2_w(m_8259m, state);
	1266	m_8259m->ir2_w(state);
1267	1267	}
1268	1268
1269	1269	READ8_MEMBER( compis_state::get_slave_ack )

trunk/src/mess/machine/bebox.c

r22822	r22823
454	454	{
455	455	bebox_set_irq_bit(machine(), 13, state);
456	456	if ( m_devices.pic8259_master ) {
457		pic8259_ir6_w(m_devices.pic8259_master, state);
	457	m_devices.pic8259_master->ir6_w(state);
458	458	}
459	459	}
460	460
r22822	r22823
474	474
475	475	READ64_MEMBER(bebox_state::bebox_interrupt_ack_r )
476	476	{
477		int result;
478		result = pic8259_acknowledge( m_devices.pic8259_master );
	477	UINT32 result;
	478	result = m_devices.pic8259_master->acknowledge();
479	479	bebox_set_irq_bit(space.machine(), 5, 0);   /* HACK */
480	480	return ((UINT64) result) << 56;
481	481	}
r22822	r22823
495	495	WRITE_LINE_MEMBER(bebox_state::bebox_pic8259_slave_set_int_line)
496	496	{
497	497	if (m_devices.pic8259_master)
498		pic8259_ir2_w(m_devices.pic8259_master, state);
	498	m_devices.pic8259_master->ir2_w(state);
499	499	}
500	500
501	501	READ8_MEMBER(bebox_state::get_slave_ack)
502	502	{
503	503	if (offset==2) { // IRQ = 2
504		return pic8259_acknowledge(m_devices.pic8259_slave);
	504	return m_devices.pic8259_slave->acknowledge();
505	505	}
506	506	return 0x00;
507	507	}
r22822	r22823
558	558	{
559	559	bebox_set_irq_bit(machine(), 7, state);
560	560	if ( m_devices.pic8259_master ) {
561		pic8259_ir6_w(m_devices.pic8259_master, state);
	561	m_devices.pic8259_master->ir6_w(state);
562	562	}
563	563	}
564	564
r22822	r22823
787	787	WRITE_LINE_MEMBER(bebox_state::bebox_timer0_w)
788	788	{
789	789	if (m_devices.pic8259_master)
790		pic8259_ir0_w(m_devices.pic8259_master, state);
	790	m_devices.pic8259_master->ir0_w(state);
791	791	}
792	792
793	793
r22822	r22823
969	969
970	970
971	971	TIMER_CALLBACK_MEMBER(bebox_state::bebox_get_devices){
972		m_devices.pic8259_master = machine().device("pic8259_master");
973		m_devices.pic8259_slave = machine().device("pic8259_slave");
	972	m_devices.pic8259_master = machine().device<pic8259_device>("pic8259_master");
	973	m_devices.pic8259_slave = machine().device<pic8259_device>("pic8259_slave");
974	974	m_devices.dma8237_1 = machine().device<i8237_device>("dma8237_1");
975	975	m_devices.dma8237_2 = machine().device<i8237_device>("dma8237_2");
976	976	}

trunk/src/mess/machine/mbc55x.c

r22822	r22823
118	118
119	119	READ8_MEMBER(mbc55x_state::mbcpic8259_r)
120	120	{
121		return pic8259_r(m_pic, space, offset>>1);
	121	return m_pic->read(space, offset>>1);
122	122	}
123	123
124	124	WRITE8_MEMBER(mbc55x_state::mbcpic8259_w)
125	125	{
126		pic8259_w(m_pic, space, offset>>1, data);
	126	m_pic->write(space, offset>>1, data);
127	127	}
128	128
129	129	IRQ_CALLBACK_MEMBER(mbc55x_state::mbc55x_irq_callback)

trunk/src/mess/machine/pc.c

r22822	r22823
457	457	/* called when a interrupt is set/cleared from com hardware */
458	458	WRITE_LINE_MEMBER(pc_state::pc_com_interrupt_1)
459	459	{
460		pic8259_ir4_w(m_pic8259, state);
	460	m_pic8259->ir4_w(state);
461	461	}
462	462
463	463	WRITE_LINE_MEMBER(pc_state::pc_com_interrupt_2)
464	464	{
465		pic8259_ir3_w(m_pic8259, state);
	465	m_pic8259->ir3_w(state);
466	466	}
467	467
468	468	const ins8250_interface ibm5150_com_interface[4]=
r22822	r22823
740	740	m_ppi_shift_register = ( m_ppi_shift_register >> 1 ) | ( m_ppi_data_signal << 7 );
741	741	if ( trigger_irq )
742	742	{
743		pic8259_ir1_w(m_pic8259, 1);
	743	m_pic8259->ir1_w(1);
744	744	m_ppi_shift_enable = 0;
745	745	m_ppi_clock_signal = 0;
746	746	m_pc_kbdc->clock_write_from_mb(m_ppi_clock_signal);
r22822	r22823
832	832	/* If PB7 is set clear the shift register and reset the IRQ line */
833	833	if ( m_ppi_keyboard_clear )
834	834	{
835		pic8259_ir1_w(m_pic8259, 0);
	835	m_pic8259->ir1_w(0);
836	836	m_ppi_shift_register = 0;
837	837	m_ppi_shift_enable = 1;
838	838	}
r22822	r22823
945	945	}
946	946
947	947	if (mc1502_keyb.pulsing) {
948		pic8259_ir1_w(m_pic8259, (mc1502_keyb.pulsing & 1));
	948	m_pic8259->ir1_w(mc1502_keyb.pulsing & 1);
949	949	mc1502_keyb.pulsing--;
950	950	}
951	951	}
r22822	r22823
962	962	mc1502_keyb.latch = data;
963	963	if (mc1502_keyb.pulsing)
964	964	mc1502_keyb.pulsing--;
965		pic8259_ir1_w(m_pic8259, 0);
	965	m_pic8259->ir1_w(0);
966	966	}
967	967
968	968	WRITE8_MEMBER(pc_state::mc1502_ppi_portb_w)
r22822	r22823
1146	1146	{
1147	1147	if (m_pic8259)
1148	1148	{
1149		pic8259_ir6_w(m_pic8259, state);
	1149	m_pic8259->ir6_w(state);
1150	1150	}
1151	1151	}
1152	1152
r22822	r22823
1161	1161
1162	1162	switch (irq)
1163	1163	{
1164		case 0: pic8259_ir0_w(st->m_pic8259, state); break;
1165		case 1: pic8259_ir1_w(st->m_pic8259, state); break;
1166		case 2: pic8259_ir2_w(st->m_pic8259, state); break;
1167		case 3: pic8259_ir3_w(st->m_pic8259, state); break;
1168		case 4: pic8259_ir4_w(st->m_pic8259, state); break;
1169		case 5: pic8259_ir5_w(st->m_pic8259, state); break;
1170		case 6: pic8259_ir6_w(st->m_pic8259, state); break;
1171		case 7: pic8259_ir7_w(st->m_pic8259, state); break;
	1164	case 0: st->m_pic8259->ir0_w(state); break;
	1165	case 1: st->m_pic8259->ir1_w(state); break;
	1166	case 2: st->m_pic8259->ir2_w(state); break;
	1167	case 3: st->m_pic8259->ir3_w(state); break;
	1168	case 4: st->m_pic8259->ir4_w(state); break;
	1169	case 5: st->m_pic8259->ir5_w(state); break;
	1170	case 6: st->m_pic8259->ir6_w(state); break;
	1171	case 7: st->m_pic8259->ir7_w(state); break;
1172	1172	}
1173	1173	}
1174	1174
r22822	r22823
1469	1469
1470	1470	IRQ_CALLBACK_MEMBER(pc_state::pc_irq_callback)
1471	1471	{
1472		return pic8259_acknowledge(m_pic8259);
	1472	return m_pic8259->acknowledge();
1473	1473	}
1474	1474
1475	1475
1476	1476	MACHINE_START_MEMBER(pc_state,pc)
1477	1477	{
1478		m_pic8259 = machine().device("pic8259");
	1478	m_pic8259 = machine().device<pic8259_device>("pic8259");
1479	1479	m_pit8253 = machine().device("pit8253");
1480	1480	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc_state::pc_irq_callback),this));
1481	1481
r22822	r22823
1512	1512	{
1513	1513	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc_state::pc_irq_callback),this));
1514	1514
1515		m_pic8259 = machine().device("pic8259");
	1515	m_pic8259 = machine().device<pic8259_device>("pic8259");
1516	1516	m_pit8253 = machine().device("pit8253");
1517	1517
1518	1518	/*
r22822	r22823
1521	1521	40ms (check) for 20ms (check) until all keys are released.
1522	1522	Last pulse causes BIOS to write a 'break' scancode into port 60h.
1523	1523	*/
1524		pic8259_ir1_w(m_pic8259, 1);
	1524	m_pic8259->ir1_w(1);
1525	1525	memset(&mc1502_keyb, 0, sizeof(mc1502_keyb));
1526	1526	mc1502_keyb.keyb_signal_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pc_state::mc1502_keyb_signal_callback),this));
1527	1527	mc1502_keyb.keyb_signal_timer->adjust( attotime::from_msec(20), 0, attotime::from_msec(20) );
r22822	r22823
1542	1542	machine().device<upd765a_device>("upd765")->set_ready_line_connected(false);
1543	1543
1544	1544
1545		m_pic8259 = machine().device("pic8259");
	1545	m_pic8259 = machine().device<pic8259_device>("pic8259");
1546	1546	m_pit8253 = machine().device("pit8253");
1547	1547	}
1548	1548

trunk/src/mess/machine/genpc.c

r22822	r22823
323	323	m_ppi_shift_register = ( m_ppi_shift_register >> 1 ) | ( m_ppi_data_signal << 7 );
324	324	if ( trigger_irq )
325	325	{
326		pic8259_ir1_w(m_pic8259, 1);
	326	m_pic8259->ir1_w(1);
327	327	m_ppi_shift_enable = 0;
328	328	m_ppi_clock_signal = 0;
329	329	m_pc_kbdc->clock_write_from_mb(m_ppi_clock_signal);
r22822	r22823
628	628	void ibm5160_mb_device::device_start()
629	629	{
630	630	install_device(0x0000, 0x000f, 0, 0, read8_delegate(FUNC(am9517a_device::read), (am9517a_device*)m_dma8237), write8_delegate(FUNC(am9517a_device::write), (am9517a_device*)m_dma8237) );
631		install_device(m_pic8259, 0x0020, 0x0021, 0, 0, FUNC(pic8259_r), FUNC(pic8259_w) );
	631	install_device(0x0020, 0x0021, 0, 0, read8_delegate(FUNC(pic8259_device::read), (pic8259_device*)m_pic8259), write8_delegate(FUNC(pic8259_device::write), (pic8259_device*)m_pic8259) );
632	632	install_device(m_pit8253, 0x0040, 0x0043, 0, 0, FUNC(pit8253_r), FUNC(pit8253_w) );
633	633
634	634	//  install_device(m_ppi8255, 0x0060, 0x0063, 0, 0, FUNC(i8255a_r), FUNC(i8255a_w) );

trunk/src/mess/machine/pc9801_118.c

r22822	r22823
38	38	WRITE_LINE_MEMBER(pc9801_118_device::pc9801_sound_irq)
39	39	{
40	40	/* TODO: seems to die very often */
41		pic8259_ir4_w(machine().device("pic8259_slave"), state);
	41	machine().device<pic8259_device>(":pic8259_slave")->ir4_w(state);
42	42	}
43	43
44	44	static const ay8910_interface ay8910_config =

trunk/src/mess/machine/pk8020.c

r22822	r22823
167	167	case 1 : return m_lan->status_r(space,0);
168	168	}
169	169	break;
170		case 0x28: return pic8259_r(m_pic8259,space, offset & 1);
	170	case 0x28: return m_pic8259->read(space, offset & 1);
171	171	case 0x30: return m_ppi8255_2->read(space,offset & 3);
172	172	case 0x38: return m_ppi8255_1->read(space,offset & 3);
173	173	}
r22822	r22823
197	197	case 1 : m_lan->control_w(space,0,data); break;
198	198	}
199	199	break;
200		case 0x28: pic8259_w(m_pic8259,space, offset & 1,data);break;
	200	case 0x28: m_pic8259->write(space, offset & 1,data);break;
201	201	case 0x30: m_ppi8255_2->write(space,offset & 3,data); break;
202	202	case 0x38: m_ppi8255_1->write(space,offset & 3,data); break;
203	203	}
r22822	r22823
955	955
956	956	IRQ_CALLBACK_MEMBER(pk8020_state::pk8020_irq_callback)
957	957	{
958		return pic8259_acknowledge(m_pic8259);
	958	return m_pic8259->acknowledge();
959	959	}
960	960
961	961	void pk8020_state::machine_start()
r22822	r22823
983	983	INTERRUPT_GEN_MEMBER(pk8020_state::pk8020_interrupt)
984	984	{
985	985	m_takt ^= 1;
986		pic8259_ir4_w(m_pic8259, 1);
	986	m_pic8259->ir4_w(1);
987	987	}

trunk/src/mess/machine/pc9801_26.c

r22822	r22823
38	38	WRITE_LINE_MEMBER(pc9801_26_device::pc9801_sound_irq)
39	39	{
40	40	/* TODO: seems to die very often */
41		pic8259_ir4_w(machine().device("pic8259_slave"), state);
	41	machine().device<pic8259_device>(":pic8259_slave")->ir4_w(state);
42	42	}
43	43
44	44	static const ay8910_interface ay8910_config =

trunk/src/mess/machine/southbridge.c

r22822	r22823
194	194	address_space& spaceio = machine().device(":maincpu")->memory().space(AS_IO);
195	195
196	196	spaceio.install_readwrite_handler(0x0000, 0x001f, read8_delegate(FUNC(am9517a_device::read),&(*m_dma8237_1)), write8_delegate(FUNC(am9517a_device::write),&(*m_dma8237_1)), 0xffffffff);
197		spaceio.install_legacy_readwrite_handler(*m_pic8259_master, 0x0020, 0x003f, FUNC(pic8259_r), FUNC(pic8259_w), 0xffffffff);
	197	spaceio.install_readwrite_handler(0x0020, 0x003f, read8_delegate(FUNC(pic8259_device::read),&(*m_pic8259_master)), write8_delegate(FUNC(pic8259_device::write),&(*m_pic8259_master)), 0xffffffff);
198	198	spaceio.install_legacy_readwrite_handler(*m_pit8254, 0x0040, 0x005f, FUNC(pit8253_r), FUNC(pit8253_w), 0xffffffff);
199	199	spaceio.install_readwrite_handler(0x0060, 0x0063, read8_delegate(FUNC(southbridge_device::at_keybc_r),this), write8_delegate(FUNC(southbridge_device::at_keybc_w),this), 0xffffffff);
200	200	spaceio.install_readwrite_handler(0x0064, 0x0067, read8_delegate(FUNC(at_keyboard_controller_device::status_r),&(*m_keybc)), write8_delegate(FUNC(at_keyboard_controller_device::command_w),&(*m_keybc)), 0xffffffff);
201	201	spaceio.install_readwrite_handler(0x0070, 0x007f, read8_delegate(FUNC(mc146818_device::read),&(*m_mc146818)), write8_delegate(FUNC(mc146818_device::write),&(*m_mc146818)), 0xffffffff);
202	202	spaceio.install_readwrite_handler(0x0080, 0x009f, read8_delegate(FUNC(southbridge_device::at_page8_r),this), write8_delegate(FUNC(southbridge_device::at_page8_w),this), 0xffffffff);
203		spaceio.install_legacy_readwrite_handler(*m_pic8259_slave, 0x00a0, 0x00bf, FUNC(pic8259_r), FUNC(pic8259_w), 0xffffffff);
	203	spaceio.install_readwrite_handler(0x00a0, 0x00bf, read8_delegate(FUNC(pic8259_device::read),&(*m_pic8259_slave)), write8_delegate(FUNC(pic8259_device::write),&(*m_pic8259_slave)), 0xffffffff);
204	204	spaceio.install_readwrite_handler(0x00c0, 0x00df, read8_delegate(FUNC(southbridge_device::at_dma8237_2_r),this), write8_delegate(FUNC(southbridge_device::at_dma8237_2_w),this), 0xffffffff);
205	205	spaceio.nop_readwrite(0x00e0, 0x00ef);
206	206
r22822	r22823
460	460
461	461	WRITE_LINE_MEMBER( southbridge_device::at_mc146818_irq )
462	462	{
463		pic8259_ir0_w(m_pic8259_slave, (state) ? 0 : 1);
	463	m_pic8259_slave->ir0_w((state) ? 0 : 1);
464	464	}
465	465
466	466	READ8_MEMBER( southbridge_device::at_dma8237_2_r )

trunk/src/mess/machine/apollo.c

r22822	r22823
599	599	#undef VERBOSE
600	600	#define VERBOSE 0
601	601
602		INLINE device_t *get_pic8259_master(device_t *device) {
	602	INLINE pic8259_device *get_pic8259_master(device_t *device) {
603	603	return device->machine().driver_data<apollo_state>()->pic8259_master;
604	604	}
605	605
606		INLINE device_t *get_pic8259_slave(device_t *device) {
	606	INLINE pic8259_device *get_pic8259_slave(device_t *device) {
607	607	return device->machine().driver_data<apollo_state>()->pic8259_slave;
608	608	}
609	609
r22822	r22823
613	613
614	614	WRITE8_DEVICE_HANDLER(apollo_pic8259_master_w ) {
615	615	DLOG1(("writing %s at offset %X = %02x", device->tag(), offset, data));
616		pic8259_w(device, space, offset, data);
	616	downcast<pic8259_device *>(device)->write(space, offset, data);
617	617	}
618	618
619	619	READ8_DEVICE_HANDLER( apollo_pic8259_master_r ) {
620		UINT8 data = pic8259_r(device, space, offset);
	620	UINT8 data = downcast<pic8259_device *>(device)->read(space, offset);
621	621	DLOG1(("reading %s at offset %X = %02x", device->tag(), offset, data));
622	622	return data;
623	623	}
r22822	r22823
628	628
629	629	WRITE8_DEVICE_HANDLER(apollo_pic8259_slave_w ) {
630	630	DLOG1(("writing %s at offset %X = %02x", device->tag(), offset, data));
631		pic8259_w(device, space, offset, data);
	631	downcast<pic8259_device *>(device)->write(space, offset, data);
632	632	}
633	633
634	634	READ8_DEVICE_HANDLER( apollo_pic8259_slave_r ) {
635		UINT8 data = pic8259_r(device, space, offset);
	635	UINT8 data = downcast<pic8259_device *>(device)->read(space, offset);
636	636	DLOG1(("reading %s at offset %X = %02x", device->tag(), offset, data));
637	637	return data;
638	638	}
r22822	r22823
644	644	}
645	645
646	646	switch (irq) {
647		case 0: pic8259_ir0_w(get_pic8259_master(device), state); break;
648		case 1: pic8259_ir1_w(get_pic8259_master(device), state); break;
649		case 2: pic8259_ir2_w(get_pic8259_master(device), state); break;
650		case 3: pic8259_ir3_w(get_pic8259_master(device), state); break;
651		case 4: pic8259_ir4_w(get_pic8259_master(device), state); break;
652		case 5: pic8259_ir5_w(get_pic8259_master(device), state); break;
653		case 6: pic8259_ir6_w(get_pic8259_master(device), state); break;
654		case 7: pic8259_ir7_w(get_pic8259_master(device), state); break;
	647	case 0: get_pic8259_master(device)->ir0_w(state); break;
	648	case 1: get_pic8259_master(device)->ir1_w(state); break;
	649	case 2: get_pic8259_master(device)->ir2_w(state); break;
	650	case 3: get_pic8259_master(device)->ir3_w(state); break;
	651	case 4: get_pic8259_master(device)->ir4_w(state); break;
	652	case 5: get_pic8259_master(device)->ir5_w(state); break;
	653	case 6: get_pic8259_master(device)->ir6_w(state); break;
	654	case 7: get_pic8259_master(device)->ir7_w(state); break;
655	655
656		case 8: pic8259_ir0_w(get_pic8259_slave(device), state); break;
657		case 9: pic8259_ir1_w(get_pic8259_slave(device), state); break;
658		case 10: pic8259_ir2_w(get_pic8259_slave(device), state); break;
659		case 11: pic8259_ir3_w(get_pic8259_slave(device), state); break;
660		case 12: pic8259_ir4_w(get_pic8259_slave(device), state); break;
661		case 13: pic8259_ir5_w(get_pic8259_slave(device), state); break;
662		case 14: pic8259_ir6_w(get_pic8259_slave(device), state); break;
663		case 15: pic8259_ir7_w(get_pic8259_slave(device), state); break;
	656	case 8: get_pic8259_slave(device)->ir0_w(state); break;
	657	case 9: get_pic8259_slave(device)->ir1_w(state); break;
	658	case 10: get_pic8259_slave(device)->ir2_w(state); break;
	659	case 11: get_pic8259_slave(device)->ir3_w(state); break;
	660	case 12: get_pic8259_slave(device)->ir4_w(state); break;
	661	case 13: get_pic8259_slave(device)->ir5_w(state); break;
	662	case 14: get_pic8259_slave(device)->ir6_w(state); break;
	663	case 15: get_pic8259_slave(device)->ir7_w(state); break;
664	664	}
665	665	}
666	666
667	667	IRQ_CALLBACK_MEMBER(apollo_state::apollo_pic_acknowledge)
668	668	{
669		UINT32 vector = pic8259_acknowledge(get_pic8259_master(&device));
	669	UINT32 vector = get_pic8259_master(&device)->acknowledge();
670	670	if ((vector & 0x0f) == APOLLO_IRQ_PIC_SLAVE) {
671		vector = pic8259_acknowledge(get_pic8259_slave(&device));
	671	vector = get_pic8259_slave(&device)->acknowledge();
672	672	}
673	673
674	674	// don't log ptm interrupts
r22822	r22823
1419	1419
1420	1420	dma8237_1 = machine().device<i8237_device>(APOLLO_DMA1_TAG);
1421	1421	dma8237_2 = machine().device<i8237_device>(APOLLO_DMA2_TAG);
1422		pic8259_master = machine().device(APOLLO_PIC1_TAG);
1423		pic8259_slave = machine().device(APOLLO_PIC2_TAG);
	1422	pic8259_master = machine().device<pic8259_device>(APOLLO_PIC1_TAG);
	1423	pic8259_slave = machine().device<pic8259_device>(APOLLO_PIC2_TAG);
1424	1424
1425	1425	// set configuration
1426	1426	apollo_csr_set_servicemode(apollo_config(APOLLO_CONF_SERVICE_MODE));

trunk/src/mess/includes/b2m.h

r22822	r22823
42	42
43	43	/* devices */
44	44	fd1793_t *m_fdc;
45		device_t *m_pic;
	45	pic8259_device *m_pic;
46	46	required_device<speaker_sound_device> m_speaker;
47	47	required_device<ram_device> m_ram;
48	48	DECLARE_READ8_MEMBER(b2m_keyboard_r);

trunk/src/mess/includes/pk8020.h

r22822	r22823
82	82	required_device<ram_device> m_ram;
83	83	required_device<device_t> m_wd1793;
84	84	required_device<device_t> m_pit8253;
85		required_device<device_t> m_pic8259;
	85	required_device<pic8259_device> m_pic8259;
86	86	required_device<device_t> m_speaker;
87	87	required_memory_region m_region_maincpu;
88	88	required_memory_region m_region_gfx1;

trunk/src/mess/includes/apollo.h

r22822	r22823
25	25	#include "machine/68681.h"
26	26	#include "machine/pc_fdc.h"
27	27	#include "machine/8237dma.h"
	28	#include "machine/pic8259.h"
28	29
29	30	#ifndef VERBOSE
30	31	#define VERBOSE 0
r22822	r22823
123	124
124	125	i8237_device *dma8237_1;
125	126	i8237_device *dma8237_2;
126		device_t *pic8259_master;
127		device_t *pic8259_slave;
	127	pic8259_device *pic8259_master;
	128	pic8259_device *pic8259_slave;
128	129
129	130	DECLARE_WRITE16_MEMBER(apollo_csr_status_register_w);
130	131	DECLARE_READ16_MEMBER(apollo_csr_status_register_r);

trunk/src/mess/includes/pc.h

r22822	r22823
17	17	#include "sound/speaker.h"
18	18	#include "imagedev/cassette.h"
19	19	#include "machine/ram.h"
	20	#include "machine/pic8259.h"
20	21
21	22	class pc_state : public driver_device
22	23	{
r22822	r22823
31	32	m_ram(*this, RAM_TAG) { }
32	33
33	34	required_device<cpu_device> m_maincpu;
34		device_t *m_pic8259;
	35	pic8259_device *m_pic8259;
35	36	optional_device<am9517a_device> m_dma8237;
36	37	device_t *m_pit8253;
37	38	optional_device<pc_kbdc_device>  m_pc_kbdc;

trunk/src/mess/includes/bebox.h

r22822	r22823
15	15	#include "machine/53c810.h"
16	16	#include "machine/upd765.h"
17	17	#include "machine/ram.h"
	18	#include "machine/pic8259.h"
18	19
19	20	struct bebox_devices_t
20	21	{
21		device_t *pic8259_master;
22		device_t *pic8259_slave;
	22	pic8259_device *pic8259_master;
	23	pic8259_device *pic8259_slave;
23	24	i8237_device *dma8237_1;
24	25	i8237_device *dma8237_2;
25	26	};

trunk/src/mess/includes/fmtowns.h

r22822	r22823
90	90	device_t* m_dma_1;
91	91	device_t* m_dma_2;
92	92	device_t* m_fdc;
93		device_t* m_pic_master;
94		device_t* m_pic_slave;
	93	pic8259_device* m_pic_master;
	94	pic8259_device* m_pic_slave;
95	95	device_t* m_pit;
96	96	ram_device* m_messram;
97	97	cdrom_image_device* m_cdrom;

trunk/src/mess/video/pc_t1t.c

r22822	r22823
991	991	{
992	992	pcjr.pc_framecnt++;
993	993	}
994		pic8259_ir5_w(device->machine().device("pic8259"), state);
	994	device->machine().device<pic8259_device>("pic8259")->ir5_w(state);
995	995	}
996	996
997	997	static VIDEO_START( pc_t1t )

trunk/src/mess/video/fmtowns.c

r22822	r22823
466	466
467	467	WRITE8_MEMBER(towns_state::towns_video_5c8_w)
468	468	{
469		device_t* dev = m_pic_slave;
	469	pic8259_device* dev = m_pic_slave;
470	470
471	471	switch(offset)
472	472	{
473	473	case 0x02:  // 0x5ca - VSync clear?
474		pic8259_ir3_w(dev, 0);
	474	dev->ir3_w(0);
475	475	if(IRQ_LOG) logerror("PIC: IRQ11 (VSync) set low\n");
476	476	//towns_vblank_flag = 0;
477	477	break;
r22822	r22823
1767	1767	{
1768	1768	// here we'll clear the vsync signal, I presume it goes low on it's own eventually
1769	1769	device_t* dev = (device_t*)ptr;
1770		pic8259_ir3_w(dev, 0);  // IRQ11 = VSync
	1770	downcast<pic8259_device *>(dev)->ir3_w(0);  // IRQ11 = VSync
1771	1771	if(IRQ_LOG) logerror("PIC: IRQ11 (VSync) set low\n");
1772	1772	m_video.towns_vblank_flag = 0;
1773	1773	}
1774	1774
1775	1775	INTERRUPT_GEN_MEMBER(towns_state::towns_vsync_irq)
1776	1776	{
1777		device_t* dev = m_pic_slave;
1778		pic8259_ir3_w(dev, 1);  // IRQ11 = VSync
	1777	pic8259_device* dev = m_pic_slave;
	1778	dev->ir3_w(1);  // IRQ11 = VSync
1779	1779	if(IRQ_LOG) logerror("PIC: IRQ11 (VSync) set high\n");
1780	1780	m_video.towns_vblank_flag = 1;
1781	1781	machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_end(), timer_expired_delegate(FUNC(towns_state::towns_vblank_end),this), 0, (void*)dev);

trunk/src/mess/drivers/pc9801.c

r22822	r22823
960	960	if(offset & 0x14)
961	961	printf("Read to undefined port [%02x]\n",offset+0x00);
962	962	else
963		return pic8259_r(machine().device((offset & 8) ? "pic8259_slave" : "pic8259_master"), space, (offset & 2) >> 1);
	963	return machine().device<pic8259_device>((offset & 8) ? "pic8259_slave" : "pic8259_master")->read(space, (offset & 2) >> 1);
964	964	}
965	965	else // odd
966	966	{
r22822	r22823
977	977	if(offset & 0x14)
978	978	printf("Write to undefined port [%02x] <- %02x\n",offset+0x00,data);
979	979	else
980		pic8259_w(machine().device((offset & 8) ? "pic8259_slave" : "pic8259_master"), space, (offset & 2) >> 1, data);
	980	machine().device<pic8259_device>((offset & 8) ? "pic8259_slave" : "pic8259_master")->write(space, (offset & 2) >> 1, data);
981	981	}
982	982	else // odd
983	983	{
r22822	r22823
2925	2925	READ8_MEMBER(pc9801_state::get_slave_ack)
2926	2926	{
2927	2927	if (offset==7) { // IRQ = 7
2928		return pic8259_acknowledge( machine().device( "pic8259_slave" ));
	2928	return machine().device<pic8259_device>( "pic8259_slave" )->acknowledge();
2929	2929	}
2930	2930	return 0x00;
2931	2931	}
r22822	r22823
2964	2964	{
2965	2965	MAIN_CLOCK_X1,              /* heartbeat IRQ */
2966	2966	DEVCB_NULL,
2967		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir0_w)
	2967	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir0_w)
2968	2968	}, {
2969	2969	MAIN_CLOCK_X1,              /* Memory Refresh */
2970	2970	DEVCB_NULL,
r22822	r22823
2983	2983	{
2984	2984	MAIN_CLOCK_X2,              /* heartbeat IRQ */
2985	2985	DEVCB_NULL,
2986		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir0_w)
	2986	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir0_w)
2987	2987	}, {
2988	2988	MAIN_CLOCK_X2,              /* Memory Refresh */
2989	2989	DEVCB_NULL,
r22822	r22823
3252	3252	void pc9801_state::fdc_2hd_irq(bool state)
3253	3253	{
3254	3254	//  printf("IRQ 2HD %d\n",state);
3255		pic8259_ir3_w(machine().device("pic8259_slave"), state);
	3255	machine().device<pic8259_device>("pic8259_slave")->ir3_w(state);
3256	3256	}
3257	3257
3258	3258	void pc9801_state::fdc_2hd_drq(bool state)
r22822	r22823
3267	3267
3268	3268	if(m_fdc_2dd_ctrl & 8)
3269	3269	{
3270		pic8259_ir2_w(machine().device("pic8259_slave"), state);
	3270	machine().device<pic8259_device>("pic8259_slave")->ir2_w(state);
3271	3271	}
3272	3272	}
3273	3273
r22822	r22823
3284	3284	//printf("%02x %d\n",m_fdc_ctrl,state);
3285	3285
3286	3286	if(m_fdc_ctrl & 1)
3287		pic8259_ir3_w(machine().device("pic8259_slave"), state);
	3287	machine().device<pic8259_device>("pic8259_slave")->ir3_w(state);
3288	3288	else
3289		pic8259_ir2_w(machine().device("pic8259_slave"), state);
	3289	machine().device<pic8259_device>("pic8259_slave")->ir2_w(state);
3290	3290	}
3291	3291
3292	3292	void pc9801_state::pc9801rs_fdc_drq(bool state)
r22822	r22823
3337	3337
3338	3338	IRQ_CALLBACK_MEMBER(pc9801_state::irq_callback)
3339	3339	{
3340		return pic8259_acknowledge( machine().device( "pic8259_master" ));
	3340	return machine().device<pic8259_device>( "pic8259_master" )->acknowledge();
3341	3341	}
3342	3342
3343	3343	MACHINE_START_MEMBER(pc9801_state,pc9801_common)
r22822	r22823
3497	3497	{
3498	3498	if(m_vrtc_irq_mask)
3499	3499	{
3500		pic8259_ir2_w(machine().device("pic8259_master"), 0);
3501		pic8259_ir2_w(machine().device("pic8259_master"), 1);
	3500	machine().device<pic8259_device>("pic8259_master")->ir2_w(0);
	3501	machine().device<pic8259_device>("pic8259_master")->ir2_w(1);
3502	3502	m_vrtc_irq_mask = 0; // TODO: this irq auto-masks?
3503	3503	}
3504	3504	//  else
r22822	r22823
3521	3521	{
3522	3522	//          printf("irq %02x\n",m_mouse.freq_reg);
3523	3523	m_mouse.freq_index = 0;
3524		pic8259_ir5_w(machine().device("pic8259_slave"), 0);
3525		pic8259_ir5_w(machine().device("pic8259_slave"), 1);
	3524	machine().device<pic8259_device>("pic8259_slave")->ir5_w(0);
	3525	machine().device<pic8259_device>("pic8259_slave")->ir5_w(1);
3526	3526	}
3527	3527	}
3528	3528	}
3529	3529
3530	3530	WRITE_LINE_MEMBER( pc9801_state::keyboard_irq )
3531	3531	{
3532		pic8259_ir1_w(machine().device("pic8259_master"), state);
	3532	machine().device<pic8259_device>("pic8259_master")->ir1_w(state);
3533	3533	}
3534	3534
3535	3535	static PC9801_KBD_INTERFACE( pc9801_keyboard_intf )

trunk/src/mess/drivers/bebox.c

r22822	r22823
47	47	AM_RANGE(0x7FFFF4F0, 0x7FFFF4F7) AM_WRITE(bebox_processor_resets_w )
48	48
49	49	AM_RANGE(0x80000000, 0x8000001F) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, U64(0xffffffffffffffff) )
50		AM_RANGE(0x80000020, 0x8000003F) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, U64(0xffffffffffffffff) )
	50	AM_RANGE(0x80000020, 0x8000003F) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, U64(0xffffffffffffffff) )
51	51	AM_RANGE(0x80000040, 0x8000005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, U64(0xffffffffffffffff) )
52	52	AM_RANGE(0x80000060, 0x8000006F) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, U64(0xffffffffffffffff) )
53	53	AM_RANGE(0x80000070, 0x8000007F) AM_DEVREADWRITE8("rtc", mc146818_device, read, write , U64(0xffffffffffffffff) )
54	54	AM_RANGE(0x80000080, 0x8000009F) AM_READWRITE8(bebox_page_r, bebox_page_w, U64(0xffffffffffffffff) )
55		AM_RANGE(0x800000A0, 0x800000BF) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, U64(0xffffffffffffffff) )
	55	AM_RANGE(0x800000A0, 0x800000BF) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, U64(0xffffffffffffffff) )
56	56	AM_RANGE(0x800000C0, 0x800000DF) AM_READWRITE8(at_dma8237_1_r, at_dma8237_1_w, U64(0xffffffffffffffff))
57	57	AM_RANGE(0x800001F0, 0x800001F7) AM_READWRITE8(bebox_800001F0_r, bebox_800001F0_w, U64(0xffffffffffffffff) )
58	58	AM_RANGE(0x800002F8, 0x800002FF) AM_DEVREADWRITE8( "ns16550_1", ns16550_device, ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
r22822	r22823
155	155	{
156	156	bebox_set_irq_bit(machine(), 16, state);
157	157	if ( m_devices.pic8259_master ) {
158		pic8259_ir1_w(m_devices.pic8259_master, state);
	158	m_devices.pic8259_master->ir1_w(state);
159	159	}
160	160	}
161	161

trunk/src/mess/drivers/iq151.c

r22822	r22823
213	213	ADDRESS_MAP_GLOBAL_MASK(0xff)
214	214	AM_RANGE( 0x80, 0x80 ) AM_WRITE(boot_bank_w)
215	215	AM_RANGE( 0x84, 0x87 ) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)
216		AM_RANGE( 0x88, 0x89 ) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w )
	216	AM_RANGE( 0x88, 0x89 ) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
217	217
218	218	AM_RANGE( 0x00, 0xff ) AM_READWRITE(cartslot_io_r, cartslot_io_w)
219	219	ADDRESS_MAP_END

trunk/src/mess/drivers/paso1600.c

r22822	r22823
231	231	static ADDRESS_MAP_START(paso1600_io, AS_IO, 16, paso1600_state)
232	232	ADDRESS_MAP_UNMAP_LOW
233	233	AM_RANGE(0x0000,0x000f) AM_DEVREADWRITE8("8237dma", i8237_device, i8237_r, i8237_w, 0xffff)
234		AM_RANGE(0x0010,0x0011) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r,pic8259_w, 0xffff) // i8259
	234	AM_RANGE(0x0010,0x0011) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff) // i8259
235	235	AM_RANGE(0x001a,0x001b) AM_READ(test_hi_r) // causes RAM error otherwise?
236	236	AM_RANGE(0x0030,0x0033) AM_READWRITE8(key_r,key_w,0xffff) //UART keyboard?
237	237	AM_RANGE(0x0048,0x0049) AM_READ(test_hi_r)
r22822	r22823
277	277
278	278	IRQ_CALLBACK_MEMBER(paso1600_state::paso1600_irq_callback)
279	279	{
280		return pic8259_acknowledge( machine().device( "pic8259" ) );
	280	return machine().device<pic8259_device>( "pic8259" )->acknowledge();
281	281	}
282	282
283	283	WRITE_LINE_MEMBER( paso1600_state::paso1600_set_int_line )

trunk/src/mess/drivers/victor9k.c

r22822	r22823
36	36
37	37	static ADDRESS_MAP_START( victor9k_mem, AS_PROGRAM, 8, victor9k_state )
38	38	//  AM_RANGE(0x00000, 0xdffff) AM_RAM
39		AM_RANGE(0xe0000, 0xe0001) AM_DEVREADWRITE_LEGACY(I8259A_TAG, pic8259_r, pic8259_w)
	39	AM_RANGE(0xe0000, 0xe0001) AM_DEVREADWRITE(I8259A_TAG, pic8259_device, read, write)
40	40	AM_RANGE(0xe0020, 0xe0023) AM_DEVREADWRITE_LEGACY(I8253_TAG, pit8253_r, pit8253_w)
41	41	AM_RANGE(0xe0040, 0xe0043) AM_DEVREADWRITE(UPD7201_TAG, upd7201_device, cd_ba_r, cd_ba_w)
42	42	AM_RANGE(0xe8000, 0xe8000) AM_DEVREADWRITE(HD46505S_TAG, mc6845_device, status_r, address_w)
r22822	r22823
180	180
181	181	static UPD7201_INTERFACE( mpsc_intf )
182	182	{
183		DEVCB_DEVICE_LINE(I8259A_TAG, pic8259_ir1_w), // interrupt
	183	DEVCB_DEVICE_LINE_MEMBER(I8259A_TAG, pic8259_device, ir1_w), // interrupt
184	184	{
185	185	{
186	186	0,                  // receive clock

trunk/src/mess/drivers/at.c

r22822	r22823
95	95	static ADDRESS_MAP_START( at16_io, AS_IO, 16, at_state )
96	96	ADDRESS_MAP_UNMAP_HIGH
97	97	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", am9517a_device, read, write, 0xffff)
98		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0xffff)
	98	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0xffff)
99	99	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffff)
100	100	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(at_keybc_r, at_keybc_w, 0xffff)
101	101	AM_RANGE(0x0064, 0x0067) AM_DEVREADWRITE8("keybc", at_keyboard_controller_device, status_r, command_w, 0xffff)
102	102	AM_RANGE(0x0070, 0x007f) AM_DEVREAD8("rtc", mc146818_device, read, 0xffff) AM_WRITE8(write_rtc , 0xffff)
103	103	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffff)
104		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffff)
	104	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffff)
105	105	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffff)
106	106	ADDRESS_MAP_END
107	107
r22822	r22823
126	126	static ADDRESS_MAP_START( neat_io, AS_IO, 16, at_state )
127	127	ADDRESS_MAP_UNMAP_HIGH
128	128	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", am9517a_device, read, write, 0xffff)
129		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0xffff)
	129	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0xffff)
130	130	AM_RANGE(0x0022, 0x0023) AM_READWRITE(neat_chipset_r, neat_chipset_w)
131	131	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffff)
132	132	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(at_keybc_r, at_keybc_w, 0xffff)
133	133	AM_RANGE(0x0064, 0x0067) AM_DEVREADWRITE8("keybc", at_keyboard_controller_device, status_r, command_w, 0xffff)
134	134	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write , 0xffff)
135	135	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffff)
136		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffff)
	136	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffff)
137	137	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffff)
138	138	ADDRESS_MAP_END
139	139
140	140	static ADDRESS_MAP_START( at386_io, AS_IO, 32, at_state )
141	141	ADDRESS_MAP_UNMAP_HIGH
142	142	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", am9517a_device, read, write, 0xffffffff)
143		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0xffffffff)
	143	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0xffffffff)
144	144	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
145	145	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(at_keybc_r, at_keybc_w, 0xffff)
146	146	AM_RANGE(0x0064, 0x0067) AM_DEVREADWRITE8("keybc", at_keyboard_controller_device, status_r, command_w, 0xffff)
147	147	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write , 0xffffffff)
148	148	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
149		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffffffff)
	149	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffffffff)
150	150	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
151	151	ADDRESS_MAP_END
152	152
r22822	r22823
154	154	READ32_MEMBER( at_state::ct486_chipset_r )
155	155	{
156	156	if (ACCESSING_BITS_0_7)
157		return pic8259_r(m_pic8259_master, space, 0);
	157	return m_pic8259_master->read(space, 0);
158	158
159	159	if (ACCESSING_BITS_8_15)
160		return pic8259_r(m_pic8259_master, space, 1) << 8;
	160	return m_pic8259_master->read(space, 1) << 8;
161	161
162	162	if (ACCESSING_BITS_24_31)
163	163	return m_cs4031->data_r(space, 0, 0) << 24;
r22822	r22823
168	168	WRITE32_MEMBER( at_state::ct486_chipset_w )
169	169	{
170	170	if (ACCESSING_BITS_0_7)
171		pic8259_w(m_pic8259_master, space, 0, data);
	171	m_pic8259_master->write(space, 0, data);
172	172
173	173	if (ACCESSING_BITS_8_15)
174		pic8259_w(m_pic8259_master, space, 1, data >> 8);
	174	m_pic8259_master->write(space, 1, data >> 8);
175	175
176	176	if (ACCESSING_BITS_16_23)
177	177	m_cs4031->address_w(space, 0, data >> 16, 0);
r22822	r22823
189	189	AM_RANGE(0x0064, 0x0067) AM_DEVREADWRITE8("keybc", at_keyboard_controller_device, status_r, command_w, 0xffff)
190	190	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write , 0xffffffff)
191	191	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
192		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffffffff)
	192	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffffffff)
193	193	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
194	194	ADDRESS_MAP_END
195	195
r22822	r22823
202	202	static ADDRESS_MAP_START( megapc_io, AS_IO, 32, at_state )
203	203	ADDRESS_MAP_UNMAP_HIGH
204	204	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", am9517a_device, read, write, 0xffffffff)
205		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0xffffffff)
	205	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0xffffffff)
206	206	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
207	207	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(at_keybc_r, at_keybc_w, 0xffff) // TODO: is this the correct type?
208	208	AM_RANGE(0x0064, 0x0067) AM_DEVREADWRITE8("keybc", at_keyboard_controller_device, status_r, command_w, 0xffff)
209	209	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write , 0xffffffff)
210	210	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
211		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffffffff)
	211	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffffffff)
212	212	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
213	213	ADDRESS_MAP_END
214	214

trunk/src/mess/drivers/compis.c

r22822	r22823
163	163	AM_RANGE( 0x0000, 0x0007) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xff00)
164	164	AM_RANGE( 0x0080, 0x0087) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
165	165	AM_RANGE( 0x0100, 0x011b) AM_DEVREADWRITE8_LEGACY("mm58274c", mm58274c_r, mm58274c_w, 0xffff)
166		AM_RANGE( 0x0280, 0x0283) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0xffff) /* 80150/80130 */
	166	AM_RANGE( 0x0280, 0x0283) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0xffff) /* 80150/80130 */
167	167	//AM_RANGE( 0x0288, 0x028f) AM_DEVREADWRITE_LEGACY("pit8254", compis_osp_pit_r, compis_osp_pit_w ) /* PIT 8254 (80150/80130)  */
168	168	AM_RANGE( 0x0310, 0x031f) AM_READWRITE( compis_usart_r, compis_usart_w )    /* USART 8251 Keyboard      */
169	169	AM_RANGE( 0x0330, 0x0333) AM_DEVREADWRITE8("upd7220", upd7220_device, read, write, 0x00ff) /* GDC 82720 PCS6:6     */

trunk/src/mess/drivers/apricot.c

r22822	r22823
125	125
126	126	WRITE_LINE_MEMBER(apricot_state::apricot_sio_irq_w)
127	127	{
128		pic8259_ir5_w(m_pic, state);
	128	m_pic->ir5_w(state);
129	129	}
130	130
131	131	static const z80sio_interface apricot_z80sio_intf =
r22822	r22823
162	162
163	163	WRITE_LINE_MEMBER( apricot_state::apricot_wd2793_intrq_w )
164	164	{
165		pic8259_ir4_w(m_pic, state);
	165	m_pic->ir4_w(state);
166	166	//  i8089 external terminate channel 1
167	167	}
168	168
r22822	r22823
285	285	ADDRESS_MAP_END
286	286
287	287	static ADDRESS_MAP_START( apricot_io, AS_IO, 16, apricot_state )
288		AM_RANGE(0x00, 0x03) AM_DEVREADWRITE8_LEGACY("ic31", pic8259_r, pic8259_w, 0x00ff)
	288	AM_RANGE(0x00, 0x03) AM_DEVREADWRITE8("ic31", pic8259_device, read, write, 0x00ff)
289	289	AM_RANGE(0x40, 0x47) AM_DEVREADWRITE8_LEGACY("ic68", wd17xx_r, wd17xx_w, 0x00ff)
290	290	AM_RANGE(0x48, 0x4f) AM_DEVREADWRITE8("ic17", i8255_device, read, write, 0x00ff)
291	291	AM_RANGE(0x50, 0x51) AM_MIRROR(0x06) AM_DEVWRITE8("ic7", sn76489_device, write, 0x00ff)

trunk/src/mess/drivers/z100.c

r22822	r22823
409	409	//  AM_RANGE (0xe4, 0xe7) 8253 PIT
410	410	//  AM_RANGE (0xe8, 0xeb) First 2661-2 serial port (printer)
411	411	//  AM_RANGE (0xec, 0xef) Second 2661-2 serial port (modem)
412		AM_RANGE (0xf0, 0xf1) AM_DEVREADWRITE_LEGACY("pic8259_slave", pic8259_r, pic8259_w)
413		AM_RANGE (0xf2, 0xf3) AM_DEVREADWRITE_LEGACY("pic8259_master", pic8259_r, pic8259_w)
	412	AM_RANGE (0xf0, 0xf1) AM_DEVREADWRITE("pic8259_slave", pic8259_device, read, write)
	413	AM_RANGE (0xf2, 0xf3) AM_DEVREADWRITE("pic8259_master", pic8259_device, read, write)
414	414	AM_RANGE (0xf4, 0xf4) AM_READ(keyb_data_r) // -> 8041 MCU
415	415	AM_RANGE (0xf5, 0xf5) AM_READWRITE(keyb_status_r,keyb_command_w)
416	416	//  AM_RANGE (0xf6, 0xf6) expansion ROM is present (bit 0, active low)

trunk/src/mess/drivers/tsispch.c

r22822	r22823
129	129	*****************************************************************************/
130	130	WRITE_LINE_MEMBER(tsispch_state::i8251_rxrdy_int)
131	131	{
132		pic8259_ir1_w(machine().device("pic8259"), state);
	132	machine().device<pic8259_device>("pic8259")->ir1_w(state);
133	133	}
134	134
135	135	WRITE_LINE_MEMBER(tsispch_state::i8251_txempty_int)
136	136	{
137		pic8259_ir2_w(machine().device("pic8259"), state);
	137	machine().device<pic8259_device>("pic8259")->ir2_w(state);
138	138	}
139	139
140	140	WRITE_LINE_MEMBER(tsispch_state::i8251_txrdy_int)
141	141	{
142		pic8259_ir3_w(machine().device("pic8259"), state);
	142	machine().device<pic8259_device>("pic8259")->ir3_w(state);
143	143	}
144	144
145	145	const i8251_interface i8251_config =
r22822	r22823
182	182
183	183	IRQ_CALLBACK_MEMBER(tsispch_state::irq_callback)
184	184	{
185		return pic8259_acknowledge(machine().device("pic8259"));
	185	return machine().device<pic8259_device>("pic8259")->acknowledge();
186	186	}
187	187
188	188	/*****************************************************************************
r22822	r22823
347	347	AM_RANGE(0x00000, 0x02FFF) AM_MIRROR(0x34000) AM_RAM // verified; 6264*2 sram, only first 3/4 used
348	348	AM_RANGE(0x03000, 0x03001) AM_MIRROR(0x341FC) AM_DEVREADWRITE8("i8251a_u15", i8251_device, data_r, data_w, 0x00FF)
349	349	AM_RANGE(0x03002, 0x03003) AM_MIRROR(0x341FC) AM_DEVREADWRITE8("i8251a_u15", i8251_device, status_r, control_w, 0x00FF)
350		AM_RANGE(0x03200, 0x03203) AM_MIRROR(0x341FC) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0x00FF) // AMD P8259 PIC @ U5 (reads as 04 and 7c, upper byte is open bus)
	350	AM_RANGE(0x03200, 0x03203) AM_MIRROR(0x341FC) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0x00FF) // AMD P8259 PIC @ U5 (reads as 04 and 7c, upper byte is open bus)
351	351	AM_RANGE(0x03400, 0x03401) AM_MIRROR(0x341FE) AM_READ8(dsw_r, 0x00FF) // verified, read from dipswitch s4
352	352	AM_RANGE(0x03400, 0x03401) AM_MIRROR(0x341FE) AM_WRITE8(peripheral_w, 0xFF00) // verified, write to the 4 leds, plus 4 control bits
353	353	AM_RANGE(0x03600, 0x03601) AM_MIRROR(0x341FC) AM_READWRITE(dsp_data_r, dsp_data_w) // verified; UPD77P20 data reg r/w

trunk/src/mess/drivers/b2m.c

r22822	r22823
35	35	AM_RANGE(0x08, 0x0b) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write)
36	36	AM_RANGE(0x0c, 0x0c) AM_READWRITE(b2m_localmachine_r,b2m_localmachine_w)
37	37	AM_RANGE(0x10, 0x13) AM_READWRITE(b2m_palette_r,b2m_palette_w)
38		AM_RANGE(0x14, 0x15) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w )
	38	AM_RANGE(0x14, 0x15) AM_DEVREADWRITE("pic8259", pic8259_device, read, write )
39	39	AM_RANGE(0x18, 0x18) AM_DEVREADWRITE("uart", i8251_device, data_r, data_w)
40	40	AM_RANGE(0x19, 0x19) AM_DEVREADWRITE("uart", i8251_device, status_r, control_w)
41	41	AM_RANGE(0x1c, 0x1f) AM_DEVREADWRITE("fd1793", fd1793_t, read, write)
r22822	r22823
48	48	AM_RANGE(0x08, 0x0b) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write)
49	49	AM_RANGE(0x0c, 0x0c) AM_READWRITE(b2m_localmachine_r,b2m_localmachine_w)
50	50	AM_RANGE(0x10, 0x13) AM_READWRITE(b2m_palette_r,b2m_palette_w)
51		AM_RANGE(0x14, 0x15) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w )
	51	AM_RANGE(0x14, 0x15) AM_DEVREADWRITE("pic8259", pic8259_device, read, write )
52	52	AM_RANGE(0x18, 0x18) AM_DEVREADWRITE("uart", i8251_device, data_r, data_w)
53	53	AM_RANGE(0x19, 0x19) AM_DEVREADWRITE("uart", i8251_device, status_r, control_w)
54	54	ADDRESS_MAP_END

trunk/src/mess/drivers/pc.c

r22822	r22823
152	152	ADDRESS_MAP_END
153	153
154	154	static ADDRESS_MAP_START(mc1502_io, AS_IO, 8, pc_state )
155		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	155	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
156	156	AM_RANGE(0x0028, 0x0028) AM_DEVREADWRITE("upd8251", i8251_device, data_r, data_w)   // not working yet
157	157	AM_RANGE(0x0029, 0x0029) AM_DEVREADWRITE("upd8251", i8251_device, status_r, control_w)
158	158	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)
r22822	r22823
190	190	static ADDRESS_MAP_START(pc8_io, AS_IO, 8, pc_state )
191	191	ADDRESS_MAP_UNMAP_HIGH
192	192	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE("dma8237", am9517a_device, read, write)
193		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	193	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
194	194	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)
195	195	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)
196	196	AM_RANGE(0x0080, 0x0087) AM_READWRITE(pc_page_r,            pc_page_w)
r22822	r22823
215	215	static ADDRESS_MAP_START(pc16_io, AS_IO, 16, pc_state )
216	216	ADDRESS_MAP_UNMAP_HIGH
217	217	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
218		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	218	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
219	219	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
220	220	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xffff)
221	221	AM_RANGE(0x0070, 0x007f) AM_RAM // needed for Poisk-2
r22822	r22823
238	238	static ADDRESS_MAP_START(ec1841_io, AS_IO, 16, pc_state)
239	239	ADDRESS_MAP_UNMAP_HIGH
240	240	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
241		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	241	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
242	242	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
243	243	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xffff)
244	244	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
259	259	static ADDRESS_MAP_START(iskr1031_io, AS_IO, 16, pc_state)
260	260	ADDRESS_MAP_UNMAP_HIGH
261	261	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
262		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	262	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
263	263	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
264	264	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xffff)
265	265	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
277	277
278	278	static ADDRESS_MAP_START(asst128_io, AS_IO, 16, pc_state)
279	279	ADDRESS_MAP_UNMAP_HIGH
280		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	280	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
281	281	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
282	282	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xffff)
283	283	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
309	309	static ADDRESS_MAP_START(ibm5550_io, AS_IO, 16, pc_state )
310	310	ADDRESS_MAP_UNMAP_HIGH
311	311	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
312		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	312	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
313	313	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
314	314	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE8("ppi8255", i8255_device, read, write, 0xffff)
315	315	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
341	341
342	342	static ADDRESS_MAP_START(europc_io, AS_IO, 8, europc_pc_state )
343	343	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE("dma8237", am9517a_device, read, write)
344		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	344	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
345	345	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)
346	346	AM_RANGE(0x0060, 0x0063) AM_READWRITE(europc_pio_r,          europc_pio_w)
347	347	AM_RANGE(0x0080, 0x0087) AM_READWRITE(pc_page_r,            pc_page_w)
r22822	r22823
375	375
376	376	static ADDRESS_MAP_START(tandy1000_io, AS_IO, 8, tandy_pc_state )
377	377	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE("dma8237", am9517a_device, read, write)
378		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	378	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
379	379	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)
380	380	AM_RANGE(0x0060, 0x0063) AM_READWRITE(tandy1000_pio_r,           tandy1000_pio_w)
381	381	AM_RANGE(0x0080, 0x0087) AM_READWRITE(pc_page_r,                pc_page_w)
r22822	r22823
405	405
406	406	static ADDRESS_MAP_START(tandy1000_16_io, AS_IO, 16, tandy_pc_state )
407	407	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
408		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	408	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
409	409	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
410	410	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(tandy1000_pio_r,          tandy1000_pio_w, 0xffff)
411	411	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
437	437
438	438	static ADDRESS_MAP_START(tandy1000_286_io, AS_IO, 16, tandy_pc_state )
439	439	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
440		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	440	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
441	441	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
442	442	AM_RANGE(0x0060, 0x0063) AM_READWRITE8(tandy1000_pio_r,         tandy1000_pio_w, 0xffff)
443	443	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r,               pc_page_w, 0xffff)
r22822	r22823
466	466
467	467
468	468	static ADDRESS_MAP_START(ibmpcjr_io, AS_IO, 8, tandy_pc_state )
469		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	469	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
470	470	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)
471	471	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)
472	472	AM_RANGE(0x0080, 0x0087) AM_READWRITE(pc_page_r,                pc_page_w)

trunk/src/mess/drivers/amstr_pc.c

r22822	r22823
80	80
81	81	static ADDRESS_MAP_START(ppc512_io, AS_IO, 16, amstrad_pc_state )
82	82	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
83		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	83	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
84	84	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
85	85	AM_RANGE(0x0060, 0x0065) AM_READWRITE8(pc1640_port60_r, pc1640_port60_w, 0xffff)
86	86	AM_RANGE(0x0070, 0x0071) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffff)
r22822	r22823
109	109
110	110	static ADDRESS_MAP_START(pc200_io, AS_IO, 16, amstrad_pc_state )
111	111	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
112		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff)
	112	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
113	113	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8253", pit8253_r, pit8253_w, 0xffff)
114	114	AM_RANGE(0x0060, 0x0065) AM_READWRITE8(pc1640_port60_r, pc1640_port60_w, 0xffff)
115	115	AM_RANGE(0x0078, 0x0079) AM_READWRITE8(pc1640_mouse_x_r, pc1640_mouse_x_w, 0xffff)

trunk/src/mess/drivers/fmtowns.c

r22822	r22823
487	487	{
488	488	if(m_towns_fdc_irq6mask == 0)
489	489	state = 0;
490		pic8259_ir6_w(m_pic_master, state);  // IRQ6 = FDC
	490	m_pic_master->ir6_w(state);  // IRQ6 = FDC
491	491	if(IRQ_LOG) logerror("PIC: IRQ6 (FDC) set to %i\n",state);
492	492	}
493	493
r22822	r22823
671	671	m_towns_kb_status |= 0x01;
672	672	if(m_towns_kb_irq1_enable)
673	673	{
674		pic8259_ir1_w(m_pic_master, 1);
	674	m_pic_master->ir1_w(1);
675	675	if(IRQ_LOG) logerror("PIC: IRQ1 (keyboard) set high\n");
676	676	}
677	677	logerror("KB: sending scancode 0x%02x\n",scancode);
r22822	r22823
712	712	case 0:  // scancode output
713	713	ret = m_towns_kb_output;
714	714	//logerror("KB: read keyboard output port, returning %02x\n",ret);
715		pic8259_ir1_w(m_pic_master, 0);
	715	m_pic_master->ir1_w(0);
716	716	if(IRQ_LOG) logerror("PIC: IRQ1 (keyboard) set low\n");
717	717	if(m_towns_kb_extend != 0xff)
718	718	{
r22822	r22823
793	793
794	794	WRITE8_MEMBER(towns_state::towns_port60_w)
795	795	{
796		device_t* dev = m_pic_master;
	796	//device_t* dev = m_pic_master;
797	797
798	798	if(data & 0x80)
799	799	{
800	800	//towns_pic_irq(dev,0);
801	801	m_timer0 = 0;
802		pic8259_ir0_w(dev, m_timer0 || m_timer1);
	802	m_pic_master->ir0_w(m_timer0 || m_timer1);
803	803	}
804	804	m_towns_timer_mask = data & 0x07;
805	805
r22822	r22823
859	859	m_towns_pcm_irq_flag = 0;
860	860	if(m_towns_fm_irq_flag == 0)
861	861	{
862		pic8259_ir5_w(m_pic_slave, 0);
	862	m_pic_slave->ir5_w(0);
863	863	if(IRQ_LOG) logerror("PIC: IRQ13 (PCM) set low\n");
864	864	}
865	865	break;
r22822	r22823
1321	1321	//                  if(m_towns_cd.mpu_irq_enable)
1322	1322	{
1323	1323	m_towns_cd.status |= 0x80;
1324		pic8259_ir1_w(m_pic_slave, 1);
	1324	m_pic_slave->ir1_w(1);
1325	1325	if(IRQ_LOG) logerror("PIC: IRQ9 (CD-ROM) set high\n");
1326	1326	}
1327	1327	}
r22822	r22823
1331	1331	else
1332	1332	{
1333	1333	m_towns_cd.status &= ~0x80;
1334		pic8259_ir1_w(m_pic_slave, 0);
	1334	m_pic_slave->ir1_w(0);
1335	1335	if(IRQ_LOG) logerror("PIC: IRQ9 (CD-ROM) set low\n");
1336	1336	}
1337	1337	break;
r22822	r22823
1343	1343	//                  if(m_towns_cd.dma_irq_enable)
1344	1344	{
1345	1345	m_towns_cd.status |= 0x40;
1346		pic8259_ir1_w(m_pic_slave, 1);
	1346	m_pic_slave->ir1_w(1);
1347	1347	if(IRQ_LOG) logerror("PIC: IRQ9 (CD-ROM DMA) set high\n");
1348	1348	}
1349	1349	}
r22822	r22823
1353	1353	else
1354	1354	{
1355	1355	m_towns_cd.status &= ~0x40;
1356		pic8259_ir1_w(m_pic_slave, 0);
	1356	m_pic_slave->ir1_w(0);
1357	1357	if(IRQ_LOG) logerror("PIC: IRQ9 (CD-ROM DMA) set low\n");
1358	1358	}
1359	1359	break;
r22822	r22823
1986	1986
1987	1987	WRITE_LINE_MEMBER(towns_state::towns_scsi_irq)
1988	1988	{
1989		pic8259_ir0_w(m_pic_slave, state);
	1989	m_pic_slave->ir0_w(state);
1990	1990	if(IRQ_LOG)
1991	1991	logerror("PIC: IRQ8 (SCSI) set to %i\n",state);
1992	1992	}
r22822	r22823
2051	2051
2052	2052	IRQ_CALLBACK_MEMBER(towns_state::towns_irq_callback)
2053	2053	{
2054		return pic8259_acknowledge(m_pic_master);
	2054	return m_pic_master->acknowledge();
2055	2055	}
2056	2056
2057	2057	// YM3438 interrupt (IRQ 13)
r22822	r22823
2060	2060	if(state)
2061	2061	{
2062	2062	m_towns_fm_irq_flag = 1;
2063		pic8259_ir5_w(m_pic_slave, 1);
	2063	m_pic_slave->ir5_w(1);
2064	2064	if(IRQ_LOG) logerror("PIC: IRQ13 (FM) set high\n");
2065	2065	}
2066	2066	else
r22822	r22823
2068	2068	m_towns_fm_irq_flag = 0;
2069	2069	if(m_towns_pcm_irq_flag == 0)
2070	2070	{
2071		pic8259_ir5_w(m_pic_slave, 0);
	2071	m_pic_slave->ir5_w(0);
2072	2072	if(IRQ_LOG) logerror("PIC: IRQ13 (FM) set low\n");
2073	2073	}
2074	2074	}
r22822	r22823
2078	2078	static void towns_pcm_irq(device_t* device, int channel)
2079	2079	{
2080	2080	towns_state* state = device->machine().driver_data<towns_state>();
2081		device_t* pic = state->m_pic_slave;
	2081	pic8259_device* pic = state->m_pic_slave;
2082	2082
2083	2083	if(state->m_towns_pcm_channel_mask & (1 << channel))
2084	2084	{
2085	2085	state->m_towns_pcm_irq_flag = 1;
2086	2086	state->m_towns_pcm_channel_flag |= (1 << channel);
2087		pic8259_ir5_w(pic, 1);
	2087	pic->ir5_w(1);
2088	2088	if(IRQ_LOG) logerror("PIC: IRQ13 (PCM) set high (channel %i)\n",channel);
2089	2089	}
2090	2090	}
r22822	r22823
2097	2097
2098	2098	WRITE_LINE_MEMBER(towns_state::towns_pit_out0_changed)
2099	2099	{
2100		device_t* dev = m_pic_master;
	2100	pic8259_device* dev = m_pic_master;
2101	2101
2102	2102	if(m_towns_timer_mask & 0x01)
2103	2103	{
r22822	r22823
2107	2107	else
2108	2108	m_timer0 = 0;
2109	2109
2110		pic8259_ir0_w(dev, m_timer0 || m_timer1);
	2110	dev->ir0_w(m_timer0 || m_timer1);
2111	2111	}
2112	2112
2113	2113	WRITE_LINE_MEMBER(towns_state::towns_pit_out1_changed)
2114	2114	{
2115		device_t* dev = m_pic_master;
	2115	pic8259_device* dev = m_pic_master;
2116	2116
2117	2117	if(m_towns_timer_mask & 0x02)
2118	2118	{
r22822	r22823
2122	2122	else
2123	2123	m_timer1 = 0;
2124	2124
2125		pic8259_ir0_w(dev, m_timer0 || m_timer1);
	2125	dev->ir0_w(m_timer0 || m_timer1);
2126	2126	}
2127	2127
2128	2128	WRITE_LINE_MEMBER( towns_state::pit_out2_changed )
r22822	r22823
2213	2213	// I/O ports derived from FM Towns/Bochs, these are specific to the FM Towns
2214	2214	// System ports
2215	2215	ADDRESS_MAP_UNMAP_HIGH
2216		AM_RANGE(0x0000,0x0003) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0x00ff00ff)
2217		AM_RANGE(0x0010,0x0013) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0x00ff00ff)
	2216	AM_RANGE(0x0000,0x0003) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0x00ff00ff)
	2217	AM_RANGE(0x0010,0x0013) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0x00ff00ff)
2218	2218	AM_RANGE(0x0020,0x0033) AM_READWRITE8(towns_system_r,towns_system_w, 0xffffffff)
2219	2219	AM_RANGE(0x0040,0x0047) AM_DEVREADWRITE8_LEGACY("pit",pit8253_r, pit8253_w, 0x00ff00ff)
2220	2220	AM_RANGE(0x0050,0x0057) AM_DEVREADWRITE8_LEGACY("pit2",pit8253_r, pit8253_w, 0x00ff00ff)
r22822	r22823
2265	2265	static ADDRESS_MAP_START( towns16_io , AS_IO, 16, towns_state)  // for the 386SX based systems
2266	2266	// System ports
2267	2267	ADDRESS_MAP_UNMAP_HIGH
2268		AM_RANGE(0x0000,0x0003) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0x00ff)
2269		AM_RANGE(0x0010,0x0013) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0x00ff)
	2268	AM_RANGE(0x0000,0x0003) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0x00ff)
	2269	AM_RANGE(0x0010,0x0013) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0x00ff)
2270	2270	AM_RANGE(0x0020,0x0033) AM_READWRITE8(towns_system_r,towns_system_w, 0xffff)
2271	2271	AM_RANGE(0x0040,0x0047) AM_DEVREADWRITE8_LEGACY("pit",pit8253_r, pit8253_w, 0x00ff)
2272	2272	AM_RANGE(0x0050,0x0057) AM_DEVREADWRITE8_LEGACY("pit2",pit8253_r, pit8253_w, 0x00ff)
r22822	r22823
2570	2570
2571	2571	void towns_state::driver_start()
2572	2572	{
2573		m_pic_master = machine().device("pic8259_master");
2574		m_pic_slave = machine().device("pic8259_slave");
	2573	m_pic_master = machine().device<pic8259_device>("pic8259_master");
	2574	m_pic_slave = machine().device<pic8259_device>("pic8259_slave");
2575	2575	m_towns_vram = auto_alloc_array(machine(),UINT32,0x20000);
2576	2576	m_towns_gfxvram = auto_alloc_array(machine(),UINT8,0x80000);
2577	2577	m_towns_txtvram = auto_alloc_array(machine(),UINT8,0x20000);
r22822	r22823
2610	2610	m_dma_1 = machine().device("dma_1");
2611	2611	m_dma_2 = machine().device("dma_2");
2612	2612	m_fdc = machine().device("fdc");
2613		m_pic_master = machine().device("pic8259_master");
2614		m_pic_slave = machine().device("pic8259_slave");
	2613	m_pic_master = machine().device<pic8259_device>("pic8259_master");
	2614	m_pic_slave = machine().device<pic8259_device>("pic8259_slave");
2615	2615	m_pit = machine().device("pit");
2616	2616	m_messram = m_ram;
2617	2617	m_cdrom = machine().device<cdrom_image_device>("cdrom");
r22822	r22823
2687	2687	READ8_MEMBER(towns_state::get_slave_ack)
2688	2688	{
2689	2689	if (offset==7) { // IRQ = 7
2690		return pic8259_acknowledge(m_pic_slave);
	2690	return m_pic_slave->acknowledge();
2691	2691	}
2692	2692	return 0x00;
2693	2693	}
r22822	r22823
2701	2701
2702	2702	static const struct pic8259_interface towns_pic8259_slave_config =
2703	2703	{
2704		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir7_w),
	2704	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir7_w),
2705	2705	DEVCB_LINE_GND,
2706	2706	DEVCB_NULL
2707	2707	};

trunk/src/mess/drivers/pc88va.c

r22822	r22823
1010	1010	{
1011	1011	if(m_fdc_ctrl_2 & 4) // XTMASK
1012	1012	{
1013		pic8259_ir3_w(machine().device( "pic8259_slave"), 0);
1014		pic8259_ir3_w(machine().device( "pic8259_slave"), 1);
	1013	machine().device<pic8259_device>( "pic8259_slave")->ir3_w(0);
	1014	machine().device<pic8259_device>( "pic8259_slave")->ir3_w(1);
1015	1015	}
1016	1016	}
1017	1017
r22822	r22823
1142	1142	{
1143	1143	if(m_timer3_io_reg & 0x80)
1144	1144	{
1145		pic8259_ir5_w(machine().device("pic8259_slave"), 0);
1146		pic8259_ir5_w(machine().device("pic8259_slave"), 1);
	1145	machine().device<pic8259_device>("pic8259_slave")->ir5_w(0);
	1146	machine().device<pic8259_device>("pic8259_slave")->ir5_w(1);
1147	1147	m_t3_mouse_timer->adjust(attotime::from_hz(120 >> (m_timer3_io_reg & 3)));
1148	1148	}
1149	1149	}
r22822	r22823
1160	1160	m_t3_mouse_timer->adjust(attotime::from_hz(120 >> (m_timer3_io_reg & 3)));
1161	1161	else
1162	1162	{
1163		pic8259_ir5_w(machine().device("pic8259_slave"), 0);
	1163	machine().device<pic8259_device>("pic8259_slave")->ir5_w(0);
1164	1164	m_t3_mouse_timer->adjust(attotime::never);
1165	1165	}
1166	1166	}
r22822	r22823
1243	1243	//  AM_RANGE(0x0158, 0x0159) Interruption Mode Modification
1244	1244	//  AM_RANGE(0x015c, 0x015f) NMI mask port (strobe port)
1245	1245	AM_RANGE(0x0160, 0x016f) AM_DEVREADWRITE8_LEGACY("dmac", upd71071_r, upd71071_w,0xffff) // DMA Controller
1246		AM_RANGE(0x0184, 0x0187) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0x00ff)
1247		AM_RANGE(0x0188, 0x018b) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0x00ff) // ICU, also controls 8214 emulation
	1246	AM_RANGE(0x0184, 0x0187) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0x00ff)
	1247	AM_RANGE(0x0188, 0x018b) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0x00ff) // ICU, also controls 8214 emulation
1248	1248	//  AM_RANGE(0x0190, 0x0191) System Port 5
1249	1249	//  AM_RANGE(0x0196, 0x0197) Keyboard sub CPU command port
1250	1250	AM_RANGE(0x0198, 0x0199) AM_WRITE(backupram_wp_1_w) //Backup RAM write inhibit
r22822	r22823
1620	1620
1621	1621	IRQ_CALLBACK_MEMBER(pc88va_state::pc88va_irq_callback)
1622	1622	{
1623		return pic8259_acknowledge( machine().device( "pic8259_master" ) );
	1623	return machine().device<pic8259_device>( "pic8259_master" )->acknowledge();
1624	1624	}
1625	1625
1626	1626	WRITE_LINE_MEMBER(pc88va_state::pc88va_pic_irq)
r22822	r22823
1632	1632	READ8_MEMBER(pc88va_state::get_slave_ack)
1633	1633	{
1634	1634	if (offset==7) { // IRQ = 7
1635		return pic8259_acknowledge(machine().device( "pic8259_slave"));
	1635	return machine().device<pic8259_device>( "pic8259_slave")->acknowledge();
1636	1636	}
1637	1637	return 0x00;
1638	1638	}
r22822	r22823
1706	1706
1707	1707	INTERRUPT_GEN_MEMBER(pc88va_state::pc88va_vrtc_irq)
1708	1708	{
1709		pic8259_ir2_w(machine().device("pic8259_master"), 0);
1710		pic8259_ir2_w(machine().device("pic8259_master"), 1);
	1709	machine().device<pic8259_device>("pic8259_master")->ir2_w(0);
	1710	machine().device<pic8259_device>("pic8259_master")->ir2_w(1);
1711	1711	}
1712	1712
1713	1713	WRITE_LINE_MEMBER(pc88va_state::pc88va_pit_out0_changed)
1714	1714	{
1715	1715	if(state)
1716	1716	{
1717		pic8259_ir0_w(machine().device("pic8259_master"), 0);
1718		pic8259_ir0_w(machine().device("pic8259_master"), 1);
	1717	machine().device<pic8259_device>("pic8259_master")->ir0_w(0);
	1718	machine().device<pic8259_device>("pic8259_master")->ir0_w(1);
1719	1719	}
1720	1720	}
1721	1721
r22822	r22823
1755	1755	if(m_fdc_mode && state)
1756	1756	{
1757	1757	//printf("%d\n",state);
1758		pic8259_ir3_w(machine().device( "pic8259_slave"), 0);
1759		pic8259_ir3_w(machine().device( "pic8259_slave"), 1);
	1758	machine().device<pic8259_device>( "pic8259_slave")->ir3_w(0);
	1759	machine().device<pic8259_device>( "pic8259_slave")->ir3_w(1);
1760	1760	}
1761	1761	#if TEST_SUBFDC
1762	1762	else

trunk/src/mess/drivers/pc1512.c

r22822	r22823
530	530	static ADDRESS_MAP_START( pc1512_io, AS_IO, 16, pc1512_state )
531	531	ADDRESS_MAP_GLOBAL_MASK(0x3ff)
532	532	AM_RANGE(0x000, 0x00f) AM_DEVREADWRITE8(I8237A5_TAG, am9517a_device, read, write, 0xffff)
533		AM_RANGE(0x020, 0x021) AM_DEVREADWRITE8_LEGACY(I8259A2_TAG, pic8259_r, pic8259_w, 0xffff)
	533	AM_RANGE(0x020, 0x021) AM_DEVREADWRITE8(I8259A2_TAG, pic8259_device, read, write, 0xffff)
534	534	AM_RANGE(0x040, 0x043) AM_DEVREADWRITE8_LEGACY(I8253_TAG, pit8253_r, pit8253_w, 0xffff)
535	535	AM_RANGE(0x060, 0x06f) AM_READWRITE8(system_r, system_w, 0xffff)
536	536	AM_RANGE(0x070, 0x071) AM_MIRROR(0x02) AM_DEVREADWRITE8(MC146818_TAG, mc146818_device, read, write, 0xffff)
r22822	r22823
567	567	// Mirrored over to 10000 for indirect reads through io_r
568	568
569	569	AM_RANGE(0x000, 0x00f) AM_MIRROR(0x10000) AM_DEVWRITE8(I8237A5_TAG, am9517a_device, write, 0xffff)
570		AM_RANGE(0x020, 0x021) AM_MIRROR(0x10000) AM_DEVWRITE8_LEGACY(I8259A2_TAG, pic8259_w, 0xffff)
	570	AM_RANGE(0x020, 0x021) AM_MIRROR(0x10000) AM_DEVWRITE8(I8259A2_TAG, pic8259_device, write, 0xffff)
571	571	AM_RANGE(0x040, 0x043) AM_MIRROR(0x10000) AM_DEVWRITE8_LEGACY(I8253_TAG, pit8253_w, 0xffff)
572	572	AM_RANGE(0x060, 0x06f) AM_MIRROR(0x10000) AM_WRITE8(system_w, 0xffff)
573	573	AM_RANGE(0x070, 0x071) AM_MIRROR(0x10000) AM_MIRROR(0x02) AM_DEVWRITE8(MC146818_TAG, mc146818_device, write, 0xffff)

trunk/src/mess/drivers/apc.c

r22822	r22823
296	296	res = 0xff;
297	297	}
298	298	else
299		res = pic8259_r(machine().device("pic8259_slave"), space, (offset & 2) >> 1);
	299	res = machine().device<pic8259_device>("pic8259_slave")->read(space, (offset & 2) >> 1);
300	300	}
301	301
302	302	return res;
r22822	r22823
311	311	if(offset & 4)
312	312	printf("Write undefined port %02x\n",offset+0x28);
313	313	else
314		pic8259_w(machine().device("pic8259_slave"), space, (offset & 2) >> 1, data);
	314	machine().device<pic8259_device>("pic8259_slave")->write(space, (offset & 2) >> 1, data);
315	315	}
316	316	}
317	317
r22822	r22823
342	342
343	343	switch(offset & 3)
344	344	{
345		case 0: res = m_keyb.data; pic8259_ir4_w(machine().device("pic8259_master"), 0); break; // according to the source, reading there acks the irq
	345	case 0: res = m_keyb.data; machine().device<pic8259_device>("pic8259_master")->ir4_w(0); break; // according to the source, reading there acks the irq
346	346	case 1: res = m_keyb.status; break;
347	347	case 2: res = m_keyb.sig; break; // bit 0: CTRL bit 1: function key (or reversed)
348	348	case 3: res = ioport("KEY_MOD")->read() & 0xff; break; // sh
r22822	r22823
410	410	---x CRT
411	411	*/
412	412	if(data & 4)
413		pic8259_ir3_w(machine().device("pic8259_master"), 0);
	413	machine().device<pic8259_device>("pic8259_master")->ir3_w(0);
414	414
415	415	if(data & ~4)
416	416	logerror("IRQ ACK %02x\n",data);
r22822	r22823
475	475	static ADDRESS_MAP_START( apc_io, AS_IO, 16, apc_state )
476	476	//  ADDRESS_MAP_GLOBAL_MASK(0xff)
477	477	AM_RANGE(0x00, 0x1f) AM_READWRITE8(apc_dma_r, apc_dma_w,0xff00)
478		AM_RANGE(0x20, 0x23) AM_DEVREADWRITE8_LEGACY("pic8259_master", pic8259_r, pic8259_w, 0x00ff) // i8259
	478	AM_RANGE(0x20, 0x23) AM_DEVREADWRITE8("pic8259_master", pic8259_device, read, write, 0x00ff) // i8259
479	479	AM_RANGE(0x28, 0x2f) AM_READWRITE8(apc_port_28_r, apc_port_28_w, 0xffff) // i8259 (even) / pit8253 (odd)
480	480	//  0x30, 0x37 serial port 0/1 (i8251) (even/odd)
481	481	AM_RANGE(0x38, 0x3f) AM_WRITE8(apc_dma_segments_w,0x00ff)
r22822	r22823
503	503	{
504	504	m_keyb.data = (UINT8)(FPTR)(param) & 0xff;
505	505	//m_keyb.status &= ~1;
506		pic8259_ir4_w(machine().device("pic8259_master"), 1);
	506	machine().device<pic8259_device>("pic8259_master")->ir4_w(1);
507	507	}
508	508
509	509	if(oldval && !newval)
r22822	r22823
744	744	void apc_state::fdc_irq(bool state)
745	745	{
746	746	//  printf("IRQ %d\n",state);
747		pic8259_ir4_w(machine().device("pic8259_slave"), state);
	747	machine().device<pic8259_device>("pic8259_slave")->ir4_w(state);
748	748	}
749	749
750	750	IRQ_CALLBACK_MEMBER(apc_state::irq_callback)
751	751	{
752		return pic8259_acknowledge( machine().device( "pic8259_master" ));
	752	return machine().device<pic8259_device>( "pic8259_master" )->acknowledge();
753	753	}
754	754
755	755	void apc_state::machine_start()
r22822	r22823
845	845	{
846	846	MAIN_CLOCK,              /* heartbeat IRQ */
847	847	DEVCB_NULL,
848		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir3_w)
	848	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir3_w)
849	849	}, {
850	850	MAIN_CLOCK,              /* Memory Refresh */
851	851	DEVCB_NULL,
r22822	r22823
893	893	READ8_MEMBER(apc_state::get_slave_ack)
894	894	{
895	895	if (offset==7) { // IRQ = 7
896		return pic8259_acknowledge( machine().device( "pic8259_slave" ));
	896	return machine().device<pic8259_device>( "pic8259_slave" )->acknowledge();
897	897	}
898	898	return 0x00;
899	899	}
r22822	r22823
907	907
908	908	static const struct pic8259_interface pic8259_slave_config =
909	909	{
910		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir7_w), //TODO: check me
	910	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir7_w), //TODO: check me
911	911	DEVCB_LINE_GND,
912	912	DEVCB_NULL
913	913	};

trunk/src/mess/drivers/tandy2k.c

r22822	r22823
276	276	AM_RANGE(0x00040, 0x00047) AM_DEVREADWRITE8_LEGACY(I8253_TAG, pit8253_r, pit8253_w, 0x00ff)
277	277	AM_RANGE(0x00052, 0x00053) AM_READ8(kbint_clr_r, 0x00ff)
278	278	AM_RANGE(0x00050, 0x00057) AM_DEVREADWRITE8(I8255A_TAG, i8255_device, read, write, 0x00ff)
279		AM_RANGE(0x00060, 0x00063) AM_DEVREADWRITE8_LEGACY(I8259A_0_TAG, pic8259_r, pic8259_w, 0x00ff)
280		AM_RANGE(0x00070, 0x00073) AM_DEVREADWRITE8_LEGACY(I8259A_1_TAG, pic8259_r, pic8259_w, 0x00ff)
	279	AM_RANGE(0x00060, 0x00063) AM_DEVREADWRITE8(I8259A_0_TAG, pic8259_device, read, write, 0x00ff)
	280	AM_RANGE(0x00070, 0x00073) AM_DEVREADWRITE8(I8259A_1_TAG, pic8259_device, read, write, 0x00ff)
281	281	AM_RANGE(0x00080, 0x00081) AM_DEVREADWRITE8(I8272A_TAG, i8272a_device, mdma_r, mdma_w, 0x00ff)
282	282	//  AM_RANGE(0x00100, 0x0017f) AM_DEVREADWRITE8(CRT9007_TAG, crt9007_device, read, write, 0x00ff) AM_WRITE8(addr_ctrl_w, 0xff00)
283	283	AM_RANGE(0x00100, 0x0017f) AM_READWRITE(vpac_r, vpac_w)

trunk/src/mess/drivers/irisha.c

r22822	r22823
20	20	AM_RANGE( 0x06, 0x06) AM_DEVREADWRITE("uart",i8251_device, data_r, data_w)
21	21	AM_RANGE( 0x07, 0x07) AM_DEVREADWRITE("uart", i8251_device, status_r, control_w)
22	22	AM_RANGE( 0x08, 0x0B) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w )
23		AM_RANGE( 0x0C, 0x0F) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w ) AM_MASK( 0x01 )
	23	AM_RANGE( 0x0C, 0x0F) AM_DEVREADWRITE("pic8259", pic8259_device, read, write ) AM_MASK( 0x01 )
24	24	AM_RANGE( 0x10, 0x13) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)
25	25	ADDRESS_MAP_END
26	26

trunk/src/mess/drivers/pc100.c

r22822	r22823
287	287	/* everything is 8-bit bus wide */
288	288	static ADDRESS_MAP_START(pc100_io, AS_IO, 16, pc100_state)
289	289	ADDRESS_MAP_GLOBAL_MASK(0xff)
290		AM_RANGE(0x00, 0x03) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0x00ff) // i8259
	290	AM_RANGE(0x00, 0x03) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0x00ff) // i8259
291	291	//  AM_RANGE(0x04, 0x07) i8237?
292	292	AM_RANGE(0x08, 0x0b) AM_DEVICE8("upd765", upd765a_device, map, 0x00ff ) // upd765
293	293	AM_RANGE(0x10, 0x17) AM_DEVREADWRITE8("ppi8255_1", i8255_device, read, write,0x00ff) // i8255 #1
r22822	r22823
405	405
406	406	IRQ_CALLBACK_MEMBER(pc100_state::pc100_irq_callback)
407	407	{
408		return pic8259_acknowledge( device.machine().device( "pic8259" ) );
	408	return device.machine().device<pic8259_device>( "pic8259" )->acknowledge();
409	409	}
410	410
411	411	WRITE_LINE_MEMBER( pc100_state::pc100_set_int_line )
r22822	r22823
436	436
437	437	INTERRUPT_GEN_MEMBER(pc100_state::pc100_vblank_irq)
438	438	{
439		pic8259_ir4_w(machine().device("pic8259"), 0);
440		pic8259_ir4_w(machine().device("pic8259"), 1);
	439	machine().device<pic8259_device>("pic8259")->ir4_w(0);
	440	machine().device<pic8259_device>("pic8259")->ir4_w(1);
441	441	}
442	442
443	443	TIMER_DEVICE_CALLBACK_MEMBER(pc100_state::pc100_600hz_irq)
444	444	{
445	445	if(m_timer_mode == 0)
446	446	{
447		pic8259_ir2_w(machine().device("pic8259"), 0);
448		pic8259_ir2_w(machine().device("pic8259"), 1);
	447	machine().device<pic8259_device>("pic8259")->ir2_w(0);
	448	machine().device<pic8259_device>("pic8259")->ir2_w(1);
449	449	}
450	450	}
451	451
r22822	r22823
453	453	{
454	454	if(m_timer_mode == 1)
455	455	{
456		pic8259_ir2_w(machine().device("pic8259"), 0);
457		pic8259_ir2_w(machine().device("pic8259"), 1);
	456	machine().device<pic8259_device>("pic8259")->ir2_w(0);
	457	machine().device<pic8259_device>("pic8259")->ir2_w(1);
458	458	}
459	459	}
460	460
r22822	r22823
462	462	{
463	463	if(m_timer_mode == 2)
464	464	{
465		pic8259_ir2_w(machine().device("pic8259"), 0);
466		pic8259_ir2_w(machine().device("pic8259"), 1);
	465	machine().device<pic8259_device>("pic8259")->ir2_w(0);
	466	machine().device<pic8259_device>("pic8259")->ir2_w(1);
467	467	}
468	468	}
469	469
r22822	r22823
471	471	{
472	472	if(m_timer_mode == 3)
473	473	{
474		pic8259_ir2_w(machine().device("pic8259"), 0);
475		pic8259_ir2_w(machine().device("pic8259"), 1);
	474	machine().device<pic8259_device>("pic8259")->ir2_w(0);
	475	machine().device<pic8259_device>("pic8259")->ir2_w(1);
476	476	}
477	477	}
478	478

trunk/src/mess/drivers/wangpc.c

r22822	r22823
558	558	AM_RANGE(0x1020, 0x1027) AM_DEVREADWRITE8(I8255A_TAG, i8255_device, read, write, 0x00ff)
559	559	AM_RANGE(0x1028, 0x1029) //AM_WRITE(?)
560	560	AM_RANGE(0x1040, 0x1047) AM_DEVREADWRITE8_LEGACY(I8253_TAG, pit8253_r, pit8253_w, 0x00ff)
561		AM_RANGE(0x1060, 0x1063) AM_DEVREADWRITE8_LEGACY(I8259A_TAG, pic8259_r, pic8259_w, 0x00ff)
	561	AM_RANGE(0x1060, 0x1063) AM_DEVREADWRITE8(I8259A_TAG, pic8259_device, read, write, 0x00ff)
562	562	AM_RANGE(0x1080, 0x1087) AM_DEVREAD8(SCN2661_TAG, mc2661_device, read, 0x00ff)
563	563	AM_RANGE(0x1088, 0x108f) AM_DEVWRITE8(SCN2661_TAG, mc2661_device, write, 0x00ff)
564	564	AM_RANGE(0x10a0, 0x10bf) AM_DEVREADWRITE8(AM9517A_TAG, am9517a_device, read, write, 0x00ff)

trunk/src/mess/drivers/apricotp.c

r22822	r22823
356	356	AM_RANGE(0x02a, 0x02b) AM_WRITE8(palette_w, 0x00ff)
357	357	AM_RANGE(0x02e, 0x02f) AM_WRITE(video_w)
358	358	AM_RANGE(0x040, 0x05f) AM_DEVREADWRITE8(I8237_TAG, am9517a_device, read, write, 0x00ff)
359		AM_RANGE(0x068, 0x06b) AM_DEVREADWRITE8_LEGACY(I8259A_TAG, pic8259_r, pic8259_w, 0x00ff)
	359	AM_RANGE(0x068, 0x06b) AM_DEVREADWRITE8(I8259A_TAG, pic8259_device, read, write, 0x00ff)
360	360	AM_RANGE(0x06c, 0x06d) AM_DEVWRITE8(MC6845_TAG, mc6845_device, address_w, 0x00ff)
361	361	AM_RANGE(0x06e, 0x06f) AM_DEVREADWRITE8(MC6845_TAG, mc6845_device, register_r, register_w, 0x00ff)
362	362	ADDRESS_MAP_END

trunk/src/mess/drivers/pasogo.c

r22822	r22823
356	356
357	357	static ADDRESS_MAP_START(pasogo_io, AS_IO, 8, pasogo_state)
358	358	//  ADDRESS_MAP_GLOBAL_MASK(0xfFFF)
359		AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE_LEGACY("pic8259", pic8259_r, pic8259_w)
	359	AM_RANGE(0x0020, 0x0021) AM_DEVREADWRITE("pic8259", pic8259_device, read, write)
360	360	AM_RANGE(0x26, 0x27) AM_READWRITE(vg230_io_r, vg230_io_w )
361	361	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8254", pit8253_r, pit8253_w)
362	362	AM_RANGE(0x6c, 0x6f) AM_READWRITE(ems_r, ems_w )
r22822	r22823
460	460
461	461	IRQ_CALLBACK_MEMBER(pasogo_state::pasogo_irq_callback)
462	462	{
463		return pic8259_acknowledge( machine().device("pic8259"));
	463	return machine().device<pic8259_device>("pic8259")->acknowledge();
464	464	}
465	465
466	466	void pasogo_state::machine_reset()

trunk/src/mess/drivers/sage2.c

r22822	r22823
88	88	AM_RANGE(0xffc020, 0xffc027) AM_DEVREADWRITE8(I8255A_0_TAG, i8255_device, read, write, 0x00ff) // i8255, DIPs + Floppy ctrl port
89	89	AM_RANGE(0xffc030, 0xffc031) AM_DEVREADWRITE8(I8251_1_TAG, i8251_device, data_r, data_w, 0x00ff)
90	90	AM_RANGE(0xffc032, 0xffc033) AM_DEVREADWRITE8(I8251_1_TAG, i8251_device, status_r, control_w, 0x00ff)
91		AM_RANGE(0xffc040, 0xffc043) AM_DEVREADWRITE8_LEGACY(I8259_TAG, pic8259_r, pic8259_w, 0x00ff)
	91	AM_RANGE(0xffc040, 0xffc043) AM_DEVREADWRITE8(I8259_TAG, pic8259_device, read, write, 0x00ff)
92	92	AM_RANGE(0xffc050, 0xffc053) AM_DEVICE8(UPD765_TAG, upd765a_device, map, 0x00ff)
93	93	AM_RANGE(0xffc060, 0xffc067) AM_DEVREADWRITE8(I8255A_0_TAG, i8255_device, read, write, 0x00ff) // i8255, Printer
94	94	AM_RANGE(0xffc070, 0xffc071) AM_DEVREAD8(I8251_0_TAG, i8251_device, data_r, 0x00ff) AM_DEVWRITE8(TERMINAL_TAG, generic_terminal_device, write, 0x00ff)

trunk/src/mess/drivers/qx10.c

r22822	r22823
593	593
594	594	IRQ_CALLBACK_MEMBER(qx10_state::irq_callback)
595	595	{
596		return pic8259_acknowledge(m_pic_m);
	596	return m_pic_m->acknowledge();
597	597	}
598	598
599	599	READ8_MEMBER( qx10_state::upd7201_r )
r22822	r22823
688	688	ADDRESS_MAP_GLOBAL_MASK(0xff)
689	689	AM_RANGE(0x00, 0x03) AM_DEVREADWRITE_LEGACY("pit8253_1", pit8253_r, pit8253_w)
690	690	AM_RANGE(0x04, 0x07) AM_DEVREADWRITE_LEGACY("pit8253_2", pit8253_r, pit8253_w)
691		AM_RANGE(0x08, 0x09) AM_DEVREADWRITE_LEGACY("pic8259_master", pic8259_r, pic8259_w)
692		AM_RANGE(0x0c, 0x0d) AM_DEVREADWRITE_LEGACY("pic8259_slave", pic8259_r, pic8259_w)
	691	AM_RANGE(0x08, 0x09) AM_DEVREADWRITE("pic8259_master", pic8259_device, read, write)
	692	AM_RANGE(0x0c, 0x0d) AM_DEVREADWRITE("pic8259_slave", pic8259_device, read, write)
693	693	AM_RANGE(0x10, 0x13) AM_READWRITE(upd7201_r, upd7201_w) //AM_DEVREADWRITE("upd7201", upd7201_device, cd_ba_r, cd_ba_w)
694	694	AM_RANGE(0x14, 0x17) AM_DEVREADWRITE("i8255", i8255_device, read, write)
695	695	AM_RANGE(0x18, 0x1b) AM_READ_PORT("DSW") AM_WRITE(qx10_18_w)

trunk/src/mess/drivers/multi16.c

r22822	r22823
108	108
109	109	static ADDRESS_MAP_START(multi16_io, AS_IO, 16, multi16_state)
110	110	ADDRESS_MAP_UNMAP_HIGH
111		AM_RANGE(0x02, 0x03) AM_DEVREADWRITE8_LEGACY("pic8259", pic8259_r, pic8259_w, 0xffff) // i8259
	111	AM_RANGE(0x02, 0x03) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff) // i8259
112	112	AM_RANGE(0x40, 0x41) AM_WRITE8(multi16_6845_address_w, 0x00ff)
113	113	AM_RANGE(0x40, 0x41) AM_WRITE8(multi16_6845_data_w, 0xff00)
114	114	ADDRESS_MAP_END
r22822	r22823
119	119
120	120	IRQ_CALLBACK_MEMBER(multi16_state::multi16_irq_callback)
121	121	{
122		return pic8259_acknowledge( machine().device("pic8259") );
	122	return machine().device<pic8259_device>("pic8259")->acknowledge();
123	123	}
124	124
125	125	WRITE_LINE_MEMBER( multi16_state::multi16_set_int_line )

trunk/src/mess/drivers/m20.c

r22822	r22823
240	240
241	241	READ16_MEMBER(m20_state::m20_i8259_r)
242	242	{
243		return pic8259_r(m_i8259, space, offset)<<1;
	243	return m_i8259->read(space, offset)<<1;
244	244	}
245	245
246	246	WRITE16_MEMBER(m20_state::m20_i8259_w)
247	247	{
248		pic8259_w(m_i8259, space, offset, (data>>1));
	248	m_i8259->write(space, offset, (data>>1));
249	249	}
250	250
251	251	WRITE_LINE_MEMBER( m20_state::pic_irq_line_w )
r22822	r22823
804	804	if (! irqline)
805	805	return 0xff; // NVI, value ignored
806	806	else
807		return pic8259_acknowledge(machine().device("i8259"));
	807	return m_i8259->acknowledge();
808	808	}
809	809
810	810	void m20_state::machine_start()
r22822	r22823
860	860
861	861	WRITE_LINE_MEMBER(m20_state::kbd_rxrdy_int)
862	862	{
863		pic8259_ir4_w(machine().device("i8259"), state);
	863	m_i8259->ir4_w(state);
864	864	}
865	865
866	866	void m20_state::fdc_intrq_w(bool state)
867	867	{
868		pic8259_ir0_w(machine().device("i8259"), state);
	868	m_i8259->ir0_w(state);
869	869	}
870	870
871	871	static const i8251_interface kbd_i8251_intf =

trunk/src/mame/drivers/xtom3d.c

r22822	r22823
538	538
539	539	static ADDRESS_MAP_START(xtom3d_io, AS_IO, 32, xtom3d_state)
540	540	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
541		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	541	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
542	542	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
543	543	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
544	544	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
545	545	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,  at_page8_w, 0xffffffff)
546		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	546	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
547	547	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
548	548	AM_RANGE(0x00e8, 0x00ef) AM_NOP
549	549
r22822	r22823
563	563	{
564	564	4772720/4,              /* heartbeat IRQ */
565	565	DEVCB_NULL,
566		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	566	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
567	567	}, {
568	568	4772720/4,              /* dram refresh */
569	569	DEVCB_NULL,
r22822	r22823
585	585	{
586	586	if (offset==2) { // IRQ = 2
587	587	logerror("pic8259_slave_ACK!\n");
588		return pic8259_acknowledge(m_pic8259_2);
	588	return m_pic8259_2->acknowledge();
589	589	}
590	590	return 0x00;
591	591	}
r22822	r22823
599	599
600	600	static const struct pic8259_interface xtom3d_pic8259_2_config =
601	601	{
602		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	602	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
603	603	DEVCB_LINE_GND,
604	604	DEVCB_NULL
605	605	};
r22822	r22823
623	623
624	624	IRQ_CALLBACK_MEMBER(xtom3d_state::irq_callback)
625	625	{
626		return pic8259_acknowledge(m_pic8259_1);
	626	return m_pic8259_1->acknowledge();
627	627	}
628	628
629	629	void xtom3d_state::machine_start()

trunk/src/mame/drivers/quakeat.c

r22822	r22823
71	71	: driver_device(mconfig, type, tag),
72	72	m_maincpu(*this, "maincpu") { }
73	73
74		device_t    *m_pic8259_1;
75		device_t    *m_pic8259_2;
	74	pic8259_device    *m_pic8259_1;
	75	pic8259_device    *m_pic8259_2;
76	76	DECLARE_WRITE_LINE_MEMBER(quakeat_pic8259_1_set_int_line);
77	77	DECLARE_READ8_MEMBER(get_slave_ack);
78	78	virtual void machine_start();
r22822	r22823
98	98
99	99	static ADDRESS_MAP_START( quake_io, AS_IO, 32, quakeat_state )
100	100	//  AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8_LEGACY("dma8237_1", dma8237_r, dma8237_w, 0xffffffff)
101		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	101	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
102	102	//  AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
103	103	//  AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r,          kbdc8042_32le_w)
104	104	//  AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
105	105	//  AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r,              at_page32_w)
106		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	106	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
107	107	//  AM_RANGE(0x00c0, 0x00df) AM_DEVREADWRITE_LEGACY("dma8237_2", at32_dma8237_2_r, at32_dma8237_2_w)
108	108	AM_RANGE(0x00e8, 0x00eb) AM_NOP
109	109	//  AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE_LEGACY("ide", ide_r, ide_w)
r22822	r22823
129	129	READ8_MEMBER(quakeat_state::get_slave_ack)
130	130	{
131	131	if (offset==2) { // IRQ = 2
132		return pic8259_acknowledge(m_pic8259_2);
	132	return m_pic8259_2->acknowledge();
133	133	}
134	134	return 0x00;
135	135	}
r22822	r22823
143	143
144	144	static const struct pic8259_interface quakeat_pic8259_2_config =
145	145	{
146		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	146	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
147	147	DEVCB_LINE_GND,
148	148	DEVCB_NULL
149	149	};
r22822	r22823
157	157
158	158	IRQ_CALLBACK_MEMBER(quakeat_state::irq_callback)
159	159	{
160		return pic8259_acknowledge(m_pic8259_1);
	160	return m_pic8259_1->acknowledge();
161	161	}
162	162
163	163	void quakeat_state::machine_start()
164	164	{
165	165	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(quakeat_state::irq_callback),this));
166	166
167		m_pic8259_1 = machine().device( "pic8259_1" );
168		m_pic8259_2 = machine().device( "pic8259_2" );
	167	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	168	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
169	169	}
170	170	/*************************************************************/
171	171

trunk/src/mame/drivers/pcxt.c

r22822	r22823
272	272	{
273	273	XTAL_14_31818MHz/12,                /* heartbeat IRQ */
274	274	DEVCB_NULL,
275		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	275	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
276	276	}, {
277	277	XTAL_14_31818MHz/12,                /* dram refresh */
278	278	DEVCB_NULL,
r22822	r22823
415	415	WRITE8_MEMBER(pcxt_state::drive_selection_w)
416	416	{
417	417	/* TODO: properly hook-up upd765 FDC there */
418		pic8259_ir6_w(machine().device("pic8259_1"), 1);
	418	machine().device<pic8259_device>("pic8259_1")->ir6_w(1);
419	419	}
420	420
421	421	/******************
r22822	r22823
525	525	READ8_MEMBER(pcxt_state::get_slave_ack)
526	526	{
527	527	if (offset==2) { // IRQ = 2
528		return pic8259_acknowledge(m_pic8259_2);
	528	return m_pic8259_2->acknowledge();
529	529	}
530	530	return 0x00;
531	531	}
r22822	r22823
539	539
540	540	static const struct pic8259_interface pic8259_2_config =
541	541	{
542		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	542	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
543	543	DEVCB_LINE_GND,
544	544	DEVCB_NULL
545	545	};
546	546
547	547	IRQ_CALLBACK_MEMBER(pcxt_state::irq_callback)
548	548	{
549		return pic8259_acknowledge(m_pic8259_1);
	549	return m_pic8259_1->acknowledge();
550	550	}
551	551
552	552	static ADDRESS_MAP_START( filetto_map, AS_PROGRAM, 8, pcxt_state )
r22822	r22823
560	560	static ADDRESS_MAP_START( pcxt_io_common, AS_IO, 8, pcxt_state )
561	561	ADDRESS_MAP_GLOBAL_MASK(0x3ff)
562	562	AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE("dma8237_1", i8237_device, i8237_r, i8237_w ) //8237 DMA Controller
563		AM_RANGE(0x0020, 0x002f) AM_DEVREADWRITE_LEGACY("pic8259_1", pic8259_r, pic8259_w ) //8259 Interrupt control
	563	AM_RANGE(0x0020, 0x002f) AM_DEVREADWRITE("pic8259_1", pic8259_device, read, write ) //8259 Interrupt control
564	564	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r, pit8253_w)    //8253 PIT
565	565	AM_RANGE(0x0060, 0x0063) AM_DEVREADWRITE("ppi8255_0", i8255_device, read, write)  //PPI 8255
566	566	AM_RANGE(0x0064, 0x0066) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write)  //PPI 8255
567	567	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE("rtc", mc146818_device, read, write)
568	568	AM_RANGE(0x0080, 0x0087) AM_READWRITE(dma_page_select_r,dma_page_select_w)
569		AM_RANGE(0x00a0, 0x00af) AM_DEVREADWRITE_LEGACY("pic8259_2", pic8259_r, pic8259_w )
	569	AM_RANGE(0x00a0, 0x00af) AM_DEVREADWRITE("pic8259_2", pic8259_device, read, write )
570	570	AM_RANGE(0x0278, 0x027f) AM_RAM //printer (parallel) port latch
571	571	AM_RANGE(0x02f8, 0x02ff) AM_RAM //Modem port
572	572	AM_RANGE(0x0378, 0x037f) AM_RAM //printer (parallel) port

trunk/src/mame/drivers/savquest.c

r22822	r22823
505	505
506	506	static ADDRESS_MAP_START(savquest_io, AS_IO, 32, savquest_state)
507	507	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
508		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	508	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
509	509	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
510	510	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
511	511	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
512	512	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
513		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	513	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
514	514	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
515	515	AM_RANGE(0x00e8, 0x00ef) AM_NOP
516	516
r22822	r22823
534	534	{
535	535	4772720/4,              /* heartbeat IRQ */
536	536	DEVCB_NULL,
537		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	537	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
538	538	}, {
539	539	4772720/4,              /* dram refresh */
540	540	DEVCB_NULL,
r22822	r22823
556	556	{
557	557	if (offset==2) { // IRQ = 2
558	558	logerror("pic8259_slave_ACK!\n");
559		return pic8259_acknowledge(m_pic8259_2);
	559	return m_pic8259_2->acknowledge();
560	560	}
561	561	return 0x00;
562	562	}
r22822	r22823
570	570
571	571	static const struct pic8259_interface savquest_pic8259_2_config =
572	572	{
573		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	573	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
574	574	DEVCB_LINE_GND,
575	575	DEVCB_NULL
576	576	};
r22822	r22823
594	594
595	595	IRQ_CALLBACK_MEMBER(savquest_state::irq_callback)
596	596	{
597		return pic8259_acknowledge(m_pic8259_1);
	597	return m_pic8259_1->acknowledge();
598	598	}
599	599
600	600	void savquest_state::machine_start()

trunk/src/mame/drivers/photoply.c

r22822	r22823
34	34	UINT8 m_vga_address;
35	35
36	36	device_t    *m_pit8253;
37		device_t    *m_pic8259_1;
38		device_t    *m_pic8259_2;
	37	pic8259_device  *m_pic8259_1;
	38	pic8259_device  *m_pic8259_2;
39	39	i8237_device    *m_dma8237_1;
40	40	i8237_device    *m_dma8237_2;
41	41	DECLARE_READ32_MEMBER(ide_r);
r22822	r22823
210	210	READ8_MEMBER(photoply_state::get_slave_ack)
211	211	{
212	212	if (offset==2) { // IRQ = 2
213		return pic8259_acknowledge(m_pic8259_2);
	213	return m_pic8259_2->acknowledge();
214	214	}
215	215	return 0x00;
216	216	}
r22822	r22823
224	224
225	225	static const struct pic8259_interface pic8259_2_config =
226	226	{
227		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	227	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
228	228	DEVCB_LINE_GND,
229	229	DEVCB_NULL
230	230	};
231	231
232	232	IRQ_CALLBACK_MEMBER(photoply_state::irq_callback)
233	233	{
234		return pic8259_acknowledge(m_pic8259_1);
	234	return m_pic8259_1->acknowledge();
235	235	}
236	236
237	237	WRITE_LINE_MEMBER(photoply_state::at_pit8254_out0_changed)
238	238	{
239	239	if ( m_pic8259_1 )
240	240	{
241		pic8259_ir0_w(m_pic8259_1, state);
	241	m_pic8259_1->ir0_w(state);
242	242	}
243	243	}
244	244
r22822	r22823
282	282
283	283	static ADDRESS_MAP_START( photoply_io, AS_IO, 32, photoply_state )
284	284	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
285		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	285	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
286	286	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
287	287	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
288	288	AM_RANGE(0x0070, 0x007f) AM_RAM//DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
289	289	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(dma_page_select_r,dma_page_select_w, 0xffffffff)//TODO
290		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	290	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
291	291	AM_RANGE(0x00c0, 0x00df) AM_DEVREADWRITE8("dma8237_2", i8237_device, i8237_r, i8237_w, 0xffff)
292	292	AM_RANGE(0x00e8, 0x00eb) AM_NOP
293	293	AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w)
r22822	r22823
355	355	{
356	356	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(photoply_state::irq_callback),this));
357	357	m_pit8253 = machine().device( "pit8254" );
358		m_pic8259_1 = machine().device( "pic8259_1" );
359		m_pic8259_2 = machine().device( "pic8259_2" );
	358	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	359	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
360	360	m_dma8237_1 = machine().device<i8237_device>( "dma8237_1" );
361	361	m_dma8237_2 = machine().device<i8237_device>( "dma8237_2" );
362	362	}

trunk/src/mame/drivers/midqslvr.c

r22822	r22823
547	547
548	548	static ADDRESS_MAP_START(midqslvr_io, AS_IO, 32, midqslvr_state)
549	549	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
550		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	550	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
551	551	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
552	552	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
553	553	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
554	554	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,at_page8_w,0xffffffff)
555		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	555	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
556	556	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
557	557	AM_RANGE(0x00e8, 0x00ef) AM_NOP
558	558
r22822	r22823
571	571	{
572	572	4772720/4,              /* heartbeat IRQ */
573	573	DEVCB_NULL,
574		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	574	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
575	575	}, {
576	576	4772720/4,              /* dram refresh */
577	577	DEVCB_NULL,
r22822	r22823
593	593	{
594	594	if (offset==2) { // IRQ = 2
595	595	logerror("pic8259_slave_ACK!\n");
596		return pic8259_acknowledge(m_pic8259_2);
	596	return m_pic8259_2->acknowledge();
597	597	}
598	598	return 0x00;
599	599	}
r22822	r22823
607	607
608	608	static const struct pic8259_interface midqslvr_pic8259_2_config =
609	609	{
610		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	610	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
611	611	DEVCB_LINE_GND,
612	612	DEVCB_NULL
613	613	};
r22822	r22823
631	631
632	632	IRQ_CALLBACK_MEMBER(midqslvr_state::irq_callback)
633	633	{
634		return pic8259_acknowledge(m_pic8259_1);
	634	return m_pic8259_1->acknowledge();
635	635	}
636	636
637	637	void midqslvr_state::machine_start()

trunk/src/mame/drivers/calchase.c

r22822	r22823
144	144	UINT8 m_piix4_config_reg[4][256];
145	145
146	146	device_t    *m_pit8254;
147		device_t    *m_pic8259_1;
148		device_t    *m_pic8259_2;
	147	pic8259_device  *m_pic8259_1;
	148	pic8259_device  *m_pic8259_2;
149	149	i8237_device    *m_dma8237_1;
150	150	i8237_device    *m_dma8237_2;
151	151
r22822	r22823
580	580
581	581	static ADDRESS_MAP_START( calchase_io, AS_IO, 32, calchase_state )
582	582	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
583		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	583	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
584	584	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
585	585	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
586	586	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
587	587	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
588		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	588	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
589	589	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
590	590	//AM_RANGE(0x00e8, 0x00eb) AM_NOP
591	591	AM_RANGE(0x00e8, 0x00ef) AM_NOP //AMI BIOS write to this ports as delays between I/O ports operations sending al value -> NEWIODELAY
r22822	r22823
806	806
807	807	IRQ_CALLBACK_MEMBER(calchase_state::irq_callback)
808	808	{
809		return pic8259_acknowledge(m_pic8259_1);
	809	return m_pic8259_1->acknowledge();
810	810	}
811	811
812	812	void calchase_state::machine_start()
r22822	r22823
817	817	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(calchase_state::irq_callback),this));
818	818
819	819	m_pit8254 = machine().device( "pit8254" );
820		m_pic8259_1 = machine().device( "pic8259_1" );
821		m_pic8259_2 = machine().device( "pic8259_2" );
	820	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	821	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
822	822	m_dma8237_1 = machine().device<i8237_device>( "dma8237_1" );
823	823	m_dma8237_2 = machine().device<i8237_device>( "dma8237_2" );
824	824	}
r22822	r22823
837	837	READ8_MEMBER(calchase_state::get_slave_ack)
838	838	{
839	839	if (offset==2) {
840		return pic8259_acknowledge(m_pic8259_2);
	840	return m_pic8259_2->acknowledge();
841	841	}
842	842	return 0x00;
843	843	}
r22822	r22823
851	851
852	852	static const struct pic8259_interface calchase_pic8259_2_config =
853	853	{
854		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	854	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
855	855	DEVCB_LINE_GND,
856	856	DEVCB_NULL
857	857	};
r22822	r22823
871	871	{
872	872	4772720/4,              /* heartbeat IRQ */
873	873	DEVCB_NULL,
874		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	874	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
875	875	}, {
876	876	4772720/4,              /* dram refresh */
877	877	DEVCB_NULL,

trunk/src/mame/drivers/pcat_nit.c

r22822	r22823
126	126
127	127	WRITE_LINE_MEMBER(pcat_nit_state::at_com_interrupt_1)
128	128	{
129		pic8259_ir4_w(machine().device("pic8259_1"), state);
	129	machine().device<pic8259_device>("pic8259_1")->ir4_w(state);
130	130	}
131	131
132	132	static const ins8250_interface pcat_nit_com0_interface =

trunk/src/mame/drivers/magtouch.c

r22822	r22823
123	123
124	124	WRITE_LINE_MEMBER(magtouch_state::at_com_interrupt_1)
125	125	{
126		pic8259_ir4_w(machine().device("pic8259_1"), state);
	126	machine().device<pic8259_device>("pic8259_1")->ir4_w(state);
127	127	}
128	128
129	129	static const ins8250_interface magtouch_com0_interface =

trunk/src/mame/drivers/queen.c

r22822	r22823
411	411
412	412	static ADDRESS_MAP_START( queen_io, AS_IO, 32, queen_state )
413	413	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
414		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	414	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
415	415	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
416	416	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
417	417	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
418	418	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,  at_page8_w, 0xffffffff)
419		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	419	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
420	420	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
421	421	AM_RANGE(0x00e8, 0x00ef) AM_NOP
422	422
r22822	r22823
435	435	{
436	436	4772720/4,              /* heartbeat IRQ */
437	437	DEVCB_NULL,
438		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	438	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
439	439	}, {
440	440	4772720/4,              /* dram refresh */
441	441	DEVCB_NULL,
r22822	r22823
457	457	{
458	458	if (offset==2) { // IRQ = 2
459	459	logerror("pic8259_slave_ACK!\n");
460		return pic8259_acknowledge(m_pic8259_2);
	460	return m_pic8259_2->acknowledge();
461	461	}
462	462	return 0x00;
463	463	}
r22822	r22823
471	471
472	472	static const struct pic8259_interface queen_pic8259_2_config =
473	473	{
474		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	474	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
475	475	DEVCB_LINE_GND,
476	476	DEVCB_NULL
477	477	};
r22822	r22823
495	495
496	496	IRQ_CALLBACK_MEMBER(queen_state::irq_callback)
497	497	{
498		return pic8259_acknowledge(m_pic8259_1);
	498	return m_pic8259_1->acknowledge();
499	499	}
500	500
501	501	void queen_state::machine_start()

trunk/src/mame/drivers/su2000.c

r22822	r22823
71	71	: pcat_base_state(mconfig, type, tag){ }
72	72
73	73	device_t    *m_pit8254;
74		device_t    *m_pic8259_1;
75		device_t    *m_pic8259_2;
	74	pic8259_device  *m_pic8259_1;
	75	pic8259_device  *m_pic8259_2;
76	76	device_t    *m_dma8237_1;
77	77	device_t    *m_dma8237_2;
78	78
r22822	r22823
145	145	{
146	146	// IRQ = 2
147	147	logerror("pic8259_slave_ACK!\n");
148		return pic8259_acknowledge(m_pic8259_2);
	148	return m_pic8259_2->acknowledge();
149	149	}
150	150	return 0x00;
151	151	}
r22822	r22823
159	159
160	160	static const struct pic8259_interface su2000_pic8259_2_config =
161	161	{
162		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	162	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
163	163	DEVCB_LINE_GND,
164	164	DEVCB_NULL
165	165	};
r22822	r22823
177	177	{
178	178	4772720/4,              /* Heartbeat IRQ */
179	179	DEVCB_NULL,
180		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	180	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
181	181	}, {
182	182	4772720/4,              /* DRAM refresh */
183	183	DEVCB_NULL,
r22822	r22823
201	201	address_space &space = m_maincpu->space(AS_PROGRAM);
202	202
203	203	m_pit8254 = machine().device("pit8254");
204		m_pic8259_1 = machine().device("pic8259_1");
205		m_pic8259_2 = machine().device("pic8259_2");
	204	m_pic8259_1 = machine().device<pic8259_device>("pic8259_1");
	205	m_pic8259_2 = machine().device<pic8259_device>("pic8259_2");
206	206	m_dma8237_1 = machine().device("dma8237_1");
207	207	m_dma8237_2 = machine().device("dma8237_2");
208	208

trunk/src/mame/drivers/mediagx.c

r22822	r22823
565	565
566	566	READ8_MEMBER(mediagx_state::io20_r)
567	567	{
568		device_t *device = machine().device("pic8259_master");
	568	pic8259_device *device = machine().device<pic8259_device>("pic8259_master");
569	569	UINT8 r = 0;
570	570
571	571	// 0x22, 0x23, Cyrix configuration registers
r22822	r22823
578	578	}
579	579	else
580	580	{
581		r = pic8259_r(device, space, offset);
	581	r = device->read(space, offset);
582	582	}
583	583	return r;
584	584	}
585	585
586	586	WRITE8_MEMBER(mediagx_state::io20_w)
587	587	{
588		device_t *device = machine().device("pic8259_master");
	588	pic8259_device *device = machine().device<pic8259_device>("pic8259_master");
589	589
590	590	// 0x22, 0x23, Cyrix configuration registers
591	591	if (offset == 0x02)
r22822	r22823
598	598	}
599	599	else
600	600	{
601		pic8259_w(device, space, offset, data);
	601	device->write(space, offset, data);
602	602	}
603	603	}
604	604
r22822	r22823
963	963	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
964	964	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
965	965	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,              at_page8_w, 0xffffffff)
966		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffffffff)
	966	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffffffff)
967	967	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
968	968	AM_RANGE(0x00e8, 0x00eb) AM_NOP     // I/O delay port
969	969	AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w)
r22822	r22823
1055	1055
1056	1056	IRQ_CALLBACK_MEMBER(mediagx_state::irq_callback)
1057	1057	{
1058		return pic8259_acknowledge(m_pic8259_1);
	1058	return m_pic8259_1->acknowledge();
1059	1059	}
1060	1060
1061	1061	void mediagx_state::machine_start()
r22822	r22823
1102	1102	READ8_MEMBER(mediagx_state::get_slave_ack)
1103	1103	{
1104	1104	if (offset==2) { // IRQ = 2
1105		return pic8259_acknowledge(m_pic8259_2);
	1105	return m_pic8259_2->acknowledge();
1106	1106	}
1107	1107	return 0x00;
1108	1108	}
r22822	r22823
1116	1116
1117	1117	static const struct pic8259_interface mediagx_pic8259_2_config =
1118	1118	{
1119		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir2_w),
	1119	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir2_w),
1120	1120	DEVCB_LINE_GND,
1121	1121	DEVCB_NULL
1122	1122	};
r22822	r22823
1134	1134	{
1135	1135	4772720/4,              /* heartbeat IRQ */
1136	1136	DEVCB_NULL,
1137		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir0_w)
	1137	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir0_w)
1138	1138	}, {
1139	1139	4772720/4,              /* dram refresh */
1140	1140	DEVCB_NULL,

trunk/src/mame/drivers/taitowlf.c

r22822	r22823
63	63
64	64	required_device<cpu_device> m_maincpu;
65	65	required_device<device_t> m_pit8254;
66		required_device<device_t> m_pic8259_1;
67		required_device<device_t> m_pic8259_2;
	66	required_device<pic8259_device> m_pic8259_1;
	67	required_device<pic8259_device> m_pic8259_2;
68	68	required_device<i8237_device> m_dma8237_1;
69	69	required_device<i8237_device> m_dma8237_2;
70	70	required_memory_region m_region_user1;
r22822	r22823
487	487
488	488	static ADDRESS_MAP_START(taitowlf_io, AS_IO, 32, taitowlf_state )
489	489	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
490		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	490	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
491	491	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
492	492	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
493	493	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
494	494	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,              at_page8_w, 0xffffffff)
495		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	495	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
496	496	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
497	497	AM_RANGE(0x00e8, 0x00eb) AM_NOP
498	498	AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w)
r22822	r22823
549	549
550	550	IRQ_CALLBACK_MEMBER(taitowlf_state::irq_callback)
551	551	{
552		return pic8259_acknowledge(m_pic8259_1);
	552	return m_pic8259_1->acknowledge();
553	553	}
554	554
555	555	void taitowlf_state::machine_start()
r22822	r22823
577	577	READ8_MEMBER(taitowlf_state::get_slave_ack)
578	578	{
579	579	if (offset==2) { // IRQ = 2
580		return pic8259_acknowledge(m_pic8259_2);
	580	return m_pic8259_2->acknowledge();
581	581	}
582	582	return 0x00;
583	583	}
r22822	r22823
591	591
592	592	static const struct pic8259_interface taitowlf_pic8259_2_config =
593	593	{
594		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	594	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
595	595	DEVCB_LINE_GND,
596	596	DEVCB_NULL
597	597	};
r22822	r22823
609	609	{
610	610	4772720/4,              /* heartbeat IRQ */
611	611	DEVCB_NULL,
612		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	612	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
613	613	}, {
614	614	4772720/4,              /* dram refresh */
615	615	DEVCB_NULL,

trunk/src/mame/drivers/funkball.c

r22822	r22823
422	422
423	423	READ8_MEMBER(funkball_state::io20_r)
424	424	{
425		device_t *device = machine().device("pic8259_1");
	425	pic8259_device *device = machine().device<pic8259_device>("pic8259_1");
426	426	UINT8 r = 0;
427	427
428	428	// 0x22, 0x23, Cyrix configuration registers
r22822	r22823
435	435	}
436	436	else
437	437	{
438		r = pic8259_r(device, space, offset);
	438	r = device->read(space, offset);
439	439	}
440	440	return r;
441	441	}
442	442
443	443	WRITE8_MEMBER(funkball_state::io20_w)
444	444	{
445		device_t *device = machine().device("pic8259_1");
	445	pic8259_device *device = machine().device<pic8259_device>("pic8259_1");
446	446
447	447	// 0x22, 0x23, Cyrix configuration registers
448	448	if (offset == 0x02)
r22822	r22823
455	455	}
456	456	else
457	457	{
458		pic8259_w(device, space, offset, data);
	458	device->write(space, offset, data);
459	459	}
460	460	}
461	461
r22822	r22823
592	592	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
593	593	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
594	594	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,at_page8_w, 0xffffffff)
595		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	595	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
596	596	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
597	597	AM_RANGE(0x00e8, 0x00ef) AM_NOP
598	598
r22822	r22823
1018	1018	{
1019	1019	4772720/4,              /* heartbeat IRQ */
1020	1020	DEVCB_NULL,
1021		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	1021	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
1022	1022	}, {
1023	1023	4772720/4,              /* dram refresh */
1024	1024	DEVCB_NULL,
r22822	r22823
1040	1040	{
1041	1041	if (offset==2) { // IRQ = 2
1042	1042	logerror("pic8259_slave_ACK!\n");
1043		return pic8259_acknowledge(m_pic8259_2);
	1043	return m_pic8259_2->acknowledge();
1044	1044	}
1045	1045	return 0x00;
1046	1046	}
r22822	r22823
1054	1054
1055	1055	static const struct pic8259_interface funkball_pic8259_2_config =
1056	1056	{
1057		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	1057	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
1058	1058	DEVCB_LINE_GND,
1059	1059	DEVCB_NULL
1060	1060	};
r22822	r22823
1078	1078
1079	1079	IRQ_CALLBACK_MEMBER(funkball_state::irq_callback)
1080	1080	{
1081		return pic8259_acknowledge(m_pic8259_1);
	1081	return m_pic8259_1->acknowledge();
1082	1082	}
1083	1083
1084	1084	void funkball_state::machine_start()

trunk/src/mame/drivers/gamecstl.c

r22822	r22823
91	91	UINT8 m_at_pages[0x10];
92	92
93	93	device_t    *m_pit8254;
94		device_t    *m_pic8259_1;
95		device_t    *m_pic8259_2;
	94	pic8259_device  *m_pic8259_1;
	95	pic8259_device  *m_pic8259_2;
96	96	i8237_device    *m_dma8237_1;
97	97	i8237_device    *m_dma8237_2;
98	98	DECLARE_WRITE32_MEMBER(pnp_config_w);
r22822	r22823
528	528
529	529	static ADDRESS_MAP_START(gamecstl_io, AS_IO, 32, gamecstl_state )
530	530	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
531		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	531	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
532	532	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
533	533	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
534	534	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
535	535	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,at_page8_w, 0xffffffff)
536		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	536	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
537	537	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
538	538	AM_RANGE(0x00e8, 0x00eb) AM_NOP
539	539	AM_RANGE(0x00ec, 0x00ef) AM_NOP
r22822	r22823
606	606
607	607	IRQ_CALLBACK_MEMBER(gamecstl_state::irq_callback)
608	608	{
609		return pic8259_acknowledge(m_pic8259_1);
	609	return m_pic8259_1->acknowledge();
610	610	}
611	611
612	612	void gamecstl_state::machine_start()
613	613	{
614	614	m_pit8254 = machine().device( "pit8254" );
615		m_pic8259_1 = machine().device( "pic8259_1" );
616		m_pic8259_2 = machine().device( "pic8259_2" );
	615	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	616	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
617	617	m_dma8237_1 = machine().device<i8237_device>( "dma8237_1" );
618	618	m_dma8237_2 = machine().device<i8237_device>( "dma8237_2" );
619	619	}
r22822	r22823
640	640	READ8_MEMBER(gamecstl_state::get_slave_ack)
641	641	{
642	642	if (offset==2) { // IRQ = 2
643		return pic8259_acknowledge(m_pic8259_2);
	643	return m_pic8259_2->acknowledge();
644	644	}
645	645	return 0x00;
646	646	}
r22822	r22823
654	654
655	655	static const struct pic8259_interface gamecstl_pic8259_2_config =
656	656	{
657		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	657	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
658	658	DEVCB_LINE_GND,
659	659	DEVCB_NULL
660	660	};
r22822	r22823
672	672	{
673	673	4772720/4,              /* heartbeat IRQ */
674	674	DEVCB_NULL,
675		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	675	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
676	676	}, {
677	677	4772720/4,              /* dram refresh */
678	678	DEVCB_NULL,

trunk/src/mame/drivers/fruitpc.c

r22822	r22823
36	36	UINT8 m_at_pages[0x10];
37	37
38	38	device_t    *m_pit8254;
39		device_t    *m_pic8259_1;
40		device_t    *m_pic8259_2;
	39	pic8259_device  *m_pic8259_1;
	40	pic8259_device  *m_pic8259_2;
41	41	i8237_device    *m_dma8237_1;
42	42	i8237_device    *m_dma8237_2;
43	43
r22822	r22823
218	218
219	219	static ADDRESS_MAP_START( fruitpc_io, AS_IO, 32, fruitpc_state )
220	220	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
221		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	221	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
222	222	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
223	223	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
224	224	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
225	225	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
226		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	226	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
227	227	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
228	228	//AM_RANGE(0x00e8, 0x00eb) AM_NOP
229	229	AM_RANGE(0x00e8, 0x00ef) AM_NOP //AMI BIOS write to this ports as delays between I/O ports operations sending al value -> NEWIODELAY
r22822	r22823
443	443
444	444	IRQ_CALLBACK_MEMBER(fruitpc_state::irq_callback)
445	445	{
446		return pic8259_acknowledge(m_pic8259_1);
	446	return m_pic8259_1->acknowledge();
447	447	}
448	448
449	449	void fruitpc_state::machine_start()
r22822	r22823
451	451	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fruitpc_state::irq_callback),this));
452	452
453	453	m_pit8254 = machine().device( "pit8254" );
454		m_pic8259_1 = machine().device( "pic8259_1" );
455		m_pic8259_2 = machine().device( "pic8259_2" );
	454	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	455	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
456	456	m_dma8237_1 = machine().device<i8237_device>( "dma8237_1" );
457	457	m_dma8237_2 = machine().device<i8237_device>( "dma8237_2" );
458	458	}
r22822	r22823
471	471	READ8_MEMBER(fruitpc_state::get_slave_ack)
472	472	{
473	473	if (offset==2) {
474		return pic8259_acknowledge(m_pic8259_2);
	474	return m_pic8259_2->acknowledge();
475	475	}
476	476	return 0x00;
477	477	}
r22822	r22823
485	485
486	486	static const struct pic8259_interface fruitpc_pic8259_2_config =
487	487	{
488		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	488	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
489	489	DEVCB_LINE_GND,
490	490	DEVCB_NULL
491	491	};
r22822	r22823
505	505	{
506	506	4772720/4,              /* heartbeat IRQ */
507	507	DEVCB_NULL,
508		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	508	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
509	509	}, {
510	510	4772720/4,              /* dram refresh */
511	511	DEVCB_NULL,

trunk/src/mame/drivers/gammagic.c

r22822	r22823
88	88	UINT8 m_at_pages[0x10];
89	89
90	90	required_device<device_t> m_pit8254;
91		required_device<device_t> m_pic8259_1;
92		required_device<device_t> m_pic8259_2;
	91	required_device<pic8259_device> m_pic8259_1;
	92	required_device<pic8259_device> m_pic8259_2;
93	93	required_device<i8237_device> m_dma8237_1;
94	94	required_device<i8237_device> m_dma8237_2;
95	95
r22822	r22823
572	572
573	573	static ADDRESS_MAP_START( gammagic_io, AS_IO, 32, gammagic_state)
574	574	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
575		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	575	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
576	576	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
577	577	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
578	578	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
579	579	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
580		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	580	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
581	581	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
582	582	AM_RANGE(0x00e8, 0x00ef) AM_NOP
583	583	AM_RANGE(0x00f0, 0x01ef) AM_NOP
r22822	r22823
644	644
645	645	IRQ_CALLBACK_MEMBER(gammagic_state::irq_callback)
646	646	{
647		return pic8259_acknowledge(m_pic8259_1);
	647	return m_pic8259_1->acknowledge();
648	648	}
649	649
650	650	void gammagic_state::machine_start()
r22822	r22823
703	703	READ8_MEMBER(gammagic_state::get_slave_ack)
704	704	{
705	705	if (offset==2) {
706		return pic8259_acknowledge(m_pic8259_2);
	706	return m_pic8259_2->acknowledge();
707	707	}
708	708	return 0x00;
709	709	}
r22822	r22823
717	717
718	718	static const struct pic8259_interface gammagic_pic8259_2_config =
719	719	{
720		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	720	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
721	721	DEVCB_LINE_GND,
722	722	DEVCB_NULL
723	723	};
r22822	r22823
734	734	{
735	735	4772720/4,              /* heartbeat IRQ */
736	736	DEVCB_NULL,
737		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	737	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
738	738	}, {
739	739	4772720/4,              /* dram refresh */
740	740	DEVCB_NULL,

trunk/src/mame/drivers/voyager.c

r22822	r22823
40	40	UINT8 m_piix4_config_reg[4][256];
41	41
42	42	device_t    *m_pit8254;
43		device_t    *m_pic8259_1;
44		device_t    *m_pic8259_2;
	43	pic8259_device  *m_pic8259_1;
	44	pic8259_device  *m_pic8259_2;
45	45	i8237_device    *m_dma8237_1;
46	46	i8237_device    *m_dma8237_2;
47	47
r22822	r22823
419	419
420	420	static ADDRESS_MAP_START( voyager_io, AS_IO, 32, voyager_state )
421	421	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
422		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	422	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
423	423	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
424	424	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
425	425	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff) /* todo: nvram (CMOS Setup Save)*/
426	426	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r, at_page8_w, 0xffffffff)
427		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	427	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
428	428	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
429	429	//AM_RANGE(0x00e8, 0x00eb) AM_NOP
430	430	AM_RANGE(0x00e8, 0x00ef) AM_NOP //AMI BIOS write to this ports as delays between I/O ports operations sending al value -> NEWIODELAY
r22822	r22823
645	645
646	646	IRQ_CALLBACK_MEMBER(voyager_state::irq_callback)
647	647	{
648		return pic8259_acknowledge(m_pic8259_1);
	648	return m_pic8259_1->acknowledge();
649	649	}
650	650
651	651	void voyager_state::machine_start()
r22822	r22823
653	653	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(voyager_state::irq_callback),this));
654	654
655	655	m_pit8254 = machine().device( "pit8254" );
656		m_pic8259_1 = machine().device( "pic8259_1" );
657		m_pic8259_2 = machine().device( "pic8259_2" );
	656	m_pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	657	m_pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
658	658	m_dma8237_1 = machine().device<i8237_device>( "dma8237_1" );
659	659	m_dma8237_2 = machine().device<i8237_device>( "dma8237_2" );
660	660	}
r22822	r22823
673	673	READ8_MEMBER(voyager_state::get_slave_ack)
674	674	{
675	675	if (offset==2) {
676		return pic8259_acknowledge(m_pic8259_2);
	676	return m_pic8259_2->acknowledge();
677	677	}
678	678	return 0x00;
679	679	}
r22822	r22823
687	687
688	688	static const struct pic8259_interface voyager_pic8259_2_config =
689	689	{
690		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	690	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
691	691	DEVCB_LINE_GND,
692	692	DEVCB_NULL
693	693	};
r22822	r22823
707	707	{
708	708	4772720/4,              /* heartbeat IRQ */
709	709	DEVCB_NULL,
710		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir0_w)
	710	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir0_w)
711	711	}, {
712	712	4772720/4,              /* dram refresh */
713	713	DEVCB_NULL,

trunk/src/mame/drivers/chihiro.c

r22822	r22823
410	410	UINT32 screen_update_callback(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
411	411
412	412	struct chihiro_devices {
413		device_t    *pic8259_1;
414		device_t    *pic8259_2;
	413	pic8259_device    *pic8259_1;
	414	pic8259_device    *pic8259_2;
415	415	device_t    *ide;
416	416	} chihiro_devs;
417	417
r22822	r22823
2317	2317	pmc[0x100/4] &= ~0x1000000;
2318	2318	if ((pmc[0x100/4] != 0) && (pmc[0x140/4] != 0)) {
2319	2319	// send interrupt
2320		pic8259_ir3_w(chst->chihiro_devs.pic8259_1, 1); // IRQ 3
	2320	chst->chihiro_devs.pic8259_1->ir3_w(1); // IRQ 3
2321	2321	} else
2322		pic8259_ir3_w(chst->chihiro_devs.pic8259_1, 0); // IRQ 3
	2322	chst->chihiro_devs.pic8259_1->ir3_w(0); // IRQ 3
2323	2323	}
2324	2324
2325	2325	UINT32 nv2a_renderer::screen_update_callback(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
r22822	r22823
2784	2784	READ8_MEMBER(chihiro_state::get_slave_ack)
2785	2785	{
2786	2786	if (offset==2) { // IRQ = 2
2787		return pic8259_acknowledge(chihiro_devs.pic8259_2);
	2787	return chihiro_devs.pic8259_2->acknowledge();
2788	2788	}
2789	2789	return 0x00;
2790	2790	}
r22822	r22823
2798	2798
2799	2799	static const struct pic8259_interface chihiro_pic8259_2_config =
2800	2800	{
2801		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	2801	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
2802	2802	DEVCB_LINE_GND,
2803	2803	DEVCB_NULL
2804	2804	};
r22822	r22823
2806	2806	IRQ_CALLBACK_MEMBER(chihiro_state::irq_callback)
2807	2807	{
2808	2808	int r = 0;
2809		r = pic8259_acknowledge(chihiro_devs.pic8259_2);
	2809	r = chihiro_devs.pic8259_2->acknowledge();
2810	2810	if (r==0)
2811	2811	{
2812		r = pic8259_acknowledge(chihiro_devs.pic8259_1);
	2812	r = chihiro_devs.pic8259_1->acknowledge();
2813	2813	}
2814	2814	return r;
2815	2815	}
2816	2816
2817	2817	WRITE_LINE_MEMBER(chihiro_state::chihiro_pit8254_out0_changed)
2818	2818	{
2819		if ( machine().device("pic8259_1") )
	2819	if ( machine().device<pic8259_device>("pic8259_1") )
2820	2820	{
2821		pic8259_ir0_w(machine().device("pic8259_1"), state);
	2821	machine().device<pic8259_device>("pic8259_1")->ir0_w(state);
2822	2822	}
2823	2823	}
2824	2824
r22822	r22823
2961	2961	if ((offset == 0) && (mem_mask == 0xff)) // 0 smbus status
2962	2962	{
2963	2963	if (!((smbusst.status ^ data) & 0x10)) // clearing interrupt
2964		pic8259_ir3_w(chihiro_devs.pic8259_2, 0); // IRQ 11
	2964	chihiro_devs.pic8259_2->ir3_w(0); // IRQ 11
2965	2965	smbusst.status &= ~data;
2966	2966	}
2967	2967	if ((offset == 0) && (mem_mask == 0xff0000)) // 2 smbus control
r22822	r22823
2982	2982	smbusst.status |= 0x10;
2983	2983	if (smbusst.control & 0x10)
2984	2984	{
2985		pic8259_ir3_w(chihiro_devs.pic8259_2, 1); // IRQ 11
	2985	chihiro_devs.pic8259_2->ir3_w(1); // IRQ 11
2986	2986	}
2987	2987	}
2988	2988	}
r22822	r22823
3010	3010	ADDRESS_MAP_END
3011	3011
3012	3012	static ADDRESS_MAP_START(xbox_map_io, AS_IO, 32, chihiro_state )
3013		AM_RANGE(0x0020, 0x0023) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	3013	AM_RANGE(0x0020, 0x0023) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
3014	3014	AM_RANGE(0x0040, 0x0043) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
3015		AM_RANGE(0x00a0, 0x00a3) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	3015	AM_RANGE(0x00a0, 0x00a3) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
3016	3016	AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w)
3017	3017	AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write)
3018	3018	AM_RANGE(0x8000, 0x80ff) AM_READWRITE(dummy_r, dummy_w)
r22822	r22823
3033	3033	smbus_register_device(0x45,smbus_callback_cx25871);
3034	3034	smbus_register_device(0x54,smbus_callback_eeprom);
3035	3035	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(chihiro_state::irq_callback),this));
3036		chihiro_devs.pic8259_1 = machine().device( "pic8259_1" );
3037		chihiro_devs.pic8259_2 = machine().device( "pic8259_2" );
	3036	chihiro_devs.pic8259_1 = machine().device<pic8259_device>( "pic8259_1" );
	3037	chihiro_devs.pic8259_2 = machine().device<pic8259_device>( "pic8259_2" );
3038	3038	chihiro_devs.ide = machine().device( "ide" );
3039	3039	if (machine().debug_flags & DEBUG_FLAG_ENABLED)
3040	3040	debug_console_register_command(machine(),"chihiro",CMDFLAG_NONE,0,1,4,chihiro_debug_commands);

trunk/src/mame/drivers/pinball2k.c

r22822	r22823
471	471
472	472	READ8_MEMBER(pinball2k_state::io20_r)
473	473	{
474		device_t *device = machine().device("pic8259_master");
	474	pic8259_device *device = machine().device<pic8259_device>("pic8259_master");
475	475	UINT8 r = 0;
476	476
477	477	// 0x22, 0x23, Cyrix configuration registers
r22822	r22823
484	484	}
485	485	else
486	486	{
487		r = pic8259_r(device, space, offset);
	487	r = device->read(space, offset);
488	488	}
489	489	return r;
490	490	}
491	491
492	492	WRITE8_MEMBER(pinball2k_state::io20_w)
493	493	{
494		device_t *device = machine().device("pic8259_master");
	494	pic8259_device *device = machine().device<pic8259_device>("pic8259_master");
495	495
496	496	// 0x22, 0x23, Cyrix configuration registers
497	497	if (offset == 0x02)
r22822	r22823
504	504	}
505	505	else
506	506	{
507		pic8259_w(device, space, offset, data);
	507	device->write(space, offset, data);
508	508	}
509	509	}
510	510
r22822	r22823
675	675	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
676	676	AM_RANGE(0x0070, 0x007f) AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
677	677	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(at_page8_r,              at_page8_w, 0xffffffff)
678		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_slave", pic8259_r, pic8259_w, 0xffffffff)
	678	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_slave", pic8259_device, read, write, 0xffffffff)
679	679	AM_RANGE(0x00c0, 0x00df) AM_READWRITE8(at_dma8237_2_r, at_dma8237_2_w, 0xffffffff)
680	680	AM_RANGE(0x00e8, 0x00eb) AM_NOP     // I/O delay port
681	681	AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w)
r22822	r22823
766	766
767	767	IRQ_CALLBACK_MEMBER(pinball2k_state::irq_callback)
768	768	{
769		return pic8259_acknowledge(m_pic8259_1);
	769	return m_pic8259_1->acknowledge();
770	770	}
771	771
772	772	void pinball2k_state::machine_start()
r22822	r22823
804	804	READ8_MEMBER(pinball2k_state::get_slave_ack)
805	805	{
806	806	if (offset==2) { // IRQ = 2
807		return pic8259_acknowledge(m_pic8259_2);
	807	return m_pic8259_2->acknowledge();
808	808	}
809	809	return 0x00;
810	810	}
r22822	r22823
818	818
819	819	static const struct pic8259_interface mediagx_pic8259_2_config =
820	820	{
821		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir2_w),
	821	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir2_w),
822	822	DEVCB_LINE_GND,
823	823	DEVCB_NULL
824	824	};
r22822	r22823
836	836	{
837	837	4772720/4,              /* heartbeat IRQ */
838	838	DEVCB_NULL,
839		DEVCB_DEVICE_LINE("pic8259_master", pic8259_ir0_w)
	839	DEVCB_DEVICE_LINE_MEMBER("pic8259_master", pic8259_device, ir0_w)
840	840	}, {
841	841	4772720/4,              /* dram refresh */
842	842	DEVCB_NULL,

trunk/src/mame/machine/pcshare.c

r22822	r22823
146	146	READ8_MEMBER( pcat_base_state::get_slave_ack )
147	147	{
148	148	if (offset==2) { // IRQ = 2
149		return pic8259_acknowledge(m_pic8259_2);
	149	return m_pic8259_2->acknowledge();
150	150	}
151	151	return 0x00;
152	152	}
r22822	r22823
160	160
161	161	static const struct pic8259_interface pic8259_2_config =
162	162	{
163		DEVCB_DEVICE_LINE("pic8259_1", pic8259_ir2_w),
	163	DEVCB_DEVICE_LINE_MEMBER("pic8259_1", pic8259_device, ir2_w),
164	164	DEVCB_LINE_GND,
165	165	DEVCB_NULL
166	166	};
167	167
168	168	IRQ_CALLBACK_MEMBER(pcat_base_state::irq_callback)
169	169	{
170		return pic8259_acknowledge(m_pic8259_1);
	170	return m_pic8259_1->acknowledge();
171	171	}
172	172
173	173	WRITE_LINE_MEMBER( pcat_base_state::at_pit8254_out0_changed )
174	174	{
175	175	if (m_pic8259_1 )
176	176	{
177		pic8259_ir0_w(m_pic8259_1, state);
	177	m_pic8259_1->ir0_w(state);
178	178	}
179	179	}
180	180
r22822	r22823
230	230
231	231	ADDRESS_MAP_START( pcat32_io_common, AS_IO, 32, pcat_base_state )
232	232	AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("dma8237_1", i8237_device, i8237_r, i8237_w, 0xffffffff)
233		AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8_LEGACY("pic8259_1", pic8259_r, pic8259_w, 0xffffffff)
	233	AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("pic8259_1", pic8259_device, read, write, 0xffffffff)
234	234	AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8_LEGACY("pit8254", pit8253_r, pit8253_w, 0xffffffff)
235	235	AM_RANGE(0x0060, 0x006f) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffffffff)
236	236	AM_RANGE(0x0070, 0x007f) AM_RAM //AM_DEVREADWRITE8("rtc", mc146818_device, read, write, 0xffffffff)
237	237	AM_RANGE(0x0080, 0x009f) AM_READWRITE8(dma_page_select_r,dma_page_select_w, 0xffffffff)//TODO
238		AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8_LEGACY("pic8259_2", pic8259_r, pic8259_w, 0xffffffff)
	238	AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("pic8259_2", pic8259_device, read, write, 0xffffffff)
239	239	AM_RANGE(0x00c0, 0x00df) AM_DEVREADWRITE8("dma8237_2", i8237_device, i8237_r, i8237_w, 0xffff)
240	240	ADDRESS_MAP_END
241	241

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team