MAME SVN History

199869 Revisions

r19156 Monday 26th November, 2012 at 16:04:41 UTC by Curt Coder
Replaced all device_t's with actual device classes. Regression test recommended. (nw)

[src/mame/drivers]	icecold.c pcxt.c
[src/mame/includes]	cidelsa.h metro.h
[src/mess/drivers]	a5105.c alphatro.c apf.c apricot.c bigbord2.c bmjr.c bml3.c camplynx.c chessmst.c csc.c d6800.c digel804.c dim68k.c dolphunk.c eacc.c esq1.c esq5505.c fp1100.c glasgow.c h19.c h8.c homelab.c horizon.c hp9k.c ht68k.c imds.c ipds.c iq151.c junior.c kim1.c lcmate2.c lx800.c m20.c mbc200.c mekd2.c mephisto.c merlin.c mk2.c multi16.c multi8.c myb3k.c mycom.c nanos.c osbexec.c palm.c paso1600.c pb1000.c pc2000.c pce220.c pcm.c pegasus.c phunsy.c ptcsol.c px4.c pyl601.c qx10.c rainbow.c rex6000.c rx78.c sc1.c sc2.c sitcom.c slc1.c sm1800.c socrates.c supercon.c svmu.c tec1.c tm990189.c unixpc.c v1050.c vk100.c votrtnt.c vt100.c vtech1.c wangpc.c xor100.c z100.c z9001.c zrt80.c
[src/mess/includes]	abc1600.h abc80.h abc80x.h ace.h amstrad.h apple2gs.h apricotf.h apricotp.h at.h atarist.h atom.h avigo.h beta.h bullet.h coco.h compis.h cosmicos.h cybiko.h dai.h dgnalpha.h exp85.h fidelz80.h intv.h irisha.h jtc.h kaypro.h kc.h kyocera.h lc80.h lisa.h llc.h mbc55x.h mbee.h mc1000.h micronic.h mikromik.h mpf1.h msx.h mz80.h ob68k1a.h osborne1.h osi.h p2000t.h pc1512.h pc4.h pc8001.h pc8401a.h pes.h plus4.h portfoli.h psion.h ql.h rm380z.h sage2.h sorcerer.h special.h studio2.h super80.h tandy2k.h tdv2324.h tek405x.h ti85.h tiki100.h trs80.h trs80m2.h tsispch.h v1050.h vector06.h victor9k.h vidbrain.h vixen.h wangpc.h x07.h x1.h xor100.h
[src/mess/machine]	a2arcadebd.h a2cffa.h a2diskii.h a2echoii.h a2mockingboard.h abc77.h abc99.h abc_fd2.h abc_hdc.c abc_hdc.h abc_xebec.c abc_xebec.h c1551.h c1571.h c1581.h c2040.h c64_currah_speech.h c64_ieee488.h c64_sfx_sound_expander.h comx_fd.h cpc_ssa1.h e01.h ecb_grip.h isa_ibm_mfc.h kc_d004.h lux10828.h lux21046.h s100_dj2db.h s100_wunderbus.h southbridge.h tvc_hbf.h v1050kb.h

trunk/src/mess/machine/lux10828.h
r19155	r19156
99	99	private:
100	100	required_device<cpu_device> m_maincpu;
101	101	required_device<z80pio_device> m_pio;
102		required_device<device_t> m_fdc;
	102	required_device<mb8876_device> m_fdc;
103	103	required_device<legacy_floppy_image_device> m_image0;
104	104	required_device<legacy_floppy_image_device> m_image1;
105	105

trunk/src/mess/machine/tvc_hbf.h
r19155	r19156
43	43
44	44	private:
45	45	// internal state
46		required_device<device_t> m_fdc;
	46	required_device<fd1793_device> m_fdc;
47	47
48	48	UINT8 * m_rom;
49	49	UINT8 * m_ram;

trunk/src/mess/machine/s100_wunderbus.h
r19155	r19156
40	40	// not really public
41	41	DECLARE_WRITE_LINE_MEMBER( pic_int_w );
42	42	DECLARE_WRITE_LINE_MEMBER( rtc_tp_w );
43		required_device<device_t> m_pic;
	43	required_device<pic8259_device> m_pic;
44	44	required_device<ins8250_device> m_ace1;
45	45	required_device<ins8250_device> m_ace2;
46	46	required_device<ins8250_device> m_ace3;

trunk/src/mess/machine/a2mockingboard.h
r19155	r19156
52	52
53	53	required_device<via6522_device> m_via1;
54	54	required_device<via6522_device> m_via2;
55		required_device<device_t> m_ay1;
56		required_device<device_t> m_ay2;
57		optional_device<device_t> m_ay3;
58		optional_device<device_t> m_ay4;
	55	required_device<ay8913_device> m_ay1;
	56	required_device<ay8913_device> m_ay2;
	57	optional_device<ay8913_device> m_ay3;
	58	optional_device<ay8913_device> m_ay4;
59	59
60	60	bool m_isPhasor, m_PhasorNative;
61	61

trunk/src/mess/machine/c64_currah_speech.h
r19155	r19156
49	49	private:
50	50	inline void set_osc1(int voice, int intonation);
51	51
52		required_device<device_t> m_nsp;
	52	required_device<sp0256_device> m_nsp;
53	53	};
54	54
55	55

trunk/src/mess/machine/abc77.h
r19155	r19156
105	105	devcb_resolved_write_line m_out_keydown_func;
106	106
107	107	required_device<cpu_device> m_maincpu;
108		required_device<device_t> m_discrete;
	108	required_device<discrete_sound_device> m_discrete;
109	109
110	110	int m_txd; // transmit data
111	111	int m_keylatch; // keyboard row latch

trunk/src/mess/machine/ecb_grip.h
r19155	r19156
80	80	required_device<z80sti_device> m_sti;
81	81	required_device<mc6845_device> m_crtc;
82	82	required_device<centronics_device> m_centronics;
83		required_device<device_t> m_speaker;
	83	required_device<speaker_sound_device> m_speaker;
84	84
85	85	// sound state
86	86	int m_vol0;

trunk/src/mess/machine/comx_fd.h
r19155	r19156
60	60	inline void update_ef4();
61	61
62	62	// internal state
63		required_device<device_t> m_fdc;
64		required_device<device_t> m_floppy0;
65		required_device<device_t> m_floppy1;
	63	required_device<wd1770_device> m_fdc;
	64	required_device<legacy_floppy_image_device> m_floppy0;
	65	required_device<legacy_floppy_image_device> m_floppy1;
66	66
67	67	// floppy state
68	68	int m_ds; // device select

trunk/src/mess/machine/a2arcadebd.h
r19155	r19156
41	41	virtual void write_c0nx(address_space &space, UINT8 offset, UINT8 data);
42	42
43	43	required_device<tms9918a_device> m_tms;
44		required_device<device_t> m_ay;
	44	required_device<ay8910_device> m_ay;
45	45
46	46	private:
47	47	};

trunk/src/mess/machine/cpc_ssa1.h
r19155	r19156
80	80	UINT8 m_lrq;
81	81	UINT8 m_sby;
82	82
83		required_device<device_t> m_sp0256_device;
	83	required_device<sp0256_device> m_sp0256_device;
84	84	};
85	85
86	86	class cpc_dkspeech_device : public device_t,
r19155	r19156
117	117	UINT8 m_lrq;
118	118	UINT8 m_sby;
119	119
120		required_device<device_t> m_sp0256_device;
	120	required_device<sp0256_device> m_sp0256_device;
121	121	};
122	122
123	123	// device type definition

trunk/src/mess/machine/e01.h
r19155	r19156
80	80	virtual void econet_clk(int state);
81	81
82	82	required_device<m65c02_device> m_maincpu;
83		required_device<device_t> m_fdc;
84		required_device<device_t> m_adlc;
	83	required_device<wd2793_device> m_fdc;
	84	required_device<mc6854_device> m_adlc;
85	85	required_device<mc146818_device> m_rtc;
86	86	required_device<ram_device> m_ram;
87	87	required_device<scsicb_device> m_scsibus;

trunk/src/mess/machine/abc_xebec.c
r19155	r19156
8	8	*********************************************************************/
9	9
10	10	#include "abc_xebec.h"
11		#include "machine/scsibus.h"
12		#include "machine/scsicb.h"
13		#include "machine/scsihd.h"
14	11
15	12
16	13

trunk/src/mess/machine/abc_xebec.h
r19155	r19156
17	17	#include "cpu/z80/z80.h"
18	18	#include "cpu/z80/z80daisy.h"
19	19	#include "machine/abcbus.h"
	20	#include "machine/scsibus.h"
	21	#include "machine/scsicb.h"
	22	#include "machine/scsihd.h"
20	23
21	24
22	25
r19155	r19156
48	51
49	52	private:
50	53	required_device<cpu_device> m_maincpu;
51		required_device<device_t> m_sasibus;
	54	required_device<scsicb_device> m_sasibus;
52	55	};
53	56
54	57

trunk/src/mess/machine/a2cffa.h
r19155	r19156
12	12
13	13	#include "emu.h"
14	14	#include "machine/a2bus.h"
	15	#include "machine/idectrl.h"
15	16
16	17	//**************************************************************************
17	18	// TYPE DEFINITIONS
r19155	r19156
40	41	virtual UINT8 read_c800(address_space &space, UINT16 offset);
41	42	virtual void write_c800(address_space &space, UINT16 offset, UINT8 data);
42	43
43		required_device<device_t> m_ide;
	44	required_device<ide_controller_device> m_ide;
44	45
45	46	UINT8 *m_rom;
46	47	UINT8 m_eeprom[0x1000];

trunk/src/mess/machine/c1551.h
r19155	r19156
85	85	bool tpi1_selected(offs_t offset);
86	86
87	87	required_device<m6510t_device> m_maincpu;
88		required_device<device_t> m_tpi0;
89		required_device<device_t> m_tpi1;
	88	required_device<tpi6525_device> m_tpi0;
	89	required_device<tpi6525_device> m_tpi1;
90	90	required_device<c64h156_device> m_ga;
91	91	required_device<pls100_device> m_pla;
92	92	required_device<legacy_floppy_image_device> m_image;

trunk/src/mess/machine/abc99.h
r19155	r19156
107	107
108	108	required_device<cpu_device> m_maincpu;
109	109	required_device<cpu_device> m_mousecpu;
110		required_device<device_t> m_speaker;
	110	required_device<speaker_sound_device> m_speaker;
111	111
112	112	int m_si;
113	113	int m_si_en;

trunk/src/mess/machine/a2echoii.h
r19155	r19156
11	11
12	12	#include "emu.h"
13	13	#include "machine/a2bus.h"
	14	#include "sound/tms5220.h"
14	15
15	16	//**************************************************************************
16	17	// TYPE DEFINITIONS
r19155	r19156
28	29	// optional information overrides
29	30	virtual machine_config_constructor device_mconfig_additions() const;
30	31
31		required_device<device_t> m_tms;
	32	required_device<tms5220_device> m_tms;
32	33
33	34	protected:
34	35	virtual void device_start();

trunk/src/mess/machine/lux21046.h
r19155	r19156
95	95	private:
96	96	required_device<cpu_device> m_maincpu;
97	97	required_device<z80dma_device> m_dma;
98		required_device<device_t> m_fdc;
	98	required_device<fd1793_device> m_fdc;
99	99	required_device<legacy_floppy_image_device> m_image0;
100	100	required_device<legacy_floppy_image_device> m_image1;
101	101

trunk/src/mess/machine/c64_sfx_sound_expander.h
r19155	r19156
58	58	virtual int c64_exrom_r(offs_t offset, int sphi2, int ba, int rw, int hiram);
59	59
60	60	private:
61		required_device<device_t> m_opl;
	61	required_device<ym3526_device> m_opl;
62	62	required_device<c64_expansion_slot_device> m_exp;
63	63	};
64	64

trunk/src/mess/machine/southbridge.h
r19155	r19156
74	74
75	75	//static IRQ_CALLBACK(at_irq_callback);
76	76	required_device<cpu_device> m_maincpu;
77		required_device<device_t> m_pic8259_master;
78		required_device<device_t> m_pic8259_slave;
79		required_device<device_t> m_dma8237_1;
80		required_device<device_t> m_dma8237_2;
81		required_device<device_t> m_pit8254;
	77	required_device<pic8259_device> m_pic8259_master;
	78	required_device<pic8259_device> m_pic8259_slave;
	79	required_device<device_t> m_dma8237_1; // TODO use correct type
	80	required_device<device_t> m_dma8237_2; // TODO use correct type
	81	required_device<pit8254_device> m_pit8254;
82	82	required_device<at_keyboard_controller_device> m_keybc;
83	83	required_device<isa16_device> m_isabus;
84		required_device<device_t> m_speaker;
	84	required_device<speaker_sound_device> m_speaker;
85	85	required_device<mc146818_device> m_mc146818;
86	86	required_device<pc_kbdc_device> m_pc_kbdc;
87	87	DECLARE_READ8_MEMBER(at_page8_r);

trunk/src/mess/machine/abc_fd2.h
r19155	r19156
54	54	private:
55	55	required_device<cpu_device> m_maincpu;
56	56	required_device<z80pio_device> m_pio;
57		required_device<device_t> m_fdc;
	57	required_device<fd1771_device> m_fdc;
58	58	required_device<legacy_floppy_image_device> m_image0;
59	59	required_device<legacy_floppy_image_device> m_image1;
60	60	};

trunk/src/mess/machine/isa_ibm_mfc.h
r19155	r19156
14	14	#include "machine/isa.h"
15	15	#include "machine/i8255.h"
16	16	#include "machine/i8251.h"
	17	#include "machine/pit8253.h"
17	18	#include "sound/2151intf.h"
18	19
19	20	//**************************************************************************
r19155	r19156
84	85
85	86	required_device<cpu_device> m_cpu;
86	87	required_device<ym2151_device> m_ym2151;
87		required_device<device_t> m_d8253;
	88	required_device<pit8253_device> m_d8253;
88	89	required_device<i8251_device> m_d71051;
89	90	required_device<i8255_device> m_d71055c_0;
90	91	required_device<i8255_device> m_d71055c_1;

trunk/src/mess/machine/a2diskii.h
r19155	r19156
37	37	virtual void write_c0nx(address_space &space, UINT8 offset, UINT8 data);
38	38	virtual UINT8 read_cnxx(address_space &space, UINT8 offset);
39	39
40		required_device<device_t> m_fdc;
	40	required_device<applefdc_base_device> m_fdc;
41	41
42	42	private:
43	43	UINT8 *m_rom;

