MESS SVN History

15994 Revisions

r14536 Sunday 19th February, 2012 at 16:44:59 UTC by Miodrag Milanović
Converted ins8250 to use diserial [Carl] Added null_modem and serial_terminal as slot devices [Carl]

[src/emu]	diserial.c diserial.h
[src/emu/imagedev]	bitbngr.c bitbngr.h
[src/emu/machine]	ins8250.c ins8250.h microtch.c microtch.h pc16552d.c pc16552d.h
[src/mame/drivers]	adp.c cd32.c magtouch.c meritm.c pcat_nit.c tmaster.c
[src/mame/includes]	cd32.h
[src/mess]	mess.mak
[src/mess/drivers]	68ksbc.c altair.c amstr_pc.c avigo.c basic52.c bebox.c bullet.c ccs2422.c ccs2810.c cm1800.c czk80.c d6809.c dectalk.c digel804.c dms86.c dual68.c exp85.c h19.c h89.c horizon.c ht68k.c imds.c ip22.c ipc.c isbc.c jupiter.c mccpm.c microdec.c mits680b.c mpz80.c msbc1.c ob68k1a.c okean240.c pc.c pc1512.c pcw16.c pdp11.c pes.c pimps.c portfoli.c qtsbc.c rvoice.c sacstate.c sage2.c sgi_ip2.c sun1.c super6.c svi318.c swtpc.c systec.c tricep.c tsispch.c vector4.c votrpss.c votrtnt.c xor100.c zexall.c zrt80.c zsbc3.c
[src/mess/includes]	pc.h pc1512.h portfoli.h
[src/mess/machine]	bebox.c isa.c isa.h isa_com.c isa_com.h null_modem.c* null_modem.h* pc.c ~~pc_mouse.c~~ ~~pc_mouse.h~~ s100_wunderbus.c s100_wunderbus.h ser_mouse.c ser_mouse.h serial.c serial.h svi318.c teleprinter.c terminal.c terminal.h

src/mame/includes/cd32.h
r14535	r14536
8	8	#define __CUBOCD32_H__
9	9
10	10	#include "includes/amiga.h"
	11	#include "machine/microtch.h"
11	12
12	13	class cd32_state : public amiga_state
13	14	{
14	15	public:
15	16	cd32_state(const machine_config &mconfig, device_type type, const char *tag)
16		: amiga_state(mconfig, type, tag) { }
	17	: amiga_state(mconfig, type, tag),
	18	m_microtouch(*this, "microtouch")
	19	{ }
17	20
	21	required_device<microtouch_device> m_microtouch;
	22
	23	DECLARE_WRITE8_MEMBER(microtouch_tx);
18	24	UINT16 m_potgo_value;
19	25	int m_cd32_shifter[2];
20	26	void (*m_input_hack)(running_machine &machine);

src/mame/drivers/adp.c
r14535	r14536
157	157	public:
158	158	adp_state(const machine_config &mconfig, device_type type, const char *tag)
159	159	: driver_device(mconfig, type, tag),
160		m_h63484(*this, "h63484")
	160	m_h63484(*this, "h63484"),
	161	m_microtouch(*this, "microtouch")
161	162	{ }
162	163
163	164	required_device<h63484_device> m_h63484;
164
	165	required_device<microtouch_device> m_microtouch;
	166
	167	DECLARE_WRITE8_MEMBER(microtouch_tx);
165	168	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
166	169
167	170	/* misc */
r14535	r14536
262	265	{
263	266	adp_state *state = device->machine().driver_data<adp_state>();
264	267	device_set_input_line_and_vector(state->m_maincpu, 4, HOLD_LINE, vector);
265		};
	268	}
266	269
267	270	static void duart_tx( device_t *device, int channel, UINT8 data )
268	271	{
	272	adp_state *state = device->machine().driver_data<adp_state>();
269	273	if (channel == 0)
270	274	{
271		microtouch_rx(1, &data);
	275	state->m_microtouch->rx(*memory_nonspecific_space(device->machine()), 0, data);
272	276	}
273		};
	277	}
274	278
275		stat~~ic void~~ microtouch_tx~~( running_machine &machine, UINT8 data~~ )
	279	WRITE8_MEMBER( adp_state::microtouch_tx )
276	280	{
277		adp_state *state = machine.driver_data<adp_state>();
278		duart68681_rx_data(state->m_duart, 0, data);
	281	duart68681_rx_data(m_duart, 0, data);
279	282	}
280	283
281	284	static UINT8 duart_input( device_t *device )
r14535	r14536
283	286	return input_port_read(device->machine(), "DSW1");
284	287	}
285	288
	289	static const microtouch_interface adb_microtouch_config =
	290	{
	291	DEVCB_DRIVER_MEMBER(adp_state, microtouch_tx),
	292	NULL
	293	};
	294
286	295	static MACHINE_START( skattv )
287	296	{
288	297	adp_state *state = machine.driver_data<adp_state>();
289		microtouch_init(machine, microtouch_tx, 0);
290	298
291	299	state->m_maincpu = machine.device("maincpu");
292	300	state->m_duart = machine.device("duart68681");
r14535	r14536
530	538	#endif
531	539
532	540	static INPUT_PORTS_START( skattv )
533		PORT_INCLUDE(microtouch)
534
535	541	PORT_START("DSW1")
536	542	PORT_BIT( 0x0001, IP_ACTIVE_HIGH, IPT_COIN5 )
537	543	PORT_BIT( 0x0002, IP_ACTIVE_LOW, IPT_COIN6 )
r14535	r14536
661	667	MCFG_MACHINE_RESET(skattv)
662	668
663	669	MCFG_DUART68681_ADD( "duart68681", XTAL_8_664MHz / 2, skattv_duart68681_config )
	670	MCFG_MICROTOUCH_ADD( "microtouch", adb_microtouch_config )
664	671
665	672	MCFG_SCREEN_ADD("screen", RASTER)
666	673	MCFG_SCREEN_REFRESH_RATE(60)
r14535	r14536
692	699	MCFG_MACHINE_RESET(skattv)
693	700
694	701	MCFG_DUART68681_ADD( "duart68681", XTAL_8_664MHz / 2, skattv_duart68681_config )
	702	MCFG_MICROTOUCH_ADD( "microtouch", adb_microtouch_config )
695	703
696	704	MCFG_SCREEN_ADD("screen", RASTER)
697	705	MCFG_SCREEN_REFRESH_RATE(60)
r14535	r14536
719	727	MCFG_CPU_PROGRAM_MAP(backgamn_mem)
720	728
721	729	MCFG_DUART68681_ADD( "duart68681", XTAL_8_664MHz / 2, skattv_duart68681_config )
	730	MCFG_MICROTOUCH_ADD( "microtouch", adb_microtouch_config )
722	731
723	732	MCFG_MACHINE_START(skattv)
724	733	MCFG_MACHINE_RESET(skattv)

src/mame/drivers/meritm.c
r14535	r14536
129	129	meritm_state(const machine_config &mconfig, device_type type, const char *tag)
130	130	: driver_device(mconfig, type, tag),
131	131	m_v9938_0(*this, "v9938_0"),
132		m_v9938_1(*this, "v9938_1") { }
	132	m_v9938_1(*this, "v9938_1"),
	133	m_microtouch(*this, "microtouch") { }
133	134
	135	DECLARE_WRITE8_MEMBER(microtouch_tx);
134	136	UINT8* m_ram;
135	137	device_t *m_z80pio[2];
136	138	int m_vint;
r14535	r14536
144	146	ds1204_t m_ds1204;
145	147	required_device<v9938_device> m_v9938_0;
146	148	required_device<v9938_device> m_v9938_1;
	149	required_device<microtouch_device> m_microtouch;
147	150	};
148	151
149	152
r14535	r14536
271	274	*
272	275	*************************************/
273	276
274		static void pc16650d_tx_callback(int channel, int count, UINT8* data)
	277	static void pc16650d_tx_callback(running_machine &machine, int channel, int count, UINT8* data)
275	278	{
276		microtouch_rx(count, data);
277		};
	279	meritm_state *state = machine.driver_data<meritm_state>();
	280	for(int i = 0; i < count; i++)
	281	state->m_microtouch->rx(*memory_nonspecific_space(machine), 0, data[i]);
	282	}
278	283
279		~~static void~~ meritm_microtouch_tx~~_callback(running_machine &machine, UINT8 data~~)
	284	WRITE8_MEMBER(meritm_state::microtouch_tx)
280	285	{
281		pc16552d_rx_data(machine, 0, 0, data);
282		};
	286	pc16552d_rx_data(space.machine(), 0, 0, data);
	287	}
283	288
284	289	/*************************************
285	290	*
286	291	* Microtouch touch coordinate transformation
287	292	*
288	293	*************************************/
289		~~static int~~ meritm_touch_coord_transform~~(running_machine &machine, int touch_x, int touch_y~~)
	294	MICROTOUCH_TOUCH(meritm_touch_coord_transform)
290	295	{
291	296	int xscr = (int)((double)(touch_x)/0x4000544);
292	297	int yscr = (int)((double)(touch_y)/0x4000480);
r14535	r14536
311	316	return 1;
312	317	}
313	318
	319	static const microtouch_interface meritm_microtouch_config =
	320	{
	321	DEVCB_DRIVER_MEMBER(meritm_state, microtouch_tx),
	322	meritm_touch_coord_transform
	323	};
	324
314	325	/*************************************
315	326	*
316	327	* Video
r14535	r14536
627	638	*************************************/
628	639
629	640	static INPUT_PORTS_START(meritm_crt260)
630		PORT_INCLUDE(microtouch)
631
632	641	PORT_START("PIO1_PORTA")
633	642	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN )
634	643	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN )
r14535	r14536
997	1006	{
998	1007	MACHINE_START_CALL(meritm_crt250_questions);
999	1008	pc16552d_init(machine, 0, UART_CLK, NULL, pc16650d_tx_callback);
1000		microtouch_init(machine, meritm_microtouch_tx_callback, meritm_touch_coord_transform);
1001	1009	}
1002	1010
1003	1011	static MACHINE_START(meritm_crt260)
r14535	r14536
1014	1022	meritm_switch_banks(machine);
1015	1023	MACHINE_START_CALL(merit_common);
1016	1024	pc16552d_init(machine, 0, UART_CLK, NULL, pc16650d_tx_callback);
1017		microtouch_init(machine, meritm_microtouch_tx_callback, meritm_touch_coord_transform);
1018	1025	state_save_register_global(machine, state->m_bank);
1019	1026	state_save_register_global(machine, state->m_psd_a15);
1020	1027	state_save_register_global_pointer(machine, state->m_ram, 0x8000);
r14535	r14536
1089	1096	MCFG_SOUND_ADD("aysnd", AY8910, SYSTEM_CLK/12)
1090	1097	MCFG_SOUND_CONFIG(ay8910_config)
1091	1098	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
	1099
	1100	MCFG_MICROTOUCH_ADD("microtouch", meritm_microtouch_config)
1092	1101	MACHINE_CONFIG_END
1093	1102
1094	1103	static MACHINE_CONFIG_DERIVED( meritm_crt250_questions, meritm_crt250 )

src/mame/drivers/cd32.c
r14535	r14536
35	35	#include "includes/cd32.h"
36	36	#include "sound/cdda.h"
37	37	#include "imagedev/chd_cd.h"
38		#include "machine/microtch.h"
39	38	#include "machine/amigafdc.h"
40	39
41	40	#define CD32PAL_XTAL_X1 XTAL_28_37516MHz
r14535	r14536
760	759	I2CMEM_SLAVE_ADDRESS, NVRAM_PAGE_SIZE, NVRAM_SIZE
761	760	};
762	761
	762	static const microtouch_interface cd32_microtouch_config =
	763	{
	764	DEVCB_DRIVER_MEMBER(cd32_state, microtouch_tx),
	765	NULL
	766	};
	767
763	768	static MACHINE_CONFIG_START( cd32base, cd32_state )
764	769
765	770	/* basic machine hardware */
r14535	r14536
800	805	MCFG_MOS8520_ADD("cia_0", AMIGA_68EC020_PAL_CLOCK / 10, cia_0_intf)
801	806	MCFG_MOS8520_ADD("cia_1", AMIGA_68EC020_PAL_CLOCK / 10, cia_1_intf)
802	807
	808	MCFG_MICROTOUCH_ADD( "microtouch", cd32_microtouch_config )
	809
803	810	/* fdc */
804	811	MCFG_AMIGA_FDC_ADD("fdc", AMIGA_68000_NTSC_CLOCK)
805	812	MACHINE_CONFIG_END
r14535	r14536
1375	1382
1376	1383	static INPUT_PORTS_START( odeontw2 )
1377	1384	// PORT_INCLUDE( cd32 )
1378		PORT_INCLUDE( microtouch )
1379
1380	1385	PORT_START("CIA0PORTA")
1381	1386	PORT_BIT( 0xff, IP_ACTIVE_LOW, IPT_UNKNOWN )
1382	1387
r14535	r14536
1440	1445
1441	1446	static void serial_w(running_machine &machine, UINT16 data)
1442	1447	{
	1448	cd32_state *state = machine.driver_data<cd32_state>();
1443	1449	UINT8 data8 = data & 0xff;
1444	1450	if ( data8 != 0x00 )
1445		microtouch_rx(1, &data8);
	1451	state->m_microtouch->rx(*memory_nonspecific_space(machine), 0, data8);
1446	1452	}
1447	1453
1448		stat~~ic void~~ microtouch_tx~~(running_machine &machine, UINT8 data~~)
	1454	WRITE8_MEMBER (cd32_state::microtouch_tx)
1449	1455	{
1450		amiga_serial_in_w(machine, data);
	1456	amiga_serial_in_w(machine(), data);
1451	1457	}
1452	1458
1453	1459	static DRIVER_INIT( odeontw2 )
r14535	r14536
1472	1478
1473	1479	/* input hack */
1474	1480	state->m_input_hack = NULL;
1475
1476		/* touch screen */
1477		microtouch_init(machine, microtouch_tx, NULL);
1478	1481	}
1479	1482
1480	1483	/***************************************************************************************************/

src/mame/drivers/pcat_nit.c
r14535	r14536
96	96	{
97	97	public:
98	98	pcat_nit_state(const machine_config &mconfig, device_type type, const char *tag)
99		: driver_device(mconfig, type, tag) { }
	99	: driver_device(mconfig, type, tag),
	100	m_uart(*this, "ns16450_0"),
	101	m_microtouch(*this, "microtouch")
	102	{ }
100	103
101	104	UINT8 *m_banked_nvram;
	105	required_device<ns16450_device> m_uart;
	106	required_device<microtouch_serial_device> m_microtouch;
	107
	108	DECLARE_WRITE_LINE_MEMBER(microtouch_out);
	109	DECLARE_WRITE_LINE_MEMBER(microtouch_in);
102	110	};
103	111
104
105		static void pcat_nit_microtouch_tx_callback(running_machine &machine, UINT8 data)
	112	WRITE_LINE_MEMBER(pcat_nit_state::microtouch_out)
106	113	{
107		ins8250_receive(machine.device("ns16450_0"), data);
108		};
	114	m_microtouch->rx(state);
	115	}
109	116
110		~~static~~ I~~NS8250_~~TRANSMIT( pcat_nit_~~com_~~transmit )
	117	WRITE_LINE_MEMBER(pcat_nit_state::microtouch_in)
111	118	{
112		UINT8 data8 = data;
113		microtouch_rx(1, &data8);
	119	m_uart->rx_w(state);
114	120	}
115	121
116	122	static WRITE_LINE_DEVICE_HANDLER( at_com_interrupt_1 )
r14535	r14536
120	126
121	127	static const ins8250_interface pcat_nit_com0_interface =
122	128	{
123		1843200,
	129	DEVCB_DRIVER_LINE_MEMBER(pcat_nit_state, microtouch_out),
	130	DEVCB_NULL,
	131	DEVCB_NULL,
124	132	DEVCB_LINE(at_com_interrupt_1),
125		pcat_nit_com_transmit,
126		NULL,
127		NULL
	133	DEVCB_NULL,
	134	DEVCB_NULL
128	135	};
129	136
	137	static const microtouch_serial_interface pcat_nit_microtouch_interface =
	138	{
	139	DEVCB_DRIVER_LINE_MEMBER(pcat_nit_state, microtouch_in)
	140	};
	141
130	142	/*************************************
131	143	*
132	144	* ROM banking
r14535	r14536
194	206	AM_IMPORT_FROM(pcat32_io_common)
195	207	AM_RANGE(0x0278, 0x027f) AM_READ8(pcat_nit_io_r, 0xffffffff) AM_WRITENOP
196	208	AM_RANGE(0x0280, 0x0283) AM_READNOP
197		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ns16450_0", ins8250_r, ins8250_w, 0xffffffff)
	209	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ns16450_0", ns16450_device, ins8250_r, ins8250_w, 0xffffffff)
198	210	ADDRESS_MAP_END
199	211
200	212	static INPUT_PORTS_START( pcat_nit )
201		PORT_INCLUDE(microtouch)
202
203	213	PORT_START("IN0")
204	214	PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_OTHER) PORT_NAME("Clear") PORT_CODE(KEYCODE_C)
205	215	PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_SERVICE)
r14535	r14536
224	234	memory_configure_bank(machine, "rombank", 0, 0x80, machine.region("game_prg")->base(), 0x8000 );
225	235	memory_set_bank(machine, "rombank", 0);
226	236
227		microtouch_init(machine, pcat_nit_microtouch_tx_callback, NULL);
	237	//microtouch_init(machine, pcat_nit_microtouch_tx_callback, NULL);
228	238	}
229	239
230	240	static MACHINE_CONFIG_START( pcat_nit, pcat_nit_state )
r14535	r14536
245	255
246	256	// MCFG_FRAGMENT_ADD( at_kbdc8042 )
247	257	MCFG_FRAGMENT_ADD( pcat_common )
248		MCFG_NS16450_ADD( "ns16450_0", pcat_nit_com0_interface )
	258	MCFG_NS16450_ADD( "ns16450_0", pcat_nit_com0_interface, XTAL_1_8432MHz )
	259	MCFG_MICROTOUCH_SERIAL_ADD( "microtouch", pcat_nit_microtouch_interface, 9600 ) // rate?
249	260
250	261	MCFG_NVRAM_ADD_0FILL("nvram")
251	262

src/mame/drivers/magtouch.c
r14535	r14536
85	85	{
86	86	public:
87	87	magtouch_state(const machine_config &mconfig, device_type type, const char *tag)
88		: driver_device(mconfig, type, tag) { }
	88	: driver_device(mconfig, type, tag),
	89	m_uart(*this, "ns16450_0"),
	90	m_microtouch(*this, "microtouch")
	91	{ }
89	92
	93	required_device<ns16450_device> m_uart;
	94	required_device<microtouch_serial_device> m_microtouch;
	95
	96	DECLARE_WRITE_LINE_MEMBER(microtouch_out);
	97	DECLARE_WRITE_LINE_MEMBER(microtouch_in);
90	98	};
91	99
92	100
r14535	r14536
96	104	*
97	105	*************************************/
98	106
99		~~static void~~ magtouch_microtouch_~~tx_callback(r~~u~~nning_machine &machine, UINT8 da~~ta)
	107	WRITE_LINE_MEMBER(magtouch_state::microtouch_out)
100	108	{
101		ins8250_receive(machine.device("ns16450_0"), data);
102		};
	109	m_microtouch->rx(state);
	110	}
103	111
104		~~static~~ I~~NS8250_~~TRANSMIT( magtouch_~~com_~~transmit )
	112	WRITE_LINE_MEMBER(magtouch_state::microtouch_in)
105	113	{
106		UINT8 data8 = data;
107		microtouch_rx(1, &data8);
	114	m_uart->rx_w(state);
108	115	}
109	116
110	117	static WRITE_LINE_DEVICE_HANDLER( at_com_interrupt_1 )
r14535	r14536
114	121
115	122	static const ins8250_interface magtouch_com0_interface =
116	123	{
117		1843200,
	124	DEVCB_DRIVER_LINE_MEMBER(magtouch_state, microtouch_out),
	125	DEVCB_NULL,
	126	DEVCB_NULL,
118	127	DEVCB_LINE(at_com_interrupt_1),
119		magtouch_com_transmit,
120		NULL,
121		NULL
	128	DEVCB_NULL,
	129	DEVCB_NULL
122	130	};
123	131
	132	static const microtouch_serial_interface magtouch_microtouch_interface =
	133	{
	134	DEVCB_DRIVER_LINE_MEMBER(magtouch_state, microtouch_in)
	135	};
	136
124	137	/*************************************
125	138	*
126	139	* ROM banking
r14535	r14536
161	174	static ADDRESS_MAP_START( magtouch_io, AS_IO, 32 )
162	175	AM_IMPORT_FROM(pcat32_io_common)
163	176	AM_RANGE(0x02e0, 0x02e7) AM_READWRITE8(magtouch_io_r, magtouch_io_w, 0xffffffff)
164		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ns16450_0", ins8250_r, ins8250_w, 0xffffffff)
	177	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ns16450_0", ns16450_device, ins8250_r, ins8250_w, 0xffffffff)
165	178	ADDRESS_MAP_END
166	179
167	180	static INPUT_PORTS_START( magtouch )
168		PORT_INCLUDE(microtouch)
169
170	181	PORT_START("IN0")
171	182	PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_OTHER) PORT_NAME("Clear") PORT_CODE(KEYCODE_C)
172	183	PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_SERVICE)
r14535	r14536
191	202	memory_configure_bank(machine, "rombank", 0, 0x80, machine.region("game_prg")->base(), 0x8000 );
192	203	memory_set_bank(machine, "rombank", 0);
193	204
194		microtouch_init(machine, magtouch_microtouch_tx_callback, NULL);
	205	// microtouch_init(machine, magtouch_microtouch_tx_callback, NULL);
195	206	}
196	207
197	208	static MACHINE_CONFIG_START( magtouch, magtouch_state )
r14535	r14536
212	223
213	224	// MCFG_FRAGMENT_ADD( at_kbdc8042 )
214	225	MCFG_FRAGMENT_ADD( pcat_common )
215		MCFG_NS16450_ADD( "ns16450_0", magtouch_com0_interface )
216
	226	MCFG_NS16450_ADD( "ns16450_0", magtouch_com0_interface, XTAL_1_8432MHz )
	227	MCFG_MICROTOUCH_SERIAL_ADD( "microtouch", magtouch_microtouch_interface, 9600 ) // rate?
217	228	MACHINE_CONFIG_END
218	229
219	230

src/mame/drivers/tmaster.c
r14535	r14536
121	121	public:
122	122	tmaster_state(const machine_config &mconfig, device_type type, const char *tag)
123	123	: driver_device(mconfig, type, tag),
124		m_maincpu(*this,"maincpu")
	124	m_maincpu(*this,"maincpu"),
	125	m_microtouch(*this,"microtouch")
125	126	{ }
126	127
	128	DECLARE_WRITE8_MEMBER(microtouch_tx);
	129
127	130	int m_okibank;
128	131	UINT8 m_rtc_ram[8];
129	132	bitmap_ind16 m_bitmap[2][2];
r14535	r14536
141	144	device_t *m_duart68681;
142	145
143	146	required_device<cpu_device> m_maincpu;
	147	optional_device<microtouch_device> m_microtouch;
144	148	};
145	149
146	150
r14535	r14536
179	183
180	184	static void duart_tx(device_t *device, int channel, UINT8 data)
181	185	{
	186	tmaster_state *state = device->machine().driver_data<tmaster_state>();
182	187	if ( channel == 0 )
183	188	{
184		microtouch_rx(1, &data);
	189	state->m_microtouch->rx(*memory_nonspecific_space(device->machine()), 0, data);
185	190	}
186	191	};
187	192
188		stat~~ic void~~ microtouch_tx~~(running_machine~~ ~~&machine, UINT8 data~~)
	193	WRITE8_MEMBER( tmaster_state::microtouch_tx )
189	194	{
190		tmaster_state *state = machine.driver_data<tmaster_state>();
191		duart68681_rx_data(state->m_duart68681, 0, data);
	195	duart68681_rx_data(m_duart68681, 0, data);
192	196	}
193	197
	198	static const microtouch_interface tmaster_microtouch_config =
	199	{
	200	DEVCB_DRIVER_MEMBER(tmaster_state, microtouch_tx),
	201	NULL
	202	};
194	203
195	204	/***************************************************************************
196	205
r14535	r14536
766	775
767	776	***************************************************************************/
768	777	static INPUT_PORTS_START( tm )
769		PORT_INCLUDE( microtouch )
770
771	778	PORT_START("COIN")
772	779	PORT_BIT( 0x0001, IP_ACTIVE_LOW, IPT_COIN5 ) // "M. Coin 1 Input"
773	780	PORT_BIT( 0x0002, IP_ACTIVE_LOW, IPT_COIN6 ) // "M. Coin 2 Input"
r14535	r14536
788	795	INPUT_PORTS_END
789	796
790	797	static INPUT_PORTS_START( tmaster )
791		PORT_INCLUDE( microtouch )
792
793	798	PORT_START("COIN")
794	799	PORT_BIT( 0x0001, IP_ACTIVE_LOW, IPT_COIN1 ) // "M. Coin 1 Input"
795	800	PORT_BIT( 0x0002, IP_ACTIVE_LOW, IPT_COIN2 ) // "M. Coin 2 Input"
r14535	r14536
863	868
864	869	***************************************************************************/
865	870
866		static MACHINE_START( tmaster )
867		{
868		microtouch_init(machine, microtouch_tx, 0);
869		}
870
871	871	static MACHINE_RESET( tmaster )
872	872	{
873	873	tmaster_state *state = machine.driver_data<tmaster_state>();
r14535	r14536
904	904	MCFG_CPU_PROGRAM_MAP(tmaster_map)
905	905	MCFG_TIMER_ADD_SCANLINE("scantimer", tm3k_interrupt, "screen", 0, 1)
906	906
907		MCFG_MACHINE_START(tmaster)
908	907	MCFG_MACHINE_RESET(tmaster)
909	908
910	909	MCFG_DUART68681_ADD( "duart68681", XTAL_8_664MHz / 2 /??/, tmaster_duart68681_config )
	910	MCFG_MICROTOUCH_ADD( "microtouch", tmaster_microtouch_config )
911	911
912	912	MCFG_NVRAM_ADD_0FILL("nvram")
913	913

src/emu/imagedev/bitbngr.c
r14535	r14536
303	303
304	304	void bitbanger_device::device_start(void)
305	305	{
306		const bitbanger_config config = (const bitbanger_config ) static_config();
307
308	306	/* output config */
309	307	m_build_count = 0;
310	308	m_output_timer = timer_alloc(TIMER_OUTPUT);
r14535	r14536
316	314	m_input_buffer_cursor = 0;
317	315
318	316	/* defaults */
319		m_mode = config->m_default_mode;
320		m_baud = config->m_default_baud;
321		m_tune = config->m_default_tune;
	317	m_mode = m_default_mode;
	318	m_baud = m_default_baud;
	319	m_tune = m_default_tune;
322	320	m_current_baud = attotime::from_hz(baud_value());
323	321
324	322	/* callback */
325		m_input_c~~allback~~.resolve(~~config->~~m_input_callback, *this);
	323	m_input_func.resolve(m_input_callback, *this);
326	324	}
327	325
328	326
r14535	r14536
333	331
334	332	void bitbanger_device::device_config_complete(void)
335	333	{
	334	const _bitbanger_config intf = reinterpret_cast<const _bitbanger_config >(static_config());
	335	if(intf != NULL)
	336	{
	337	static_cast<_bitbanger_config >(this) = *intf;
	338	}
	339	else
	340	{
	341	memset(&m_input_callback, 0, sizeof(m_input_callback));
	342	m_default_mode = 0;
	343	m_default_baud = 0;
	344	m_default_tune = 0;
	345	}
336	346	update_names();
337	347	}
338	348
r14535	r14536
433	443	if (m_current_input != line)
434	444	{
435	445	m_current_input = line;
436		if (!m_input_callback.isnull())
437		{
438		m_input_callback(line ? ASSERT_LINE : CLEAR_LINE);
439		}
	446	m_input_func(line ? ASSERT_LINE : CLEAR_LINE);
440	447	}
441	448	}
442	449

src/emu/imagedev/bitbngr.h
r14535	r14536
84	84
85	85
86	86	class bitbanger_device : public device_t,
87		public device_image_interface
	87	public device_image_interface,
	88	public _bitbanger_config
