Previous

199869 Revisions

Next

r22509 Tuesday 23rd April, 2013 at 07:11:57 UTC by Miodrag Milanović
made BEEP and RAM devices initialize in constructor of driver classes (nw)

[src/emu/sound]	beep.h
[src/mame/drivers]	deshoros.c dlair.c
[src/mess/drivers]	a5105.c ace.c alphatro.c aquarius.c bigbord2.c bmjr.c bml3.c comx35.c electron.c enterp.c ex800.c fidelz80.c fk1.c fm7.c fmtowns.c glasgow.c h19.c h8.c jr100.c jr200.c kaypro.c lx800.c mephisto.c micronic.c mmodular.c ms0515.c mstation.c multi8.c mz2000.c mz2500.c mz3500.c nc.c osborne1.c osi.c p8k.c pb1000.c pc100.c pc2000.c pc4.c pc8801.c pc9801.c pce220.c pcw.c pcw16.c portfoli.c psion.c pyl601.c qx10.c rex6000.c rt1715.c rx78.c sc2.c smc777.c spc1000.c studio2.c supercon.c thomson.c ti990_10.c ti990_4.c tmc1800.c tvc.c v1050.c vg5k.c vk100.c vt100.c vt220.c vt320.c vtech1.c x07.c x68k.c xerox820.c z9001.c zrt80.c
[src/mess/includes]	aim65.h apple1.h b2m.h bebox.h c65.h cgenie.h comx35.h dai.h dgn_beta.h electron.h enterp.h fidelz80.h fm7.h gb.h genpc.h kaypro.h llc.h lviv.h micronic.h mtx.h mz700.h nascom1.h nc.h osborne1.h osi.h partner.h pc.h pc1350.h pc4.h pcw.h pcw16.h portfoli.h pp01.h psion.h rmnimbus.h samcoupe.h studio2.h tmc1800.h x07.h x68k.h xerox820.h
[src/mess/machine]	aim65.c apple1.c apple2.c apple2gs.c apple3.c at.c b2m.c bebox.c c65.c cgenie.c dai.c dgn_beta.c electron.c galaxy.c gb.c genpc.c kay_kbd.c llc.c lviv.c mtx.c mz700.c nascom1.c partner.c pc.c pc1350.c pp01.c rmnimbus.c samcoupe.c vector06.c
[src/mess/video]	911_vdt.c apple3.c b2m.c epnick.c mac.c nc.c pcw.c pp01.c timex.c vector06.c x68k.c

trunk/src/emu/sound/beep.h

r22508	r22509
3	3	#ifndef __BEEP_H__
4	4	#define __BEEP_H__
5	5
6		#define BEEPER_TAG      "beeper"
7
8
9	6	//**************************************************************************
10	7	//  TYPE DEFINITIONS
11	8	//**************************************************************************

trunk/src/mess/machine/mz700.c

r22508	r22509
171	171
172	172	/* ram from 0xa000 to 0xbfff */
173	173	spc.install_readwrite_bank(0xa000, 0xbfff, "bank5");
174		membank("bank5")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xa000);
	174	membank("bank5")->set_base(m_ram->pointer() + 0xa000);
175	175	}
176	176	}
177	177
r22508	r22509
183	183	address_space &spc = m_maincpu->space(AS_PROGRAM);
184	184
185	185	spc.install_readwrite_bank(0x0000, 0x0fff, "bank1");
186		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	186	membank("bank1")->set_base(m_ram->pointer());
187	187	}
188	188
189	189	WRITE8_MEMBER(mz_state::mz800_bank_0_w)
r22508	r22509
191	191	address_space &spc = m_maincpu->space(AS_PROGRAM);
192	192
193	193	spc.install_readwrite_bank(0x0000, 0x7fff, "bank1");
194		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	194	membank("bank1")->set_base(m_ram->pointer());
195	195	}
196	196
197	197	READ8_MEMBER(mz_state::mz800_bank_1_r)
r22508	r22509
200	200
201	201	/* switch in ram from 0x1000 to 0x1fff */
202	202	spc.install_readwrite_bank(0x1000, 0x1fff, "bank2");
203		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x1000);
	203	membank("bank2")->set_base(m_ram->pointer() + 0x1000);
204	204
205	205	if (m_mz700_mode)
206	206	{
207	207	/* ram from 0xc000 to 0xcfff */
208	208	spc.install_readwrite_bank(0xc000, 0xcfff, "bank6");
209		membank("bank6")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xc000);
	209	membank("bank6")->set_base(m_ram->pointer() + 0xc000);
210	210	}
211	211	else
212	212	{
213	213	/* ram from 0x8000 to 0xbfff */
214	214	spc.install_readwrite_bank(0x8000, 0xbfff, "bank4");
215		membank("bank4")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x8000);
	215	membank("bank4")->set_base(m_ram->pointer() + 0x8000);
216	216	}
217	217
218	218	return 0xff;
r22508	r22509
228	228	if (!m_mz700_ram_lock)
229	229	{
230	230	spc.install_readwrite_bank(0xd000, 0xffff, "bank7");
231		membank("bank7")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xd000);
	231	membank("bank7")->set_base(m_ram->pointer() + 0xd000);
232	232	m_mz700_ram_vram = FALSE;
233	233	}
234	234	}
r22508	r22509
238	238	if (!m_mz800_ram_lock)
239	239	{
240	240	spc.install_readwrite_bank(0xe000, 0xffff, "bank8");
241		membank("bank8")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xe000);
	241	membank("bank8")->set_base(m_ram->pointer() + 0xe000);
242	242	m_mz800_ram_monitor = FALSE;
243	243	}
244	244	}
r22508	r22509
313	313
314	314	/* rest is ram is always ram in mz700 mode */
315	315	spc.install_readwrite_bank(0x1000, 0xcfff, "bank2");
316		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x1000);
	316	membank("bank2")->set_base(m_ram->pointer() + 0x1000);
317	317	}
318	318	else
319	319	{
r22508	r22509
324	324
325	325	/* ram from 0x2000 to 0x7fff */
326	326	spc.install_readwrite_bank(0x2000, 0x7fff, "bank3");
327		membank("bank3")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	327	membank("bank3")->set_base(m_ram->pointer());
328	328
329	329	if (m_hires_mode)
330	330	{
r22508	r22509
340	340
341	341	/* ram from 0xa000 to 0xbfff */
342	342	spc.install_readwrite_bank(0xa000, 0xbfff, "bank5");
343		membank("bank5")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xa000);
	343	membank("bank5")->set_base(m_ram->pointer() + 0xa000);
344	344	}
345	345
346	346	/* ram from 0xc000 to 0xdfff */
347	347	spc.install_readwrite_bank(0xc000, 0xdfff, "bank6");
348		membank("bank6")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xc000);
	348	membank("bank6")->set_base(m_ram->pointer() + 0xc000);
349	349
350	350	/* mz800 monitor rom from 0xe000 to 0xffff */
351	351	spc.install_read_bank(0xe000, 0xffff, "bank8");

trunk/src/mess/machine/dgn_beta.c

r22508	r22509
231	231	//
232	232	// Map block, $00-$BF are ram, $FC-$FF are Boot ROM
233	233	//
234		if ((MapPage*4) < ((machine().device<ram_device>(RAM_TAG)->size() / 1024)-1))     // Block is ram
	234	if ((MapPage*4) < ((m_ram->size() / 1024)-1))     // Block is ram
235	235	{
236	236	if (!is_last_page(Page))
237	237	{
238		readbank = &machine().device<ram_device>(RAM_TAG)->pointer()[MapPage*RamPageSize];
	238	readbank = &m_ram->pointer()[MapPage*RamPageSize];
239	239	if(m_LogDatWrites)
240	240	debug_console_printf(machine(), "Mapping page %X, pageno=%X, mess_ram)[%X]\n",Page,MapPage,(MapPage*RamPageSize));
241	241	}
242	242	else
243	243	{
244		readbank = &machine().device<ram_device>(RAM_TAG)->pointer()[(MapPage*RamPageSize)-256];
	244	readbank = &m_ram->pointer()[(MapPage*RamPageSize)-256];
245	245	logerror("Error RAM in Last page !\n");
246	246	}
247	247	write8_delegate func = bank_info[Page].func;
r22508	r22509
310	310
311	311	/* Map video ram to base of area it can use, that way we can take the literal RA */
312	312	/* from the 6845 without having to mask it ! */
313		//  videoram=&machine().device<ram_device>(RAM_TAG)->pointer()[TextVidBasePage*RamPageSize];
	313	//  videoram=&m_ram->pointer()[TextVidBasePage*RamPageSize];
314	314	}
315	315
316	316	// Return the value of a page register
r22508	r22509
1036	1036	wd17xx_dden_w(fdc, CLEAR_LINE);
1037	1037	wd17xx_set_drive(fdc, 0);
1038	1038
1039		m_videoram.set_target(machine().device<ram_device>(RAM_TAG)->pointer(),m_videoram.bytes());     /* Point video ram at the start of physical ram */
	1039	m_videoram.set_target(m_ram->pointer(),m_videoram.bytes());     /* Point video ram at the start of physical ram */
1040	1040
1041	1041	wd17xx_reset(fdc);
1042	1042	m_wd2797_written=0;

trunk/src/mess/machine/partner.c