trunk/src/mess/machine/c1571.h
r19155	r19156
107	107	required_device<via6522_device> m_via0;
108	108	required_device<via6522_device> m_via1;
109	109	required_device<mos6526_device> m_cia;
110		required_device<device_t> m_fdc;
	110	required_device<wd1770_device> m_fdc;
111	111	required_device<c64h156_device> m_ga;
112	112	required_device<legacy_floppy_image_device> m_image;
113	113

trunk/src/mess/machine/kc_d004.h
r19155	r19156
103	103	DECLARE_WRITE8_MEMBER(gide_w);
104	104
105	105	private:
106		required_device<device_t> m_ide;
	106	required_device<ide_controller_device> m_ide;
107	107
108	108	UINT16 m_ide_data;
109	109	int m_lh;

trunk/src/mess/machine/c1581.h
r19155	r19156
80	80
81	81	required_device<cpu_device> m_maincpu;
82	82	required_device<mos6526_device> m_cia;
83		required_device<device_t> m_fdc;
	83	required_device<wd1770_device> m_fdc;
84	84	required_device<legacy_floppy_image_device> m_image;
85	85
86	86	int m_data_out; // serial data out

trunk/src/mess/machine/v1050kb.h
r19155	r19156
73	73
74	74	private:
75	75	required_device<cpu_device> m_maincpu;
76		required_device<device_t> m_discrete;
	76	required_device<discrete_sound_device> m_discrete;
77	77
78	78	UINT8 m_y;
79	79	int m_so;

trunk/src/mess/machine/c2040.h
r19155	r19156
102	102	required_device<m6504_device> m_fdccpu;
103	103	required_device<riot6532_device> m_riot0;
104	104	required_device<riot6532_device> m_riot1;
105		required_device<device_t> m_miot;
	105	required_device<mos6530_device> m_miot;
106	106	required_device<via6522_device> m_via;
107	107	required_device<legacy_floppy_image_device> m_image0;
108	108	optional_device<legacy_floppy_image_device> m_image1;

trunk/src/mess/machine/abc_hdc.c
r19155	r19156
8	8	*********************************************************************/
9	9
10	10	#include "abc_hdc.h"
11		#include "machine/scsibus.h"
12		#include "machine/scsicb.h"
13		#include "machine/scsihd.h"
14	11
15	12
16	13

trunk/src/mess/machine/abc_hdc.h
r19155	r19156
17	17	#include "cpu/z80/z80.h"
18	18	#include "cpu/z80/z80daisy.h"
19	19	#include "machine/abcbus.h"
	20	#include "machine/scsibus.h"
	21	#include "machine/scsicb.h"
	22	#include "machine/scsihd.h"
20	23
21	24
22	25
r19155	r19156
48	51
49	52	private:
50	53	required_device<cpu_device> m_maincpu;
51		required_device<device_t> m_sasibus;
	54	required_device<scsicb_device> m_sasibus;
52	55	};
53	56
54	57

trunk/src/mess/machine/c64_ieee488.h
r19155	r19156
62	62	virtual int c64_game_r(offs_t offset, int sphi2, int ba, int rw, int hiram);
63	63
64	64	private:
65		required_device<device_t> m_tpi;
	65	required_device<tpi6525_device> m_tpi;
66	66	required_device<ieee488_device> m_bus;
67	67	required_device<c64_expansion_slot_device> m_exp;
68	68

trunk/src/mess/machine/s100_dj2db.h
r19155	r19156
61	61
62	62	private:
63	63	// internal state
64		required_device<device_t> m_fdc;
	64	required_device<mb8866_device> m_fdc;
65	65	required_device<com8116_device> m_dbrg;
66	66	device_t* m_floppy0;
67	67	device_t* m_floppy1;

trunk/src/mess/includes/pc4.h
r19155	r19156
22	22	{ }
23	23
24	24	required_device<cpu_device> m_maincpu;
25		required_device<device_t> m_beep;
	25	required_device<beep_device> m_beep;
26	26
27	27	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
28	28	virtual void machine_start();

trunk/src/mess/includes/osi.h
r19155	r19156
34	34	m_cassette(*this, CASSETTE_TAG),
35	35	m_discrete(*this, DISCRETE_TAG),
36	36	m_ram(*this, RAM_TAG),
37		m_video_ram(*this, "video_ram"),
38		m_color_ram(*this, "color_ram"){ }
	37	m_video_ram(*this, "video_ram"),
	38	m_color_ram(*this, "color_ram")
	39	{ }
39	40
40	41	required_device<cpu_device> m_maincpu;
41	42	required_device<cassette_image_device> m_cassette;
42		optional_device<device_t> m_discrete;
	43	optional_device<discrete_sound_device> m_discrete;
43	44	required_device<ram_device> m_ram;
44	45
45	46	virtual void machine_start();
r19155	r19156
76	77	m_beep(*this, BEEPER_TAG)
77	78	{ }
78	79
79		required_device<device_t> m_beep;
	80	required_device<beep_device> m_beep;
80	81
81	82	virtual void machine_start();
82	83
r19155	r19156
93	94	m_floppy(*this, FLOPPY_0)
94	95	{ }
95	96
96		required_device<device_t> m_floppy;
	97	required_device<legacy_floppy_image_device> m_floppy;
97	98
98	99	virtual void machine_start();
99	100

trunk/src/mess/includes/avigo.h
r19155	r19156
39	39
40	40	required_device<cpu_device> m_maincpu;
41	41	required_device<ram_device> m_ram;
42		required_device<device_t> m_speaker;
	42	required_device<speaker_sound_device> m_speaker;
43	43	required_device<ns16550_device> m_uart;
44	44	required_device<rs232_port_device> m_serport;
45	45

trunk/src/mess/includes/trs80m2.h
r19155	r19156
53	53	required_device<z80ctc_device>m_ctc;
54	54	required_device<z80pio_device> m_pio;
55	55	required_device<mc6845_device> m_crtc;
56		required_device<device_t> m_fdc;
	56	required_device<fd1791_device> m_fdc;
57	57	required_device<centronics_device> m_centronics;
58		required_device<device_t> m_floppy;
	58	required_device<legacy_floppy_image_device> m_floppy;
59	59	required_device<ram_device> m_ram;
60	60	required_device<trs80m2_keyboard_device> m_kb;
61	61
r19155	r19156
124	124	{ }
125	125
126	126	required_device<cpu_device> m_subcpu;
127		required_device<device_t> m_pic;
	127	required_device<pic8259_device> m_pic;
128	128
129	129	virtual void machine_start();
130	130

trunk/src/mess/includes/pc8401a.h
r19155	r19156
44	44	required_device<upd1990a_device> m_rtc;
45	45	required_device<sed1330_device> m_lcdc;
46	46	required_device<mc6845_device> m_crtc;
47		required_device<device_t> m_screen_lcd;
	47	required_device<screen_device> m_screen_lcd;
48	48	required_device<ram_device> m_ram;
49	49
50	50	virtual void machine_start();

trunk/src/mess/includes/trs80.h
r19155	r19156
38	38
39	39	required_device<cpu_device> m_maincpu;
40	40	optional_device<centronics_device> m_printer;
41		optional_device<device_t> m_ay31015;
42		optional_device<device_t> m_fdc;
43		required_device<device_t> m_speaker;
	41	optional_device<ay31015_device> m_ay31015;
	42	optional_device<fd1793_device> m_fdc;
	43	required_device<speaker_sound_device> m_speaker;
44	44	required_device<cassette_image_device> m_cass;
45	45	DECLARE_WRITE8_MEMBER ( trs80_ff_w );
46	46	DECLARE_WRITE8_MEMBER ( lnw80_fe_w );

trunk/src/mess/includes/intv.h
r19155	r19156
7	7	#ifndef INTV_H_
8	8	#define INTV_H_
9	9
	10	#include "sound/ay8910.h"
	11	#include "sound/sp0256.h"
	12