88	89	{
89	90	public:
90	91	// construction/destruction
r14535	r14536
145	146	// variables
146	147	emu_timer * m_output_timer;
147	148	emu_timer * m_input_timer;
148		devcb_resolved_write_line m_input_c~~allback~~;
	149	devcb_resolved_write_line m_input_func;
149	150	int m_output_value;
150	151	int m_build_count;
151	152	int m_build_byte;

src/emu/diserial.c
r14535	r14536
76	76	int previous_bit;
77	77
78	78	//LOG(("receive register receive bit: %1x\n",bit));
79		previous_bit = m_rcv_register_data & 1;
	79	previous_bit = (m_rcv_register_data & 0x8000) && 1;
80	80
81	81	/* shift previous bit 7 out */
82		m_rcv_register_data = m_rcv_register_data<<1;
	82	m_rcv_register_data = m_rcv_register_data>>1;
83	83	/* shift new bit in */
84		m_rcv_register_data = (m_rcv_register_data & 0xfffe) \| bit;
	84	m_rcv_register_data = (m_rcv_register_data & 0x7fff) \| (bit<<15);
85	85	/* update bit count received */
86	86	m_rcv_bit_count_received++;
87	87
r14535	r14536
123	123
124	124	void device_serial_interface::receive_register_extract()
125	125	{
126		unsigned long data_shift;
127	126	UINT8 data;
128	127
129	128	receive_register_reset();
130	129
131		data_shift = 0;
132
133		/* if parity is even or odd, there should be a parity bit in the stream! */
134		if (m_df_parity!=SERIAL_PARITY_NONE)
135		{
136		data_shift++;
137		}
138
139		data_shift+=m_df_stop_bit_count;
140
141	130	/* strip off stop bits and parity */
142		data = m_rcv_register_data>>~~data~~_shift;
	131	data = m_rcv_register_data>>(16-m_rcv_bit_count);
143	132
144	133	/* mask off other bits so data byte has 0's in unused bits */
145		data = data & (0x0ff
146		>>
147		(8-(m_df_word_length)));
	134	data &= ~(0xff<<m_df_word_length);
148	135
149	136	m_rcv_byte_received = data;
150	137
	138	if(m_df_parity == SERIAL_PARITY_NONE)
	139	return;
	140
	141	//unsigned char computed_parity;
	142	//unsigned char parity_received;
	143
	144	/* get state of parity bit received */
	145	//parity_received = (m_rcv_register_data>>m_df_word length) & 0x01;
	146
151	147	/* parity enable? */
152	148	switch (m_df_parity)
153	149	{
154		case SERIAL_PARITY_NONE:
155		break;
156
157	150	/* check parity */
158	151	case SERIAL_PARITY_ODD:
159	152	case SERIAL_PARITY_EVEN:
160	153	{
161		//unsigned char computed_parity;
162		//unsigned char parity_received;
163
164		/* get state of parity bit received */
165		//parity_received = (m_rcv_register_data>>m_df_stop_bit_count) & 0x01;
166
167	154	/* compute parity for received bits */
168	155	//computed_parity = serial_helper_get_parity(data);
169	156
r14535	r14536
182	169
183	170	}
184	171	break;
	172	case SERIAL_PARITY_MARK:
	173	case SERIAL_PARITY_SPACE:
	174	//computed_parity = parity_received;
	175	break;
185	176	}
186	177	}
187	178
r14535	r14536
225	216	int databit;
226	217
227	218	/* get bit from data */
228		databit = (transmit_data~~>>(m_df_word_length-1))~~ & 0x01;
	219	databit = transmit_data & 0x01;
229	220	/* add bit to formatted byte */
230	221	transmit_register_add_bit(databit);
231		transmit_data = transmit_data<<1;
	222	transmit_data = transmit_data>>1;
232	223	}
233	224
234	225	/* parity */
235	226	if (m_df_parity!=SERIAL_PARITY_NONE)
236	227	{
237	228	/* odd or even parity */
238		unsigned char parity;
	229	unsigned char parity = 0;
	230	switch(m_df_parity)
	231	{
	232	case SERIAL_PARITY_EVEN:
	233	case SERIAL_PARITY_ODD:
239	234
240		/* get parity */
241		/* if parity = 0, data has even parity - i.e. there is an even number of one bits in the data */
242		/* if parity = 1, data has odd parity - i.e. there is an odd number of one bits in the data */
243		parity = serial_helper_get_parity(data_byte);
244
	235	/* get parity */
	236	/* if parity = 0, data has even parity - i.e. there is an even number of one bits in the data */
	237	/* if parity = 1, data has odd parity - i.e. there is an odd number of one bits in the data */
	238	parity = serial_helper_get_parity(data_byte);
	239	break;
	240	case SERIAL_PARITY_MARK:
	241	parity = 1;
	242	break;
	243	case SERIAL_PARITY_SPACE:
	244	parity = 0;
	245	break;
	246	}
245	247	transmit_register_add_bit(parity);
246	248	}
247	249
r14535	r14536
258	260	{
259	261	int bit;
260	262
261		bit = (m_tra_register_data>>
262		(m_tra_bit_count - 1 -
263		m_tra_bit_count_transmitted)) & 0x01;
	263	bit = (m_tra_register_data>>(m_tra_bit_count-1-m_tra_bit_count_transmitted))&1;
264	264
265	265	m_tra_bit_count_transmitted++;
266	266

src/emu/diserial.h
r14535	r14536
19	19	{
20	20	SERIAL_PARITY_NONE, /* no parity. a parity bit will not be in the transmitted/received data */
21	21	SERIAL_PARITY_ODD, /* odd parity */
22		SERIAL_PARITY_EVEN /* even parity */
	22	SERIAL_PARITY_EVEN, /* even parity */
	23	SERIAL_PARITY_MARK, /* one parity */
	24	SERIAL_PARITY_SPACE /* zero parity */
23	25	};
24	26
25	27	/*

src/emu/machine/pc16552d.c
r14535	r14536
55	55	PC16552D_CHANNEL ch[2];
56	56	int frequency;
57	57	void (* irq_handler)(running_machine &machine, int channel, int value);
58		void (* tx_callback)(int channel, int count, UINT8* data);
	58	void (* tx_callback)(running_machine &machine, int channel, int count, UINT8* data);
59	59	} PC16552D_REGS;
60	60
61	61	#define MAX_PC16552D_CHIPS 4
r14535	r14536
151	151	ch = &duart[chip].ch[channel];
152	152
153	153	if (duart[chip].tx_callback)
154		duart[chip].tx_callback(channel, ch->tx_fifo_num, ch->tx_fifo);
	154	duart[chip].tx_callback(machine, channel, ch->tx_fifo_num, ch->tx_fifo);
155	155
156	156	ch->tx_fifo_num = 0;
157	157
r14535	r14536
387	387
388	388	/*****************************************************************************/
389	389
390		void pc16552d_init(running_machine &machine, int chip, int frequency, void (* irq_handler)(running_machine &machine, int channel, int value), void (* tx_callback)(int channel, int count, UINT8* data))
	390	void pc16552d_init(running_machine &machine, int chip, int frequency, void (* irq_handler)(running_machine &machine, int channel, int value), void (* tx_callback)(running_machine &machine, int channel, int count, UINT8* data))
391	391	{
392	392	memset(&duart[chip], 0, sizeof(PC16552D_REGS));
393	393

src/emu/machine/pc16552d.h
r14535	r14536
1	1	#ifndef PC16552D_H
2	2	#define PC16552D_H
3	3
4		void pc16552d_init(running_machine &machine, int chip, int frequency, void (* irq_handler)(running_machine &machine, int channel, int value), void (* tx_callback)(int channel, int count, UINT8* data));
	4	void pc16552d_init(running_machine &machine, int chip, int frequency, void (* irq_handler)(running_machine &machine, int channel, int value), void (* tx_callback)(running_machine &machine, int channel, int count, UINT8* data));
5	5	void pc16552d_rx_data(running_machine &machine, int chip, int channel, UINT8 data);
6	6
7	7	READ8_HANDLER(pc16552d_0_r);

src/emu/machine/ins8250.c
r14535	r14536
73	73
74	74	**********************************************************************/
75	75
76		#include "emu.h"
77	76	#include "machine/ins8250.h"
78	77
	78	const device_type INS8250 = &device_creator<ins8250_device>;
	79	const device_type NS16450 = &device_creator<ns16450_device>;
	80	const device_type NS16550 = &device_creator<ns16550_device>;
79	81
80		#define LOG(LEVEL,N,M,A) \
81		do { \
82		if(LEVEL>=N) \
83		{ \
84		if( M ) \
85		logerror("%-24s",(char*)M ); \
86		logerror A; \
87		} \
88		} while (0)
	82	ins8250_uart_device::ins8250_uart_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock)
	83	: device_t(mconfig, type, name, tag, owner, clock),
	84	device_serial_interface(mconfig, *this)
	85	{
	86	}
89	87
	88	ins8250_device::ins8250_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	89	: ins8250_uart_device(mconfig, INS8250, "ins8250", tag, owner, clock)
	90	{
	91	m_device_type = TYPE_INS8250;
	92	}
90	93
91		/* device types */
92		enum {
93		TYPE_INS8250 = 0,
94		TYPE_INS8250A,
95		TYPE_NS16450,
96		TYPE_NS16550,
97		TYPE_NS16550A,
98		TYPE_PC16550D,
	94	ns16450_device::ns16450_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	95	: ins8250_uart_device(mconfig, NS16450, "ns16450", tag, owner, clock)
	96	{
	97	m_device_type = TYPE_NS16450;
	98	}
99	99
100		NUM_TYPES
101		};
	100	ns16550_device::ns16550_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	101	: ins8250_uart_device(mconfig, NS16550, "ns16550", tag, owner, clock)
	102	{
	103	m_device_type = TYPE_NS16550;
	104	}
102	105
103
104		/* device tags */
105		static const char * const device_tags[NUM_TYPES] = { "ins8250", "ins8250a", "ns16450", "ns16550", "ns16550a", "pc16550d" };
106
107
108		#define VERBOSE_COM 0
109		#define COM_LOG(n,m,a) LOG(VERBOSE_COM,n,m,a)
110
111		typedef struct {
112		devcb_resolved_write_line out_intr_func;
113		const ins8250_interface *interface;
114		int device_type;
115
116		UINT8 thr; /* 0 -W transmitter holding register */
117		UINT8 rbr; /* 0 R- receiver buffer register */
118		UINT8 ier; /* 1 RW interrupt enable register */
119		UINT8 dll; /* 0 RW divisor latch lsb (if DLAB = 1) */
120		UINT8 dlm; /* 1 RW divisor latch msb (if DLAB = 1) */
121		UINT8 iir; /* 2 R- interrupt identification register */
122		UINT8 lcr; /* 3 RW line control register (bit 7: DLAB) */
123		UINT8 mcr; /* 4 RW modem control register */
124		UINT8 lsr; /* 5 R- line status register */
125		UINT8 msr; /* 6 R- modem status register */
126		UINT8 scr; /* 7 RW scratch register */
127
128		/* holds int pending state for com */
129		UINT8 int_pending;
130
131		// sending circuit
132		struct {
133		int active;
134		UINT8 data;
135		double time;
136		} send;
137		} ins8250_t;
138
139	106	/* int's pending */
140	107	#define COM_INT_PENDING_RECEIVED_DATA_AVAILABLE 0x0001
141	108	#define COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY 0x0002
142	109	#define COM_INT_PENDING_RECEIVER_LINE_STATUS 0x0004
143	110	#define COM_INT_PENDING_MODEM_STATUS_REGISTER 0x0008
144	111
145
146		INLINE ins8250_t get_safe_token(device_t device)
147		{
148		assert( device != NULL );
149		assert( ( device->type() == INS8250 ) \|\|
150		( device->type() == INS8250A ) \|\|
151		( device->type() == NS16450 ) \|\|
152		( device->type() == NS16550 ) \|\|
153		( device->type() == NS16550A ) \|\|
154		( device->type() == PC16550D ) );
155		return (ins8250_t )downcast<legacy_device_base >(device)->token();
156		}
157
158
159		/* setup iir with the priority id */
160		static void ins8250_setup_iir(device_t *device)
161		{
162		ins8250_t *ins8250 = get_safe_token(device);
163
164		ins8250->iir &= ~(0x04\|0x02);
165
166		/* highest to lowest */
167		if (ins8250->ier & ins8250->int_pending & COM_INT_PENDING_RECEIVER_LINE_STATUS)
168		{
169		ins8250->iir \|=0x04\|0x02;
170		return;
171		}
172
173		if (ins8250->ier & ins8250->int_pending & COM_INT_PENDING_RECEIVED_DATA_AVAILABLE)
174		{
175		ins8250->iir \|=0x04;
176		return;
177		}
178
179		if (ins8250->ier & ins8250->int_pending & COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY)
180		{
181		ins8250->iir \|=0x02;
182		return;
183		}
184
185		/* modem status has both bits clear */
186		}
187
188
189	112	/* ints will continue to be set for as long as there are ints pending */
190		~~static~~ void ins8250_update_interrupt(~~device_t *device~~)
	113	void ins8250_uart_device::update_interrupt()
191	114	{
192		ins8250_t *ins8250 = get_safe_token(device);
193	115	int state;
194	116
195	117	/* if any bits are set and are enabled */
196		if (((in~~s8250->in~~t_pending&ins~~8250->~~ier) & 0x0f) != 0)
	118	if (((m_int_pending & m_regs.ier) & 0x0f) != 0)
197	119	{
198	120	/* trigger next highest priority int */
199	121
200	122	/* set int */
201	123	state = 1;
202		~~ins8250~~_se~~tup_~~iir(~~device~~);
	124	m_regs.iir &= ~(0x04\|0x02);
203	125
	126	/* highest to lowest */
	127	if (m_regs.ier & m_int_pending & COM_INT_PENDING_RECEIVER_LINE_STATUS)
	128	m_regs.iir \|=0x04\|0x02;
	129	else if (m_regs.ier & m_int_pending & COM_INT_PENDING_RECEIVED_DATA_AVAILABLE)
	130	m_regs.iir \|=0x04;
	131	else if (m_regs.ier & m_int_pending & COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY)
	132	m_regs.iir \|=0x02;
	133
204	134	/* int pending */
205		ins~~8250->~~iir &= ~0x01;
	135	m_regs.iir &= ~0x01;
206	136	}
207	137	else
208	138	{
r14535	r14536
210	140	state = 0;
211	141
212	142	/* no ints pending */
213		ins~~8250->~~iir \|= 0x01;
	143	m_regs.iir \|= 0x01;
214	144	/* priority level */
215		ins~~8250->~~iir &= ~(0x04\|0x02);
	145	m_regs.iir &= ~(0x04\|0x02);
216	146	}
217	147
218	148	/* set or clear the int */
219		~~ins8250->~~out_intr_func(state);
	149	m_out_int_func(state);
220	150	}
221	151
222
223
224	152	/* set pending bit and trigger int */
225		~~static~~ void ins8250_trigger_int(~~device_t *device,~~ int flag)
	153	void ins8250_uart_device::trigger_int(int flag)
226	154	{
227		ins8250_t *ins8250 = get_safe_token(device);
228
229		ins8250->int_pending \|= flag;
230		ins8250_update_interrupt(device);
	155	m_int_pending \|= flag;
	156	update_interrupt();
231	157	}
232	158
233
234
235	159	/* clear pending bit, if any ints are pending, then int will be triggered, otherwise it
236	160	will be cleared */
237		~~static~~ void ins8250_~~cle~~ar~~_in~~t(device~~_t *devi~~ce, int flag)
	161	void ins8250_uart_device::clear_int(int flag)
238	162	{
239		ins8250_t *ins8250 = get_safe_token(device);
	163	m_int_pending &= ~flag;
	164	update_interrupt();
	165	}
240	166
241		ins8250->int_pending &= ~flag;
242		ins8250_update_interrupt(device);
	167	void ins8250_uart_device::update_clock()
	168	{
	169	int baud;
	170	if(m_regs.dl == 0)
	171	{
	172	m_timer->adjust(attotime::never);
	173	return;
	174	}
	175	baud = clock()/(m_regs.dl*16);
	176	m_timer->adjust(attotime::zero, 0, attotime::from_hz(baud));
243	177	}
244	178
245
246		WRITE8_DEVICE_HANDLER( ins8250_w )
	179	WRITE8_MEMBER( ins8250_uart_device::ins8250_w )
247	180	{
248		static const char P[] = "NONENHNL"; /* names for parity select */
249		ins8250_t *ins8250 = get_safe_token(device);
250		int tmp;
	181	int tmp;
251	182
252	183	switch (offset)
253	184	{
254	185	case 0:
255		if (ins~~8250->~~lcr & 0x80)
	186	if (m_regs.lcr & 0x80)
256	187	{
257		ins8250->dll = data;
258		tmp = ins8250->dlm * 256 + ins8250->dll;
259		COM_LOG(1,"COM_dll_w",("COM \"%s\" $%02x: [$%04x = %d baud]\n", device->tag(),
260		data, tmp, (tmp)?(int)(ins8250->interface->clockin/16/tmp):0));
	188	m_regs.dl = (m_regs.dl & 0xff00) \| data;
	189	update_clock();
261	190	}
262	191	else
263	192	{
264		ins8250->thr = data;
265		COM_LOG(2,"COM_thr_w",("COM $%02x\n", data));
266
267		if ( ins8250->mcr & 0x10 )
	193	m_regs.thr = data;
	194	m_regs.lsr &= ~0x60;
	195	if ( m_regs.mcr & 0x10 )
268	196	{
269		ins8250->lsr \|= 1;
270		ins8250->rbr = data;
271		ins8250_trigger_int( device, COM_INT_PENDING_RECEIVED_DATA_AVAILABLE );
	197	m_regs.lsr \|= 1;
	198	m_regs.rbr = data;
	199	trigger_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
272	200	}
273
274		if ( ins8250->interface->transmit )
275		ins8250->interface->transmit(device, ins8250->thr);
276
277		/* writing to thr will clear the int */
278		ins8250_clear_int(device, COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
279	201	}
280	202	break;
281	203	case 1:
282		if (ins~~8250->~~lcr & 0x80)
	204	if (m_regs.lcr & 0x80)
283	205	{
284		ins8250->dlm = data;
285		tmp = ins8250->dlm * 256 + ins8250->dll;
286		COM_LOG(1,"COM_dlm_w",("COM \"%s\" $%02x: [$%04x = %d baud]\n", device->tag(),
287		data, tmp, (tmp)?(int)(ins8250->interface->clockin/16/tmp):0));
	206	m_regs.dl = (m_regs.dl & 0xff) \| (data << 8);
	207	update_clock();
288	208	}
289	209	else
290	210	{
291		ins8250->ier = data;
292		COM_LOG(2,"COM_ier_w",("COM \"%s\" $%02x: enable int on RX %d, THRE %d, RLS %d, MS %d\n", device->tag(),
293		data, data&1, (data>>1)&1, (data>>2)&1, (data>>3)&1));
294		COM_LOG(2,"COM_ier_w",("COM \"%s\" lsr = $%02x, int_pending = $%02x\n", device->tag(), ins8250->lsr, ins8250->int_pending ));
295		ins8250_update_interrupt(device);
	211	m_regs.ier = data;
	212	update_interrupt();
296	213	}
297	214	break;
298	215	case 2:
299		COM_LOG(1,"COM_fcr_w",("COM \"%s\" $%02x (16550 only)\n", device->tag(), data));
300	216	break;
301	217	case 3:
302		ins8250->lcr = data;
303		COM_LOG(1,"COM_lcr_w",("COM \"%s\" $%02x word length %d, stop bits %d, parity %c, break %d, DLAB %d\n", device->tag(),
304		data, 5+(data&3), 1+((data>>2)&1), P[(data>>3)&7], (data>>6)&1, (data>>7)&1));
305		break;
	218	m_regs.lcr = data;
	219	switch ((m_regs.lcr>>3) & 7)
	220	{
	221	case 1:
	222	tmp = SERIAL_PARITY_ODD;
	223	break;
	224	case 3:
	225	tmp = SERIAL_PARITY_EVEN;
	226	break;
	227	case 5:
	228	tmp = SERIAL_PARITY_MARK;
	229	break;
	230	case 7:
	231	tmp = SERIAL_PARITY_SPACE;
	232	break;
	233	default:
	234	tmp = SERIAL_PARITY_NONE;
	235	break;
	236	}
	237	// if 5 data bits and stb = 1, stop bits is supposed to be 1.5
	238	set_data_frame((m_regs.lcr & 3) + 5, (m_regs.lcr & 4)?2:1, tmp);
	239	break;
306	240	case 4:
307		if ( ( ins~~8250->~~mcr & 0x1f ) != ( data & 0x1f ) )
	241	if ( ( m_regs.mcr & 0x1f ) != ( data & 0x1f ) )
308	242	{
309		ins8250->mcr = data & 0x1f;
310		COM_LOG(1,"COM_mcr_w",("COM \"%s\" $%02x DTR %d, RTS %d, OUT1 %d, OUT2 %d, loopback %d\n", device->tag(),
311		data, data&1, (data>>1)&1, (data>>2)&1, (data>>3)&1, (data>>4)&1));
312		if (ins8250->interface->handshake_out)
313		ins8250->interface->handshake_out(device,data);
	243	m_regs.mcr = data & 0x1f;
314	244
315		if ( ins~~8250->~~mcr & 0x10 ) /* loopback test */
	245	if ( m_regs.mcr & 0x10 ) /* loopback test */
316	246	{
317		data = ( ( ins8250->mcr & 0x0c ) << 4 ) \| ( ( ins8250->mcr & 0x01 ) << 5 ) \| ( ( ins8250->mcr & 0x02 ) << 3 );
318		if ( ( ins8250->msr & 0x20 ) != ( data & 0x20 ) )
319		{
	247	data = ( ( m_regs.mcr & 0x0c ) << 4 ) \| ( ( m_regs.mcr & 0x01 ) << 5 ) \| ( ( m_regs.mcr & 0x02 ) << 3 );
	248	if ( ( m_regs.msr & 0x20 ) != ( data & 0x20 ) )
320	249	data \|= 0x02;
321		}
322		if ( ( ins8250->msr & 0x10 ) != ( data & 0x10 ) )
323		{
	250	if ( ( m_regs.msr & 0x10 ) != ( data & 0x10 ) )
324	251	data \|= 0x01;
325		}
326		if ( ( ins8250->msr & 0x40 ) && ! ( data & 0x40 ) )
327		{
	252	if ( ( m_regs.msr & 0x40 ) && ! ( data & 0x40 ) )
328	253	data \|= 0x04;
329		}
330		if ( ( ins8250->msr & 0x80 ) != ( data & 0x80 ) )
331		{
	254	if ( ( m_regs.msr & 0x80 ) != ( data & 0x80 ) )
332	255	data \|= 0x08;
333		}
334		ins8250->msr = data;
	256	m_regs.msr = data;
335	257	}
	258	else
	259	{
	260	m_out_dtr_func(m_regs.mcr & 1);
	261	m_out_rts_func((m_regs.mcr & 2) && 1);
	262	m_out_out1_func((m_regs.mcr & 4) && 1);
	263	m_out_out2_func((m_regs.mcr & 8) && 1);
	264	}
336	265	}
337	266	break;
338	267	case 5:
r14535	r14536
341	270	bits 5 - 0, you could cause an interrupt if the appropriate IER bit
342	271	is set.
343	272	*/
344		~~COM~~_~~LOG(1,"COM_~~lsr~~_w",("COM~~ ~~\"%s\"~~ ~~$%02x\n",~~ d~~evice->t~~a~~g(), da~~ta ));
	273	m_regs.lsr = data;
345	274
346		ins8250->lsr = data;
347
348	275	tmp = 0;
349		tmp \|= ( ins8250->lsr & 0x01 ) ? COM_INT_PENDING_RECEIVED_DATA_AVAILABLE : 0;
350		tmp \|= ( ins8250->lsr & 0x1e ) ? COM_INT_PENDING_RECEIVER_LINE_STATUS : 0;
351		tmp \|= ( ins8250->lsr & 0x20 ) ? COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY : 0;
352		ins8250_trigger_int( device, tmp );
	276	tmp \|= ( m_regs.lsr & 0x01 ) ? COM_INT_PENDING_RECEIVED_DATA_AVAILABLE : 0;
	277	tmp \|= ( m_regs.lsr & 0x1e ) ? COM_INT_PENDING_RECEIVER_LINE_STATUS : 0;
	278	tmp \|= ( m_regs.lsr & 0x20 ) ? COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY : 0;
	279	trigger_int(tmp);
353	280
354	281	break;
355	282	case 6:
r14535	r14536
358	285	bits 3 - 0, you could cause an interrupt if the appropriate IER bit
359	286	is set.
360	287	*/
361		~~COM~~_~~LOG(1,"COM_~~msr~~_w",("COM~~ ~~\"%s\"~~ ~~$%02x\n",~~ d~~evice->t~~a~~g(), da~~ta ));
	288	m_regs.msr = data;
362	289
363		ins8250->msr = data;
364
365		if ( ins8250->msr & 0x0f )
366		{
367		ins8250_trigger_int( device, COM_INT_PENDING_MODEM_STATUS_REGISTER );
368		}
	290	if ( m_regs.msr & 0x0f )
	291	trigger_int(COM_INT_PENDING_MODEM_STATUS_REGISTER);
369	292	break;
370	293	case 7:
371		ins8250->scr = data;
372		COM_LOG(2,"COM_scr_w",("COM \"%s\" $%02x\n", device->tag(), data));
	294	m_regs.scr = data;
373	295	break;
374	296	}
375
376		if (ins8250->interface->refresh_connected)
377		ins8250->interface->refresh_connected(device);
378	297	}
379	298
380
381
382		READ8_DEVICE_HANDLER( ins8250_r )
	299	READ8_MEMBER( ins8250_uart_device::ins8250_r )
383	300	{
384		ins8250_t *ins8250 = get_safe_token(device);
385	301	int data = 0x0ff;
386	302
387	303	switch (offset)
388	304	{
389	305	case 0:
390		if (ins8250->lcr & 0x80)
391		{
392		data = ins8250->dll;
393		COM_LOG(1,"COM_dll_r",("COM \"%s\" $%02x\n", device->tag(), data));
394		}
	306	if (m_regs.lcr & 0x80)
	307	data = (m_regs.dl & 0xff);
395	308	else
396	309	{
397		data = ins8250->rbr;
398		if( ins8250->lsr & 0x01 )
399		{
400		ins8250->lsr &= ~0x01; /* clear data ready status */
401		COM_LOG(2,"COM_rbr_r",("COM \"%s\" $%02x\n", device->tag(), data));
402		}
	310	data = m_regs.rbr;
	311	if( m_regs.lsr & 0x01 )
	312	m_regs.lsr &= ~0x01; /* clear data ready status */
403	313
404		~~ins8250_~~clear_int(~~device,~~ COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
	314	clear_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
405	315	}
406	316	break;
407	317	case 1:
408		if (ins8250->lcr & 0x80)
409		{
410		data = ins8250->dlm;
411		COM_LOG(1,"COM_dlm_r",("COM \"%s\" $%02x\n", device->tag(), data));
412		}
	318	if (m_regs.lcr & 0x80)
	319	data = (m_regs.dl >> 8);
413	320	else
414		{
415		data = ins8250->ier & 0x0f;
416		COM_LOG(2,"COM_ier_r",("COM \"%s\" $%02x\n", device->tag(), data));
417		}
	321	data = m_regs.ier & 0x0f;
418	322	break;
419	323	case 2:
420		data = ins8250->iir;
421		COM_LOG(2,"COM_iir_r",("COM \"%s\" $%02x\n", device->tag(), data));
	324	data = m_regs.iir;
422	325	/* The documentation says that reading this register will
423	326	clear the int if this is the source of the int */
424		if ( ins8250->ier & COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY )
425		{
426		ins8250_clear_int(device, COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
427		}
	327	if ( m_regs.ier & COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY )
	328	clear_int(COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
428	329	break;
429	330	case 3:
430		data = ins8250->lcr;
431		COM_LOG(2,"COM_lcr_r",("COM \"%s\" $%02x\n", device->tag(), data));
	331	data = m_regs.lcr;
432	332	break;
433	333	case 4:
434		data = ins8250->mcr;
435		COM_LOG(2,"COM_mcr_r",("COM \"%s\" $%02x\n", device->tag(), data));
	334	data = m_regs.mcr;
436	335	break;
437	336	case 5:
	337	data = m_regs.lsr;
	338	if( m_regs.lsr & 0x1f )
	339	m_regs.lsr &= 0xe1; /* clear FE, PE and OE and BREAK bits */
438	340
439		#if 0
440		if (ins8250->send.active && (machine.time()-ins8250->send.time>uart_byte_time(n)))
441		{
442		// currently polling is enough for pc1512
443		ins8250->lsr \|= 0x40; /* set TSRE */
444		ins8250->send.active = 0;
445		if ( ins8250->mcr & 0x10 )
446		{
447		ins8250->lsr \|= 1;
448		ins8250->rbr = ins8250->send.data;
449		}
450		}
451		#endif
452		ins8250->lsr \|= 0x60; /* set THRE */
453		data = ins8250->lsr;
454		if( ins8250->lsr & 0x1f )
455		{
456		ins8250->lsr &= 0xe1; /* clear FE, PE and OE and BREAK bits */
457		COM_LOG(2,"COM_lsr_r",("COM \"%s\" $%02x, DR %d, OE %d, PE %d, FE %d, BREAK %d, THRE %d, TSRE %d\n", device->tag(),
458		data, data&1, (data>>1)&1, (data>>2)&1, (data>>3)&1, (data>>4)&1, (data>>5)&1, (data>>6)&1));
459		}
460
461	341	/* reading line status register clears int */
462		~~ins8250_~~clear_int(~~device,~~ COM_INT_PENDING_RECEIVER_LINE_STATUS);
	342	clear_int(COM_INT_PENDING_RECEIVER_LINE_STATUS);
463	343	break;
464	344	case 6:
465		data = ins8250->msr;
466		ins8250->msr &= 0xf0; /* reset delta values */
467		COM_LOG(2,"COM_msr_r",("COM \"%s\" $%02x\n", device->tag(), data));
	345	data = m_regs.msr;
	346	m_regs.msr &= 0xf0; /* reset delta values */
468	347
469	348	/* reading msr clears int */
470		~~ins8250_~~clear_int(~~device,~~ COM_INT_PENDING_MODEM_STATUS_REGISTER);
	349	clear_int(COM_INT_PENDING_MODEM_STATUS_REGISTER);
471	350
472	351	break;
473	352	case 7:
474		data = ins8250->scr;
475		COM_LOG(2,"COM_scr_r",("COM \"%s\" $%02x\n", device->tag(), data));
	353	data = m_regs.scr;
476	354	break;
477	355	}
478
479		if (ins8250->interface->refresh_connected)
480		ins8250->interface->refresh_connected(device);
481
482	356	return data;
483	357	}
484	358
485
486
487		void ins8250_receive(device_t *device, int data)
	359	void ins8250_uart_device::update_msr(int bit, UINT8 state)
488	360	{
489		ins8250_t *ins8250 = get_safe_token(device);
490
491		/* check if data rate 1200 baud is set */
492		if( ins8250->dlm != 0x00 \|\| ins8250->dll != 0x60 )
493		ins8250->lsr \|= 0x08; /* set framing error */
494
495		/* if data not yet serviced */
496		if( ins8250->lsr & 0x01 )
497		ins8250->lsr \|= 0x02; /* set overrun error */
498
499		/* put data into receiver buffer register */
500		ins8250->rbr = data;
501
502		/* set data ready status */
503		ins8250->lsr \|= 0x01;
504
505		/* set pending state for this interrupt. */
506		ins8250_trigger_int(device, COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
507
508
509		// /* OUT2 + received line data avail interrupt enabled? */
510		// if( (COM_mcr[n] & 0x08) && (COM_ier[n] & 0x01) )
511		// {
512		// if (com_interface.interrupt)
513		// com_interface.interrupt(4-(n&1), 1);
514		//
515		// }
516		}
517
518		/**************************************************************************
519		* change the modem status register
520		**************************************************************************/
521		void ins8250_handshake_in(device_t *device, int new_msr)
522		{
523		ins8250_t *ins8250 = get_safe_token(device);
524
525		/* no change in modem status bits? */
526		if( ((ins8250->msr ^ new_msr) & 0xf0) == 0 )
	361	UINT8 mask = (1<<bit);
	362	if((m_regs.msr & mask) == (state<<bit))
527	363	return;
528
529		/* set delta status bits 0..3 and new modem status bits 4..7 */
530		ins8250->msr = (((ins8250->msr ^ new_msr) >> 4) & 0x0f) \| (new_msr & 0xf0);
531
532		ins8250_trigger_int(device, COM_INT_PENDING_MODEM_STATUS_REGISTER);
533
534		// /* set up interrupt information register */
535		// COM_iir[n] &= ~(0x06 \| 0x01);
536
537		// /* OUT2 + modem status interrupt enabled? */
538		// if( (COM_mcr[n] & 0x08) && (COM_ier[n] & 0x08) )
539		// {
540		// if (com_interface.interrupt)
541		// com_interface.interrupt(4-(n&1), 1);
542		// }
	364	m_regs.msr = (m_regs.msr & ~mask) \| (mask & (state<<bit));
	365	m_regs.msr = (m_regs.msr & ~(mask << 4)) \| (1<<(bit+4));
	366	trigger_int(COM_INT_PENDING_MODEM_STATUS_REGISTER);
543	367	}
544	368
545
546		static void common_start( device_t *device, int device_type )
	369	WRITE_LINE_MEMBER(ins8250_uart_device::dcd_w)
547	370	{
548		ins8250_t *ins8250 = get_safe_token(device);
549
550		ins8250->interface = (const ins8250_interface*)device->static_config();
551		ins8250->device_type = device_type;
552
553		ins8250->out_intr_func.resolve(ins8250->interface->out_intr_cb, *device);
	371	update_msr(3, (state&&1));
554	372	}
555	373
556
557		static DEVICE_START( ins8250 )
	374	WRITE_LINE_MEMBER(ins8250_uart_device::dsr_w)
558	375	{
559		~~common~~_start( ~~device~~, ~~TYPE_INS8250~~ );
	376	update_msr(1, (state&&1));
560	377	}
561	378
562
563		static DEVICE_START( ins8250a )
	379	WRITE_LINE_MEMBER(ins8250_uart_device::ri_w)
564	380	{
565		~~common~~_start( ~~device~~, ~~TYPE_INS8250A~~ );
	381	update_msr(2, (state&&1));
566	382	}
567	383
568
569		static DEVICE_START( ns16450 )
	384	WRITE_LINE_MEMBER(ins8250_uart_device::cts_w)
570	385	{
571		~~common~~_start( ~~device~~, ~~TYPE_NS~~1~~6450~~ );
	386	update_msr(0, (state&&1));
572	387	}
573	388
574
575		static DEVICE_START( ns16550 )
	389	void ins8250_uart_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
576	390	{
577		common_start( device, TYPE_NS16550 );
578		}
579
580
581		static DEVICE_START( ns16550a )
582		{
583		common_start( device, TYPE_NS16550A );
584		}
585
586
587		static DEVICE_START( pc16550d )
588		{
589		common_start( device, TYPE_PC16550D );
590		}
591
592
593		static DEVICE_RESET( ins8250 )
594		{
595		ins8250_t *ins8250 = get_safe_token(device);
596
597		ins8250->ier = 0;
598		ins8250->iir = 1;
599		ins8250->lcr = 0;
600		ins8250->mcr = 0;
601		ins8250->lsr = (1<<5) \| (1<<6);
602
603		ins8250->send.active=0;
604
605		/* refresh with reset state of register */
606		if (ins8250->interface->refresh_connected)
607		ins8250->interface->refresh_connected(device);
608		}
609
610
611		DEVICE_GET_INFO( ins8250 )
612		{
613		switch ( state )
	391	receive_register_update_bit(m_rx_line);
	392	if(is_receive_register_full())
614	393	{
615		/* --- the following bits of info are returned as 64-bit signed integers --- */
616		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ins8250_t); break;
617		case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
618
619		/* --- the following bits of info are returned as pointers to data or functions --- */
620		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ins8250); break;
621		case DEVINFO_FCT_STOP: /* nothing */ break;
622		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(ins8250); break;
623
624		/* --- the following bits of info are returned as NULL-terminated strings --- */
625		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor INS8250/INS8250B"); break;
626		case DEVINFO_STR_FAMILY: strcpy(info->s, "INS8250"); break;
627		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
628		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
629		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
	394	if(m_regs.lsr & 0x01)
	395	{
	396	m_regs.lsr \|= 0x02; //overrun
	397	trigger_int(COM_INT_PENDING_RECEIVER_LINE_STATUS);
	398	}
	399	else
	400	{
	401	m_regs.lsr \|= 0x01;
	402	receive_register_extract();
	403	m_regs.rbr = get_received_char();
	404	trigger_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
	405	}
	406	receive_register_reset();
630	407	}
631		}
632	408
633
634		DEVICE_GET_INFO( ins8250a )
635		{
636		switch ( state )
	409	if(is_transmit_register_empty())
637	410	{
638		/* --- the following bits of info are returned as 64-bit signed integers --- */
639		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor INS8250A/INS82C50A"); break;
640
641		/* --- the following bits of info are returned as pointers to data or functions --- */
642		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ins8250a); break;
643
644		default: DEVICE_GET_INFO_CALL(ins8250); break;
	411	if(!(m_regs.lsr & 0x20))
	412	{
	413	transmit_register_setup(m_regs.thr);
	414	m_regs.lsr &= ~0x40;
	415	m_regs.lsr \|= 0x20;
	416	trigger_int(COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
	417	}
	418	else
	419	m_regs.lsr \|= 0x40;
645	420	}
	421	else
	422	m_out_tx_func(transmit_register_get_data_bit());
646	423	}
647	424
648
649		DEVICE_GET_INFO( ns16450 )
	425	void ins8250_uart_device::device_start()
650	426	{
651		switch ( state )
652		{
653		/* --- the following bits of info are returned as 64-bit signed integers --- */
654		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor NS16450/PC16450"); break;
	427	m_out_tx_func.resolve(m_out_tx_cb, *this);
	428	m_out_dtr_func.resolve(m_out_dtr_cb, *this);
	429	m_out_rts_func.resolve(m_out_rts_cb, *this);
	430	m_out_int_func.resolve(m_out_int_cb, *this);
	431	m_out_out1_func.resolve(m_out_out1_cb, *this);
	432	m_out_out2_func.resolve(m_out_out2_cb, *this);
655	433
656		/* --- the following bits of info are returned as pointers to data or functions --- */
657		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ns16450); break;
658
659		default: DEVICE_GET_INFO_CALL(ins8250); break;
660		}
	434	m_timer = timer_alloc();
661	435	}
662	436
663
664		DEVICE_GET_INFO( ns16550 )
	437	void ins8250_uart_device::device_reset()
665	438	{
666		switch ( state )
667		{
668		/* --- the following bits of info are returned as 64-bit signed integers --- */
669		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor NS16550/PC16550"); break;
670
671		/* --- the following bits of info are returned as pointers to data or functions --- */
672		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ns16550); break;
673
674		default: DEVICE_GET_INFO_CALL(ins8250); break;
675		}
	439	memset(&m_regs, '\0', sizeof(m_regs));
	440	m_regs.ier = 0;
	441	m_regs.iir = 1;
	442	m_regs.lcr = 0;
	443	m_regs.mcr = 0;
	444	m_regs.lsr = (1<<5) \| (1<<6);
	445	m_int_pending = 0;
	446	m_rx_line = 0;
	447	m_timer->adjust(attotime::never);
	448	receive_register_reset();
	449	transmit_register_reset();
	450	m_out_rts_func(0);
	451	m_out_dtr_func(0);
	452	m_out_out1_func(0);
	453	m_out_out2_func(0);
676	454	}
677	455
678
679		DEVICE_GET_INFO( ns16550a )
	456	void ins8250_uart_device::device_config_complete()
680	457	{
681		switch ( state )
	458	const ins8250_interface intf = reinterpret_cast<const ins8250_interface >(static_config());
	459	if(intf != NULL)
682	460	{
683		/* --- the following bits of info are returned as 64-bit signed integers --- */
684		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor NS16550A/PC16550A"); break;
685
686		/* --- the following bits of info are returned as pointers to data or functions --- */
687		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ns16550a); break;
688
689		default: DEVICE_GET_INFO_CALL(ins8250); break;
	461	static_cast<ins8250_interface >(this) = *intf;
690	462	}
691		}
692
693
694		DEVICE_GET_INFO( pc16550d )
695		{
696		switch ( state )
	463	else
697	464	{
698		/* --- the following bits of info are returned as 64-bit signed integers --- */
699		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor PC16550D"); break;
700
701		/* --- the following bits of info are returned as pointers to data or functions --- */
702		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pc16550d); break;
703
704		default: DEVICE_GET_INFO_CALL(ins8250); break;
	465	memset(&m_out_tx_cb, 0, sizeof(m_out_tx_cb));
	466	memset(&m_out_dtr_cb, 0, sizeof(m_out_dtr_cb));
	467	memset(&m_out_rts_cb, 0, sizeof(m_out_rts_cb));
	468	memset(&m_out_int_cb, 0, sizeof(m_out_int_cb));
	469	memset(&m_out_out1_cb, 0, sizeof(m_out_out1_cb));
	470	memset(&m_out_out2_cb, 0, sizeof(m_out_out2_cb));
705	471	}
706	472	}
707
708
709
710		DEFINE_LEGACY_DEVICE(INS8250, ins8250);
711		DEFINE_LEGACY_DEVICE(INS8250A, ins8250a);
712		DEFINE_LEGACY_DEVICE(NS16450, ns16450);
713		DEFINE_LEGACY_DEVICE(NS16550, ns16550);
714		DEFINE_LEGACY_DEVICE(NS16550A, ns16550a);
715		DEFINE_LEGACY_DEVICE(PC16550D, pc16550d);