r22508	r22509
142	142	{
143	143	address_space &space = m_maincpu->space(AS_PROGRAM);
144	144	UINT8 *rom = memregion("maincpu")->base();
145		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	145	UINT8 *ram = m_ram->pointer();
146	146
147	147	space.install_write_bank(0x0000, 0x07ff, "bank1");
148	148	space.install_write_bank(0x0800, 0x3fff, "bank2");

trunk/src/mess/machine/electron.c

r22508	r22509
171	171
172	172	WRITE8_MEMBER(electron_state::electron_ula_w)
173	173	{
174		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
175	174	int i = electron_palette_offset[(( offset >> 1 ) & 0x03)];
176	175	logerror( "ULA: write offset %02x <- %02x\n", offset & 0x0f, data );
177	176	switch( offset & 0x0f )
r22508	r22509
231	230	case 0x06:  /* Counter divider */
232	231	if ( m_ula.communication_mode == 0x01)
233	232	{
234		speaker->set_frequency( 1000000 / ( 16 * ( data + 1 ) ) );
	233	m_beeper->set_frequency( 1000000 / ( 16 * ( data + 1 ) ) );
235	234	}
236	235	break;
237	236	case 0x07:  /* Misc. */
r22508	r22509
239	238	switch( m_ula.communication_mode )
240	239	{
241	240	case 0x00:  /* cassette input */
242		speaker->set_state( 0 );
	241	m_beeper->set_state( 0 );
243	242	electron_tape_start();
244	243	break;
245	244	case 0x01:  /* sound generation */
246		speaker->set_state( 1 );
	245	m_beeper->set_state( 1 );
247	246	electron_tape_stop();
248	247	break;
249	248	case 0x02:  /* cassette output */
250		speaker->set_state( 0 );
	249	m_beeper->set_state( 0 );
251	250	electron_tape_stop();
252	251	break;
253	252	case 0x03:  /* not used */
254		speaker->set_state( 0 );
	253	m_beeper->set_state( 0 );
255	254	electron_tape_stop();
256	255	break;
257	256	}
r22508	r22509
309	308
310	309	TIMER_CALLBACK_MEMBER(electron_state::setup_beep)
311	310	{
312		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
313		speaker->set_state( 0 );
314		speaker->set_frequency( 300 );
	311	m_beeper->set_state( 0 );
	312	m_beeper->set_frequency( 300 );
315	313	}
316	314
317	315	void electron_state::machine_reset()

trunk/src/mess/machine/b2m.c

r22508	r22509
44	44	{
45	45	UINT8 *rom;
46	46	address_space &space = m_maincpu->space(AS_PROGRAM);
47		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	47	UINT8 *ram = m_ram->pointer();
48	48
49	49	space.install_write_bank(0x0000, 0x27ff, "bank1");
50	50	space.install_write_bank(0x2800, 0x2fff, "bank2");

trunk/src/mess/machine/samcoupe.c

r22508	r22509
114	114	UINT8 *mem;
115	115
116	116	/* bank 3 */
117		if (m_lext >> 6 < space.machine().device<ram_device>(RAM_TAG)->size() >> 20)
118		mem = &space.machine().device<ram_device>(RAM_TAG)->pointer()[(space.machine().device<ram_device>(RAM_TAG)->size() & 0xfffff) + (m_lext >> 6) * 0x100000 + (m_lext & 0x3f) * 0x4000];
	117	if (m_lext >> 6 < m_ram->size() >> 20)
	118	mem = &m_ram->pointer()[(m_ram->size() & 0xfffff) + (m_lext >> 6) * 0x100000 + (m_lext & 0x3f) * 0x4000];
119	119	else
120	120	mem = NULL;
121	121
122	122	samcoupe_update_bank(space, 3, mem, FALSE);
123	123
124	124	/* bank 4 */
125		if (m_hext >> 6 < space.machine().device<ram_device>(RAM_TAG)->size() >> 20)
126		mem = &space.machine().device<ram_device>(RAM_TAG)->pointer()[(space.machine().device<ram_device>(RAM_TAG)->size() & 0xfffff) + (m_hext >> 6) * 0x100000 + (m_hext & 0x3f) * 0x4000];
	125	if (m_hext >> 6 < m_ram->size() >> 20)
	126	mem = &m_ram->pointer()[(m_ram->size() & 0xfffff) + (m_hext >> 6) * 0x100000 + (m_hext & 0x3f) * 0x4000];
127	127	else
128	128	mem = NULL;
129	129
r22508	r22509
133	133
134	134	void samcoupe_state::samcoupe_update_memory(address_space &space)
135	135	{
136		const int PAGE_MASK = ((machine().device<ram_device>(RAM_TAG)->size() & 0xfffff) / 0x4000) - 1;
	136	const int PAGE_MASK = ((m_ram->size() & 0xfffff) / 0x4000) - 1;
137	137	UINT8 *rom = memregion("maincpu")->base();
138	138	UINT8 *memory;
139	139	int is_readonly;
r22508	r22509
142	142	if (m_lmpr & LMPR_RAM0)   /* Is ram paged in at bank 1 */
143	143	{
144	144	if ((m_lmpr & 0x1F) <= PAGE_MASK)
145		memory = &machine().device<ram_device>(RAM_TAG)->pointer()[(m_lmpr & PAGE_MASK) * 0x4000];
	145	memory = &m_ram->pointer()[(m_lmpr & PAGE_MASK) * 0x4000];
146	146	else
147	147	memory = NULL;  /* Attempt to page in non existant ram region */
148	148	is_readonly = FALSE;
r22508	r22509
157	157
158	158	/* BANK2 */
159	159	if (((m_lmpr + 1) & 0x1f) <= PAGE_MASK)
160		memory = &machine().device<ram_device>(RAM_TAG)->pointer()[((m_lmpr + 1) & PAGE_MASK) * 0x4000];
	160	memory = &m_ram->pointer()[((m_lmpr + 1) & PAGE_MASK) * 0x4000];
161	161	else
162	162	memory = NULL;  /* Attempt to page in non existant ram region */
163	163	samcoupe_update_bank(space, 2, memory, FALSE);
r22508	r22509
171	171	{
172	172	/* BANK3 */
173	173	if ((m_hmpr & 0x1F) <= PAGE_MASK )
174		memory = &machine().device<ram_device>(RAM_TAG)->pointer()[(m_hmpr & PAGE_MASK)*0x4000];
	174	memory = &m_ram->pointer()[(m_hmpr & PAGE_MASK)*0x4000];
175	175	else
176	176	memory = NULL;  /* Attempt to page in non existant ram region */
177	177	samcoupe_update_bank(space, 3, memory, FALSE);
r22508	r22509
186	186	else
187	187	{
188	188	if (((m_hmpr + 1) & 0x1f) <= PAGE_MASK)
189		memory = &space.machine().device<ram_device>(RAM_TAG)->pointer()[((m_hmpr + 1) & PAGE_MASK) * 0x4000];
	189	memory = &m_ram->pointer()[((m_hmpr + 1) & PAGE_MASK) * 0x4000];
190	190	else
191	191	memory = NULL;  /* Attempt to page in non existant ram region */
192	192	is_readonly = FALSE;
r22508	r22509
196	196
197	197	/* video memory location */
198	198	if (m_vmpr & 0x40)   /* if bit set in 2 bank screen mode */
199		m_videoram = &machine().device<ram_device>(RAM_TAG)->pointer()[((m_vmpr & 0x1e) & PAGE_MASK) * 0x4000];
	199	m_videoram = &m_ram->pointer()[((m_vmpr & 0x1e) & PAGE_MASK) * 0x4000];
200	200	else
201		m_videoram = &machine().device<ram_device>(RAM_TAG)->pointer()[((m_vmpr & 0x1f) & PAGE_MASK) * 0x4000];
	201	m_videoram = &m_ram->pointer()[((m_vmpr & 0x1f) & PAGE_MASK) * 0x4000];
202	202	}
203	203
204	204

trunk/src/mess/machine/apple2gs.c

r22508	r22509
1576	1576
1577	1577	if ((m_shadow & 0x40) && ((address & 0xF00000) == 0x000000)) // shadow all banks and C0xx?
1578	1578	{
1579		result = machine().device<ram_device>(RAM_TAG)->pointer()[address];
	1579	result = m_ram->pointer()[address];
1580	1580	}
1581	1581	else if ((address & 0x000F00) == 0x000000)  // accessing C0xx?
1582	1582	{
r22508	r22509
1667	1667
1668	1668	if ((m_shadow & 0x40) && ((address & 0xF00000) == 0x000000))
1669	1669	{
1670		machine().device<ram_device>(RAM_TAG)->pointer()[address] = data;
	1670	m_ram->pointer()[address] = data;
1671	1671	}
1672	1672	else if ((address & 0x000F00) == 0x000000)
1673	1673	{
r22508	r22509
1745	1745	{
1746	1746	if ((m_shadow & 0x40) && ((address & 0xF00000) == 0x000000))
1747	1747	{
1748		opptr = &machine().device<ram_device>(RAM_TAG)->pointer()[address];
	1748	opptr = &m_ram->pointer()[address];
1749	1749	}
1750	1750	else if ((address & 0x000F00) == 0x000000)
1751	1751	{
r22508	r22509
1829	1829	// otherwise nothing works :)
1830	1830	if (m_is_rom3)
1831	1831	{
1832		int ramsize = machine().device<ram_device>(RAM_TAG)->size();
	1832	int ramsize = m_ram->size();
1833	1833
1834	1834	// ROM 03 hardware: the quoted "1 MB" for a base machine doesn't include banks e0/e1, so map accordingly
1835	1835	space.install_readwrite_bank(0x010000, ramsize - 1, "bank1");
1836		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x010000);
	1836	membank("bank1")->set_base(m_ram->pointer() + 0x010000);
1837	1837
1838	1838	space.install_read_handler( ramsize, 0xdfffff, read8_delegate(FUNC(apple2gs_state::apple2gs_bank_echo_r),this));
1839	1839	m_echo_bank = (ramsize >> 16);
1840	1840	}
1841	1841	else
1842	1842	{
1843		int ramsize = machine().device<ram_device>(RAM_TAG)->size()-0x30000;
	1843	int ramsize = m_ram->size()-0x30000;
1844	1844
1845	1845	// ROM 00/01 hardware: the quoted "256K" for a base machine *does* include banks e0/e1.
1846	1846	space.install_readwrite_bank(0x010000, ramsize - 1 + 0x10000, "bank1");
1847		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x010000);
	1847	membank("bank1")->set_base(m_ram->pointer() + 0x010000);
1848	1848
1849	1849	space.install_read_handler( ramsize + 0x10000, 0xdfffff, read8_delegate(FUNC(apple2gs_state::apple2gs_bank_echo_r),this));
1850	1850	m_echo_bank = (ramsize+0x10000) >> 16;
r22508	r22509
1971	1971	machine().device<nvram_device>("nvram")->set_base(m_clock_bram, sizeof(m_clock_bram));
1972	1972
1973	1973	/* save state stuff.  note that the driver takes care of docram. */
1974		UINT8* ram = machine().device<ram_device>(RAM_TAG)->pointer();
1975		state_save_register_item_pointer(machine(), "APPLE2GS_RAM", NULL, 0, ram, machine().device<ram_device>(RAM_TAG)->size());
	1974	UINT8* ram = m_ram->pointer();
	1975	state_save_register_item_pointer(machine(), "APPLE2GS_RAM", NULL, 0, ram, m_ram->size());
1976	1976
1977	1977	state_save_register_item(machine(), "NEWVIDEO", NULL, 0, m_newvideo);
1978	1978	state_save_register_item(machine(), "BORDERCOLOR", NULL, 0, m_bordercolor);

trunk/src/mess/machine/cgenie.c

r22508	r22509
146	146	memset(gfx + i * 8, i, 8);
147	147
148	148	/* set up RAM */
149		space.install_read_bank(0x4000, 0x4000 + machine().device<ram_device>(RAM_TAG)->size() - 1, "bank1");
150		space.install_write_handler(0x4000, 0x4000 + machine().device<ram_device>(RAM_TAG)->size() - 1, write8_delegate(FUNC(cgenie_state::cgenie_videoram_w),this));
151		m_videoram = machine().device<ram_device>(RAM_TAG)->pointer();
152		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	149	space.install_read_bank(0x4000, 0x4000 + m_ram->size() - 1, "bank1");
	150	space.install_write_handler(0x4000, 0x4000 + m_ram->size() - 1, write8_delegate(FUNC(cgenie_state::cgenie_videoram_w),this));
	151	m_videoram = m_ram->pointer();
	152	membank("bank1")->set_base(m_ram->pointer());
153	153	machine().scheduler().timer_pulse(attotime::from_hz(11025), timer_expired_delegate(FUNC(cgenie_state::handle_cassette_input),this));
154	154	}
155	155

trunk/src/mess/machine/llc.c

r22508	r22509
147	147	/* Driver initialization */
148	148	DRIVER_INIT_MEMBER(llc_state,llc2)
149	149	{
150		m_p_videoram.set_target( machine().device<ram_device>(RAM_TAG)->pointer() + 0xc000,m_p_videoram.bytes());
	150	m_p_videoram.set_target( m_ram->pointer() + 0xc000,m_p_videoram.bytes());
151	151	}
152	152
153	153	MACHINE_RESET_MEMBER(llc_state,llc2)
r22508	r22509
164	164	membank("bank3")->set_base(memregion("maincpu")->base() + 0x6000);
165	165
166	166	space.install_write_bank(0xc000, 0xffff, "bank4");
167		membank("bank4")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xc000);
	167	membank("bank4")->set_base(m_ram->pointer() + 0xc000);
168	168
169	169	}
170	170
171	171	WRITE8_MEMBER(llc_state::llc2_rom_disable_w)
172	172	{
173	173	address_space &mem_space = m_maincpu->space(AS_PROGRAM);
174		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	174	UINT8 *ram = m_ram->pointer();
175	175
176	176	mem_space.install_write_bank(0x0000, 0xbfff, "bank1");
177	177	membank("bank1")->set_base(ram);
r22508	r22509
198	198	else
199	199	{
200	200	mem_space.install_write_bank(0x4000, 0x5fff, "bank2");
201		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x4000);
	201	membank("bank2")->set_base(m_ram->pointer() + 0x4000);
202	202	}
203	203
204	204	}

trunk/src/mess/machine/apple1.c

r22508	r22509
135	135	{
136	136	address_space& space = m_maincpu->space(AS_PROGRAM);
137	137	/* Set up the handlers for MESS's dynamically-sized RAM. */
138		space.install_readwrite_bank(0x0000, machine().device<ram_device>(RAM_TAG)->size() - 1, "bank1");
139		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	138	space.install_readwrite_bank(0x0000, m_ram->size() - 1, "bank1");
	139	membank("bank1")->set_base(m_ram->pointer());
140	140
141	141	/* Poll the keyboard input ports periodically.  These include both
142	142	ordinary keys and the RESET and CLEAR SCREEN pushbutton
r22508	r22509
233	233
234	234	end_addr = start_addr + datasize - 1;
235	235
236		if ((start_addr < 0xE000 && end_addr > machine().device<ram_device>(RAM_TAG)->size() - 1)
	236	if ((start_addr < 0xE000 && end_addr > m_ram->size() - 1)
237	237	|| end_addr > 0xEFFF)
238	238	{
239	239	logerror("apple1 - Snapshot won't fit in this memory configuration;\n"

trunk/src/mess/machine/apple3.c

r22508	r22509
262	262	{
263	263	if (bank != (UINT16) ~0)
264	264	{
265		bank %= machine().device<ram_device>(RAM_TAG)->size() / 0x8000;
266		if ((bank + 1) == (machine().device<ram_device>(RAM_TAG)->size() / 0x8000))
	265	bank %= m_ram->size() / 0x8000;
	266	if ((bank + 1) == (m_ram->size() / 0x8000))
267	267	bank = 0x02;
268	268	}
269	269	offset += ((offs_t) bank) * 0x8000;
270		offset %= machine().device<ram_device>(RAM_TAG)->size();
271		return &machine().device<ram_device>(RAM_TAG)->pointer()[offset];
	270	offset %= m_ram->size();
	271	return &m_ram->pointer()[offset];
272	272	}
273	273
274	274
r22508	r22509
283	283	if (LOG_MEMORY)
284	284	{
285	285	#ifdef PTR64
286		//logerror("\tbank %s --> %02x/%04x [0x%08lx]\n", mame_bank, (unsigned) bank, (unsigned)offset, ptr - machine().device<ram_device>(RAM_TAG)->pointer());
	286	//logerror("\tbank %s --> %02x/%04x [0x%08lx]\n", mame_bank, (unsigned) bank, (unsigned)offset, ptr - m_ram->pointer());
287	287	#else
288		logerror("\tbank %s --> %02x/%04x [0x%08lx]\n", mame_bank, (unsigned) bank, (unsigned)offset, ptr - machine().device<ram_device>(RAM_TAG)->pointer());
	288	logerror("\tbank %s --> %02x/%04x [0x%08lx]\n", mame_bank, (unsigned) bank, (unsigned)offset, ptr - m_ram->pointer());
289	289	#endif
290	290	}
291	291	#endif
r22508	r22509
568	568	else if (offset > 0x9FFF)
569	569	result = apple3_bankaddr(~0, offset - 0x8000);
570	570	else
571		result = &machine().device<ram_device>(RAM_TAG)->pointer()[offset - 0x2000];
	571	result = &m_ram->pointer()[offset - 0x2000];
572	572	}
573	573	else if ((n >= 0x80) && (n <= 0x8E))
574	574	{

trunk/src/mess/machine/pc1350.c

r22508	r22509
96	96	machine().scheduler().timer_set(attotime::from_seconds(1), timer_expired_delegate(FUNC(pc1350_state::pc1350_power_up),this));
97	97
98	98	space.install_readwrite_bank(0x6000, 0x6fff, "bank1");
99		membank("bank1")->set_base(&machine().device<ram_device>(RAM_TAG)->pointer()[0x0000]);
	99	membank("bank1")->set_base(&m_ram->pointer()[0x0000]);
100	100
101		if (machine().device<ram_device>(RAM_TAG)->size() >= 0x3000)
	101	if (m_ram->size() >= 0x3000)
102	102	{
103	103	space.install_readwrite_bank(0x4000, 0x5fff, "bank2");
104		membank("bank2")->set_base(&machine().device<ram_device>(RAM_TAG)->pointer()[0x1000]);
	104	membank("bank2")->set_base(&m_ram->pointer()[0x1000]);
105	105	}
106	106	else
107	107	{
108	108	space.nop_readwrite(0x4000, 0x5fff);
109	109	}
110	110
111		if (machine().device<ram_device>(RAM_TAG)->size() >= 0x5000)
	111	if (m_ram->size() >= 0x5000)
112	112	{
113	113	space.install_readwrite_bank(0x2000, 0x3fff, "bank3");
114		membank("bank3")->set_base(&machine().device<ram_device>(RAM_TAG)->pointer()[0x3000]);
	114	membank("bank3")->set_base(&m_ram->pointer()[0x3000]);
115	115	}
116	116	else
117	117	{

trunk/src/mess/machine/bebox.c

r22508	r22509
1013	1013	membank("bank2")->set_base(memregion("user2")->base());
1014	1014
1015	1015	/* install MESS managed RAM */
1016		space_0.install_readwrite_bank(0, machine().device<ram_device>(RAM_TAG)->size() - 1, 0, 0x02000000, "bank3");
1017		space_1.install_readwrite_bank(0, machine().device<ram_device>(RAM_TAG)->size() - 1, 0, 0x02000000, "bank3");
1018		membank("bank3")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	1016	space_0.install_readwrite_bank(0, m_ram->size() - 1, 0, 0x02000000, "bank3");
	1017	space_1.install_readwrite_bank(0, m_ram->size() - 1, 0, 0x02000000, "bank3");
	1018	membank("bank3")->set_base(m_ram->pointer());
1019	1019
1020	1020	/* The following is a verrrry ugly hack put in to support NetBSD for
1021	1021	* NetBSD.  When NetBSD/bebox it does most of its work on CPU #0 and then

trunk/src/mess/machine/genpc.c

r22508	r22509
564	564	m_ppi8255(*this, "ppi8255"),
565	565	m_speaker(*this, "speaker"),
566	566	m_isabus(*this, "isa"),
567		m_pc_kbdc(*this, "pc_kbdc")
	567	m_pc_kbdc(*this, "pc_kbdc"),
	568	m_ram(*this, RAM_TAG)
568	569	{
569	570	}
570	571
r22508	r22509
648	649	install_device(this,    0x0080, 0x0087, 0, 0, FUNC(pc_page_r), FUNC(pc_page_w) );
649	650	install_device_write(this,    0x00a0, 0x00a1, 0, 0, FUNC(nmi_enable_w));
650	651	/* MESS managed RAM */
651		if ( machine().device<ram_device>(RAM_TAG)->pointer() )
652		membank( "bank10" )->set_base( machine().device<ram_device>(RAM_TAG)->pointer() );
	652	if ( m_ram->pointer() )
	653	membank( "bank10" )->set_base( m_ram->pointer() );
653	654	}
654	655
655	656	IRQ_CALLBACK_MEMBER(ibm5160_mb_device::pc_irq_callback)
r22508	r22509
761	762	* 6-7  The number of floppy disk drives
762	763	*/
763	764	data = ioport("DSW0")->read() & 0xF3;
764		switch ( machine().device<ram_device>(RAM_TAG)->size() )
	765	switch ( m_ram->size() )
765	766	{
766	767	case 16 * 1024:
767	768	data |= 0x00;
r22508	r22509
799	800	/* read hi nibble of SW2 */
800	801	data = data & 0xf0;
801	802
802		switch ( machine().device<ram_device>(RAM_TAG)->size() - 64 * 1024 )
	803	switch ( m_ram->size() - 64 * 1024 )
803	804	{
804	805	case 64 * 1024:     data |= 0x00; break;
805	806	case 128 * 1024:    data |= 0x02; break;
r22508	r22509
817	818	case 896 * 1024:    data |= 0x0B; break;
818	819	case 960 * 1024:    data |= 0x0D; break;
819	820	}
820		if ( machine().device<ram_device>(RAM_TAG)->size() > 960 * 1024 )
	821	if ( m_ram->size() > 960 * 1024 )
821	822	data |= 0x0D;
822	823
823	824	PIO_LOG(1,"PIO_C_r (hi)",("$%02x\n", data));

trunk/src/mess/machine/gb.c

r22508	r22509
110	110	MBC_UNKNOWN,    /* Unknown mapper                                */
111	111	};
112	112
113		/* machine.device<ram_device>(RAM_TAG)->pointer() layout defines */
	113	/* RAM layout defines */
114	114	#define CGB_START_VRAM_BANKS    0x0000
115	115	#define CGB_START_RAM_BANKS ( 2 * 8 * 1024 )
116	116
r22508	r22509
255	255	/* Allocate memory for internal ram */
256	256	for (ii = 0; ii < 8; ii++)
257	257	{
258		m_GBC_RAMMap[ii] = machine().device<ram_device>(RAM_TAG)->pointer() + CGB_START_RAM_BANKS + ii * 0x1000;
	258	m_GBC_RAMMap[ii] = m_ram->pointer() + CGB_START_RAM_BANKS + ii * 0x1000;
259	259	memset(m_GBC_RAMMap[ii], 0, 0x1000);
260	260	}
261	261	}

trunk/src/mess/machine/rmnimbus.c

r22508	r22509
1951	1951	void rmnimbus_state::nimbus_bank_memory()
1952	1952	{
1953	1953	address_space &space = machine().device( MAINCPU_TAG)->memory().space( AS_PROGRAM );
1954		int     ramsize = machine().device<ram_device>(RAM_TAG)->size();
	1954	int     ramsize = m_ram->size();
1955	1955	int     ramblock = 0;
1956	1956	int     blockno;
1957	1957	char    bank[10];
1958		UINT8   *ram    = &machine().device<ram_device>(RAM_TAG)->pointer()[0];
	1958	UINT8   *ram    = &m_ram->pointer()[0];
1959	1959	UINT8   *map_blocks[3];
1960	1960	UINT8   *map_base;
1961	1961	int     map_blockno;

trunk/src/mess/machine/c65.c

r22508	r22509
601	601	READ8_MEMBER( c65_state::c65_ram_expansion_r )
602	602	{
603	603	UINT8 data = 0xff;
604		if (machine().device<ram_device>(RAM_TAG)->size() > (128 * 1024))
	604	if (m_ram->size() > (128 * 1024))
605	605	data = m_expansion_ram.reg;
606	606	return data;
607	607	}
r22508	r22509
611	611	offs_t expansion_ram_begin;
612	612	offs_t expansion_ram_end;
613	613
614		if (space.machine().device<ram_device>(RAM_TAG)->size() > (128 * 1024))
	614	if (m_ram->size() > (128 * 1024))
615	615	{
616	616	m_expansion_ram.reg = data;
617	617
618	618	expansion_ram_begin = 0x80000;
619		expansion_ram_end = 0x80000 + (machine().device<ram_device>(RAM_TAG)->size() - 128*1024) - 1;
	619	expansion_ram_end = 0x80000 + (m_ram->size() - 128*1024) - 1;
620	620
621	621	if (data == 0x00) {
622	622	space.install_readwrite_bank(expansion_ram_begin, expansion_ram_end,"bank16");
623		membank("bank16")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 128*1024);
	623	membank("bank16")->set_base(m_ram->pointer() + 128*1024);
624	624	} else {
625	625	space.nop_readwrite(expansion_ram_begin, expansion_ram_end);
626	626	}
r22508	r22509
985	985	MACHINE_START_MEMBER(c65_state,c65)
986	986	{
987	987	/* clear upper memory */
988		memset(machine().device<ram_device>(RAM_TAG)->pointer() + 128*1024, 0xff, machine().device<ram_device>(RAM_TAG)->size() -  128*1024);
	988	memset(m_ram->pointer() + 128*1024, 0xff, m_ram->size() -  128*1024);
989	989
990	990	//removed   cbm_drive_0_config (SERIAL, 10);
991	991	//removed   cbm_drive_1_config (SERIAL, 11);

trunk/src/mess/machine/galaxy.c

r22508	r22509
85	85	m_maincpu->set_state_int(Z80_I,    data[0x40]);
86	86	m_maincpu->set_state_int(Z80_R,    (data[0x44] & 0x7f) | (data[0x48] & 0x80));
87	87
88		memcpy (machine().device<ram_device>(RAM_TAG)->pointer(), data + 0x084c, (machine().device<ram_device>(RAM_TAG)->size() < 0x1800) ? machine().device<ram_device>(RAM_TAG)->size() : 0x1800);
	88	memcpy (m_ram->pointer(), data + 0x084c, (m_ram->size() < 0x1800) ? m_ram->size() : 0x1800);
89	89
90	90	break;
91	91	case GALAXY_SNAPSHOT_V2_SIZE:
r22508	r22509
112	112	m_maincpu->set_state_int(Z80_I,    data[0x19]);
113	113	m_maincpu->set_state_int(Z80_R,    data[0x1a]);
114	114
115		memcpy (machine().device<ram_device>(RAM_TAG)->pointer(), data + 0x0834, (machine().device<ram_device>(RAM_TAG)->size() < 0x1800) ? machine().device<ram_device>(RAM_TAG)->size() : 0x1800);
	115	memcpy (m_ram->pointer(), data + 0x0834, (m_ram->size() < 0x1800) ? m_ram->size() : 0x1800);
116	116
117	117	break;
118	118	}
r22508	r22509
155	155	space.install_readwrite_bank( 0x2800, 0x2800 + m_ram->size() - 1, "bank1");
156	156	membank("bank1")->set_base(m_ram->pointer());
157	157
158		if (machine().device<ram_device>(RAM_TAG)->size() < (6 + 48) * 1024)
	158	if (m_ram->size() < (6 + 48) * 1024)
159	159	{
160		space.nop_readwrite( 0x2800 + machine().device<ram_device>(RAM_TAG)->size(), 0xffff);
	160	space.nop_readwrite( 0x2800 + m_ram->size(), 0xffff);
161	161	}
162	162
163	163	for ( int i = 0; i < 8; i++ )

trunk/src/mess/machine/kay_kbd.c

r22508	r22509
287	287	/* disable CapsLock LED initially */
288	288	set_led_status(machine(), 1, 1);
289	289	set_led_status(machine(), 1, 0);
290		kbd->beeper = machine().device<beep_device>(BEEPER_TAG);
	290	kbd->beeper = machine().device<beep_device>("beeper");
291	291	kbd->beep_on = 1;
292	292	kbd->control_status = 0x14;
293	293	kbd->beeper->set_state(0);

trunk/src/mess/machine/apple2.c

r22508	r22509
1128	1128	//CMemory::mState |= CMemory::kVBLBar; // N: VBL' is true // FIX: MESS?
1129	1129	}
1130	1130
1131		return m_ram->pointer()[address % machine().device<ram_device>(RAM_TAG)->size()]; // FIX: this seems to work, but is it right!?
	1131	return m_ram->pointer()[address % m_ram->size()]; // FIX: this seems to work, but is it right!?
1132	1132	}
1133	1133
1134	1134
r22508	r22509
2107	2107	if (memregion("maincpu")->bytes() < 0x8000)
2108	2108	m_a2_mask &= ~VAR_ROMSWITCH;
2109	2109
2110		if (machine().device<ram_device>(RAM_TAG)->size() <= 64*1024)
	2110	if (m_ram->size() <= 64*1024)
2111	2111	m_a2_mask &= ~(VAR_RAMRD | VAR_RAMWRT | VAR_80STORE | VAR_ALTZP | VAR_80COL);
2112	2112
2113	2113	apple2_refresh_delegates();

trunk/src/mess/machine/at.c

r22508	r22509
325	325	if (machine().device("cs4031") == NULL)
326	326	{
327	327	/* MESS managed RAM */
328		membank("bank10")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	328	membank("bank10")->set_base(m_ram->pointer());
329	329
330		if (machine().device<ram_device>(RAM_TAG)->size() > 0x0a0000)
	330	if (m_ram->size() > 0x0a0000)
331	331	{
332		offs_t ram_limit = 0x100000 + machine().device<ram_device>(RAM_TAG)->size() - 0x0a0000;
	332	offs_t ram_limit = 0x100000 + m_ram->size() - 0x0a0000;
333	333	space.install_read_bank(0x100000,  ram_limit - 1, "bank1");
334	334	space.install_write_bank(0x100000,  ram_limit - 1, "bank1");
335		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0xa0000);
	335	membank("bank1")->set_base(m_ram->pointer() + 0xa0000);
336	336	}
337	337	}
338	338

trunk/src/mess/machine/mtx.c

r22508	r22509
74	74
75	75	*/
76	76	address_space &program = m_maincpu->space(AS_PROGRAM);
77		ram_device *messram = machine().device<ram_device>(RAM_TAG);
	77	ram_device *messram = m_ram;
78	78
79	79	//  UINT8 cbm_mode = data >> 7 & 0x01;
80	80	UINT8 rom_page = data >> 4 & 0x07;
r22508	r22509
366	366
367	367	MACHINE_START_MEMBER(mtx_state,mtx512)
368	368	{
369		ram_device *messram = machine().device<ram_device>(RAM_TAG);
	369	ram_device *messram = m_ram;
370	370
371	371	/* find devices */
372	372	m_z80ctc = machine().device<z80ctc_device>(Z80CTC_TAG);

trunk/src/mess/machine/dai.c

r22508	r22509
116	116	machine().scheduler().timer_set(attotime::zero, timer_expired_delegate(FUNC(dai_state::dai_bootstrap_callback),this));
117	117	machine().scheduler().timer_pulse(attotime::from_hz(100), timer_expired_delegate(FUNC(dai_state::dai_timer),this)); /* timer for tms5501 */
118	118
119		memset(machine().device<ram_device>(RAM_TAG)->pointer(), 0, machine().device<ram_device>(RAM_TAG)->size());
	119	memset(m_ram->pointer(), 0, m_ram->size());
120	120	}
121	121
122	122	void dai_state::machine_reset()
123	123	{
124		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	124	membank("bank1")->set_base(m_ram->pointer());
125	125	}
126	126
127	127	/***************************************************************************

trunk/src/mess/machine/vector06.c

r22508	r22509
148	148
149	149	if (BIT(val, 1))
150	150	{
151		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x0000);
	151	membank("bank1")->set_base(m_ram->pointer() + 0x0000);
152	152	m_maincpu->reset();
153	153	}
154	154	}
r22508	r22509
177	177	space.install_write_bank(0x8000, 0xffff, "bank4");
178	178
179	179	membank("bank1")->set_base(memregion("maincpu")->base() + 0x10000);
180		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x0000);
181		membank("bank3")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x8000);
182		membank("bank4")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x8000);
	180	membank("bank2")->set_base(m_ram->pointer() + 0x0000);
	181	membank("bank3")->set_base(m_ram->pointer() + 0x8000);
	182	membank("bank4")->set_base(m_ram->pointer() + 0x8000);
183	183
184	184	m_keyboard_mask = 0;
185	185	m_color_index = 0;

trunk/src/mess/machine/lviv.c

r22508	r22509
26	26
27	27	void lviv_state::lviv_update_memory ()
28	28	{
29		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	29	UINT8 *ram = m_ram->pointer();
30	30
31	31	if (m_ppi_port_outputs[0][2] & 0x02)
32	32	{
r22508	r22509
164	164	address_space &cpuspace = m_maincpu->space(AS_PROGRAM);
165	165	if (m_startup_mem_map)
166	166	{
167		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	167	UINT8 *ram = m_ram->pointer();
168	168
169	169	m_startup_mem_map = 0;
170	170
r22508	r22509
226	226
227	227	space.set_direct_update_handler(direct_update_delegate(FUNC(lviv_state::lviv_directoverride), this));
228	228
229		m_video_ram = machine().device<ram_device>(RAM_TAG)->pointer() + 0xc000;
	229	m_video_ram = m_ram->pointer() + 0xc000;
230	230
231	231	m_startup_mem_map = 1;
232	232
r22508	r22509
243	243
244	244	/*machine().scheduler().timer_pulse(TIME_IN_NSEC(200), FUNC(lviv_draw_pixel));*/
245	245
246		/*memset(machine().device<ram_device>(RAM_TAG)->pointer(), 0, sizeof(unsigned char)*0xffff);*/
	246	/*memset(m_ram->pointer(), 0, sizeof(unsigned char)*0xffff);*/
247	247	}
248	248
249	249
r22508	r22509
287	287	m_maincpu->set_state_int(I8085_PC, (hi << 8) | lo);
288	288
289	289	/* Memory dump */
290		memcpy (machine().device<ram_device>(RAM_TAG)->pointer(), data+0x0011, 0xc000);
291		memcpy (machine().device<ram_device>(RAM_TAG)->pointer()+0xc000, data+0x10011, 0x4000);
	290	memcpy (m_ram->pointer(), data+0x0011, 0xc000);
	291	memcpy (m_ram->pointer()+0xc000, data+0x10011, 0x4000);
292	292
293	293	/* Ports */
294	294	m_ppi_port_outputs[0][0] = data[0x14011+0xc0];

trunk/src/mess/machine/aim65.c

r22508	r22509
140	140
141	141	void aim65_state::machine_start()
142	142	{
143		ram_device *ram = machine().device<ram_device>(RAM_TAG);
	143	ram_device *ram = m_ram;
144	144	address_space &space = m_maincpu->space(AS_PROGRAM);
145	145
146	146	/* Init RAM */

trunk/src/mess/machine/pc.c

r22508	r22509
1076	1076
1077	1077	data&=~0x80;
1078	1078	data &= ~0x04;      /* floppy drive installed */
1079		if ( machine().device<ram_device>(RAM_TAG)->size() > 64 * 1024 )    /* more than 64KB ram installed */
	1079	if ( m_ram->size() > 64 * 1024 )    /* more than 64KB ram installed */
1080	1080	data &= ~0x08;
1081	1081	data = ( data & ~0x01 ) | ( pcjr_keyb.latch ? 0x01: 0x00 );
1082	1082	if ( ! ( m_ppi_portb & 0x08 ) )
r22508	r22509
1414	1414	init_pc_common(set_keyb_int_func);
1415	1415
1416	1416	/* MESS managed RAM */
1417		if ( machine().device<ram_device>(RAM_TAG)->pointer() )
1418		membank( "bank10" )->set_base( machine().device<ram_device>(RAM_TAG)->pointer() );
	1417	if ( m_ram->pointer() )
	1418	membank( "bank10" )->set_base( m_ram->pointer() );
1419	1419	}
1420	1420
1421	1421

trunk/src/mess/machine/pp01.c

r22508	r22509
21	21	void pp01_state::pp01_video_w(UINT8 block,UINT16 offset,UINT8 data,UINT8 part)
22	22	{
23	23	UINT16 addroffset = part ? 0x1000  : 0x0000;
24		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	24	UINT8 *ram = m_ram->pointer();
25	25
26	26	if (BIT(m_video_write_mode,3)) {
27	27	// Copy mode
r22508	r22509
117	117	break;
118	118	}
119	119
120		membank(bank)->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + (data & 0x0F)* 0x1000);
	120	membank(bank)->set_base(m_ram->pointer() + (data & 0x0F)* 0x1000);
121	121	} else if (data>=0xF8) {
122	122	space.install_read_bank (startaddr, endaddr, bank);
123	123	space.unmap_write(startaddr, endaddr);

trunk/src/mess/machine/nascom1.c

r22508	r22509
257	257
258	258	DRIVER_INIT_MEMBER(nascom1_state,nascom1)
259	259	{
260		switch (machine().device<ram_device>(RAM_TAG)->size())
	260	switch (m_ram->size())
261	261	{
262	262	case 1 * 1024:
263	263	m_maincpu->space(AS_PROGRAM).nop_readwrite(
r22508	r22509
269	269	0x1400, 0x4fff, "bank1");
270	270	m_maincpu->space(AS_PROGRAM).nop_readwrite(
271	271	0x5000, 0xafff);
272		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	272	membank("bank1")->set_base(m_ram->pointer());
273	273	break;
274	274
275	275	case 32 * 1024:
r22508	r22509
277	277	0x1400, 0x8fff, "bank1");
278	278	m_maincpu->space(AS_PROGRAM).nop_readwrite(
279	279	0x9000, 0xafff);
280		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	280	membank("bank1")->set_base(m_ram->pointer());
281	281	break;
282	282
283	283	case 40 * 1024:
284	284	m_maincpu->space(AS_PROGRAM).install_readwrite_bank(
285	285	0x1400, 0xafff, "bank1");
286		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	286	membank("bank1")->set_base(m_ram->pointer());
287	287	break;
288	288	}
289	289	}