10	13	struct intv_sprite_type
11	14	{
12	15	int visible;
r19155	r19156
41	44	{ }
42	45
43	46	required_device<cpu_device> m_maincpu;
44		required_device<device_t> m_intellivoice;
45		required_device<device_t> m_sound;
46		optional_device<device_t> m_ecs_sound;
	47	required_device<sp0256_device> m_intellivoice;
	48	required_device<ay8914_device> m_sound;
	49	optional_device<ay8914_device> m_ecs_sound;
47	50	optional_shared_ptr<UINT16> m_intvkbd_dualport_ram;
48	51	optional_shared_ptr<UINT8> m_videoram;
49	52

trunk/src/mess/includes/apricotp.h
r19155	r19156
73	73	required_device<cpu_device> m_maincpu;
74	74	required_device<cpu_device> m_soundcpu;
75	75	required_device<am9517a_device> m_dmac;
76		required_device<device_t> m_pic;
77		required_device<device_t> m_pit;
	76	required_device<pic8259_device> m_pic;
	77	required_device<pit8253_device> m_pit;
78	78	required_device<z80dart_device> m_sio;
79		required_device<device_t> m_fdc;
	79	required_device<wd2797_device> m_fdc;
80	80	required_device<mc6845_device> m_crtc;
81	81	required_device<ram_device> m_ram;
82		required_device<device_t> m_floppy0;
	82	required_device<legacy_floppy_image_device> m_floppy0;
83	83	required_device<centronics_device> m_centronics;
84	84
85	85	virtual void machine_start();

trunk/src/mess/includes/compis.h
r19155	r19156
144	144	m_video_ram(*this, "video_ram") { }
145	145
146	146	required_device<cpu_device> m_maincpu;
147		required_device<device_t> m_8253;
148		required_device<device_t> m_8254;
149		required_device<device_t> m_8259m;
150		required_device<device_t> m_8259s;
	147	required_device<pit8253_device> m_8253;
	148	required_device<pit8254_device> m_8254;
	149	required_device<pic8259_device> m_8259m;
	150	required_device<pic8259_device> m_8259s;
151	151	required_device<i8255_device> m_8255;
152	152	required_device<centronics_device> m_centronics;
153	153	required_device<i8251_device> m_uart;
154		required_device<device_t> m_rtc;
	154	required_device<mm58274c_device> m_rtc;
155	155	required_device<i8272a_device> m_fdc;
156	156	required_device<upd7220_device> m_crtc;
157	157	DECLARE_READ16_MEMBER(compis_usart_r);

trunk/src/mess/includes/mz80.h
r19155	r19156
20	20	public:
21	21	mz80_state(const machine_config &mconfig, device_type type, const char *tag)
22	22	: driver_device(mconfig, type, tag),
23		m_maincpu(*this, "maincpu"),
24		m_pit(*this, "pit8253"),
25		m_ppi(*this, "ppi8255"),
26		m_cass(*this, CASSETTE_TAG),
27		m_speaker(*this, SPEAKER_TAG)
28		,
	23	m_maincpu(*this, "maincpu"),
	24	m_pit(*this, "pit8253"),
	25	m_ppi(*this, "ppi8255"),
	26	m_cass(*this, CASSETTE_TAG),
	27	m_speaker(*this, SPEAKER_TAG),
29	28	m_p_ram(*this, "p_ram"),
30	29	m_p_videoram(*this, "p_videoram"){ }
31	30
32	31	required_device<cpu_device> m_maincpu;
33		required_device<device_t> m_pit;
	32	required_device<pit8253_device> m_pit;
34	33	required_device<i8255_device> m_ppi;
35	34	required_device<cassette_image_device> m_cass;
36		required_device<device_t> m_speaker;
	35	required_device<speaker_sound_device> m_speaker;
37	36	DECLARE_READ8_MEMBER(mz80k_strobe_r);
38	37	DECLARE_WRITE8_MEMBER(mz80k_strobe_w);
39	38	DECLARE_READ8_MEMBER(mz80k_8255_portb_r);

trunk/src/mess/includes/sage2.h
r19155	r19156
48	48	{ }
49	49
50	50	required_device<cpu_device> m_maincpu;
51		required_device<device_t> m_pic;
	51	required_device<pic8259_device> m_pic;
52	52	required_device<i8251_device> m_usart0;
53	53	required_device<i8251_device> m_usart1;
54	54	required_device<upd765a_device> m_fdc;

trunk/src/mess/includes/at.h
r19155	r19156
101	101	{ }
102	102
103	103	required_device<cpu_device> m_maincpu;
104		optional_device<device_t> m_pic8259_master;
105		optional_device<device_t> m_pic8259_slave;
	104	optional_device<pic8259_device> m_pic8259_master;
	105	optional_device<pic8259_device> m_pic8259_slave;
106	106	optional_device<am9517a_device> m_dma8237_1;
107	107	optional_device<am9517a_device> m_dma8237_2;
108		optional_device<device_t> m_pit8254;
	108	optional_device<pit8254_device> m_pit8254;
109	109	optional_device<cs8221_device> m_cs8221;
110	110	optional_device<cs4031_device> m_cs4031;
111		optional_device<device_t> m_ide;
	111	optional_device<ide_controller_device> m_ide;
112	112	optional_device<at_keyboard_controller_device> m_keybc;
113	113	optional_device<isa16_device> m_isabus;
114		required_device<device_t> m_speaker;
115		optional_device<device_t> m_ram;
	114	required_device<speaker_sound_device> m_speaker;
	115	optional_device<ram_device> m_ram;
116	116	optional_device<mc146818_device> m_mc146818;
117	117	optional_device<pc_kbdc_device> m_pc_kbdc;
118	118	DECLARE_READ8_MEMBER(at_page8_r);

trunk/src/mess/includes/ql.h
r19155	r19156
84	84	required_device<cpu_device> m_ipc;
85	85	required_device<zx8301_device> m_zx8301;
86	86	required_device<zx8302_device> m_zx8302;
87		required_device<device_t> m_speaker;
	87	required_device<speaker_sound_device> m_speaker;
88	88	required_device<microdrive_image_device> m_mdv1;
89	89	required_device<microdrive_image_device> m_mdv2;
90	90	required_device<ram_device> m_ram;
91		required_device<device_t> m_fdc;
	91	required_device<wd1772_device> m_fdc;
92	92	required_device<printer_image_device> m_printer;
93	93
94	94	virtual void machine_start();

trunk/src/mess/includes/psion.h
r19155	r19156
50	50
51	51	required_device<cpu_device> m_maincpu;
52	52	required_device<hd44780_device> m_lcdc;
53		required_device<device_t> m_beep;
	53	required_device<beep_device> m_beep;
54	54	required_device<datapack_device> m_pack1;
55	55	required_device<datapack_device> m_pack2;
56	56

trunk/src/mess/includes/vixen.h
r19155	r19156
32	32	m_srq(1),
33	33	m_atn(1),
34	34	m_rxrdy(0),
35		m_txrdy(0)
36		,
37		m_video_ram(*this, "video_ram"){ }
	35	m_txrdy(0),
	36	m_video_ram(*this, "video_ram")
	37	{ }
38	38
39	39	required_device<cpu_device> m_maincpu;
40		required_device<device_t> m_fdc;
41		required_device<device_t> m_io_i8155;
	40	required_device<fd1797_device> m_fdc;
	41	required_device<i8155_device> m_io_i8155;
42	42	required_device<i8251_device> m_usart;
43		required_device<device_t> m_discrete;
	43	required_device<discrete_sound_device> m_discrete;
44	44	required_device<ieee488_device> m_ieee488;
45	45	required_device<ram_device> m_ram;
46		required_device<device_t> m_floppy0;
47		required_device<device_t> m_floppy1;
	46	required_device<legacy_floppy_image_device> m_floppy0;
	47	required_device<legacy_floppy_image_device> m_floppy1;
48	48
49	49	virtual void machine_start();
50	50	virtual void machine_reset();

trunk/src/mess/includes/ti85.h
r19155	r19156
24	24	{ }
25	25
26	26	required_device<cpu_device> m_maincpu;
27		optional_device<device_t> m_speaker;
28		//optional_device<device_t> m_serial;
	27	optional_device<speaker_sound_device> m_speaker;
	28	//optional_device<> m_serial;
29	29	optional_shared_ptr<UINT8> m_nvram;
30	30
31	31	UINT8 m_LCD_memory_base;

trunk/src/mess/includes/mc1000.h
r19155	r19156
5	5	#include "emu.h"
6	6	#include "cpu/z80/z80.h"
7	7	#include "imagedev/cassette.h"
	8	#include "video/mc6845.h"
8	9	#include "video/mc6847.h"
9	10	#include "sound/ay8910.h"
10	11	#include "machine/ctronics.h"
r19155	r19156
31	32	m_crtc(*this, MC6845_TAG),
32	33	m_centronics(*this, CENTRONICS_TAG),
33	34	m_cassette(*this, CASSETTE_TAG),
34		m_ram(*this, RAM_TAG)
35		,
36		m_mc6845_video_ram(*this, "mc6845_vram"),
37		m_mc6847_video_ram(*this, "mc6847_vram"){ }
	35	m_ram(*this, RAM_TAG),
	36	m_mc6845_video_ram(*this, "mc6845_vram"),
	37	m_mc6847_video_ram(*this, "mc6847_vram")
	38	{ }
38	39
39	40	required_device<cpu_device> m_maincpu;
40	41	required_device<mc6847_base_device> m_vdg;
41		optional_device<device_t> m_crtc;
	42	optional_device<mc6845_device> m_crtc;
42	43	required_device<centronics_device> m_centronics;
43	44	required_device<cassette_image_device> m_cassette;
44	45	required_device<ram_device> m_ram;

trunk/src/mess/includes/rm380z.h
r19155	r19156
87	87
88	88	required_device<cpu_device> m_maincpu;
89	89	required_device<ram_device> m_messram;
90		optional_device<device_t> m_fdc;
	90	optional_device<fd1771_device> m_fdc;
91	91
92	92	rm380z_state(const machine_config &mconfig, device_type type, const char *tag)
93	93	: driver_device(mconfig, type, tag),

trunk/src/mess/includes/exp85.h
r19155	r19156
20	20	required_device<cpu_device> m_maincpu;
21	21	required_device<serial_terminal_device> m_terminal;
22	22	required_device<cassette_image_device> m_cassette;
23		required_device<device_t> m_speaker;
	23	required_device<speaker_sound_device> m_speaker;
24	24
25	25	virtual void machine_start();
26	26

trunk/src/mess/includes/victor9k.h
r19155	r19156
61	61	required_device<cpu_device> m_maincpu;
62	62	required_device<cpu_device> m_fdc_cpu;
63	63	required_device<ieee488_device> m_ieee488;
64		required_device<device_t> m_pic;
	64	required_device<pic8259_device> m_pic;
65	65	required_device<mc6852_device> m_ssda;
66	66	required_device<via6522_device> m_via1;
67	67	required_device<via6522_device> m_via2;
68		required_device<device_t> m_cvsd;
	68	required_device<hc55516_device> m_cvsd;
69	69	required_device<mc6845_device> m_crtc;
70	70	required_device<ram_device> m_ram;
71		required_device<device_t> m_floppy0;
72		required_device<device_t> m_floppy1;
	71	required_device<legacy_floppy_image_device> m_floppy0;
	72	required_device<legacy_floppy_image_device> m_floppy1;
73	73	required_device<victor9k_keyboard_device> m_kb;
74	74
75	75	virtual void machine_start();

trunk/src/mess/includes/llc.h
r19155	r19156
36	36	DECLARE_READ8_MEMBER(llc2_port2_a_r);
37	37	DECLARE_WRITE8_MEMBER(llc2_port1_b_w);
38	38	const UINT8 *m_p_chargen;
39		optional_device<device_t> m_speaker;
	39	optional_device<speaker_sound_device> m_speaker;
40	40	optional_shared_ptr<UINT8> m_p_videoram;
41	41	bool m_rv;
42	42	UINT8 m_term_status;

trunk/src/mess/includes/pc1512.h
r19155	r19156
81	81
82	82	required_device<cpu_device> m_maincpu;
83	83	required_device<am9517a_device> m_dmac;
84		required_device<device_t> m_pic;
85		required_device<device_t> m_pit;
	84	required_device<pic8259_device> m_pic;
	85	required_device<pit8253_device> m_pit;
86	86	required_device<mc146818_device> m_rtc;
87	87	required_device<pc_fdc_xt_device> m_fdc;
88	88	required_device<ins8250_device> m_uart;
89	89	required_device<ams40041_device> m_vdu;
90	90	required_device<centronics_device> m_centronics;
91		required_device<device_t> m_speaker;
	91	required_device<speaker_sound_device> m_speaker;
92	92	required_device<pc1512_keyboard_device> m_kb;
93	93	required_device<ram_device> m_ram;
94	94	required_device<floppy_image_device> m_floppy0;

trunk/src/mess/includes/jtc.h
r19155	r19156
31	31
32	32	required_device<cpu_device> m_maincpu;
33	33	required_device<cassette_image_device> m_cassette;
34		required_device<device_t> m_speaker;
	34	required_device<speaker_sound_device> m_speaker;
35	35	required_device<centronics_device> m_centronics;
36	36
37	37	virtual void machine_start();

trunk/src/mess/includes/mikromik.h
r19155	r19156
50	50	required_device<cpu_device> m_maincpu;
51	51	required_device<i8212_device> m_iop;
52	52	required_device<am9517a_device> m_dmac;
53		required_device<device_t> m_pit;
54		required_device<device_t> m_crtc;
	53	required_device<pit8253_device> m_pit;
	54	required_device<i8275_device> m_crtc;
55	55	required_device<upd765a_device> m_fdc;
56	56	required_device<upd7201_device> m_mpsc;
57	57	required_device<upd7220_device> m_hgdc;
58		required_device<device_t> m_speaker;
	58	required_device<speaker_sound_device> m_speaker;
59	59	required_device<floppy_image_device> m_floppy0;
60	60	required_device<floppy_image_device> m_floppy1;
61	61	required_device<ram_device> m_ram;

trunk/src/mess/includes/xor100.h
r19155	r19156
3	3	#ifndef __XOR100__
4	4	#define __XOR100__
5	5
	6	#include "emu.h"
	7	#include "cpu/z80/z80.h"
	8	#include "formats/basicdsk.h"
	9	#include "imagedev/flopdrv.h"
6	10	#include "machine/ram.h"
	11	#include "machine/com8116.h"
	12	#include "machine/ctronics.h"
	13	#include "machine/i8255.h"
	14	#include "machine/i8251.h"
	15	#include "machine/terminal.h"
	16	#include "machine/wd17xx.h"
7	17	#include "machine/z80ctc.h"
8	18
9	19	#define SCREEN_TAG "screen"
r19155	r19156
35	45	required_device<cpu_device> m_maincpu;
36	46	required_device<com8116_device> m_dbrg;
37	47	required_device<i8251_device> m_uart_b;
38		required_device<device_t> m_fdc;
	48	required_device<fd1795_device> m_fdc;
39	49	required_device<z80ctc_device> m_ctc;
40	50	required_device<ram_device> m_ram;
41	51	required_device<generic_terminal_device> m_terminal;
42		required_device<device_t> m_floppy0;
43		required_device<device_t> m_floppy1;
	52	required_device<legacy_floppy_image_device> m_floppy0;
	53	required_device<legacy_floppy_image_device> m_floppy1;
44	54
45	55	virtual void machine_start();
46	56	virtual void machine_reset();

trunk/src/mess/includes/portfoli.h
r19155	r19156
34	34	m_ppi(*this, M82C55A_TAG),
35	35	m_uart(*this, M82C50A_TAG),
36	36	m_speaker(*this, SPEAKER_TAG),
37		m_timer_tick(*this, TIMER_TICK_TAG)
38		,
39		m_contrast(*this, "contrast"){ }
	37	m_timer_tick(*this, TIMER_TICK_TAG),
	38	m_contrast(*this, "contrast")
	39	{ }
40	40
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	44	required_device<ins8250_device> m_uart;
45		required_device<device_t> m_speaker;
	45	required_device<speaker_sound_device> m_speaker;
46	46	required_device<timer_device> m_timer_tick;
47	47
48	48	virtual void machine_start();

trunk/src/mess/includes/super80.h
r19155	r19156
34	34	required_device<cpu_device> m_maincpu;
35	35	required_device<z80pio_device> m_pio;
36	36	required_device<cassette_image_device> m_cass;
37		required_device<device_t> m_wave;
38		required_device<device_t> m_speaker;
	37	required_device<wave_device> m_wave;
	38	required_device<speaker_sound_device> m_speaker;
39	39	required_device<centronics_device> m_centronics;
40	40	optional_device<mc6845_device> m_6845;
41	41	DECLARE_READ8_MEMBER( super80v_low_r );

trunk/src/mess/includes/atarist.h
r19155	r19156
77	77	m_fdc(*this, WD1772_TAG),
78	78	m_mfp(*this, MC68901_TAG),
79	79	m_centronics(*this, CENTRONICS_TAG),
80		//m_rs232(*this, RS232_TAG),
81	80	m_ram(*this, RAM_TAG),
82	81	m_acia_ikbd_irq(1),
83	82	m_acia_midi_irq(1),
r19155	r19156
93	92	required_device<wd1772_t> m_fdc;
94	93	required_device<mc68901_device> m_mfp;
95	94	required_device<centronics_device> m_centronics;
96		//required_device<device_t> m_rs232;
97	95	required_device<ram_device> m_ram;
98	96
99	97	void machine_start();

trunk/src/mess/includes/vector06.h
r19155	r19156
35	35
36	36	required_device<cpu_device> m_maincpu;
37	37	required_device<cassette_image_device> m_cass;
38		required_device<device_t> m_fdc;
	38	required_device<fd1793_device> m_fdc;
39	39	required_device<i8255_device> m_ppi;
40	40	required_device<i8255_device> m_ppi2;
41	41	required_device<ram_device> m_ram;

trunk/src/mess/includes/x07.h
r19155	r19156
167	167
168	168	required_device<cpu_device> m_maincpu;
169	169	required_device<printer_image_device> m_printer;
170		required_device<device_t> m_beep;
	170	required_device<beep_device> m_beep;
171	171	required_device<ram_device> m_ram;
172	172	required_device<cassette_image_device> m_cassette;
173	173

trunk/src/mess/includes/sorcerer.h
r19155	r19156
74	74	required_device<cpu_device> m_maincpu;
75	75	required_device<cassette_image_device> m_cass1;
76	76	required_device<cassette_image_device> m_cass2;
77		required_device<device_t> m_wave1;
78		required_device<device_t> m_wave2;
	77	required_device<wave_device> m_wave1;
	78	required_device<wave_device> m_wave2;
79	79	required_device<dac_device> m_dac;
80		required_device<device_t> m_uart;
	80	required_device<ay31015_device> m_uart;
81	81	required_device<centronics_device> m_centronics;
82	82	required_device<ram_device> m_ram;
83	83	required_ioport m_iop_config;

trunk/src/mess/includes/studio2.h
r19155	r19156
29	29	{ }
30	30
31	31	required_device<cosmac_device> m_maincpu;
32		required_device<device_t> m_speaker;
	32	required_device<beep_device> m_speaker;
33	33	optional_device<cdp1861_device> m_vdc;
34	34
35	35	virtual void machine_start();

trunk/src/mess/includes/kaypro.h
r19155	r19156
36	36	required_device<z80sio_device> m_sio;
37	37	optional_device<z80sio_device> m_sio2x;
38	38	required_device<centronics_device> m_centronics;
39		required_device<device_t> m_fdc;
	39	required_device<fd1793_device> m_fdc;
40	40	optional_device<mc6845_device> m_crtc;
41		required_device<device_t> m_beep;
	41	required_device<beep_device> m_beep;
42	42	DECLARE_READ8_MEMBER(kaypro2x_87_r);
43	43	DECLARE_READ8_MEMBER(kaypro2x_system_port_r);
44	44	DECLARE_READ8_MEMBER(kaypro2x_status_r);

trunk/src/mess/includes/apricotf.h
r19155	r19156
56	56	required_device<cpu_device> m_maincpu;
57	57	required_device<z80ctc_device> m_ctc;
58	58	required_device<z80dart_device> m_sio;
59		required_device<device_t> m_fdc;
60		required_device<device_t> m_floppy0;
	59	required_device<wd2797_device> m_fdc;
	60	required_device<legacy_floppy_image_device> m_floppy0;
61	61	required_device<centronics_device> m_centronics;
62	62	int m_ctc_int;
63	63	int m_sio_int;

trunk/src/mess/includes/mbee.h
r19155	r19156
42	42	required_device<cpu_device> m_maincpu;
43	43	required_device<z80pio_device> m_pio;
44	44	required_device<cassette_image_device> m_cass;
45		required_device<device_t> m_wave;
46		required_device<device_t> m_speaker;
	45	required_device<wave_device> m_wave;
	46	required_device<speaker_sound_device> m_speaker;
47	47	required_device<centronics_device> m_printer;
48	48	required_device<mc6845_device> m_crtc;
49		optional_device<device_t> m_fdc;
50		optional_device<device_t> m_rtc;
	49	optional_device<wd2793_device> m_fdc;
	50	optional_device<mc146818_device> m_rtc;
51	51	DECLARE_WRITE8_MEMBER( mbee_04_w );
52	52	DECLARE_WRITE8_MEMBER( mbee_06_w );
53	53	DECLARE_READ8_MEMBER( mbee_07_r );

trunk/src/mess/includes/pc8001.h
r19155	r19156
42	42
43	43	required_device<cpu_device> m_maincpu;
44	44	required_device<upd1990a_device> m_rtc;
45		required_device<device_t> m_dma;
	45	required_device<i8257_device> m_dma;
46	46	required_device<upd3301_device> m_crtc;
47	47	required_device<cassette_image_device> m_cassette;
48	48	required_device<centronics_device> m_centronics;
49		required_device<device_t> m_speaker;
	49	required_device<speaker_sound_device> m_speaker;
50	50	required_device<ram_device> m_ram;
51	51
52	52	virtual void machine_start();

trunk/src/mess/includes/coco.h
r19155	r19156
101	101	required_device<pia6821_device> m_pia_0;
102	102	required_device<pia6821_device> m_pia_1;
103	103	required_device<dac_device> m_dac;
104		required_device<device_t> m_wave;
	104	required_device<wave_device> m_wave;
105	105	required_device<cococart_slot_device> m_cococart;
106	106	required_device<ram_device> m_ram;
107	107	required_device<cassette_image_device> m_cassette;

trunk/src/mess/includes/p2000t.h
r19155	r19156
24	24	{ }
25	25
26	26	required_device<cpu_device> m_maincpu;
27		required_device<device_t> m_speaker;
	27	required_device<speaker_sound_device> m_speaker;
28	28	DECLARE_READ8_MEMBER(p2000t_port_000f_r);
29	29	DECLARE_READ8_MEMBER(p2000t_port_202f_r);
30	30	DECLARE_WRITE8_MEMBER(p2000t_port_101f_w);

trunk/src/mess/includes/fidelz80.h
r19155	r19156
9	9	#ifndef _FIDELZ80_H_
10	10	#define _FIDELZ80_H_
11	11
	12	#include "sound/beep.h"
	13	#include "sound/s14001a.h"
	14
12	15	class fidelz80_state : public driver_device
13	16	{
14	17	public:
r19155	r19156
22	25	{ }
23	26
24	27	required_device<cpu_device> m_maincpu;
25		optional_device<device_t> m_speech;
26		optional_device<device_t> m_beep;
	28	optional_device<s14001a_device> m_speech;
	29	optional_device<beep_device> m_beep;
27	30	optional_device<cpu_device> m_i8041;
28	31	optional_device<i8243_device> m_i8243;
29	32

trunk/src/mess/includes/osborne1.h
r19155	r19156
42	42	required_device<cpu_device> m_maincpu;
43	43	required_device<pia6821_device> m_pia0;
44	44	required_device<pia6821_device> m_pia1;
45		required_device<device_t> m_fdc;
46		required_device<device_t> m_beep;
	45	required_device<mb8877_device> m_fdc;
	46	required_device<beep_device> m_beep;
47	47	required_device<ram_device> m_ram;
48	48	required_device<ieee488_device> m_ieee;
49	49

trunk/src/mess/includes/dai.h
r19155	r19156
58	58	m_sound(*this, "custom")
59	59	{ }
60	60
61		required_device<device_t> m_pit;
	61	required_device<pit8253_device> m_pit;
62	62	required_device<tms5501_device> m_tms5501;
63	63	required_device<dai_sound_device> m_sound;
64	64

trunk/src/mess/includes/abc80.h
r19155	r19156
77	77
78	78	required_device<cpu_device> m_maincpu;
79	79	required_device<z80pio_device> m_pio;
80		required_device<device_t> m_psg;
	80	required_device<sn76477_device> m_psg;
81	81	required_device<cassette_image_device> m_cassette;
82	82	required_device<abcbus_slot_device> m_bus;
83	83	required_device<abc80_keyboard_device> m_kb;

trunk/src/mess/includes/kc.h
r19155	r19156
69	69	required_device<z80pio_device> m_z80pio;
70	70	required_device<z80ctc_device> m_z80ctc;
71	71	required_device<ram_device> m_ram;
72		required_device<device_t> m_speaker;
	72	required_device<speaker_sound_device> m_speaker;
73	73	required_device<cassette_image_device> m_cassette;
74	74
75	75	// defined in machine/kc.c

trunk/src/mess/includes/mbc55x.h
r19155	r19156
103	103	required_device<cpu_device> m_maincpu;
104	104	required_device<mc6845_device> m_crtc;
105	105	required_device<i8251_device> m_kb_uart;
106		required_device<device_t> m_pit;
	106	required_device<pit8253_device> m_pit;
107	107	required_device<i8255_device> m_ppi;
108		required_device<device_t> m_pic;
109		required_device<device_t> m_fdc;
110		required_device<device_t> m_speaker;
	108	required_device<pic8259_device> m_pic;
	109	required_device<fd1793_device> m_fdc;
	110	required_device<speaker_sound_device> m_speaker;
111	111	required_device<ram_device> m_ram;
112	112	//DECLARE_READ8_MEMBER(pic8259_r);
113	113	//DECLARE_WRITE8_MEMBER(pic8259_w);

trunk/src/mess/includes/tek405x.h
r19155	r19156
33	33	{ }
34	34
35	35	required_device<cpu_device> m_maincpu;
36		required_device<device_t> m_gpib_pia;
37		required_device<device_t> m_com_pia;
	36	required_device<pia6821_device> m_gpib_pia;
	37	required_device<pia6821_device> m_com_pia;
38	38	required_device<acia6850_device> m_acia;
39	39	required_device<ieee488_device> m_gpib;
40		required_device<device_t> m_speaker;
	40	required_device<speaker_sound_device> m_speaker;
41	41	required_device<ram_device> m_ram;
42	42
43	43	virtual void machine_start();

trunk/src/mess/includes/plus4.h
r19155	r19156
59	59	optional_device<acia6551_device> m_acia;
60	60	optional_device<mos6529_device> m_spi_user;
61	61	required_device<mos6529_device> m_spi_kb;
62		optional_device<device_t> m_t6721;
	62	optional_device<t6721_device> m_t6721;
63	63	required_device<cbm_iec_device> m_iec;
64	64	required_device<plus4_expansion_slot_device> m_exp;
65	65	optional_device<plus4_user_port_device> m_user;

trunk/src/mess/includes/tsispch.h
r19155	r19156
9	9	#ifndef _TSISPCH_H_
10	10	#define _TSISPCH_H_
11	11
	12	#include "machine/i8251.h"
	13	#include "machine/pic8259.h"
12	14	#include "machine/terminal.h"
13	15
14	16	class tsispch_state : public driver_device
r19155	r19156
25	27
26	28	required_device<cpu_device> m_maincpu;
27	29	required_device<cpu_device> m_dsp;
28		required_device<device_t> m_terminal;
29		required_device<device_t> m_uart;
30		required_device<device_t> m_pic;
	30	required_device<generic_terminal_device> m_terminal;
	31	required_device<i8251_device> m_uart;
	32	required_device<pic8259_device> m_pic;
31	33
32	34	UINT8 m_infifo[32]; // input fifo
33	35	UINT8 m_infifo_tail_ptr; // " tail

trunk/src/mess/includes/dgnalpha.h
r19155	r19156
45	45	}
46	46
47	47	required_device<pia6821_device> m_pia_2;
48		required_device<device_t> m_ay8912;
49		required_device<device_t> m_fdc;
	48	required_device<ay8912_device> m_ay8912;
	49	required_device<wd2797_device> m_fdc;
50	50
51	51	static const pia6821_interface pia2_config;
52	52	static const ay8910_interface ay8912_interface;

trunk/src/mess/includes/irisha.h
r19155	r19156
24	24	m_speaker(*this, SPEAKER_TAG)
25	25	{ }
26	26
27		required_device<device_t> m_pit;
28		required_device<device_t> m_speaker;
	27	required_device<pit8253_device> m_pit;
	28	required_device<speaker_sound_device> m_speaker;
29	29
30	30	int m_keyboard_mask;
31	31	UINT8 m_keypressed;

trunk/src/mess/includes/special.h
r19155	r19156
73	73	UINT8 m_RC_register;
74	74	required_device<cpu_device> m_maincpu;
75	75	optional_device<i8255_device> m_ppi;
76		optional_device<device_t> m_fdc;
	76	optional_device<fd1793_device> m_fdc;
77	77	optional_device<dac_device> m_dac;
78	78	optional_device<cassette_image_device> m_cass;
79	79	optional_device<ram_device> m_ram;

trunk/src/mess/includes/abc80x.h
r19155	r19156
93	93	required_device<z80ctc_device> m_ctc;
94	94	required_device<z80dart_device> m_dart;
95	95	required_device<z80dart_device> m_sio;
96		optional_device<device_t> m_discrete;
	96	optional_device<discrete_sound_device> m_discrete;
97	97	optional_device<cassette_image_device> m_cassette;
98	98	required_device<ram_device> m_ram;
99	99
r19155	r19156
212	212	{ }
213	213
214	214	required_device<mc6845_device> m_crtc;
215		optional_device<device_t> m_abc77;
	215	optional_device<abc77_device> m_abc77;
216	216
217	217	DECLARE_DRIVER_INIT(driver_init);
218	218	virtual void machine_start();
r19155	r19156
255	255
256	256	required_device<mc6845_device> m_crtc;
257	257	required_device<e0516_device> m_rtc;
258		optional_device<device_t> m_abc77;
	258	optional_device<abc77_device> m_abc77;
259	259
260	260	DECLARE_DRIVER_INIT(driver_init);
261	261	virtual void machine_start();

trunk/src/mess/includes/pes.h
r19155	r19156
10	10	#define _PES_H_
11	11
12	12	#include "machine/terminal.h"
	13	#include "sound/tms5220.h"
13	14
14	15	class pes_state : public driver_device
15	16	{
r19155	r19156
23	24
24	25	required_device<cpu_device> m_maincpu;
25	26	required_device<generic_terminal_device> m_terminal;
26		required_device<device_t> m_speech;
	27	required_device<tms5220_device> m_speech;
27	28
28	29	UINT8 m_wsstate; // /WS
29	30	UINT8 m_rsstate; // /RS

trunk/src/mess/includes/lisa.h
r19155	r19156
99	99	m_fdc_rom(*this,"fdc_rom"),
100	100	m_fdc_ram(*this,"fdc_ram") { }
101	101
102		required_device<device_t> m_maincpu;
	102	required_device<cpu_device> m_maincpu;
103	103	required_device<scc8530_t> m_scc;
104	104
105	105	required_shared_ptr<UINT8> m_fdc_rom;

trunk/src/mess/includes/amstrad.h
r19155	r19156
7	7	#ifndef AMSTRAD_H_
8	8	#define AMSTRAD_H_
9	9
	10	#include "sound/ay8910.h"
10	11	#include "machine/upd765.h"
11	12	#include "video/mc6845.h"
12	13	#include "machine/i8255.h"
r19155	r19156
107	108	{ }
108	109
109	110	required_device<cpu_device> m_maincpu;
110		required_device<device_t> m_ay;
	111	required_device<ay8912_device> m_ay;
111	112	optional_device<upd765_family_device> m_fdc; // not on a GX4000
112	113	required_device<mc6845_device> m_crtc;
113	114	required_device<screen_device> m_screen;

trunk/src/mess/includes/kyocera.h
r19155	r19156
84	84	required_device<hd44102_device> m_lcdc8;
85	85	required_device<hd44102_device> m_lcdc9;
86	86	required_device<centronics_device> m_centronics;
87		required_device<device_t> m_speaker;
	87	required_device<speaker_sound_device> m_speaker;
88	88	required_device<cassette_image_device> m_cassette;
89	89	required_device<ram_device> m_ram;
90	90
r19155	r19156
173	173	required_device<rp5c01_device> m_rtc;
174	174	required_device<hd61830_device> m_lcdc;
175	175	required_device<centronics_device> m_centronics;
176		required_device<device_t> m_speaker;
	176	required_device<speaker_sound_device> m_speaker;
177	177	required_device<cassette_image_device> m_cassette;
178	178	required_device<ram_device> m_ram;
179	179

trunk/src/mess/includes/mpf1.h
r19155	r19156
35	35
36	36	required_device<cpu_device> m_maincpu;
37	37	required_device<z80ctc_device> m_ctc;
38		required_device<device_t> m_speaker;
	38	required_device<speaker_sound_device> m_speaker;
39	39	required_device<cassette_image_device> m_cassette;
40	40
41	41	virtual void machine_start();

trunk/src/mess/includes/micronic.h
r19155	r19156
33	33
34	34	required_device<cpu_device> m_maincpu;
35	35	required_device<hd61830_device> m_lcdc;
36		required_device<device_t> m_beep;
	36	required_device<beep_device> m_beep;
37	37	required_device<mc146818_device> m_rtc;
38	38	required_device<ram_device> m_ram;
39	39

trunk/src/mess/includes/msx.h
r19155	r19156
112	112
113	113	optional_device<v9938_device> m_v9938;
114	114	required_device<cassette_image_device> m_cass;
115		required_device<device_t> m_ym;
	115	required_device<ym2413_device> m_ym;
116	116	required_device<dac_device> m_dac;
117	117	optional_device<rp5c01_device> m_rtc;
118	118	DECLARE_READ8_MEMBER(msx_psg_port_a_r);

trunk/src/mess/includes/beta.h
r19155	r19156
27	27	{ }
28	28
29	29	required_device<cpu_device> m_maincpu;
30		required_device<device_t> m_speaker;
	30	required_device<speaker_sound_device> m_speaker;
31	31
32	32	virtual void machine_start();
33	33

trunk/src/mess/includes/v1050.h
r19155	r19156
15	15	#include "machine/i8255.h"
16	16	#include "machine/msm58321.h"
17	17	#include "machine/ram.h"
	18	#include "machine/s1410.h"
	19	#include "machine/scsibus.h"
18	20	#include "machine/scsicb.h"
	21	#include "machine/scsihd.h"
19	22	#include "machine/v1050kb.h"
20	23	#include "machine/wd1772.h"
21	24	#include "video/mc6845.h"

trunk/src/mess/includes/wangpc.h
r19155	r19156
77	77
78	78	required_device<cpu_device> m_maincpu;
79	79	required_device<am9517a_device> m_dmac;
80		required_device<device_t> m_pic;
	80	required_device<pic8259_device> m_pic;
81	81	required_device<i8255_device> m_ppi;
82		required_device<device_t> m_pit;
	82	required_device<pit8253_device> m_pit;
83	83	required_device<im6402_device> m_uart;
84	84	required_device<mc2661_device> m_epci;
85	85	required_device<upd765a_device> m_fdc;

trunk/src/mess/includes/cosmicos.h
r19155	r19156
54	54	required_device<cdp1864_device> m_cti;
55	55	required_device<dm9368_device> m_led;
56	56	required_device<cassette_image_device> m_cassette;
57		required_device<device_t> m_speaker;
	57	required_device<speaker_sound_device> m_speaker;
58	58	required_device<ram_device> m_ram;
59	59
60	60	virtual void machine_start();

trunk/src/mess/includes/tiki100.h
r19155	r19156
46	46
47	47	required_device<cpu_device> m_maincpu;
48	48	required_device<z80ctc_device> m_ctc;
49		required_device<device_t> m_fdc;
	49	required_device<fd1797_device> m_fdc;
50	50	required_device<ram_device> m_ram;
51		required_device<device_t> m_floppy0;
52		required_device<device_t> m_floppy1;
	51	required_device<legacy_floppy_image_device> m_floppy0;
	52	required_device<legacy_floppy_image_device> m_floppy1;
53	53
54	54	virtual void machine_start();
55	55

trunk/src/mess/includes/bullet.h
r19155	r19156
48	48	required_device<z80ctc_device> m_ctc;
49	49	required_device<z80dart_device> m_dart;
50	50	required_device<z80dma_device> m_dmac;
51		required_device<device_t> m_fdc;
	51	required_device<mb8877_device> m_fdc;
52	52	required_device<ram_device> m_ram;
53		required_device<device_t> m_floppy0;
54		required_device<device_t> m_floppy1;
	53	required_device<legacy_floppy_image_device> m_floppy0;
	54	required_device<legacy_floppy_image_device> m_floppy1;
55	55	required_device<serial_terminal_device> m_terminal;
56	56	required_device<centronics_device> m_centronics;
57	57

trunk/src/mess/includes/ace.h
r19155	r19156
33	33
34	34	required_device<cpu_device> m_maincpu;
35	35	required_device<i8255_device> m_ppi;
36		required_device<device_t> m_speaker;
	36	required_device<speaker_sound_device> m_speaker;
37	37	required_device<cassette_image_device> m_cassette;
38	38	required_device<centronics_device> m_centronics;
39	39	required_device<ram_device> m_ram;

trunk/src/mess/includes/x1.h
r19155	r19156
190	190
191	191	required_device<cpu_device> m_x1_cpu;
192	192	required_device<cassette_image_device> m_cass;
193		required_device<device_t> m_fdc;
	193	required_device<mb8877_device> m_fdc;
194	194	required_device<mc6845_device> m_crtc;
195	195	required_device<z80ctc_device> m_ctc;
196	196	DECLARE_DRIVER_INIT(x1_kanji);

trunk/src/mess/includes/abc1600.h
r19155	r19156
83	83	required_device<z80dart_device> m_dart;
84	84	required_device<scc8530_t> m_scc;
85	85	required_device<z8536_device> m_cio;
86		required_device<device_t> m_fdc;
	86	required_device<fd1797_device> m_fdc;
87	87	required_device<e0516_device> m_rtc;
88	88	required_device<nmc9306_device> m_nvram;
89	89	required_device<mc6845_device> m_crtc;
90	90	required_device<ram_device> m_ram;
91		required_device<device_t> m_floppy;
	91	required_device<legacy_floppy_image_device> m_floppy;
92	92	required_device<abc1600bus_slot_device> m_bus0i;
93	93	required_device<abc1600bus_slot_device> m_bus0x;
94	94	required_device<abc1600bus_slot_device> m_bus1;

trunk/src/mess/includes/vidbrain.h
r19155	r19156
40	40	required_device<cpu_device> m_maincpu;
41	41	required_device<f3853_device> m_smi;
42	42	required_device<uv201_device> m_uv;
43		required_device<device_t> m_discrete;
	43	required_device<discrete_sound_device> m_discrete;
44	44	required_device<dac_device> m_dac;
45	45	required_device<videobrain_expansion_slot_device> m_exp;
46	46

trunk/src/mess/includes/atom.h
r19155	r19156
55	55	required_device<mc6847_base_device> m_vdg;
56	56	required_device<cassette_image_device> m_cassette;
57	57	required_device<centronics_device> m_centronics;
58		required_device<device_t> m_speaker;
	58	required_device<speaker_sound_device> m_speaker;
59	59
60	60	virtual void machine_start();
61	61	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mess/includes/lc80.h
r19155	r19156
33	33	required_device<cpu_device> m_maincpu;
34	34	required_device<z80pio_device> m_pio2;
35	35	required_device<cassette_image_device> m_cassette;
36		required_device<device_t> m_speaker;
	36	required_device<speaker_sound_device> m_speaker;
37	37	required_device<ram_device> m_ram;
38	38
39	39	virtual void machine_start();

trunk/src/mess/includes/tdv2324.h
r19155	r19156
55	55	m_sio(*this, MK3887N4_TAG),
56	56	m_pic(*this, P8259A_TAG),
57	57	m_pit0(*this, P8253_5_0_TAG),
58		m_pit1(*this, P8253_5_1_TAG)
59		,
60		m_video_ram(*this, "video_ram"){ }
	58	m_pit1(*this, P8253_5_1_TAG),
	59	m_video_ram(*this, "video_ram")
	60	{ }
61	61
62	62	required_device<cpu_device> m_maincpu;
63	63	required_device<cpu_device> m_subcpu;
64	64	required_device<cpu_device> m_fdccpu;
65	65	required_device<z80dart_device> m_sio;
66		required_device<device_t> m_pic;
67		required_device<device_t> m_pit0;
68		required_device<device_t> m_pit1;
	66	required_device<pic8259_device> m_pic;
	67	required_device<pit8253_device> m_pit0;
	68	required_device<pit8253_device> m_pit1;
69	69
70	70	virtual void video_start();
71	71	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mess/includes/ob68k1a.h
r19155	r19156
29	29
30	30	required_device<cpu_device> m_maincpu;
31	31	required_device<com8116_device> m_dbrg;
32		required_device<device_t> m_acia0;
	32	required_device<acia6850_device> m_acia0;
33	33	required_device<pia6821_device> m_pia0;
34	34	required_device<pia6821_device> m_pia1;
35	35	required_device<serial_terminal_device> m_terminal;

trunk/src/mess/includes/tandy2k.h
r19155	r19156
57	57	m_floppy0(*this, I8272A_TAG ":0:525qd"),
58	58	m_floppy1(*this, I8272A_TAG ":1:525qd"),
59	59	m_kb(*this, TANDY2K_KEYBOARD_TAG),
60		m_kbdclk(0)
61		,
62		m_hires_ram(*this, "hires_ram"),
63		m_char_ram(*this, "char_ram"){ }
	60	m_kbdclk(0),
	61	m_hires_ram(*this, "hires_ram"),
	62	m_char_ram(*this, "char_ram")
	63	{ }
64	64
65	65	required_device<cpu_device> m_maincpu;
66	66	required_device<i8251_device> m_uart;
67		required_device<device_t> m_pit;
	67	required_device<pit8253_device> m_pit;
68	68	required_device<i8272a_device> m_fdc;
69		required_device<device_t> m_pic0;
70		required_device<device_t> m_pic1;
	69	required_device<pic8259_device> m_pic0;
	70	required_device<pic8259_device> m_pic1;
71	71	required_device<crt9007_device> m_vpac;
72	72	required_device<crt9212_device> m_drb0;
73	73	required_device<crt9212_device> m_drb1;
74	74	required_device<crt9021_device> m_vac;
75	75	required_device<centronics_device> m_centronics;
76		required_device<device_t> m_speaker;
	76	required_device<speaker_sound_device> m_speaker;
77	77	required_device<ram_device> m_ram;
78	78	required_device<floppy_image_device> m_floppy0;
79	79	required_device<floppy_image_device> m_floppy1;

trunk/src/mess/includes/apple2gs.h
r19155	r19156
66	66
67	67	required_device<cpu_device> m_maincpu;
68	68	required_device<es5503_device> m_es5503;
69		required_device<device_t> m_fdc;
	69	required_device<applefdc_base_device> m_fdc;
70	70
71	71	UINT8 *m_slowmem;
72	72	UINT8 m_newvideo;

trunk/src/mess/includes/cybiko.h
r19155	r19156
73	73	int cybiko_rs232_rx_queue();
74	74
75	75	required_device<hd66421_device> m_crtc;
76		required_device<device_t> m_speaker;
77		required_device<device_t> m_rtc;
78		optional_device<device_t> m_flash1;
	76	required_device<speaker_sound_device> m_speaker;
	77	required_device<pcf8593_device> m_rtc;
	78	optional_device<at45db041_device> m_flash1;
79	79	DECLARE_DRIVER_INIT(cybikoxt);
80	80	DECLARE_DRIVER_INIT(cybikov1);
81	81	DECLARE_DRIVER_INIT(cybikov2);

trunk/src/mess/drivers/sc2.c
r19155	r19156
23	23	m_beep(*this, BEEPER_TAG)
24	24	{ }
25	25
26		required_device<device_t> m_beep;
	26	required_device<beep_device> m_beep;
27	27	DECLARE_READ8_MEMBER(pio_port_a_r);
28	28	DECLARE_READ8_MEMBER(pio_port_b_r);
29	29	DECLARE_WRITE8_MEMBER(pio_port_a_w);

trunk/src/mess/drivers/mk2.c
r19155	r19156
65	65	{ }
66	66
67	67	required_device<cpu_device> m_maincpu;
68		required_device<device_t> m_speaker;
69		required_device<device_t> m_miot;
	68	required_device<speaker_sound_device> m_speaker;
	69	required_device<mos6530_device> m_miot;
70	70	DECLARE_READ8_MEMBER(mk2_read_a);
71	71	DECLARE_WRITE8_MEMBER(mk2_write_a);
72	72	DECLARE_READ8_MEMBER(mk2_read_b);

trunk/src/mess/drivers/chessmst.c
r19155	r19156
24	24	m_speaker(*this, SPEAKER_TAG)
25	25	{ }
26	26
27		required_device<device_t> m_speaker;
	27	required_device<speaker_sound_device> m_speaker;
28	28
29	29	UINT16 m_matrix;
30	30	UINT16 m_led_sel;

trunk/src/mess/drivers/vtech1.c
r19155	r19156
160	160	m_mc6847(*this, "mc6847"),
161	161	m_speaker(*this, SPEAKER_TAG),
162	162	m_cassette(*this, CASSETTE_TAG),
163		m_printer(*this, "printer")
164		,
165		m_videoram(*this, "videoram"){ }
	163	m_videoram(*this, "videoram"){ }
166	164
167	165	/* devices */
168	166	required_device<mc6847_base_device> m_mc6847;
169		optional_device<device_t> m_speaker;
	167	optional_device<speaker_sound_device> m_speaker;
170	168	optional_device<cassette_image_device> m_cassette;
171		optional_device<device_t> m_printer;
172	169
173	170	UINT8 *m_ram;
174	171	UINT32 m_ram_size;

trunk/src/mess/drivers/apricot.c
r19155	r19156
44	44
45	45	required_device<cpu_device> m_maincpu;
46	46	required_device<ram_device> m_ram;
47		required_device<device_t> m_sn;
	47	required_device<sn76489_device> m_sn;
48	48	required_device<mc6845_device> m_crtc;
49	49	required_device<i8255_device> m_ppi;
50		required_device<device_t> m_pic;
51		required_device<device_t> m_pit;
52		required_device<device_t> m_z80sio;
53		required_device<device_t> m_fdc;
	50	required_device<pic8259_device> m_pic;
	51	required_device<pit8253_device> m_pit;
	52	required_device<z80sio_device> m_z80sio;
	53	required_device<wd2793_device> m_fdc;
54	54	DECLARE_READ8_MEMBER(apricot_sysctrl_r);
55	55	DECLARE_WRITE8_MEMBER(apricot_sysctrl_w);
56	56	DECLARE_WRITE_LINE_MEMBER(apricot_pit8253_out1);

trunk/src/mess/drivers/junior.c
r19155	r19156
36	36	m_riot(*this, "riot")
37	37	{ }
38	38
39		required_device<device_t> m_riot;
	39	required_device<riot6532_device> m_riot;
40	40	DECLARE_READ8_MEMBER(junior_riot_a_r);
41	41	DECLARE_READ8_MEMBER(junior_riot_b_r);
42	42	DECLARE_WRITE8_MEMBER(junior_riot_a_w);

trunk/src/mess/drivers/tm990189.c
r19155	r19156
81	81	{ }
82	82
83	83	required_device<tms9980a_device> m_tms9980a;
84		required_device<device_t> m_speaker;
	84	required_device<speaker_sound_device> m_speaker;
85	85	required_device<cassette_image_device> m_cass;
86	86	optional_device<tms9918_device> m_tms9918;
87	87

trunk/src/mess/drivers/eacc.c
r19155	r19156
73	73	bool m_cb2;
74	74	bool m_nmi;
75	75	required_device<cpu_device> m_maincpu;
76		required_device<device_t> m_pia;
	76	required_device<pia6821_device> m_pia;
77	77	required_shared_ptr<UINT8> m_p_nvram;
78	78	virtual void machine_reset();
79	79	TIMER_DEVICE_CALLBACK_MEMBER(eacc_cb1);

trunk/src/mess/drivers/pegasus.c
r19155	r19156
58	58
59	59	required_device<cpu_device> m_maincpu;
60	60	required_device<cassette_image_device> m_cass;
61		required_device<device_t> m_pia_s;
62		required_device<device_t> m_pia_u;
	61	required_device<pia6821_device> m_pia_s;
	62	required_device<pia6821_device> m_pia_u;
63	63	DECLARE_READ8_MEMBER( pegasus_keyboard_r );
64	64	DECLARE_READ8_MEMBER( pegasus_protection_r );
65	65	DECLARE_READ8_MEMBER( pegasus_pcg_r );

trunk/src/mess/drivers/esq5505.c
r19155	r19156
135	135	{ }
136	136
137	137	required_device<m68000_device> m_maincpu;
138		required_device<device_t> m_duart;
	138	required_device<duart68681_device> m_duart;
139	139	optional_device<wd1772_t> m_fdc;
140	140	optional_device<esq1x22_t> m_epsvfd;
141	141	optional_device<esq2x40_sq1_t> m_sq1vfd;
142	142	optional_device<esq2x40_t> m_vfd;
143		optional_device<device_t> m_dmac;
	143	optional_device<hd63450_device> m_dmac;
144	144
145	145	virtual void machine_reset();
146	146

trunk/src/mess/drivers/h8.c
r19155	r19156
33	33
34	34	required_device<cpu_device> m_maincpu;
35	35	//required_device<cassette_image_device> m_cass;
36		required_device<device_t> m_beep;
	36	required_device<beep_device> m_beep;
37	37	DECLARE_READ8_MEMBER(h8_f0_r);
38	38	DECLARE_WRITE8_MEMBER(h8_f0_w);
39	39	DECLARE_WRITE8_MEMBER(h8_f1_w);

trunk/src/mess/drivers/mycom.c
r19155	r19156
81	81	required_device<i8255_device> m_ppi1;
82	82	required_device<i8255_device> m_ppi2;
83	83	required_device<cassette_image_device> m_cass;
84		required_device<device_t> m_wave;
	84	required_device<wave_device> m_wave;
85	85	required_device<mc6845_device> m_crtc;
86		required_device<device_t> m_fdc;
	86	required_device<fd1771_device> m_fdc;
87	87	required_device<sn76489_device> m_audio;
88	88	required_device<msm5832_device> m_rtc;
89	89	DECLARE_READ8_MEMBER( mycom_upper_r );

trunk/src/mess/drivers/horizon.c
r19155	r19156
25	25	{ }
26	26
27	27	required_device<cpu_device> m_maincpu;
28		required_device<device_t> m_terminal;
	28	required_device<generic_terminal_device> m_terminal;
29	29	DECLARE_WRITE8_MEMBER( kbd_put );
30	30	//UINT8 m_term_data;
31	31	virtual void machine_reset();

trunk/src/mess/drivers/sm1800.c
r19155	r19156
32	32	{ }
33	33
34	34	required_device<cpu_device> m_maincpu;
35		required_device<device_t> m_uart;
36		required_device<device_t> m_ppi;
37		required_device<device_t> m_crtc;
	35	required_device<i8251_device> m_uart;
	36	required_device<i8255_device> m_ppi;
	37	required_device<i8275_device> m_crtc;
38	38	DECLARE_WRITE8_MEMBER(sm1800_8255_portb_w);
39	39	DECLARE_WRITE8_MEMBER(sm1800_8255_portc_w);
40	40	DECLARE_READ8_MEMBER(sm1800_8255_porta_r);

trunk/src/mess/drivers/d6800.c
r19155	r19156
70	70	bool m_screen_on;
71	71	required_device<cpu_device> m_maincpu;
72	72	required_device<cassette_image_device> m_cass;
73		required_device<device_t> m_pia;
	73	required_device<pia6821_device> m_pia;
74	74	required_device<dac_device> m_dac;
75	75	required_shared_ptr<UINT8> m_videoram;
76	76	private:

trunk/src/mess/drivers/rx78.c
r19155	r19156
63	63
64	64	required_device<cpu_device> m_maincpu;
65	65	required_device<cassette_image_device> m_cass;
66		required_device<device_t> m_wave;
	66	required_device<wave_device> m_wave;
67	67	DECLARE_READ8_MEMBER( key_r );
68	68	DECLARE_READ8_MEMBER( rx78_f0_r );
69	69	DECLARE_READ8_MEMBER( rx78_vram_r );

trunk/src/mess/drivers/bigbord2.c
r19155	r19156
138	138	required_device<z80ctc_device> m_ctca;
139	139	required_device<z80ctc_device> m_ctcb;
140	140	required_device<z80dma_device> m_dma;
141		required_device<device_t> m_fdc;
142		required_device<device_t> m_floppy0;
143		required_device<device_t> m_floppy1;
144		required_device<device_t> m_floppy2;
145		required_device<device_t> m_floppy3;
146		required_device<device_t> m_beeper;
	141	required_device<fd1793_device> m_fdc;
	142	required_device<legacy_floppy_image_device> m_floppy0;
	143	required_device<legacy_floppy_image_device> m_floppy1;
	144	required_device<legacy_floppy_image_device> m_floppy2;
	145	required_device<legacy_floppy_image_device> m_floppy3;
	146	required_device<beep_device> m_beeper;
147	147	DECLARE_DRIVER_INIT(bigbord2);
148	148	TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
149	149	DECLARE_WRITE_LINE_MEMBER(bigbord2_interrupt);

trunk/src/mess/drivers/sitcom.c
r19155	r19156
46	46	{ }
47	47
48	48	required_device<cpu_device> m_maincpu;
49		required_device<device_t> m_ds0;
50		required_device<device_t> m_ds1;
	49	required_device<dl1416_device> m_ds0;
	50	required_device<dl1416_device> m_ds1;
51	51	DECLARE_WRITE_LINE_MEMBER(sod_led);
52	52	DECLARE_READ_LINE_MEMBER(sid_line);
53	53	virtual void machine_reset();

trunk/src/mess/drivers/csc.c
r19155	r19156
28	28	m_speech(*this, "speech")
29	29	{ }
30	30
31		required_device<device_t> m_speech;
	31	required_device<s14001a_device> m_speech;
32	32
33	33	virtual void machine_start();
34	34

trunk/src/mess/drivers/myb3k.c
r19155	r19156
29	29	m_p_vram(*this, "p_vram"){ }
30	30
31	31	required_device<cpu_device> m_maincpu;
32		required_device<device_t> m_fdc;
	32	required_device<mb8877_device> m_fdc;
33	33	required_device<mc6845_device> m_crtc;
34	34	DECLARE_WRITE8_MEMBER(myb3k_6845_address_w);
35	35	DECLARE_WRITE8_MEMBER(myb3k_6845_data_w);

trunk/src/mess/drivers/pce220.c
r19155	r19156
48	48
49	49	required_device<cpu_device> m_maincpu;
50	50	required_device<ram_device> m_ram;
51		required_device<device_t> m_beep;
	51	required_device<beep_device> m_beep;
52	52	required_device<pce220_serial_device> m_serial;
53	53
54	54	// HD61202 LCD controller

trunk/src/mess/drivers/camplynx.c
r19155	r19156
96	96
97	97	required_device<cpu_device> m_maincpu;
98	98	//required_device<cassette_image_device> m_cass;
99		//required_device<device_t> m_wave;
100		//required_device<device_t> m_printer;
	99	//required_device<> m_wave;
	100	//required_device<> m_printer;
101	101	required_device<mc6845_device> m_crtc;
102		//optional_device<~~device_t~~> m_fdc;
	102	//optional_device<> m_fdc;
103	103	DECLARE_WRITE8_MEMBER(lynx48k_bank_w);
104	104	DECLARE_WRITE8_MEMBER(lynx128k_bank_w);
105	105	DECLARE_WRITE8_MEMBER(lynx128k_irq);

trunk/src/mess/drivers/rainbow.c
r19155	r19156
84	84	{ }
85	85
86	86
87		required_device<device_t> m_crtc;
88		required_device<device_t> m_i8088;
89		required_device<device_t> m_z80;
90		required_device<device_t> m_fdc;
	87	required_device<vt100_video_device> m_crtc;
	88	required_device<cpu_device> m_i8088;
	89	required_device<cpu_device> m_z80;
	90	required_device<fd1793_device> m_fdc;
91	91	required_device<i8251_device> m_kbd8251;
92	92	required_device<lk201_device> m_lk201;
93	93	required_shared_ptr<UINT8> m_p_ram;
r19155	r19156
198	198	void rainbow_state::machine_reset()
199	199	{
200	200
201		m_z80->~~execute().~~set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	201	m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
202	202
203	203	m_zflip = true;
204	204	m_z80_halted = true;
r19155	r19156
278	278	READ8_MEMBER(rainbow_state::i8088_latch_r)
279	279	{
280	280	// printf("Read %02x from 8088 mailbox\n", m_8088_mailbox);
281		m_i8088->~~execute().~~set_input_line(INPUT_LINE_INT1, CLEAR_LINE);
	281	m_i8088->set_input_line(INPUT_LINE_INT1, CLEAR_LINE);
282	282	return m_8088_mailbox;
283	283	}
284	284
285	285	WRITE8_MEMBER(rainbow_state::i8088_latch_w)
286	286	{
287	287	// printf("%02x to Z80 mailbox\n", data);
288		m_z80->~~execute().~~set_input_line_and_vector(0, ASSERT_LINE, 0xf7);
	288	m_z80->set_input_line_and_vector(0, ASSERT_LINE, 0xf7);
289	289	m_z80_mailbox = data;
290	290	}
291	291
292	292	READ8_MEMBER(rainbow_state::z80_latch_r)
293	293	{
294	294	// printf("Read %02x from Z80 mailbox\n", m_z80_mailbox);
295		m_z80->~~execute().~~set_input_line(0, CLEAR_LINE);
	295	m_z80->set_input_line(0, CLEAR_LINE);
296	296	return m_z80_mailbox;
297	297	}
298	298
299	299	WRITE8_MEMBER(rainbow_state::z80_latch_w)
300	300	{
301	301	// printf("%02x to 8088 mailbox\n", data);
302		m_i8088->~~execute().~~set_input_line_and_vector(INPUT_LINE_INT1, ASSERT_LINE, 0x27);
	302	m_i8088->set_input_line_and_vector(INPUT_LINE_INT1, ASSERT_LINE, 0x27);
303	303	m_8088_mailbox = data;
304	304	}
305	305
r19155	r19156
325	325
326	326	WRITE8_MEMBER( rainbow_state::clear_video_interrupt )
327	327	{
328		m_i8088->~~execute().~~set_input_line(INPUT_LINE_INT0, CLEAR_LINE);
	328	m_i8088->set_input_line(INPUT_LINE_INT0, CLEAR_LINE);
329	329	}
330	330
331	331	READ8_MEMBER( rainbow_state::diagnostic_r )
r19155	r19156
339	339
340	340	if (!(data & 1))
341	341	{
342		m_z80->~~execute().~~set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	342	m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
343	343	m_z80_halted = true;
344	344	}
345	345
r19155	r19156
347	347	{
348	348	m_zflip = true;
349	349	m_z80_halted = false;
350		m_z80->~~execute().~~set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	350	m_z80->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
351	351	m_z80->reset();
352	352	}
353	353
r19155	r19156
358	358	{
359	359	if ((m_kbd_rx_ready) \|\| (m_kbd_tx_ready))
360	360	{
361		m_i8088->~~execute().~~set_input_line_and_vector(INPUT_LINE_INT2, ASSERT_LINE, 0x26);
	361	m_i8088->set_input_line_and_vector(INPUT_LINE_INT2, ASSERT_LINE, 0x26);
362	362	}
363	363	else
364	364	{
365		m_i8088->~~execute().~~set_input_line(INPUT_LINE_INT2, CLEAR_LINE);
	365	m_i8088->set_input_line(INPUT_LINE_INT2, CLEAR_LINE);
366	366	}
367	367	}
368	368

trunk/src/mess/drivers/mekd2.c
r19155	r19156
54	54	{ }
55	55
56	56	required_device<cpu_device> m_maincpu;
57		required_device<device_t> m_pia_s;
58		required_device<device_t> m_pia_u;
59		required_device<device_t> m_acia;
	57	required_device<pia6821_device> m_pia_s;
	58	required_device<pia6821_device> m_pia_u;
	59	required_device<acia6850_device> m_acia;
60	60	DECLARE_READ_LINE_MEMBER( mekd2_key40_r );
61	61	DECLARE_READ8_MEMBER( mekd2_key_r );
62	62	DECLARE_WRITE_LINE_MEMBER( mekd2_nmi_w );

trunk/src/mess/drivers/homelab.c
r19155	r19156
63	63	const UINT8 *m_p_videoram;
64	64	bool m_nmi;
65	65	required_device<cpu_device> m_maincpu;
66		required_device<device_t> m_speaker;
	66	required_device<speaker_sound_device> m_speaker;
67	67	required_device<cassette_image_device> m_cass;
68	68	DECLARE_DRIVER_INIT(brailab4);
69	69	DECLARE_VIDEO_START(homelab2);

trunk/src/mess/drivers/v1050.c
r19155	r19156
106	106	*/
107	107
108	108	#include "includes/v1050.h"
109		#include "machine/scsibus.h"
110		#include "machine/scsicb.h"
111		#include "machine/scsihd.h"
112		#include "machine/s1410.h"
113	109
114	110	void v1050_state::set_interrupt(UINT8 mask, int state)
115	111	{
r19155	r19156
1091	1087	MCFG_I8255A_ADD(I8255A_M6502_TAG, m6502_ppi_intf)
1092	1088	MCFG_I8251_ADD(I8251A_KB_TAG, /XTAL_16MHz/8,/ kb_8251_intf)
1093	1089	MCFG_I8251_ADD(I8251A_SIO_TAG, /XTAL_16MHz/8,/ sio_8251_intf)
1094		MCFG_FD1793x_ADD(MB8877_TAG, XTAL_16MHz/2)
	1090	MCFG_FD1793x_ADD(MB8877_TAG, XTAL_16MHz/16 *8)
1095	1091	MCFG_FLOPPY_DRIVE_ADD(MB8877_TAG":0", v1050_floppies, "525dd", NULL, floppy_image_device::default_floppy_formats)
1096	1092	MCFG_FLOPPY_DRIVE_ADD(MB8877_TAG":1", v1050_floppies, "525dd", NULL, floppy_image_device::default_floppy_formats)
1097	1093	MCFG_FLOPPY_DRIVE_ADD(MB8877_TAG":2", v1050_floppies, NULL, NULL, floppy_image_device::default_floppy_formats)

trunk/src/mess/drivers/digel804.c
r19155	r19156
82	82	{ }
83	83
84	84	required_device<cpu_device> m_maincpu;
85		required_device<device_t> m_terminal;
86		required_device<device_t> m_speaker;
	85	required_device<generic_terminal_device> m_terminal;
	86	required_device<speaker_sound_device> m_speaker;
87	87	required_device<acia6551_device> m_acia;
88	88	required_device<roc10937_t> m_vfd;
89	89	required_device<mm74c922_device> m_kb;

trunk/src/mess/drivers/osbexec.c
r19155	r19156
35	35	{ }
36	36
37	37	required_device<cpu_device> m_maincpu;
38		required_device<device_t> m_mb8877;
	38	required_device<mb8877_device> m_mb8877;
39	39	required_device<ram_device> m_messram;
40	40	required_device<pia6821_device> m_pia_0;
41	41	required_device<pia6821_device> m_pia_1;
42	42	required_device<z80dart_device> m_sio;
43		required_device<device_t> m_speaker;
	43	required_device<speaker_sound_device> m_speaker;
44	44
45	45	virtual void video_start();
46	46

trunk/src/mess/drivers/ipds.c
r19155	r19156
22	22	{ }
23	23
24	24	required_device<cpu_device> m_maincpu;
25		required_device<device_t> m_crtc;
	25	required_device<i8275_device> m_crtc;
26	26	DECLARE_READ8_MEMBER(ipds_b0_r);
27	27	DECLARE_READ8_MEMBER(ipds_b1_r);
28	28	DECLARE_READ8_MEMBER(ipds_c0_r);

trunk/src/mess/drivers/multi16.c
r19155	r19156
22	22	m_p_vram(*this, "p_vram"){ }
23	23
24	24	required_device<cpu_device> m_maincpu;
25		required_device<device_t> m_pic;
	25	required_device<pic8259_device> m_pic;
26	26	required_device<mc6845_device> m_crtc;
27	27	DECLARE_WRITE8_MEMBER(multi16_6845_address_w);
28	28	DECLARE_WRITE8_MEMBER(multi16_6845_data_w);

trunk/src/mess/drivers/pc2000.c
r19155	r19156
31	31	{ }
32	32
33	33	required_device<hd44780_device> m_lcdc;
34		required_device<device_t> m_beep;
	34	required_device<beep_device> m_beep;
35	35
36	36	UINT8 m_mux_data;
37	37	UINT8 m_beep_state;

trunk/src/mess/drivers/bmjr.c
r19155	r19156
32	32
33	33	required_device<cpu_device> m_maincpu;
34	34	required_device<cassette_image_device> m_cass;
35		required_device<device_t> m_beep;
	35	required_device<beep_device> m_beep;
36	36	DECLARE_READ8_MEMBER(key_r);
37	37	DECLARE_WRITE8_MEMBER(key_w);
38	38	DECLARE_READ8_MEMBER(ff_r);

trunk/src/mess/drivers/dim68k.c
r19155	r19156
50	50
51	51	required_device<cpu_device> m_maincpu;
52	52	required_device<mc6845_device> m_crtc;
53		required_device<device_t> m_speaker;
	53	required_device<speaker_sound_device> m_speaker;
54	54	DECLARE_READ16_MEMBER( dim68k_duart_r );
55	55	DECLARE_READ16_MEMBER( dim68k_fdc_r );
56	56	DECLARE_READ16_MEMBER( dim68k_game_switches_r );

trunk/src/mess/drivers/glasgow.c
r19155	r19156
63	63	{ }
64	64
65	65	required_device<cpu_device> m_maincpu;
66		required_device<device_t> m_beep;
	66	required_device<beep_device> m_beep;
67	67	DECLARE_WRITE16_MEMBER(glasgow_lcd_w);
68	68	DECLARE_WRITE16_MEMBER(glasgow_lcd_flag_w);
69	69	DECLARE_READ16_MEMBER(glasgow_keys_r);

trunk/src/mess/drivers/lcmate2.c
r19155	r19156
50	50	required_device<cpu_device> m_maincpu;
51	51	required_device<hd44780_device> m_lcdc;
52	52	required_device<rp5c15_device> m_rtc;
53		required_device<device_t> m_speaker;
	53	required_device<speaker_sound_device> m_speaker;
54	54
55	55	virtual void machine_start();
56	56

trunk/src/mess/drivers/z100.c
r19155	r19156
166	166	{ }
167	167
168	168	required_device<cpu_device> m_maincpu;
169		required_device<device_t> m_pia0;
170		required_device<device_t> m_pia1;
171		required_device<device_t> m_picm;
172		required_device<device_t> m_pics;
173		required_device<device_t> m_fdc;
	169	required_device<pia6821_device> m_pia0;
	170	required_device<pia6821_device> m_pia1;
	171	required_device<pic8259_device> m_picm;
	172	required_device<pic8259_device> m_pics;
	173	required_device<fd1797_device> m_fdc;
174	174	required_device<mc6845_device> m_crtc;
175	175	DECLARE_READ8_MEMBER(z100_vram_r);
176	176	DECLARE_WRITE8_MEMBER(z100_vram_w);

trunk/src/mess/drivers/tec1.c
r19155	r19156
90	90	{ }
91	91
92	92	required_device<cpu_device> m_maincpu;
93		required_device<device_t> m_speaker;
	93	required_device<speaker_sound_device> m_speaker;
94	94	optional_device<cassette_image_device> m_cass;
95		optional_device<device_t> m_wave;
	95	optional_device<wave_device> m_wave;
96	96	emu_timer *m_kbd_timer;
97	97	DECLARE_READ8_MEMBER( tec1_kbd_r );
98	98	DECLARE_READ8_MEMBER( latch_r );

trunk/src/mess/drivers/px4.c
r19155	r19156
88	88	required_device<ram_device> m_ram;
89	89	required_device<centronics_device> m_centronics;
90	90	required_device<cassette_image_device> m_ext_cas;
91		required_device<device_t> m_speaker;
	91	required_device<speaker_sound_device> m_speaker;
92	92	required_device<epson_sio_device> m_sio;
93	93
94	94	/* gapnit register */

trunk/src/mess/drivers/nanos.c
r19155	r19156
44	44	required_device<z80ctc_device> m_ctc_0;
45	45	required_device<z80ctc_device> m_ctc_1;
46	46	required_device<upd765a_device> m_fdc;
47		required_device<device_t> m_key_t;
	47	required_device<timer_device> m_key_t;
48	48	const UINT8 *m_p_chargen;
49	49	UINT8 m_key_command;
50	50	UINT8 m_last_code;

trunk/src/mess/drivers/z9001.c
r19155	r19156
52	52
53	53	required_device<cpu_device> m_maincpu;
54	54	UINT8 m_framecnt;
55		required_device<device_t> m_beeper;
	55	required_device<beep_device> m_beeper;
56	56	required_device<cassette_image_device> m_cass;
57	57	required_shared_ptr<const UINT8> m_p_colorram;
58	58	required_shared_ptr<const UINT8> m_p_videoram;

trunk/src/mess/drivers/dolphunk.c
r19155	r19156
91	91	UINT8 m_last_key;
92	92	bool m_speaker_state;
93	93	required_device<cpu_device> m_maincpu;
94		required_device<device_t> m_speaker;
	94	required_device<speaker_sound_device> m_speaker;
95	95	};
96	96
97	97	WRITE8_MEMBER( dolphunk_state::port00_w )

trunk/src/mess/drivers/palm.c
r19155	r19156
29	29	{ }
30	30
31	31	required_device<cpu_device> m_maincpu;
32		required_device<device_t> m_lsi;
	32	required_device<mc68328_device> m_lsi;
33	33	required_device<dac_device> m_dac;
34	34	required_device<ram_device> m_ram;
35	35	// mc68328 needs modernising

trunk/src/mess/drivers/pyl601.c
r19155	r19156
77	77	DECLARE_WRITE8_MEMBER(floppy_w);
78	78	DECLARE_READ8_MEMBER(floppy_r);
79	79	UINT8 selectedline(UINT16 data);
80		required_device<device_t> m_speaker;
	80	required_device<speaker_sound_device> m_speaker;
81	81	required_device<upd765a_device> m_fdc;
82	82	required_device<ram_device> m_ram;
83	83	DECLARE_DRIVER_INIT(pyl601);

trunk/src/mess/drivers/kim1.c
r19155	r19156
111	111	m_cass(*this, CASSETTE_TAG)
112	112	{ }
113	113
114		required_device<device_t> m_riot2;
	114	required_device<mos6530_device> m_riot2;
115	115	required_device<cassette_image_device> m_cass;
116	116	DECLARE_READ8_MEMBER(kim1_u2_read_a);
117	117	DECLARE_WRITE8_MEMBER(kim1_u2_write_a);

trunk/src/mess/drivers/rex6000.c
r19155	r19156
66	66
67	67	required_device<cpu_device> m_maincpu;
68	68	required_device<ram_device> m_ram;
69		required_device<device_t> m_beep;
	69	required_device<beep_device> m_beep;
70	70	fujitsu_29dl16x_device *m_flash[4];
71	71
72	72	UINT8 m_bank[4];

trunk/src/mess/drivers/apf.c
r19155	r19156
79	79
80	80	required_device<cpu_device> m_maincpu;
81	81	required_device<mc6847_base_device> m_crtc;
82		required_device<device_t> m_speaker;
83		required_device<device_t> m_pia0;
84		optional_device<device_t> m_pia1;
	82	required_device<speaker_sound_device> m_speaker;
	83	required_device<pia6821_device> m_pia0;
	84	optional_device<pia6821_device> m_pia1;
85	85	optional_device<cassette_image_device> m_cass;
86		optional_device<device_t> m_fdc;
	86	optional_device<wd1770_device> m_fdc;
87	87	DECLARE_READ8_MEMBER(apf_mc6847_videoram_r);
88	88	DECLARE_WRITE_LINE_MEMBER(apf_mc6847_fs_w);
89	89	DECLARE_READ8_MEMBER(apf_m1000_pia_in_a_func);

trunk/src/mess/drivers/paso1600.c
r19155	r19156
29	29	m_p_gvram(*this, "p_gvram"){ }
30	30
31	31	required_device<cpu_device> m_maincpu;
32		required_device<device_t> m_pic;
33		required_device<device_t> m_dma;
	32	required_device<pic8259_device> m_pic;
	33	required_device<i8237_device> m_dma;
34	34	required_device<mc6845_device> m_crtc;
35	35	DECLARE_READ8_MEMBER(paso1600_pcg_r);
36	36	DECLARE_WRITE8_MEMBER(paso1600_pcg_w);

trunk/src/mess/drivers/mbc200.c
r19155	r19156
41	41	m_fdc(*this, "fdc"),
42	42	m_ppi(*this, "ppi8255_2"),
43	43	m_floppy0(*this, FLOPPY_0),
44		m_floppy1(*this, FLOPPY_1)
45		,
46		m_vram(*this, "vram"){ }
	44	m_floppy1(*this, FLOPPY_1),
	45	m_vram(*this, "vram")
	46	{ }
47	47
48	48	virtual void machine_start();
49	49
50	50	required_device<mc6845_device> m_6845;
51		required_device<device_t> m_fdc;
	51	required_device<mb8876_device> m_fdc;
52	52	required_device<i8255_device> m_ppi;
53		required_device<device_t> m_floppy0;
54		required_device<device_t> m_floppy1;
	53	required_device<legacy_floppy_image_device> m_floppy0;
	54	required_device<legacy_floppy_image_device> m_floppy1;
55	55
56	56	DECLARE_READ8_MEMBER(from_master_r);
57	57	DECLARE_WRITE8_MEMBER(porta_w);

trunk/src/mess/drivers/a5105.c
r19155	r19156
53	53	required_device<cpu_device> m_maincpu;
54	54	required_device<upd7220_device> m_hgdc;
55	55	required_device<cassette_image_device> m_cass;
56		required_device<device_t> m_beep;
	56	required_device<beep_device> m_beep;
57	57	required_device<upd765a_device> m_fdc;
58	58	required_device<floppy_connector> m_floppy0;
59	59	required_device<floppy_connector> m_floppy1;

trunk/src/mess/drivers/imds.c
r19155	r19156
31	31	{ }
32	32
33	33	required_device<cpu_device> m_maincpu;
34		required_device<device_t> m_terminal;
	34	required_device<generic_terminal_device> m_terminal;
35	35	DECLARE_READ8_MEMBER(term_r);
36	36	DECLARE_READ8_MEMBER(term_status_r);
37	37	DECLARE_WRITE8_MEMBER(kbd_put);

trunk/src/mess/drivers/ptcsol.c
r19155	r19156
162	162	required_device<cpu_device> m_maincpu;
163	163	required_device<cassette_image_device> m_cass1;
164	164	required_device<cassette_image_device> m_cass2;
165		required_device<device_t> m_uart;
166		required_device<device_t> m_uart_s;
	165	required_device<ay31015_device> m_uart;
	166	required_device<ay31015_device> m_uart_s;
167	167	required_shared_ptr<const UINT8> m_p_videoram;
168	168	required_ioport m_iop_arrows;
169	169	required_ioport m_iop_config;

trunk/src/mess/drivers/socrates.c
r19155	r19156
87	87	{ }
88	88	required_device<cpu_device> m_maincpu;
89	89	required_device<screen_device> m_screen;
90		required_device<device_t> m_sound;
	90	required_device<socrates_snd_device> m_sound;
91	91
92	92	rgb_t m_palette[256];
93	93

trunk/src/mess/drivers/h19.c
r19155	r19156
55	55
56	56	required_device<cpu_device> m_maincpu;
57	57	required_device<mc6845_device> m_crtc;
58		required_device<device_t> m_ace;
59		required_device<device_t> m_beep;
	58	required_device<ins8250_device> m_ace;
	59	required_device<beep_device> m_beep;
60	60	DECLARE_READ8_MEMBER(h19_80_r);
61	61	DECLARE_READ8_MEMBER(h19_a0_r);
62	62	DECLARE_WRITE8_MEMBER(h19_c0_w);

trunk/src/mess/drivers/pb1000.c
r19155	r19156
36	36	{ }
37	37
38	38	required_device<hd61700_cpu_device> m_maincpu;
39		required_device<device_t> m_beep;
	39	required_device<beep_device> m_beep;
40	40	required_device<hd44352_device> m_hd44352;
41	41
42	42	emu_timer *m_kb_timer;

trunk/src/mess/drivers/ht68k.c
r19155	r19156
48	48
49	49	required_device<cpu_device> m_maincpu;
50	50	required_device<generic_terminal_device> m_terminal;
51		required_device<device_t> m_duart;
	51	required_device<duart68681_device> m_duart;
52	52	required_device<wd1770_t> m_fdc;
53	53	DECLARE_WRITE8_MEMBER(kbd_put);
54	54	DECLARE_WRITE_LINE_MEMBER(ht68k_fdc_intrq_w);

trunk/src/mess/drivers/vt100.c
r19155	r19156
37	37	m_p_ram(*this, "p_ram"){ }
38	38
39	39	required_device<cpu_device> m_maincpu;
40		required_device<device_t> m_crtc;
41		required_device<device_t> m_speaker;
	40	required_device<vt100_video_device> m_crtc;
	41	required_device<beep_device> m_speaker;
42	42	DECLARE_READ8_MEMBER(vt100_flags_r);
43	43	DECLARE_WRITE8_MEMBER(vt100_keyboard_w);
44	44	DECLARE_READ8_MEMBER(vt100_keyboard_r);

trunk/src/mess/drivers/merlin.c
r19155	r19156
22	22
23	23	virtual void machine_start();
24	24
25		required_device<device_t> m_speaker;
	25	required_device<speaker_sound_device> m_speaker;
26	26
27	27	DECLARE_READ8_MEMBER(read_k);
28	28	DECLARE_WRITE16_MEMBER(write_o);

trunk/src/mess/drivers/qx10.c
r19155	r19156
70	70	m_vram_bank(0)
71	71	{ }
72	72
73		required_device<device_t> m_pit_1;
74		required_device<device_t> m_pit_2;
75		required_device<device_t> m_pic_m;
76		required_device<device_t> m_pic_s;
	73	required_device<pit8253_device> m_pit_1;
	74	required_device<pit8253_device> m_pit_2;
	75	required_device<pic8259_device> m_pic_m;
	76	required_device<pic8259_device> m_pic_s;
77	77	required_device<upd7201_device> m_scc;
78	78	required_device<i8255_device> m_ppi;
79	79	required_device<i8237_device> m_dma_1;

trunk/src/mess/drivers/unixpc.c
r19155	r19156
30	30	m_maincpu(*this, "maincpu"),
31	31	m_ram(*this, RAM_TAG),
32	32	m_wd2797(*this, "wd2797"),
33		m_floppy(*this, FLOPPY_0)
34		,
35		m_mapram(*this, "mapram"),
36		m_videoram(*this, "videoram"){ }
	33	m_floppy(*this, FLOPPY_0),
	34	m_mapram(*this, "mapram"),
	35	m_videoram(*this, "videoram"){ }
37	36
38	37	required_device<cpu_device> m_maincpu;
39	38	required_device<ram_device> m_ram;
40		required_device<device_t> m_wd2797;
41		required_device<device_t> m_floppy;
	39	required_device<wd2797_device> m_wd2797;
	40	required_device<legacy_floppy_image_device> m_floppy;
42	41
43	42	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	43

trunk/src/mess/drivers/pcm.c
r19155	r19156
83	83	required_device<z80sio_device> m_sio;
84	84	required_device<z80ctc_device> m_ctc_s;
85	85	required_device<z80ctc_device> m_ctc_u;
86		required_device<device_t> m_speaker;
	86	required_device<speaker_sound_device> m_speaker;
87	87	required_device<cassette_image_device> m_cass;
88	88	DECLARE_READ8_MEMBER( pcm_85_r );
89	89	DECLARE_WRITE_LINE_MEMBER( pcm_82_w );

trunk/src/mess/drivers/mephisto.c
r19155	r19156
78	78	{ }
79	79
80	80	required_device<m65c02_device> m_maincpu;
81		required_device<device_t> m_beep;
	81	required_device<beep_device> m_beep;
82	82	DECLARE_WRITE8_MEMBER(write_lcd);
83	83	DECLARE_WRITE8_MEMBER(mephisto_NMI);
84	84	DECLARE_READ8_MEMBER(read_keys);

trunk/src/mess/drivers/xor100.c
r19155	r19156
32	32	*/
33	33
34	34
35		#include "emu.h"
36		#include "cpu/z80/z80.h"
37		#include "formats/basicdsk.h"
38		#include "imagedev/flopdrv.h"
39		#include "machine/ram.h"
40		#include "machine/com8116.h"
41		#include "machine/ctronics.h"
42		#include "machine/i8255.h"
43		#include "machine/i8251.h"
44		#include "machine/terminal.h"
45		#include "machine/wd17xx.h"
46		#include "machine/z80ctc.h"
47	35	#include "includes/xor100.h"
48	36
49	37	/* Read/Write Handlers */

trunk/src/mess/drivers/bml3.c
r19155	r19156
55	55	required_device<cpu_device> m_maincpu;
56	56	required_device<mc6845_device> m_crtc;
57	57	//required_device<cassette_image_device> m_cass;
58		required_device<device_t> m_beep;
	58	required_device<beep_device> m_beep;
59	59	DECLARE_WRITE8_MEMBER(bml3_6845_w);
60	60	DECLARE_READ8_MEMBER(bml3_keyboard_r);
61	61	DECLARE_WRITE8_MEMBER(bml3_hres_reg_w);

trunk/src/mess/drivers/supercon.c
r19155	r19156
33	33	{ }
34	34
35	35	required_device<cpu_device> m_maincpu;
36		required_device<device_t> m_beep;
	36	required_device<beep_device> m_beep;
37	37	DECLARE_READ8_MEMBER(supercon_port1_r);
38	38	DECLARE_READ8_MEMBER(supercon_port2_r);
39	39	DECLARE_READ8_MEMBER(supercon_port3_r);

trunk/src/mess/drivers/fp1100.c
r19155	r19156
76	76	required_device<cpu_device> m_maincpu;
77	77	required_device<cpu_device> m_subcpu;
78	78	//required_device<cassette_image_device> m_cass;
79		//required_device<device_t> m_wave;
80		//required_device<device_t> m_speaker;
81		//required_device<device_t> m_printer;
	79	//required_device<> m_wave;
	80	//required_device<> m_speaker;
	81	//required_device<> m_printer;
82	82	required_device<mc6845_device> m_crtc;
83		//required_device<~~device_t~~> m_fdc;
	83	//required_device<> m_fdc;
84	84	DECLARE_READ8_MEMBER(fp1100_mem_r);
85	85	DECLARE_WRITE8_MEMBER(fp1100_mem_w);
86	86	DECLARE_WRITE8_MEMBER(main_bank_w);

trunk/src/mess/drivers/votrtnt.c
r19155	r19156
56	56
57	57	required_device<cpu_device> m_maincpu;
58	58	required_device<generic_terminal_device> m_terminal;
59		//required_device<~~device_t~~> m_acia;
	59	//required_device<> m_acia;
60	60	required_device<votrax_sc01_device> m_votrax;
61	61	DECLARE_READ8_MEMBER(votrtnt_acia_status_r);
62	62	DECLARE_READ8_MEMBER(votrtnt_acia_data_r);

trunk/src/mess/drivers/vk100.c
r19155	r19156
145	145	required_device<cpu_device> m_maincpu;
146	146	required_device<screen_device> m_screen;
147	147	required_device<mc6845_device> m_crtc;
148		required_device<device_t> m_speaker;
149		required_device<device_t> m_uart;
150		//required_device<device_t> m_i8251_rx_timer;
151		//required_device<device_t> m_i8251_tx_timer;
152		//required_device<device_t> m_sync_timer;
	148	required_device<beep_device> m_speaker;
	149	required_device<i8251_device> m_uart;
	150	//required_device<> m_i8251_rx_timer;
	151	//required_device<> m_i8251_tx_timer;
	152	//required_device<> m_sync_timer;
153	153
154	154	UINT8* m_vram;
155	155	UINT8* m_trans;

trunk/src/mess/drivers/alphatro.c
r19155	r19156
48	48	required_device<mc6845_device> m_crtc;
49	49	required_device<i8251_device> m_usart;
50	50	required_device<cassette_image_device> m_cass;
51		required_device<device_t> m_beep;
	51	required_device<beep_device> m_beep;
52	52
53	53	DECLARE_READ8_MEMBER(port10_r);
54	54	DECLARE_WRITE8_MEMBER(port10_w);

trunk/src/mess/drivers/hp9k.c
r19155	r19156
134	134	UINT8 kbdBit;
135	135
136	136	required_device<cpu_device> m_maincpu;
137		//required_device<~~device_t~~> m_terminal;
	137	//required_device<> m_terminal;
138	138	required_device<mc6845_device> m_6845;
139	139
140	140	UINT8 m_videoram[0x4000];

trunk/src/mess/drivers/phunsy.c
r19155	r19156
54	54	virtual void video_start();
55	55	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
56	56	required_device<cpu_device> m_maincpu;
57		required_device<device_t> m_speaker;
	57	required_device<speaker_sound_device> m_speaker;
58	58	required_device<cassette_image_device> m_cass;
59	59	required_shared_ptr<UINT8> m_videoram;
60	60	virtual void palette_init();

trunk/src/mess/drivers/sc1.c
r19155	r19156
51	51	{ }
52	52
53	53	required_device<cpu_device> m_maincpu;
54		required_device<device_t> m_speaker;
	54	required_device<speaker_sound_device> m_speaker;
55	55
56	56	DECLARE_WRITE8_MEMBER( matrix_w );
57	57	DECLARE_WRITE8_MEMBER( pio_port_a_w );

trunk/src/mess/drivers/iq151.c
r19155	r19156
73	73	{ }
74	74
75	75	required_device<cpu_device> m_maincpu;
76		required_device<device_t> m_pic;
77		required_device<device_t> m_speaker;
	76	required_device<pic8259_device> m_pic;
	77	required_device<speaker_sound_device> m_speaker;
78	78	required_device<cassette_image_device> m_cassette;
79	79
80	80	DECLARE_READ8_MEMBER(keyboard_row_r);

trunk/src/mess/drivers/slc1.c
r19155	r19156
62	62	{ }
63	63
64	64	required_device<cpu_device> m_maincpu;
65		required_device<device_t> m_speaker;
	65	required_device<speaker_sound_device> m_speaker;
66	66	DECLARE_READ8_MEMBER( io_r );
67	67	DECLARE_WRITE8_MEMBER( io_w );
68	68	UINT8 m_digit;

trunk/src/mess/drivers/esq1.c
r19155	r19156
136	136	m_vfd(*this, "vfd")
137	137	{ }
138	138
139		required_device<device_t> m_maincpu;
140		required_device<device_t> m_duart;
	139	required_device<cpu_device> m_maincpu;
	140	required_device<duart68681_device> m_duart;
141	141	optional_device<wd1772_t> m_fdc;
142	142	optional_device<esq2x40_t> m_vfd;
143	143

trunk/src/mess/drivers/lx800.c
r19155	r19156
35	35	{ }
36	36
37	37	required_device<cpu_device> m_maincpu;
38		required_device<device_t> m_beep;
	38	required_device<beep_device> m_beep;
39	39	DECLARE_READ8_MEMBER(lx800_porta_r);
40	40	DECLARE_WRITE8_MEMBER(lx800_porta_w);
41	41	DECLARE_READ8_MEMBER(lx800_portc_r);

trunk/src/mess/drivers/zrt80.c
r19155	r19156
36	36	required_device<cpu_device> m_maincpu;
37	37	required_device<mc6845_device> m_crtc;
38	38	required_device<ins8250_device> m_8250;
39		required_device<device_t> m_beep;
	39	required_device<beep_device> m_beep;
40	40	DECLARE_READ8_MEMBER(zrt80_10_r);
41	41	DECLARE_WRITE8_MEMBER(zrt80_30_w);
42	42	DECLARE_WRITE8_MEMBER(zrt80_38_w);

trunk/src/mess/drivers/svmu.c
r19155	r19156
32	32
33	33	required_device<lc8670_cpu_device> m_maincpu;
34	34	required_device<intelfsh8_device> m_flash;
35		required_device<device_t> m_speaker;
	35	required_device<speaker_sound_device> m_speaker;
36	36
37	37	virtual void palette_init();
38	38	virtual void machine_reset();

trunk/src/mess/drivers/m20.c
r19155	r19156
65	65	required_device<i8251_device> m_kbdi8251;
66	66	required_device<i8251_device> m_ttyi8251;
67	67	required_device<i8255_device> m_i8255;
68		required_device<device_t> m_i8259;
69		required_device<device_t> m_wd177x;
	68	required_device<pic8259_device> m_i8259;
	69	required_device<fd1797_device> m_wd177x;
70	70
71	71	required_shared_ptr<UINT16> m_p_videoram;
72	72

trunk/src/mess/drivers/wangpc.c
r19155	r19156
17	17	*/
18	18
19	19	#include "includes/wangpc.h"
20		#include "formats/mfi_dsk.h"
21	20
22	21
23	22	//**************************************************************************
r19155	r19156
1197	1196	int wangpc_state::on_disk0_load(floppy_image_device *image)
1198	1197	{
1199	1198	on_disk0_unload(image);
	1199
1200	1200	return IMAGE_INIT_PASS;
1201	1201	}
1202	1202
r19155	r19156
1215	1215
1216	1216	int wangpc_state::on_disk1_load(floppy_image_device *image)
1217	1217	{
1218		on_disk0_unload(image);
	1218	on_disk1_unload(image);
	1219
1219	1220	return IMAGE_INIT_PASS;
1220	1221	}
1221	1222

trunk/src/mess/drivers/multi8.c
r19155	r19156
34	34	required_device<cpu_device> m_maincpu;
35	35	required_device<i8255_device> m_ppi;
36	36	required_device<mc6845_device> m_crtc;
37		required_device<device_t> m_beep;
	37	required_device<beep_device> m_beep;
38	38	DECLARE_WRITE8_MEMBER(multi8_6845_w);
39	39	DECLARE_READ8_MEMBER(key_input_r);
40	40	DECLARE_READ8_MEMBER(key_status_r);

trunk/src/mame/drivers/pcxt.c
r19155	r19156
90	90	UINT8 m_at_pages[0x10];
91	91	UINT8 m_pc_spkrdata, m_pc_input;
92	92
93		required_device<device_t> m_pit8253;
94		required_device<device_t> m_pic8259_1;
95		required_device<device_t> m_pic8259_2;
96		required_device<device_t> m_dma8237_1;
	93	required_device<pit8253_device> m_pit8253;
	94	required_device<pic8259_device> m_pic8259_1;
	95	required_device<pic8259_device> m_pic8259_2;
	96	required_device<i8237_device> m_dma8237_1;
97	97
98	98	DECLARE_READ8_MEMBER(disk_iobank_r);
99	99	DECLARE_WRITE8_MEMBER(disk_iobank_w);

trunk/src/mame/drivers/icecold.c
r19155	r19156
41	41
42	42	// devices
43	43	required_device<cpu_device> m_maincpu;
44		required_device<device_t> m_ay8910_0;
45		required_device<device_t> m_ay8910_1;
	44	required_device<ay8910_device> m_ay8910_0;
	45	required_device<ay8910_device> m_ay8910_1;
46	46	required_device<pia6821_device> m_pia1;
47	47
48	48	UINT8 m_digit; // scanlines from i8279

trunk/src/mame/includes/cidelsa.h
r19155	r19156
83	83	m_psg(*this, AY8910_TAG)
84	84	{ }
85	85
86		required_device<device_t> m_psg;
	86	required_device<ay8910_device> m_psg;
87	87
88	88	virtual void machine_start();
89	89

trunk/src/mame/includes/metro.h
r19155	r19156
40	40	required_device<cpu_device> m_maincpu;
41	41	optional_device<cpu_device> m_audiocpu;
42	42	optional_device<okim6295_device> m_oki;
43		optional_device<device_t> m_ymsnd;
	43	optional_device<ym2151_device> m_ymsnd;
44	44	optional_device<k053936_device> m_k053936;
45	45	/* memory pointers */
46	46	optional_shared_ptr<UINT16> m_vram_0;

199869 Revisions