src/emu/machine/ins8250.h
r14535	r14536
7	7	#ifndef __INS8250_H_
8	8	#define __INS8250_H_
9	9
10		#include "de~~vlegcy~~.h"
	10	#include "emu.h"
11	11
12		DECLARE_LEGACY_DEVICE(INS8250, ins8250);
13		DECLARE_LEGACY_DEVICE(INS8250A, ins8250a);
14		DECLARE_LEGACY_DEVICE(NS16450, ns16450);
15		DECLARE_LEGACY_DEVICE(NS16550, ns16550);
16		DECLARE_LEGACY_DEVICE(NS16550A, ns16550a);
17		DECLARE_LEGACY_DEVICE(PC16550D, pc16550d);
	12	/***************************************************************************
	13	CLASS DEFINITIONS
	14	***************************************************************************/
	15	struct ins8250_interface
	16	{
	17	devcb_write_line m_out_tx_cb;
	18	devcb_write_line m_out_dtr_cb;
	19	devcb_write_line m_out_rts_cb;
	20	devcb_write_line m_out_int_cb;
	21	devcb_write_line m_out_out1_cb;
	22	devcb_write_line m_out_out2_cb;
	23	};
18	24
19		#define UART8250_HANDSHAKE_OUT_DTR 0x01
20		#define UART8250_HANDSHAKE_OUT_RTS 0x02
	25	class ins8250_uart_device : public device_t,
	26	public device_serial_interface,
	27	public ins8250_interface
	28	{
	29	public:
	30	ins8250_uart_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock);
	31	DECLARE_WRITE8_MEMBER( ins8250_w );
	32	DECLARE_READ8_MEMBER( ins8250_r );
	33	DECLARE_WRITE_LINE_MEMBER( dcd_w );
	34	DECLARE_WRITE_LINE_MEMBER( dsr_w );
	35	DECLARE_WRITE_LINE_MEMBER( ri_w );
	36	DECLARE_WRITE_LINE_MEMBER( cts_w );
	37	DECLARE_WRITE_LINE_MEMBER( rx_w ) { m_rx_line = state; }
	38	void input_callback(UINT8 state) { m_input_state = state; }
21	39
22		#define UART8250_HANDSHAKE_IN_DSR 0x020
23		#define UART8250_HANDSHAKE_IN_CTS 0x010
24		#define UART8250_INPUTS_RING_INDICATOR 0x0040
25		#define UART8250_INPUTS_DATA_CARRIER_DETECT 0x0080
	40	protected:
	41	virtual void device_start();
	42	virtual void device_config_complete();
	43	virtual void device_reset();
	44	enum {
	45	TYPE_INS8250 = 0,
	46	TYPE_INS8250A,
	47	TYPE_NS16450,
	48	TYPE_NS16550,
	49	TYPE_NS16550A,
	50	TYPE_PC16550D,
	51	};
	52	int m_device_type;
	53	private:
	54	struct {
	55	UINT8 thr; /* 0 -W transmitter holding register */
	56	UINT8 rbr; /* 0 R- receiver buffer register */
	57	UINT8 ier; /* 1 RW interrupt enable register */
	58	UINT16 dl; /* 0/1 RW divisor latch (if DLAB = 1) */
	59	UINT8 iir; /* 2 R- interrupt identification register */
	60	UINT8 lcr; /* 3 RW line control register (bit 7: DLAB) */
	61	UINT8 mcr; /* 4 RW modem control register */
	62	UINT8 lsr; /* 5 R- line status register */
	63	UINT8 msr; /* 6 R- modem status register */
	64	UINT8 scr; /* 7 RW scratch register */
	65	} m_regs;
	66	UINT8 m_int_pending;
	67	UINT8 m_rx_line;
26	68
	69	devcb_resolved_write_line m_out_tx_func;
	70	devcb_resolved_write_line m_out_dtr_func;
	71	devcb_resolved_write_line m_out_rts_func;
	72	devcb_resolved_write_line m_out_int_func;
	73	devcb_resolved_write_line m_out_out1_func;
	74	devcb_resolved_write_line m_out_out2_func;
27	75
28		/***************************************************************************
29		TYPE DEFINITIONS
30		***************************************************************************/
	76	void update_interrupt();
	77	void update_clock();
	78	void trigger_int(int flag);
	79	void clear_int(int flag);
	80	void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	81	void update_msr(int bit, UINT8 state);
31	82
32		typedef void (ins8250_transmit_func)(device_t device, int data);
33		typedef void (ins8250_handshake_out_func)(device_t device, int data);
34		typedef void (ins8250_refresh_connect_func)(device_t device);
	83	emu_timer *m_timer;
	84	};
35	85
36		#define INS8250_TRANSMIT(name) void name(device_t *device, int data)
37		#define INS8250_HANDSHAKE_OUT(name) void name(device_t *device, int data)
38		#define INS8250_REFRESH_CONNECT(name) void name(device_t *device)
	86	class ins8250_device : public ins8250_uart_device
	87	{
	88	public:
	89	ins8250_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	90	};
39	91
40		~~type~~def ~~str~~uct
	92	class ns16450_device : public ins8250_uart_device
41	93	{
42		long clockin;
43		devcb_write_line out_intr_cb;
	94	public:
	95	ns16450_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	96	};
44	97
45		ins8250_transmit_func transmit;
46		ins8250_handshake_out_func handshake_out;
	98	class ns16550_device : public ins8250_uart_device
	99	{
	100	public:
	101	ns16550_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	102	};
47	103
48		// refresh object connected to this port
49		ins8250_refresh_connect_func refresh_connected;
50		} ins8250_interface;
	104	extern const device_type INS8250;
	105	extern const device_type NS16450;
	106	extern const device_type NS16550;
51	107
52
53	108	/***************************************************************************
54	109	DEVICE CONFIGURATION MACROS
55	110	***************************************************************************/
56	111
57		#define MCFG_INS8250_ADD(_tag, _intrf) \
58		MCFG_DEVICE_ADD(_tag, INS8250, 0) \
	112	#define MCFG_INS8250_ADD(_tag, _intrf, _clock) \
	113	MCFG_DEVICE_ADD(_tag, INS8250, _clock) \
59	114	MCFG_DEVICE_CONFIG(_intrf)
60	115
61	116
62		#define MCFG_NS16450_ADD(_tag, _intrf) \
63		MCFG_DEVICE_ADD(_tag, NS16450, 0) \
	117	#define MCFG_NS16450_ADD(_tag, _intrf, _clock) \
	118	MCFG_DEVICE_ADD(_tag, NS16450, _clock) \
64	119	MCFG_DEVICE_CONFIG(_intrf)
65	120
66	121
67		#define MCFG_NS16550_ADD(_tag, _intrf) \
68		MCFG_DEVICE_ADD(_tag, NS16550, 0) \
	122	#define MCFG_NS16550_ADD(_tag, _intrf, _clock) \
	123	MCFG_DEVICE_ADD(_tag, NS16550, _clock) \
69	124	MCFG_DEVICE_CONFIG(_intrf)
70	125
71
72		/***************************************************************************
73		FUNCTION PROTOTYPES
74		***************************************************************************/
75
76		void ins8250_receive(device_t *device, int data);
77		void ins8250_handshake_in(device_t *device, int new_msr);
78
79		READ8_DEVICE_HANDLER( ins8250_r );
80		WRITE8_DEVICE_HANDLER( ins8250_w );
81
82
83		#endif /* __INS8250_H_ */
	126	#endif

src/emu/machine/microtch.c
r14535	r14536
9	9
10	10	*/
11	11
12		#include "emu.h"
13	12	#include "microtch.h"
14	13
15	14	#define LOG 0
16	15
17		enum MICROTOUCH_FORMAT
18		{
19		FORMAT_UNKNOWN,
20		FORMAT_TABLET,
21		FORMAT_DECIMAL
22		};
	16	const device_type MICROTOUCH = &device_creator<microtouch_device>;
23	17
24		ALLOW_SAVE_TYPE(MICROTOUCH_FORMAT);
25
26		enum MICROTOUCH_MODE
	18	microtouch_device::microtouch_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock)
	19	: device_t(mconfig, type, name, tag, owner, clock)
27	20	{
28		MODE_INACTIVE,
29		MODE_STREAM,
30		MODE_POINT
31		};
	21	}
32	22
33		ALLOW_SAVE_TYPE(MICROTOUCH_MODE);
34
35		static struct
	23	microtouch_device::microtouch_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	24	: device_t(mconfig, MICROTOUCH, "Microtouch Touchscreen", tag, owner, clock)
36	25	{
37		UINT8 rx_buffer[16];
38		int rx_buffer_ptr;
39		emu_timer* timer;
40		UINT8 tx_buffer[16];
41		UINT8 tx_buffer_num;
42		UINT8 tx_buffer_ptr;
43		int reset_done;
44		MICROTOUCH_FORMAT format;
45		MICROTOUCH_MODE mode;
46		int last_touch_state;
47		int last_x;
48		int last_y;
49		microtouch_tx_func tx_callback;
50		microtouch_touch_func touch_callback;
51		} microtouch;
	26	}
52	27
53
54		static int microtouch_check_command( const char* commandtocheck, int command_len, UINT8* command_data )
	28	int microtouch_device::check_command( const char* commandtocheck, int command_len, UINT8* command_data )
55	29	{
56	30	if ( (command_len == (strlen(commandtocheck) + 2)) &&
57	31	(command_data[0] == 0x01) &&
r14535	r14536
66	40	}
67	41	}
68	42
69		~~static~~ void microtouch_send_format_table_packet(UINT8 flag, int x, int y)
	43	void microtouch_device::send_format_table_packet(UINT8 flag, int x, int y)
70	44	{
71		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = flag;
	45	m_tx_buffer[m_tx_buffer_num++] = flag;
72	46	// lower byte (7bits) of x coordinate
73		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = x & 0x7f;
	47	m_tx_buffer[m_tx_buffer_num++] = x & 0x7f;
74	48	// higher byte (7bits) of x coordinate
75		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = (x >> 7) & 0x7f;
	49	m_tx_buffer[m_tx_buffer_num++] = (x >> 7) & 0x7f;
76	50	// lower byte (7bits) of y coordinate
77		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = y & 0x7f;
	51	m_tx_buffer[m_tx_buffer_num++] = y & 0x7f;
78	52	// higher byte (7bits) of y coordinate
79		microtouch.tx_buffer[microtouch.tx_buffer_num++] = (y >> 7) & 0x7f;
80		};
	53	m_tx_buffer[m_tx_buffer_num++] = (y >> 7) & 0x7f;
	54	}
81	55
82		~~static~~ void microtouch_send_format_decimal_packet(int x, int y)
	56	void microtouch_device::send_format_decimal_packet(int x, int y)
83	57	{
84	58	int decx, decy;
85	59
r14535	r14536
91	65	decy = 999;
92	66
93	67	// header byte
94		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = 0x01;
	68	m_tx_buffer[m_tx_buffer_num++] = 0x01;
95	69	// x coordinate in decimal mode
96		microtouch.tx_buffer[microtouch.tx_buffer_num++] = (decx / 100) + '0';
97		microtouch.tx_buffer[microtouch.tx_buffer_num++] = ((decx / 10) % 10) + '0';
98		microtouch.tx_buffer[microtouch.tx_buffer_num++] = (decx % 10) + '0';
	70	m_tx_buffer[m_tx_buffer_num++] = (decx / 100) + '0';
	71	m_tx_buffer[m_tx_buffer_num++] = ((decx / 10) % 10) + '0';
	72	m_tx_buffer[m_tx_buffer_num++] = (decx % 10) + '0';
99	73	// comma (separator)
100		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = ',';
	74	m_tx_buffer[m_tx_buffer_num++] = ',';
101	75	// y coordinate in decimal mode
102		microtouch.tx_buffer[microtouch.tx_buffer_num++] = (decy / 100) + '0';
103		microtouch.tx_buffer[microtouch.tx_buffer_num++] = ((decy / 10) % 10) + '0';
104		microtouch.tx_buffer[microtouch.tx_buffer_num++] = (decy % 10) + '0';
	76	m_tx_buffer[m_tx_buffer_num++] = (decy / 100) + '0';
	77	m_tx_buffer[m_tx_buffer_num++] = ((decy / 10) % 10) + '0';
	78	m_tx_buffer[m_tx_buffer_num++] = (decy % 10) + '0';
105	79	// terminator
106		m~~icro~~t~~ouch.t~~x_buffer[m~~icrotouch.~~tx_buffer_num++] = 0x0d;
	80	m_tx_buffer[m_tx_buffer_num++] = 0x0d;
107	81	}
108	82
109		~~static~~ void microtouch_send_touch_packet(~~running_machine &machine~~)
	83	void microtouch_device::send_touch_packet()
110	84	{
111		int tx = input_port_read(machine, "TOUCH_X");
112		int ty = input_port_read(machine, "TOUCH_Y");
	85	int tx = input_port_read(*this, "TOUCH_X");
	86	int ty = input_port_read(*this, "TOUCH_Y");
113	87
114		if ( microtouch.touch_callback == NULL \|\|
115		microtouch.touch_callback( machine, &tx, &ty ) != 0 )
	88	if ( m_out_touch_cb == NULL \|\|
	89	m_out_touch_cb( &tx, &ty ) != 0 )
116	90	{
117	91	ty = 0x4000 - ty;
118	92
119		switch( m~~icrotouch.~~format )
	93	switch( m_format )
120	94	{
121	95	case FORMAT_TABLET:
122		~~microtouch_~~send_format_table_packet(0xc8, tx, ty);
	96	send_format_table_packet(0xc8, tx, ty);
123	97	break;
124	98	case FORMAT_DECIMAL:
125		~~microtouch_~~send_format_decimal_packet(tx, ty);
	99	send_format_decimal_packet(tx, ty);
126	100	break;
127	101	case FORMAT_UNKNOWN:
128	102	break;
129	103	}
130		microtouch.last_touch_state = 1;
131		microtouch.last_x = tx;
132		microtouch.last_y = ty;
	104	m_last_touch_state = 1;
	105	m_last_x = tx;
	106	m_last_y = ty;
133	107	}
134	108	}
135	109
136		~~stat~~ic ~~TIMER_CALLBACK(~~microtouch_timer_ca~~llb~~ack)
	110	void microtouch_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
137	111	{
138		if ( m~~icro~~t~~ouch.t~~x_buffer_ptr < m~~icrotouch.~~tx_buffer_num )
	112	if ( m_tx_buffer_ptr < m_tx_buffer_num )
139	113	{
140		microtouch.tx_callback( machine, microtouch.tx_buffer[microtouch.tx_buffer_ptr++] );
141		if ( microtouch.tx_buffer_ptr == microtouch.tx_buffer_num )
	114	tx( m_tx_buffer[m_tx_buffer_ptr++] );
	115	if ( m_tx_buffer_ptr == m_tx_buffer_num )
142	116	{
143		m~~icro~~t~~ouch.t~~x_buffer_ptr = m~~icrotouch.~~tx_buffer_num = 0;
	117	m_tx_buffer_ptr = m_tx_buffer_num = 0;
144	118	}
145	119	return;
146	120	}
147	121
148		if ( (microtouch.reset_done == 0) \|\|
149		(microtouch.format == FORMAT_UNKNOWN) \|\|
150		(microtouch.mode != MODE_STREAM))
	122	if ( (m_reset_done == 0) \|\|
	123	(m_format == FORMAT_UNKNOWN) \|\|
	124	(m_mode != MODE_STREAM))
151	125	{
152	126	return;
153	127	}
154	128
155	129	// send format tablet packet
156		if ( input_port_read(~~mac~~hine, "TOUCH") & 0x01 )
	130	if ( input_port_read(*this, "TOUCH") & 0x01 )
157	131	{
158		~~microtouch_~~send_touch_packet(~~machine~~);
	132	send_touch_packet();
159	133	}
160	134	else
161	135	{
162		if ( m~~icrotouch.~~last_touch_state == 1 )
	136	if ( m_last_touch_state == 1 )
163	137	{
164		microtouch.last_touch_state = 0;
165		switch( microtouch.format )
	138	m_last_touch_state = 0;
	139	switch( m_format )
166	140	{
167	141	case FORMAT_TABLET:
168		~~microtouch_~~send_format_table_packet(0x88, m~~icrotouch.~~last_x, m~~icrotouch.~~last_y);
	142	send_format_table_packet(0x88, m_last_x, m_last_y);
169	143	break;
170	144	case FORMAT_DECIMAL:
171		~~microtouch_~~send_format_decimal_packet(m~~icrotouch.~~last_x, m~~icrotouch.~~last_y);
	145	send_format_decimal_packet(m_last_x, m_last_y);
172	146	break;
173	147	case FORMAT_UNKNOWN:
174	148	break;
175	149	}
176	150	}
177	151	}
178		};
	152	}
179	153
180		void microtouch_i~~nit(running_ma~~c~~hin~~e ~~&machin~~e~~, m~~ic~~rotouch~~_~~tx_fun~~c ~~tx_cb, micr~~o~~touch_touch_fu~~n~~c touch~~_cb)
	154	void microtouch_device::device_config_complete()
181	155	{
182		memset(&microtouch, 0, sizeof(microtouch));
	156	const microtouch_interface intf = reinterpret_cast<const microtouch_interface >(static_config());
	157	if(intf != NULL)
	158	static_cast<microtouch_interface >(this) = *intf;
	159	else
	160	{
	161	memset(&m_out_tx_cb, 0, sizeof(m_out_tx_cb));
	162	memset(&m_out_touch_cb, 0, sizeof(m_out_touch_cb));
	163	}
	164	}
183	165
184		microtouch.last_touch_state = -1;
185		microtouch.tx_callback = tx_cb;
186		microtouch.touch_callback = touch_cb;
	166	void microtouch_device::device_start()
	167	{
	168	memset(m_rx_buffer, 0, sizeof(m_rx_buffer));
	169	memset(m_tx_buffer, 0, sizeof(m_tx_buffer));
	170	m_rx_buffer_ptr = 0;
	171	m_tx_buffer_ptr = 0;
	172	m_tx_buffer_num = 0;
	173	m_reset_done = 0;
	174	m_format = 0;
	175	m_mode = 0;
	176	m_last_x = 0;
	177	m_last_y = 0;
	178	m_last_touch_state = -1;
187	179
188		microtouch.timer = machine.scheduler().timer_alloc(FUNC(microtouch_timer_callback));
189		microtouch.timer->adjust(attotime::from_hz(1675), 0, attotime::from_hz(1675));
	180	m_timer = timer_alloc();
	181	m_timer->adjust(attotime::from_hz(1675), 0, attotime::from_hz(1675));
190	182
191		microtouch.format = FORMAT_UNKNOWN;
192		microtouch.mode = MODE_INACTIVE;
	183	m_format = FORMAT_UNKNOWN;
	184	m_mode = MODE_INACTIVE;
193	185
194		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.reset_done);
195		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_touch_state);
196		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_x);
197		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_y);
198		state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.rx_buffer);
199		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.rx_buffer_ptr);
200		state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.tx_buffer);
201		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_num);
202		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_ptr);
203		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.format);
204		state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode);
205		};
	186	save_item(NAME(m_reset_done));
	187	save_item(NAME(m_last_touch_state));
	188	save_item(NAME(m_last_x));
	189	save_item(NAME(m_last_y));
	190	save_item(NAME(m_rx_buffer));
	191	save_item(NAME(m_rx_buffer_ptr));
	192	save_item(NAME(m_tx_buffer));
	193	save_item(NAME(m_tx_buffer_num));
	194	save_item(NAME(m_tx_buffer_ptr));
	195	save_item(NAME(m_format));
	196	save_item(NAME(m_mode));
	197	m_out_tx_func.resolve(m_out_tx_cb, *this);
	198	}
206	199
207	200
208		~~void~~ microtouch_~~rx(~~int c~~ount, UINT8* data~~)
	201	WRITE8_MEMBER(microtouch_device::rx)