trunk/src/mess/includes/portfoli.h

r22508	r22509
46	46	m_y6(*this, "Y6"),
47	47	m_y7(*this, "Y7"),
48	48	m_battery(*this, "BATTERY"),
49		m_contrast(*this, "contrast")
	49	m_contrast(*this, "contrast"),
	50	m_ram(*this, RAM_TAG)
50	51	{ }
51	52
52	53	required_device<cpu_device> m_maincpu;
r22508	r22509
113	114	DECLARE_READ8_MEMBER(hd61830_rd_r);
114	115	IRQ_CALLBACK_MEMBER(portfolio_int_ack);
115	116	DECLARE_DEVICE_IMAGE_LOAD_MEMBER( portfolio_cart );
	117	required_device<ram_device> m_ram;
116	118	};
117	119
118	120	#endif

trunk/src/mess/includes/electron.h

r22508	r22509
12	12	#define ELECTRON_H_
13	13
14	14	#include "imagedev/cassette.h"
	15	#include "sound/beep.h"
15	16
16	17	/* Interrupts */
17	18	#define INT_HIGH_TONE       0x40
r22508	r22509
58	59	electron_state(const machine_config &mconfig, device_type type, const char *tag)
59	60	: driver_device(mconfig, type, tag),
60	61	m_maincpu(*this, "maincpu"),
61		m_cassette(*this, "cassette")   { }
	62	m_cassette(*this, "cassette"),
	63	m_beeper(*this, "beeper")   { }
62	64
63	65	ULA m_ula;
64	66	emu_timer *m_tape_timer;
r22508	r22509
84	86	TIMER_CALLBACK_MEMBER(electron_scanline_interrupt);
85	87	required_device<cpu_device> m_maincpu;
86	88	required_device<cassette_image_device> m_cassette;
	89	required_device<beep_device> m_beeper;
87	90	inline UINT8 read_vram( UINT16 addr );
88	91	inline void electron_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color);
89	92	void electron_interrupt_handler(int mode, int interrupt);

trunk/src/mess/includes/b2m.h

r22508	r22509
13	13	#include "machine/wd_fdc.h"
14	14	#include "sound/speaker.h"
15	15	#include "sound/wave.h"
	16	#include "machine/ram.h"
16	17
17	18	class b2m_state : public driver_device
18	19	{
r22508	r22509
20	21	b2m_state(const machine_config &mconfig, device_type type, const char *tag)
21	22	: driver_device(mconfig, type, tag),
22	23	m_maincpu(*this, "maincpu"),
23		m_speaker(*this, "speaker") { }
	24	m_speaker(*this, "speaker"),
	25	m_ram(*this, RAM_TAG) { }
24	26
25	27	UINT8 m_b2m_8255_porta;
26	28	UINT8 m_b2m_video_scroll;
r22508	r22509
42	44	fd1793_t *m_fdc;
43	45	device_t *m_pic;
44	46	required_device<speaker_sound_device> m_speaker;
	47	required_device<ram_device> m_ram;
45	48	DECLARE_READ8_MEMBER(b2m_keyboard_r);
46	49	DECLARE_WRITE8_MEMBER(b2m_palette_w);
47	50	DECLARE_READ8_MEMBER(b2m_palette_r);

trunk/src/mess/includes/nc.h

r22508	r22509
6	6
7	7	#ifndef NC_H_
8	8	#define NC_H_
	9	#include "machine/ram.h"
	10	#include "sound/beep.h"
9	11
10
11	12	#define NC_NUM_COLOURS 4
12	13
13	14	#define NC_SCREEN_WIDTH        480
r22508	r22509
30	31	public:
31	32	nc_state(const machine_config &mconfig, device_type type, const char *tag)
32	33	: driver_device(mconfig, type, tag),
33		m_maincpu(*this, "maincpu") { }
	34	m_maincpu(*this, "maincpu"),
	35	m_ram(*this, RAM_TAG),
	36	m_beeper1(*this, "beep.1"),
	37	m_beeper2(*this, "beep.2") { }
34	38
35	39	emu_timer *m_serial_timer;
36	40	char m_memory_config[4];
r22508	r22509
103	107	void nc100_machine_stop();
104	108	void nc200_machine_stop();
105	109	required_device<cpu_device> m_maincpu;
	110	required_device<ram_device> m_ram;
	111	required_device<beep_device> m_beeper1;
	112	required_device<beep_device> m_beeper2;
	113
106	114	void nc200_video_set_backlight(int state);
107	115	void nc_card_save(device_image_interface &image);
108	116	int nc_card_calculate_mask(int size);

trunk/src/mess/includes/pc1350.h

r22508	r22509
10	10	#define PC1350_H_
11	11
12	12	#include "machine/nvram.h"
	13	#include "machine/ram.h"
13	14
14	15	#define PC1350_CONTRAST (ioport("DSW0")->read() & 0x07)
15	16
r22508	r22509
19	20	public:
20	21	pc1350_state(const machine_config &mconfig, device_type type, const char *tag)
21	22	: driver_device(mconfig, type, tag),
22		m_maincpu(*this, "maincpu") { }
	23	m_maincpu(*this, "maincpu"),
	24	m_ram(*this, RAM_TAG) { }
23	25
24	26	UINT8 m_outa;
25	27	UINT8 m_outb;
r22508	r22509
41	43
42	44	virtual void machine_start();
43	45	required_device<cpu_device> m_maincpu;
	46	required_device<ram_device> m_ram;
44	47	};
45	48
46	49	#endif /* PC1350_H_ */

trunk/src/mess/includes/fidelz80.h

r22508	r22509
19	19	: driver_device(mconfig, type, tag),
20	20	m_maincpu(*this, "maincpu"),
21	21	m_speech(*this, "speech"),
22		m_beep(*this, BEEPER_TAG),
	22	m_beep(*this, "beeper"),
23	23	m_i8041(*this, "mcu"),
24	24	m_i8243(*this, "i8243")
25	25	{ }

trunk/src/mess/includes/pc4.h

r22508	r22509
18	18	pc4_state(const machine_config &mconfig, device_type type, const char *tag)
19	19	: driver_device(mconfig, type, tag),
20	20	m_maincpu(*this, "maincpu"),
21		m_beep(*this, BEEPER_TAG),
	21	m_beep(*this, "beeper"),
22	22	m_region_charset(*this, "charset"),
23	23	m_rombank(*this, "rombank") { }
24	24

trunk/src/mess/includes/psion.h

r22508	r22509
24	24	: driver_device(mconfig, type, tag),
25	25	m_maincpu(*this, "maincpu"),
26	26	m_lcdc(*this, "hd44780"),
27		m_beep(*this, BEEPER_TAG),
	27	m_beep(*this, "beeper"),
28	28	m_pack1(*this, "pack1"),
29	29	m_pack2(*this, "pack2"),
30	30	m_sys_register(*this, "sys_register"),

trunk/src/mess/includes/osborne1.h

r22508	r22509
28	28	m_pia0(*this, "pia_0"),
29	29	m_pia1(*this, "pia_1"),
30	30	m_fdc(*this, "mb8877"),
31		m_beep(*this, BEEPER_TAG),
	31	m_beep(*this, "beeper"),
32	32	m_ram(*this, RAM_TAG),
33	33	m_ieee(*this, IEEE488_TAG),
34	34	m_row0(*this, "ROW0"),

trunk/src/mess/includes/gb.h

r22508	r22509
8	8	#define GB_H_
9	9
10	10	#include "machine/gb_slot.h"
	11	#include "machine/ram.h"
11	12
12
13	13	/* Interrupts */
14	14	#define VBL_INT               0       /* V-Blank    */
15	15	#define LCD_INT               1       /* LCD Status */
r22508	r22509
116	116	m_custom(*this, "custom"),
117	117	m_region_maincpu(*this, "maincpu"),
118	118	m_rambank(*this, "cgb_ram"),
119		m_inputs(*this, "INPUTS") { }
	119	m_inputs(*this, "INPUTS"),
	120	m_ram(*this, RAM_TAG) { }
120	121
121	122	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
122	123
r22508	r22509
213	214	required_memory_region m_region_maincpu;
214	215	optional_memory_bank m_rambank;   // cgb
215	216	required_ioport m_inputs;
	217	optional_device<ram_device> m_ram;
216	218
217	219	void gb_timer_increment();
218	220	void gb_timer_check_irq();

trunk/src/mess/includes/pcw.h

r22508	r22509
8	8	#define PCW_H_
9	9
10	10	#include "machine/upd765.h"
	11	#include "machine/ram.h"
	12	#include "sound/beep.h"
11	13
12	14	#define PCW_BORDER_HEIGHT 8
13	15	#define PCW_BORDER_WIDTH 8
r22508	r22509
28	30	: driver_device(mconfig, type, tag),
29	31	m_maincpu(*this, "maincpu"),
30	32	m_screen(*this, "screen"),
31		m_fdc(*this, "upd765")
	33	m_fdc(*this, "upd765"),
	34	m_ram(*this, RAM_TAG),
	35	m_beeper(*this, "beeper")
32	36	{ }
33	37
34	38	int m_boot;
r22508	r22509
116	120	required_device<cpu_device> m_maincpu;
117	121	required_device<screen_device> m_screen;
118	122	required_device<upd765a_device> m_fdc;
	123	required_device<ram_device> m_ram;
	124	required_device<beep_device> m_beeper;
	125
119	126	inline void pcw_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color);
120	127	void pcw_update_interrupt_counter();
121	128	void pcw_update_irqs();

trunk/src/mess/includes/studio2.h

r22508	r22509
23	23	studio2_state(const machine_config &mconfig, device_type type, const char *tag)
24	24	: driver_device(mconfig, type, tag),
25	25	m_maincpu(*this, CDP1802_TAG),
26		m_speaker(*this, BEEPER_TAG),
	26	m_beeper(*this, "beeper"),
27	27	m_vdc(*this, CDP1861_TAG),
28	28	m_clear(*this, "CLEAR"),
29	29	m_a(*this, "A"),
r22508	r22509
31	31	{ }
32	32
33	33	required_device<cosmac_device> m_maincpu;
34		required_device<beep_device> m_speaker;
	34	required_device<beep_device> m_beeper;
35	35	optional_device<cdp1861_device> m_vdc;
36	36	required_ioport m_clear;
37	37	required_ioport m_a;

trunk/src/mess/includes/osi.h

r22508	r22509
45	45	m_io_row6(*this, "ROW6"),
46	46	m_io_row7(*this, "ROW7"),
47	47	m_io_sound(*this, "Sound"),
48		m_io_reset(*this, "Reset")
	48	m_io_reset(*this, "Reset"),
	49	m_beeper(*this, "beeper")
49	50	{ }
50	51
51	52	virtual void machine_start();
r22508	r22509
86	87	required_ioport m_io_row7;
87	88	required_ioport m_io_sound;
88	89	required_ioport m_io_reset;
	90	optional_device<beep_device> m_beeper;
89	91	};
90	92
91	93	class c1p_state : public sb2m600_state
r22508	r22509
93	95	public:
94	96	c1p_state(const machine_config &mconfig, device_type type, const char *tag)
95	97	: sb2m600_state(mconfig, type, tag),
96		m_beep(*this, BEEPER_TAG)
	98	m_beep(*this, "beeper")
97	99	{ }
98	100
99	101	required_device<beep_device> m_beep;

trunk/src/mess/includes/rmnimbus.h

r22508	r22509
10	10	#include "machine/wd17xx.h"
11	11	#include "machine/scsicb.h"
12	12	#include "machine/6522via.h"
	13	#include "machine/ram.h"
13	14
14	15	#define MAINCPU_TAG "maincpu"
15	16	#define IOCPU_TAG   "iocpu"
r22508	r22509
393	394	rmnimbus_state(const machine_config &mconfig, device_type type, const char *tag)
394	395	: driver_device(mconfig, type, tag),
395	396	m_scsibus(*this, SCSIBUS_TAG ":host"),
396		m_maincpu(*this, "maincpu") {
	397	m_maincpu(*this, "maincpu"),
	398	m_ram(*this, RAM_TAG) {
397	399	}
398	400
399	401	required_device<scsicb_device> m_scsibus;
r22508	r22509
469	471	void nimbus_scsi_linechange( UINT8 mask, UINT8 state );
470	472	IRQ_CALLBACK_MEMBER(int_callback);
471	473	required_device<cpu_device> m_maincpu;
	474	required_device<ram_device> m_ram;
472	475	UINT8 get_pixel(UINT16 x, UINT16 y);
473	476	UINT16 read_pixel_line(UINT16 x, UINT16 y, UINT8 width);
474	477	UINT16 read_pixel_data(UINT16 x, UINT16 y);

trunk/src/mess/includes/partner.h

r22508	r22509
10	10	#include "machine/i8255.h"
11	11	#include "machine/8257dma.h"
12	12	#include "machine/wd17xx.h"
	13	#include "machine/ram.h"
13	14
14	15	class partner_state : public radio86_state
15	16	{
16	17	public:
17	18	partner_state(const machine_config &mconfig, device_type type, const char *tag)
18		: radio86_state(mconfig, type, tag) { }
	19	: radio86_state(mconfig, type, tag),
	20	m_ram(*this, RAM_TAG) { }
19	21
20	22	UINT8 m_mem_page;
21	23	UINT8 m_win_mem_page;
r22508	r22509
32	34	void partner_window_2(UINT8 bank_num, UINT16 offset,UINT8 *rom);
33	35	void partner_iomap_bank(UINT8 *rom);
34	36	void partner_bank_switch();
	37	required_device<ram_device> m_ram;
35	38	};
36	39
37	40

trunk/src/mess/includes/samcoupe.h

r22508	r22509
14	14	#include "machine/wd_fdc.h"
15	15	#include "sound/speaker.h"
16	16	#include "imagedev/cassette.h"
	17	#include "machine/ram.h"
17	18
18	19	/* screen dimensions */
19	20	#define SAM_BLOCK           8
r22508	r22509
42	43	: driver_device(mconfig, type, tag),
43	44	m_maincpu(*this, "maincpu"),
44	45	m_speaker(*this, "speaker"),
45		m_cassette(*this, "cassette") {
	46	m_cassette(*this, "cassette"),
	47	m_ram(*this, RAM_TAG) {
46	48	sam_bank_read_ptr[0] = NULL;
47	49	sam_bank_write_ptr[0] = NULL;
48	50	sam_bank_read_ptr[1] = NULL;
r22508	r22509
124	126	required_device<cpu_device> m_maincpu;
125	127	required_device<speaker_sound_device> m_speaker;
126	128	required_device<cassette_image_device> m_cassette;
	129	required_device<ram_device> m_ram;
127	130	void draw_mode4_line(int y, int hpos);
128	131	void draw_mode3_line(int y, int hpos);
129	132	void draw_mode12_block(bitmap_ind16 &bitmap, int vpos, int hpos, UINT8 mask);

trunk/src/mess/includes/pp01.h

r22508	r22509
9	9
10	10	#include "machine/pit8253.h"
11	11	#include "machine/i8255.h"
	12	#include "machine/ram.h"
12	13
13	14	class pp01_state : public driver_device
14	15	{
15	16	public:
16	17	pp01_state(const machine_config &mconfig, device_type type, const char *tag)
17	18	: driver_device(mconfig, type, tag),
18		m_maincpu(*this, "maincpu") { }
	19	m_maincpu(*this, "maincpu"),
	20	m_ram(*this, RAM_TAG) { }
19	21
20	22	UINT8 m_video_scroll;
21	23	UINT8 m_memory_block[16];
r22508	r22509
44	46	DECLARE_WRITE8_MEMBER(pp01_8255_portc_w);
45	47	DECLARE_READ8_MEMBER(pp01_8255_portc_r);
46	48	required_device<cpu_device> m_maincpu;
	49	required_device<ram_device> m_ram;
47	50	void pp01_video_w(UINT8 block,UINT16 offset,UINT8 data,UINT8 part);
48	51	void pp01_set_memory(UINT8 block, UINT8 data);
49	52	};

trunk/src/mess/includes/cgenie.h

r22508	r22509
9	9
10	10	#include "machine/wd17xx.h"
11	11	#include "imagedev/cassette.h"
	12	#include "machine/ram.h"
12	13
13	14	// CRTC 6845
14	15	struct CRTC6845
r22508	r22509
43	44	m_colorram(*this, "colorram"),
44	45	m_fontram(*this, "fontram"),
45	46	m_maincpu(*this, "maincpu"),
46		m_cassette(*this, "cassette") { }
	47	m_cassette(*this, "cassette"),
	48	m_ram(*this, RAM_TAG) { }
47	49
48	50	required_shared_ptr<UINT8> m_colorram;
49	51	required_shared_ptr<UINT8> m_fontram;
r22508	r22509
82	84	DECLARE_WRITE8_MEMBER(cgenie_sh_control_port_w);
83	85	required_device<cpu_device> m_maincpu;
84	86	required_device<cassette_image_device> m_cassette;
	87	required_device<ram_device> m_ram;
	88
85	89	void cgenie_offset_xy();
86	90	int cgenie_get_register(int indx);
87	91	void cgenie_mode_select(int mode);

trunk/src/mess/includes/tmc1800.h

r22508	r22509
12	12	#include "machine/rescap.h"
13	13	#include "sound/cdp1864.h"
14	14	#include "video/cdp1861.h"
	15	#include "sound/beep.h"
15	16
16	17	#define TMC2000_COLORRAM_SIZE   0x200
17	18
r22508	r22509
29	30	m_cassette(*this, "cassette"),
30	31	m_rom(*this, CDP1802_TAG),
31	32	m_run(*this, "RUN"),
32		m_ram(*this, RAM_TAG)
	33	m_ram(*this, RAM_TAG),
	34	m_beeper(*this, "beeper")
33	35	{ }
34	36
35	37
r22508	r22509
38	40	required_memory_region m_rom;
39	41	required_ioport m_run;
40	42	required_device<ram_device> m_ram;
	43	optional_device<beep_device> m_beeper;
41	44
42	45	DECLARE_QUICKLOAD_LOAD_MEMBER( tmc1800 );
43	46	};

trunk/src/mess/includes/xerox820.h

r22508	r22509
114	114	public:
115	115	bigboard_state(const machine_config &mconfig, device_type type, const char *tag)
116	116	: xerox820_state(mconfig, type, tag),
117		m_beeper(*this, BEEPER_TAG)
	117	m_beeper(*this, "beeper")
118	118	{ }
119	119
120	120	required_device<beep_device> m_beeper;

trunk/src/mess/includes/nascom1.h

r22508	r22509
10	10	#include "imagedev/snapquik.h"
11	11	#include "machine/wd17xx.h"
12	12	#include "imagedev/cassette.h"
	13	#include "machine/ram.h"
13	14
14	15	struct nascom1_portstat_t
15	16	{
r22508	r22509
32	33	: driver_device(mconfig, type, tag),
33	34	m_videoram(*this, "videoram"),
34	35	m_maincpu(*this, "maincpu"),
35		m_cassette(*this, "cassette") { }
	36	m_cassette(*this, "cassette"),
	37	m_ram(*this, RAM_TAG) { }
36	38
37	39	required_shared_ptr<UINT8> m_videoram;
38	40	device_t *m_hd6402;
r22508	r22509
61	63	DECLARE_DEVICE_IMAGE_UNLOAD_MEMBER( nascom1_cassette );
62	64	required_device<cpu_device> m_maincpu;
63	65	required_device<cassette_image_device> m_cassette;
	66	required_device<ram_device> m_ram;
64	67	DECLARE_SNAPSHOT_LOAD_MEMBER( nascom1 );
65	68	};
66	69

trunk/src/mess/includes/micronic.h

r22508	r22509
26	26	: driver_device(mconfig, type, tag),
27	27	m_maincpu(*this, Z80_TAG),
28	28	m_lcdc(*this, HD61830_TAG),
29		m_beep(*this, BEEPER_TAG),
	29	m_beep(*this, "beeper"),
30	30	m_rtc(*this, MC146818_TAG),
31	31	m_ram(*this, RAM_TAG),
32	32	m_ram_base(*this, "ram_base"),

trunk/src/mess/includes/kaypro.h

r22508	r22509
27	27	m_centronics(*this, "centronics"),
28	28	m_fdc(*this, "wd1793"),
29	29	m_crtc(*this, "crtc"),
30		m_beep(*this, BEEPER_TAG),
	30	m_beep(*this, "beeper"),
31	31	m_p_videoram(*this, "p_videoram"){ }
32	32
33	33	required_device<cpu_device> m_maincpu;

trunk/src/mess/includes/mtx.h

r22508	r22509
12	12	#include "machine/ctronics.h"
13	13	#include "machine/z80ctc.h"
14	14	#include "sound/sn76496.h"
	15	#include "machine/ram.h"
15	16
16	17	#define Z80_TAG         "z80"
17	18	#define Z80CTC_TAG      "z80ctc"
r22508	r22509
30	31	: driver_device(mconfig, type, tag),
31	32	m_maincpu(*this, Z80_TAG),
32	33	m_sn(*this, SN76489A_TAG),
33		m_cassette(*this, "cassette")
	34	m_cassette(*this, "cassette"),
	35	m_ram(*this, RAM_TAG)
34	36	{ }
35	37
36	38	required_device<cpu_device> m_maincpu;
r22508	r22509
50	52	z80ctc_device *m_z80ctc;
51	53	device_t *m_z80dart;
52	54	required_device<cassette_image_device> m_cassette;
	55	required_device<ram_device> m_ram;
53	56	centronics_device *m_centronics;
54	57
55	58	/* timers */

trunk/src/mess/includes/enterp.h

r22508	r22509
13	13
14	14	#define NICK_PALETTE_SIZE   256
15	15
16
	16	#include "machine/ram.h"
17	17	struct NICK_STATE;
18	18
19	19	class ep_state : public driver_device
r22508	r22509
21	21	public:
22	22	ep_state(const machine_config &mconfig, device_type type, const char *tag)
23	23	: driver_device(mconfig, type, tag),
24		m_maincpu(*this, "maincpu") { }
	24	m_maincpu(*this, "maincpu"),
	25	m_ram(*this, RAM_TAG) { }
25	26
26	27	UINT8 exdos_card_value;  /* state of the wd1770 irq/drq lines */
27	28	UINT8 keyboard_line;     /* index of keyboard line to read */
r22508	r22509
39	40	DECLARE_WRITE_LINE_MEMBER(enterp_wd1770_intrq_w);
40	41	DECLARE_WRITE_LINE_MEMBER(enterp_wd1770_drq_w);
41	42	required_device<cpu_device> m_maincpu;
	43	required_device<ram_device> m_ram;
42	44	void enterprise_update_memory_page(address_space &space, offs_t page, int index);
43	45	char Nick_FetchByte(unsigned long Addr);
44	46	void nick_write_pixel(int ci);

trunk/src/mess/includes/pcw16.h

r22508	r22509
39	39	m_flash1(*this, "flash1"),
40	40	m_fdc(*this, "fdc"),
41	41	m_uart2(*this, "ns16550_2"),
42		m_speaker(*this, BEEPER_TAG),
	42	m_beeper(*this, "beeper"),
43	43	m_ram(*this, RAM_TAG),
44	44	m_region_rom(*this, "maincpu"),
45	45	m_io_extra(*this, "EXTRA")
r22508	r22509
50	50	required_device<intel_e28f008sa_device> m_flash1;
51	51	required_device<pc_fdc_superio_device> m_fdc;
52	52	required_device<ns16550_device> m_uart2;
53		required_device<beep_device> m_speaker;
	53	required_device<beep_device> m_beeper;
54	54	required_device<ram_device> m_ram;
55	55	required_memory_region m_region_rom;
56	56	required_ioport m_io_extra;

trunk/src/mess/includes/dgn_beta.h

r22508	r22509
10	10	#include "video/mc6845.h"
11	11	#include "machine/wd17xx.h"
12	12	#include "machine/6821pia.h"
	13	#include "machine/ram.h"
13	14
14	15	/* Tags */
15	16
r22508	r22509
88	89	: driver_device(mconfig, type, tag),
89	90	m_mc6845(*this, "crtc"),
90	91	m_videoram(*this, "videoram"),
91		m_maincpu(*this, "maincpu") { }
	92	m_maincpu(*this, "maincpu"),
	93	m_ram(*this, RAM_TAG) { }
92	94
93	95	required_device<mc6845_device> m_mc6845;
94	96	required_shared_ptr<UINT8> m_videoram;
r22508	r22509
207	209	void ScanInKeyboard(void);
208	210	void dgn_beta_frame_interrupt (int data);
209	211	void dgn_beta_line_interrupt (int data);
	212	required_device<ram_device> m_ram;
210	213	};
211	214
212	215

trunk/src/mess/includes/llc.h

r22508	r22509
21	21	public:
22	22	llc_state(const machine_config &mconfig, device_type type, const char *tag)
23	23	: driver_device(mconfig, type, tag),
24		m_speaker(*this, "speaker"),
25		m_p_videoram(*this, "videoram"),
26		m_maincpu(*this, "maincpu") { }
	24	m_speaker(*this, "speaker"),
	25	m_p_videoram(*this, "videoram"),
	26	m_maincpu(*this, "maincpu"),
	27	m_ram(*this, RAM_TAG) { }
27	28
28	29	DECLARE_WRITE8_MEMBER(llc2_rom_disable_w);
29	30	DECLARE_WRITE8_MEMBER(llc2_basic_enable_w);
r22508	r22509
55	56	UINT32 screen_update_llc1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
56	57	UINT32 screen_update_llc2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
57	58	required_device<cpu_device> m_maincpu;
	59	optional_device<ram_device> m_ram;
58	60	};
59	61
60	62