209	202	{
210		int i;
	203	m_rx_buffer[m_rx_buffer_ptr] = data;
	204	m_rx_buffer_ptr++;
	205	if(m_rx_buffer_ptr == 16)
	206	return;
211	207
212		for ( i = 0; ~~(i < count)~~ && ((micr~~oto~~u~~ch.~~rx_buffer_ptr ~~+ i) <~~ 1~~6);~~ ~~i++~~ )
	208	if (m_rx_buffer_ptr > 0 && (m_rx_buffer[m_rx_buffer_ptr-1] == 0x0d))
213	209	{
214		microtouch.rx_buffer[i+microtouch.rx_buffer_ptr] = data[i];
215		microtouch.rx_buffer_ptr++;
216		}
217
218		if (microtouch.rx_buffer_ptr > 0 && (microtouch.rx_buffer[microtouch.rx_buffer_ptr-1] == 0x0d))
219		{
220	210	if (LOG)
221	211	{
222	212	char command[16];
223	213	memset(command, 0, sizeof(command));
224		strncpy( command, (const char*)micr~~otouch.r~~x_buffer + 1, m~~icrotouch.~~rx_buffer_ptr - 2 );
	214	strncpy( command, (const char*)m_rx_buffer + 1, m_rx_buffer_ptr - 2 );
225	215	logerror("Microtouch: received command %s\n", command);
226	216	}
227	217	// check command
228		if ( mic~~rotouc~~h~~_ch~~eck_command( "MS", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	218	if ( check_command( "MS", m_rx_buffer_ptr, m_rx_buffer ) )
229	219	{
230		m~~icrotouch.~~mode = MODE_STREAM;
	220	m_mode = MODE_STREAM;
231	221	}
232		else if ( mic~~rotouc~~h~~_ch~~eck_command( "MI", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	222	else if ( check_command( "MI", m_rx_buffer_ptr, m_rx_buffer ) )
233	223	{
234		m~~icrotouch.~~mode = MODE_INACTIVE;
	224	m_mode = MODE_INACTIVE;
235	225	}
236		else if ( mic~~rotouc~~h~~_ch~~eck_command( "MP", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	226	else if ( check_command( "MP", m_rx_buffer_ptr, m_rx_buffer ) )
237	227	{
238		m~~icrotouch.~~mode = MODE_POINT;
	228	m_mode = MODE_POINT;
239	229	}
240		else if ( mic~~rotouc~~h~~_ch~~eck_command( "R", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	230	else if ( check_command( "R", m_rx_buffer_ptr, m_rx_buffer ) )
241	231	{
242		microtouch.tx_buffer_num = 0;
243		microtouch.reset_done = 1;
	232	m_tx_buffer_num = 0;
	233	m_reset_done = 1;
244	234	}
245		else if ( mic~~rotouc~~h~~_ch~~eck_command( "FT", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	235	else if ( check_command( "FT", m_rx_buffer_ptr, m_rx_buffer ) )
246	236	{
247		m~~icrotouch.~~format = FORMAT_TABLET;
	237	m_format = FORMAT_TABLET;
248	238	}
249		else if ( mic~~rotouc~~h~~_ch~~eck_command( "FD", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	239	else if ( check_command( "FD", m_rx_buffer_ptr, m_rx_buffer ) )
250	240	{
251		m~~icrotouch.~~format = FORMAT_DECIMAL;
	241	m_format = FORMAT_DECIMAL;
252	242	}
253		else if ( mic~~rotouc~~h~~_ch~~eck_command("OI", micr~~otouch.r~~x_buffer_ptr, m~~icrotouch.~~rx_buffer ) )
	243	else if ( check_command("OI", m_rx_buffer_ptr, m_rx_buffer ) )
254	244	{
255	245	// output identity - SMT3, ver 01.00
256		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 0x01;
257		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 'Q';
258		microtouch.tx_buffer[microtouch.tx_buffer_num++] = '1';
259		microtouch.tx_buffer[microtouch.tx_buffer_num++] = '0';
260		microtouch.tx_buffer[microtouch.tx_buffer_num++] = '1';
261		microtouch.tx_buffer[microtouch.tx_buffer_num++] = '0';
262		microtouch.tx_buffer[microtouch.tx_buffer_num++] = '0';
263		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 0x0d;
264		microtouch.rx_buffer_ptr = 0;
	246	m_tx_buffer[m_tx_buffer_num++] = 0x01;
	247	m_tx_buffer[m_tx_buffer_num++] = 'Q';
	248	m_tx_buffer[m_tx_buffer_num++] = '1';
	249	m_tx_buffer[m_tx_buffer_num++] = '0';
	250	m_tx_buffer[m_tx_buffer_num++] = '1';
	251	m_tx_buffer[m_tx_buffer_num++] = '0';
	252	m_tx_buffer[m_tx_buffer_num++] = '0';
	253	m_tx_buffer[m_tx_buffer_num++] = 0x0d;
	254	m_rx_buffer_ptr = 0;
265	255	return;
266	256	}
267	257	// send response
268		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 0x01;
269		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 0x30;
270		microtouch.tx_buffer[microtouch.tx_buffer_num++] = 0x0d;
271		microtouch.rx_buffer_ptr = 0;
	258	m_tx_buffer[m_tx_buffer_num++] = 0x01;
	259	m_tx_buffer[m_tx_buffer_num++] = 0x30;
	260	m_tx_buffer[m_tx_buffer_num++] = 0x0d;
	261	m_rx_buffer_ptr = 0;
272	262	}
273	263	};
274	264
275		~~static~~ INPUT_CHANGED( microtouch_touch )
	265	INPUT_CHANGED_MEMBER( microtouch_device::touch )
276	266	{
277		if ( newval && ( m~~icrotouch.~~mode == MODE_POINT ) )
	267	if ( newval && ( m_mode == MODE_POINT ) )
278	268	{
279		~~microtouch_~~send_touch_packet( ~~field.machine()~~ );
	269	send_touch_packet();
280	270	}
281	271	}
282	272
283		INPUT_PORTS_START(microtouch)
	273	static INPUT_PORTS_START(microtouch)
284	274	PORT_START("TOUCH")
285		PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_NAME( "Touch screen" ) PORT_CHANGED( microtouch_touch, 0 )
	275	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_NAME( "Touch screen" ) PORT_CHANGED_MEMBER( DEVICE_SELF,microtouch_device, touch, 0 )
286	276	PORT_START("TOUCH_X")
287	277	PORT_BIT( 0x3fff, 0x2000, IPT_LIGHTGUN_X ) PORT_CROSSHAIR(X, 1.0, 0.0, 0) PORT_SENSITIVITY(45) PORT_KEYDELTA(15)
288	278	PORT_START("TOUCH_Y")
289	279	PORT_BIT( 0x3fff, 0x2000, IPT_LIGHTGUN_Y ) PORT_CROSSHAIR(Y, 1.0, 0.0, 0) PORT_SENSITIVITY(45) PORT_KEYDELTA(15)
290	280	INPUT_PORTS_END
291	281
	282	ioport_constructor microtouch_device::device_input_ports() const
	283	{
	284	return INPUT_PORTS_NAME(microtouch);
	285	}
	286
	287	const device_type MICROTOUCH_SERIAL = &device_creator<microtouch_serial_device>;
	288
	289	microtouch_serial_device::microtouch_serial_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	290	: microtouch_device(mconfig, MICROTOUCH_SERIAL, "Microtouch Serial Touchscreen", tag, owner, clock),
	291	device_serial_interface(mconfig, *this)
	292	{
	293	}
	294
	295	void microtouch_serial_device::device_config_complete()
	296	{
	297	const microtouch_serial_interface intf = reinterpret_cast<const microtouch_serial_interface >(static_config());
	298	if(intf != NULL)
	299	static_cast<microtouch_serial_interface >(this) = *intf;
	300	else
	301	{
	302	memset(&m_out_stx_cb, 0, sizeof(m_out_stx_cb));
	303	}
	304	memset(&(microtouch_interface::m_out_tx_cb), 0, sizeof(microtouch_interface::m_out_tx_cb));
	305	memset(&m_out_touch_cb, 0, sizeof(m_out_touch_cb));
	306	}
	307
	308	void microtouch_serial_device::device_start()
	309	{
	310	microtouch_device::device_start();
	311	m_timer->adjust(attotime::from_hz(clock()), 0, attotime::from_hz(clock()));
	312	set_data_frame(8, 1, SERIAL_PARITY_NONE); //8N1?
	313	m_out_stx_func.resolve(m_out_stx_cb, *this);
	314	m_count = 0;
	315	m_output_valid = false;
	316
	317	save_item(NAME(m_count));
	318	save_item(NAME(m_output_valid));
	319	save_item(NAME(m_output));
	320	save_item(NAME(m_rx_line));
	321	}
	322
	323	void microtouch_serial_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	324	{
	325	if(is_transmit_register_empty())
	326	{
	327	if(m_output_valid)
	328	{
	329	transmit_register_setup(m_output);
	330	m_output_valid = false;
	331	}
	332	}
	333	else
	334	m_out_stx_func(transmit_register_get_data_bit());
	335
	336	receive_register_update_bit(m_rx_line);
	337	if(is_receive_register_full())
	338	{
	339	receive_register_extract();
	340	microtouch_device::rx(*memory_nonspecific_space(machine()), 0, get_received_char());
	341	receive_register_reset();
	342	}
	343
	344	if((m_count == 0) && (m_output_valid == false))
	345	microtouch_device::device_timer(timer, id, param, ptr);
	346
	347	++m_count %= 8;
	348	}

src/emu/machine/microtch.h
r14535	r14536
1	1	#ifndef _MICROTOUCH_H
2	2	#define _MICROTOUCH_H
3	3
4		~~INPUT_PORTS_EXTERN(m~~ic~~roto~~uch);
	4	#include "emu.h"
5	5
6		typedef void (*microtouch_tx_func)(running_machine &machine, UINT8 data);
7		typedef int (microtouch_touch_func)(running_machine &machine, int touch_x, int *touch_y);
	6	typedef int (microtouch_touch_func)(int touch_x, int *touch_y);
	7	#define MICROTOUCH_TOUCH(name) int name(int touch_x, int touch_y)
8	8
9		void microtouch_init(running_machine &machine, microtouch_tx_func tx_cb, microtouch_touch_func touch_cb);
10		void microtouch_rx(int count, UINT8* data);
	9	struct microtouch_interface
	10	{
	11	devcb_write8 m_out_tx_cb;
	12	microtouch_touch_func m_out_touch_cb;
	13	};
11	14
	15	class microtouch_device :
	16	public device_t,
	17	public microtouch_interface
	18	{
	19	public:
	20	microtouch_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock);
	21	microtouch_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	22
	23	virtual ioport_constructor device_input_ports() const;
	24	DECLARE_WRITE8_MEMBER(rx);
	25	DECLARE_INPUT_CHANGED_MEMBER(touch);
	26	protected:
	27	virtual void device_start();
	28	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	29	virtual void device_config_complete();
	30	virtual void tx(UINT8 data) { m_out_tx_func(0, data); }
	31	emu_timer* m_timer;
	32	private:
	33	int check_command( const char* commandtocheck, int command_len, UINT8* command_data );
	34	void send_format_table_packet(UINT8 flag, int x, int y);
	35	void send_format_decimal_packet(int x, int y);
	36	void send_touch_packet();
	37
	38	enum
	39	{
	40	FORMAT_UNKNOWN,
	41	FORMAT_TABLET,
	42	FORMAT_DECIMAL
	43	};
	44	enum
	45	{
	46	MODE_INACTIVE,
	47	MODE_STREAM,
	48	MODE_POINT
	49	};
	50	UINT8 m_rx_buffer[16];
	51	int m_rx_buffer_ptr;
	52	UINT8 m_tx_buffer[16];
	53	UINT8 m_tx_buffer_num;
	54	UINT8 m_tx_buffer_ptr;
	55	int m_reset_done;
	56	int m_format;
	57	int m_mode;
	58	int m_last_touch_state;
	59	int m_last_x;
	60	int m_last_y;
	61	devcb_resolved_write8 m_out_tx_func;
	62	};
	63
	64	extern const device_type MICROTOUCH;
	65
	66	#define MCFG_MICROTOUCH_ADD(_tag, _intrf) \
	67	MCFG_DEVICE_ADD(_tag, MICROTOUCH, 0) \
	68	MCFG_DEVICE_CONFIG(_intrf)
	69
	70	struct microtouch_serial_interface
	71	{
	72	devcb_write_line m_out_stx_cb;
	73	};
	74
	75	class microtouch_serial_device
	76	: public microtouch_device,
	77	public device_serial_interface,
	78	public microtouch_serial_interface
	79	{
	80	public:
	81	microtouch_serial_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	82
	83	DECLARE_WRITE_LINE_MEMBER(rx) {m_rx_line = state;}
	84	protected:
	85	virtual void device_start();
	86	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	87	virtual void device_config_complete();
	88	virtual void tx(UINT8 data) {m_output = data; m_output_valid = true;}
	89	virtual void input_callback(UINT8 state) { m_input_state = state; }
	90	private:
	91	int m_count;
	92	bool m_output_valid;
	93	UINT8 m_output;
	94	UINT8 m_rx_line;
	95	devcb_resolved_write_line m_out_stx_func;
	96	};
	97
	98	extern const device_type MICROTOUCH_SERIAL;
	99
	100	#define MCFG_MICROTOUCH_SERIAL_ADD(_tag, _intrf, _clock) \
	101	MCFG_DEVICE_ADD(_tag, MICROTOUCH_SERIAL, _clock) \
	102	MCFG_DEVICE_CONFIG(_intrf)
	103
12	104	#endif //_MICROTOUCH_H

src/mess/machine/pc_mouse.c
r14535	r14536
1		/***************************************************************************
2
3		machine/pc_mouse.c
4
5		Code for emulating PC-style serial mouses
6
7		***************************************************************************/
8
9		#include "emu.h"
10		#include "machine/ins8250.h"
11		#include "machine/pc_mouse.h"
12
13
14		static struct {
15
16		PC_MOUSE_PROTOCOL protocol;
17
18		device_t *ins8250;
19		int inputs;
20
21		UINT8 queue[256];
22		UINT8 head, tail, mb;
23
24		emu_timer *timer;
25
26		} pc_mouse;
27
28		static TIMER_CALLBACK(pc_mouse_scan);
29
30		void pc_mouse_initialise(running_machine &machine)
31		{
32		pc_mouse.head = pc_mouse.tail = 0;
33		pc_mouse.timer = machine.scheduler().timer_alloc(FUNC(pc_mouse_scan));
34		pc_mouse.inputs = 0;
35		pc_mouse.ins8250 = NULL;
36		}
37
38		void pc_mouse_set_serial_port(device_t *ins8250)
39		{
40		if ( pc_mouse.ins8250 != ins8250 ) {
41		pc_mouse.ins8250 = ins8250;
42		ins8250_handshake_in(pc_mouse.ins8250, pc_mouse.inputs);
43		}
44		}
45
46		/* add data to queue */
47		static void pc_mouse_queue_data(int data)
48		{
49		pc_mouse.queue[pc_mouse.head] = data;
50		pc_mouse.head++;
51		pc_mouse.head %= 256;
52		}
53
54		/**************************************************************************
55		* Check for mouse moves and buttons. Build delta x/y packets
56		**************************************************************************/
57		static TIMER_CALLBACK(pc_mouse_scan)
58		{
59		static int ox = 0, oy = 0;
60		int nx,ny;
61		int dx, dy, nb;
62		int mbc;
63
64		/* Do not get deltas or send packets if queue is not empty (Prevents drifting) */
65		if (pc_mouse.head==pc_mouse.tail)
66		{
67		nx = input_port_read(machine, "pc_mouse_x");
68
69		dx = nx - ox;
70		if (dx<=-0x800) dx = nx + 0x1000 - ox; /* Prevent jumping */
71		if (dx>=0x800) dx = nx - 0x1000 - ox;
72		ox = nx;
73
74		ny = input_port_read(machine, "pc_mouse_y");
75
76		dy = ny - oy;
77		if (dy<=-0x800) dy = ny + 0x1000 - oy;
78		if (dy>=0x800) dy = ny - 0x1000 - oy;
79		oy = ny;
80
81		nb = input_port_read(machine, "pc_mouse_misc");
82		if ((nb & 0x80) != 0)
83		{
84		pc_mouse.protocol=TYPE_MOUSE_SYSTEMS;
85		}
86		else
87		{
88		pc_mouse.protocol=TYPE_MICROSOFT_MOUSE;
89		}
90		mbc = nb^pc_mouse.mb;
91		pc_mouse.mb = nb;
92
93		/* check if there is any delta or mouse buttons changed */
94		if ( (dx!=0) \|\| (dy!=0) \|\| (mbc!=0) )
95		{
96		switch (pc_mouse.protocol)
97		{
98
99		default:
100		case TYPE_MICROSOFT_MOUSE:
101		{
102		/* split deltas into packtes of -128..+127 max */
103		do
104		{
105		UINT8 m0, m1, m2;
106		int ddx = (dx < -128) ? -128 : (dx > 127) ? 127 : dx;
107		int ddy = (dy < -128) ? -128 : (dy > 127) ? 127 : dy;
108		m0 = 0x40 \| ((nb << 4) & 0x30) \| ((ddx >> 6) & 0x03) \| ((ddy >> 4) & 0x0c);
109		m1 = ddx & 0x3f;
110		m2 = ddy & 0x3f;
111
112		/* KT - changed to use a function */
113		pc_mouse_queue_data(m0 \| 0x40);
114		pc_mouse_queue_data(m1 & 0x03f);
115		pc_mouse_queue_data(m2 & 0x03f);
116		if ((mbc & 0x04) != 0) /* If button 3 changed send extra byte */
117		{
118		pc_mouse_queue_data( (nb & 0x04) << 3);
119		}
120
121		dx -= ddx;
122		dy -= ddy;
123		} while( dx \|\| dy );
124		}
125		break;
126
127		/* mouse systems mouse
128		from "PC Mouse information" by Tomi Engdahl */
129
130		/*
131		The data is sent in 5 byte packets in following format:
132		D7 D6 D5 D4 D3 D2 D1 D0
133
134		1. 1 0 0 0 0 LB CB RB
135		2. X7 X6 X5 X4 X3 X2 X1 X0
136		3. Y7 Y6 Y5 Y4 Y3 Y4 Y1 Y0
137		4. X7' X6' X5' X4' X3' X2' X1' X0'
138		5. Y7' Y6' Y5' Y4' Y3' Y4' Y1' Y0'
139
140		LB is left button state (0=pressed, 1=released)
141		CB is center button state (0=pressed, 1=released)
142		RB is right button state (0=pressed, 1=released)
143		X7-X0 movement in X direction since last packet in signed byte
144		format (-128..+127), positive direction right
145		Y7-Y0 movement in Y direction since last packet in signed byte
146		format (-128..+127), positive direction up
147		X7'-X0' movement in X direction since sending of X7-X0 packet in signed byte
148		format (-128..+127), positive direction right
149		Y7'-Y0' movement in Y direction since sending of Y7-Y0 in signed byte
150		format (-128..+127), positive direction up
151
152		The last two bytes in the packet (bytes 4 and 5) contains information about movement data changes which have occurred after data butes 2 and 3 have been sent. */
153
154		case TYPE_MOUSE_SYSTEMS:
155		{
156
157		dy =-dy;
158
159		do
160		{
161		int ddx = (dx < -128) ? -128 : (dx > 127) ? 127 : dx;
162		int ddy = (dy < -128) ? -128 : (dy > 127) ? 127 : dy;
163
164		/* KT - changed to use a function */
165		pc_mouse_queue_data(0x080 \| ((((nb & 0x04) >> 1) + ((nb & 0x02) << 1) + (nb & 0x01)) ^ 0x07));
166		pc_mouse_queue_data(ddx);
167		pc_mouse_queue_data(ddy);
168		/* for now... */
169		pc_mouse_queue_data(0);
170		pc_mouse_queue_data(0);
171		dx -= ddx;
172		dy -= ddy;
173		} while( dx \|\| dy );
174
175		}
176		break;
177		}
178		}
179		}
180
181		/* Send any data from this scan or any pending data from a previous scan */
182
183		if( pc_mouse.tail != pc_mouse.head )
184		{
185		int data;
186
187		data = pc_mouse.queue[pc_mouse.tail];
188		ins8250_receive(pc_mouse.ins8250, data);
189		pc_mouse.tail++;
190		pc_mouse.tail &= 255;
191		}
192		}
193
194
195
196		/**************************************************************************
197		* Check for mouse control line changes and (de-)install timer
198		**************************************************************************/
199
200		INS8250_HANDSHAKE_OUT( pc_mouse_handshake_in )
201		{
202		if (device!=pc_mouse.ins8250) return;
203		if (!(data ^ pc_mouse.inputs)) {
204		ins8250_handshake_in(pc_mouse.ins8250, 0);
205		return;
206		}
207
208		if ((data & UART8250_HANDSHAKE_OUT_DTR) && (data & UART8250_HANDSHAKE_OUT_RTS))
209		{
210		/* RTS toggled */
211		if (!(pc_mouse.inputs & UART8250_HANDSHAKE_OUT_RTS) && (data & UART8250_HANDSHAKE_OUT_RTS))
212		{
213		/* reset mouse */
214		pc_mouse.head = pc_mouse.tail = pc_mouse.mb = 0;
215
216		if ((input_port_read(device->machine(), "pc_mouse_misc") & 0x80) == 0 )
217		{
218		/* Identify as Microsoft 3 Button Mouse */
219		pc_mouse.queue[pc_mouse.head] = 'M';
220		pc_mouse.head++;
221		pc_mouse.head %= 256;
222		pc_mouse.queue[pc_mouse.head] = '3';
223		pc_mouse.head++;
224		pc_mouse.head %= 256;
225		}
226		}
227		/* start a timer to scan the mouse input */
228		pc_mouse.timer->adjust(attotime::zero, 0, attotime::from_hz(240));
229		}
230		else
231		{
232		pc_mouse.timer->adjust(attotime::zero);
233		pc_mouse.head = pc_mouse.tail = 0;
234		}
235
236		pc_mouse.inputs=data;
237		// do not set DSR or CTS
238		ins8250_handshake_in(pc_mouse.ins8250, 0);
239		}
240
241
242
243		/**************************************************************************
244		* Mouse INPUT_PORT declarations
245		**************************************************************************/
246
247		INPUT_PORTS_START( pc_mouse_mousesystems )
248		PORT_START( "pc_mouse_misc" )
249		PORT_CONFNAME( 0x80, 0x80, "Mouse Protocol" )
250		PORT_CONFSETTING( 0x80, "Mouse Systems" )
251		PORT_CONFSETTING( 0x00, "Microsoft" )
252		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Mouse Left Button") PORT_CODE(MOUSECODE_BUTTON1)
253		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Mouse Middle Button") PORT_CODE(MOUSECODE_BUTTON3)
254		PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON3) PORT_NAME("Mouse Right Button") PORT_CODE(MOUSECODE_BUTTON2)
255
256		PORT_START( "pc_mouse_x" ) /* Mouse - X AXIS */
257		PORT_BIT( 0xfff, 0x00, IPT_MOUSE_X) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1)
258
259		PORT_START( "pc_mouse_y" ) /* Mouse - Y AXIS */
260		PORT_BIT( 0xfff, 0x00, IPT_MOUSE_Y) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1)
261		INPUT_PORTS_END
262
263
264
265		INPUT_PORTS_START( pc_mouse_microsoft )
266		PORT_START( "pc_mouse_misc" )
267		PORT_CONFNAME( 0x80, 0x00, "Mouse Protocol" )
268		PORT_CONFSETTING( 0x00, "Microsoft" )
269		PORT_CONFSETTING( 0x80, "Mouse Systems" )
270		PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Mouse Left Button") PORT_CODE(MOUSECODE_BUTTON1)
271		PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Mouse Middle Button") PORT_CODE(MOUSECODE_BUTTON3)
272		PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON3) PORT_NAME("Mouse Right Button") PORT_CODE(MOUSECODE_BUTTON2)
273
274		PORT_START( "pc_mouse_x" ) /* Mouse - X AXIS */
275		PORT_BIT( 0xfff, 0x00, IPT_MOUSE_X) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1)
276
277		PORT_START( "pc_mouse_y" ) /* Mouse - Y AXIS */
278		PORT_BIT( 0xfff, 0x00, IPT_MOUSE_Y) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1)
279		INPUT_PORTS_END
280
281
282
283		INPUT_PORTS_START( pc_mouse_none )
284		PORT_START( "pc_mouse_misc" ) /* IN12 */
285		PORT_BIT ( 0xffff, 0x0000, IPT_UNUSED )
286		PORT_START( "pc_mouse_x" ) /* IN13 */
287		PORT_BIT ( 0xffff, 0x0000, IPT_UNUSED )
288		PORT_START( "pc_mouse_y" ) /* IN14 */
289		PORT_BIT ( 0xffff, 0x0000, IPT_UNUSED )
290		INPUT_PORTS_END

src/mess/machine/pc_mouse.h
r14535	r14536
1		/*****************************************************************************
2		*
3		* machine/pc_mouse.h
4		*
5		****************************************************************************/
6
7		#ifndef PC_MOUSE_H_
8		#define PC_MOUSE_H_
9
10		#ifdef __cplusplus
11		extern "C" {
12		#endif
13
14		#include "machine/ins8250.h"
15
16		typedef enum
17		{
18		TYPE_MICROSOFT_MOUSE,
19		TYPE_MOUSE_SYSTEMS
20		} PC_MOUSE_PROTOCOL;
21
22
23		/----------- defined in machine/pc_mouse.c -----------/
24
25		INS8250_HANDSHAKE_OUT( pc_mouse_handshake_in );
26
27		// set base for input port
28		void pc_mouse_set_serial_port(device_t *ins8250);
29		void pc_mouse_initialise(running_machine &machine);
30
31		INPUT_PORTS_EXTERN( pc_mouse_mousesystems );
32		INPUT_PORTS_EXTERN( pc_mouse_microsoft );
33		INPUT_PORTS_EXTERN( pc_mouse_none );
34
35
36		#ifdef __cplusplus
37		}
38		#endif
39
40		#endif /* PC_MOUSE_H_ */

src/mess/machine/s100_wunderbus.c
r14535	r14536
65	65	//-------------------------------------------------
66	66	// ins8250_interface ace1_intf
67	67	//-------------------------------------------------
68
	68	/*
69	69	static INS8250_TRANSMIT( ace1_transmit )
70	70	{
71	71	s100_wunderbus_device wunderbus = downcast<s100_wunderbus_device >(device->owner());
72	72
73	73	wunderbus->m_s100->terminal_transmit_w(data);
74	74	}
	75	*/
	76	//-------------------------------------------------
	77	// s100_terminal_w - terminal write
	78	//-------------------------------------------------
75	79
	80	void s100_wunderbus_device::s100_terminal_w(UINT8 data)
	81	{
	82	// ins8250_receive(m_ace1, data);
	83	}
	84
76	85	static ins8250_interface ace1_intf =
77	86	{
78		XTAL_18_432MHz/10,
	87	DEVCB_NULL,
	88	DEVCB_NULL,
79	89	DEVCB_DEVICE_LINE(I8259A_TAG, pic8259_ir3_w),
80		ace1_transmit,
81		NULL,
82		NULL
	90	DEVCB_NULL,
	91	DEVCB_NULL,
	92	DEVCB_NULL
83	93	};
84	94
85	95
r14535	r14536
89	99
90	100	static ins8250_interface ace2_intf =
91	101	{
92		XTAL_18_432MHz/10,
	102	DEVCB_NULL,
	103	DEVCB_NULL,
93	104	DEVCB_DEVICE_LINE(I8259A_TAG, pic8259_ir4_w),
94		NULL,
95		NULL,
96		NULL
	105	DEVCB_NULL,
	106	DEVCB_NULL,
	107	DEVCB_NULL
97	108	};
98	109
99	110
r14535	r14536
103	114
104	115	static ins8250_interface ace3_intf =
105	116	{
106		XTAL_18_432MHz/10,
	117	DEVCB_NULL,
	118	DEVCB_NULL,
107	119	DEVCB_DEVICE_LINE(I8259A_TAG, pic8259_ir5_w),
108		NULL,
109		NULL,
110		NULL
	120	DEVCB_NULL,
	121	DEVCB_NULL,
	122	DEVCB_NULL
111	123	};
112	124
113	125
r14535	r14536
137	149
138	150	static MACHINE_CONFIG_FRAGMENT( s100_wunderbus )
139	151	MCFG_PIC8259_ADD(I8259A_TAG, pic_intf)
140		MCFG_INS8250_ADD(INS8250_1_TAG, ace1_intf)
141		MCFG_INS8250_ADD(INS8250_2_TAG, ace2_intf)
142		MCFG_INS8250_ADD(INS8250_3_TAG, ace3_intf)
	152	MCFG_INS8250_ADD(INS8250_1_TAG, ace1_intf, XTAL_18_432MHz/10)
	153	MCFG_INS8250_ADD(INS8250_2_TAG, ace2_intf, XTAL_18_432MHz/10)
	154	MCFG_INS8250_ADD(INS8250_3_TAG, ace3_intf, XTAL_18_432MHz/10)
143	155	MCFG_UPD1990A_ADD(UPD1990C_TAG, XTAL_32_768kHz, rtc_intf)
144	156	MACHINE_CONFIG_END
145	157
r14535	r14536
403	415	break;
404	416
405	417	case 1:
406		data = ins8250_r(m_ace1, offset & 0x07);
	418	data = m_ace1->ins8250_r(*memory_nonspecific_space(machine()), offset & 0x07);
407	419	break;
408	420
409	421	case 2:
410		data = ins8250_r(m_ace2, offset & 0x07);
	422	data = m_ace2->ins8250_r(*memory_nonspecific_space(machine()), offset & 0x07);
411	423	break;
412	424
413	425	case 3:
414		data = ins8250_r(m_ace3, offset & 0x07);
	426	data = m_ace3->ins8250_r(*memory_nonspecific_space(machine()), offset & 0x07);
415	427	break;
416	428	}
417	429	}
r14535	r14536
526	538	break;
527	539
528	540	case 1:
529		ins8250_w(m_ace1, offset & 0x07, data);
	541	m_ace1->ins8250_w(*memory_nonspecific_space(machine()), offset & 0x07, data);
530	542	break;
531	543
532	544	case 2:
533		ins8250_w(m_ace2, offset & 0x07, data);
	545	m_ace2->ins8250_w(*memory_nonspecific_space(machine()), offset & 0x07, data);
534	546	break;
535	547
536	548	case 3:
537		ins8250_w(m_ace3, offset & 0x07, data);
	549	m_ace3->ins8250_w(*memory_nonspecific_space(machine()), offset & 0x07, data);
538	550	break;
539	551	}
540	552	}
541	553	}
542	554
543
544		//-------------------------------------------------
545		// s100_terminal_w - terminal write
546		//-------------------------------------------------
547
548		void s100_wunderbus_device::s100_terminal_w(UINT8 data)
549		{
550		ins8250_receive(m_ace1, data);
551		}

src/mess/machine/s100_wunderbus.h
r14535	r14536
41	41	DECLARE_WRITE_LINE_MEMBER( pic_int_w );
42	42	DECLARE_WRITE_LINE_MEMBER( rtc_tp_w );
43	43	required_device<device_t> m_pic;
44		required_device<device_t> m_ace1;
45		required_device<device_t> m_ace2;
46		required_device<device_t> m_ace3;
	44	required_device<ins8250_device> m_ace1;
	45	required_device<ins8250_device> m_ace2;
	46	required_device<ins8250_device> m_ace3;
47	47	required_device<upd1990a_device> m_rtc;
48	48
49	49	protected:

src/mess/machine/teleprinter.c
r14535	r14536
244	244
245	245	static TIMER_CALLBACK(keyboard_callback)
246	246	{
	247	UINT8 new_code;
247	248	teleprinter_state term = get_safe_token((device_t )ptr);
248		term->last_code = terminal_keyboard_handler(machine, term->teleprinter_keyboard_func, term->last_code, &term->scan_line, NULL, NULL, (device_t *)ptr);
	249	new_code = terminal_keyboard_handler(machine, term->last_code, &term->scan_line, NULL, NULL, (device_t *)ptr);
	250
	251	if(new_code != term->last_code)
	252	term->teleprinter_keyboard_func(0, new_code);
	253	term->last_code = new_code;
249	254	}
250	255
251	256	/***************************************************************************

src/mess/machine/serial.c
r14535	r14536
6	6	device_serial_port_interface::device_serial_port_interface(const machine_config &mconfig, device_t &device)
7	7	: device_slot_card_interface(mconfig, device)
8	8	{
9		m_rdata = 0;
10		m_tdata = 0;
11	9	m_rbit = FALSE;
12	10	m_tbit = FALSE;
13	11	}
r14535	r14536
23	21	{
24	22	}
25	23
	24	serial_port_device::serial_port_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
	25	: device_t(mconfig, type, name, tag, owner, clock),
	26	device_slot_interface(mconfig, *this),
	27	m_dev(NULL)
	28	{
	29	}
	30
26	31	serial_port_device::~serial_port_device()
27	32	{
28	33	}
r14535	r14536
36	41	}
37	42	else
38	43	{
39		memset(&m_out_rx8_cb, 0, sizeof(m_out_rx8_cb));
40	44	memset(&m_out_rx_cb, 0, sizeof(m_out_rx_cb));
41	45	}
42	46	m_dev = dynamic_cast<device_serial_port_interface *>(get_card_device());
r14535	r14536
44	48
45	49	void serial_port_device::device_start()
46	50	{
47		m_out_rx8_func.resolve(m_out_rx8_cb, *this);
48	51	m_out_rx_func.resolve(m_out_rx_cb, *this);
49	52	}
50	53
r14535	r14536
66	69	}
67	70
68	71	rs232_port_device::rs232_port_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
69		: serial_port_device(mconfig, tag, owner, clock)
	72	: serial_port_device(mconfig, RS232_PORT, "RS232 Port", tag, owner, clock)
70	73	{
71	74	}
72	75
r14535	r14536
80	83	if (intf != NULL)
81	84	{
82	85	static_cast<rs232_port_interface >(this) = *intf;
83		memcpy(&(serial_port_interface::m_out_rx8_cb), &(rs232_port_interface::m_out_rx8_cb), sizeof(rs232_port_interface::m_out_rx8_cb));
84	86	memcpy(&(serial_port_interface::m_out_rx_cb), &(rs232_port_interface::m_out_rx_cb), sizeof(rs232_port_interface::m_out_rx_cb));
85	87	}
86	88	else
87	89	{
88		memset(&(serial_port_interface::m_out_rx8_cb), 0, sizeof(serial_port_interface::m_out_rx8_cb));
89	90	memset(&(serial_port_interface::m_out_rx_cb), 0, sizeof(serial_port_interface::m_out_rx_cb));
90	91	memset(&m_out_dcd_cb, 0, sizeof(m_out_dcd_cb));
91	92	memset(&m_out_dsr_cb, 0, sizeof(m_out_dsr_cb));
r14535	r14536
93	94	memset(&m_out_cts_cb, 0, sizeof(m_out_cts_cb));
94	95	}
95	96	m_dev = dynamic_cast<device_rs232_port_interface *>(get_card_device());
	97	serial_port_device::m_dev = dynamic_cast<device_serial_port_interface *>(get_card_device());
	98	loopdtr = 0;
	99	looprts = 0;
96	100	}
97	101
98	102	void rs232_port_device::device_start()
r14535	r14536
103	107	m_out_ri_func.resolve(m_out_ri_cb, *this);
104	108	m_out_cts_func.resolve(m_out_cts_cb, *this);
105	109	}
	110
	111	// XXX:make loopback handshaking optional if needed
	112	WRITE_LINE_MEMBER( rs232_port_device::dtr_w )
	113	{
	114	if(m_dev)
	115	return m_dev->dtr_w(state);
	116
	117	if(serial_port_device::m_dev)
	118	{
	119	loopdtr = state;
	120	out_dcd(state);
	121	out_dsr(state);
	122	}
	123	}
	124
	125	WRITE_LINE_MEMBER( rs232_port_device::rts_w )
	126	{
	127	if(m_dev)
	128	return m_dev->rts_w(state);
	129
	130	if(serial_port_device::m_dev)
	131	{
	132	looprts = state;
	133	out_cts(state);
	134	}
	135	}
	136

src/mess/machine/serial.h
r14535	r14536
15	15
16	16	struct serial_port_interface
17	17	{
18		devcb_write8 m_out_rx8_cb;
19	18	devcb_write_line m_out_rx_cb;
20	19	};
21	20
r14535	r14536
25	24	device_serial_port_interface(const machine_config &mconfig, device_t &device);
26	25	virtual ~device_serial_port_interface();
27	26
28		virtual void tx8(UINT8 data) { m_tdata = data; }
29		virtual UINT8 rx8() { return m_rdata; }
30	27	virtual void tx(UINT8 state) { m_tbit = state; }
31		virtual ~~int~~ rx() { return m_rbit; }
	28	virtual UINT8 rx() { return m_rbit; }
32	29	protected:
33		UINT8 m_rdata;
34	30	UINT8 m_rbit;
35		UINT8 m_tdata;
36	31	UINT8 m_tbit;
37	32	};
38	33
r14535	r14536
42	37	{
43	38	public:
44	39	serial_port_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	40	serial_port_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock);
45	41	virtual ~serial_port_device();
46	42
47		DECLARE_WRITE8_MEMBER( tx8 ) { if(m_dev) m_dev->tx8(data); }
48		DECLARE_READ8_MEMBER( rx8 ) { return (m_dev) ? m_dev->rx8() : 0; }
49
50	43	DECLARE_WRITE_LINE_MEMBER( tx ) { if(m_dev) m_dev->tx(state); }
51	44	DECLARE_READ_LINE_MEMBER( rx ) { return (m_dev) ? m_dev->rx() : 0; }
52	45
53		void out_rx8(UINT8 data) { m_out_rx8_func(0, data); }
54	46	void out_rx(UINT8 param) { m_out_rx_func(param); }
55	47	protected:
56	48	virtual void device_start();
57	49	virtual void device_config_complete();
58
	50	device_serial_port_interface *m_dev;
59	51	private:
60		devcb_resolved_write8 m_out_rx8_func;
61	52	devcb_resolved_write_line m_out_rx_func;
62
63		device_serial_port_interface *m_dev;
64	53	};
65	54
66	55	extern const device_type SERIAL_PORT;
67	56
68	57	struct rs232_port_interface
69	58	{
70		devcb_write8 m_out_rx8_cb;
71	59	devcb_write_line m_out_rx_cb;
72	60	devcb_write_line m_out_dcd_cb;
73	61	devcb_write_line m_out_dsr_cb;
r14535	r14536
104	92	rs232_port_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
105	93	virtual ~rs232_port_device();
106	94
107		DECLARE_WRITE_LINE_MEMBER( dtr_w ) { if (m_dev) m_dev->dtr_w(state); }
108		DECLARE_WRITE_LINE_MEMBER( rts_w ) { if (m_dev) m_dev->rts_w(state); }
	95	DECLARE_WRITE_LINE_MEMBER( dtr_w );
	96	DECLARE_WRITE_LINE_MEMBER( rts_w );
109	97
110		DECLARE_READ_LINE_MEMBER( dcd_r ) { return (m_dev) ? m_dev->dcd_r() : 0; }
111		DECLARE_READ_LINE_MEMBER( dsr_r ) { return (m_dev) ? m_dev->dsr_r() : 0; }
	98	DECLARE_READ_LINE_MEMBER( dcd_r ) { return (m_dev) ? m_dev->dcd_r() : loopdtr; }
	99	DECLARE_READ_LINE_MEMBER( dsr_r ) { return (m_dev) ? m_dev->dsr_r() : loopdtr; }
112	100	DECLARE_READ_LINE_MEMBER( ri_r ) { return (m_dev) ? m_dev->ri_r() : 0; }
113		DECLARE_READ_LINE_MEMBER( cts_r ) { return (m_dev) ? m_dev->cts_r() : 0; }
	101	DECLARE_READ_LINE_MEMBER( cts_r ) { return (m_dev) ? m_dev->cts_r() : looprts; }
114	102
115	103	void out_dcd(UINT8 param) { m_out_dcd_func(param); }
116	104	void out_dsr(UINT8 param) { m_out_dsr_func(param); }
r14535	r14536
120	108	protected:
121	109	virtual void device_start();
122	110	virtual void device_config_complete();
123
124		private:
125	111	device_rs232_port_interface *m_dev;
126
	112	private:
127	113	devcb_resolved_write_line m_out_dcd_func;
128	114	devcb_resolved_write_line m_out_dsr_func;
129	115	devcb_resolved_write_line m_out_ri_func;
130	116	devcb_resolved_write_line m_out_cts_func;
	117	UINT8 loopdtr;
	118	UINT8 looprts;
131	119	};
132	120
133	121	extern const device_type RS232_PORT;

src/mess/machine/svi318.c
r14535	r14536
42	42	cputag_set_input_line(device->machine(), "maincpu", 0, (state ? HOLD_LINE : CLEAR_LINE));
43	43	}
44	44	}
45
	45	#if 0
46	46	static INS8250_REFRESH_CONNECT( svi318_com_refresh_connected )
47	47	{
48	48	/* Motorola MC14412 modem */
49	49	ins8250_handshake_in(device, UART8250_HANDSHAKE_IN_CTS\|UART8250_HANDSHAKE_IN_DSR\|UART8250_INPUTS_RING_INDICATOR\|UART8250_INPUTS_DATA_CARRIER_DETECT);
50	50	}
51
	51	#endif
52	52	const ins8250_interface svi318_ins8250_interface[2]=
53	53	{
54	54	{
55		1000000,
	55	DEVCB_NULL,
	56	DEVCB_NULL,
	57	DEVCB_NULL,
56	58	DEVCB_LINE(svi318_ins8250_interrupt),
57		NULL,
58		NULL,
59		svi318_com_refresh_connected
	59	DEVCB_NULL,
	60	DEVCB_NULL
60	61	},
61	62	{
62		3072000,
	63	DEVCB_NULL,
	64	DEVCB_NULL,
	65	DEVCB_NULL,
63	66	DEVCB_LINE(svi318_ins8250_interrupt),
64		NULL,
65		NULL,
66		NULL
	67	DEVCB_NULL,
	68	DEVCB_NULL
67	69	}
68	70	};
69	71
r14535	r14536
773	775	svi318_state *state = space->machine().driver_data<svi318_state>();
774	776	UINT8 data = 0xff;
775	777	device_t *device;
	778	ins8250_device *uart;
776	779	centronics_device *centronics = space->machine().device<centronics_device>("centronics");
777	780
778	781	if (state->m_svi.bankLow == SVI_CART)
r14535	r14536
794	797	case 0x25:
795	798	case 0x26:
796	799	case 0x27:
797		device = space->machine().device("ins8250_0");
798		data = ins8250_r(device, offset & 7);
	800	uart = space->machine().device<ins8250_device>("ins8250_0");
	801	data = uart->ins8250_r(*space, offset & 7);
799	802	break;
800	803
801	804	case 0x28:
r14535	r14536
806	809	case 0x2D:
807	810	case 0x2E:
808	811	case 0x2F:
809		device = space->machine().device("ins8250_1");
810		data = ins8250_r(device, offset & 7);
	812	uart = space->machine().device<ins8250_device>("ins8250_1");
	813	data = uart->ins8250_r(*space, offset & 7);
811	814	break;
812	815
813	816	case 0x30:
r14535	r14536
842	845	{
843	846	svi318_state *state = space->machine().driver_data<svi318_state>();
844	847	device_t *device;
	848	ins8250_device *uart;
845	849	centronics_device *centronics = space->machine().device<centronics_device>("centronics");
846	850
847	851	if (state->m_svi.bankLow == SVI_CART)
r14535	r14536
867	871	case 0x25:
868	872	case 0x26:
869	873	case 0x27:
870		device = space->machine().device("ins8250_0");
871		ins8250_w(device, offset & 7, data);
	874	uart = space->machine().device<ins8250_device>("ins8250_0");
	875	uart->ins8250_w(*space, offset & 7, data);
872	876	break;
873	877
874	878	case 0x28:
r14535	r14536
879	883	case 0x2D:
880	884	case 0x2E:
881	885	case 0x2F:
882		device = space->machine().device("ins8250_1");
883		ins8250_w(device, offset & 7, data);
	886	uart = space->machine().device<ins8250_device>("ins8250_1");
	887	uart->ins8250_w(*space, offset & 7, data);
884	888	break;
885	889
886	890	case 0x30:

src/mess/machine/isa_com.c
r14535	r14536
4	4
5	5	***************************************************************************/
6	6
7		#include "emu.h"
8	7	#include "isa_com.h"
9		#include "machine/ins8250.h"
10	8	#include "machine/ser_mouse.h"
	9	#include "machine/terminal.h"
	10	#include "machine/null_modem.h"
11	11
12	12	/* called when a interrupt is set/cleared from com hardware */
13	13	static WRITE_LINE_DEVICE_HANDLER( pc_com_interrupt_1 )
r14535	r14536
22	22	com->m_isa->irq3_w(state);
23	23	}
24	24
25		static void pc_com_~~refresh_connec~~t~~ed_common~~(device_t *uart, ~~int~~ n, int ~~data~~)
	25	static void pc_com_tx(device_t *uart, UINT8 state, int n)
26	26	{
27	27	isa8_com_device com = downcast<isa8_com_device >(uart->owner());
28		rs232_port_device *port = com->get_port(n);
29
30		port->dtr_w(data & 1);
31		port->rts_w((data & 2) && 1);
32		ins8250_handshake_in(uart, (port->cts_r() << 4)\|(port->dsr_r() << 5)\|(port->ri_r() << 6)\|(port->dcd_r() << 7));
	28	com->get_port(n)->tx(state);
33	29	}
34	30
35		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_0 ) { pc_com_refresh_connected_common( device, 0, data ); }
36		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_1 ) { pc_com_refresh_connected_common( device, 1, data ); }
37		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_2 ) { pc_com_refresh_connected_common( device, 2, data ); }
38		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_3 ) { pc_com_refresh_connected_common( device, 3, data ); }
	31	static void pc_com_dtr(device_t *uart, UINT8 state, int n)
	32	{
	33	isa8_com_device com = downcast<isa8_com_device >(uart->owner());
	34	com->get_port(n)->dtr_w(state);
	35	}
39	36
40		static void pc_com_tx(device_t *uart, UINT8 data, int n)
	37	static void pc_com_rts(device_t *uart, UINT8 state, int n)
41	38	{
42	39	isa8_com_device com = downcast<isa8_com_device >(uart->owner());
43		com->get_port(n)->~~tx8(*memo~~r~~y_non~~s~~pecific~~_~~space~~(~~uar~~t~~->m~~a~~chine()), 0, da~~ta);
	40	com->get_port(n)->rts_w(state);
44	41	}
45	42
46		static INS8250_TRANSMIT( pc_com_tx_0 ) { pc_com_tx(device, data, 0); }
47		static INS8250_TRANSMIT( pc_com_tx_1 ) { pc_com_tx(device, data, 1); }
48		static INS8250_TRANSMIT( pc_com_tx_2 ) { pc_com_tx(device, data, 2); }
49		static INS8250_TRANSMIT( pc_com_tx_3 ) { pc_com_tx(device, data, 3); }
	43	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_0 ) { pc_com_tx(device, state, 0); }
	44	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_0 ) { pc_com_dtr(device, state, 0); }
	45	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_0 ) { pc_com_rts(device, state, 0); }
50	46
51		WRITE8_DEVICE_HANDLER( pc_com_rx_0 ) { ins8250_receive(downcast<isa8_com_device *>(device->owner())->get_uart(0), data); }
52		WRITE8_DEVICE_HANDLER( pc_com_rx_1 ) { ins8250_receive(downcast<isa8_com_device *>(device->owner())->get_uart(1), data); }
53		WRITE8_DEVICE_HANDLER( pc_com_rx_2 ) { ins8250_receive(downcast<isa8_com_device *>(device->owner())->get_uart(2), data); }
54		WRITE8_DEVICE_HANDLER( pc_com_rx_3 ) { ins8250_receive(downcast<isa8_com_device *>(device->owner())->get_uart(3), data); }
	47	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_1 ) { pc_com_tx(device, state, 1); }
	48	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_1 ) { pc_com_dtr(device, state, 1); }
	49	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_1 ) { pc_com_rts(device, state, 1); }
55	50
	51	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_2 ) { pc_com_tx(device, state, 2); }
	52	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_2 ) { pc_com_dtr(device, state, 2); }
	53	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_2 ) { pc_com_rts(device, state, 2); }
	54
	55	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_3 ) { pc_com_tx(device, state, 3); }
	56	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_3 ) { pc_com_dtr(device, state, 3); }
	57	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_3 ) { pc_com_rts(device, state, 3); }
	58
	59	static void pc_com_rx(device_t *port, UINT8 state, int n)
	60	{
	61	isa8_com_device com = downcast<isa8_com_device >(port->owner());
	62	com->get_uart(n)->rx_w(state);
	63	}
	64
	65	static void pc_com_dcd(device_t *port, UINT8 state, int n)
	66	{
	67	isa8_com_device com = downcast<isa8_com_device >(port->owner());
	68	com->get_uart(n)->dcd_w(state);
	69	}
	70
	71	static void pc_com_dsr(device_t *port, UINT8 state, int n)
	72	{
	73	isa8_com_device com = downcast<isa8_com_device >(port->owner());
	74	com->get_uart(n)->dsr_w(state);
	75	}
	76
	77	static void pc_com_ri(device_t *port, UINT8 state, int n)
	78	{
	79	isa8_com_device com = downcast<isa8_com_device >(port->owner());
	80	com->get_uart(n)->ri_w(state);
	81	}
	82
	83	static void pc_com_cts(device_t *port, UINT8 state, int n)
	84	{
	85	isa8_com_device com = downcast<isa8_com_device >(port->owner());
	86	com->get_uart(n)->cts_w(state);
	87	}
	88
	89	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_0 ) { pc_com_rx(device, state, 0); }
	90	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_0 ) { pc_com_dcd(device, state, 0); }
	91	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_0 ) { pc_com_dsr(device, state, 0); }
	92	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_0 ) { pc_com_ri(device, state, 0); }
	93	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_0 ) { pc_com_cts(device, state, 0); }
	94
	95	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_1 ) { pc_com_rx(device, state, 1); }
	96	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_1 ) { pc_com_dcd(device, state, 1); }
	97	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_1 ) { pc_com_dsr(device, state, 1); }
	98	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_1 ) { pc_com_ri(device, state, 1); }
	99	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_1 ) { pc_com_cts(device, state, 1); }
	100
	101	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_2 ) { pc_com_rx(device, state, 2); }
	102	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_2 ) { pc_com_dcd(device, state, 2); }
	103	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_2 ) { pc_com_dsr(device, state, 2); }
	104	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_2 ) { pc_com_ri(device, state, 2); }
	105	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_2 ) { pc_com_cts(device, state, 2); }
	106
	107	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_3 ) { pc_com_rx(device, state, 3); }
	108	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_3 ) { pc_com_dcd(device, state, 3); }
	109	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_3 ) { pc_com_dsr(device, state, 3); }
	110	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_3 ) { pc_com_ri(device, state, 3); }
	111	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_3 ) { pc_com_cts(device, state, 3); }
	112
56	113	static const ins8250_interface genpc_com_interface[4]=
57	114	{
58	115	{
59		1843200,
	116	DEVCB_LINE(pc_com_tx_0),
	117	DEVCB_LINE(pc_com_dtr_0),
	118	DEVCB_LINE(pc_com_rts_0),
60	119	DEVCB_LINE(pc_com_interrupt_1),
61		pc_com_tx_0,
62		pc_com_handshake_out_0,
63		NULL
	120	DEVCB_NULL,
	121	DEVCB_NULL
64	122	},
65	123	{
66		1843200,
	124	DEVCB_LINE(pc_com_tx_1),
	125	DEVCB_LINE(pc_com_dtr_1),
	126	DEVCB_LINE(pc_com_rts_1),
67	127	DEVCB_LINE(pc_com_interrupt_2),
68		pc_com_tx_1,
69		pc_com_handshake_out_1,
70		NULL
	128	DEVCB_NULL,
	129	DEVCB_NULL
71	130	},
72	131	{
73		1843200,
	132	DEVCB_LINE(pc_com_tx_2),
	133	DEVCB_LINE(pc_com_dtr_2),
	134	DEVCB_LINE(pc_com_rts_2),
74	135	DEVCB_LINE(pc_com_interrupt_1),
75		pc_com_tx_2,
76		pc_com_handshake_out_2,
77		NULL
	136	DEVCB_NULL,
	137	DEVCB_NULL
78	138	},
79	139	{
80		1843200,
	140	DEVCB_LINE(pc_com_tx_3),
	141	DEVCB_LINE(pc_com_dtr_3),
	142	DEVCB_LINE(pc_com_rts_3),
81	143	DEVCB_LINE(pc_com_interrupt_2),
82		pc_com_tx_3,
83		pc_com_handshake_out_3,
84		NULL
	144	DEVCB_NULL,
	145	DEVCB_NULL
85	146	}
86	147	};
87	148
88	149	static const rs232_port_interface serport_config[4] =
89	150	{
90	151	{
91		DEVCB_HANDLER( pc_com_rx_0 ),
92		DEVCB_NULL,
93		DEVCB_NULL,
94		DEVCB_NULL,
95		DEVCB_NULL,
96		DEVCB_NULL
	152	DEVCB_LINE( pc_com_rx_0 ),
	153	DEVCB_LINE( pc_com_dcd_0 ),
	154	DEVCB_LINE( pc_com_dsr_0 ),
	155	DEVCB_LINE( pc_com_ri_0 ),
	156	DEVCB_LINE( pc_com_cts_0 )
97	157	},
98	158	{
99		DEVCB_HANDLER( pc_com_rx_1 ),
100		DEVCB_NULL,
101		DEVCB_NULL,
102		DEVCB_NULL,
103		DEVCB_NULL,
104		DEVCB_NULL
	159	DEVCB_LINE( pc_com_rx_1 ),
	160	DEVCB_LINE( pc_com_dcd_1 ),
	161	DEVCB_LINE( pc_com_dsr_1 ),
	162	DEVCB_LINE( pc_com_ri_1 ),
	163	DEVCB_LINE( pc_com_cts_1 )
105	164	},
106	165	{
107		DEVCB_HANDLER( pc_com_rx_2 ),
108		DEVCB_NULL,
109		DEVCB_NULL,
110		DEVCB_NULL,
111		DEVCB_NULL,
112		DEVCB_NULL
	166	DEVCB_LINE( pc_com_rx_2 ),
	167	DEVCB_LINE( pc_com_dcd_2 ),
	168	DEVCB_LINE( pc_com_dsr_2 ),
	169	DEVCB_LINE( pc_com_ri_2 ),
	170	DEVCB_LINE( pc_com_cts_2 )
113	171	},
114	172	{
115		DEVCB_HANDLER( pc_com_rx_3 ),
116		DEVCB_NULL,
117		DEVCB_NULL,
118		DEVCB_NULL,
119		DEVCB_NULL,
120		DEVCB_NULL
	173	DEVCB_LINE( pc_com_rx_3 ),
	174	DEVCB_LINE( pc_com_dcd_3 ),
	175	DEVCB_LINE( pc_com_dsr_3 ),
	176	DEVCB_LINE( pc_com_ri_3 ),
	177	DEVCB_LINE( pc_com_cts_3 )
121	178	}
122	179	};
123	180
124	181	static SLOT_INTERFACE_START(isa_com)
125	182	SLOT_INTERFACE("microsoft_mouse", MSFT_SERIAL_MOUSE)
126		SLOT_INTERFACE("mouse_systems_mouse", MSYSTEM_SERIAL_MOUSE)
	183	SLOT_INTERFACE("msystems_mouse", MSYSTEM_SERIAL_MOUSE)
	184	SLOT_INTERFACE("serial_terminal", SERIAL_TERMINAL)
	185	SLOT_INTERFACE("null_modem", NULL_MODEM)
127	186	SLOT_INTERFACE_END
128	187
129	188	static MACHINE_CONFIG_FRAGMENT( com_config )
130		MCFG_INS8250_ADD( "uart_0", genpc_com_interface[0] )
131		MCFG_INS8250_ADD( "uart_1", genpc_com_interface[1] )
132		MCFG_INS8250_ADD( "uart_2", genpc_com_interface[2] )
133		MCFG_INS8250_ADD( "uart_3", genpc_com_interface[3] )
	189	MCFG_INS8250_ADD( "uart_0", genpc_com_interface[0], XTAL_1_8432MHz )
	190	MCFG_INS8250_ADD( "uart_1", genpc_com_interface[1], XTAL_1_8432MHz )
	191	MCFG_INS8250_ADD( "uart_2", genpc_com_interface[2], XTAL_1_8432MHz )
	192	MCFG_INS8250_ADD( "uart_3", genpc_com_interface[3], XTAL_1_8432MHz )
134	193	MCFG_RS232_PORT_ADD( "serport0", serport_config[0], isa_com, "microsoft_mouse", NULL )
135	194	MCFG_RS232_PORT_ADD( "serport1", serport_config[1], isa_com, NULL, NULL )
136		MCFG_RS232_PORT_ADD( "serport2", serport_config[3], isa_com, NULL, NULL )
137		MCFG_RS232_PORT_ADD( "serport3", serport_config[4], isa_com, NULL, NULL )
	195	MCFG_RS232_PORT_ADD( "serport2", serport_config[2], isa_com, NULL, NULL )
	196	MCFG_RS232_PORT_ADD( "serport3", serport_config[3], isa_com, NULL, NULL )
138	197	MACHINE_CONFIG_END
139	198
140	199	//**************************************************************************
r14535	r14536
181	240	void isa8_com_device::device_start()
182	241	{
183	242	set_isa_device();
184		m_uart[0] = subdevice("uart_0");
185		m_uart[1] = subdevice("uart_1");
186		m_uart[2] = subdevice("uart_2");
187		m_uart[3] = subdevice("uart_3");
188		m_isa->install_device(m_uart[0], 0x03f8, 0x03ff, 0, 0, FUNC(ins8250_r), FUNC(ins8250_w) );
189		m_isa->install_device(m_uart[1], 0x02f8, 0x02ff, 0, 0, FUNC(ins8250_r), FUNC(ins8250_w) );
190		m_isa->install_device(m_uart[2], 0x03e8, 0x03ef, 0, 0, FUNC(ins8250_r), FUNC(ins8250_w) );
191		m_isa->install_device(m_uart[3], 0x02e8, 0x02ef, 0, 0, FUNC(ins8250_r), FUNC(ins8250_w) );
	243	m_uart[0] = subdevice<ins8250_uart_device>("uart_0");
	244	m_uart[1] = subdevice<ins8250_uart_device>("uart_1");
	245	m_uart[2] = subdevice<ins8250_uart_device>("uart_2");
	246	m_uart[3] = subdevice<ins8250_uart_device>("uart_3");
	247	m_isa->install_device(0x03f8, 0x03ff, 0, 0, read8_delegate(FUNC(ins8250_device::ins8250_r), m_uart[0]), write8_delegate(FUNC(ins8250_device::ins8250_w), m_uart[0]) );
	248	m_isa->install_device(0x02f8, 0x02ff, 0, 0, read8_delegate(FUNC(ins8250_device::ins8250_r), m_uart[1]), write8_delegate(FUNC(ins8250_device::ins8250_w), m_uart[1]) );
	249	m_isa->install_device(0x03e8, 0x03ef, 0, 0, read8_delegate(FUNC(ins8250_device::ins8250_r), m_uart[2]), write8_delegate(FUNC(ins8250_device::ins8250_w), m_uart[2]) );
	250	m_isa->install_device(0x02e8, 0x02ef, 0, 0, read8_delegate(FUNC(ins8250_device::ins8250_r), m_uart[3]), write8_delegate(FUNC(ins8250_device::ins8250_w), m_uart[3]) );
192	251
193	252	m_serport[0] = subdevice<rs232_port_device>("serport0");
194	253	m_serport[1] = subdevice<rs232_port_device>("serport1");
r14535	r14536
205	264	}
206	265
207	266	static MACHINE_CONFIG_FRAGMENT( com_at_config )
208		MCFG_NS16450_ADD( "uart_0", genpc_com_interface[0] ) /* Verified: IBM P/N 6320947 Serial/Parallel card uses an NS16450N */
209		MCFG_NS16450_ADD( "uart_1", genpc_com_interface[1] )
210		MCFG_NS16450_ADD( "uart_2", genpc_com_interface[2] )
211		MCFG_NS16450_ADD( "uart_3", genpc_com_interface[3] )
	267	MCFG_NS16450_ADD( "uart_0", genpc_com_interface[0], XTAL_1_8432MHz ) /* Verified: IBM P/N 6320947 Serial/Parallel card uses an NS16450N */
	268	MCFG_NS16450_ADD( "uart_1", genpc_com_interface[1], XTAL_1_8432MHz )
	269	MCFG_NS16450_ADD( "uart_2", genpc_com_interface[2], XTAL_1_8432MHz )
	270	MCFG_NS16450_ADD( "uart_3", genpc_com_interface[3], XTAL_1_8432MHz )
212	271	MCFG_RS232_PORT_ADD( "serport0", serport_config[0], isa_com, "microsoft_mouse", NULL )
213	272	MCFG_RS232_PORT_ADD( "serport1", serport_config[1], isa_com, NULL, NULL )
214		MCFG_RS232_PORT_ADD( "serport2", serport_config[3], isa_com, NULL, NULL )
215		MCFG_RS232_PORT_ADD( "serport3", serport_config[4], isa_com, NULL, NULL )
	273	MCFG_RS232_PORT_ADD( "serport2", serport_config[2], isa_com, NULL, NULL )
	274	MCFG_RS232_PORT_ADD( "serport3", serport_config[3], isa_com, NULL, NULL )
216	275	MACHINE_CONFIG_END
217	276
218	277	//**************************************************************************

src/mess/machine/isa_com.h
r14535	r14536
6	6	#include "emu.h"
7	7	#include "machine/isa.h"
8	8	#include "machine/serial.h"
	9	#include "machine/ins8250.h"
9	10
10	11	//**************************************************************************
11	12	// TYPE DEFINITIONS
r14535	r14536
26	27	virtual machine_config_constructor device_mconfig_additions() const;
27	28
28	29	rs232_port_device *get_port(int port) { return m_serport[port]; }
29		device_t *get_uart(int dev) { return m_uart[dev]; }
	30	ins8250_uart_device *get_uart(int dev) { return m_uart[dev]; }
30	31	protected:
31	32	// device-level overrides
32	33	virtual void device_start();
r14535	r14536
34	35
35	36	private:
36	37	// internal state
37		device_t *m_uart[4];
	38	ins8250_uart_device *m_uart[4];
38	39	rs232_port_device *m_serport[4];
39	40	};
40	41

src/mess/machine/bebox.c
r14535	r14536
357	357	*
358	358	*************************************/
359	359
360		static INS8250_TRANSMIT( bebox_uart_transmit )
361		{
362		if (LOG_UART)
363		logerror("bebox_uart_transmit(): data=0x%02X\n", data);
364		}
365
366
367		static INS8250_HANDSHAKE_OUT( bebox_uart_handshake )
368		{
369		if (LOG_UART)
370		logerror("bebox_uart_handshake(): data=0x%02X\n", data);
371		}
372
373
374	360	const ins8250_interface bebox_uart_inteface_0 =
375	361	{
376		0,
377	362	DEVCB_NULL,
378		NULL,
379		NULL,
380		NULL
	363	DEVCB_NULL,
	364	DEVCB_NULL,
	365	DEVCB_NULL,
	366	DEVCB_NULL,
	367	DEVCB_NULL
381	368	};
382	369
383	370	const ins8250_interface bebox_uart_inteface_1 =
384	371	{
385		0,
386	372	DEVCB_NULL,
387		NULL,
388		NULL,
389		NULL
	373	DEVCB_NULL,
	374	DEVCB_NULL,
	375	DEVCB_NULL,
	376	DEVCB_NULL,
	377	DEVCB_NULL
390	378	};
391	379
392	380	const ins8250_interface bebox_uart_inteface_2 =
393	381	{
394		0,
395	382	DEVCB_NULL,
396		NULL,
397		NULL,
398		NULL
	383	DEVCB_NULL,
	384	DEVCB_NULL,
	385	DEVCB_NULL,
	386	DEVCB_NULL,
	387	DEVCB_NULL
399	388	};
400	389
401	390	const ins8250_interface bebox_uart_inteface_3 =
402	391	{
403		0,
404	392	DEVCB_NULL,
405		bebox_uart_transmit,
406		bebox_uart_handshake,
407		NULL
	393	DEVCB_NULL,
	394	DEVCB_NULL,
	395	DEVCB_NULL,
	396	DEVCB_NULL,
	397	DEVCB_NULL
408	398	};
409	399
410	400

src/mess/machine/pc.c
r14535	r14536
26	26
27	27	#include "machine/pit8253.h"
28	28
29		#include "machine/pc_mouse.h"
30	29	#include "machine/pckeybrd.h"
31	30	#include "machine/pc_lpt.h"
32	31	#include "machine/pc_fdc.h"
r14535	r14536
357	356	pic8259_ir3_w(st->m_pic8259, state);
358	357	}
359	358
360		/* called when com registers read/written - used to update peripherals that
361		are connected */
362		static void pc_com_refresh_connected_common(device_t *device, int n, int data)
	359	static void pc_com_tx(device_t uart, UINT8 state, const char portn)
363	360	{
364		/* mouse connected to this port? */
365		//if (input_port_read(device->machine(), "DSW2") & (0x80>>n))
366		// pc_mouse_handshake_in(device,data);
	361	rs232_port_device *port = uart->owner()->subdevice<rs232_port_device>(portn);
	362	port->tx(state);
367	363	}
368	364
369		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_0 ) { pc_com_refresh_connected_common( device, 0, data ); }
370		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_1 ) { pc_com_refresh_connected_common( device, 1, data ); }
371		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_2 ) { pc_com_refresh_connected_common( device, 2, data ); }
372		static INS8250_HANDSHAKE_OUT( pc_com_handshake_out_3 ) { pc_com_refresh_connected_common( device, 3, data ); }
	365	static void pc_com_dtr(device_t uart, UINT8 state, const char portn)
	366	{
	367	rs232_port_device *port = uart->owner()->subdevice<rs232_port_device>(portn);
	368	port->dtr_w(state);
	369	}
373	370
	371	static void pc_com_rts(device_t uart, UINT8 state, const char portn)
	372	{
	373	rs232_port_device *port = uart->owner()->subdevice<rs232_port_device>(portn);
	374	port->rts_w(state);
	375	}
	376
	377	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_0 ) { pc_com_tx(device, state, "serport0"); }
	378	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_0 ) { pc_com_dtr(device, state, "serport0"); }
	379	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_0 ) { pc_com_rts(device, state, "serport0"); }
	380
	381	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_1 ) { pc_com_tx(device, state, "serport1"); }
	382	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_1 ) { pc_com_dtr(device, state, "serport1"); }
	383	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_1 ) { pc_com_rts(device, state, "serport1"); }
	384
	385	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_2 ) { pc_com_tx(device, state, "serport2"); }
	386	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_2 ) { pc_com_dtr(device, state, "serport2"); }
	387	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_2 ) { pc_com_rts(device, state, "serport2"); }
	388
	389	static WRITE_LINE_DEVICE_HANDLER( pc_com_tx_3 ) { pc_com_tx(device, state, "serport3"); }
	390	static WRITE_LINE_DEVICE_HANDLER( pc_com_dtr_3 ) { pc_com_dtr(device, state, "serport3"); }
	391	static WRITE_LINE_DEVICE_HANDLER( pc_com_rts_3 ) { pc_com_rts(device, state, "serport3"); }
	392
	393	static void pc_com_rx(device_t port, UINT8 state, const char uartn)
	394	{
	395	ins8250_uart_device *uart = port->owner()->subdevice<ins8250_uart_device>(uartn);
	396	uart->rx_w(state);
	397	}
	398
	399	static void pc_com_dcd(device_t port, UINT8 state, const char uartn)
	400	{
	401	ins8250_uart_device *uart = port->owner()->subdevice<ins8250_uart_device>(uartn);
	402	uart->dcd_w(state);
	403	}
	404
	405	static void pc_com_dsr(device_t port, UINT8 state, const char uartn)
	406	{
	407	ins8250_uart_device *uart = port->owner()->subdevice<ins8250_uart_device>(uartn);
	408	uart->dsr_w(state);
	409	}
	410
	411	static void pc_com_ri(device_t port, UINT8 state, const char uartn)
	412	{
	413	ins8250_uart_device *uart = port->owner()->subdevice<ins8250_uart_device>(uartn);
	414	uart->ri_w(state);
	415	}
	416
	417	static void pc_com_cts(device_t port, UINT8 state, const char uartn)
	418	{
	419	ins8250_uart_device *uart = port->owner()->subdevice<ins8250_uart_device>(uartn);
	420	uart->cts_w(state);
	421	}
	422
	423	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_0 ) { pc_com_rx(device, state, "ins8250_0"); }
	424	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_0 ) { pc_com_dcd(device, state, "ins8250_0"); }
	425	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_0 ) { pc_com_dsr(device, state, "ins8250_0"); }
	426	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_0 ) { pc_com_ri(device, state, "ins8250_0"); }
	427	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_0 ) { pc_com_cts(device, state, "ins8250_0"); }
	428
	429	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_1 ) { pc_com_rx(device, state, "ins8250_1"); }
	430	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_1 ) { pc_com_dcd(device, state, "ins8250_1"); }
	431	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_1 ) { pc_com_dsr(device, state, "ins8250_1"); }
	432	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_1 ) { pc_com_ri(device, state, "ins8250_1"); }
	433	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_1 ) { pc_com_cts(device, state, "ins8250_1"); }
	434
	435	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_2 ) { pc_com_rx(device, state, "ins8250_2"); }
	436	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_2 ) { pc_com_dcd(device, state, "ins8250_2"); }
	437	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_2 ) { pc_com_dsr(device, state, "ins8250_2"); }
	438	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_2 ) { pc_com_ri(device, state, "ins8250_2"); }
	439	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_2 ) { pc_com_cts(device, state, "ins8250_2"); }
	440
	441	static WRITE_LINE_DEVICE_HANDLER( pc_com_rx_3 ) { pc_com_rx(device, state, "ins8250_3"); }
	442	static WRITE_LINE_DEVICE_HANDLER( pc_com_dcd_3 ) { pc_com_dcd(device, state, "ins8250_3"); }
	443	static WRITE_LINE_DEVICE_HANDLER( pc_com_dsr_3 ) { pc_com_dsr(device, state, "ins8250_3"); }
	444	static WRITE_LINE_DEVICE_HANDLER( pc_com_ri_3 ) { pc_com_ri(device, state, "ins8250_3"); }
	445	static WRITE_LINE_DEVICE_HANDLER( pc_com_cts_3 ) { pc_com_cts(device, state, "ins8250_3"); }
	446