trunk/src/mess/includes/mz700.h

r22508	r22509
17	17	#include "machine/z80pio.h"
18	18	#include "sound/speaker.h"
19	19	#include "imagedev/cassette.h"
	20	#include "machine/ram.h"
20	21
21	22	class mz_state : public driver_device
22	23	{
r22508	r22509
25	26	: driver_device(mconfig, type, tag),
26	27	m_maincpu(*this, "maincpu"),
27	28	m_speaker(*this, "speaker"),
28		m_cassette(*this, "cassette") { }
	29	m_cassette(*this, "cassette"),
	30	m_ram(*this, RAM_TAG) { }
29	31
30	32	int m_mz700;                /* 1 if running on an mz700 */
31	33
r22508	r22509
98	100	required_device<cpu_device> m_maincpu;
99	101	required_device<speaker_sound_device> m_speaker;
100	102	required_device<cassette_image_device> m_cassette;
	103	required_device<ram_device> m_ram;
101	104	};
102	105
103	106

trunk/src/mess/includes/aim65.h

r22508	r22509
35	35	public:
36	36	aim65_state(const machine_config &mconfig, device_type type, const char *tag)
37	37	: driver_device(mconfig, type, tag),
38		m_maincpu(*this, "maincpu"),
39		m_cassette1(*this, "cassette"),
40		m_cassette2(*this, "cassette2")
	38	m_maincpu(*this, "maincpu"),
	39	m_cassette1(*this, "cassette"),
	40	m_cassette2(*this, "cassette2"),
	41	m_ram(*this, RAM_TAG)
41	42	{ }
42	43
43	44	DECLARE_WRITE8_MEMBER(aim65_pia_a_w);
r22508	r22509
56	57	required_device<cpu_device> m_maincpu;
57	58	required_device<cassette_image_device> m_cassette1;
58	59	required_device<cassette_image_device> m_cassette2;
	60	required_device<ram_device> m_ram;
59	61	virtual void machine_start();
60	62	TIMER_CALLBACK_MEMBER(aim65_printer_timer);
61	63	void aim65_pia();

trunk/src/mess/includes/apple1.h

r22508	r22509
10	10	#include "imagedev/snapquik.h"
11	11	#include "machine/6821pia.h"
12	12	#include "imagedev/cassette.h"
	13	#include "machine/ram.h"
13	14
14	15	typedef short termchar_t;
15	16
r22508	r22509
34	35	apple1_state(const machine_config &mconfig, device_type type, const char *tag)
35	36	: driver_device(mconfig, type, tag),
36	37	m_maincpu(*this, "maincpu"),
37		m_cassette(*this, "cassette") { }
	38	m_cassette(*this, "cassette"),
	39	m_ram(*this, RAM_TAG) { }
38	40
39	41	int m_vh_clrscrn_pressed;
40	42	int m_kbd_data;
r22508	r22509
80	82	terminal_t *terminal_create(int gfx, int blank_char, int char_bits,int (*getcursorcode)(int original_code),int num_cols, int num_rows);
81	83	attotime apple1_vh_dsp_time_to_ready();
82	84	DECLARE_SNAPSHOT_LOAD_MEMBER( apple1 );
	85	required_device<ram_device> m_ram;
83	86	};
84	87
85	88

trunk/src/mess/includes/x07.h

r22508	r22509
160	160	: driver_device(mconfig, type, tag),
161	161	m_maincpu(*this, "maincpu"),
162	162	m_printer(*this, "printer"),
163		m_beep(*this, BEEPER_TAG),
	163	m_beep(*this, "beeper"),
164	164	m_ram(*this, RAM_TAG),
165	165	m_cassette(*this, "cassette")
166	166	{ }

trunk/src/mess/includes/fm7.h

r22508	r22509
1	1	#include "imagedev/cassette.h"
	2	#include "sound/beep.h"
2	3
3	4	/*
4	5	*
r22508	r22509
110	111	m_maincpu(*this, "maincpu"),
111	112	m_sub(*this, "sub"),
112	113	m_x86(*this, "x86"),
113		m_cassette(*this, "cassette") { }
	114	m_cassette(*this, "cassette"),
	115	m_beeper(*this, "beeper") { }
114	116
115	117	optional_shared_ptr<UINT8> m_shared_ram;
116	118	optional_shared_ptr<UINT8> m_boot_ram;
r22508	r22509
262	264	required_device<cpu_device> m_sub;
263	265	optional_device<cpu_device> m_x86;
264	266	required_device<cassette_image_device> m_cassette;
	267	required_device<beep_device> m_beeper;
265	268	void fm7_alu_mask_write(UINT32 offset, int bank, UINT8 dat);
266	269	void fm7_alu_function_compare(UINT32 offset);
267	270	void fm7_alu_function_pset(UINT32 offset);

trunk/src/mess/includes/genpc.h

r22508	r22509
16	16	#include "machine/pit8253.h"
17	17	#include "sound/speaker.h"
18	18	#include "imagedev/cassette.h"
	19	#include "machine/ram.h"
19	20
20	21	#define MCFG_IBM5160_MOTHERBOARD_ADD(_tag, _cputag) \
21	22	MCFG_DEVICE_ADD(_tag, IBM5160_MOTHERBOARD, 0) \
r22508	r22509
49	50	required_device<speaker_sound_device>  m_speaker;
50	51	required_device<isa8_device>  m_isabus;
51	52	required_device<pc_kbdc_device>  m_pc_kbdc;
	53	required_device<ram_device> m_ram;
52	54
53	55	/* U73 is an LS74 - dual flip flop */
54	56	/* Q2 is set by OUT1 from the 8253 and goes to DRQ1 on the 8237 */

trunk/src/mess/includes/comx35.h

r22508	r22509
92	92	DECLARE_WRITE_LINE_MEMBER( prd_w );
93	93	DECLARE_INPUT_CHANGED_MEMBER( trigger_reset );
94	94	DECLARE_QUICKLOAD_LOAD_MEMBER( comx35_comx );
	95	void image_fread_memory(device_image_interface &image, UINT16 addr, UINT32 count);
95	96
96	97	// processor state
97	98	int m_clear;                // CPU mode

trunk/src/mess/includes/dai.h

r22508	r22509
57	57	m_tms5501(*this, "tms5501"),
58	58	m_sound(*this, "custom"),
59	59	m_maincpu(*this, "maincpu"),
60		m_cassette(*this, "cassette") { }
	60	m_cassette(*this, "cassette"),
	61	m_ram(*this, RAM_TAG) { }
61	62
62	63	required_device<pit8253_device> m_pit;
63	64	required_device<tms5501_device> m_tms5501;
r22508	r22509
86	87	TIMER_CALLBACK_MEMBER(dai_timer);
87	88	required_device<cpu_device> m_maincpu;
88	89	required_device<cassette_image_device> m_cassette;
	90	required_device<ram_device> m_ram;
89	91	void dai_update_memory(int dai_rom_bank);
90	92	};
91	93

trunk/src/mess/includes/c65.h

r22508	r22509
11	11	#include "machine/cbmiec.h"
12	12	#include "imagedev/cartslot.h"
13	13	#include "imagedev/snapquik.h"
	14	#include "machine/ram.h"
14	15
15	16	#define C64_MAX_ROMBANK 64 // .crt files contain multiple 'CHIPs', i.e. rom banks (of variable size) with headers. Known carts have at most 64 'CHIPs'.
16	17
r22508	r22509
66	67	m_c65_chargen(*this, "c65_chargen"),
67	68	m_interface(*this, "interface"),
68	69	m_roml_writable(0),
69		m_maincpu(*this, "maincpu") { }
	70	m_maincpu(*this, "maincpu"),
	71	m_ram(*this, RAM_TAG) { }
70	72
71	73	optional_device<cbm_iec_device> m_iec;
72	74
r22508	r22509
176	178	void c65_common_driver_init(  );
177	179
178	180	required_device<cpu_device> m_maincpu;
	181	required_device<ram_device> m_ram;
179	182	};
180	183
181	184	/*----------- defined in machine/c65.c -----------*/

trunk/src/mess/includes/bebox.h

r22508	r22509
14	14	#include "machine/8237dma.h"
15	15	#include "machine/53c810.h"
16	16	#include "machine/upd765.h"
	17	#include "machine/ram.h"