374	447	/* PC interface to PC-com hardware. Done this way because PCW16 also
375	448	uses PC-com hardware and doesn't have the same setup! */
376	449	const ins8250_interface ibm5150_com_interface[4]=
377	450	{
378	451	{
379		1843200,
	452	DEVCB_LINE(pc_com_tx_0),
	453	DEVCB_LINE(pc_com_dtr_0),
	454	DEVCB_LINE(pc_com_rts_0),
380	455	DEVCB_LINE(pc_com_interrupt_1),
381		NULL,
382		pc_com_handshake_out_0,
383		NULL
	456	DEVCB_NULL,
	457	DEVCB_NULL
384	458	},
385	459	{
386		1843200,
	460	DEVCB_LINE(pc_com_tx_1),
	461	DEVCB_LINE(pc_com_dtr_1),
	462	DEVCB_LINE(pc_com_rts_1),
387	463	DEVCB_LINE(pc_com_interrupt_2),
388		NULL,
389		pc_com_handshake_out_1,
390		NULL
	464	DEVCB_NULL,
	465	DEVCB_NULL
391	466	},
392	467	{
393		1843200,
	468	DEVCB_LINE(pc_com_tx_2),
	469	DEVCB_LINE(pc_com_dtr_2),
	470	DEVCB_LINE(pc_com_rts_2),
394	471	DEVCB_LINE(pc_com_interrupt_1),
395		NULL,
396		pc_com_handshake_out_2,
397		NULL
	472	DEVCB_NULL,
	473	DEVCB_NULL
398	474	},
399	475	{
400		1843200,
	476	DEVCB_LINE(pc_com_tx_3),
	477	DEVCB_LINE(pc_com_dtr_3),
	478	DEVCB_LINE(pc_com_rts_3),
401	479	DEVCB_LINE(pc_com_interrupt_2),
402		NULL,
403		pc_com_handshake_out_3,
404		NULL
	480	DEVCB_NULL,
	481	DEVCB_NULL
405	482	}
406	483	};
407	484
	485	const rs232_port_interface ibm5150_serport_config[4] =
	486	{
	487	{
	488	DEVCB_LINE( pc_com_rx_0 ),
	489	DEVCB_LINE( pc_com_dcd_0 ),
	490	DEVCB_LINE( pc_com_dsr_0 ),
	491	DEVCB_LINE( pc_com_ri_0 ),
	492	DEVCB_LINE( pc_com_cts_0 )
	493	},
	494	{
	495	DEVCB_LINE( pc_com_rx_1 ),
	496	DEVCB_LINE( pc_com_dcd_1 ),
	497	DEVCB_LINE( pc_com_dsr_1 ),
	498	DEVCB_LINE( pc_com_ri_1 ),
	499	DEVCB_LINE( pc_com_cts_1 )
	500	},
	501	{
	502	DEVCB_LINE( pc_com_rx_2 ),
	503	DEVCB_LINE( pc_com_dcd_2 ),
	504	DEVCB_LINE( pc_com_dsr_2 ),
	505	DEVCB_LINE( pc_com_ri_2 ),
	506	DEVCB_LINE( pc_com_cts_2 )
	507	},
	508	{
	509	DEVCB_LINE( pc_com_rx_3 ),
	510	DEVCB_LINE( pc_com_dcd_3 ),
	511	DEVCB_LINE( pc_com_dsr_3 ),
	512	DEVCB_LINE( pc_com_ri_3 ),
	513	DEVCB_LINE( pc_com_cts_3 )
	514	}
	515	};
408	516
409	517	/**********************************************************
410	518	*
r14535	r14536
973	1081	/* MESS managed RAM */
974	1082	if ( machine.device<ram_device>(RAM_TAG)->pointer() )
975	1083	memory_set_bankptr( machine, "bank10", machine.device<ram_device>(RAM_TAG)->pointer() );
976
977		/* serial mouse */
978		//pc_mouse_initialise(machine);
979	1084	}
980	1085
981	1086
r14535	r14536
1139	1244	st->m_ppi_shift_register = 0;
1140	1245	st->m_ppi_shift_enable = 0;
1141	1246
1142		//pc_mouse_set_serial_port( machine.device("ins8250_0") );
1143	1247	speaker_level_w( speaker, 0 );
1144	1248	}
1145	1249
r14535	r14536
1178	1282	st->m_ppi_data_signal = 0;
1179	1283	st->m_ppi_shift_register = 0;
1180	1284	st->m_ppi_shift_enable = 0;
1181		//pc_mouse_set_serial_port( machine.device("ins8250_0") );
1182	1285	speaker_level_w( speaker, 0 );
1183	1286
1184	1287	pcjr_keyb_init(machine);

src/mess/machine/ser_mouse.c
r14535	r14536
14	14
15	15	serial_mouse_device::serial_mouse_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock)
16	16	: device_t(mconfig, type, name, tag, owner, clock),
17		device_rs232_port_interface(mconfig, *this)
	17	device_rs232_port_interface(mconfig, *this),
	18	device_serial_interface(mconfig, *this)
18	19	{
19	20	}
20	21
r14535	r14536
33	34	m_owner = dynamic_cast<rs232_port_device *>(owner());
34	35	m_timer = timer_alloc();
35	36	m_enabled = false;
	37	set_frame();
36	38	}
37	39
38	40	void serial_mouse_device::device_reset()
39	41	{
40		m_head = m_tail = 0;
	42	m_head = m_tail = m_count = 0;
	43	tx(0);
	44	m_dcd = 0;
	45	m_owner->out_dcd(0);
	46	m_dsr = 0;
	47	m_owner->out_dsr(0);
	48	m_ri = 0;
	49	m_owner->out_ri(0);
	50	m_cts = 0;
	51	m_owner->out_cts(0);
41	52	}
42	53
43	54	/**************************************************************************
r14535	r14536
51	62	int mbc;
52	63
53	64	/* Do not get deltas or send packets if queue is not empty (Prevents drifting) */
54		if (m_head==m_tail)
	65	if ((m_head==m_tail) && (m_count == 0))
55	66	{
56	67	nx = input_port_read(*this, "ser_mouse_x");
57	68
r14535	r14536
76	87	mouse_trans(dx, dy, nb, mbc);
77	88	}
78	89
79		if( m_tail != m_head )
	90	++m_count %= 8;
	91
	92	if(is_transmit_register_empty())
80	93	{
81		UINT8 data = unqueue_data();
82		m_rdata = data;
83		m_owner->out_rx8(data);
	94	if(m_tail != m_head)
	95	transmit_register_setup(unqueue_data());
84	96	}
	97	else
	98	{
	99	m_rbit = transmit_register_get_data_bit();
	100	m_owner->out_rx(m_rbit);
	101	}
85	102	}
86	103
87	104	void microsoft_mouse_device::mouse_trans(int dx, int dy, int nb, int mbc)
r14535	r14536
164	181	void serial_mouse_device::set_mouse_enable(bool state)
165	182	{
166	183	if(state && !m_enabled)
167		m_timer->adjust(attotime::zero, 0, attotime::from_hz(240));
	184	m_timer->adjust(attotime::zero, 0, attotime::from_hz(1200));
168	185	else if(!state && m_enabled)
169	186	{
170		m_timer->adjust(attotime::zero);
	187	m_timer->adjust(attotime::never);
171	188	m_head = m_tail = 0;
172	189	}
173	190	m_enabled = state;

src/mess/machine/ser_mouse.h
r14535	r14536
12	12
13	13	class serial_mouse_device :
14	14	public device_t,
15		public device_rs232_port_interface
	15	public device_rs232_port_interface,
	16	public device_serial_interface
16	17	{
17	18	public:
18	19	serial_mouse_device(const machine_config &mconfig, device_type type, const char* name, const char tag, device_t owner, UINT32 clock);
r14535	r14536
24	25	virtual void device_reset();
25	26	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
26	27	virtual void mouse_trans(int dx, int dy, int nb, int mbc) = 0;
	28	virtual void set_frame() = 0;
27	29	void set_mouse_enable(bool state);
28	30	void queue_data(UINT8 data) {m_queue[m_head] = data; ++m_head %= 256;}
29	31	UINT8 unqueue_data() {UINT8 ret = m_queue[m_tail]; ++m_tail %= 256; return ret;}
	32	virtual void input_callback(UINT8 state) { m_input_state = state; }
30	33	private:
31	34	UINT8 m_queue[256];
32	35	UINT8 m_head, m_tail, m_mb;
r14535	r14536
34	37	emu_timer *m_timer;
35	38	rs232_port_device *m_owner;
36	39	bool m_enabled;
	40	int m_count;
37	41	};
38	42
39	43	class microsoft_mouse_device : public serial_mouse_device
r14535	r14536
43	47	virtual void dtr_w(UINT8 state) { m_dtr = state; check_state(); }
44	48	virtual void rts_w(UINT8 state) { m_rts = state; check_state(); m_old_rts = state; }
45	49	protected:
	50	virtual void set_frame() { set_data_frame(7, 1, SERIAL_PARITY_NONE); }
46	51	virtual void mouse_trans(int dx, int dy, int nb, int mbc);
47	52	virtual void device_reset() {m_old_rts = 0; serial_mouse_device::device_reset();}
48	53	private:
r14535	r14536
58	63	virtual void dtr_w(UINT8 state) { m_dtr = state; check_state(); }
59	64	virtual void rts_w(UINT8 state) { m_rts = state; check_state(); }
60	65	protected:
	66	virtual void set_frame() { set_data_frame(8, 1, SERIAL_PARITY_NONE); }
61	67	virtual void mouse_trans(int dx, int dy, int nb, int mbc);
62	68	private:
63	69	void check_state() { set_mouse_enable((m_dtr && m_rts)?true:false); }

src/mess/machine/terminal.c
r14535	r14536
7	7	enum
8	8	{
9	9	START = 0,
10		STOP = 9
	10	STOP = 9,
	11	DONE = 10
11	12	};
12	13
13	14	#define TERMINAL_WIDTH 80
r14535	r14536
223	224
224	225	switch (term->tx_state)
225	226	{
	227	case DONE:
	228	break;
226	229	case STOP:
227	230	data = 1;
	231	term->tx_state++;
228	232	break;
229	233
230	234	case START:
r14535	r14536
313	317	/***************************************************************************
314	318	VIDEO HARDWARE
315	319	***************************************************************************/
316		static void generic_terminal_update(device_t *device, bitmap_~~ind16~~ &bitmap, const rectangle &cliprect)
	320	static void generic_terminal_update(device_t *device, bitmap_rgb32 &bitmap, const rectangle &cliprect)
317	321	{
318	322	terminal_state *term = get_safe_token(device);
319	323	UINT8 options = input_port_read(*device, "TERM_CONF");
320	324	UINT16 cursor = term->y_pos * TERMINAL_WIDTH + term->x_pos;
321	325	UINT8 y,ra,chr,gfx;
322	326	UINT16 sy=0,ma=0,x;
	327	UINT32 font_color;
	328	switch (options & 0x30)
	329	{
	330	case 0x10:
	331	font_color = 0x00ff7e00;
	332	break;
	333	case 0x20:
	334	font_color = 0x00ffffff;
	335	break;
	336	default:
	337	font_color = 0x0000ff00;
	338	break;
	339	}
323	340
324	341	term->framecnt++;
325	342
r14535	r14536
327	344	{
328	345	for (ra = 0; ra < 10; ra++)
329	346	{
330		UINT16 *p = &bitmap.pix16(sy++);
	347	UINT32 *p = &bitmap.pix32(sy++);
331	348
332	349	for (x = ma; x < ma + TERMINAL_WIDTH; x++)
333	350	{
r14535	r14536
352	369	}
353	370
354	371	/* Display a scanline of a character */
355		*p++ = BIT( gfx, 7 );
356		*p++ = BIT( gfx, 6 );
357		*p++ = BIT( gfx, 5 );
358		*p++ = BIT( gfx, 4 );
359		*p++ = BIT( gfx, 3 );
360		*p++ = BIT( gfx, 2 );
361		*p++ = BIT( gfx, 1 );
362		*p++ = BIT( gfx, 0 );
	372	*p++ = (BIT( gfx, 7 ))?font_color:0;
	373	*p++ = (BIT( gfx, 6 ))?font_color:0;
	374	*p++ = (BIT( gfx, 5 ))?font_color:0;
	375	*p++ = (BIT( gfx, 4 ))?font_color:0;
	376	*p++ = (BIT( gfx, 3 ))?font_color:0;
	377	*p++ = (BIT( gfx, 2 ))?font_color:0;
	378	*p++ = (BIT( gfx, 1 ))?font_color:0;
	379	*p++ = (BIT( gfx, 0 ))?font_color:0;
363	380	}
364	381	}
365	382	ma+=TERMINAL_WIDTH;
r14535	r14536
378	395	return 0;
379	396	}
380	397
381		UINT8 terminal_keyboard_handler(running_machine &machine, ~~devcb_resolved_write8 &callback,~~ UINT8 last_code, UINT8 scan_line, UINT8 tx_shift, int tx_state, device_t device)
	398	UINT8 terminal_keyboard_handler(running_machine &machine, UINT8 last_code, UINT8 scan_line, UINT8 tx_shift, int tx_state, device_t device)
382	399	{
383	400	static const char *const keynames[] = { "TERM_LINE0", "TERM_LINE1", "TERM_LINE2", "TERM_LINE3", "TERM_LINE4", "TERM_LINE5", "TERM_LINE6", "TERM_LINE7" };
384	401	int i;
r14535	r14536
468	485	}
469	486	}
470	487	if (last_code != key_code ) {
471		callback(0, key_code);
472	488	if (tx_shift) *tx_shift = key_code;
473	489	if (tx_state) *tx_state = START;
474	490	}
r14535	r14536
485	501
486	502	static TIMER_CALLBACK(keyboard_callback)
487	503	{
	504	UINT8 new_code;
488	505	terminal_state term = get_safe_token((device_t )ptr);
489		term->last_code = terminal_keyboard_handler(machine, term->terminal_keyboard_func, term->last_code, &term->scan_line, &term->tx_shift, &term->tx_state, (device_t *)ptr);
	506	new_code = terminal_keyboard_handler(machine, term->last_code, &term->scan_line, &term->tx_shift, &term->tx_state, (device_t *)ptr);
	507	if(term->last_code != new_code)
	508	term->terminal_keyboard_func(0, new_code);
	509	term->last_code = new_code;
490	510	}
491	511
	512	static TIMER_CALLBACK(serial_callback)
	513	{
	514	static int count = 0;
	515	terminal_state term = get_safe_token((device_t )ptr);
	516	if(term->tx_state == DONE) {
	517	if(count == 0) {
	518	term->last_code = terminal_keyboard_handler(machine, term->last_code, &term->scan_line, &term->tx_shift, &term->tx_state, (device_t *)ptr);
	519	} else
	520	++count %= 8;
	521	} else
	522	term->terminal_keyboard_func(0, terminal_serial_r((device_t *)ptr));
	523	}
	524
492	525	/***************************************************************************
493	526	VIDEO HARDWARE
494	527	***************************************************************************/
495		static VIDEO_START( terminal )
496		{
497	528
498		}
499
500		static SCREEN_UPDATE_IND16(terminal )
	529	static SCREEN_UPDATE_RGB32(terminal )
501	530	{
502		device_t *devconf = screen.~~machi~~ne(~~).device(TERMINAL_TAG~~);
	531	device_t *devconf = screen.owner();
503	532	generic_terminal_update( devconf, bitmap, cliprect);
504	533	return 0;
505	534	}
506	535
507		MACHINE_CONFIG_FRAGMENT( generic_terminal )
	536	static MACHINE_CONFIG_FRAGMENT( generic_terminal )
508	537	MCFG_SCREEN_ADD(TERMINAL_SCREEN_TAG, RASTER)
509	538	MCFG_SCREEN_REFRESH_RATE(50)
510	539	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
511	540	MCFG_SCREEN_SIZE(TERMINAL_WIDTH8, TERMINAL_HEIGHT10)
512	541	MCFG_SCREEN_VISIBLE_AREA(0, TERMINAL_WIDTH8-1, 0, TERMINAL_HEIGHT10-1)
513	542	MCFG_SCREEN_UPDATE_STATIC(terminal)
514
515		MCFG_PALETTE_LENGTH(2)
516		MCFG_PALETTE_INIT(monochrome_green)
517
518		MCFG_VIDEO_START(terminal)
519	543	MACHINE_CONFIG_END
520	544
521	545
r14535	r14536
527	551	{
528	552	terminal_state *term = get_safe_token(device);
529	553	const terminal_interface *intf = get_interface(device);
	554	if(dynamic_cast<serial_terminal_device *>(device->owner()))
	555	term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device->owner());
	556	else
	557	term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device);
530	558
531		term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device);
532
533		if (!term->terminal_keyboard_func.isnull())
	559	if (device->clock())
	560	device->machine().scheduler().timer_pulse(attotime::from_hz(device->clock()), FUNC(serial_callback), 0, (void*)device);
	561	else if (!term->terminal_keyboard_func.isnull())
534	562	device->machine().scheduler().timer_pulse(attotime::from_hz(2400), FUNC(keyboard_callback), 0, (void*)device);
535	563	}
536	564
r14535	r14536
682	710	PORT_CONFNAME( 0x08, 0x08, "Invert")
683	711	PORT_CONFSETTING( 0x00, DEF_STR(No))
684	712	PORT_CONFSETTING( 0x08, DEF_STR(Yes))
	713	PORT_CONFNAME( 0x30, 0x00, "Color")
	714	PORT_CONFSETTING( 0x00, "Green")
	715	PORT_CONFSETTING( 0x10, "Amber")
	716	PORT_CONFSETTING( 0x20, "White")
685	717	INPUT_PORTS_END
686	718
687	719	/*-------------------------------------------------
r14535	r14536
702	734	case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(terminal); break;
703	735
704	736	case DEVINFO_PTR_INPUT_PORTS: info->ipt = INPUT_PORTS_NAME(generic_terminal); break;
	737	case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(generic_terminal); break;
705	738	/* --- the following bits of info are returned as NULL-terminated strings --- */
706	739	case DEVINFO_STR_NAME: strcpy(info->s, "Generic Terminal"); break;
707	740	case DEVINFO_STR_FAMILY: strcpy(info->s, "Terminal"); break;
r14535	r14536
712	745	}
713	746
714	747	DEFINE_LEGACY_DEVICE(GENERIC_TERMINAL, terminal);
	748
	749	serial_terminal_device::serial_terminal_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	750	: device_t(mconfig, SERIAL_TERMINAL, "Serial Terminal", tag, owner, clock),
	751	device_serial_port_interface(mconfig, *this),
	752	m_terminal(*this, TERMINAL_TAG)
	753	{
	754	}
	755
	756	static const terminal_interface serial_terminal_terminal_interface = {
	757	DEVCB_MEMBER(serial_terminal_device, serial_keyboard_func)
	758	};
	759
	760	static MACHINE_CONFIG_FRAGMENT(serial_terminal_config)
	761	MCFG_SERIAL_TERMINAL_ADD(TERMINAL_TAG, serial_terminal_terminal_interface, 9600)
	762	MACHINE_CONFIG_END
	763
	764	const device_type SERIAL_TERMINAL = &device_creator<serial_terminal_device>;
	765
	766	machine_config_constructor serial_terminal_device::device_mconfig_additions() const
	767	{
	768	return MACHINE_CONFIG_NAME(serial_terminal_config);
	769	}
	770

src/mess/machine/terminal.h
r14535	r14536
1	1	#ifndef __TERMINAL_H__
2	2	#define __TERMINAL_H__
3	3
	4	#include "emu.h"
	5	#include "machine/serial.h"
4	6	#include "devcb.h"
5	7
6	8	/***************************************************************************
r14535	r14536
30	32	#define MCFG_GENERIC_TERMINAL_REMOVE(_tag) \
31	33	MCFG_DEVICE_REMOVE(_tag)
32	34
	35	#define MCFG_SERIAL_TERMINAL_ADD(_tag, _intrf, _baud) \
	36	MCFG_DEVICE_ADD(_tag, GENERIC_TERMINAL, _baud) \
	37	MCFG_DEVICE_CONFIG(_intrf)
33	38
34	39	/***************************************************************************
35	40	FUNCTION PROTOTYPES
r14535	r14536
40	45
41	46	WRITE8_DEVICE_HANDLER ( terminal_write );
42	47
43		MACHINE_CONFIG_EXTERN( generic_terminal );
44
45	48	INPUT_PORTS_EXTERN(generic_terminal);
46	49
47		UINT8 terminal_keyboard_handler(running_machine &machine, ~~devcb_resolved_write8 &callback,~~ UINT8 last_code, UINT8 scan_line, UINT8 tx_shift, int tx_state, device_t device);
	50	UINT8 terminal_keyboard_handler(running_machine &machine, UINT8 last_code, UINT8 scan_line, UINT8 tx_shift, int tx_state, device_t device);
48	51
	52
	53	class serial_terminal_device :
	54	public device_t,
	55	public device_serial_port_interface
	56	{
	57	public:
	58	serial_terminal_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	59	virtual machine_config_constructor device_mconfig_additions() const;
	60	virtual void tx(UINT8 state) { terminal_serial_w(m_terminal, state); }
	61	DECLARE_WRITE8_MEMBER(serial_keyboard_func) { m_rbit = data&&1; m_owner->out_rx(m_rbit); }
	62	protected:
	63	virtual void device_start() { m_owner = dynamic_cast<serial_port_device *>(owner()); }
	64	private:
	65	required_device<device_t> m_terminal;
	66	serial_port_device *m_owner;
	67	};
	68
	69	extern const device_type SERIAL_TERMINAL;
	70
49	71	#endif /* __TERMINAL_H__ */

src/mess/machine/null_modem.c
r0	r14536
	1	#include "machine/null_modem.h"
	2
	3	const device_type NULL_MODEM = &device_creator<null_modem_device>;
	4
	5	null_modem_device::null_modem_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	6	: device_t(mconfig, NULL_MODEM, "Null Modem", tag, owner, clock),
	7	device_serial_port_interface(mconfig, *this),
	8	m_bitbanger(*this, "bitbanger")
	9	{
	10	}
	11
	12	static struct _bitbanger_config null_modem_image_config =
	13	{
	14	DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, null_modem_device, read),
	15	BITBANGER_MODEM,
	16	BITBANGER_9600,
	17	BITBANGER_0PERCENT
	18	};
	19
	20	static MACHINE_CONFIG_FRAGMENT(null_modem_config)
	21	MCFG_BITBANGER_ADD("bitbanger", null_modem_image_config);
	22	MACHINE_CONFIG_END
	23
	24	machine_config_constructor null_modem_device::device_mconfig_additions() const
	25	{
	26	return MACHINE_CONFIG_NAME(null_modem_config);
	27	}

src/mess/machine/null_modem.h
r0	r14536
	1	#ifndef NULL_MODEM_H_
	2	#define NULL_MODEM_H_
	3
	4	#include "emu.h"
	5	#include "machine/serial.h"
	6	#include "imagedev/bitbngr.h"
	7
	8	class null_modem_device :
	9	public device_t,
	10	public device_serial_port_interface
	11	{
	12	public:
	13	null_modem_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	14	virtual machine_config_constructor device_mconfig_additions() const;
	15	DECLARE_WRITE_LINE_MEMBER( read ) { m_rbit = state; m_owner->out_rx(state); }
	16	virtual void tx(UINT8 state) { m_tbit = state; m_bitbanger->output(state); }
	17	protected:
	18	virtual void device_start() { m_owner = dynamic_cast<serial_port_device *>(owner()); }
	19	private:
	20	serial_port_device *m_owner;
	21	required_device<bitbanger_device> m_bitbanger;
	22	};
	23
	24	extern const device_type NULL_MODEM;
	25	#endif

src/mess/machine/isa.c
r14535	r14536
346	346	space->unmap_read(start, end, mask, mirror);
347	347	}
348	348
	349	bool isa8_device::is_option_rom_space_available(offs_t start, int size)
	350	{
	351	m_maincpu = machine().device(m_cputag);
	352	address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	353	for(int i = 0; i < size; i += 4096) // 4KB granularity should be enough
	354	if(space->get_read_ptr(start + i)) return false;
	355	return true;
	356	}
	357
349	358	// interrupt request from isa card
350	359	WRITE_LINE_MEMBER( isa8_device::irq2_w ) { m_out_irq2_func(state); }
351	360	WRITE_LINE_MEMBER( isa8_device::irq3_w ) { m_out_irq3_func(state); }

src/mess/machine/isa.h
r14535	r14536
160	160
161	161	void unmap_bank(offs_t start, offs_t end, offs_t mask, offs_t mirror);
162	162	void unmap_rom(offs_t start, offs_t end, offs_t mask, offs_t mirror);
	163	bool is_option_rom_space_available(offs_t start, int size);
163	164
164	165	DECLARE_WRITE_LINE_MEMBER( irq2_w );
165	166	DECLARE_WRITE_LINE_MEMBER( irq3_w );

src/mess/includes/pc1512.h
r14535	r14536
86	86	required_device<device_t> m_pit;
87	87	required_device<mc146818_device> m_rtc;
88	88	required_device<device_t> m_fdc;
89		required_device<device_t> m_uart;
	89	required_device<ins8250_device> m_uart;
90	90	required_device<ams40041_device> m_vdu;
91	91	required_device<centronics_device> m_centronics;
92	92	required_device<device_t> m_speaker;

src/mess/includes/portfoli.h
r14535	r14536
41	41	required_device<cpu_device> m_maincpu;
42	42	required_device<hd61830_device> m_lcdc;
43	43	required_device<i8255_device> m_ppi;
44		required_device<device_t> m_uart;
	44	required_device<ins8250_device> m_uart;
45	45	required_device<device_t> m_speaker;
46	46	required_device<timer_device> m_timer_tick;
47	47

src/mess/includes/pc.h
r14535	r14536
10	10	#include "machine/ins8250.h"
11	11	#include "machine/i8255.h"
12	12	#include "machine/8237dma.h"
	13	#include "machine/serial.h"
	14	#include "machine/ser_mouse.h"
13	15
14	16	class pc_state : public driver_device
15	17	{
r14535	r14536
49	51	extern const struct pic8259_interface ibm5150_pic8259_config;
50	52	extern const struct pic8259_interface pcjr_pic8259_config;
51	53	extern const ins8250_interface ibm5150_com_interface[4];
	54	extern const rs232_port_interface ibm5150_serport_config[4];
52	55	extern const i8255_interface ibm5150_ppi8255_interface;
53	56	extern const i8255_interface ibm5160_ppi8255_interface;
54	57	extern const i8255_interface pc_ppi8255_interface;

src/mess/mess.mak
r14535	r14536
515	515	$(MESS_MACHINE)/ncr5390.o \
516	516	$(MESS_MACHINE)/pc_lpt.o \
517	517	$(MESS_MACHINE)/cntr_covox.o \
518		$(MESS_MACHINE)/pc_mouse.o \
519	518	$(MESS_MACHINE)/pcf8593.o \
520	519	$(MESS_MACHINE)/rs232.o \
521	520	$(MESS_MACHINE)/scsibus.o \
r14535	r14536
545	544	$(MESS_FORMATS)/z80bin.o \
546	545	$(MESS_MACHINE)/n82077aa.o \
547	546	$(MESS_MACHINE)/mb8795.o \
	547	$(MESS_MACHINE)/null_modem.o \
548	548
549	549
550	550

src/mess/drivers/dectalk.c
r14535	r14536
753	753
754	754	/* Y2 is a 3.579545 MHz xtal for the dtmf decoder chip */
755	755
756		MCFG_FRAGMENT_ADD( generic_terminal )
757	756	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,dectalk_terminal_intf)
758	757	MACHINE_CONFIG_END
759	758

src/mess/drivers/msbc1.c
r14535	r14536
84	84	MCFG_CPU_ADD(MC68000R12_TAG, M68000, XTAL_12_5MHz)
85	85	MCFG_CPU_PROGRAM_MAP(msbc1_mem)
86	86
87		/* video hardware */
88		MCFG_FRAGMENT_ADD( generic_terminal )
89
90	87	// devices
91	88	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
92	89	MACHINE_CONFIG_END

src/mess/drivers/pc1512.c
r14535	r14536
559	559	else if (addr >= 0x378 && addr <= 0x37b) { data = printer_r(space, offset & 0x03); decoded = true; }
560	560	else if (addr >= 0x3b0 && addr <= 0x3df) { data = iga_r(space, addr - 0x3b0); decoded = true; }
561	561	else if (addr >= 0x3f0 && addr <= 0x3f7) { data = fdc_r(space, offset & 0x07); decoded = true; }
562		else if (addr >= 0x3f8 && addr <= 0x3ff) { data = ins8250_r(~~m_u~~art, offset & 0x07); decoded = true; }
	562	else if (addr >= 0x3f8 && addr <= 0x3ff) { data = m_uart->ins8250_r(space, offset & 0x07); decoded = true; }
563	563
564	564	if (decoded)
565	565	{
r14535	r14536
622	622	AM_RANGE(0x378, 0x37b) AM_READWRITE8(printer_r, printer_w, 0xffff)
623	623	AM_RANGE(0x3d0, 0x3df) AM_READWRITE8(vdu_r, vdu_w, 0xffff)
624	624	AM_RANGE(0x3f0, 0x3f7) AM_READWRITE8(fdc_r, fdc_w, 0xffff)
625		AM_RANGE(0x3f8, 0x3ff) AM_DEVREADWRITE8~~_LEGACY~~(INS8250_TAG, ins8250_r, ins8250_w, 0xffff)
	625	AM_RANGE(0x3f8, 0x3ff) AM_DEVREADWRITE8(INS8250_TAG, ins8250_device, ins8250_r, ins8250_w, 0xffff)
626	626	ADDRESS_MAP_END
627	627
628	628
r14535	r14536
656	656	AM_RANGE(0x378, 0x37b) AM_WRITE8(printer_w, 0xffff)
657	657	AM_RANGE(0x3b0, 0x3df) AM_WRITE8(iga_w, 0xffff)
658	658	AM_RANGE(0x3f0, 0x3f7) AM_WRITE8(fdc_w, 0xffff)
659		AM_RANGE(0x3f8, 0x3ff) AM_DEVWRITE8~~_LEGACY~~(INS8250_TAG, ins8250_w, 0xffff)
	659	AM_RANGE(0x3f8, 0x3ff) AM_DEVWRITE8(INS8250_TAG, ins8250_device, ins8250_w, 0xffff)
660	660	ADDRESS_MAP_END
661	661
662	662
r14535	r14536
1136	1136
1137	1137	static const ins8250_interface uart_intf =
1138	1138	{
1139		XTAL_1_8432MHz,
	1139	DEVCB_NULL,
	1140	DEVCB_NULL,
	1141	DEVCB_NULL,
1140	1142	DEVCB_DEVICE_LINE(I8259A2_TAG, pic8259_ir4_w),
1141		NULL,
1142		NULL,
1143		NULL
	1143	DEVCB_NULL,
	1144	DEVCB_NULL
1144	1145	};
1145	1146
1146	1147
r14535	r14536
1365	1366	MCFG_PIT8253_ADD(I8253_TAG, pit_intf)
1366	1367	MCFG_MC146818_IRQ_ADD(MC146818_TAG, MC146818_STANDARD, rtc_intf)
1367	1368	MCFG_UPD765A_ADD(UPD765AC2_TAG, fdc_intf)
1368		MCFG_INS8250_ADD(INS8250_TAG, uart_intf)
	1369	MCFG_INS8250_ADD(INS8250_TAG, uart_intf, XTAL_1_8432MHz)
1369	1370	MCFG_CENTRONICS_PRINTER_ADD(CENTRONICS_TAG, centronics_intf)
1370	1371	MCFG_LEGACY_FLOPPY_2_DRIVES_ADD(floppy_intf)
1371	1372
r14535	r14536
1409	1410	MCFG_PIT8253_ADD(I8253_TAG, pit_intf)
1410	1411	MCFG_MC146818_IRQ_ADD(MC146818_TAG, MC146818_STANDARD, rtc_intf)
1411	1412	MCFG_UPD765A_ADD(UPD765AC2_TAG, fdc_intf)
1412		MCFG_INS8250_ADD(INS8250_TAG, uart_intf)
	1413	MCFG_INS8250_ADD(INS8250_TAG, uart_intf, XTAL_1_8432MHz)
1413	1414	MCFG_CENTRONICS_PRINTER_ADD(CENTRONICS_TAG, centronics_intf)
1414	1415	MCFG_LEGACY_FLOPPY_2_DRIVES_ADD(floppy_intf)
1415	1416

src/mess/drivers/pes.c
r14535	r14536
273	273	MCFG_SOUND_ADD("tms5220", TMS5220C, 720000) /* 720Khz clock, 10khz output */
274	274	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
275	275
276		MCFG_FRAGMENT_ADD( generic_terminal )
277	276	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,pes_terminal_intf)
278	277	MACHINE_CONFIG_END
279	278

src/mess/drivers/xor100.c
r14535	r14536
582	582	MCFG_CPU_PROGRAM_MAP(xor100_mem)
583	583	MCFG_CPU_IO_MAP(xor100_io)
584	584
585		/* video hardware */
586		MCFG_FRAGMENT_ADD( generic_terminal )
587
588	585	/* devices */
589	586	MCFG_I8251_ADD(I8251_A_TAG, /XTAL_8MHz/2,/ printer_8251_intf)
590	587	MCFG_I8251_ADD(I8251_B_TAG, /XTAL_8MHz/2,/ terminal_8251_intf)

src/mess/drivers/imds.c
r14535	r14536
101	101	// MCFG_INS8250_ADD( "ins8250", imds_com_interface )
102	102
103	103	/* video hardware */
104		MCFG_FRAGMENT_ADD( generic_terminal )
105	104	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
106	105	MACHINE_CONFIG_END
107	106

src/mess/drivers/zexall.c
r14535	r14536
150	150	MCFG_MACHINE_RESET(zexall)
151	151
152	152	/* video hardware */
153		MCFG_FRAGMENT_ADD( generic_terminal )
154	153	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, zexall_terminal_intf)
155	154	MACHINE_CONFIG_END
156	155

src/mess/drivers/h89.c
r14535	r14536
34	34	{ }
35	35
36	36	required_device<cpu_device> m_maincpu;
37		required_device<device_t> m_uart;
	37	required_device<ins8250_device> m_uart;
38	38
39		DECLARE_WRITE8_MEMBER( h89_kbd_put );
	39	DECLARE_WRITE_LINE_MEMBER( h89_terminal_out );
	40	DECLARE_WRITE8_MEMBER( h89_terminal_in );
40	41	DECLARE_WRITE8_MEMBER( port_f2_w );
41	42
42	43	UINT8 m_port_f2;
r14535	r14536
57	58	// AM_RANGE(0xd0, 0xd7) 8250 UART DCE
58	59	// AM_RANGE(0xd8, 0xdf) 8250 UART DTE
59	60	// AM_RANGE(0xe0, 0xe7) 8250 UART LP
60		AM_RANGE(0xe8, 0xef) AM_DEVREADWRITE~~_LEGACY~~("ins8250", ins8250_r, ins8250_w) // 8250 UART console
	61	AM_RANGE(0xe8, 0xef) AM_DEVREADWRITE("ins8250", ins8250_device, ins8250_r, ins8250_w) // 8250 UART console
61	62	// AM_RANGE(0xf0, 0xf1) front panel
62	63	AM_RANGE(0xf2, 0xf2) AM_WRITE(port_f2_w) AM_READ_PORT("SW501")
63	64	// AM_RANGE(0xf8, 0xf9) cassette
r14535	r14536
109	110	m_port_f2 = data;
110	111	}
111	112
112		WRITE8_MEMBER( h89_state::h89_~~kbd~~_put )
	113	WRITE_LINE_MEMBER( h89_state::h89_terminal_out )
113	114	{
114		ins8250_receive(m_uart, data);
	115	device_t *terminal = machine().device(TERMINAL_TAG);
	116	terminal_serial_w(terminal, state);
115	117	}
116	118
117		~~static~~ INS8~~250~~_~~TRANS~~MIT(h89_terminal_w)
	119	WRITE8_MEMBER( h89_state::h89_terminal_in )
118	120	{
119		~~ter~~m~~inal~~_writ~~e(device~~->~~machine~~().d~~evice(TERMINAL_TAG), 0, d~~ata);
	121	m_uart->rx_w(data&&1);
120	122	}
121	123
122	124	static GENERIC_TERMINAL_INTERFACE( terminal_intf )
123	125	{
124		DEVCB_DRIVER_MEMBER(h89_state, h89_~~kbd_pu~~t)
	126	DEVCB_DRIVER_MEMBER(h89_state, h89_terminal_in)
125	127	};
126	128
127	129	static const ins8250_interface h89_ins8250_interface =
128	130	{
129		XTAL_12_288MHz / 4, // clock
130		DEVCB_NULL, // interrupt
131		h89_terminal_w, // transmit func
132		NULL, // handshake out
133		NULL // refresh func
	131	DEVCB_DRIVER_LINE_MEMBER(h89_state, h89_terminal_out),
	132	DEVCB_NULL,
	133	DEVCB_NULL,
	134	DEVCB_NULL,
	135	DEVCB_NULL,
	136	DEVCB_NULL
134	137	};
135	138
136	139	static MACHINE_CONFIG_START( h89, h89_state )
r14535	r14536
154	157	MCFG_PALETTE_INIT(black_and_white)
155	158	#endif
156	159
157		MCFG_INS8250_ADD( "ins8250", h89_ins8250_interface )
	160	MCFG_INS8250_ADD( "ins8250", h89_ins8250_interface, XTAL_1_8432MHz )
158	161
159		MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
160		MCFG_FRAGMENT_ADD( generic_terminal )
	162	MCFG_SERIAL_TERMINAL_ADD(TERMINAL_TAG, terminal_intf, 9600)
161	163
162	164	MCFG_TIMER_ADD_PERIODIC("irq_timer", h89_irq_timer, attotime::from_hz(100))
163	165	MACHINE_CONFIG_END

src/mess/drivers/ip22.c
r14535	r14536
43	43	#include "sound/cdda.h"
44	44	#include "machine/sgi.h"
45	45	#include "machine/pckeybrd.h"
46		#include "machine/pc_mouse.h"
47	46	#include "machine/pc_lpt.h"
48	47	#include "includes/at.h"
49	48	#include "machine/8042kbdc.h"
r14535	r14536
1550	1549	PORT_START("DSW1") // unused IN2
1551	1550	PORT_START("DSW2") // unused IN3
1552	1551	PORT_INCLUDE( at_keyboard ) /* IN4 - IN11 */
1553		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
1554	1552	INPUT_PORTS_END
1555	1553
1556	1554	static void rtc_update(ip22_state *state)

src/mess/drivers/zsbc3.c
r14535	r14536
110	110	MCFG_MACHINE_RESET(zsbc3)
111	111
112	112	/* video hardware */
113		MCFG_FRAGMENT_ADD( generic_terminal )
114
115	113	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
116	114	MACHINE_CONFIG_END
117	115

src/mess/drivers/dual68.c
r14535	r14536
92	92	MCFG_MACHINE_RESET(dual68)
93	93
94	94	/* video hardware */
95		MCFG_FRAGMENT_ADD( generic_terminal )
96	95	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,terminal_intf)
97	96	MACHINE_CONFIG_END
98	97

src/mess/drivers/d6809.c
r14535	r14536
153	153	MCFG_MACHINE_RESET(d6809)
154	154
155	155	/* video hardware */
156		MCFG_FRAGMENT_ADD( generic_terminal )
157	156	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
158	157	MACHINE_CONFIG_END
159	158

src/mess/drivers/isbc.c
r14535	r14536
119	119	MCFG_CPU_IO_MAP(isbc86_io)
120	120
121	121	/* video hardware */
122		MCFG_FRAGMENT_ADD( generic_terminal )
123	122	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
124	123	MACHINE_CONFIG_END
125	124
r14535	r14536
130	129	MCFG_CPU_IO_MAP(rpc86_io)
131	130
132	131	/* video hardware */
133		MCFG_FRAGMENT_ADD( generic_terminal )
134	132	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
135	133	MACHINE_CONFIG_END
136	134
r14535	r14536
144	142	MCFG_CPU_CONFIG(i286_address_mask)
145	143
146	144	/* video hardware */
147		MCFG_FRAGMENT_ADD( generic_terminal )
148	145	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
149	146	MACHINE_CONFIG_END
150	147
r14535	r14536
156	153	MCFG_CPU_CONFIG(i286_address_mask)
157	154
158	155	/* video hardware */
159		MCFG_FRAGMENT_ADD( generic_terminal )
160	156	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
161	157	MACHINE_CONFIG_END
162	158

src/mess/drivers/sacstate.c
r14535	r14536
100	100	MCFG_CPU_IO_MAP(sacstate_io)
101	101
102	102	/* video hardware */
103		MCFG_FRAGMENT_ADD( generic_terminal )
104	103	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
105	104	MACHINE_CONFIG_END
106	105

src/mess/drivers/qtsbc.c
r14535	r14536
87	87	MCFG_CPU_IO_MAP(qtsbc_io)
88	88
89	89	/* video hardware */
90		MCFG_FRAGMENT_ADD( generic_terminal )
91	90	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
92	91	MACHINE_CONFIG_END
93	92

src/mess/drivers/mits680b.c
r14535	r14536
101	101	MCFG_CPU_PROGRAM_MAP(mits680b_mem)
102	102
103	103	/* video hardware */
104		MCFG_FRAGMENT_ADD( generic_terminal )
105	104	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
106	105
107	106	/* acia */

src/mess/drivers/votrpss.c
r14535	r14536
204	204	/* printer */
205	205	//MCFG_PRINTER_ADD("printer")
206	206
207		MCFG_FRAGMENT_ADD( generic_terminal )
208	207	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, votrpss_terminal_intf)
209	208	MACHINE_CONFIG_END
210	209

src/mess/drivers/ccs2422.c
r14535	r14536
95	95	MCFG_CPU_IO_MAP(ccs2422_io)
96	96
97	97	/* video hardware */
98		MCFG_FRAGMENT_ADD( generic_terminal )
99	98	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
100	99	MACHINE_CONFIG_END
101	100

src/mess/drivers/bullet.c
r14535	r14536
1182	1182	MCFG_CPU_IO_MAP(bullet_io)
1183	1183	MCFG_CPU_CONFIG(daisy_chain)
1184	1184
1185		// video hardware
1186		MCFG_FRAGMENT_ADD( generic_terminal )
1187
1188	1185	// devices
1189	1186	MCFG_Z80CTC_ADD(Z80CTC_TAG, XTAL_16MHz/4, ctc_intf)
1190	1187	MCFG_TIMER_ADD_PERIODIC("ctc", ctc_tick, attotime::from_hz(XTAL_4_9152MHz/4))
r14535	r14536
1213	1210	MCFG_CPU_IO_MAP(bulletf_io)
1214	1211	MCFG_CPU_CONFIG(daisy_chain)
1215	1212
1216		// video hardware
1217		MCFG_FRAGMENT_ADD( generic_terminal )
1218
1219	1213	// devices
1220	1214	MCFG_Z80CTC_ADD(Z80CTC_TAG, XTAL_16MHz/4, ctc_intf)
1221	1215	MCFG_TIMER_ADD_PERIODIC("ctc", ctc_tick, attotime::from_hz(XTAL_4_9152MHz/4))

src/mess/drivers/mccpm.c
r14535	r14536
133	133	MCFG_CPU_IO_MAP(mccpm_io)
134	134
135	135	/* video hardware */
136		MCFG_FRAGMENT_ADD( generic_terminal )
137	136	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
138	137	MACHINE_CONFIG_END
139	138

src/mess/drivers/systec.c
r14535	r14536
108	108	MCFG_MACHINE_RESET(systec)
109	109
110	110	/* video hardware */
111		MCFG_FRAGMENT_ADD( generic_terminal )
112	111	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
113	112	MACHINE_CONFIG_END
114	113

src/mess/drivers/ipc.c
r14535	r14536
118	118	MCFG_CPU_IO_MAP(ipc_io)
119	119
120	120	/* video hardware */
121		MCFG_FRAGMENT_ADD( generic_terminal )
122	121	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
123	122	MACHINE_CONFIG_END
124	123

src/mess/drivers/digel804.c
r14535	r14536
550	550	MCFG_MACHINE_RESET(digel804)
551	551
552	552	/* video hardware */
553		MCFG_FRAGMENT_ADD( generic_terminal )
554	553	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, digel804_terminal_intf)
555	554
556	555	/* acia */
r14535	r14536
572	571	MCFG_MACHINE_RESET(digel804)
573	572
574	573	/* video hardware */
575		MCFG_FRAGMENT_ADD( generic_terminal )
576	574	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, digel804_terminal_intf)
577	575
578	576	/* acia */

src/mess/drivers/tricep.c
r14535	r14536
80	80	MCFG_MACHINE_RESET(tricep)
81	81
82	82	/* video hardware */
83		MCFG_FRAGMENT_ADD( generic_terminal )
84	83	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
85	84	MACHINE_CONFIG_END
86	85

src/mess/drivers/svi318.c
r14535	r14536
319	319
320	320	MCFG_I8255_ADD( "ppi8255", svi318_ppi8255_interface )
321	321
322		MCFG_INS8250_ADD( "ins8250_0", svi318_ins8250_interface[0] )
323		MCFG_INS8250_ADD( "ins8250_1", svi318_ins8250_interface[1] )
	322	MCFG_INS8250_ADD( "ins8250_0", svi318_ins8250_interface[0], 1000000 )
	323	MCFG_INS8250_ADD( "ins8250_1", svi318_ins8250_interface[1], 3072000 )
324	324
325	325	/* Video hardware */
326	326	MCFG_TMS9928A_ADD( "tms9928a", TMS9929A, svi318_tms9928a_interface )
r14535	r14536
430	430
431	431	MCFG_I8255A_ADD( "ppi8255", svi318_ppi8255_interface )
432	432
433		MCFG_INS8250_ADD( "ins8250_0", svi318_ins8250_interface[0] )
434		MCFG_INS8250_ADD( "ins8250_1", svi318_ins8250_interface[1] )
	433	MCFG_INS8250_ADD( "ins8250_0", svi318_ins8250_interface[0], 1000000 )
	434	MCFG_INS8250_ADD( "ins8250_1", svi318_ins8250_interface[1], 3072000 )
435	435
436	436	/* Video hardware */
437	437	MCFG_DEFAULT_LAYOUT( layout_dualhsxs )

src/mess/drivers/sage2.c
r14535	r14536
596	596	MCFG_CPU_PROGRAM_MAP(sage2_mem)
597	597
598	598	// video hardware
599		MCFG_FRAGMENT_ADD(generic_terminal)
600	599	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
601	600
602	601	// devices

src/mess/drivers/cm1800.c
r14535	r14536
100	100	MCFG_MACHINE_RESET(cm1800)
101	101
102	102	/* video hardware */
103		MCFG_FRAGMENT_ADD( generic_terminal )
104	103	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
105	104	MACHINE_CONFIG_END
106	105

src/mess/drivers/amstr_pc.c
r14535	r14536
44	44	#include "machine/pc_joy.h"
45	45	#include "machine/pckeybrd.h"
46	46	#include "machine/pc_lpt.h"
47		#include "machine/pc_mouse.h"
48	47
49	48	#include "includes/amstr_pc.h"
50	49
r14535	r14536
92	91	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r, pc_page_w, 0xffff)
93	92	AM_RANGE(0x0200, 0x0207) AM_READWRITE(pc16le_JOY_r, pc16le_JOY_w)
94	93	AM_RANGE(0x0278, 0x027b) AM_READ(pc200_16le_port278_r) AM_DEVWRITE8("lpt_2", pc_lpt_w, 0x00ff)
95		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8("ins8250_3", ins8250_r, ins8250_w, 0xffff)
96		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	94	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w, 0xffff)
	95	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
97	96	AM_RANGE(0x0378, 0x037b) AM_READ(pc200_16le_port378_r) AM_DEVWRITE8("lpt_1", pc_lpt_w, 0x00ff)
98	97	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0x00ff)
99		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8("ins8250_2", ins8250_r, ins8250_w, 0xffff)
	98	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w, 0xffff)
100	99	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
101		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	100	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
102	101	ADDRESS_MAP_END
103	102
104	103	static ADDRESS_MAP_START( pc200_map, AS_PROGRAM, 16 )
r14535	r14536
120	119	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r, pc_page_w, 0xffff)
121	120	AM_RANGE(0x0200, 0x0207) AM_READWRITE(pc16le_JOY_r, pc16le_JOY_w)
122	121	AM_RANGE(0x0278, 0x027b) AM_READ(pc200_16le_port278_r) AM_DEVWRITE8("lpt_2", pc_lpt_w, 0x00ff)
123		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8("ins8250_3", ins8250_r, ins8250_w, 0xffff)
124		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	122	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w, 0xffff)
	123	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
125	124	AM_RANGE(0x0378, 0x037b) AM_READ(pc200_16le_port378_r) AM_DEVWRITE8("lpt_1", pc_lpt_w, 0x00ff)
126	125	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0x00ff)
127		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8("ins8250_2", ins8250_r, ins8250_w, 0xffff)
	126	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w, 0xffff)
128	127	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
129		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	128	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
130	129	ADDRESS_MAP_END
131	130
132	131
r14535	r14536
188	187	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
189	188
190	189	PORT_START("DSW2") /* IN3 */
191		PORT_DIPNAME( 0xf0, 0x00, "Serial mouse")
192		PORT_DIPSETTING( 0x80, "COM1" )
193		PORT_DIPSETTING( 0x40, "COM2" )
194		PORT_DIPSETTING( 0x20, "COM3" )
195		PORT_DIPSETTING( 0x10, "COM4" )
196		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
197	190	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
198	191	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
199	192	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
204	197	PORT_BIT( 0x01, 0x01, IPT_UNUSED )
205	198
206	199	PORT_INCLUDE( at_keyboard ) /* IN4 - IN11 */
207		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
208	200	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
209	201
210	202	PORT_START("VIDEO") /* IN20 */
r14535	r14536
241	233	NULL
242	234	};
243	235
	236	SLOT_INTERFACE_START(amstr_com)
	237	SLOT_INTERFACE("microsoft_mouse", MSFT_SERIAL_MOUSE)
	238	SLOT_INTERFACE("mouse_systems_mouse", MSYSTEM_SERIAL_MOUSE)
	239	SLOT_INTERFACE_END
244	240
245	241	#define MCFG_CPU_PC(mem, port, type, clock, vblankfunc) \
246	242	MCFG_CPU_ADD("maincpu", type, clock) \
r14535	r14536
282	278
283	279	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
284	280
285		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
286		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
287		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
288		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	281	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	282	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	283	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	284	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	285	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], amstr_com, NULL, NULL )
	286	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], amstr_com, NULL, NULL )
	287	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[3], amstr_com, NULL, NULL )
	288	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[4], amstr_com, NULL, NULL )
289	289
290	290	/* video hardware */
291	291	MCFG_FRAGMENT_ADD( pcvideo_pc200 )
r14535	r14536
348	348
349	349	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
350	350
351		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
352		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
353		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
354		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	351	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	352	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	353	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	354	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	355	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], amstr_com, NULL, NULL )
	356	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], amstr_com, NULL, NULL )
	357	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[3], amstr_com, NULL, NULL )
	358	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[4], amstr_com, NULL, NULL )
355	359
356	360	/* video hardware */
357	361	MCFG_FRAGMENT_ADD( pcvideo_pc200 )

src/mess/drivers/ob68k1a.c
r14535	r14536
343	343	MCFG_CPU_ADD(MC68000L10_TAG, M68000, XTAL_10MHz)
344	344	MCFG_CPU_PROGRAM_MAP(ob68k1a_mem)
345	345
346		// video hardware
347		MCFG_FRAGMENT_ADD( generic_terminal )
348
349	346	// devices
350	347	MCFG_PIA6821_ADD(MC6821_0_TAG, pia0_intf)
351	348	MCFG_PIA6821_ADD(MC6821_1_TAG, pia1_intf)

src/mess/drivers/czk80.c
r14535	r14536
98	98	MCFG_CPU_PROGRAM_MAP(czk80_mem)
99	99	MCFG_CPU_IO_MAP(czk80_io)
100	100
101		MCFG_FRAGMENT_ADD( generic_terminal )
102	101	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
103	102	MACHINE_CONFIG_END
104	103

src/mess/drivers/exp85.c
r14535	r14536
208	208	MCFG_CPU_IO_MAP(exp85_io)
209	209	MCFG_CPU_CONFIG(exp85_i8085_config)
210	210
211		/* video hardware */
212		MCFG_FRAGMENT_ADD( generic_terminal )
213
214	211	/* sound hardware */
215	212	MCFG_SPEAKER_STANDARD_MONO("mono")
216	213	MCFG_SOUND_ADD(SPEAKER_TAG, SPEAKER_SOUND, 0)

src/mess/drivers/votrtnt.c
r14535	r14536
174	174	MCFG_SOUND_ADD("votrax", VOTRAX, 1700000) /* 1.70 MHz? needs verify */
175	175	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
176	176
177		MCFG_FRAGMENT_ADD( generic_terminal )
178	177	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, votrtnt_terminal_intf)
179	178	MCFG_TIMER_ADD_PERIODIC("votrtnt_timer", votrtnt_poll_votrax, attotime::from_hz(70) )
180	179	MACHINE_CONFIG_END

src/mess/drivers/pdp11.c
r14535	r14536
327	327	MCFG_MACHINE_RESET(pdp11)
328	328
329	329	/* video hardware */
330		MCFG_FRAGMENT_ADD( generic_terminal )
331	330	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
332	331	MACHINE_CONFIG_END
333	332

src/mess/drivers/dms86.c
r14535	r14536
117	117
118	118	MCFG_MACHINE_RESET(dms86)
119	119
120		MCFG_FRAGMENT_ADD( generic_terminal )
121	120	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
122	121	MACHINE_CONFIG_END
123	122

src/mess/drivers/okean240.c
r14535	r14536
478	478	static MACHINE_CONFIG_DERIVED( okean240t, okean240 )
479	479	MCFG_CPU_MODIFY("maincpu")
480	480	MCFG_CPU_IO_MAP(okean240t_io)
481		MCFG_FRAGMENT_ADD( generic_terminal )
482	481	MACHINE_CONFIG_END
483	482
484	483	/* ROM definition */

src/mess/drivers/sgi_ip2.c
r14535	r14536
465	465	MCFG_MACHINE_RESET(sgi_ip2)
466	466
467	467	/* video hardware */
468		MCFG_FRAGMENT_ADD( generic_terminal )
469	468	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,sgi_terminal_intf)
470	469
471	470	MCFG_DUART68681_ADD( "duart68681a", XTAL_3_6864MHz, sgi_ip2_duart68681a_config ) /* Y3 3.6864MHz Xtal ??? copy-over from dectalk */

src/mess/drivers/pcw16.c
r14535	r14536
97	97	#include "machine/pckeybrd.h" /* PC-AT keyboard */
98	98	#include "machine/pc_fdc.h" /* change to superio later */
99	99	#include "machine/ins8250.h" /* pc com port */
100		#include "machine/pc_mouse.h" /* pc serial mouse */
101	100	#include "sound/beep.h" /* pcw/pcw16 beeper */
102	101	#include "machine/intelfsh.h"
103	102
r14535	r14536
801	800	pcw16_keyboard_signal_byte_received(timer.machine(), data);
802	801	}
803	802	}
	803	// TODO: fix
	804	state->subdevice<ns16550_device>("ns16550_2")->ri_w(input_port_read(timer.machine(), "EXTRA") & 0x040);
804	805	}
805	806
806	807
r14535	r14536
1258	1259	pcw16_refresh_ints(device->machine());
1259	1260	}
1260	1261
	1262	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_tx_0 ) { }
	1263	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_dtr_0 ) { }
	1264	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_rts_0 ) { }
1261	1265
1262		static INS8250_REFRESH_CONNECT( pcw16_com_refresh_connected_1 ) {
1263		#if 0
1264		pc_mouse_poll(0);
1265		#endif
1266		}
	1266	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_tx_1 ) { }
	1267	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_dtr_1 ) { }
	1268	static WRITE_LINE_DEVICE_HANDLER( pcw16_com_rts_1 ) { }
1267	1269
1268
1269		static INS8250_REFRESH_CONNECT( pcw16_com_refresh_connected_2 )
1270		{
1271		int new_inputs;
1272
1273		new_inputs = 0;
1274
1275		/* Power switch is connected to Ring indicator */
1276		if (input_port_read(device->machine(), "EXTRA") & 0x040)
1277		{
1278		new_inputs = UART8250_INPUTS_RING_INDICATOR;
1279		}
1280
1281		ins8250_handshake_in(device, new_inputs);
1282		}
1283
1284	1270	static const ins8250_interface pcw16_com_interface[2]=
1285	1271	{
1286	1272	{
1287		1843200,
	1273	DEVCB_LINE(pcw16_com_tx_0),
	1274	DEVCB_LINE(pcw16_com_dtr_0),
	1275	DEVCB_LINE(pcw16_com_rts_0),
1288	1276	DEVCB_LINE(pcw16_com_interrupt_1),
1289		NULL,
1290		pc_mouse_handshake_in,
1291		pcw16_com_refresh_connected_1
	1277	DEVCB_NULL,
	1278	DEVCB_NULL
1292	1279	},
1293	1280	{
1294		1843200,
	1281	DEVCB_LINE(pcw16_com_tx_1),
	1282	DEVCB_LINE(pcw16_com_dtr_1),
	1283	DEVCB_LINE(pcw16_com_rts_1),
1295	1284	DEVCB_LINE(pcw16_com_interrupt_2),
1296		NULL,
1297		NULL,
1298		pcw16_com_refresh_connected_2
	1285	DEVCB_NULL,
	1286	DEVCB_NULL
1299	1287	}
1300	1288	};
1301	1289
r14535	r14536
1308	1296	AM_RANGE(0x01c, 0x01c) AM_READ(pcw16_superio_fdc_main_status_register_r)
1309	1297	AM_RANGE(0x01d, 0x01d) AM_READWRITE(pcw16_superio_fdc_data_r, pcw16_superio_fdc_data_w)
1310	1298	AM_RANGE(0x01f, 0x01f) AM_READWRITE(pcw16_superio_fdc_digital_input_register_r, pcw16_superio_fdc_datarate_w)
1311		AM_RANGE(0x020, 0x027) AM_DEVREADWRITE("ns16550_1", ins8250_r, ins8250_w)
1312		AM_RANGE(0x028, 0x02f) AM_DEVREADWRITE("ns16550_2", ins8250_r, ins8250_w)
	1299	AM_RANGE(0x020, 0x027) AM_DEVREADWRITE_MODERN("ns16550_1", ns16550_device, ins8250_r, ins8250_w)
	1300	AM_RANGE(0x028, 0x02f) AM_DEVREADWRITE_MODERN("ns16550_2", ns16550_device, ins8250_r, ins8250_w)