17	18
18	19	struct bebox_devices_t
19	20	{
r22508	r22509
31	32	: driver_device(mconfig, type, tag),
32	33	m_ppc1(*this, "ppc1"),
33	34	m_ppc2(*this, "ppc2"),
34		m_lsi53c810(*this, "scsi:lsi53c810"){ }
	35	m_lsi53c810(*this, "scsi:lsi53c810"),
	36	m_ram(*this, RAM_TAG){ }
35	37
36	38	required_device<cpu_device> m_ppc1;
37	39	required_device<cpu_device> m_ppc2;
38	40	required_device<lsi53c810_device> m_lsi53c810;
	41	required_device<ram_device> m_ram;
39	42	UINT32 m_cpu_imask[2];
40	43	UINT32 m_interrupts;
41	44	UINT32 m_crossproc_interrupts;

trunk/src/mess/includes/x68k.h

r22508	r22509
12	12	#include "machine/rp5c15.h"
13	13	#include "machine/upd765.h"
14	14	#include "sound/okim6258.h"
	15	#include "machine/ram.h"
15	16
16
17	17	#define MC68901_TAG     "mc68901"
18	18	#define RP5C15_TAG      "rp5c15"
19	19
r22508	r22509
55	55	m_gvram32(*this, "gvram32"),
56	56	m_tvram32(*this, "tvram32"),
57	57	m_maincpu(*this, "maincpu"),
58		m_okim6258(*this, "okim6258") { }
	58	m_okim6258(*this, "okim6258"),
	59	m_ram(*this, RAM_TAG) { }
59	60
60	61	required_device<mc68901_device> m_mfpdev;
61	62	required_device<rp5c15_device> m_rtc;
r22508	r22509
384	385	public:
385	386	required_device<cpu_device> m_maincpu;
386	387	required_device<okim6258_device> m_okim6258;
	388	required_device<ram_device> m_ram;
387	389	bitmap_ind16* x68k_get_gfx_page(int pri,int type);
388	390	attotime prescale(int val);
389	391	void mfp_trigger_irq(int irq);

trunk/src/mess/includes/pc.h

r22508	r22509
16	16	#include "machine/upd765.h"
17	17	#include "sound/speaker.h"
18	18	#include "imagedev/cassette.h"
	19	#include "machine/ram.h"
19	20
20	21	class pc_state : public driver_device
21	22	{
r22508	r22509
26	27	m_dma8237(*this, "dma8237"),
27	28	m_pc_kbdc(*this, "pc_kbdc"),
28	29	m_speaker(*this, "speaker"),
29		m_cassette(*this, "cassette") { }
	30	m_cassette(*this, "cassette"),
	31	m_ram(*this, RAM_TAG) { }
30	32
31	33	required_device<cpu_device> m_maincpu;
32	34	device_t *m_pic8259;
r22508	r22509
35	37	optional_device<pc_kbdc_device>  m_pc_kbdc;
36	38	optional_device<speaker_sound_device> m_speaker;
37	39	optional_device<cassette_image_device> m_cassette;
	40	optional_device<ram_device> m_ram;
38	41
39	42	/* U73 is an LS74 - dual flip flop */
40	43	/* Q2 is set by OUT1 from the 8253 and goes to DRQ1 on the 8237 */

trunk/src/mess/includes/lviv.h

r22508	r22509
11	11	#include "machine/i8255.h"
12	12	#include "sound/speaker.h"
13	13	#include "imagedev/cassette.h"
	14	#include "machine/ram.h"
14	15
15	16	class lviv_state : public driver_device
16	17	{
r22508	r22509
19	20	: driver_device(mconfig, type, tag),
20	21	m_maincpu(*this, "maincpu"),
21	22	m_speaker(*this, "speaker"),
22		m_cassette(*this, "cassette") { }
	23	m_cassette(*this, "cassette"),
	24	m_ram(*this, RAM_TAG) { }
23	25
24	26	unsigned char * m_video_ram;
25	27	unsigned short m_colortable[1][4];
r22508	r22509
48	50	required_device<cpu_device> m_maincpu;
49	51	required_device<speaker_sound_device> m_speaker;
50	52	required_device<cassette_image_device> m_cassette;
	53	required_device<ram_device> m_ram;
51	54	void lviv_update_palette(UINT8 pal);
52	55	void lviv_update_memory ();
53	56	void lviv_setup_snapshot (UINT8 * data);

trunk/src/mess/video/timex.c

r22508	r22509
62	62	scrx=TS2068_LEFT_BORDER;
63	63	scry=((y&7) * 8) + ((y&0x38)>>3) + (y&0xC0);
64	64
65		scr=machine().device<ram_device>(RAM_TAG)->pointer() + y*32;
	65	scr=m_ram->pointer() + y*32;
66	66	attr=scr + 0x2000;
67	67
68	68	for (x=0;x<32;x++)
r22508	r22509
106	106	scrx=TS2068_LEFT_BORDER;
107	107	scry=((y&7) * 8) + ((y&0x38)>>3) + (y&0xC0);
108	108
109		scr1=machine().device<ram_device>(RAM_TAG)->pointer() + y*32;
	109	scr1=m_ram->pointer() + y*32;
110	110	scr2=scr1 + 0x2000;
111	111
112	112	for (x=0;x<32;x++)
r22508	r22509
141	141	scrx=TS2068_LEFT_BORDER;
142	142	scry=((y&7) * 8) + ((y&0x38)>>3) + (y&0xC0);
143	143
144		scr = machine().device<ram_device>(RAM_TAG)->pointer() + y*32 + screen*0x2000;
145		attr = machine().device<ram_device>(RAM_TAG)->pointer() + ((scry>>3)*32) + screen*0x2000 + 0x1800;
	144	scr = m_ram->pointer() + y*32 + screen*0x2000;
	145	attr = m_ram->pointer() + ((scry>>3)*32) + screen*0x2000 + 0x1800;
146	146
147	147	for (x=0;x<32;x++)
148	148	{

trunk/src/mess/video/nc.c

r22508	r22509
89	89	{
90	90	int by;
91	91	/* 64 bytes per line */
92		char *line_ptr = ((char*)machine().device<ram_device>(RAM_TAG)->pointer()) + m_display_memory_start + (y<<6);
	92	char *line_ptr = ((char*)m_ram->pointer()) + m_display_memory_start + (y<<6);
93	93
94	94	x = 0;
95	95	for (by=0; by<width>>3; by++)

trunk/src/mess/video/x68k.c

r22508	r22509
1288	1288	//  popmessage("Graphic layer scroll - %i, %i - %i, %i - %i, %i - %i, %i",
1289	1289	//      m_crtc.reg[12],m_crtc.reg[13],m_crtc.reg[14],m_crtc.reg[15],m_crtc.reg[16],m_crtc.reg[17],m_crtc.reg[18],m_crtc.reg[19]);
1290	1290	//  popmessage("IOC IRQ status - %02x",m_ioc.irqstatus);
1291		//  popmessage("RAM: mouse data - %02x %02x %02x %02x",machine().device<ram_device>(RAM_TAG)->pointer()[0x931],machine().device<ram_device>(RAM_TAG)->pointer()[0x930],machine().device<ram_device>(RAM_TAG)->pointer()[0x933],machine().device<ram_device>(RAM_TAG)->pointer()[0x932]);
	1291	//  popmessage("RAM: mouse data - %02x %02x %02x %02x",m_ram->pointer()[0x931],m_ram->pointer()[0x930],m_ram->pointer()[0x933],m_ram->pointer()[0x932]);
1292	1292	#endif
1293	1293	return 0;
1294	1294	}

trunk/src/mess/video/b2m.c

r22508	r22509
21	21	UINT8 code2;
22	22	UINT8 col;
23	23	int y, x, b;
24		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	24	UINT8 *ram = m_ram->pointer();
25	25
26	26	for (x = 0; x < 48; x++)
27	27	{

trunk/src/mess/video/pcw.c

r22508	r22509
92	92
93	93	x = PCW_BORDER_WIDTH;
94	94
95		roller_ram_ptr = machine().device<ram_device>(RAM_TAG)->pointer() + m_roller_ram_addr + roller_ram_offs;
	95	roller_ram_ptr = m_ram->pointer() + m_roller_ram_addr + roller_ram_offs;
96	96
97	97	/* get line address */
98	98	/* b16-14 control which bank the line is to be found in, b13-3 the address in the bank (in 16-byte units), and b2-0 the offset. Thus a roller RAM address bbbxxxxxxxxxxxyyy indicates bank bbb, address 00xxxxxxxxxxx0yyy. */
99	99	line_data = ((unsigned char *)roller_ram_ptr)[0] | (((unsigned char *)roller_ram_ptr)[1]<<8);
100	100
101	101	/* calculate address of pixel data */
102		line_ptr = machine().device<ram_device>(RAM_TAG)->pointer() + ((line_data & 0x0e000)<<1) + ((line_data & 0x01ff8)<<1) + (line_data & 0x07);
	102	line_ptr = m_ram->pointer() + ((line_data & 0x0e000)<<1) + ((line_data & 0x01ff8)<<1) + (line_data & 0x07);
103	103
104	104	for (by=0; by<90; by++)
105	105	{

trunk/src/mess/video/911_vdt.c

r22508	r22509
230	230
231	231	static TIMER_CALLBACK(setup_beep)
232	232	{
233		machine.device<beep_device>(BEEPER_TAG)->set_frequency(2000);
	233	machine.device<beep_device>("beeper")->set_frequency(2000);
234	234	}
235	235
236	236
r22508	r22509
311	311	*/
312	312	static TIMER_CALLBACK(beep_callback)
313	313	{
314		machine.device<beep_device>(BEEPER_TAG)->set_state(0);
	314	machine.device<beep_device>("beeper")->set_state(0);
315	315	}
316	316
317	317	/*
r22508	r22509
485	485
486	486	case 0xe:
487	487	/* beep enable strobe - not tested */
488		space.machine().device<beep_device>(BEEPER_TAG)->set_state(1);
	488	space.machine().device<beep_device>("beeper")->set_state(1);
489	489
490	490	vdt->beep_timer->adjust(attotime::from_usec(300));
491	491	break;

trunk/src/mess/video/pp01.c

r22508	r22509
20	20	UINT8 code_r,code_g,code_b;
21	21	UINT8 col;
22	22	int y, x, b;
23		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	23	UINT8 *ram = m_ram->pointer();
24	24
25	25	for (y = 0; y < 256; y++)
26	26	{

trunk/src/mess/video/apple3.c

r22508	r22509
93	93	const UINT8 *char_data;
94	94	pen_t fg, bg, temp;
95	95	UINT16 *dest;
96		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
97		UINT32 ram_size = machine().device<ram_device>(RAM_TAG)->size();
	96	UINT8 *ram = m_ram->pointer();
	97	UINT32 ram_size = m_ram->size();
98	98
99	99	for (y = 0; y < 24; y++)
100	100	{
r22508	r22509
150	150	const UINT8 *char_data;
151	151	pen_t fg, bg;
152	152	UINT16 *dest;
153		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
154		UINT32 ram_size = machine().device<ram_device>(RAM_TAG)->size();
	153	UINT8 *ram = m_ram->pointer();
	154	UINT32 ram_size = m_ram->size();
155	155
156	156	for (y = 0; y < 24; y++)
157	157	{
r22508	r22509
201	201	const UINT8 *pix_info;
202	202	UINT16 *ptr;
203	203	UINT8 b;
204		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	204	UINT8 *ram = m_ram->pointer();
205	205
206	206	for (y = 0; y < 192; y++)
207	207	{
r22508	r22509
246	246	UINT16 *ptr;
247	247	UINT8 b;
248	248	UINT16 fgcolor, bgcolor;
249		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	249	UINT8 *ram = m_ram->pointer();
250	250
251	251	for (y = 0; y < 192; y++)
252	252	{
r22508	r22509
291	291	const UINT8 *pix_info2;
292	292	UINT16 *ptr;
293	293	UINT8 b1, b2;
294		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	294	UINT8 *ram = m_ram->pointer();
295	295
296	296	for (y = 0; y < 192; y++)
297	297	{
r22508	r22509
330	330	UINT16 *pen;
331	331	PAIR pix;
332	332	int y, i;
333		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	333	UINT8 *ram = m_ram->pointer();
334	334
335	335	for (y = 0; y < 192; y++)
336	336	{

trunk/src/mess/video/vector06.c

r22508	r22509
19	19	UINT8 code1,code2,code3,code4;
20	20	UINT8 col;
21	21	int y, x, b,draw_y;
22		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	22	UINT8 *ram = m_ram->pointer();
23	23
24	24	int width = (m_video_mode==0x00) ? 256 : 512;
25	25	rectangle screen_area(0,width+64-1,0,256+64-1);

trunk/src/mess/video/epnick.c

r22508	r22509
1015	1015	{
1016	1016	nick = auto_alloc_clear(machine(), NICK_STATE);
1017	1017
1018		nick->videoram = machine().device<ram_device>(RAM_TAG)->pointer();
	1018	nick->videoram = m_ram->pointer();
1019	1019	Nick_Init();
1020	1020	machine().primary_screen->register_screen_bitmap(m_bitmap);
1021	1021	}

trunk/src/mess/video/mac.c

r22508	r22509
86	86	UINT16 *line;
87	87	int y, x, b;
88	88
89		video_base = machine().device<ram_device>(RAM_TAG)->size() - (m_screen_buffer ? MAC_MAIN_SCREEN_BUF_OFFSET : MAC_ALT_SCREEN_BUF_OFFSET);
90		video_ram = (const UINT16 *) (machine().device<ram_device>(RAM_TAG)->pointer() + video_base);
	89	video_base = m_ram->size() - (m_screen_buffer ? MAC_MAIN_SCREEN_BUF_OFFSET : MAC_ALT_SCREEN_BUF_OFFSET);
	90	video_ram = (const UINT16 *) (m_ram->pointer() + video_base);
91	91
92	92	for (y = 0; y < MAC_V_VIS; y++)
93	93	{
r22508	r22509
381	381	{
382	382	UINT32 *scanline;
383	383	int x, y, hres, vres;
384		UINT8 *vram8 = (UINT8 *)machine().device<ram_device>(RAM_TAG)->pointer();
	384	UINT8 *vram8 = (UINT8 *)m_ram->pointer();
385	385
386	386	switch (m_rbv_montype)
387	387	{

trunk/src/mess/drivers/pc8801.c

r22508	r22509
303	303	m_fdccpu(*this, "fdccpu"),
304	304	m_pic(*this, I8214_TAG),
305	305	m_rtc(*this, UPD1990A_TAG),
306		m_cassette(*this, "cassette")
	306	m_cassette(*this, "cassette"),
	307	m_beeper(*this, "beeper")
307	308	{ }
308	309
309	310	required_device<cpu_device> m_maincpu;
r22508	r22509
311	312	optional_device<i8214_device> m_pic;
312	313	required_device<upd1990a_device> m_rtc;
313	314	required_device<cassette_image_device> m_cassette;
	315	required_device<beep_device> m_beeper;
314	316	UINT8 *m_work_ram;
315	317	UINT8 *m_hi_work_ram;
316	318	UINT8 *m_ext_work_ram;
r22508	r22509
1185	1187	m_rtc->clk_w((data & 4) >> 2);
1186	1188
1187	1189	if(((m_device_ctrl_data & 0x20) == 0x00) && ((data & 0x20) == 0x20))
1188		machine().device<beep_device>(BEEPER_TAG)->set_state(1);
	1190	m_beeper->set_state(1);
1189	1191
1190	1192	if(((m_device_ctrl_data & 0x20) == 0x20) && ((data & 0x20) == 0x00))
1191		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1193	m_beeper->set_state(0);
1192	1194
1193	1195	if((m_device_ctrl_data & 0x40) != (data & 0x40))
1194	1196	{
r22508	r22509
1215	1217
1216	1218	/* TODO: is SING a buzzer mask? Bastard Special relies on this ... */
1217	1219	if(m_device_ctrl_data & 0x80)
1218		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1220	m_beeper->set_state(0);
1219	1221
1220	1222	m_device_ctrl_data = data;
1221	1223	}
r22508	r22509
2473	2475	m_crtc.status = 0;
2474	2476	}
2475	2477
2476		machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
2477		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	2478	m_beeper->set_frequency(2400);
	2479	m_beeper->set_state(0);
2478	2480
2479	2481	#ifdef USE_PROPER_I8214
2480	2482	{
r22508	r22509
2708	2710	MCFG_SOUND_CONFIG(pc88_ym2608_intf)
2709	2711	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
2710	2712
2711		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2713	MCFG_SOUND_ADD("beeper", BEEP, 0)
2712	2714	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.10)
2713	2715
2714	2716	MCFG_TIMER_DRIVER_ADD_PERIODIC("rtc_timer", pc8801_state, pc8801_rtc_irq, attotime::from_hz(600))

trunk/src/mess/drivers/enterp.c

r22508	r22509
70	70	case 0xfa:
71	71	case 0xfb:
72	72	/* additional 64k ram */
73		if (space.machine().device<ram_device>(RAM_TAG)->size() == 128*1024)
	73	if (m_ram->size() == 128*1024)
74	74	{
75	75	space.install_readwrite_bank(start, end, page_num);
76		membank(page_num)->set_base(space.machine().device<ram_device>(RAM_TAG)->pointer() + (index - 0xf4) * 0x4000);
	76	membank(page_num)->set_base(m_ram->pointer() + (index - 0xf4) * 0x4000);
77	77	}
78	78	else
79	79	{
r22508	r22509
87	87	case 0xff:
88	88	/* basic 64k ram */
89	89	space.install_readwrite_bank(start, end, page_num);
90		membank(page_num)->set_base(space.machine().device<ram_device>(RAM_TAG)->pointer() + (index - 0xfc) * 0x4000);
	90	membank(page_num)->set_base(m_ram->pointer() + (index - 0xfc) * 0x4000);
91	91	break;
92	92
93	93	default:

trunk/src/mess/drivers/ti990_4.c

r22508	r22509
280	280	#if VIDEO_911
281	281	/* 911 VDT has a beep tone generator */
282	282	MCFG_SPEAKER_STANDARD_MONO("mono")
283		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	283	MCFG_SOUND_ADD("beeper", BEEP, 0)
284	284	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
285	285	#endif
286	286	MCFG_LEGACY_FLOPPY_4_DRIVES_ADD(ti990_4_floppy_interface)

trunk/src/mess/drivers/ms0515.c

r22508	r22509
19	19	public:
20	20	ms0515_state(const machine_config &mconfig, device_type type, const char *tag)
21	21	: driver_device(mconfig, type, tag),
22		m_maincpu(*this, "maincpu")
	22	m_maincpu(*this, "maincpu"),
	23	m_ram(*this, RAM_TAG)
23	24	{ }
24	25
25	26	required_device<cpu_device> m_maincpu;
	27	required_device<ram_device> m_ram;
26	28
27	29	DECLARE_WRITE16_MEMBER(ms0515_bank_w);
28	30	DECLARE_WRITE8_MEMBER(ms0515_sys_w);
r22508	r22509
83	85
84	86	WRITE16_MEMBER(ms0515_state::ms0515_bank_w)
85	87	{
86		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	88	UINT8 *ram = m_ram->pointer();
87	89	membank("bank0")->set_base(ram + 0000000 + BIT(data,0) * 0160000);
88	90	membank("bank1")->set_base(ram + 0020000 + BIT(data,1) * 0160000);
89	91	membank("bank2")->set_base(ram + 0040000 + BIT(data,2) * 0160000);
r22508	r22509
118	120
119	121	void ms0515_state::machine_reset()
120	122	{
121		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	123	UINT8 *ram = m_ram->pointer();
122	124	ms0515_bank_w(machine().driver_data()->generic_space(),0,0);
123	125
124	126	m_video_ram = ram + 0000000 + 0340000;

trunk/src/mess/drivers/osi.c

r22508	r22509
852	852	MCFG_SOUND_ADD(DISCRETE_TAG, DISCRETE, 0)
853	853	MCFG_SOUND_CONFIG_DISCRETE(osi600c_discrete_interface)
854	854	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
855		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	855	MCFG_SOUND_ADD("beeper", BEEP, 0)
856	856	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
857	857
858	858	MCFG_PIA6821_ADD( "pia_1", pia_dummy_intf )
r22508	r22509
933	933
934	934	TIMER_CALLBACK_MEMBER(sb2m600_state::setup_beep)
935	935	{
936		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
937		speaker->set_state(0);
938		speaker->set_frequency(300);
	936	m_beeper->set_state(0);
	937	m_beeper->set_frequency(300);
939	938	}
940	939
941	940	DRIVER_INIT_MEMBER(c1p_state,c1p)

trunk/src/mess/drivers/pyl601.c

r22508	r22509
498	498
499	499	DRIVER_INIT_MEMBER(pyl601_state,pyl601)
500	500	{
501		memset(machine().device<ram_device>(RAM_TAG)->pointer(), 0, 64 * 1024);
	501	memset(m_ram->pointer(), 0, 64 * 1024);
502	502	}
503	503
504	504	INTERRUPT_GEN_MEMBER(pyl601_state::pyl601_interrupt)

trunk/src/mess/drivers/pc100.c

r22508	r22509
67	67	pc100_state(const machine_config &mconfig, device_type type, const char *tag)
68	68	: driver_device(mconfig, type, tag),
69	69	m_rtc(*this, "rtc"),
70		m_palram(*this, "palram")
71		,
72		m_maincpu(*this, "maincpu") { }
	70	m_palram(*this, "palram"),
	71	m_maincpu(*this, "maincpu"),
	72	m_beeper(*this, "beeper") { }
73	73
74	74	required_device<msm58321_device> m_rtc;
75	75	required_shared_ptr<UINT16> m_palram;
r22508	r22509
118	118	TIMER_DEVICE_CALLBACK_MEMBER(pc100_10hz_irq);
119	119	IRQ_CALLBACK_MEMBER(pc100_irq_callback);
120	120	required_device<cpu_device> m_maincpu;
	121	required_device<beep_device> m_beeper;
121	122	};
122	123
123	124	void pc100_state::video_start()
r22508	r22509
219	220	if(offset == 0)
220	221	{
221	222	m_timer_mode = (data & 0x18) >> 3;
222		machine().device<beep_device>(BEEPER_TAG)->set_state(((data & 0x40) >> 6) ^ 1);
	223	m_beeper->set_state(((data & 0x40) >> 6) ^ 1);
223	224	printf("%02x\n",data & 0xc0);
224	225	}
225	226	}
r22508	r22509
429	430
430	431	void pc100_state::machine_reset()
431	432	{
432		machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
433		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	433	m_beeper->set_frequency(2400);
	434	m_beeper->set_state(0);
434	435	}
435	436
436	437	INTERRUPT_GEN_MEMBER(pc100_state::pc100_vblank_irq)
r22508	r22509
517	518
518	519	MCFG_SPEAKER_STANDARD_MONO("mono")
519	520
520		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	521	MCFG_SOUND_ADD("beeper", BEEP, 0)
521	522	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
522	523	MACHINE_CONFIG_END
523	524

trunk/src/mess/drivers/mmodular.c

r22508	r22509
129	129	public:
130	130	polgar_state(const machine_config &mconfig, device_type type, const char *tag)
131	131	: mboard_state(mconfig, type, tag),
132		m_lcdc(*this, "hd44780")
	132	m_lcdc(*this, "hd44780"),
	133	m_beeper(*this, "beeper")
133	134	{ }
134	135
135	136	optional_device<hd44780_device> m_lcdc;
	137	optional_device<beep_device> m_beeper;
136	138
137	139	UINT8 led_status;
138	140	UINT8 lcd_char;
r22508	r22509
244	246	}
245	247
246	248	if (BIT(data,2) || BIT(data,3))
247		machine().device<beep_device>("beep")->set_state(1);
	249	m_beeper->set_state(1);
248	250	else
249		machine().device<beep_device>("beep")->set_state(0);
	251	m_beeper->set_state(0);
250	252
251	253	if (BIT(data,7) && BIT(data, 4)) {
252	254	for (i = 0;i < 8;i++)
r22508	r22509
412	414	WRITE8_MEMBER(polgar_state::megaiv_write_LED)
413	415	{
414	416	if (BIT(data,7))
415		machine().device<beep_device>("beep")->set_state(1);
	417	m_beeper->set_state(1);
416	418	else
417		machine().device<beep_device>("beep")->set_state(0);
	419	m_beeper->set_state(0);
418	420	output_set_led_value(102,BIT(data,1)?1:0);
419	421	output_set_led_value(107,BIT(data,6)?1:0);
420	422
r22508	r22509
475	477	}
476	478
477	479	if (BIT(data,7))
478		machine().device<beep_device>("beep")->set_state(1);
	480	m_beeper->set_state(1);
479	481	else
480		machine().device<beep_device>("beep")->set_state(0);
	482	m_beeper->set_state(0);
481	483	if (BIT(data,1))
482		machine().device<beep_device>("beep")->set_state(1);
	484	m_beeper->set_state(1);
483	485	else
484		machine().device<beep_device>("beep")->set_state(0);
	486	m_beeper->set_state(0);
485	487	//  logerror("LEDs  FUNC = %02x found = %d\n",data,found);
486	488	if (!found) {
487	489	logerror("unknown LED mask %d\n",data);
r22508	r22509
724	726	WRITE8_MEMBER(polgar_state::beep_academy)
725	727	{
726	728	if (!BIT(data,7))
727		machine().device<beep_device>("beep")->set_state(1);
	729	m_beeper->set_state(1);
728	730	else
729		machine().device<beep_device>("beep")->set_state(0);
	731	m_beeper->set_state(0);
730	732	}
731	733
732	734	WRITE8_MEMBER(polgar_state::megaiv_IO)
r22508	r22509
878	880	void polgar_state::write_IOenable(unsigned char data,address_space &space)
879	881	{
880	882	hd44780_device * hd44780 = space.machine().device<hd44780_device>("hd44780");
881		beep_device *speaker = machine().device<beep_device>("beep");
882	883
883	884	if (BIT(data,5) && BIT(data,4)) {
884	885	if (BIT(data,1)) {
r22508	r22509
904	905	logerror("Write to IOENBL data: %08x\n",data);
905	906
906	907	if (BIT(data,2) || BIT(data,3))
907		speaker->set_state(1);
	908	m_beeper->set_state(1);
908	909	else
909		speaker->set_state(0);
	910	m_beeper->set_state(0);
910	911	}
911	912
912	913	}
r22508	r22509
1532	1533
1533	1534	/* sound hardware */
1534	1535	MCFG_SPEAKER_STANDARD_MONO("mono")
1535		MCFG_SOUND_ADD("beep", BEEP, 0)
	1536	MCFG_SOUND_ADD("beeper", BEEP, 0)
1536	1537	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
1537	1538
1538	1539	MACHINE_CONFIG_END

trunk/src/mess/drivers/pc9801.c

r22508	r22509
365	365	m_hgdc2(*this, "upd7220_btm"),
366	366	m_sasibus(*this, SASIBUS_TAG ":host"),
367	367	m_video_ram_1(*this, "video_ram_1"),
368		m_video_ram_2(*this, "video_ram_2"){ }
	368	m_video_ram_2(*this, "video_ram_2"),
	369	m_beeper(*this, "beeper"),
	370	m_ram(*this, RAM_TAG) { }
369	371
370	372	required_device<cpu_device> m_maincpu;
371	373	required_device<am9517a_device> m_dmac;
r22508	r22509
379	381	optional_device<scsicb_device> m_sasibus;
380	382	required_shared_ptr<UINT8> m_video_ram_1;
381	383	required_shared_ptr<UINT8> m_video_ram_2;
	384	required_device<beep_device> m_beeper;
	385	optional_device<ram_device> m_ram;
382	386
383	387	virtual void video_start();
384	388	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
r22508	r22509
3109	3113
3110	3114	WRITE8_MEMBER(pc9801_state::ppi_sys_portc_w)
3111	3115	{
3112		machine().device<beep_device>(BEEPER_TAG)->set_state(!(data & 0x08));
	3116	m_beeper->set_state(!(data & 0x08));
3113	3117	}
3114	3118
3115	3119	static I8255A_INTERFACE( ppi_system_intf )
r22508	r22509
3388	3392	state_save_register_global_pointer(machine(), m_work_ram, 0xa0000);
3389	3393	state_save_register_global_pointer(machine(), m_ext_work_ram, 0x700000);
3390	3394
3391		m_ram_size = machine().device<ram_device>(RAM_TAG)->size() - 0xa0000;
	3395	m_ram_size = m_ram->size() - 0xa0000;
3392	3396
3393	3397	upd765a_device *fdc;
3394	3398	fdc = machine().device<upd765a_device>(":upd765_2hd");
r22508	r22509
3427	3431	m_tvram[(0x3fe0)+i*2] = default_memsw_data[i];
3428	3432	}
3429	3433
3430		machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
3431		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	3434	m_beeper->set_frequency(2400);
	3435	m_beeper->set_state(0);
3432	3436
3433	3437	m_nmi_ff = 0;
3434	3438	m_mouse.control = 0xff;
r22508	r22509
3612	3616
3613	3617	MCFG_SPEAKER_STANDARD_MONO("mono")
3614	3618
3615		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	3619	MCFG_SOUND_ADD("beeper", BEEP, 0)
3616	3620	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.15)
3617	3621	MACHINE_CONFIG_END
3618	3622
r22508	r22509
3677	3681	//  MCFG_SOUND_CONFIG(pc98_ym2608_intf)
3678	3682	//  MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
3679	3683
3680		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	3684	MCFG_SOUND_ADD("beeper", BEEP, 0)
3681	3685	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.15)
3682	3686	MACHINE_CONFIG_END
3683	3687
r22508	r22509
3743	3747	//  MCFG_SOUND_CONFIG(pc98_ym2608_intf)
3744	3748	//  MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
3745	3749
3746		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	3750	MCFG_SOUND_ADD("beeper", BEEP, 0)
3747	3751	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.15)
3748	3752	MACHINE_CONFIG_END
3749	3753

trunk/src/mess/drivers/fidelz80.c

r22508	r22509
1296	1296
1297	1297	/* sound hardware */
1298	1298	MCFG_SPEAKER_STANDARD_MONO( "mono" )
1299		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	1299	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
1300	1300	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
1301	1301	MACHINE_CONFIG_END
1302	1302

trunk/src/mess/drivers/fm7.c

r22508	r22509
229	229
230	230	TIMER_CALLBACK_MEMBER(fm7_state::fm7_beeper_off)
231	231	{
232		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	232	m_beeper->set_state(0);
233	233	logerror("timed beeper off\n");
234	234	}
235	235
r22508	r22509
239	239
240	240	if(!m_speaker_active)  // speaker not active, disable all beeper sound
241	241	{
242		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	242	m_beeper->set_state(0);
243	243	return;
244	244	}
245	245
246	246	if(data & 0x80)
247	247	{
248	248	if(m_speaker_active)
249		machine().device<beep_device>(BEEPER_TAG)->set_state(1);
	249	m_beeper->set_state(1);
250	250	}
251	251	else
252		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	252	m_beeper->set_state(0);
253	253
254	254	if(data & 0x40)
255	255	{
256	256	if(m_speaker_active)
257	257	{
258		machine().device<beep_device>(BEEPER_TAG)->set_state(1);
	258	m_beeper->set_state(1);
259	259	logerror("timed beeper on\n");
260	260	machine().scheduler().timer_set(attotime::from_msec(205), timer_expired_delegate(FUNC(fm7_state::fm7_beeper_off),this));
261	261	}
r22508	r22509
272	272	{
273	273	if(m_speaker_active)
274	274	{
275		machine().device<beep_device>(BEEPER_TAG)->set_state(1);
	275	m_beeper->set_state(1);
276	276	logerror("timed beeper on\n");
277	277	machine().scheduler().timer_set(attotime::from_msec(205), timer_expired_delegate(FUNC(fm7_state::fm7_beeper_off),this));
278	278	}
r22508	r22509
1836	1836	memset(m_shared_ram,0xff,0x80);
1837	1837	m_type = SYS_FM7;
1838	1838
1839		machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
1840		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1839	m_beeper->set_frequency(1200);
	1840	m_beeper->set_state(0);
1841	1841	}
1842	1842
1843	1843	MACHINE_START_MEMBER(fm7_state,fm77av)
r22508	r22509
1857	1857	membank("bank21")->set_base(RAM+0x800);
1858	1858
1859	1859	m_type = SYS_FM77AV;
1860		machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
1861		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1860	m_beeper->set_frequency(1200);
	1861	m_beeper->set_state(0);
1862	1862	}
1863	1863
1864	1864	MACHINE_START_MEMBER(fm7_state,fm11)
r22508	r22509
1868	1868
1869	1869	memset(m_shared_ram,0xff,0x80);
1870	1870	m_type = SYS_FM11;
1871		machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
1872		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1871	m_beeper->set_frequency(1200);
	1872	m_beeper->set_state(0);
1873	1873	// last part of Initiate ROM is visible at the end of RAM too (interrupt vectors)
1874	1874	memcpy(RAM+0x3fff0,ROM+0x0ff0,16);
1875	1875	}
r22508	r22509
1877	1877	MACHINE_START_MEMBER(fm7_state,fm16)
1878	1878	{
1879	1879	m_type = SYS_FM16;
1880		machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
1881		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1880	m_beeper->set_frequency(1200);
	1881	m_beeper->set_state(0);
1882	1882	}
1883	1883
1884	1884	void fm7_state::machine_reset()
r22508	r22509
2022	2022	MCFG_SOUND_ADD("psg", AY8910, XTAL_4_9152MHz / 4)
2023	2023	MCFG_SOUND_CONFIG(fm7_psg_intf)
2024	2024	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono", 1.00)
2025		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2025	MCFG_SOUND_ADD("beeper", BEEP, 0)
2026	2026	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono", 0.50)
2027	2027	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
2028	2028	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono", 0.25)
r22508	r22509
2064	2064	MCFG_QUANTUM_PERFECT_CPU("sub")
2065	2065
2066	2066	MCFG_SPEAKER_STANDARD_MONO("mono")
2067		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2067	MCFG_SOUND_ADD("beeper", BEEP, 0)
2068	2068	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
2069	2069	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
2070	2070	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.25)
r22508	r22509
2107	2107	MCFG_SOUND_ADD("ym", YM2203, XTAL_4_9152MHz / 4)
2108	2108	MCFG_SOUND_CONFIG(fm7_ym_intf)
2109	2109	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",1.0)
2110		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2110	MCFG_SOUND_ADD("beeper", BEEP, 0)
2111	2111	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
2112	2112	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
2113	2113	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.25)
r22508	r22509
2153	2153	MCFG_CPU_IO_MAP(fm11_x86_io)
2154	2154
2155	2155	MCFG_SPEAKER_STANDARD_MONO("mono")
2156		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2156	MCFG_SOUND_ADD("beeper", BEEP, 0)
2157	2157	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
2158	2158	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
2159	2159	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.25)
r22508	r22509
2194	2194	MCFG_QUANTUM_PERFECT_CPU("sub")
2195	2195
2196	2196	MCFG_SPEAKER_STANDARD_MONO("mono")
2197		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2197	MCFG_SOUND_ADD("beeper", BEEP, 0)
2198	2198	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
2199	2199	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
2200	2200	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.25)

trunk/src/mess/drivers/ex800.c

r22508	r22509
137	137	public:
138	138	ex800_state(const machine_config &mconfig, device_type type, const char *tag)
139	139	: driver_device(mconfig, type, tag) ,
140		m_maincpu(*this, "maincpu") { }
	140	m_maincpu(*this, "maincpu"),
	141	m_beeper(*this, "beeper") { }
141	142
142	143	int m_irq_state;
143	144	DECLARE_READ8_MEMBER(ex800_porta_r);
r22508	r22509
157	158	virtual void machine_start();
158	159	DECLARE_INPUT_CHANGED_MEMBER(online_switch);
159	160	required_device<cpu_device> m_maincpu;
	161	required_device<beep_device> m_beeper;
160	162	};
161	163
162	164
r22508	r22509
208	210	void ex800_state::machine_start()
209	211	{
210	212	m_irq_state = ASSERT_LINE;
211		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
212	213	/* Setup beep */
213		speaker->set_state(0);
214		speaker->set_frequency(4000); /* measured at 4000 Hz */
	214	m_beeper->set_state(0);
	215	m_beeper->set_frequency(4000); /* measured at 4000 Hz */
215	216	}
216	217
217	218
r22508	r22509
267	268
268	269	WRITE8_MEMBER(ex800_state::ex800_portc_w)
269	270	{
270		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
271	271	if (data & 0x80)
272		speaker->set_state(0);
	272	m_beeper->set_state(0);
273	273	else
274		speaker->set_state(1);
	274	m_beeper->set_state(1);
275	275
276	276	logerror("PC W %x @%x\n", data, space.device().safe_pc());
277	277	}
r22508	r22509
458	458
459	459	/* audio hardware */
460	460	MCFG_SPEAKER_STANDARD_MONO("mono")
461		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	461	MCFG_SOUND_ADD("beeper", BEEP, 0)
462	462	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
463	463	MACHINE_CONFIG_END
464	464

trunk/src/mess/drivers/vt220.c

r22508	r22509
16	16	public:
17	17	vt220_state(const machine_config &mconfig, device_type type, const char *tag)
18	18	: driver_device(mconfig, type, tag) ,
19		m_maincpu(*this, "maincpu") { }
	19	m_maincpu(*this, "maincpu"),
	20	m_ram(*this, RAM_TAG) { }
20	21
21	22	virtual void machine_reset();
22	23	virtual void video_start();
23	24	UINT32 screen_update_vt220(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
24	25	required_device<cpu_device> m_maincpu;
	26	required_device<ram_device> m_ram;
25	27	};
26	28
27	29
r22508	r22509
38	40
39	41	void vt220_state::machine_reset()
40	42	{
41		memset(machine().device<ram_device>(RAM_TAG)->pointer(),0,16*1024);
	43	memset(m_ram->pointer(),0,16*1024);
42	44	}
43	45
44	46	void vt220_state::video_start()

trunk/src/mess/drivers/smc777.c

r22508	r22509
52	52	m_maincpu(*this, "maincpu"),
53	53	m_crtc(*this, "crtc"),
54	54	m_fdc(*this, "fdc"),
55		m_sn(*this, "sn1")
	55	m_sn(*this, "sn1"),
	56	m_beeper(*this, "beeper")
56	57	{ }
57	58
58	59	required_device<cpu_device> m_maincpu;
59	60	required_device<mc6845_device> m_crtc;
60	61	required_device<mb8876_device> m_fdc;
61	62	optional_device<sn76489a_device> m_sn;
	63	required_device<beep_device> m_beeper;
62	64
63	65	UINT8 *m_ipl_rom;
64	66	UINT8 *m_work_ram;
r22508	r22509
528	530	m_raminh_prefetch = (UINT8)(space.device().state().state_int(Z80_R)) & 0x7f;
529	531	break;
530	532	case 0x02: printf("Interlace %s\n",data & 0x10 ? "on" : "off"); break;
531		case 0x05: machine().device<beep_device>(BEEPER_TAG)->set_state(data & 0x10); break;
	533	case 0x05: m_beeper->set_state(data & 0x10); break;
532	534	default: printf("System FF W %02x\n",data); break;
533	535	}
534	536	}
r22508	r22509
990	992	m_raminh_prefetch = 0xff;
991	993	m_pal_mode = 0x10;
992	994
993		machine().device<beep_device>(BEEPER_TAG)->set_frequency(300); //TODO: correct frequency
994		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	995	m_beeper->set_frequency(300); //TODO: correct frequency
	996	m_beeper->set_state(0);
995	997	}
996	998
997	999
r22508	r22509
1114	1116	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
1115	1117	MCFG_SOUND_CONFIG(psg_intf)
1116	1118
1117		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	1119	MCFG_SOUND_ADD("beeper", BEEP, 0)
1118	1120	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
1119	1121
1120	1122	MCFG_TIMER_DRIVER_ADD_PERIODIC("keyboard_timer", smc777_state, keyboard_callback, attotime::from_hz(240/32))

trunk/src/mess/drivers/xerox820.c

r22508	r22509
714	714	static MACHINE_CONFIG_DERIVED_CLASS( bigboard, xerox820, bigboard_state )
715	715	/* sound hardware */
716	716	MCFG_SPEAKER_STANDARD_MONO("mono")
717		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	717	MCFG_SOUND_ADD("beeper", BEEP, 0)
718	718	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) /* bigboard only */
719	719	MACHINE_CONFIG_END
720	720

trunk/src/mess/drivers/micronic.c

r22508	r22509
384	384
385	385	/* sound hardware */
386	386	MCFG_SPEAKER_STANDARD_MONO( "mono" )
387		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	387	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
388	388	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
389	389
390	390	/* ram banks */

trunk/src/mess/drivers/spc1000.c

r22508	r22509
22	22	spc1000_state(const machine_config &mconfig, device_type type, const char *tag)
23	23	: driver_device(mconfig, type, tag),
24	24	m_vdg(*this, "mc6847") ,
25		m_maincpu(*this, "maincpu") {}
	25	m_maincpu(*this, "maincpu"),
	26	m_ram(*this, RAM_TAG) {}
26	27
27	28	required_device<mc6847_base_device> m_vdg;
28	29	UINT8 m_IPLK;
r22508	r22509
44	45	DECLARE_READ8_MEMBER(spc1000_gmode_r);
45	46	DECLARE_READ8_MEMBER(spc1000_mc6847_videoram_r);
46	47	required_device<cpu_device> m_maincpu;
	48	required_device<ram_device> m_ram;
47	49	};
48	50
49	51
r22508	r22509
62	64	membank("bank1")->set_base(mem);
63	65	membank("bank3")->set_base(mem);
64	66	} else {
65		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	67	UINT8 *ram = m_ram->pointer();
66	68	membank("bank1")->set_base(ram);
67	69	membank("bank3")->set_base(ram + 0x8000);
68	70	}
r22508	r22509
76	78	membank("bank1")->set_base(mem);
77	79	membank("bank3")->set_base(mem);
78	80	} else {
79		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	81	UINT8 *ram = m_ram->pointer();
80	82	membank("bank1")->set_base(ram);
81	83	membank("bank3")->set_base(ram + 0x8000);
82	84	}
r22508	r22509
229	231	{
230	232	address_space &space = m_maincpu->space(AS_PROGRAM);
231	233	UINT8 *mem = memregion("maincpu")->base();
232		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	234	UINT8 *ram = m_ram->pointer();
233	235
234	236	space.install_read_bank(0x0000, 0x7fff, "bank1");
235	237	space.install_read_bank(0x8000, 0xffff, "bank3");

trunk/src/mess/drivers/mz2500.c

r22508	r22509
65	65	mz2500_state(const machine_config &mconfig, device_type type, const char *tag)
66	66	: driver_device(mconfig, type, tag),
67	67	m_maincpu(*this, "maincpu"),
68		m_rtc(*this, RP5C15_TAG)
	68	m_rtc(*this, RP5C15_TAG),
	69	m_beeper(*this, "beeper")
69	70	{ }
70	71
71	72	required_device<cpu_device> m_maincpu;
72	73	required_device<rp5c15_device> m_rtc;
	74	required_device<beep_device> m_beeper;
73	75
74	76	UINT8 *m_main_ram;
75	77	UINT8 *m_ipl_rom;
r22508	r22509
1806	1808
1807	1809	m_cg_clear_flag = 0;
1808	1810
1809		machine().device<beep_device>(BEEPER_TAG)->set_frequency(4096);
1810		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	1811	m_beeper->set_frequency(4096);
	1812	m_beeper->set_state(0);
1811	1813
1812	1814	//  m_monitor_type = ioport("DSW1")->read() & 0x40 ? 1 : 0;
1813	1815	}
r22508	r22509
1921	1923
1922	1924	m_old_portc = data;
1923	1925
1924		machine().device<beep_device>(BEEPER_TAG)->set_state(data & 0x04);
	1926	m_beeper->set_state(data & 0x04);
1925	1927
1926	1928	m_screen_enable = data & 1;
1927	1929
r22508	r22509
2157	2159	MCFG_SOUND_ROUTE(2, "mono", 0.50)
2158	2160	MCFG_SOUND_ROUTE(3, "mono", 0.50)
2159	2161
2160		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	2162	MCFG_SOUND_ADD("beeper", BEEP, 0)
2161	2163	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
2162	2164	MACHINE_CONFIG_END
2163	2165

trunk/src/mess/drivers/multi8.c

r22508	r22509
28	28	m_maincpu(*this, "maincpu"),
29	29	m_ppi(*this, "ppi8255_0"),
30	30	m_crtc(*this, "crtc"),
31		m_beep(*this, BEEPER_TAG)
	31	m_beeper(*this, "beeper")
32	32	{ }
33	33
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<beep_device> m_beep;
	37	required_device<beep_device> m_beeper;
38	38	DECLARE_WRITE8_MEMBER(multi8_6845_w);
39	39	DECLARE_READ8_MEMBER(key_input_r);
40	40	DECLARE_READ8_MEMBER(key_status_r);
r22508	r22509
629	629
630	630	WRITE8_MEMBER( multi8_state::ym2203_porta_w )
631	631	{
632		m_beep->set_state((data & 0x08));
	632	m_beeper->set_state((data & 0x08));
633	633	}
634	634
635	635	static const ym2203_interface ym2203_config =
r22508	r22509
655	655
656	656	void multi8_state::machine_reset()
657	657	{
658		machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200); //guesswork
659		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	658	m_beeper->set_frequency(1200); //guesswork
	659	m_beeper->set_state(0);
660	660	m_mcu_init = 0;
661	661	}
662	662
r22508	r22509
682	682	MCFG_SOUND_ADD("aysnd", AY8912, 1500000) //unknown clock / divider
683	683	MCFG_SOUND_CONFIG(ym2203_config)
684	684	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
685		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	685	MCFG_SOUND_ADD("beeper", BEEP, 0)
686	686	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
687	687
688	688	/* Devices */

trunk/src/mess/drivers/z9001.c

r22508	r22509
45	45	: driver_device(mconfig, type, tag),
46	46	m_maincpu(*this, "maincpu"),
47	47	m_framecnt(0),
48		m_beeper(*this, BEEPER_TAG),
	48	m_beeper(*this, "beeper"),
49	49	m_cass(*this, "cassette"),
50	50	m_p_colorram(*this, "colorram"),
51	51	m_p_videoram(*this, "videoram"){ }
r22508	r22509
252	252	MCFG_SPEAKER_STANDARD_MONO("mono")
253	253	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
254	254	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
255		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	255	MCFG_SOUND_ADD("beeper", BEEP, 0)
256	256	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
257	257
258	258	/* Devices */

trunk/src/mess/drivers/pc4.c

r22508	r22509
233	233
234	234	/* sound hardware */
235	235	MCFG_SPEAKER_STANDARD_MONO( "mono" )
236		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	236	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
237	237	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
238	238
239	239	MCFG_RP5C01_ADD("rtc", XTAL_32_768kHz, rtc_intf)

trunk/src/mess/drivers/vtech1.c

r22508	r22509
161	161	m_speaker(*this, "speaker"),
162	162	m_cassette(*this, "cassette"),
163	163	m_videoram(*this, "videoram"),
164		m_maincpu(*this, "maincpu") { }
	164	m_maincpu(*this, "maincpu"),
	165	m_ram(*this, RAM_TAG) { }
165	166
166	167	/* devices */
167	168	required_device<mc6847_base_device> m_mc6847;
168	169	optional_device<speaker_sound_device> m_speaker;
169	170	optional_device<cassette_image_device> m_cassette;
170	171
171		UINT8 *m_ram;
	172	UINT8 *m_ram_pointer;
172	173	UINT32 m_ram_size;
173	174	required_shared_ptr<UINT8> m_videoram;
174	175
r22508	r22509
204	205	void vtech1_get_track();
205	206	void vtech1_put_track();
206	207	required_device<cpu_device> m_maincpu;
	208	required_device<ram_device> m_ram;
207	209	};
208	210
209	211
r22508	r22509
239	241	}
240	242
241	243	/* write it to ram */
242		image.fread( &m_ram[start - 0x7800], size);
	244	image.fread( &m_ram_pointer[start - 0x7800], size);
243	245
244	246	/* patch variables depending on snapshot type */
245	247	switch (header[21])
r22508	r22509
629	631	int id;
630	632
631	633	/* ram */
632		m_ram = machine().device<ram_device>(RAM_TAG)->pointer();
633		m_ram_size = machine().device<ram_device>(RAM_TAG)->size();
	634	m_ram_pointer = m_ram->pointer();
	635	m_ram_size = m_ram->size();
634	636
635	637	/* setup memory banking */
636		membank("bank1")->set_base(m_ram);
	638	membank("bank1")->set_base(m_ram_pointer);
637	639
638	640	/* 16k memory expansion? */
639	641	if (m_ram_size == 18*1024 || m_ram_size == 22*1024 || m_ram_size == 32*1024)
640	642	{
641	643	offs_t base = 0x7800 + (m_ram_size - 0x4000);
642	644	prg.install_readwrite_bank(base, base + 0x3fff, "bank2");
643		membank("bank2")->set_base(m_ram + base - 0x7800);
	645	membank("bank2")->set_base(m_ram_pointer + base - 0x7800);
644	646	}
645	647
646	648	/* 64k expansion? */
r22508	r22509
648	650	{
649	651	/* install fixed first bank */
650	652	prg.install_readwrite_bank(0x8000, 0xbfff, "bank2");
651		membank("bank2")->set_base(m_ram + 0x800);
	653	membank("bank2")->set_base(m_ram_pointer + 0x800);
652	654
653	655	/* install the others, dynamically banked in */
654	656	prg.install_readwrite_bank(0xc000, 0xffff, "bank3");
655		membank("bank3")->configure_entries(0, (m_ram_size - 0x4800) / 0x4000, m_ram + 0x4800, 0x4000);
	657	membank("bank3")->configure_entries(0, (m_ram_size - 0x4800) / 0x4000, m_ram_pointer + 0x4800, 0x4000);
656	658	membank("bank3")->set_entry(0);
657	659	}
658	660

trunk/src/mess/drivers/jr100.c

r22508	r22509
31	31	m_vram(*this, "vram"),
32	32	m_via(*this, "via"),
33	33	m_cassette(*this, "cassette"),
34		m_beeper(*this, BEEPER_TAG),
	34	m_beeper(*this, "beeper"),
35	35	m_speaker(*this, "speaker"),
36	36	m_region_maincpu(*this, "maincpu"),
37	37	m_line0(*this, "LINE0"),
r22508	r22509
413	413	MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0)
414	414	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
415	415
416		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	416	MCFG_SOUND_ADD("beeper", BEEP, 0)
417	417	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
418	418
419	419	MCFG_CASSETTE_ADD( "cassette", jr100_cassette_interface )

trunk/src/mess/drivers/rex6000.c

r22508	r22509
61	61	: driver_device(mconfig, type, tag),
62	62	m_maincpu(*this, "maincpu"),
63	63	m_ram(*this, RAM_TAG),
64		m_beep(*this, BEEPER_TAG)
	64	m_beep(*this, "beeper")
65	65	{ }
66	66
67	67	required_device<cpu_device> m_maincpu;
r22508	r22509
684	684
685	685	/* sound hardware */
686	686	MCFG_SPEAKER_STANDARD_MONO( "mono" )
687		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	687	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
688	688	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
689	689	MACHINE_CONFIG_END
690	690

trunk/src/mess/drivers/vt320.c

r22508	r22509
16	16	public:
17	17	vt320_state(const machine_config &mconfig, device_type type, const char *tag)
18	18	: driver_device(mconfig, type, tag) ,
19		m_maincpu(*this, "maincpu") { }
	19	m_maincpu(*this, "maincpu"),
	20	m_ram(*this, RAM_TAG) { }
20	21
21	22	virtual void machine_reset();
22	23	virtual void video_start();
23	24	UINT32 screen_update_vt320(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
24	25	required_device<cpu_device> m_maincpu;
	26	required_device<ram_device> m_ram;
25	27	};
26	28
27	29	/*
r22508	r22509
64	66
65	67	void vt320_state::machine_reset()
66	68	{
67		memset(machine().device<ram_device>(RAM_TAG)->pointer(),0,16*1024);
	69	memset(m_ram->pointer(),0,16*1024);
68	70	}
69	71
70	72	void vt320_state::video_start()

trunk/src/mess/drivers/comx35.c

r22508	r22509
37	37	image_fread_memory - read image to memory
38	38	-------------------------------------------------*/
39	39
40		static void image_fread_memory(device_image_interface &image, UINT16 addr, UINT32 count)
	40	void comx35_state::image_fread_memory(device_image_interface &image, UINT16 addr, UINT32 count)
41	41	{
42		UINT8 *ram = image.device().machine().device<ram_device>(RAM_TAG)->pointer() + (addr - 0x4000);
	42	UINT8 *ram = m_ram->pointer() + (addr - 0x4000);
43	43
44	44	image.fread(ram, count);
45	45	}
r22508	r22509
55	55	UINT8 header[16] = {0};
56	56	int size = image.length();
57	57
58		if (size > machine().device<ram_device>(RAM_TAG)->size())
	58	if (size > m_ram->size())
59	59	{
60	60	return IMAGE_INIT_FAIL;
61	61	}

trunk/src/mess/drivers/a5105.c

r22508	r22509
40	40	m_maincpu(*this, "maincpu"),
41	41	m_hgdc(*this, "upd7220"),
42	42	m_cass(*this, "cassette"),
43		m_beep(*this, BEEPER_TAG),
	43	m_beep(*this, "beeper"),
44	44	m_fdc(*this, "upd765a"),
45	45	m_floppy0(*this, "upd765a:0"),
46	46	m_floppy1(*this, "upd765a:1"),
47	47	m_floppy2(*this, "upd765a:2"),
48	48	m_floppy3(*this, "upd765a:3"),
49		m_video_ram(*this, "video_ram")
	49	m_video_ram(*this, "video_ram"),
	50	m_ram(*this, RAM_TAG)
50	51	{ }
51	52
52	53	required_device<cpu_device> m_maincpu;
r22508	r22509
80	81	virtual void video_start();
81	82	virtual void palette_init();
82	83	DECLARE_FLOPPY_FORMATS( floppy_formats );
	84	required_device<ram_device> m_ram;
83	85	};
84	86
85	87	/* TODO */
r22508	r22509
484	486	a5105_ab_w(space, 0, 9); // turn motor off
485	487	m_beep->set_frequency(500);
486	488
487		m_ram_base = (UINT8*)machine().device<ram_device>(RAM_TAG)->pointer();
	489	m_ram_base = (UINT8*)m_ram->pointer();
488	490	m_rom_base = (UINT8*)memregion("maincpu")->base();
489	491
490	492	membank("bank1")->set_base(m_rom_base);
r22508	r22509
601	603	MCFG_SPEAKER_STANDARD_MONO("mono")
602	604	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
603	605	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
604		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	606	MCFG_SOUND_ADD("beeper", BEEP, 0)
605	607	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
606	608
607	609	/* Devices */

trunk/src/mess/drivers/fmtowns.c

r22508	r22509
2596	2596	m_towns_cd.read_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(towns_state::towns_cdrom_read_byte),this), (void*)machine().device("dma_1"));
2597	2597
2598	2598	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(towns_state::towns_irq_callback),this));
2599		m_maincpu->space(AS_PROGRAM).install_ram(0x100000,machine().device<ram_device>(RAM_TAG)->size()-1,0xffffffff,0,NULL);
	2599	m_maincpu->space(AS_PROGRAM).install_ram(0x100000,m_ram->size()-1,0xffffffff,0,NULL);
2600	2600
2601	2601	}
2602	2602
r22508	r22509
2616	2616	m_pic_master = machine().device("pic8259_master");
2617	2617	m_pic_slave = machine().device("pic8259_slave");
2618	2618	m_pit = machine().device("pit");
2619		m_messram = machine().device<ram_device>(RAM_TAG);
	2619	m_messram = m_ram;
2620	2620	m_cdrom = machine().device<cdrom_image_device>("cdrom");
2621	2621	m_cdda = machine().device("cdda");
2622	2622	m_scsi = machine().device<fmscsi_device>("scsi:fm");
2623		m_ram = machine().device<ram_device>(RAM_TAG);
	2623	m_ram = m_ram;
2624	2624	m_ftimer = 0x00;
2625	2625	m_freerun_timer = 0x00;
2626	2626	m_nmi_mask = 0x00;

trunk/src/mess/drivers/h8.c

r22508	r22509
28	28	: driver_device(mconfig, type, tag),
29	29	m_maincpu(*this, "maincpu"),
30	30	//m_cass(*this, "cassette"),
31		m_beep(*this, BEEPER_TAG)
	31	m_beep(*this, "beeper")
32	32	{ }
33	33
34	34	required_device<cpu_device> m_maincpu;
r22508	r22509
232	232
233	233	/* sound hardware */
234	234	MCFG_SPEAKER_STANDARD_MONO("mono")
235		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	235	MCFG_SOUND_ADD("beeper", BEEP, 0)
236	236	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
237	237	MACHINE_CONFIG_END
238	238

trunk/src/mess/drivers/pcw16.c

r22508	r22509
842	842	/* bleeper on */
843	843	case 0x0b:
844	844	{
845		m_speaker->set_state(1);
	845	m_beeper->set_state(1);
846	846	}
847	847	break;
848	848
849	849	/* bleeper off */
850	850	case 0x0c:
851	851	{
852		m_speaker->set_state(0);
	852	m_beeper->set_state(0);
853	853	}
854	854	break;
855	855
r22508	r22509
1005	1005
1006	1006	void pcw16_state::machine_start()
1007	1007	{
1008		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
1009	1008	m_system_status = 0;
1010	1009	m_interrupt_counter = 0;
1011	1010
r22508	r22509
1015	1014	at_keyboard_init(machine(), AT_KEYBOARD_TYPE_AT);
1016	1015	at_keyboard_set_scan_code_set(3);
1017	1016
1018		speaker->set_state(0);
1019		speaker->set_frequency(3750);
	1017	m_beeper->set_state(0);
	1018	m_beeper->set_frequency(3750);
1020	1019	}
1021	1020
1022	1021	static INPUT_PORTS_START(pcw16)
r22508	r22509
1062	1061
1063	1062	/* sound hardware */
1064	1063	MCFG_SPEAKER_STANDARD_MONO("mono")
1065		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	1064	MCFG_SOUND_ADD("beeper", BEEP, 0)
1066	1065	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
1067	1066
1068	1067	/* printer */

trunk/src/mess/drivers/vg5k.c

r22508	r22509
66	66	m_ef9345(*this, "ef9345"),
67	67	m_dac(*this, "dac"),
68	68	m_printer(*this, "printer"),
69		m_cassette(*this, "cassette")
	69	m_cassette(*this, "cassette"),
	70	m_ram(*this, RAM_TAG)
70	71	{ }
71	72
72	73	required_device<cpu_device> m_maincpu;
r22508	r22509
74	75	required_device<dac_device> m_dac;
75	76	required_device<printer_image_device> m_printer;
76	77	required_device<cassette_image_device> m_cassette;
	78	required_device<ram_device> m_ram;
77	79
78	80	offs_t m_ef9345_offset;
79	81
r22508	r22509
339	341
340	342	/* install expansion memory*/
341	343	address_space &program = m_maincpu->space(AS_PROGRAM);
342		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
343		UINT16 ram_size = machine().device<ram_device>(RAM_TAG)->size();
	344	UINT8 *ram = m_ram->pointer();
	345	UINT16 ram_size = m_ram->size();
344	346
345	347	if (ram_size > 0x4000)
346	348	program.install_ram(0x8000, 0x3fff + ram_size, ram);

trunk/src/mess/drivers/osborne1.c

r22508	r22509
246	246	MCFG_PALETTE_LENGTH( 3 )
247	247
248	248	MCFG_SPEAKER_STANDARD_MONO( "mono" )
249		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	249	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
250	250	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
251	251
252	252	MCFG_PIA6821_ADD( "pia_0", osborne1_ieee_pia_config )

trunk/src/mess/drivers/pce220.c

r22508	r22509
42	42	: driver_device(mconfig, type, tag),
43	43	m_maincpu(*this, "maincpu"),
44	44	m_ram(*this, RAM_TAG),
45		m_beep(*this, BEEPER_TAG),
	45	m_beep(*this, "beeper"),