1313	1301	AM_RANGE(0x038, 0x03a) AM_DEVREADWRITE("lpt", pc_lpt_r, pc_lpt_w)
1314	1302	/* anne asic */
1315	1303	AM_RANGE(0x0e0, 0x0ef) AM_WRITE(pcw16_palette_w)
r14535	r14536
1363	1351
1364	1352	pc_fdc_init(machine, &pcw16_fdc_interface);
1365	1353
1366		/* initialise mouse */
1367		//pc_mouse_initialise(machine);
1368		//pc_mouse_set_serial_port( machine.device("ns16550_0") );
1369
1370	1354	/* initialise keyboard */
1371	1355	at_keyboard_init(machine, AT_KEYBOARD_TYPE_AT);
1372	1356	at_keyboard_set_scan_code_set(3);
r14535	r14536
1386	1370	PORT_DIPSETTING(0x0, DEF_STR( Off) )
1387	1371	PORT_DIPSETTING(0x40, DEF_STR( On) )
1388	1372
1389		PORT_INCLUDE( pc_mouse_mousesystems ) /* IN12 - IN14 */
1390
1391	1373	PORT_INCLUDE( at_keyboard ) /* IN4 - IN11 */
1392	1374	INPUT_PORTS_END
1393	1375
r14535	r14536
1419	1401
1420	1402	MCFG_MACHINE_START( pcw16 )
1421	1403
1422		MCFG_NS16550_ADD( "ns16550_1", pcw16_com_interface[0] ) /* TODO: Verify uart model */
	1404	MCFG_NS16550_ADD( "ns16550_1", pcw16_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify uart model */
1423	1405
1424		MCFG_NS16550_ADD( "ns16550_2", pcw16_com_interface[1] ) /* TODO: Verify uart model */
	1406	MCFG_NS16550_ADD( "ns16550_2", pcw16_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify uart model */
1425	1407
1426	1408	/* video hardware */
1427	1409	MCFG_SCREEN_ADD("screen", RASTER)

src/mess/drivers/ht68k.c
r14535	r14536
166	166	MCFG_MACHINE_RESET(ht68k)
167	167
168	168	/* video hardware */
169		MCFG_FRAGMENT_ADD( generic_terminal )
170	169	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
171	170
172	171	MCFG_DUART68681_ADD( "duart68681", XTAL_8MHz / 2, ht68k_duart68681_config )

src/mess/drivers/microdec.c
r14535	r14536
111	111	MCFG_MACHINE_RESET(microdec)
112	112
113	113	/* video hardware */
114		MCFG_FRAGMENT_ADD( generic_terminal )
115	114	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
116	115
117	116	MCFG_UPD765A_ADD("upd765", microdec_upd765_interface)

src/mess/drivers/rvoice.c
r14535	r14536
373	373	//MCFG_DEFAULT_LAYOUT(layout_dectalk) // hack to avoid screenless system crash
374	374
375	375	/* sound hardware */
376		MCFG_FRAGMENT_ADD( generic_terminal )
377	376	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,dectalk_terminal_intf)
378	377
379	378	MACHINE_CONFIG_END

src/mess/drivers/basic52.c
r14535	r14536
90	90	MCFG_MACHINE_RESET(basic52)
91	91
92	92	/* video hardware */
93		MCFG_FRAGMENT_ADD( generic_terminal )
94	93	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
95	94
96	95	MCFG_I8255_ADD("ppi8255", ppi8255_intf )
r14535	r14536
105	104	MCFG_MACHINE_RESET(basic52)
106	105
107	106	/* video hardware */
108		MCFG_FRAGMENT_ADD( generic_terminal )
109	107	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
110	108
111	109	MCFG_I8255_ADD("ppi8255", ppi8255_intf )

src/mess/drivers/pimps.c
r14535	r14536
95	95	MCFG_CPU_IO_MAP(pimps_io)
96	96
97	97	/* video hardware */
98		MCFG_FRAGMENT_ADD( generic_terminal )
99	98	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
100	99	MACHINE_CONFIG_END
101	100

src/mess/drivers/vector4.c
r14535	r14536
98	98	MCFG_MACHINE_RESET(vector4)
99	99
100	100	/* video hardware */
101		MCFG_FRAGMENT_ADD( generic_terminal )
102	101	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
103	102	MACHINE_CONFIG_END
104	103

src/mess/drivers/portfoli.c
r14535	r14536
721	721
722	722	static const ins8250_interface i8250_intf =
723	723	{
724		XTAL_1_8432MHz,
	724	DEVCB_NULL,
	725	DEVCB_NULL,
	726	DEVCB_NULL,
725	727	DEVCB_DRIVER_LINE_MEMBER(portfolio_state, i8250_intrpt_w),
726		NULL,
727		NULL,
728		NULL
	728	DEVCB_NULL,
	729	DEVCB_NULL
729	730	};
730	731
731	732	//-------------------------------------------------
r14535	r14536
811	812	switch (m_pid)
812	813	{
813	814	case PID_SERIAL:
814		io->install_~~legacy_~~readwrite_handler(*m_uart, 0x8070, 0x8077, FUNC(ins8250_r), FUNC(ins8250_w));
	815	io->install_readwrite_handler(0x8070, 0x8077, read8_delegate(FUNC(ins8250_device::ins8250_r), (ins8250_device)m_uart), write8_delegate(FUNC(ins8250_device::ins8250_w), (ins8250_device)m_uart));
815	816	break;
816	817
817	818	case PID_PARALLEL:
r14535	r14536
858	859	/* devices */
859	860	MCFG_I8255A_ADD(M82C55A_TAG, ppi_intf)
860	861	MCFG_CENTRONICS_PRINTER_ADD(CENTRONICS_TAG, centronics_intf)
861		MCFG_INS8250_ADD(M82C50A_TAG, i8250_intf) // should be MCFG_INS8250A_ADD
	862	MCFG_INS8250_ADD(M82C50A_TAG, i8250_intf, XTAL_1_8432MHz) // should be MCFG_INS8250A_ADD
862	863	MCFG_TIMER_ADD_PERIODIC("counter", counter_tick, attotime::from_hz(XTAL_32_768kHz/16384))
863	864	MCFG_TIMER_ADD_PERIODIC(TIMER_TICK_TAG, system_tick, attotime::from_hz(XTAL_32_768kHz/32768))
864	865

src/mess/drivers/68ksbc.c
r14535	r14536
98	98	MCFG_CPU_ADD("maincpu", M68000, 8000000) // text says 8MHz, schematic says 10MHz
99	99	MCFG_CPU_PROGRAM_MAP(c68ksbc_mem)
100	100
101		MCFG_FRAGMENT_ADD( generic_terminal )
102	101	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
103	102	MACHINE_CONFIG_END
104	103

src/mess/drivers/altair.c
r14535	r14536
129	129	MCFG_MACHINE_RESET(altair)
130	130
131	131	/* video hardware */
132		MCFG_FRAGMENT_ADD( generic_terminal )
133	132	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
134	133
135	134	/* quickload */

src/mess/drivers/bebox.c
r14535	r14536
67	67	AM_RANGE(0x800000A0, 0x800000BF) AM_DEVREADWRITE8( "pic8259_slave", pic8259_r, pic8259_w, U64(0xffffffffffffffff) )
68	68	AM_RANGE(0x800000C0, 0x800000DF) AM_READWRITE( bebox_dma8237_1_r, bebox_dma8237_1_w)
69	69	AM_RANGE(0x800001F0, 0x800001F7) AM_READWRITE( bebox_800001F0_r, bebox_800001F0_w )
70		AM_RANGE(0x800002F8, 0x800002FF) AM_DEVREADWRITE8( "ns16550_1", ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
71		AM_RANGE(0x80000380, 0x80000387) AM_DEVREADWRITE8( "ns16550_2", ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
72		AM_RANGE(0x80000388, 0x8000038F) AM_DEVREADWRITE8( "ns16550_3", ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
	70	AM_RANGE(0x800002F8, 0x800002FF) AM_DEVREADWRITE8_MODERN( "ns16550_1", ns16550_device, ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
	71	AM_RANGE(0x80000380, 0x80000387) AM_DEVREADWRITE8_MODERN( "ns16550_2", ns16550_device, ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
	72	AM_RANGE(0x80000388, 0x8000038F) AM_DEVREADWRITE8_MODERN( "ns16550_3", ns16550_device, ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
73	73	AM_RANGE(0x800003F0, 0x800003F7) AM_READWRITE( bebox_800003F0_r, bebox_800003F0_w )
74		AM_RANGE(0x800003F8, 0x800003FF) AM_DEVREADWRITE8( "ns16550_0", ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
	74	AM_RANGE(0x800003F8, 0x800003FF) AM_DEVREADWRITE8_MODERN( "ns16550_0",ns16550_device, ins8250_r, ins8250_w, U64(0xffffffffffffffff) )
75	75	AM_RANGE(0x80000480, 0x8000048F) AM_READWRITE( bebox_80000480_r, bebox_80000480_w )
76	76	AM_RANGE(0x80000CF8, 0x80000CFF) AM_DEVREADWRITE("pcibus", pci_64be_r, pci_64be_w )
77	77	AM_RANGE(0x800042E8, 0x800042EF) AM_DEVWRITE8( "cirrus", cirrus_42E8_w, U64(0xffffffffffffffff) )
r14535	r14536
143	143
144	144	MCFG_PIC8259_ADD( "pic8259_slave", bebox_pic8259_slave_config )
145	145
146		MCFG_NS16550_ADD( "ns16550_0", bebox_uart_inteface_0 ) /* TODO: Verify model */
147		MCFG_NS16550_ADD( "ns16550_1", bebox_uart_inteface_1 ) /* TODO: Verify model */
148		MCFG_NS16550_ADD( "ns16550_2", bebox_uart_inteface_2 ) /* TODO: Verify model */
149		MCFG_NS16550_ADD( "ns16550_3", bebox_uart_inteface_3 ) /* TODO: Verify model */
	146	MCFG_NS16550_ADD( "ns16550_0", bebox_uart_inteface_0, 0 ) /* TODO: Verify model */
	147	MCFG_NS16550_ADD( "ns16550_1", bebox_uart_inteface_1, 0 ) /* TODO: Verify model */
	148	MCFG_NS16550_ADD( "ns16550_2", bebox_uart_inteface_2, 0 ) /* TODO: Verify model */
	149	MCFG_NS16550_ADD( "ns16550_3", bebox_uart_inteface_3, 0 ) /* TODO: Verify model */
150	150
151	151	/* video hardware */
152	152	MCFG_FRAGMENT_ADD( pcvideo_vga )

src/mess/drivers/tsispch.c
r14535	r14536
431	431	//MCFG_SOUND_ADD("dac", DAC, 0) /* TODO: correctly figure out how the DAC works; apparently it is connected to the serial output of the upd7720, which will be "fun" to connect up */
432	432	//MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
433	433
434		MCFG_FRAGMENT_ADD( generic_terminal )
435	434	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,tsispch_terminal_intf)
436	435	MACHINE_CONFIG_END
437	436

src/mess/drivers/jupiter.c
r14535	r14536
260	260	MCFG_CPU_PROGRAM_MAP(jupiter_m6800_mem)
261	261	MCFG_CPU_IO_MAP(jupiter_m6800_io)
262	262
263		// video hardware
264		MCFG_FRAGMENT_ADD( generic_terminal )
265
266	263	// devices
267	264	MCFG_FD1771_ADD(INS1771N1_TAG, fdc_intf)
268	265	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, jupiter2_terminal_intf)

src/mess/drivers/sun1.c
r14535	r14536
138	138	MCFG_CPU_PROGRAM_MAP(sun1_mem)
139	139
140	140	/* video hardware */
141		MCFG_FRAGMENT_ADD( generic_terminal )
142	141	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
143	142	MACHINE_CONFIG_END
144	143

src/mess/drivers/horizon.c
r14535	r14536
89	89	MCFG_MACHINE_RESET(horizon)
90	90
91	91	/* video hardware */
92		MCFG_FRAGMENT_ADD( generic_terminal )
93	92	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
94	93	MACHINE_CONFIG_END
95	94

src/mess/drivers/h19.c
r14535	r14536
118	118	ADDRESS_MAP_GLOBAL_MASK(0xff)
119	119	AM_RANGE(0x00, 0x1F) AM_READ_PORT("S401")
120	120	AM_RANGE(0x20, 0x3F) AM_READ_PORT("S402")
121		AM_RANGE(0x40, 0x47) AM_MIRROR(0x18) AM_DEVREADWRITE~~_LEGACY~~("ins8250", ins8250_r, ins8250_w )
	121	AM_RANGE(0x40, 0x47) AM_MIRROR(0x18) AM_DEVREADWRITE("ins8250", ins8250_device, ins8250_r, ins8250_w )
122	122	AM_RANGE(0x60, 0x60) AM_DEVWRITE("crtc", mc6845_device, address_w)
123	123	AM_RANGE(0x61, 0x61) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
124	124	AM_RANGE(0x80, 0x9F) AM_READ(h19_80_r)
r14535	r14536
346	346
347	347	static const ins8250_interface h19_ace_interface =
348	348	{
349		XTAL_12_288MHz / 4, // 3.072mhz clock which gets divided down for the various baud rates
	349	DEVCB_NULL,
	350	DEVCB_NULL,
	351	DEVCB_NULL,
350	352	DEVCB_LINE(h19_ace_irq), // interrupt
351		NULL, // transmit func
352		NULL, // handshake out
353		NULL // refresh func
	353	DEVCB_NULL,
	354	DEVCB_NULL
354	355	};
355	356
356	357	static const mc6845_interface h19_crtc6845_interface =
r14535	r14536
415	416	MCFG_PALETTE_INIT(monochrome_green)
416	417
417	418	MCFG_MC6845_ADD("crtc", MC6845, XTAL_12_288MHz / 8, h19_crtc6845_interface) // clk taken from schematics
418		MCFG_INS8250_ADD( "ins8250", h19_ace_interface )
	419	MCFG_INS8250_ADD( "ins8250", h19_ace_interface, XTAL_12_288MHz / 4) // 3.072mhz clock which gets divided down for the various baud rates
419	420	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, h19_terminal_intf) // keyboard only
420	421
421	422	/* sound hardware */

src/mess/drivers/avigo.c
r14535	r14536
227	227
228	228	static const ins8250_interface avigo_com_interface =
229	229	{
230		1843200,
	230	DEVCB_NULL,
	231	DEVCB_NULL,
	232	DEVCB_NULL,
231	233	DEVCB_DRIVER_LINE_MEMBER(avigo_state, com_interrupt),
232		NULL,
233		NULL,
234		NULL
	234	DEVCB_NULL,
	235	DEVCB_NULL
235	236	};
236	237
237	238
r14535	r14536
635	636	AM_RANGE(0x010, 0x01f) AM_DEVREADWRITE("rtc", rp5c01_device, read, write)
636	637	AM_RANGE(0x028, 0x028) AM_WRITE( speaker_w )
637	638	AM_RANGE(0x02d, 0x02d) AM_READ( ad_data_r )
638		AM_RANGE(0x030, 0x037) AM_DEVREADWRITE~~_LEGACY~~("ns16550", ins8250_r, ins8250_w )
	639	AM_RANGE(0x030, 0x037) AM_DEVREADWRITE("ns16550", ns16550_device, ins8250_r, ins8250_w )
639	640	ADDRESS_MAP_END
640	641
641	642
r14535	r14536
885	886	MCFG_CPU_IO_MAP(avigo_io)
886	887	MCFG_QUANTUM_TIME(attotime::from_hz(60))
887	888
888		MCFG_NS16550_ADD( "ns16550", avigo_com_interface )
	889	MCFG_NS16550_ADD( "ns16550", avigo_com_interface, XTAL_1_8432MHz )
889	890
890	891	/* video hardware */
891	892	MCFG_SCREEN_ADD("screen", LCD)

src/mess/drivers/mpz80.c
r14535	r14536
758	758	MCFG_CPU_PROGRAM_MAP(mpz80_mem)
759	759	MCFG_CPU_IO_MAP(mpz80_io)
760	760
761		// video hardware
762		MCFG_FRAGMENT_ADD( generic_terminal )
763
764	761	// S-100
765	762	MCFG_S100_BUS_ADD(Z80_TAG, s100_intf)
766	763	MCFG_S100_SLOT_ADD("s100_1", mpz80_s100_cards, "mm65k16s", NULL)

src/mess/drivers/ccs2810.c
r14535	r14536
119	119
120	120	static const ins8250_interface ccs2810_com_interface =
121	121	{
122		1843200,
123	122	DEVCB_NULL,
124		NULL,
125		NULL,
126		NULL
	123	DEVCB_NULL,
	124	DEVCB_NULL,
	125	DEVCB_NULL,
	126	DEVCB_NULL,
	127	DEVCB_NULL
127	128	};
128	129
129	130	static MACHINE_CONFIG_START( ccs2810, ccs2810_state )
r14535	r14536
132	133	MCFG_CPU_PROGRAM_MAP(ccs2810_mem)
133	134	MCFG_CPU_IO_MAP(ccs2810_io)
134	135
135		MCFG_INS8250_ADD( "ins8250", ccs2810_com_interface )
	136	MCFG_INS8250_ADD( "ins8250", ccs2810_com_interface, XTAL_1_8432MHz )
136	137
137	138	/* video hardware */
138		MCFG_FRAGMENT_ADD( generic_terminal )
139	139	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
140	140	MACHINE_CONFIG_END
141	141

src/mess/drivers/super6.c
r14535	r14536
569	569	MCFG_CPU_IO_MAP(super6_io)
570	570	MCFG_CPU_CONFIG(super6_daisy_chain)
571	571
572		// video hardware
573		MCFG_FRAGMENT_ADD(generic_terminal)
574
575	572	// devices
576	573	MCFG_Z80CTC_ADD(Z80CTC_TAG, XTAL_24MHz/4, ctc_intf)
577	574	MCFG_TIMER_ADD_PERIODIC("ctc", ctc_tick, attotime::from_hz(XTAL_24MHz/16))

src/mess/drivers/zrt80.c
r14535	r14536
40	40	required_device<cpu_device> m_maincpu;
41	41	required_device<device_t> m_terminal;
42	42	required_device<mc6845_device> m_crtc;
43		required_device<device_t> m_8250;
	43	required_device<ins8250_device> m_8250;
44	44	required_device<device_t> m_beep;
45	45	DECLARE_READ8_MEMBER( zrt80_10_r );
46	46	DECLARE_WRITE8_MEMBER( zrt80_30_w );
r14535	r14536
91	91	static ADDRESS_MAP_START( zrt80_io, AS_IO, 8, zrt80_state)
92	92	ADDRESS_MAP_UNMAP_HIGH
93	93	ADDRESS_MAP_GLOBAL_MASK(0xff)
94		AM_RANGE(0x00, 0x07) AM_DEVREADWRITE~~_LEGACY~~("ins8250", ins8250_r, ins8250_w )
	94	AM_RANGE(0x00, 0x07) AM_DEVREADWRITE("ins8250", ins8250_device, ins8250_r, ins8250_w )
95	95	AM_RANGE(0x08, 0x08) AM_DEVWRITE("crtc", mc6845_device, address_w)
96	96	AM_RANGE(0x09, 0x09) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
97	97	AM_RANGE(0x10, 0x17) AM_READ(zrt80_10_r)
r14535	r14536
247	247
248	248	static const ins8250_interface zrt80_com_interface =
249	249	{
250		2457600,
	250	DEVCB_NULL,
	251	DEVCB_NULL,
251	252	DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_IRQ0),
252		NULL,
253		NULL,
254		NULL
	253	DEVCB_NULL,
	254	DEVCB_NULL,
	255	DEVCB_NULL
255	256	};
256	257
257	258	WRITE8_MEMBER( zrt80_state::kbd_put )
r14535	r14536
308	309
309	310	/* Devices */
310	311	MCFG_MC6845_ADD("crtc", MC6845, XTAL_20MHz / 8, zrt80_crtc6845_interface)
311		MCFG_INS8250_ADD( "ins8250", zrt80_com_interface )
	312	MCFG_INS8250_ADD( "ins8250", zrt80_com_interface, 2457600 )
312	313	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
313	314	MACHINE_CONFIG_END
314	315

src/mess/drivers/swtpc.c
r14535	r14536
111	111	MCFG_MACHINE_RESET(swtpc)
112	112
113	113	/* video hardware */
114		MCFG_FRAGMENT_ADD( generic_terminal )
115	114	MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
116	115	MACHINE_CONFIG_END
117	116

src/mess/drivers/pc.c
r14535	r14536
78	78	#include "machine/pc_joy.h"
79	79	#include "machine/pckeybrd.h"
80	80	#include "machine/pc_lpt.h"
81		#include "machine/~~pc_mou~~se.h"
	81	#include "machine/serial.h"
82	82
83	83	#include "includes/europc.h"
84	84	#include "includes/tandy1t.h"
r14535	r14536
162	162	AM_RANGE(0x0200, 0x0207) AM_READWRITE(pc_JOY_r, pc_JOY_w)
163	163	AM_RANGE(0x0240, 0x0257) AM_READWRITE(pc_rtc_r, pc_rtc_w)
164	164	AM_RANGE(0x0278, 0x027b) AM_DEVREADWRITE("lpt_2", pc_lpt_r, pc_lpt_w)
165		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE("ins8250_3", ins8250_r, ins8250_w)
166		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE("ins8250_1", ins8250_r, ins8250_w)
	165	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w)
	166	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w)
167	167	AM_RANGE(0x0340, 0x0357) AM_NOP /* anonymous bios should not recogniced realtimeclock */
168	168	AM_RANGE(0x0378, 0x037f) AM_DEVREADWRITE("lpt_1", pc_lpt_r, pc_lpt_w)
169	169	AM_RANGE(0x03bc, 0x03be) AM_DEVREADWRITE("lpt_0", pc_lpt_r, pc_lpt_w)
170		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE("ins8250_2", ins8250_r, ins8250_w)
	170	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w)
171	171	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(pc_fdc_r, pc_fdc_w)
172		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE("ins8250_0", ins8250_r, ins8250_w)
	172	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w)
173	173	ADDRESS_MAP_END
174	174
175	175	static ADDRESS_MAP_START(oliv_io, AS_IO, 8)
r14535	r14536
189	189	AM_RANGE(0x0240, 0x0257) AM_READWRITE(pc16le_rtc_r, pc16le_rtc_w)
190	190	AM_RANGE(0x0278, 0x027b) AM_DEVREADWRITE8("lpt_2", pc_lpt_r, pc_lpt_w, 0x00ff)
191	191	AM_RANGE(0x02b0, 0x02bf) AM_RAM // needed for EC-18xx
192		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8("ins8250_3", ins8250_r, ins8250_w, 0xffff)
193		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	192	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w, 0xffff)
	193	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
194	194	AM_RANGE(0x0340, 0x0357) AM_NOP /* anonymous bios should not recogniced realtimeclock */
195	195	AM_RANGE(0x0378, 0x037f) AM_DEVREADWRITE8("lpt_1", pc_lpt_r, pc_lpt_w, 0x00ff)
196	196	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0x00ff)
197		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8("ins8250_2", ins8250_r, ins8250_w, 0xffff)
	197	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w, 0xffff)
198	198	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
199		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	199	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
200	200	ADDRESS_MAP_END
201	201
202	202
r14535	r14536
225	225	AM_RANGE(0x0240, 0x0257) AM_READWRITE(pc16le_rtc_r, pc16le_rtc_w)
226	226	AM_RANGE(0x0278, 0x027b) AM_DEVREADWRITE8("lpt_2", pc_lpt_r, pc_lpt_w, 0x00ff)
227	227	AM_RANGE(0x02b0, 0x02bf) AM_RAM // needed for EC-18xx
228		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8("ins8250_3", ins8250_r, ins8250_w, 0xffff)
229		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	228	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE8_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w, 0xffff)
	229	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
230	230	AM_RANGE(0x0340, 0x0357) AM_NOP /* anonymous bios should not recogniced realtimeclock */
231	231	AM_RANGE(0x0378, 0x037f) AM_DEVREADWRITE8("lpt_1", pc_lpt_r, pc_lpt_w, 0x00ff)
232	232	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0x00ff)
233		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8("ins8250_2", ins8250_r, ins8250_w, 0xffff)
	233	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE8_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w, 0xffff)
234	234	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
235		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	235	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
236	236	ADDRESS_MAP_END
237	237
238	238
r14535	r14536
257	257	AM_RANGE(0x0250, 0x025f) AM_READWRITE(europc_jim_r, europc_jim_w)
258	258	AM_RANGE(0x0278, 0x027b) AM_DEVREADWRITE("lpt_2", pc_lpt_r, pc_lpt_w)
259	259	AM_RANGE(0x02e0, 0x02e0) AM_READ (europc_jim2_r)
260		AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE("ins8250_3", ins8250_r, ins8250_w)
261		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE("ins8250_1", ins8250_r, ins8250_w)
	260	AM_RANGE(0x02e8, 0x02ef) AM_DEVREADWRITE_MODERN("ins8250_3", ins8250_device, ins8250_r, ins8250_w)
	261	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w)
262	262	AM_RANGE(0x0378, 0x037b) AM_DEVREADWRITE("lpt_1", pc_lpt_r, pc_lpt_w)
263	263	// AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE("lpt_0", pc_lpt_r, pc_lpt_w)
264		AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE("ins8250_2", ins8250_r, ins8250_w)
	264	AM_RANGE(0x03e8, 0x03ef) AM_DEVREADWRITE_MODERN("ins8250_2", ins8250_device, ins8250_r, ins8250_w)
265	265	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(pc_fdc_r, pc_fdc_w)
266		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE("ins8250_0", ins8250_r, ins8250_w)
	266	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w)
267	267	ADDRESS_MAP_END
268	268
269	269
r14535	r14536
289	289	AM_RANGE(0x0080, 0x0087) AM_READWRITE(pc_page_r, pc_page_w)
290	290	AM_RANGE(0x00c0, 0x00c0) AM_DEVWRITE("sn76496", sn76496_w)
291	291	AM_RANGE(0x0200, 0x0207) AM_READWRITE(pc_JOY_r, pc_JOY_w)
292		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE("ins8250_1", ins8250_r, ins8250_w)
	292	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w)
293	293	AM_RANGE(0x0378, 0x037f) AM_READWRITE(pc_t1t_p37x_r, pc_t1t_p37x_w)
294	294	AM_RANGE(0x03bc, 0x03be) AM_DEVREADWRITE("lpt_0", pc_lpt_r, pc_lpt_w)
295	295	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(pc_fdc_r, pc_fdc_w)
296		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE("ins8250_0", ins8250_r, ins8250_w)
	296	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w)
297	297	ADDRESS_MAP_END
298	298
299	299
r14535	r14536
319	319	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r, pc_page_w, 0xffff)
320	320	AM_RANGE(0x00c0, 0x00c1) AM_DEVWRITE8("sn76496", sn76496_w, 0xffff)
321	321	AM_RANGE(0x0200, 0x0207) AM_READWRITE8(pc_JOY_r, pc_JOY_w, 0xffff)
322		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	322	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
323	323	AM_RANGE(0x0378, 0x037f) AM_READWRITE8(pc_t1t_p37x_r, pc_t1t_p37x_w, 0xffff)
324	324	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0xffff)
325	325	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
326		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	326	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
327	327	AM_RANGE(0xffea, 0xffeb) AM_READWRITE8(tandy1000_bank_r, tandy1000_bank_w, 0xffff)
328	328	ADDRESS_MAP_END
329	329
r14535	r14536
350	350	AM_RANGE(0x0080, 0x0087) AM_READWRITE8(pc_page_r, pc_page_w, 0xffff)
351	351	AM_RANGE(0x00c0, 0x00c1) AM_DEVWRITE8("sn76496", sn76496_w, 0xffff)
352	352	AM_RANGE(0x0200, 0x0207) AM_READWRITE8(pc_JOY_r, pc_JOY_w, 0xffff)
353		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8("ins8250_1", ins8250_r, ins8250_w, 0xffff)
	353	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE8_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w, 0xffff)
354	354	AM_RANGE(0x0378, 0x037f) AM_READWRITE8(pc_t1t_p37x_r, pc_t1t_p37x_w, 0xffff)
355	355	AM_RANGE(0x03bc, 0x03bf) AM_DEVREADWRITE8("lpt_0", pc_lpt_r, pc_lpt_w, 0xffff)
356	356	AM_RANGE(0x03f0, 0x03f7) AM_READWRITE8(pc_fdc_r, pc_fdc_w, 0xffff)
357		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8("ins8250_0", ins8250_r, ins8250_w, 0xffff)
	357	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE8_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w, 0xffff)
358	358	ADDRESS_MAP_END
359	359
360	360
r14535	r14536
381	381	AM_RANGE(0x00c0, 0x00c0) AM_DEVWRITE("sn76496", sn76496_w)
382	382	AM_RANGE(0x00f0, 0x00f7) AM_READWRITE(pc_fdc_r, pcjr_fdc_w)
383	383	AM_RANGE(0x0200, 0x0207) AM_READWRITE(pc_JOY_r, pc_JOY_w)
384		AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE("ins8250_1", ins8250_r, ins8250_w)
	384	AM_RANGE(0x02f8, 0x02ff) AM_DEVREADWRITE_MODERN("ins8250_1", ins8250_device, ins8250_r, ins8250_w)
385	385	AM_RANGE(0x0378, 0x037f) AM_READWRITE(pc_t1t_p37x_r, pc_t1t_p37x_w)
386	386	AM_RANGE(0x03bc, 0x03be) AM_DEVREADWRITE("lpt_0", pc_lpt_r, pc_lpt_w)
387		AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE("ins8250_0", ins8250_r, ins8250_w)
	387	AM_RANGE(0x03f8, 0x03ff) AM_DEVREADWRITE_MODERN("ins8250_0", ins8250_device, ins8250_r, ins8250_w)
388	388	ADDRESS_MAP_END
389	389
390	390	static ADDRESS_MAP_START(ibmpcjx_map, AS_PROGRAM, 8 )
r14535	r14536
453	453	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
454	454
455	455	PORT_START("DSW2") /* IN3 */
456		PORT_DIPNAME( 0xf0, 0x80, "Serial mouse")
457		PORT_DIPSETTING( 0x80, "COM1" )
458		PORT_DIPSETTING( 0x40, "COM2" )
459		PORT_DIPSETTING( 0x20, "COM3" )
460		PORT_DIPSETTING( 0x10, "COM4" )
461		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
462	456	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
463	457	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
464	458	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
469	463	PORT_BIT( 0x01, 0x01, IPT_UNUSED )
470	464
471	465	PORT_INCLUDE( kb_keytronic_pc )
472		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
473	466	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
474	467	PORT_INCLUDE( pcvideo_cga )
475	468	INPUT_PORTS_END
r14535	r14536
530	523	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
531	524
532	525	PORT_START("DSW2") /* IN3 */
533		PORT_DIPNAME( 0xf0, 0x80, "Serial mouse")
534		PORT_DIPSETTING( 0x80, "COM1" )
535		PORT_DIPSETTING( 0x40, "COM2" )
536		PORT_DIPSETTING( 0x20, "COM3" )
537		PORT_DIPSETTING( 0x10, "COM4" )
538		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
539	526	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
540	527	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
541	528	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
546	533	PORT_BIT( 0x01, 0x01, IPT_UNUSED )
547	534
548	535	PORT_INCLUDE( kb_keytronic_pc )
549		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
550	536	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
551	537	PORT_INCLUDE( pcvideo_cga )
552	538	INPUT_PORTS_END
r14535	r14536
587	573	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
588	574
589	575	PORT_START("DSW2") /* IN3 */
590		PORT_DIPNAME( 0xf0, 0x80, "Serial mouse")
591		PORT_DIPSETTING( 0x80, "COM1" )
592		PORT_DIPSETTING( 0x40, "COM2" )
593		PORT_DIPSETTING( 0x20, "COM3" )
594		PORT_DIPSETTING( 0x10, "COM4" )
595		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
596	576	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
597	577	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
598	578	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
604	584
605	585	EUROPC_KEYBOARD
606	586
607		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
608	587	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
609	588	PORT_INCLUDE( pcvideo_cga )
610	589	INPUT_PORTS_END
r14535	r14536
665	644	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
666	645
667	646	PORT_START("DSW2") /* IN3 */
668		PORT_DIPNAME( 0xf0, 0x80, "Serial mouse")
669		PORT_DIPSETTING( 0x80, "COM1" )
670		PORT_DIPSETTING( 0x40, "COM2" )
671		PORT_DIPSETTING( 0x20, "COM3" )
672		PORT_DIPSETTING( 0x10, "COM4" )
673		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
674	647	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
675	648	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
676	649	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
684	657
685	658	// PORT_INCLUDE( at_keyboard ) /* IN4 - IN11 */
686	659	PORT_INCLUDE( kb_keytronic_pc )
687		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
688	660	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
689	661	PORT_INCLUDE( pcvideo_cga )
690	662	INPUT_PORTS_END
r14535	r14536
715	687	PORT_DIPSETTING( 0x01, DEF_STR( Yes ) )
716	688
717	689	PORT_START("DSW2") /* IN3 */
718		PORT_DIPNAME( 0xf0, 0x80, "Serial mouse")
719		PORT_DIPSETTING( 0x80, "COM1" )
720		PORT_DIPSETTING( 0x40, "COM2" )
721		PORT_DIPSETTING( 0x20, "COM3" )
722		PORT_DIPSETTING( 0x10, "COM4" )
723		PORT_DIPSETTING( 0x00, DEF_STR( None ) )
724	690	PORT_DIPNAME( 0x08, 0x08, "HDC1 (C800:0 port 320-323)")
725	691	PORT_DIPSETTING( 0x00, DEF_STR( No ) )
726	692	PORT_DIPSETTING( 0x08, DEF_STR( Yes ) )
r14535	r14536
731	697	PORT_BIT( 0x01, 0x01, IPT_UNUSED )
732	698
733	699	PORT_INCLUDE( t1000_keyboard )
734		PORT_INCLUDE( pc_mouse_microsoft ) /* IN12 - IN14 */
735	700	PORT_INCLUDE( pc_joystick ) /* IN15 - IN19 */
736	701	INPUT_PORTS_END
737	702
r14535	r14536
756	721	NULL
757	722	};
758	723
	724	SLOT_INTERFACE_START(ibm5150_com)
	725	SLOT_INTERFACE("microsoft_mouse", MSFT_SERIAL_MOUSE)
	726	SLOT_INTERFACE("mouse_systems_mouse", MSYSTEM_SERIAL_MOUSE)
	727	SLOT_INTERFACE_END
	728
759	729	static const kb_keytronic_interface pc_keytronic_intf =
760	730	{
761	731	DEVCB_MEMORY_HANDLER("maincpu", IO, ibm5150_kb_set_clock_signal),
r14535	r14536
834	804
835	805	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
836	806
837		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
838		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
839		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
840		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	807	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	808	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	809	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	810	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	811	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	812	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	813	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	814	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
841	815
842	816	/* video hardware */
843	817	MCFG_FRAGMENT_ADD( pcvideo_cga )
r14535	r14536
882	856
883	857	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
884	858
885		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
886		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
887		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
888		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	859	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	860	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	861	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	862	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	863	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	864	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	865	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	866	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
889	867
890	868	/* video hardware */
891	869	MCFG_FRAGMENT_ADD( pcvideo_cga32k )
r14535	r14536
959	937
960	938	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
961	939
962		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
963		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
964		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
965		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	940	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	941	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	942	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	943	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	944	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	945	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	946	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	947	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
966	948
967	949	/* video hardware */
968	950	MCFG_FRAGMENT_ADD( pcvideo_aga )
r14535	r14536
1005	987
1006	988	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
1007	989
1008		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1009		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
	990	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	991	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	992	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	993	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
1010	994
1011	995	/* video hardware */
1012	996	MCFG_FRAGMENT_ADD( pcvideo_t1000 )
r14535	r14536
1051	1035
1052	1036	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
1053	1037
1054		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1055		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
	1038	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1039	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1040	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1041	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
1056	1042
1057	1043	/* video hardware */
1058	1044	MCFG_FRAGMENT_ADD( pcvideo_t1000 )
r14535	r14536
1097	1083
1098	1084	MCFG_I8255_ADD( "ppi8255", pc_ppi8255_interface )
1099	1085
1100		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1101		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
	1086	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1087	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1088	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1089	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
1102	1090
1103	1091	/* video hardware */
1104	1092	MCFG_FRAGMENT_ADD( pcvideo_t1000 )
r14535	r14536
1154	1142
1155	1143	MCFG_I8255_ADD( "ppi8255", pcjr_ppi8255_interface )
1156	1144
1157		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1158		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
	1145	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1146	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1147	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1148	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
1159	1149
1160	1150	/* video hardware */
1161	1151	MCFG_FRAGMENT_ADD( pcvideo_pcjr )
r14535	r14536
1235	1225
1236	1226	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1237	1227
1238		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1239		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1240		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1241		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1228	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1229	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1230	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1231	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1232	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1233	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1234	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	1235	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
1242	1236
1243	1237	/* video hardware */
1244	1238	MCFG_FRAGMENT_ADD( pcvideo_cga )
r14535	r14536
1284	1278
1285	1279	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1286	1280
1287		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1288		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1289		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1290		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1281	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1282	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1283	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1284	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1285	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1286	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1287	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	1288	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
1291	1289
1292	1290	/* video hardware */
1293	1291	// MCFG_FRAGMENT_ADD( pcvideo_ega ) // Put this back after ISA are added to this driver
r14535	r14536
1332	1330
1333	1331	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1334	1332
1335		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1336		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1337		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1338		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1333	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1334	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1335	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1336	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1337	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1338	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1339	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	1340	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
1339	1341
1340	1342	/* video hardware */
1341	1343	MCFG_FRAGMENT_ADD( pcvideo_poisk2 )
r14535	r14536
1380	1382
1381	1383	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1382	1384
1383		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1384		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1385		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1386		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1385	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1386	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1387	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1388	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1389	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1390	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1391	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	1392	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
1387	1393
1388	1394	/* video hardware */
1389	1395	MCFG_FRAGMENT_ADD( pcvideo_cga )
r14535	r14536
1428	1434
1429	1435	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1430	1436
1431		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1432		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1433		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1434		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1437	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1438	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1439	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1440	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1441	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1442	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1443	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
	1444	MCFG_RS232_PORT_ADD( "serport3", ibm5150_serport_config[3], ibm5150_com, NULL, NULL )
1435	1445
1436	1446	/* video hardware */
1437	1447	MCFG_FRAGMENT_ADD( pcvideo_cga )
r14535	r14536
1476	1486
1477	1487	MCFG_I8255_ADD( "ppi8255", ibm5160_ppi8255_interface )
1478	1488
1479		MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0] ) /* TODO: Verify model */
1480		MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1] ) /* TODO: Verify model */
1481		MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2] ) /* TODO: Verify model */
1482		MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3] ) /* TODO: Verify model */
	1489	MCFG_INS8250_ADD( "ins8250_0", ibm5150_com_interface[0], XTAL_1_8432MHz ) /* TODO: Verify model */
	1490	MCFG_INS8250_ADD( "ins8250_1", ibm5150_com_interface[1], XTAL_1_8432MHz ) /* TODO: Verify model */
	1491	MCFG_INS8250_ADD( "ins8250_2", ibm5150_com_interface[2], XTAL_1_8432MHz ) /* TODO: Verify model */
	1492	MCFG_INS8250_ADD( "ins8250_3", ibm5150_com_interface[3], XTAL_1_8432MHz ) /* TODO: Verify model */
	1493	MCFG_RS232_PORT_ADD( "serport0", ibm5150_serport_config[0], ibm5150_com, NULL, NULL )
	1494	MCFG_RS232_PORT_ADD( "serport1", ibm5150_serport_config[1], ibm5150_com, NULL, NULL )
	1495	MCFG_RS232_PORT_ADD( "serport2", ibm5150_serport_config[2], ibm5150_com, NULL, NULL )
1483	1496
1484	1497	/* video hardware */
1485	1498	MCFG_FRAGMENT_ADD( pcvideo_cga )

15994 Revisions