46	46	m_serial(*this, PCE220SERIAL_TAG)
47	47	{ }
48	48
r22508	r22509
939	939
940	940	/* sound hardware */
941	941	MCFG_SPEAKER_STANDARD_MONO("mono")
942		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	942	MCFG_SOUND_ADD("beeper", BEEP, 0)
943	943	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
944	944
945	945	MCFG_TIMER_DRIVER_ADD_PERIODIC("pce220_timer", pce220_state, pce220_timer_callback, attotime::from_msec(468))
r22508	r22509
974	974
975	975	/* sound hardware */
976	976	MCFG_SPEAKER_STANDARD_MONO("mono")
977		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	977	MCFG_SOUND_ADD("beeper", BEEP, 0)
978	978	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
979	979
980	980	MCFG_TIMER_DRIVER_ADD_PERIODIC("pce220_timer", pce220_state, pce220_timer_callback, attotime::from_msec(468))

trunk/src/mess/drivers/jr200.c

r22508	r22509
29	29	m_cram(*this, "cram"),
30	30	m_mn1271_ram(*this, "mn1271_ram"),
31	31	m_maincpu(*this, "maincpu"),
32		m_beeper(*this, BEEPER_TAG),
	32	m_beeper(*this, "beeper"),
33	33	m_pcg(*this, "pcg"),
34	34	m_gfx_rom(*this, "gfx_rom"),
35	35	m_gfx_ram(*this, "gfx_ram"),
r22508	r22509
559	559
560	560	// AY-8910 ?
561	561
562		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	562	MCFG_SOUND_ADD("beeper", BEEP, 0)
563	563	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
564	564	MACHINE_CONFIG_END
565	565

trunk/src/mess/drivers/mz3500.c

r22508	r22509
46	46	m_hgdc1(*this, "upd7220_chr"),
47	47	m_hgdc2(*this, "upd7220_gfx"),
48	48	m_fdc(*this, "upd765a"),
49		m_video_ram(*this, "video_ram")
	49	m_video_ram(*this, "video_ram"),
	50	m_beeper(*this, "beeper")
50	51	{ }
51	52
52	53	// devices
r22508	r22509
56	57	required_device<upd7220_device> m_hgdc2;
57	58	required_device<upd765a_device> m_fdc;
58	59	required_shared_ptr<UINT8> m_video_ram;
	60	required_device<beep_device> m_beeper;
	61
59	62	UINT8 *m_ipl_rom;
60	63	UINT8 *m_basic_rom;
61	64	UINT8 *m_work_ram;
r22508	r22509
661	664	*/
662	665	//printf("%02x PC\n",data);
663	666
664		machine().device<beep_device>(BEEPER_TAG)->set_state(data & 0x10);
	667	m_beeper->set_state(data & 0x10);
665	668
666	669	}
667	670
r22508	r22509
815	818	}
816	819	}
817	820
818		machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
819		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	821	m_beeper->set_frequency(2400);
	822	m_beeper->set_state(0);
820	823	}
821	824
822	825
r22508	r22509
883	886	/* sound hardware */
884	887	MCFG_SPEAKER_STANDARD_MONO("mono")
885	888
886		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	889	MCFG_SOUND_ADD("beeper", BEEP, 0)
887	890	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.15)
888	891	MACHINE_CONFIG_END
889	892

trunk/src/mess/drivers/vk100.c

r22508	r22509
159	159	m_maincpu(*this, "maincpu"),
160	160	m_screen(*this, "screen"),
161	161	m_crtc(*this, "crtc"),
162		m_speaker(*this, BEEPER_TAG),
	162	m_speaker(*this, "beeper"),
163	163	m_uart(*this, "i8251"),
164	164	//m_i8251_rx_timer(NULL),
165	165	//m_i8251_tx_timer(NULL),
r22508	r22509
1025	1025	MCFG_DEFAULT_LAYOUT( layout_vk100 )
1026	1026
1027	1027	MCFG_SPEAKER_STANDARD_MONO( "mono" )
1028		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	1028	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
1029	1029	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 0.25 )
1030	1030	MACHINE_CONFIG_END
1031	1031

trunk/src/mess/drivers/bmjr.c

r22508	r22509
26	26	: driver_device(mconfig, type, tag),
27	27	m_maincpu(*this, "maincpu"),
28	28	m_cass(*this, "cassette"),
29		m_beep(*this, BEEPER_TAG)
	29	m_beep(*this, "beeper")
30	30	,
31	31	m_p_wram(*this, "p_wram"){ }
32	32
r22508	r22509
362	362
363	363	/* Audio */
364	364	MCFG_SPEAKER_STANDARD_MONO("mono")
365		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	365	MCFG_SOUND_ADD("beeper", BEEP, 0)
366	366	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
367	367	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
368	368	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)

trunk/src/mess/drivers/lx800.c

r22508	r22509
31	31	lx800_state(const machine_config &mconfig, device_type type, const char *tag)
32	32	: driver_device(mconfig, type, tag),
33	33	m_maincpu(*this, "maincpu"),
34		m_beep(*this, BEEPER_TAG)
	34	m_beep(*this, "beeper")
35	35	{ }
36	36
37	37	required_device<cpu_device> m_maincpu;
r22508	r22509
268	268
269	269	/* audio hardware */
270	270	MCFG_SPEAKER_STANDARD_MONO("mono")
271		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	271	MCFG_SOUND_ADD("beeper", BEEP, 0)
272	272	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
273	273
274	274	/* gate array */

trunk/src/mess/drivers/zrt80.c

r22508	r22509
30	30	m_maincpu(*this, "maincpu"),
31	31	m_crtc(*this, "crtc"),
32	32	m_8250(*this, "ins8250"),
33		m_beep(*this, BEEPER_TAG),
	33	m_beep(*this, "beeper"),
34	34	m_p_videoram(*this, "videoram"){ }
35	35
36	36	required_device<cpu_device> m_maincpu;
r22508	r22509
301	301
302	302	/* sound hardware */
303	303	MCFG_SPEAKER_STANDARD_MONO("mono")
304		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	304	MCFG_SOUND_ADD("beeper", BEEP, 0)
305	305	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
306	306
307	307	/* Devices */

trunk/src/mess/drivers/ace.c

r22508	r22509
76	76	unsigned char ace_repeat, ace_byte, loop;
77	77	int done=0, ace_index=0x2000;
78	78
79		if (machine().device<ram_device>(RAM_TAG)->size() < 16*1024)
	79	if (m_ram->size() < 16*1024)
80	80	{
81	81	image.seterror(IMAGE_ERROR_INVALIDIMAGE, "At least 16KB RAM expansion required");
82	82	image.message("At least 16KB RAM expansion required");

trunk/src/mess/drivers/sc2.c

r22508	r22509
20	20	public:
21	21	sc2_state(const machine_config &mconfig, device_type type, const char *tag)
22	22	: driver_device(mconfig, type, tag),
23		m_beep(*this, BEEPER_TAG)
	23	m_beep(*this, "beeper")
24	24	,
25	25	m_maincpu(*this, "maincpu") { }
26	26
r22508	r22509
219	219
220	220	/* sound hardware */
221	221	MCFG_SPEAKER_STANDARD_MONO( "mono" )
222		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	222	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
223	223	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 0.50 )
224	224	MACHINE_CONFIG_END
225	225

trunk/src/mess/drivers/psion.c

r22508	r22509
490	490
491	491	/* sound hardware */
492	492	MCFG_SPEAKER_STANDARD_MONO( "mono" )
493		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	493	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
494	494	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
495	495
496	496	MCFG_NVRAM_HANDLER(psion)

trunk/src/mess/drivers/pcw.c

r22508	r22509
239	239	space.install_read_bank(block * 0x04000 + 0x0000, block * 0x04000 + 0x3fff,block_name);
240	240	//      LOG(("MEM: read block %i -> bank %i\n",block,bank));
241	241	}
242		membank(block_name)->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + ((bank * 0x4000) % machine().device<ram_device>(RAM_TAG)->size()));
	242	membank(block_name)->set_base(m_ram->pointer() + ((bank * 0x4000) % m_ram->size()));
243	243	}
244	244
245	245
r22508	r22509
249	249	char block_name[10];
250	250
251	251	sprintf(block_name,"bank%d",block+5);
252		membank(block_name)->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + ((bank * 0x4000) % machine().device<ram_device>(RAM_TAG)->size()));
	252	membank(block_name)->set_base(m_ram->pointer() + ((bank * 0x4000) % m_ram->size()));
253	253	//  LOG(("MEM: write block %i -> bank %i\n",block,bank));
254	254	}
255	255
r22508	r22509
407	407	WRITE8_MEMBER(pcw_state::pcw_system_control_w)
408	408	{
409	409	upd765a_device *fdc = machine().device<upd765a_device>("upd765");
410		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
411	410	LOG(("SYSTEM CONTROL: %d\n",data));
412	411
413	412	switch (data)
r22508	r22509
545	544	/* beep on */
546	545	case 11:
547	546	{
548		speaker->set_state(1);
	547	m_beeper->set_state(1);
549	548	}
550	549	break;
551	550
552	551	/* beep off */
553	552	case 12:
554	553	{
555		speaker->set_state(0);
	554	m_beeper->set_state(0);
556	555	}
557	556	break;
558	557
r22508	r22509
995	994
996	995	TIMER_CALLBACK_MEMBER(pcw_state::setup_beep)
997	996	{
998		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
999		speaker->set_state(0);
1000		speaker->set_frequency(3750);
	997	m_beeper->set_state(0);
	998	m_beeper->set_frequency(3750);
1001	999	}
1002	1000
1003	1001
r22508	r22509
1028	1026	m_boot = 0;   // System starts up in bootstrap mode, disabled until it's possible to emulate it.
1029	1027
1030	1028	/* copy boot code into RAM - yes, it's skipping a step */
1031		memset(machine().device<ram_device>(RAM_TAG)->pointer(),0x00,machine().device<ram_device>(RAM_TAG)->size());
	1029	memset(m_ram->pointer(),0x00,m_ram->size());
1032	1030	for(x=0;x<256;x++)
1033		machine().device<ram_device>(RAM_TAG)->pointer()[x+2] = code[x+0x300];
	1031	m_ram->pointer()[x+2] = code[x+0x300];
1034	1032
1035	1033	/* and hack our way past the MCU side of the boot process */
1036	1034	code[0x01] = 0x40;
r22508	r22509
1291	1289
1292	1290	/* sound hardware */
1293	1291	MCFG_SPEAKER_STANDARD_MONO("mono")
1294		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	1292	MCFG_SOUND_ADD("beeper", BEEP, 0)
1295	1293	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
1296	1294
1297	1295	MCFG_UPD765A_ADD("upd765", true, true)

trunk/src/mess/drivers/aquarius.c

r22508	r22509
187	187	{
188	188	address_space &space = m_maincpu->space(AS_PROGRAM);
189	189
190		space.install_readwrite_bank(0x4000, 0x4000 + machine().device<ram_device>(RAM_TAG)->size() - 0x1000 - 1, "bank1");
191		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	190	space.install_readwrite_bank(0x4000, 0x4000 + m_ram->size() - 0x1000 - 1, "bank1");
	191	membank("bank1")->set_base(m_ram->pointer());
192	192	}
193	193	}
194	194

trunk/src/mess/drivers/tvc.c

r22508	r22509
621	621	if (first_byte == 0x11)
622	622	{
623	623	image.fseek(0x90, SEEK_SET);
624		image.fread(machine().device<ram_device>(RAM_TAG)->pointer() + 0x19ef, image.length() - 0x90);
	624	image.fread(m_ram->pointer() + 0x19ef, image.length() - 0x90);
625	625	return IMAGE_INIT_PASS;
626	626	}
627	627	else

trunk/src/mess/drivers/fk1.c

r22508	r22509
19	19	public:
20	20	fk1_state(const machine_config &mconfig, device_type type, const char *tag)
21	21	: driver_device(mconfig, type, tag),
22		m_maincpu(*this, "maincpu")
	22	m_maincpu(*this, "maincpu"),
	23	m_ram(*this, RAM_TAG)
23	24	{ }
24	25
25	26	required_device<cpu_device> m_maincpu;
	27	required_device<ram_device> m_ram;
	28
26	29	DECLARE_WRITE8_MEMBER(fk1_ppi_1_a_w);
27	30	DECLARE_WRITE8_MEMBER(fk1_ppi_1_b_w);
28	31	DECLARE_WRITE8_MEMBER(fk1_ppi_1_c_w);
r22508	r22509
297	300	READ8_MEMBER( fk1_state::fk1_bank_ram_r )
298	301	{
299	302	address_space &space_mem = m_maincpu->space(AS_PROGRAM);
300		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	303	UINT8 *ram = m_ram->pointer();
301	304
302	305	space_mem.install_write_bank(0x0000, 0x3fff, "bank1");
303	306	membank("bank1")->set_base(ram);
r22508	r22509
310	313	address_space &space_mem = m_maincpu->space(AS_PROGRAM);
311	314	space_mem.unmap_write(0x0000, 0x3fff);
312	315	membank("bank1")->set_base(memregion("maincpu")->base());
313		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x10000);
	316	membank("bank2")->set_base(m_ram->pointer() + 0x10000);
314	317	return 0;
315	318	}
316	319
r22508	r22509
421	424	void fk1_state::machine_reset()
422	425	{
423	426	address_space &space = m_maincpu->space(AS_PROGRAM);
424		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	427	UINT8 *ram = m_ram->pointer();
425	428
426	429	space.unmap_write(0x0000, 0x3fff);
427	430	membank("bank1")->set_base(memregion("maincpu")->base()); // ROM
r22508	r22509
436	439	{
437	440	UINT8 code;
438	441	int y, x, b;
439		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	442	UINT8 *ram = m_ram->pointer();
440	443
441	444	for (x = 0; x < 64; x++)
442	445	{

trunk/src/mess/drivers/portfoli.c

r22508	r22509
762	762	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(portfolio_state::portfolio_int_ack),this));
763	763
764	764	/* memory expansions */
765		switch (machine().device<ram_device>(RAM_TAG)->size())
	765	switch (m_ram->size())
766	766	{
767	767	case 128 * 1024:
768	768	program.unmap_readwrite(0x1f000, 0x9efff);

trunk/src/mess/drivers/pb1000.c

r22508	r22509
31	31	pb1000_state(const machine_config &mconfig, device_type type, const char *tag)
32	32	: driver_device(mconfig, type, tag),
33	33	m_maincpu(*this, "maincpu"),
34		m_beep(*this, BEEPER_TAG),
	34	m_beeper(*this, "beeper"),
35	35	m_hd44352(*this, "hd44352")
36	36	{ }
37	37
38	38	required_device<hd61700_cpu_device> m_maincpu;
39		required_device<beep_device> m_beep;
	39	required_device<beep_device> m_beeper;
40	40	required_device<hd44352_device> m_hd44352;
41	41
42	42	emu_timer *m_kb_timer;
r22508	r22509
443	443
444	444	static void port_w(hd61700_cpu_device &device, UINT8 data)
445	445	{
446		device.machine().device<beep_device>(BEEPER_TAG)->set_state((BIT(data,7) ^ BIT(data,6)));
	446	pb1000_state *state = device.machine().driver_data<pb1000_state>();
	447	state->m_beeper->set_state((BIT(data,7) ^ BIT(data,6)));
447	448	//printf("%x\n", data);
448	449	}
449	450
r22508	r22509
526	527
527	528	/* sound hardware */
528	529	MCFG_SPEAKER_STANDARD_MONO( "mono" )
529		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	530	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
530	531	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
531	532	MACHINE_CONFIG_END
532	533

trunk/src/mess/drivers/mz2000.c

r22508	r22509
43	43	m_maincpu(*this, "maincpu"),
44	44	m_mb8877a(*this, "mb8877a"),
45	45	m_pit8253(*this, "pit"),
46		m_beeper(*this, BEEPER_TAG),
	46	m_beeper(*this, "beeper"),
47	47	m_region_tvram(*this, "tvram"),
48	48	m_region_gvram(*this, "gvram"),
49	49	m_region_chargen(*this, "chargen"),
r22508	r22509
892	892	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
893	893	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
894	894
895		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	895	MCFG_SOUND_ADD("beeper", BEEP, 0)
896	896	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.15)
897	897	MACHINE_CONFIG_END
898	898

trunk/src/mess/drivers/qx10.c

r22508	r22509
64	64	m_fdc(*this, "upd765"),
65	65	m_hgdc(*this, "upd7220"),
66	66	m_rtc(*this, "rtc"),
67		m_vram_bank(0)
68		,
69		m_maincpu(*this, "maincpu") { }
	67	m_vram_bank(0),
	68	m_maincpu(*this, "maincpu"),
	69	m_ram(*this, RAM_TAG) { }
70	70
71	71	required_device<pit8253_device> m_pit_1;
72	72	required_device<pit8253_device> m_pit_2;
r22508	r22509
149	149	DECLARE_WRITE_LINE_MEMBER(dma_hrq_changed);
150	150	IRQ_CALLBACK_MEMBER(irq_callback);
151	151	required_device<cpu_device> m_maincpu;
	152	required_device<ram_device> m_ram;
152	153	};
153	154
154	155	static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
r22508	r22509
274	275	}
275	276	else
276	277	{
277		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + drambank*64*1024);
	278	membank("bank1")->set_base(m_ram->pointer() + drambank*64*1024);
278	279	}
279	280	if (m_memcmos)
280	281	{
r22508	r22509
282	283	}
283	284	else
284	285	{
285		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + drambank*64*1024 + 32*1024);
	286	membank("bank2")->set_base(m_ram->pointer() + drambank*64*1024 + 32*1024);
286	287	}
287	288	}
288	289

trunk/src/mess/drivers/nc.c

r22508	r22509
347	347
348	348	mem_bank = mem_bank & m_membank_internal_ram_mask;
349	349
350		addr = machine().device<ram_device>(RAM_TAG)->pointer() + (mem_bank<<14);
	350	addr = m_ram->pointer() + (mem_bank<<14);
351	351
352	352	membank(bank1)->set_base(addr);
353	353	membank(bank5)->set_base(addr);
r22508	r22509
420	420	if (m_file->read(&stored_size, sizeof(UINT32)) != sizeof(UINT32))
421	421	stored_size = 0;
422	422
423		if (stored_size > machine().device<ram_device>(RAM_TAG)->size())
424		restore_size = machine().device<ram_device>(RAM_TAG)->size();
	423	if (stored_size > m_ram->size())
	424	restore_size = m_ram->size();
425	425	else
426	426	restore_size = stored_size;
427	427
428	428	/* read as much as will fit into memory */
429		m_file->read(machine().device<ram_device>(RAM_TAG)->pointer(), restore_size);
	429	m_file->read(m_ram->pointer(), restore_size);
430	430	/* seek over remaining data */
431	431	m_file->seek(SEEK_CUR,stored_size - restore_size);
432	432	}
r22508	r22509
434	434	/* store a block of memory to the nvram file */
435	435	void nc_state::nc_common_store_memory_to_stream()
436	436	{
437		UINT32 size = machine().device<ram_device>(RAM_TAG)->size();
	437	UINT32 size = m_ram->size();
438	438	if (!m_file)
439	439	return;
440	440
r22508	r22509
443	443	m_file->write(&size, sizeof(UINT32));
444	444
445	445	/* write data block */
446		m_file->write(machine().device<ram_device>(RAM_TAG)->pointer(), size);
	446	m_file->write(m_ram->pointer(), size);
447	447	}
448	448
449	449	void nc_state::nc_common_open_stream_for_reading()
r22508	r22509
660	660	int on;
661	661	int frequency;
662	662	int period;
663		const char *beeper_device = NULL;
	663	beep_device *beeper_device = NULL;
664	664
665	665	switch(channel)
666	666	{
667	667	case 0:
668		beeper_device = "beep.1";
	668	beeper_device = m_beeper1;
669	669	break;
670	670	case 1:
671		beeper_device = "beep.2";
	671	beeper_device = m_beeper2;
672	672	break;
673	673	}
674	674
r22508	r22509
681	681	frequency = (int)(1000000.0f/((float)((period & 0x07fff)<<1) * 1.6276f));
682	682
683	683	/* set state */
684		machine().device<beep_device>(beeper_device)->set_state(on);
	684	beeper_device->set_state(on);
685	685	/* set frequency */
686		machine().device<beep_device>(beeper_device)->set_frequency(frequency);
	686	beeper_device->set_frequency(frequency);
687	687	}
688	688
689	689	WRITE8_MEMBER(nc_state::nc_sound_w)

trunk/src/mess/drivers/x07.c

r22508	r22509
1509	1509
1510	1510	/* sound hardware */
1511	1511	MCFG_SPEAKER_STANDARD_MONO( "mono" )
1512		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	1512	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
1513	1513	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 0.50 )
1514	1514	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
1515	1515	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)

trunk/src/mess/drivers/mephisto.c

r22508	r22509
74	74	mephisto_state(const machine_config &mconfig, device_type type, const char *tag)
75	75	: mboard_state(mconfig, type, tag)
76	76	, m_maincpu(*this, "maincpu")
77		, m_beep(*this, BEEPER_TAG)
	77	, m_beep(*this, "beeper")
78	78	, m_key1_0(*this, "KEY1_0")
79	79	, m_key1_1(*this, "KEY1_1")
80	80	, m_key1_2(*this, "KEY1_2")
r22508	r22509
459	459
460	460	/* sound hardware */
461	461	MCFG_SPEAKER_STANDARD_MONO("mono")
462		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	462	MCFG_SOUND_ADD("beeper", BEEP, 0)
463	463	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
464	464
465	465	MCFG_TIMER_DRIVER_ADD_PERIODIC("nmi_timer", mephisto_state, update_nmi, attotime::from_hz(600))

trunk/src/mess/drivers/bml3.c

r22508	r22509
49	49	m_maincpu(*this, "maincpu"),
50	50	m_crtc(*this, "crtc"),
51	51	//m_cass(*this, "cassette"),
52		m_beep(*this, BEEPER_TAG)
	52	m_beep(*this, "beeper")
53	53	{ }
54	54
55	55	required_device<cpu_device> m_maincpu;
r22508	r22509
918	918
919	919	/* Audio */
920	920	MCFG_SPEAKER_STANDARD_MONO("mono")
921		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	921	MCFG_SOUND_ADD("beeper", BEEP, 0)
922	922	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
923	923
924	924	MCFG_SOUND_ADD("ym2203", YM2203, 2000000) //unknown clock / divider

trunk/src/mess/drivers/mstation.c

r22508	r22509
36	36	public:
37	37	mstation_state(const machine_config &mconfig, device_type type, const char *tag)
38	38	: driver_device(mconfig, type, tag),
39		m_maincpu(*this, "maincpu")
	39	m_maincpu(*this, "maincpu"),
	40	m_ram(*this, RAM_TAG)
40	41	{ }
41	42
42	43	required_device<cpu_device> m_maincpu;
	44	required_device<ram_device> m_ram;
43	45
44	46	intelfsh8_device *m_flashes[2];
45	47	UINT8 m_bank1[2];
r22508	r22509
454	456
455	457	// allocate the videoram
456	458	m_vram = (UINT8*)machine().memory().region_alloc( "vram", 9600, 1, ENDIANNESS_LITTLE )->base();
457		m_ram_base = (UINT8*)machine().device<ram_device>(RAM_TAG)->pointer();
	459	m_ram_base = (UINT8*)m_ram->pointer();
458	460
459	461	// map firsh RAM bank at 0xc000-0xffff
460	462	membank("sysram")->set_base(m_ram_base);

trunk/src/mess/drivers/supercon.c

r22508	r22509
29	29	supercon_state(const machine_config &mconfig, device_type type, const char *tag)
30	30	: driver_device(mconfig, type, tag),
31	31	m_maincpu(*this, "maincpu"),
32		m_beep(*this, BEEPER_TAG),
	32	m_beep(*this, "beeper"),
33	33	m_b_white(*this, "B_WHITE"),
34	34	m_b_black(*this, "B_BLACK"),
35	35	m_b_clr(*this, "B_CLR"),
r22508	r22509
793	793
794	794	/* sound hardware */
795	795	MCFG_SPEAKER_STANDARD_MONO("mono")
796		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	796	MCFG_SOUND_ADD("beeper", BEEP, 0)
797	797	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
798	798
799	799	MCFG_TIMER_DRIVER_ADD_PERIODIC("artwork_timer", supercon_state, update_artwork, attotime::from_hz(20))

trunk/src/mess/drivers/v1050.c

r22508	r22509
1012	1012	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(v1050_state::v1050_int_ack),this));
1013	1013
1014	1014	// setup memory banking
1015		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	1015	UINT8 *ram = m_ram->pointer();
1016	1016
1017	1017	membank("bank1")->configure_entries(0, 2, ram, 0x10000);
1018	1018	membank("bank1")->configure_entry(2, ram + 0x1c000);

trunk/src/mess/drivers/p8k.c

r22508	r22509
792	792	/* sound hardware */
793	793	MCFG_SPEAKER_STANDARD_MONO("mono")
794	794
795		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	795	MCFG_SOUND_ADD("beeper", BEEP, 0)
796	796	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.5)
797	797
798	798	/* video hardware */
r22508	r22509
819	819
820	820	/* sound hardware */
821	821	MCFG_SPEAKER_STANDARD_MONO("mono")
822		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	822	MCFG_SOUND_ADD("beeper", BEEP, 0)
823	823	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.5)
824	824
825	825	/* video hardware */

trunk/src/mess/drivers/alphatro.c

r22508	r22509
40	40	m_crtc(*this, "crtc"),
41	41	m_usart(*this, "usart"),
42	42	m_cass(*this, "cassette"),
43		m_beep(*this, BEEPER_TAG),
	43	m_beep(*this, "beeper"),
44	44	m_p_ram(*this, "p_ram"),
45	45	m_p_videoram(*this, "p_videoram"){ }
46	46
r22508	r22509
437	437
438	438	/* sound hardware */
439	439	MCFG_SPEAKER_STANDARD_MONO("mono")
440		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	440	MCFG_SOUND_ADD("beeper", BEEP, 0)
441	441	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
442	442	MCFG_SOUND_WAVE_ADD(WAVE_TAG, "cassette")
443	443	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)

trunk/src/mess/drivers/rt1715.c

r22508	r22509
27	27	public:
28	28	rt1715_state(const machine_config &mconfig, device_type type, const char *tag)
29	29	: driver_device(mconfig, type, tag) ,
30		m_maincpu(*this, "maincpu") { }
	30	m_maincpu(*this, "maincpu"),
	31	m_ram(*this, RAM_TAG) { }
31	32
32	33	int m_led1_val;
33	34	int m_led2_val;
r22508	r22509
41	42	virtual void machine_reset();
42	43	virtual void palette_init();
43	44	required_device<cpu_device> m_maincpu;
	45	required_device<ram_device> m_ram;
44	46	};
45	47
46	48
r22508	r22509
109	111
110	112	void rt1715_state::machine_start()
111	113	{
112		membank("bank2")->set_base(machine().device<ram_device>(RAM_TAG)->pointer() + 0x0800);
113		membank("bank3")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	114	membank("bank2")->set_base(m_ram->pointer() + 0x0800);
	115	membank("bank3")->set_base(m_ram->pointer());
114	116	}
115	117
116	118	void rt1715_state::machine_reset()
r22508	r22509
124	126	logerror("%s: rt1715_set_bank %02x\n", machine().describe_context(), data);
125	127
126	128	/* disable ROM, enable RAM */
127		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	129	membank("bank1")->set_base(m_ram->pointer());
128	130	}
129	131
130	132	/***************************************************************************

trunk/src/mess/drivers/glasgow.c

r22508	r22509
59	59	glasgow_state(const machine_config &mconfig, device_type type, const char *tag)
60	60	: mboard_state(mconfig, type, tag),
61	61	m_maincpu(*this, "maincpu"),
62		m_beep(*this, BEEPER_TAG)
	62	m_beep(*this, "beeper")
63	63	{ }
64	64
65	65	required_device<cpu_device> m_maincpu;
r22508	r22509
511	511	MCFG_CPU_ADD("maincpu", M68000, 12000000)
512	512	MCFG_CPU_PROGRAM_MAP(glasgow_mem)
513	513	MCFG_SPEAKER_STANDARD_MONO("mono")
514		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	514	MCFG_SOUND_ADD("beeper", BEEP, 0)
515	515	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
516	516
517	517	MCFG_TIMER_DRIVER_ADD_PERIODIC("nmi_timer", glasgow_state, update_nmi, attotime::from_hz(50))

trunk/src/mess/drivers/thomson.c

r22508	r22509
317	317	/* 0x10000 - 0x1ffff: 64 KB external ROM cartridge */
318	318	/* 0x20000 - 0x247ff: 18 KB floppy / network ROM controllers */
319	319
320		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping:
	320	/* RAM mapping:
321	321	0x0000 - 0x3fff: 16 KB video RAM (actually 8 K x 8 bits + 8 K x 6 bits)
322	322	0x4000 - 0x5fff:  8 KB base RAM
323	323	0x6000 - 0x9fff: 16 KB extended RAM
r22508	r22509
784	784	/* 0x10000 - 0x1ffff: 64 KB external ROM cartridge */
785	785	/* 0x20000 - 0x247ff: 18 KB floppy / network ROM controllers */
786	786
787		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping:
	787	/* RAM mapping:
788	788	0x00000 - 0x03fff: 16 KB video RAM
789	789	0x04000 - 0x07fff: 16 KB unbanked base RAM
790	790	0x08000 - 0x1ffff: 6 * 16 KB banked extended RAM
r22508	r22509
975	975	/* 0x10000 - 0x1ffff: 16 KB integrated BASIC / 64 KB external cartridge */
976	976	/* 0x20000 - 0x247ff: 18 KB floppy / network ROM controllers */
977	977
978		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping:
	978	/* RAM mapping:
979	979	0x00000 - 0x03fff: 16 KB video RAM
980	980	0x04000 - 0x0bfff: 32 KB unbanked base RAM
981	981	0x0c000 - 0x1bfff: 4 * 16 KB bank extended RAM
r22508	r22509
1182	1182	/* 0x20000 - 0x3ffff: 128 KB internal software ROM */
1183	1183	/* 0x40000 - 0x447ff: 18  KB external floppy / network ROM controllers */
1184	1184
1185		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping:
	1185	/* RAM mapping:
1186	1186	0x00000 - 0x03fff: 16 KB video RAM
1187	1187	0x04000 - 0x07fff: 16 KB unbanked base RAM
1188	1188	0x08000 - 0x2ffff: 10 * 16 KB banked extended RAM
r22508	r22509
1507	1507	/* 0x30000 - 0x33fff: 16 KB BIOS ROM */
1508	1508	/* 0x34000 - 0x387ff: 18 KB external floppy / network ROM controllers */
1509	1509
1510		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping: 512 KB flat (including video) */
	1510	/* RAM mapping: 512 KB flat (including video) */
1511	1511
1512	1512	ADDRESS_MAP_END
1513	1513
r22508	r22509
1703	1703	/* 0x30000 - 0x33fff: 16 KB BIOS ROM */
1704	1704	/* 0x34000 - 0x387ff: 18 KB external floppy / network ROM controllers */
1705	1705
1706		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping: 512 KB flat (including video) */
	1706	/* RAM mapping: 512 KB flat (including video) */
1707	1707
1708	1708	ADDRESS_MAP_END
1709	1709
r22508	r22509
1863	1863	/* 0x20000 - 0x2ffff: 64 KB BIOS ROM */
1864	1864	/* 0x30000 - 0x347ff: 16 KB floppy / network ROM controllers */
1865	1865
1866		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping: 128 KB flat (including video) */
	1866	/* RAM mapping: 128 KB flat (including video) */
1867	1867
1868	1868	ADDRESS_MAP_END
1869	1869
r22508	r22509
2178	2178	/* 0x20000 - 0x2ffff: 64 KB BIOS ROM */
2179	2179	/* 0x30000 - 0x347ff: 16 KB floppy / network ROM controllers */
2180	2180
2181		/* machine.device<ram_device>(RAM_TAG)->pointer() mapping: 128 KB flat (including video) */
	2181	/* RAM mapping: 128 KB flat (including video) */
2182	2182
2183	2183	ADDRESS_MAP_END
2184	2184

trunk/src/mess/drivers/studio2.c

r22508	r22509
446	446
447	447	WRITE_LINE_MEMBER( studio2_state::q_w )
448	448	{
449		m_speaker->set_state(state);
	449	m_beeper->set_state(state);
450	450	}
451	451
452	452	static COSMAC_INTERFACE( studio2_cosmac_intf )
r22508	r22509
550	550
551	551	/* sound hardware */
552	552	MCFG_SPEAKER_STANDARD_MONO("mono")
553		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	553	MCFG_SOUND_ADD("beeper", BEEP, 0)
554	554	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
555	555
556	556	MCFG_FRAGMENT_ADD( studio2_cartslot )
r22508	r22509
569	569
570	570	/* sound hardware */
571	571	MCFG_SPEAKER_STANDARD_MONO("mono")
572		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	572	MCFG_SOUND_ADD("beeper", BEEP, 0)
573	573	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
574	574
575	575	MCFG_FRAGMENT_ADD( studio2_cartslot )
r22508	r22509
588	588
589	589	/* sound hardware */
590	590	MCFG_SPEAKER_STANDARD_MONO("mono")
591		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	591	MCFG_SOUND_ADD("beeper", BEEP, 0)
592	592	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
593	593
594	594	MCFG_CDP1864_ADD(CDP1864_TAG, CDP1864_CLOCK, mpt02_cdp1864_intf)
r22508	r22509
629	629
630	630	TIMER_CALLBACK_MEMBER(studio2_state::setup_beep)
631	631	{
632		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
633		speaker->set_state(0);
634		speaker->set_frequency(300);
	632	m_beeper->set_state(0);
	633	m_beeper->set_frequency(300);
635	634	}
636	635
637	636	DRIVER_INIT_MEMBER(studio2_state,studio2)

trunk/src/mess/drivers/tmc1800.c

r22508	r22509
794	794	// sound hardware
795	795	MCFG_SPEAKER_STANDARD_MONO("mono")
796	796
797		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	797	MCFG_SOUND_ADD("beeper", BEEP, 0)
798	798	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
799	799
800	800	// devices
r22508	r22509
820	820	// sound hardware
821	821	MCFG_SPEAKER_STANDARD_MONO("mono")
822	822
823		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	823	MCFG_SOUND_ADD("beeper", BEEP, 0)
824	824	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
825	825
826	826	// devices
r22508	r22509
907	907
908	908	TIMER_CALLBACK_MEMBER(tmc1800_state::setup_beep)
909	909	{
910		beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
911		speaker->set_state(0);
912		speaker->set_frequency(0);
	910	m_beeper->set_state(0);
	911	m_beeper->set_frequency(0);
913	912	}
914	913
915	914	DRIVER_INIT_MEMBER(tmc1800_state,tmc1800)

trunk/src/mess/drivers/x68k.c

r22508	r22509
1466	1466	//  if(offset == 0x5a/2)  // 0x5a should be 0 if no SASI HDs are present.
1467	1467	//      return 0x0000;
1468	1468	if(offset == 0x08/2)
1469		return machine().device<ram_device>(RAM_TAG)->size() >> 16;  // RAM size
	1469	return m_ram->size() >> 16;  // RAM size
1470	1470	#if 0
1471	1471	if(offset == 0x46/2)
1472	1472	return 0x0024;
r22508	r22509
1481	1481	READ32_MEMBER(x68k_state::x68k_sram32_r)
1482	1482	{
1483	1483	if(offset == 0x08/4)
1484		return (machine().device<ram_device>(RAM_TAG)->size() & 0xffff0000);  // RAM size
	1484	return (m_ram->size() & 0xffff0000);  // RAM size
1485	1485	#if 0
1486	1486	if(offset == 0x46/2)
1487	1487	return 0x0024;
r22508	r22509
1600	1600	{
1601	1601	int val = param;
1602	1602	int v;
1603		UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
	1603	UINT8 *ram = m_ram->pointer();
1604	1604
1605	1605	if(strcmp(machine().system().name,"x68030") == 0)
1606	1606	v = 0x0b;
r22508	r22509
2410	2410	UINT8* romdata = memregion("user2")->base();
2411	2411	attotime irq_time;
2412	2412
2413		memset(machine().device<ram_device>(RAM_TAG)->pointer(),0,machine().device<ram_device>(RAM_TAG)->size());
2414		memcpy(machine().device<ram_device>(RAM_TAG)->pointer(),romdata,8);
	2413	memset(m_ram->pointer(),0,m_ram->size());
	2414	memcpy(m_ram->pointer(),romdata,8);
2415	2415
2416	2416	// init keyboard
2417	2417	m_keyboard.delay = 500;  // 3*100+200
r22508	r22509
2468	2468	m_spriteram = (UINT16*)(*memregion("user1"));
2469	2469	space.install_read_handler(0x000000,0xbffffb,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_emptyram_r),this));
2470	2470	space.install_write_handler(0x000000,0xbffffb,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_emptyram_w),this));
2471		space.install_readwrite_bank(0x000000,machine().device<ram_device>(RAM_TAG)->size()-1,0xffffffff,0,"bank1");
2472		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	2471	space.install_readwrite_bank(0x000000,m_ram->size()-1,0xffffffff,0,"bank1");
	2472	membank("bank1")->set_base(m_ram->pointer());
2473	2473	space.install_read_handler(0xc00000,0xdfffff,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_gvram_r),this));
2474	2474	space.install_write_handler(0xc00000,0xdfffff,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_gvram_w),this));
2475	2475	membank("bank2")->set_base(m_gvram16);  // so that code in VRAM is executable - needed for Terra Cresta
r22508	r22509
2515	2515	m_spriteram = (UINT16*)(*memregion("user1"));
2516	2516	space.install_read_handler(0x000000,0xbffffb,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_rom0_r),this),0xffffffff);
2517	2517	space.install_write_handler(0x000000,0xbffffb,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_rom0_w),this),0xffffffff);
2518		space.install_readwrite_bank(0x000000,machine().device<ram_device>(RAM_TAG)->size()-1,0xffffffff,0,"bank1");
2519		membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer());
	2518	space.install_readwrite_bank(0x000000,m_ram->size()-1,0xffffffff,0,"bank1");
	2519	membank("bank1")->set_base(m_ram->pointer());
2520	2520	space.install_read_handler(0xc00000,0xdfffff,0xffffffff,0,read32_delegate(FUNC(x68k_state::x68k_gvram32_r),this));
2521	2521	space.install_write_handler(0xc00000,0xdfffff,0xffffffff,0,write32_delegate(FUNC(x68k_state::x68k_gvram32_w),this));
2522	2522	membank("bank2")->set_base(m_gvram32);  // so that code in VRAM is executable - needed for Terra Cresta

trunk/src/mess/drivers/h19.c

r22508	r22509
49	49	m_maincpu(*this, "maincpu"),
50	50	m_crtc(*this, "crtc"),
51	51	m_ace(*this, "ins8250"),
52		m_beep(*this, BEEPER_TAG),
	52	m_beep(*this, "beeper"),
53	53	m_p_videoram(*this, "p_videoram")
54	54	{ }
55	55
r22508	r22509
419	419
420	420	/* sound hardware */
421	421	MCFG_SPEAKER_STANDARD_MONO("mono")
422		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	422	MCFG_SOUND_ADD("beeper", BEEP, 0)
423	423	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
424	424	MACHINE_CONFIG_END
425	425

trunk/src/mess/drivers/rx78.c

r22508	r22509
52	52	public:
53	53	rx78_state(const machine_config &mconfig, device_type type, const char *tag)
54	54	: driver_device(mconfig, type, tag),
55		m_maincpu(*this, "maincpu"),
56		m_cass(*this, "cassette")
	55	m_maincpu(*this, "maincpu"),
	56	m_cass(*this, "cassette"),
	57	m_ram(*this, RAM_TAG)
57	58	{ }
58	59
59	60	DECLARE_READ8_MEMBER( key_r );
r22508	r22509
78	79	DECLARE_DRIVER_INIT(rx78);
79	80	required_device<cpu_device> m_maincpu;
80	81	required_device<cassette_image_device> m_cass;
	82	required_device<ram_device> m_ram;
81	83	DECLARE_DEVICE_IMAGE_LOAD_MEMBER( rx78_cart );
82	84	};
83	85
r22508	r22509
514	516
515	517	DRIVER_INIT_MEMBER(rx78_state,rx78)
516	518	{
517		UINT32 ram_size = machine().device<ram_device>(RAM_TAG)->size();
	519	UINT32 ram_size = m_ram->size();
518	520	address_space &prg = m_maincpu->space(AS_PROGRAM);
519	521
520	522	if(ram_size == 0x4000)

trunk/src/mess/drivers/vt100.c

r22508	r22509
33	33	: driver_device(mconfig, type, tag),
34	34	m_maincpu(*this, "maincpu"),
35	35	m_crtc(*this, "vt100_video"),
36		m_speaker(*this, BEEPER_TAG),
	36	m_speaker(*this, "beeper"),
37	37	m_uart(*this, "i8251"),
38	38	m_p_ram(*this, "p_ram")
39	39	{ }
r22508	r22509
454	454
455	455	/* audio hardware */
456	456	MCFG_SPEAKER_STANDARD_MONO("mono")
457		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	457	MCFG_SOUND_ADD("beeper", BEEP, 0)
458	458	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
459	459
460	460	MCFG_TIMER_DRIVER_ADD_PERIODIC("keyboard_timer", vt100_state, keyboard_callback, attotime::from_hz(800))

trunk/src/mess/drivers/electron.c

r22508	r22509
192	192	MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_SCANLINE)
193	193
194	194	MCFG_SPEAKER_STANDARD_MONO( "mono" )
195		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	195	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
196	196	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
197	197
198	198	MCFG_CASSETTE_ADD( "cassette", electron_cassette_interface )

trunk/src/mess/drivers/ti990_10.c

r22508	r22509
238	238
239	239	/* 911 VDT has a beep tone generator */
240	240	MCFG_SPEAKER_STANDARD_MONO("mono")
241		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	241	MCFG_SOUND_ADD("beeper", BEEP, 0)
242	242	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
243	243
244	244	MCFG_FRAGMENT_ADD( ti990_hdc )

trunk/src/mess/drivers/bigbord2.c

r22508	r22509
98	98	m_floppy1(*this, FLOPPY_1),
99	99	m_floppy2(*this, FLOPPY_2),
100	100	m_floppy3(*this, FLOPPY_3),
101		m_beeper(*this, BEEPER_TAG)
	101	m_beeper(*this, "beeper")
102	102	{ }
103	103
104	104	virtual void machine_start();
r22508	r22509
712	712
713	713	/* sound hardware */
714	714	MCFG_SPEAKER_STANDARD_MONO("mono")
715		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	715	MCFG_SOUND_ADD("beeper", BEEP, 0)
716	716	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
717	717	MACHINE_CONFIG_END
718	718

trunk/src/mess/drivers/pc2000.c

r22508	r22509
28	28	: driver_device(mconfig, type, tag),
29	29	m_maincpu(*this, "maincpu"),
30	30	m_lcdc(*this, "hd44780"),
31		m_beep(*this, BEEPER_TAG),
	31	m_beep(*this, "beeper"),
32	32	m_bank1(*this, "bank1"),
33	33	m_bank2(*this, "bank2")
34	34	{ }
r22508	r22509
560	560
561	561	/* sound hardware */
562	562	MCFG_SPEAKER_STANDARD_MONO( "mono" )
563		MCFG_SOUND_ADD( BEEPER_TAG, BEEP, 0 )
	563	MCFG_SOUND_ADD( "beeper", BEEP, 0 )
564	564	MCFG_SOUND_ROUTE( ALL_OUTPUTS, "mono", 1.00 )
565	565
566	566	MCFG_CARTSLOT_ADD("cart")

trunk/src/mess/drivers/kaypro.c

r22508	r22509
263	263
264	264	/* sound hardware */
265	265	MCFG_SPEAKER_STANDARD_MONO("mono")
266		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	266	MCFG_SOUND_ADD("beeper", BEEP, 0)
267	267	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
268	268
269	269	/* devices */
r22508	r22509
308	308
309	309	/* sound hardware */
310	310	MCFG_SPEAKER_STANDARD_MONO("mono")
311		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	311	MCFG_SOUND_ADD("beeper", BEEP, 0)
312	312	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
313	313
314	314	/* devices */

trunk/src/mame/drivers/deshoros.c

r22508	r22509
36	36	public:
37	37	destiny_state(const machine_config &mconfig, device_type type, const char *tag)
38	38	: driver_device(mconfig, type, tag),
39		m_maincpu(*this, "maincpu")
	39	m_maincpu(*this, "maincpu"),
	40	m_beeper(*this, "beeper")
40	41	{ }
41	42
42	43	required_device<cpu_device> m_maincpu;
	44	required_device<beep_device> m_beeper;
43	45
44	46	char m_led_array[21];
45	47
r22508	r22509
158	160	WRITE8_MEMBER(destiny_state::sound_w)
159	161	{
160	162	// a0: sound on/off
161		machine().device<beep_device>(BEEPER_TAG)->set_state(~offset & 1);
	163	m_beeper->set_state(~offset & 1);
162	164	}
163	165
164	166	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, destiny_state )
r22508	r22509
247	249
248	250	void destiny_state::machine_start()
249	251	{
250		machine().device<beep_device>(BEEPER_TAG)->set_frequency(800); // TODO: determine exact frequency thru schematics
251		machine().device<beep_device>(BEEPER_TAG)->set_state(0);
	252	m_beeper->set_frequency(800); // TODO: determine exact frequency thru schematics
	253	m_beeper->set_state(0);
252	254	}
253	255
254	256	void destiny_state::machine_reset()
r22508	r22509
275	277
276	278	/* sound hardware */
277	279	MCFG_SPEAKER_STANDARD_MONO("mono")
278		MCFG_SOUND_ADD(BEEPER_TAG, BEEP, 0)
	280	MCFG_SOUND_ADD("beeper", BEEP, 0)
279	281	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono",0.50)
280	282	MACHINE_CONFIG_END
281	283

trunk/src/mame/drivers/dlair.c

r22508	r22509
54	54	m_pr7820(*this, "ld_pr7820"),
55	55	m_22vp932(*this, "ld_22vp932") ,
56	56	m_videoram(*this, "videoram"),
57		m_maincpu(*this, "maincpu") { }
	57	m_maincpu(*this, "maincpu"),
	58	m_beeper(*this, "beeper")    { }
58	59
59	60	void laserdisc_data_w(UINT8 data)
60	61	{
r22508	r22509
120	121	DECLARE_WRITE16_MEMBER(serial_transmit);
121	122	DECLARE_READ16_MEMBER(serial_receive);
122	123	required_device<cpu_device> m_maincpu;
	124	optional_device<beep_device> m_beeper;
123	125	};
124	126
125	127
r22508	r22509
284	286	INTERRUPT_GEN_MEMBER(dlair_state::vblank_callback)
285	287	{
286	288	/* also update the speaker on the European version */
287		beep_device *beep = machine().device<beep_device>("beep");
288		if (beep != NULL)
	289	if (m_beeper != NULL)
289	290	{
290	291	z80ctc_device *ctc = machine().device<z80ctc_device>("ctc");
291		beep->set_state(1);
292		beep->set_frequency(ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds));
	292	m_beeper->set_state(1);
	293	m_beeper->set_frequency(ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds));
293	294	}
294	295	}
295	296
r22508	r22509
789	790	/* sound hardware */
790	791	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
791	792
792		MCFG_SOUND_ADD("beep", BEEP, 0)
	793	MCFG_SOUND_ADD("beeper", BEEP, 0)
793	794	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.33)
794	795	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.33)
795	796

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team