Previous

199869 Revisions

Next

r21621 Wednesday 6th March, 2013 at 04:33:54 UTC by Andrew Gardner
Modernized the beep and taitosnd devices. [Andrew Gardner]

[src/emu/sound]	beep.c beep.h
[src/mame/audio]	taitosnd.c taitosnd.h
[src/mame/drivers]	asuka.c darius.c deshoros.c dlair.c exzisus.c mlanding.c ninjaw.c opwolf.c othunder.c pcxt.c rainbow.c rastan.c slapshot.c taito_b.c taito_f2.c taito_h.c taito_l.c taito_x.c taito_z.c taitoair.c topspeed.c volfied.c warriorb.c wgp.c zn.c
[src/mame/includes]	darius.h ninjaw.h othunder.h slapshot.h taito_z.h warriorb.h wgp.h
[src/mess/drivers]	a5105.c alphatro.c bigbord2.c bmjr.c bml3.c ex800.c fidelz80.c fm7.c glasgow.c h19.c h8.c jr100.c jr200.c lx800.c mephisto.c micronic.c mmodular.c multi8.c mz2000.c mz2500.c nc.c osi.c pb1000.c pc100.c pc2000.c pc4.c pc8801.c pc9801.c pce220.c pcw.c pcw16.c psion.c rex6000.c sc2.c smc777.c studio2.c supercon.c tmc1800.c vk100.c vt100.c x07.c xerox820.c z9001.c zrt80.c
[src/mess/includes]	fidelz80.h osi.h psion.h studio2.h tmc1800.h xerox820.h
[src/mess/machine]	apollo_kbd.c apollo_kbd.h electron.c kay_kbd.c osborne1.c
[src/mess/video]	911_vdt.c

trunk/src/mame/includes/taito_z.h

r21620	r21621
5	5
6	6	*************************************************************************/
7	7
	8	#include <audio/taitosnd.h>
8	9	#include "machine/eeprom.h"
9	10
10	11	class taitoz_state : public driver_device
r21620	r21621
38	39	device_t *m_tc0150rod;
39	40	device_t *m_tc0100scn;
40	41	device_t *m_tc0220ioc;
41		device_t *m_tc0140syt;
	42	tc0140syt_device *m_tc0140syt;
42	43
43	44	DECLARE_WRITE16_MEMBER(cpua_ctrl_w);
44	45	DECLARE_WRITE16_MEMBER(chasehq_cpua_ctrl_w);

trunk/src/mame/includes/darius.h

r21620	r21621
5	5	*************************************************************************/
6	6
7	7	#include <sound/flt_vol.h>
	8	#include <audio/taitosnd.h>
8	9
9	10	#define DARIUS_VOL_MAX    (3*2 + 2)
10	11	#define DARIUS_PAN_MAX    (2 + 2 + 1)   /* FM 2port + PSG 2port + DA 1port */
r21620	r21621
39	40	cpu_device *m_audiocpu;
40	41	device_t *m_cpub;
41	42	device_t *m_adpcm;
42		device_t *m_tc0140syt;
	43	tc0140syt_device *m_tc0140syt;
43	44	device_t *m_pc080sn;
44	45
45	46	device_t *m_lscreen;

trunk/src/mame/includes/warriorb.h

r21620	r21621
5	5	*************************************************************************/
6	6
7	7	#include <sound/flt_vol.h>
	8	#include <audio/taitosnd.h>
8	9
9	10	class warriorb_state : public driver_device
10	11	{
r21620	r21621
23	24	/* devices */
24	25	cpu_device *m_maincpu;
25	26	cpu_device *m_audiocpu;
26		device_t *m_tc0140syt;
	27	tc0140syt_device *m_tc0140syt;
27	28	device_t *m_tc0100scn_1;
28	29	device_t *m_tc0100scn_2;
29	30	device_t *m_lscreen;

trunk/src/mame/includes/othunder.h

r21620	r21621
6	6
7	7	#include "machine/eeprom.h"
8	8	#include <sound/flt_vol.h>
	9	#include <audio/taitosnd.h>
9	10
10	11	struct othunder_tempsprite
11	12	{
r21620	r21621
44	45	device_t *m_tc0220ioc;
45	46	device_t *m_tc0100scn;
46	47	device_t *m_tc0110pcr;
47		device_t *m_tc0140syt;
	48	tc0140syt_device *m_tc0140syt;
48	49	filter_volume_device *m_2610_0l;
49	50	filter_volume_device *m_2610_0r;
50	51	filter_volume_device *m_2610_1l;

trunk/src/mame/includes/slapshot.h

r21620	r21621
4	4
5	5	*************************************************************************/
6	6
	7	#include <audio/taitosnd.h>
	8
7	9	struct slapshot_tempsprite
8	10	{
9	11	int gfx;
r21620	r21621
49	51	/* devices */
50	52	cpu_device *m_maincpu;
51	53	cpu_device *m_audiocpu;
52		device_t *m_tc0140syt;
	54	tc0140syt_device *m_tc0140syt;
53	55	device_t *m_tc0480scp;
54	56	device_t *m_tc0360pri;
55	57	device_t *m_tc0640fio;

trunk/src/mame/includes/ninjaw.h

r21620	r21621
5	5	*************************************************************************/
6	6
7	7	#include <sound/flt_vol.h>
	8	#include <audio/taitosnd.h>
8	9
9	10	class ninjaw_state : public driver_device
10	11	{
r21620	r21621
25	26	cpu_device *m_maincpu;
26	27	cpu_device *m_audiocpu;
27	28	cpu_device *m_subcpu;
28		device_t *m_tc0140syt;
	29	tc0140syt_device *m_tc0140syt;
29	30	device_t *m_tc0100scn_1;
30	31	device_t *m_tc0100scn_2;
31	32	device_t *m_tc0100scn_3;

trunk/src/mame/includes/wgp.h

r21620	r21621
4	4
5	5	*************************************************************************/
6	6
	7	#include <audio/taitosnd.h>
	8
7	9	class wgp_state : public driver_device
8	10	{
9	11	public:
r21620	r21621
44	46	cpu_device *m_audiocpu;
45	47	cpu_device *m_subcpu;
46	48	device_t *m_tc0100scn;
47		device_t *m_tc0140syt;
	49	tc0140syt_device *m_tc0140syt;
48	50	DECLARE_READ16_MEMBER(sharedram_r);
49	51	DECLARE_WRITE16_MEMBER(sharedram_w);
50	52	DECLARE_WRITE16_MEMBER(cpua_ctrl_w);

trunk/src/mame/drivers/taitoair.c

r21620	r21621
401	401	AM_RANGE(0xa00000, 0xa00007) AM_READ(stick_input_r)
402	402	AM_RANGE(0xa00100, 0xa00107) AM_READ(stick2_input_r)
403	403	AM_RANGE(0xa00200, 0xa0020f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff) /* other I/O */
404		AM_RANGE(0xa80000, 0xa80001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
405		AM_RANGE(0xa80002, 0xa80003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	404	AM_RANGE(0xa80000, 0xa80001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	405	AM_RANGE(0xa80002, 0xa80003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
406	406	AM_RANGE(0xb00000, 0xb007ff) AM_RAM                     /* "power common ram" (mecha drive) */
407	407	ADDRESS_MAP_END
408	408
r21620	r21621
413	413	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
414	414	AM_RANGE(0xc000, 0xdfff) AM_RAM
415	415	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
416		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
417		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	416	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	417	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
418	418	AM_RANGE(0xe400, 0xe403) AM_WRITENOP        /* pan control */
419	419	AM_RANGE(0xea00, 0xea00) AM_READNOP
420	420	AM_RANGE(0xee00, 0xee00) AM_WRITENOP        /* ? */

trunk/src/mame/drivers/volfied.c

r21620	r21621
71	71	AM_RANGE(0x600000, 0x600001) AM_WRITE(volfied_video_mask_w)
72	72	AM_RANGE(0x700000, 0x700001) AM_WRITE(volfied_sprite_ctrl_w)
73	73	AM_RANGE(0xd00000, 0xd00001) AM_READWRITE(volfied_video_ctrl_r, volfied_video_ctrl_w)
74		AM_RANGE(0xe00000, 0xe00001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
75		AM_RANGE(0xe00002, 0xe00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	74	AM_RANGE(0xe00000, 0xe00001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	75	AM_RANGE(0xe00002, 0xe00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
76	76	AM_RANGE(0xf00000, 0xf007ff) AM_READWRITE(volfied_cchip_ram_r, volfied_cchip_ram_w)
77	77	AM_RANGE(0xf00802, 0xf00803) AM_READWRITE(volfied_cchip_ctrl_r, volfied_cchip_ctrl_w)
78	78	AM_RANGE(0xf00c00, 0xf00c01) AM_WRITE(volfied_cchip_bank_w)
r21620	r21621
81	81	static ADDRESS_MAP_START( z80_map, AS_PROGRAM, 8, volfied_state )
82	82	AM_RANGE(0x0000, 0x7fff) AM_ROM
83	83	AM_RANGE(0x8000, 0x87ff) AM_RAM
84		AM_RANGE(0x8800, 0x8800) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
85		AM_RANGE(0x8801, 0x8801) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	84	AM_RANGE(0x8800, 0x8800) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	85	AM_RANGE(0x8801, 0x8801) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
86	86	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
87	87	AM_RANGE(0x9800, 0x9800) AM_WRITENOP    /* ? */
88	88	ADDRESS_MAP_END

trunk/src/mame/drivers/rastan.c

r21620	r21621
216	216	AM_RANGE(0x390008, 0x390009) AM_READ_PORT("DSWA")
217	217	AM_RANGE(0x39000a, 0x39000b) AM_READ_PORT("DSWB")
218	218	AM_RANGE(0x3c0000, 0x3c0001) AM_WRITE(watchdog_reset16_w)
219		AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
220		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	219	AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	220	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
221	221	AM_RANGE(0xc00000, 0xc0ffff) AM_DEVREADWRITE_LEGACY("pc080sn", pc080sn_word_r, pc080sn_word_w)
222	222	AM_RANGE(0xc20000, 0xc20003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_yscroll_word_w)
223	223	AM_RANGE(0xc40000, 0xc40003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_xscroll_word_w)
r21620	r21621
231	231	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
232	232	AM_RANGE(0x8000, 0x8fff) AM_RAM
233	233	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
234		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
235		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	234	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	235	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
236	236	AM_RANGE(0xb000, 0xb000) AM_WRITE(rastan_msm5205_address_w)
237	237	AM_RANGE(0xc000, 0xc000) AM_WRITE(rastan_msm5205_start_w)
238	238	AM_RANGE(0xd000, 0xd000) AM_WRITE(rastan_msm5205_stop_w)

trunk/src/mame/drivers/slapshot.c

r21620	r21621
252	252	WRITE16_MEMBER(slapshot_state::slapshot_msb_sound_w)
253	253	{
254	254	if (offset == 0)
255		tc0140syt_port_w(m_tc0140syt, space, 0, (data >> 8) & 0xff);
	255	m_tc0140syt->tc0140syt_port_w(space, 0, (data >> 8) & 0xff);
256	256	else if (offset == 1)
257		tc0140syt_comm_w(m_tc0140syt, space, 0, (data >> 8) & 0xff);
	257	m_tc0140syt->tc0140syt_comm_w(space, 0, (data >> 8) & 0xff);
258	258
259	259	#ifdef MAME_DEBUG
260	260	if (data & 0xff)
r21620	r21621
265	265	READ16_MEMBER(slapshot_state::slapshot_msb_sound_r)
266	266	{
267	267	if (offset == 1)
268		return ((tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff) << 8);
	268	return ((m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff) << 8);
269	269	else
270	270	return 0;
271	271	}
r21620	r21621
314	314	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
315	315	AM_RANGE(0xc000, 0xdfff) AM_RAM
316	316	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r,ym2610_w)
317		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
318		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	317	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	318	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
319	319	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
320	320	AM_RANGE(0xea00, 0xea00) AM_READNOP
321	321	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
519	519
520	520	m_maincpu = machine().device<cpu_device>("maincpu");
521	521	m_audiocpu = machine().device<cpu_device>("audiocpu");
522		m_tc0140syt = machine().device("tc0140syt");
	522	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
523	523	m_tc0480scp = machine().device("tc0480scp");
524	524	m_tc0360pri = machine().device("tc0360pri");
525	525	m_tc0640fio = machine().device("tc0640fio");

trunk/src/mame/drivers/deshoros.c

r21620	r21621
158	158	WRITE8_MEMBER(destiny_state::sound_w)
159	159	{
160	160	// a0: sound on/off
161		beep_set_state(machine().device(BEEPER_TAG), ~offset & 1);
	161	machine().device<beep_device>(BEEPER_TAG)->set_state(~offset & 1);
162	162	}
163	163
164	164	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, destiny_state )
r21620	r21621
247	247
248	248	void destiny_state::machine_start()
249	249	{
250		beep_set_frequency(machine().device(BEEPER_TAG),800); // TODO: determine exact frequency thru schematics
251		beep_set_state(machine().device(BEEPER_TAG),0);
	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	252	}
253	253
254	254	void destiny_state::machine_reset()

trunk/src/mame/drivers/ninjaw.c

r21620	r21621
364	364	WRITE16_MEMBER(ninjaw_state::ninjaw_sound_w)
365	365	{
366	366	if (offset == 0)
367		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	367	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
368	368	else if (offset == 1)
369		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	369	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
370	370
371	371	#ifdef MAME_DEBUG
372	372	if (data & 0xff00)
r21620	r21621
377	377	READ16_MEMBER(ninjaw_state::ninjaw_sound_r)
378	378	{
379	379	if (offset == 1)
380		return ((tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff));
	380	return ((m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff));
381	381	else
382	382	return 0;
383	383	}
r21620	r21621
489	489	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
490	490	AM_RANGE(0xc000, 0xdfff) AM_RAM
491	491	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r,ym2610_w)
492		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
493		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r,tc0140syt_slave_comm_w)
	492	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	493	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r,tc0140syt_slave_comm_w)
494	494	AM_RANGE(0xe400, 0xe403) AM_WRITE(ninjaw_pancontrol) /* pan */
495	495	AM_RANGE(0xea00, 0xea00) AM_READNOP
496	496	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
800	800	m_maincpu = machine().device<cpu_device>("maincpu");
801	801	m_audiocpu = machine().device<cpu_device>("audiocpu");
802	802	m_subcpu = machine().device<cpu_device>("sub");
803		m_tc0140syt = machine().device("tc0140syt");
	803	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
804	804	m_tc0100scn_1 = machine().device("tc0100scn_1");
805	805	m_tc0100scn_2 = machine().device("tc0100scn_2");
806	806	m_tc0100scn_3 = machine().device("tc0100scn_3");

trunk/src/mame/drivers/topspeed.c

r21620	r21621
419	419
420	420	WRITE8_MEMBER(topspeed_state::topspeed_tc0140syt_comm_w)
421	421	{
422		device_t *device = machine().device("tc0140syt");
	422	tc0140syt_device *device = machine().device<tc0140syt_device>("tc0140syt");
423	423	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
424		tc0140syt_comm_w(device, space, 0, data);
	424	device->tc0140syt_comm_w(space, 0, data);
425	425	}
426	426
427	427	static void topspeed_msm5205_clock( device_t *device, int chip )
r21620	r21621
502	502	AM_RANGE(0x400000, 0x40ffff) AM_READWRITE(sharedram_r, sharedram_w) AM_SHARE("sharedram")
503	503	AM_RANGE(0x500000, 0x503fff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")
504	504	AM_RANGE(0x600002, 0x600003) AM_WRITE(cpua_ctrl_w)
505		AM_RANGE(0x7e0000, 0x7e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
506		AM_RANGE(0x7e0002, 0x7e0003) AM_DEVREAD8_LEGACY("tc0140syt", tc0140syt_comm_r, 0x00ff) AM_WRITE8(topspeed_tc0140syt_comm_w, 0x00ff)
	505	AM_RANGE(0x7e0000, 0x7e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	506	AM_RANGE(0x7e0002, 0x7e0003) AM_DEVREAD8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, 0x00ff) AM_WRITE8(topspeed_tc0140syt_comm_w, 0x00ff)
507	507	AM_RANGE(0x800000, 0x8003ff) AM_RAM AM_SHARE("raster_ctrl")
508	508	AM_RANGE(0x800400, 0x80ffff) AM_RAM
509	509	AM_RANGE(0xa00000, 0xa0ffff) AM_DEVREADWRITE_LEGACY("pc080sn_1", pc080sn_word_r, pc080sn_word_w)
r21620	r21621
534	534	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
535	535	AM_RANGE(0x8000, 0x8fff) AM_RAM
536	536	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
537		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
538		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	537	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	538	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
539	539	AM_RANGE(0xb000, 0xd3ff) AM_WRITE(topspeed_msm5205_command_w)
540	540	AM_RANGE(0xd400, 0xd400) AM_WRITENOP // ym2151 volume
541	541	AM_RANGE(0xd600, 0xd600) AM_WRITENOP // ym2151 volume

trunk/src/mame/drivers/taito_f2.c

r21620	r21621
684	684	AM_RANGE(0x100000, 0x10ffff) AM_RAM
685	685	AM_RANGE(0x200000, 0x200007) AM_DEVREADWRITE_LEGACY("tc0110pcr", tc0110pcr_word_r, tc0110pcr_word_w)    /* palette */
686	686	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
687		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
688		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	687	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	688	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
689	689	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
690	690	AM_RANGE(0x810000, 0x81ffff) AM_WRITENOP   /* error in game init code ? */
691	691	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
r21620	r21621
698	698	AM_RANGE(0x100000, 0x10ffff) AM_RAM
699	699	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
700	700	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
701		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
702		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	701	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	702	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
703	703	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
704	704	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
705	705	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
710	710
711	711	static ADDRESS_MAP_START( megab_map, AS_PROGRAM, 16, taitof2_state )
712	712	AM_RANGE(0x000000, 0x07ffff) AM_ROM
713		AM_RANGE(0x100000, 0x100001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
714		AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	713	AM_RANGE(0x100000, 0x100001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	714	AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
715	715	AM_RANGE(0x120000, 0x12000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
716	716	AM_RANGE(0x180000, 0x180fff) AM_READWRITE(cchip2_word_r, cchip2_word_w) AM_SHARE("cchip2_ram")
717	717	AM_RANGE(0x200000, 0x20ffff) AM_RAM
r21620	r21621
727	727	AM_RANGE(0x000000, 0x07ffff) AM_ROM
728	728	AM_RANGE(0x100000, 0x101fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
729	729	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
730		AM_RANGE(0x220000, 0x220001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
731		AM_RANGE(0x220002, 0x220003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	730	AM_RANGE(0x220000, 0x220001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	731	AM_RANGE(0x220002, 0x220003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
732	732	AM_RANGE(0x300000, 0x30ffff) AM_RAM
733	733	AM_RANGE(0x400000, 0x40ffff) AM_DEVREADWRITE_LEGACY("tc0100scn_1", tc0100scn_word_r, tc0100scn_word_w)  /* tilemaps */
734	734	AM_RANGE(0x420000, 0x42000f) AM_DEVREADWRITE_LEGACY("tc0100scn_1", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
r21620	r21621
744	744	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
745	745	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
746	746	AM_RANGE(0x300018, 0x30001f) AM_READ(cameltry_paddle_r)
747		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
748		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	747	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	748	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
749	749	AM_RANGE(0x800000, 0x813fff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
750	750	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
751	751	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
759	759	AM_RANGE(0x100000, 0x10ffff) AM_RAM
760	760	AM_RANGE(0x200000, 0x200007) AM_DEVREADWRITE_LEGACY("tc0110pcr", tc0110pcr_word_r, tc0110pcr_word_w)    /* palette */
761	761	AM_RANGE(0x500000, 0x50000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
762		AM_RANGE(0x600000, 0x600001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
763		AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	762	AM_RANGE(0x600000, 0x600001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	763	AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
764	764	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
765	765	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
766	766	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
772	772	AM_RANGE(0x100000, 0x10ffff) AM_RAM
773	773	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
774	774	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
775		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
776		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	775	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	776	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
777	777	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
778	778	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
779	779	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
792	792	AM_RANGE(0x580000, 0x580001) AM_READ_PORT("DSWA")
793	793	AM_RANGE(0x580002, 0x580003) AM_READ_PORT("IN1")
794	794	AM_RANGE(0x580004, 0x580005) AM_READ_PORT("IN2")
795		AM_RANGE(0x600000, 0x600001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
796		AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	795	AM_RANGE(0x600000, 0x600001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	796	AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
797	797	AM_RANGE(0x680000, 0x680001) AM_WRITENOP   /* ??? */
798	798	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
799	799	AM_RANGE(0x810000, 0x81ffff) AM_WRITENOP   /* error in init code ? */
r21620	r21621
806	806	AM_RANGE(0x100000, 0x10000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
807	807	AM_RANGE(0x200000, 0x20ffff) AM_RAM
808	808	AM_RANGE(0x300000, 0x301fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
809		AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
810		AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	809	AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	810	AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
811	811	//  AM_RANGE(0x500000, 0x500001) AM_WRITENOP   /* ?? */
812	812	AM_RANGE(0x600000, 0x60ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps (not used) */
813	813	AM_RANGE(0x620000, 0x62000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
r21620	r21621
819	819	AM_RANGE(0x100000, 0x10ffff) AM_RAM
820	820	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
821	821	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_wordswap_r, tc0510nio_halfword_wordswap_w)
822		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
823		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	822	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	823	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
824	824	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
825	825	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
826	826	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
839	839	AM_RANGE(0x320002, 0x320003) AM_READ_PORT("IN1")
840	840	AM_RANGE(0x320004, 0x320005) AM_READ_PORT("IN2")
841	841	AM_RANGE(0x340000, 0x340001) AM_WRITE(watchdog_reset16_w)
842		AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
843		AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	842	AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	843	AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
844	844	AM_RANGE(0x500000, 0x50000f) AM_WRITE(taitof2_spritebank_w)
845	845	AM_RANGE(0x504000, 0x504001) AM_WRITENOP    /* unknown... various values */
846	846	AM_RANGE(0x508000, 0x50800f) AM_READ_PORT("IN3")
r21620	r21621
861	861	AM_RANGE(0x320000, 0x320001) AM_WRITE(mjnquest_inputselect_w)
862	862	AM_RANGE(0x330000, 0x330001) AM_WRITENOP   /* watchdog ? */
863	863	AM_RANGE(0x350000, 0x350001) AM_WRITENOP   /* watchdog ? */
864		AM_RANGE(0x360000, 0x360001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
865		AM_RANGE(0x360002, 0x360003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	864	AM_RANGE(0x360000, 0x360001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	865	AM_RANGE(0x360002, 0x360003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
866	866	AM_RANGE(0x380000, 0x380001) AM_DEVWRITE_LEGACY("tc0100scn", tc0100scn_gfxbank_w)   /* scr gfx bank select */
867	867	AM_RANGE(0x400000, 0x40ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
868	868	AM_RANGE(0x420000, 0x42000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
r21620	r21621
887	887	AM_RANGE(0x70000e, 0x70000f) AM_READ_PORT("IN3")
888	888	AM_RANGE(0x700010, 0x700011) AM_READ_PORT("IN4")
889	889	AM_RANGE(0x800000, 0x800001) AM_WRITE(watchdog_reset16_w)   /* ??? */
890		AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
891		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	890	AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	891	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
892	892	ADDRESS_MAP_END
893	893
894	894	static ADDRESS_MAP_START( koshien_map, AS_PROGRAM, 16, taitof2_state )
r21620	r21621
896	896	AM_RANGE(0x100000, 0x10ffff) AM_RAM
897	897	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
898	898	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
899		AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
900		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	899	AM_RANGE(0x320000, 0x320001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	900	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
901	901	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
902	902	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
903	903	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
908	908	static ADDRESS_MAP_START( yuyugogo_map, AS_PROGRAM, 16, taitof2_state )
909	909	AM_RANGE(0x000000, 0x03ffff) AM_ROM
910	910	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
911		AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
912		AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	911	AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	912	AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
913	913	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
914	914	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
915	915	AM_RANGE(0x900000, 0x90ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
926	926	AM_RANGE(0x300000, 0x30000f) AM_READ(ninjak_input_r)
927	927	AM_RANGE(0x30000e, 0x30000f) AM_WRITE(ninjak_coin_word_w)
928	928	AM_RANGE(0x380000, 0x380001) AM_WRITE(watchdog_reset16_w)   /* ??? */
929		AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
930		AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	929	AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	930	AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
931	931	AM_RANGE(0x600000, 0x60000f) AM_WRITE(taitof2_spritebank_w)
932	932	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
933	933	AM_RANGE(0x820000, 0x82000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
r21620	r21621
946	946	AM_RANGE(0x320002, 0x320003) AM_READ_PORT("IN1")
947	947	AM_RANGE(0x320004, 0x320005) AM_READ_PORT("IN2")
948	948	AM_RANGE(0x340000, 0x340001) AM_WRITE(watchdog_reset16_w)   /* NOT VERIFIED */
949		AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
950		AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	949	AM_RANGE(0x400000, 0x400001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	950	AM_RANGE(0x400002, 0x400003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
951	951	AM_RANGE(0x500000, 0x50000f) AM_WRITE(taitof2_spritebank_w)
952	952	AM_RANGE(0x504000, 0x504001) AM_WRITENOP    /* unknown... various values */
953	953	AM_RANGE(0x800000, 0x80ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
r21620	r21621
959	959	static ADDRESS_MAP_START( qzquest_map, AS_PROGRAM, 16, taitof2_state )
960	960	AM_RANGE(0x000000, 0x17ffff) AM_ROM
961	961	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
962		AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
963		AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	962	AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	963	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
964	964	AM_RANGE(0x400000, 0x401fff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram")
965	965	AM_RANGE(0x500000, 0x50ffff) AM_RAM
966	966	AM_RANGE(0x600000, 0x60ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
970	970
971	971	static ADDRESS_MAP_START( pulirula_map, AS_PROGRAM, 16, taitof2_state )
972	972	AM_RANGE(0x000000, 0x0bffff) AM_ROM
973		AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
974		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	973	AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	974	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
975	975	AM_RANGE(0x300000, 0x30ffff) AM_RAM
976	976	AM_RANGE(0x400000, 0x401fff) AM_DEVREADWRITE_LEGACY("tc0430grw", tc0430grw_word_r, tc0430grw_word_w)    /* ROZ tilemap */
977	977	AM_RANGE(0x402000, 0x40200f) AM_DEVWRITE_LEGACY("tc0430grw", tc0430grw_ctrl_word_w)
r21620	r21621
995	995	AM_RANGE(0x600000, 0x60001f) AM_DEVWRITE8_LEGACY("tc0360pri", tc0360pri_w, 0x00ff)
996	996	AM_RANGE(0x700000, 0x703fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
997	997	AM_RANGE(0x800000, 0x80000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_wordswap_r, tc0510nio_halfword_wordswap_w)
998		AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
999		AM_RANGE(0x900002, 0x900003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	998	AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	999	AM_RANGE(0x900002, 0x900003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1000	1000	//  AM_RANGE(0xa00000, 0xa00001) AM_WRITENOP   /* ??? */
1001	1001	ADDRESS_MAP_END
1002	1002
1003	1003	static ADDRESS_MAP_START( qzchikyu_map, AS_PROGRAM, 16, taitof2_state )
1004	1004	AM_RANGE(0x000000, 0x17ffff) AM_ROM
1005	1005	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
1006		AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
1007		AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	1006	AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	1007	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
1008	1008	AM_RANGE(0x400000, 0x401fff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram")
1009	1009	AM_RANGE(0x500000, 0x50ffff) AM_RAM
1010	1010	AM_RANGE(0x600000, 0x60ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
1020	1020	AM_RANGE(0x520000, 0x52000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
1021	1021	AM_RANGE(0x600000, 0x601fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
1022	1022	//  AM_RANGE(0x700000, 0x70000b) AM_READ_LEGACY(yesnoj_unknown_r)   /* what's this? */
1023		AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1024		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1023	AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1024	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1025	1025	AM_RANGE(0x900002, 0x900003) AM_WRITENOP   /* lots of similar writes */
1026	1026	AM_RANGE(0xa00000, 0xa00001) AM_READ_PORT("IN0")
1027	1027	AM_RANGE(0xa00002, 0xa00003) AM_READ_PORT("IN1")
r21620	r21621
1048	1048	AM_RANGE(0x70000a, 0x70000b) AM_READ_PORT("IN0")
1049	1049	AM_RANGE(0x70000c, 0x70000d) AM_READ_PORT("IN1")
1050	1050	AM_RANGE(0x800000, 0x800001) AM_WRITE(watchdog_reset16_w)   /* ??? */
1051		AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1052		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1051	AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1052	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1053	1053	ADDRESS_MAP_END
1054	1054
1055	1055	static ADDRESS_MAP_START( dinorex_map, AS_PROGRAM, 16, taitof2_state )
r21620	r21621
1062	1062	AM_RANGE(0x800000, 0x80ffff) AM_RAM AM_SHARE("spriteram")
1063	1063	AM_RANGE(0x900000, 0x90ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
1064	1064	AM_RANGE(0x920000, 0x92000f) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_ctrl_word_r, tc0100scn_ctrl_word_w)
1065		AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1066		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1065	AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1066	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1067	1067	AM_RANGE(0xb00000, 0xb00001) AM_WRITENOP   /* watchdog? */
1068	1068	ADDRESS_MAP_END
1069	1069
1070	1070	static ADDRESS_MAP_START( qjinsei_map, AS_PROGRAM, 16, taitof2_state )
1071	1071	AM_RANGE(0x000000, 0x1fffff) AM_ROM
1072		AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1073		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1072	AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1073	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1074	1074	AM_RANGE(0x300000, 0x30ffff) AM_RAM
1075	1075	AM_RANGE(0x500000, 0x500001) AM_WRITENOP   /* watchdog ? */
1076	1076	AM_RANGE(0x600000, 0x603fff) AM_WRITE(taitof2_sprite_extension_w) AM_SHARE("sprite_ext")
r21620	r21621
1087	1087	AM_RANGE(0x100000, 0x10ffff) AM_RAM
1088	1088	//  AM_RANGE(0x200000, 0x200001) AM_WRITENOP   /* unknown */
1089	1089	AM_RANGE(0x300000, 0x3fffff) AM_ROM AM_REGION("extra", 0)   /* extra data rom */
1090		AM_RANGE(0x500000, 0x500001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1091		AM_RANGE(0x500002, 0x500003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1090	AM_RANGE(0x500000, 0x500001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1091	AM_RANGE(0x500002, 0x500003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1092	1092	AM_RANGE(0x600000, 0x603fff) AM_WRITE(taitof2_sprite_extension_w) AM_SHARE("sprite_ext")
1093	1093	AM_RANGE(0x700000, 0x701fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
1094	1094	AM_RANGE(0x800000, 0x80ffff) AM_RAM AM_SHARE("spriteram")
r21620	r21621
1108	1108	AM_RANGE(0x600000, 0x67ffff) AM_ROM AM_REGION("extra", 0)   /* extra data rom */
1109	1109	AM_RANGE(0x700000, 0x70000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_r, tc0510nio_halfword_w)
1110	1110	AM_RANGE(0x900000, 0x90001f) AM_DEVWRITE8_LEGACY("tc0360pri", tc0360pri_w, 0x00ff)  /* ?? */
1111		AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1112		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1111	AM_RANGE(0xa00000, 0xa00001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1112	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1113	1113	AM_RANGE(0xb00000, 0xb017ff) AM_WRITE(taitof2_sprite_extension_w) AM_SHARE("sprite_ext")
1114	1114	ADDRESS_MAP_END
1115	1115
1116	1116	static ADDRESS_MAP_START( driftout_map, AS_PROGRAM, 16, taitof2_state )
1117	1117	AM_RANGE(0x000000, 0x0fffff) AM_ROM
1118		AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
1119		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	1118	AM_RANGE(0x200000, 0x200001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	1119	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
1120	1120	AM_RANGE(0x300000, 0x30ffff) AM_RAM
1121	1121	AM_RANGE(0x400000, 0x401fff) AM_DEVREADWRITE_LEGACY("tc0430grw", tc0430grw_word_r, tc0430grw_word_w)    /* ROZ tilemap */
1122	1122	AM_RANGE(0x402000, 0x40200f) AM_DEVWRITE_LEGACY("tc0430grw", tc0430grw_ctrl_word_w)
r21620	r21621
1155	1155	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank2")
1156	1156	AM_RANGE(0xc000, 0xdfff) AM_RAM
1157	1157	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
1158		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
1159		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	1158	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	1159	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
1160	1160	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
1161	1161	AM_RANGE(0xea00, 0xea00) AM_READNOP
1162	1162	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
1171	1171	AM_RANGE(0x0000, 0x7fff) AM_ROM     // I can't see a bank control, but there ARE some bytes past 0x8000
1172	1172	AM_RANGE(0x8000, 0x8fff) AM_RAM
1173	1173	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
1174		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
1175		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	1174	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	1175	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
1176	1176	//  AM_RANGE(0xb000, 0xb000) AM_WRITE_LEGACY(unknown_w)    // probably controlling sample player?
1177	1177	AM_RANGE(0xb000, 0xb001) AM_MIRROR(0x0001) AM_DEVREADWRITE("oki", okim6295_device, read, write)
1178	1178	ADDRESS_MAP_END

trunk/src/mame/drivers/taito_x.c

r21620	r21621
433	433	AM_RANGE(0x400000, 0x400001) AM_WRITENOP    /* written each frame at $3aa2, mostly 0x10 */
434	434	AM_RANGE(0x500000, 0x500007) AM_READ(superman_dsw_input_r)
435	435	AM_RANGE(0x600000, 0x600001) AM_WRITENOP    /* written each frame at $3ab0, mostly 0x10 */
436		AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
437		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	436	AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	437	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
438	438	AM_RANGE(0x900000, 0x9007ff) AM_READWRITE_LEGACY(cchip1_ram_r, cchip1_ram_w)
439	439	AM_RANGE(0x900802, 0x900803) AM_READWRITE_LEGACY(cchip1_ctrl_r, cchip1_ctrl_w)
440	440	AM_RANGE(0x900c00, 0x900c01) AM_WRITE_LEGACY(cchip1_bank_w)
r21620	r21621
450	450	//  AM_RANGE(0x400000, 0x400001) AM_WRITENOP    /* written each frame at $2ac, values change */
451	451	AM_RANGE(0x500000, 0x50000f) AM_READ(superman_dsw_input_r)
452	452	//  AM_RANGE(0x600000, 0x600001) AM_WRITENOP    /* written each frame at $2a2, values change */
453		AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
454		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	453	AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	454	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
455	455	AM_RANGE(0x900000, 0x90000f) AM_READWRITE(daisenpu_input_r, daisenpu_input_w)
456	456	AM_RANGE(0xb00000, 0xb00fff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram")
457	457	AM_RANGE(0xd00000, 0xd005ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r16, spriteylow_w16) // Sprites Y
r21620	r21621
465	465	AM_RANGE(0x400000, 0x400001) AM_WRITENOP    /* 0x1 written each frame at $d42, watchdog? */
466	466	AM_RANGE(0x500000, 0x500007) AM_READ(superman_dsw_input_r)
467	467	AM_RANGE(0x600000, 0x600001) AM_WRITENOP    /* 0x1 written each frame at $d3c, watchdog? */
468		AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
469		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	468	AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	469	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
470	470	AM_RANGE(0x900000, 0x90000f) AM_READWRITE(daisenpu_input_r, daisenpu_input_w)
471	471	AM_RANGE(0xb00000, 0xb00fff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram")
472	472	AM_RANGE(0xd00000, 0xd005ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r16, spriteylow_w16) // Sprites Y
r21620	r21621
480	480	AM_RANGE(0x400000, 0x400001) AM_WRITENOP    /* 0x1 written each frame at $c56, watchdog? */
481	481	AM_RANGE(0x500000, 0x50000f) AM_READ(superman_dsw_input_r)
482	482	AM_RANGE(0x600000, 0x600001) AM_WRITENOP    /* 0x1 written each frame at $c4e, watchdog? */
483		AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
484		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	483	AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	484	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
485	485	AM_RANGE(0x900000, 0x90000f) AM_READWRITE(daisenpu_input_r, daisenpu_input_w)
486	486	AM_RANGE(0xb00000, 0xb00fff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram")
487	487	AM_RANGE(0xd00000, 0xd005ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r16, spriteylow_w16) // Sprites Y
r21620	r21621
498	498	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank2")
499	499	AM_RANGE(0xc000, 0xdfff) AM_RAM
500	500	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
501		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
502		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	501	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	502	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
503	503	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
504	504	AM_RANGE(0xea00, 0xea00) AM_READNOP
505	505	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
512	512	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank2")
513	513	AM_RANGE(0xc000, 0xdfff) AM_RAM
514	514	AM_RANGE(0xe000, 0xe001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
515		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
516		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	515	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	516	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
517	517	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
518	518	AM_RANGE(0xea00, 0xea00) AM_READNOP
519	519	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */

trunk/src/mame/drivers/exzisus.c

r21620	r21621
151	151	AM_RANGE(0xc000, 0xc5ff) AM_READWRITE(exzisus_objectram_0_r, exzisus_objectram_0_w) AM_SHARE("objectram0")
152	152	AM_RANGE(0xc600, 0xdfff) AM_READWRITE(exzisus_videoram_0_r, exzisus_videoram_0_w) AM_SHARE("videoram0")
153	153	AM_RANGE(0xe000, 0xefff) AM_RAM
154		AM_RANGE(0xf000, 0xf000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_port_w)
155		AM_RANGE(0xf001, 0xf001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w)
	154	AM_RANGE(0xf000, 0xf000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_port_w)
	155	AM_RANGE(0xf001, 0xf001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w)
156	156	AM_RANGE(0xf400, 0xf400) AM_READ_PORT("P1")
157	157	AM_RANGE(0xf400, 0xf400) AM_WRITE(exzisus_cpub_bankswitch_w)
158	158	AM_RANGE(0xf401, 0xf401) AM_READ_PORT("P2")
r21620	r21621
176	176	AM_RANGE(0x0000, 0x7fff) AM_ROM
177	177	AM_RANGE(0x8000, 0x8fff) AM_RAM
178	178	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
179		AM_RANGE(0xa000, 0xa000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
180		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	179	AM_RANGE(0xa000, 0xa000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	180	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
181	181	ADDRESS_MAP_END
182	182
183	183

trunk/src/mame/drivers/darius.c

r21620	r21621
174	174	switch (offset)
175	175	{
176	176	case 0x01:
177		return (tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff);    /* sound interface read */
	177	return (m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff);    /* sound interface read */
178	178
179	179	case 0x04:
180	180	return ioport("P1")->read();
r21620	r21621
203	203	{
204	204	case 0x00:  /* sound interface write */
205	205
206		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	206	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
207	207	return;
208	208
209	209	case 0x01:  /* sound interface write */
210	210
211		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	211	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
212	212	return;
213	213
214	214	case 0x28:  /* unknown, written by both cpus - always 0? */
r21620	r21621
466	466	AM_RANGE(0x8000, 0x8fff) AM_RAM
467	467	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ym1", ym2203_r, ym2203_w)
468	468	AM_RANGE(0xa000, 0xa001) AM_DEVREADWRITE_LEGACY("ym2", ym2203_r, ym2203_w)
469		AM_RANGE(0xb000, 0xb000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
470		AM_RANGE(0xb001, 0xb001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	469	AM_RANGE(0xb000, 0xb000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	470	AM_RANGE(0xb001, 0xb001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
471	471	AM_RANGE(0xc000, 0xc000) AM_WRITE(darius_fm0_pan)
472	472	AM_RANGE(0xc400, 0xc400) AM_WRITE(darius_fm1_pan)
473	473	AM_RANGE(0xc800, 0xc800) AM_WRITE(darius_psg0_pan)
r21620	r21621
830	830	m_cpub = machine().device("cpub");
831	831	m_adpcm = machine().device("adpcm");
832	832	m_pc080sn = machine().device("pc080sn");
833		m_tc0140syt = machine().device("tc0140syt");
	833	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
834	834
835	835	m_lscreen = machine().device("lscreen");
836	836	m_mscreen = machine().device("mscreen");

trunk/src/mame/drivers/taito_z.c

r21620	r21621
1417	1417	WRITE16_MEMBER(taitoz_state::taitoz_sound_w)
1418	1418	{
1419	1419	if (offset == 0)
1420		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	1420	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
1421	1421	else if (offset == 1)
1422		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	1422	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
1423	1423
1424	1424	#ifdef MAME_DEBUG
1425	1425	//  if (data & 0xff00)
r21620	r21621
1435	1435	READ16_MEMBER(taitoz_state::taitoz_sound_r)
1436	1436	{
1437	1437	if (offset == 1)
1438		return (tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff);
	1438	return (m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff);
1439	1439	else
1440	1440	return 0;
1441	1441	}
r21620	r21621
1444	1444	WRITE16_MEMBER(taitoz_state::taitoz_msb_sound_w)
1445	1445	{
1446	1446	if (offset == 0)
1447		tc0140syt_port_w(m_tc0140syt, 0, (data >> 8) & 0xff);
	1447	m_tc0140syt->tc0140syt_port_w(0, (data >> 8) & 0xff);
1448	1448	else if (offset == 1)
1449		tc0140syt_comm_w(m_tc0140syt, 0, (data >> 8) & 0xff);
	1449	m_tc0140syt->tc0140syt_comm_w(0, (data >> 8) & 0xff);
1450	1450
1451	1451	#ifdef MAME_DEBUG
1452	1452	if (data & 0xff)
r21620	r21621
1462	1462	READ16_MEMBER(taitoz_state::taitoz_msb_sound_r)
1463	1463	{
1464	1464	if (offset == 1)
1465		return ((tc0140syt_comm_r(m_tc0140syt, 0) & 0xff) << 8);
	1465	return ((m_tc0140syt->tc0140syt_comm_r(0) & 0xff) << 8);
1466	1466	else
1467	1467	return 0;
1468	1468	}
r21620	r21621
1746	1746	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
1747	1747	AM_RANGE(0xc000, 0xdfff) AM_RAM
1748	1748	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
1749		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
1750		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	1749	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	1750	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
1751	1751	AM_RANGE(0xe400, 0xe403) AM_WRITE(taitoz_pancontrol) /* pan */
1752	1752	AM_RANGE(0xea00, 0xea00) AM_READNOP
1753	1753	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
3039	3039	m_tc0150rod = machine().device("tc0150rod");
3040	3040	m_tc0480scp = machine().device("tc0480scp");
3041	3041	m_tc0220ioc = machine().device("tc0220ioc");
3042		m_tc0140syt = machine().device("tc0140syt");
	3042	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
3043	3043
3044	3044	save_item(NAME(m_cpua_ctrl));
3045	3045

trunk/src/mame/drivers/wgp.c

r21620	r21621
614	614	WRITE16_MEMBER(wgp_state::wgp_sound_w)
615	615	{
616	616	if (offset == 0)
617		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	617	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
618	618	else if (offset == 1)
619		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	619	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
620	620	}
621	621
622	622	READ16_MEMBER(wgp_state::wgp_sound_r)
623	623	{
624	624	if (offset == 1)
625		return ((tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff));
	625	return ((m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff));
626	626	else
627	627	return 0;
628	628	}
r21620	r21621
671	671	AM_RANGE(0x0000, 0x7fff) AM_ROM
672	672	AM_RANGE(0xc000, 0xdfff) AM_RAM
673	673	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
674		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
675		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	674	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	675	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
676	676	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
677	677	AM_RANGE(0xea00, 0xea00) AM_READNOP
678	678	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
940	940	m_maincpu = machine().device<cpu_device>("maincpu");
941	941	m_audiocpu = machine().device<cpu_device>("audiocpu");
942	942	m_subcpu = machine().device<cpu_device>("sub");
943		m_tc0140syt = machine().device("tc0140syt");
	943	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
944	944	m_tc0100scn = machine().device("tc0100scn");
945	945
946	946	save_item(NAME(m_cpua_ctrl));

trunk/src/mame/drivers/mlanding.c

r21620	r21621
346	346
347	347	WRITE16_MEMBER(mlanding_state::ml_to_sound_w)
348	348	{
349		device_t *tc0140syt = machine().device("tc0140syt");
	349	tc0140syt_device *tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
350	350	if (offset == 0)
351		tc0140syt_port_w(tc0140syt, space, 0, data & 0xff);
	351	tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
352	352	else if (offset == 1)
353	353	{
354	354	//machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
355		tc0140syt_comm_w(tc0140syt, space, 0, data & 0xff);
	355	tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
356	356	}
357	357	}
358	358
359	359	WRITE8_MEMBER(mlanding_state::ml_sound_to_main_w)
360	360	{
361		device_t *tc0140syt = machine().device("tc0140syt");
	361	tc0140syt_device *tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
362	362	if (offset == 0)
363		tc0140syt_slave_port_w(tc0140syt, space, 0, data & 0xff);
	363	tc0140syt->tc0140syt_slave_port_w(space, 0, data & 0xff);
364	364	else if (offset == 1)
365	365	{
366	366	//machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
367		tc0140syt_slave_comm_w(tc0140syt, space, 0, data & 0xff);
	367	tc0140syt->tc0140syt_slave_comm_w(space, 0, data & 0xff);
368	368	}
369	369	}
370	370
r21620	r21621
489	489
490	490	AM_RANGE(0x2d0000, 0x2d0003) AM_WRITE(ml_to_sound_w)
491	491	AM_RANGE(0x2d0000, 0x2d0001) AM_READNOP
492		AM_RANGE(0x2d0002, 0x2d0003) AM_DEVREAD8_LEGACY("tc0140syt", tc0140syt_comm_r, 0x00ff)
	492	AM_RANGE(0x2d0002, 0x2d0003) AM_DEVREAD8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, 0x00ff)
493	493
494	494	AM_RANGE(0x200000, 0x20ffff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")
495	495	AM_RANGE(0x280000, 0x2807ff) AM_READWRITE(ml_mecha_ram_r,ml_mecha_ram_w)
r21620	r21621
542	542	AM_RANGE(0x8000, 0x8fff) AM_RAM
543	543	AM_RANGE(0x9000, 0x9001) AM_MIRROR(0x00fe) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
544	544	AM_RANGE(0xa000, 0xa001) AM_WRITE(ml_sound_to_main_w)
545		AM_RANGE(0xa001, 0xa001) AM_DEVREAD_LEGACY("tc0140syt", tc0140syt_slave_comm_r)
	545	AM_RANGE(0xa001, 0xa001) AM_DEVREAD("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r)
546	546
547	547	//  AM_RANGE(0xb000, 0xb000) AM_WRITE_LEGACY(ml_msm5205_address_w) //guess
548	548	//  AM_RANGE(0xc000, 0xc000) AM_DEVWRITE_LEGACY("msm", ml_msm5205_start_w)

trunk/src/mame/drivers/warriorb.c

r21620	r21621
178	178	WRITE16_MEMBER(warriorb_state::warriorb_sound_w)
179	179	{
180	180	if (offset == 0)
181		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	181	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
182	182	else if (offset == 1)
183		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	183	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
184	184	}
185	185
186	186	READ16_MEMBER(warriorb_state::warriorb_sound_r)
187	187	{
188	188	if (offset == 1)
189		return ((tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff));
	189	return ((m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff));
190	190	else
191	191	return 0;
192	192	}
r21620	r21621
259	259	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
260	260	AM_RANGE(0xc000, 0xdfff) AM_RAM
261	261	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
262		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
263		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	262	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	263	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
264	264	AM_RANGE(0xe400, 0xe403) AM_WRITE(warriorb_pancontrol) /* pan */
265	265	AM_RANGE(0xea00, 0xea00) AM_READNOP
266	266	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
509	509
510	510	m_maincpu = machine().device<cpu_device>("maincpu");
511	511	m_audiocpu = machine().device<cpu_device>("audiocpu");
512		m_tc0140syt = machine().device("tc0140syt");
	512	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
513	513	m_tc0100scn_1 = machine().device("tc0100scn_1");
514	514	m_tc0100scn_2 = machine().device("tc0100scn_2");
515	515

trunk/src/mame/drivers/taito_b.c

r21620	r21621
504	504	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
505	505	AM_RANGE(0x600000, 0x607fff) AM_RAM /* Main RAM */ /*ashura up to 603fff only*/
506	506	TC0180VCU_MEMRW( 0x400000 )
507		AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
508		AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	507	AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	508	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
509	509	AM_RANGE(0xa00000, 0xa0000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
510	510	ADDRESS_MAP_END
511	511
r21620	r21621
514	514	AM_RANGE(0x000000, 0x07ffff) AM_ROM
515	515	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
516	516	TC0180VCU_MEMRW( 0x400000 )
517		AM_RANGE(0x600000, 0x600001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
518		AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	517	AM_RANGE(0x600000, 0x600001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	518	AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
519	519	AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
520	520	AM_RANGE(0xa00000, 0xa0ffff) AM_RAM /* Main RAM */
521	521	ADDRESS_MAP_END
r21620	r21621
523	523
524	524	static ADDRESS_MAP_START( tetrist_map, AS_PROGRAM, 16, taitob_state )
525	525	AM_RANGE(0x000000, 0x07ffff) AM_ROM
526		AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
527		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	526	AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	527	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
528	528	TC0180VCU_MEMRW( 0x400000 )
529	529	AM_RANGE(0x600000, 0x60000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
530	530	AM_RANGE(0x800000, 0x807fff) AM_RAM /* Main RAM */
r21620	r21621
538	538	AM_RANGE(0x600000, 0x600001) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_portreg_r, tc0220ioc_portreg_w, 0xff00)
539	539	AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_port_r, tc0220ioc_port_w, 0xff00)
540	540	AM_RANGE(0x800000, 0x803fff) AM_RAM /* Main RAM */
541		AM_RANGE(0xa00000, 0xa00001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
542		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	541	AM_RANGE(0xa00000, 0xa00001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	542	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
543	543	ADDRESS_MAP_END
544	544
545	545
r21620	r21621
548	548	TC0180VCU_MEMRW( 0x400000 )
549	549	AM_RANGE(0x600000, 0x60000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
550	550	AM_RANGE(0x610000, 0x610001) AM_READ_PORT("P3_P4")
551		AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
552		AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	551	AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	552	AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
553	553	AM_RANGE(0x800000, 0x803fff) AM_RAM /* Main RAM */
554	554	AM_RANGE(0xa00000, 0xa01fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
555	555	AM_RANGE(0xb00000, 0xb7ffff) AM_RAM_WRITE(hitice_pixelram_w) AM_SHARE("pixelram")
r21620	r21621
561	561
562	562	static ADDRESS_MAP_START( rambo3_map, AS_PROGRAM, 16, taitob_state )
563	563	AM_RANGE(0x000000, 0x07ffff) AM_ROM
564		AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
565		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	564	AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	565	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
566	566	TC0180VCU_MEMRW( 0x400000 )
567	567	AM_RANGE(0x600000, 0x60000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
568	568	AM_RANGE(0x600010, 0x600011) AM_READ(tracky1_lo_r) /*player 1*/
r21620	r21621
587	587	AM_RANGE(0x500028, 0x500029) AM_WRITE(player_34_coin_ctrl_w)    /* simply locks coins 3&4 out */
588	588	AM_RANGE(0x50002e, 0x50002f) AM_READ_PORT("P3_P4_B")        /* shown in service mode, game omits to read it */
589	589	AM_RANGE(0x600000, 0x600003) AM_WRITE(gain_control_w)
590		AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
591		AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	590	AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	591	AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
592	592	AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
593	593	AM_RANGE(0x900000, 0x90ffff) AM_RAM /* Main RAM */
594	594	ADDRESS_MAP_END
r21620	r21621
603	603	AM_RANGE(0x500028, 0x500029) AM_WRITE(player_34_coin_ctrl_w)    /* simply locks coins 3&4 out */
604	604	AM_RANGE(0x50002e, 0x50002f) AM_READ_PORT("P3_P4_B")
605	605	AM_RANGE(0x600000, 0x600003) AM_WRITE(gain_control_w)
606		AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
607		AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	606	AM_RANGE(0x700000, 0x700001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	607	AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
608	608	AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
609	609	AM_RANGE(0x900000, 0x90ffff) AM_RAM /* Main RAM */
610	610	ADDRESS_MAP_END
611	611
612	612	static ADDRESS_MAP_START( spacedxo_map, AS_PROGRAM, 16, taitob_state )
613	613	AM_RANGE(0x000000, 0x07ffff) AM_ROM
614		AM_RANGE(0x100000, 0x100001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
615		AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	614	AM_RANGE(0x100000, 0x100001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	615	AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
616	616	AM_RANGE(0x200000, 0x20000f) AM_DEVREAD8_LEGACY("tc0220ioc", tc0220ioc_r, 0x00ff) AM_WRITE(spacedxo_tc0220ioc_w)
617	617	AM_RANGE(0x210000, 0x210001) AM_READ_PORT("IN3")
618	618	AM_RANGE(0x220000, 0x220001) AM_READ_PORT("IN4")
r21620	r21621
632	632	AM_RANGE(0x200028, 0x200029) AM_READWRITE(player_34_coin_ctrl_r, player_34_coin_ctrl_w)
633	633	AM_RANGE(0x20002e, 0x20002f) AM_READ_PORT("P3_P4_B")    /* player 3,4 buttons */
634	634	TC0180VCU_MEMRW( 0x400000 )
635		AM_RANGE(0x600000, 0x600001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
636		AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	635	AM_RANGE(0x600000, 0x600001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	636	AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
637	637	AM_RANGE(0x700000, 0x700003) AM_WRITE(gain_control_w)
638	638	AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
639	639	AM_RANGE(0x900000, 0x90ffff) AM_RAM /* Main RAM */
r21620	r21621
642	642
643	643	static ADDRESS_MAP_START( viofight_map, AS_PROGRAM, 16, taitob_state )
644	644	AM_RANGE(0x000000, 0x07ffff) AM_ROM
645		AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
646		AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	645	AM_RANGE(0x200000, 0x200001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	646	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
647	647	TC0180VCU_MEMRW( 0x400000 )
648	648	AM_RANGE(0x600000, 0x601fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
649	649	AM_RANGE(0x800000, 0x80000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
r21620	r21621
658	658	AM_RANGE(0x600000, 0x601fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
659	659	AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_portreg_r, tc0220ioc_portreg_w, 0xff00)
660	660	AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_port_r, tc0220ioc_port_w, 0xff00)
661		AM_RANGE(0xa00000, 0xa00001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
662		AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	661	AM_RANGE(0xa00000, 0xa00001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	662	AM_RANGE(0xa00002, 0xa00003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
663	663	ADDRESS_MAP_END
664	664
665	665
666	666	static ADDRESS_MAP_START( silentd_map, AS_PROGRAM, 16, taitob_state )
667	667	AM_RANGE(0x000000, 0x07ffff) AM_ROM
668		AM_RANGE(0x100000, 0x100001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
669		AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	668	AM_RANGE(0x100000, 0x100001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	669	AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
670	670	//  AM_RANGE(0x10001a, 0x10001b) AM_READNOP // ??? read at $1e344
671	671	//  AM_RANGE(0x10001c, 0x10001d) AM_READNOP // ??? read at $1e356
672	672	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
r21620	r21621
688	688	AM_RANGE(0x300000, 0x301fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
689	689	AM_RANGE(0x400000, 0x40000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00)
690	690	AM_RANGE(0x410000, 0x41000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0xff00) /* mirror address - seems to be only used for coin control */
691		AM_RANGE(0x500000, 0x500001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
692		AM_RANGE(0x500002, 0x500003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	691	AM_RANGE(0x500000, 0x500001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	692	AM_RANGE(0x500002, 0x500003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
693	693	ADDRESS_MAP_END
694	694
695	695
r21620	r21621
698	698	AM_RANGE(0x100000, 0x10ffff) AM_RAM /* Main RAM */
699	699	AM_RANGE(0x200000, 0x201fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
700	700	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_wordswap_r, tc0510nio_halfword_wordswap_w)
701		AM_RANGE(0x320000, 0x320001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
702		AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	701	AM_RANGE(0x320000, 0x320001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	702	AM_RANGE(0x320002, 0x320003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
703	703	TC0180VCU_MEMRW( 0x900000 )
704	704	ADDRESS_MAP_END
705	705
r21620	r21621
710	710	AM_RANGE(0x130000, 0x13ffff) AM_RAM // Check me
711	711	AM_RANGE(0x180000, 0x18000f) AM_DEVREADWRITE_LEGACY("tc0510nio", tc0510nio_halfword_wordswap_r, tc0510nio_halfword_wordswap_w)
712	712	AM_RANGE(0x184000, 0x184001) AM_WRITE(realpunc_video_ctrl_w)
713		AM_RANGE(0x188000, 0x188001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
714		AM_RANGE(0x188002, 0x188003) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_comm_w, 0xff00)
	713	AM_RANGE(0x188000, 0x188001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	714	AM_RANGE(0x188002, 0x188003) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_w, 0xff00)
715	715	AM_RANGE(0x18c000, 0x18c001) AM_WRITE(realpunc_output_w)
716	716	TC0180VCU_MEMRW( 0x200000 )
717	717	AM_RANGE(0x280000, 0x281fff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBxxxx_word_w) AM_SHARE("paletteram")
718	718	AM_RANGE(0x300000, 0x300001) AM_DEVREADWRITE_LEGACY("hd63484", hd63484_status_r, hd63484_address_w)
719	719	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE_LEGACY("hd63484", hd63484_data_r, hd63484_data_w)
720	720	//  AM_RANGE(0x320000, 0x320001) AM_READ_LEGACY(SMH_NOP) // ?
721		AM_RANGE(0x320002, 0x320003) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_comm_w, 0xff00)
	721	AM_RANGE(0x320002, 0x320003) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_w, 0xff00)
722	722	ADDRESS_MAP_END
723	723
724	724	static ADDRESS_MAP_START( masterw_sound_map, AS_PROGRAM, 8, taitob_state )
r21620	r21621
726	726	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
727	727	AM_RANGE(0x8000, 0x8fff) AM_RAM
728	728	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
729		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
730		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	729	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	730	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
731	731	ADDRESS_MAP_END
732	732
733	733	static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8, taitob_state )
r21620	r21621
735	735	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
736	736	AM_RANGE(0xc000, 0xdfff) AM_RAM
737	737	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
738		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
739		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	738	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	739	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
740	740	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
741	741	AM_RANGE(0xe600, 0xe600) AM_WRITENOP /* ? */
742	742	AM_RANGE(0xea00, 0xea00) AM_READNOP
r21620	r21621
751	751	AM_RANGE(0x8000, 0x8fff) AM_RAM
752	752	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
753	753	AM_RANGE(0xb000, 0xb001) AM_DEVREADWRITE("oki", okim6295_device, read, write)       /* yes, both addresses for the same chip */
754		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
755		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	754	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	755	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
756	756	ADDRESS_MAP_END
757	757
758	758

trunk/src/mame/drivers/othunder.c

r21620	r21621
397	397	WRITE16_MEMBER(othunder_state::othunder_sound_w)
398	398	{
399	399	if (offset == 0)
400		tc0140syt_port_w(m_tc0140syt, space, 0, data & 0xff);
	400	m_tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
401	401	else if (offset == 1)
402		tc0140syt_comm_w(m_tc0140syt, space, 0, data & 0xff);
	402	m_tc0140syt->tc0140syt_comm_w(space, 0, data & 0xff);
403	403	}
404	404
405	405	READ16_MEMBER(othunder_state::othunder_sound_r)
406	406	{
407	407	if (offset == 1)
408		return ((tc0140syt_comm_r(m_tc0140syt, space, 0) & 0xff));
	408	return ((m_tc0140syt->tc0140syt_comm_r(space, 0) & 0xff));
409	409	else
410	410	return 0;
411	411	}
r21620	r21621
466	466	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank10")
467	467	AM_RANGE(0xc000, 0xdfff) AM_RAM
468	468	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
469		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
470		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	469	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	470	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
471	471	AM_RANGE(0xe400, 0xe403) AM_WRITE(othunder_TC0310FAM_w) /* pan */
472	472	AM_RANGE(0xe600, 0xe600) AM_WRITENOP /* ? */
473	473	AM_RANGE(0xea00, 0xea00) AM_READ_PORT(ROTARY_PORT_TAG)  /* rotary input */
r21620	r21621
671	671	m_tc0220ioc = machine().device("tc0220ioc");
672	672	m_tc0100scn = machine().device("tc0100scn");
673	673	m_tc0110pcr = machine().device("tc0110pcr");
674		m_tc0140syt = machine().device("tc0140syt");
	674	m_tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
675	675	m_2610_0l = machine().device<filter_volume_device>("2610.0l");
676	676	m_2610_0r = machine().device<filter_volume_device>("2610.0r");
677	677	m_2610_1l = machine().device<filter_volume_device>("2610.1l");

trunk/src/mame/drivers/pcxt.c

r21620	r21621
332	332	pit8253_gate2_w(m_pit8253, BIT(data, 0));
333	333	pcxt_speaker_set_spkrdata( data & 0x02 );
334	334	m_port_b_data = data;
335		// device_t *beep = machine().device("beep");
	335	// device_t *beep = machine().device<beep_device>("beep");
336	336	// device_t *cvsd = machine().device("cvsd");
337	337	//  hc55516_digit_w(cvsd, data);
338	338	//  popmessage("%02x\n",data);
339		//  beep_set_state(beep, 0);
340		//  beep_set_state(beep, 1);
341		//  beep_set_frequency(beep, m_port_b_data);
	339	//  beep->beep_set_state(0);
	340	//  beep->beep_set_state(1);
	341	//  beep->beep_set_frequency(m_port_b_data);
342	342	}
343	343
344	344	WRITE8_MEMBER(pcxt_state::wss_1_w)

trunk/src/mame/drivers/dlair.c

r21620	r21621
286	286	if (beep != NULL)
287	287	{
288	288	z80ctc_device *ctc = machine().device<z80ctc_device>("ctc");
289		beep_set_state(beep, 1);
290		beep_set_frequency(beep, ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds));
	289	beep->set_state(1);
	290	beep->set_frequency(ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds));
291	291	}
292	292	}
293	293

trunk/src/mame/drivers/taito_h.c

r21620	r21621
251	251	AM_RANGE(0x100000, 0x10ffff) AM_MIRROR(0x010000) AM_RAM AM_SHARE("m68000_mainram")
252	252	AM_RANGE(0x200000, 0x200001) AM_READ8(syvalion_input_bypass_r, 0x00ff) AM_DEVWRITE8_LEGACY("tc0220ioc", tc0220ioc_portreg_w, 0x00ff)
253	253	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_port_r, tc0220ioc_port_w, 0x00ff)
254		AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
255		AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	254	AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	255	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
256	256	AM_RANGE(0x400000, 0x420fff) AM_DEVREADWRITE_LEGACY("tc0080vco", tc0080vco_word_r, tc0080vco_word_w)
257	257	AM_RANGE(0x500800, 0x500fff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")
258	258	ADDRESS_MAP_END
r21620	r21621
262	262	AM_RANGE(0x100000, 0x10ffff) AM_MIRROR(0x010000) AM_RAM AM_SHARE("m68000_mainram")
263	263	AM_RANGE(0x200000, 0x200001) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_portreg_r, tc0220ioc_portreg_w, 0x00ff)
264	264	AM_RANGE(0x200002, 0x200003) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_port_r, tc0220ioc_port_w, 0x00ff)
265		AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
266		AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	265	AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	266	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
267	267	AM_RANGE(0x400000, 0x420fff) AM_DEVREADWRITE_LEGACY("tc0080vco", tc0080vco_word_r, tc0080vco_word_w)
268	268	AM_RANGE(0x500800, 0x500fff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")
269	269	ADDRESS_MAP_END
r21620	r21621
272	272	AM_RANGE(0x000000, 0x05ffff) AM_ROM
273	273	AM_RANGE(0x100000, 0x10ffff) AM_MIRROR(0x010000) AM_RAM AM_SHARE("m68000_mainram")
274	274	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
275		AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
276		AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	275	AM_RANGE(0x300000, 0x300001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	276	AM_RANGE(0x300002, 0x300003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
277	277	AM_RANGE(0x400000, 0x420fff) AM_DEVREADWRITE_LEGACY("tc0080vco", tc0080vco_word_r, tc0080vco_word_w)
278	278	AM_RANGE(0x500800, 0x500fff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")
279	279	AM_RANGE(0x600000, 0x600001) AM_WRITENOP    /* ?? writes zero once per frame */
r21620	r21621
285	285	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
286	286	AM_RANGE(0xc000, 0xdfff) AM_RAM
287	287	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
288		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
289		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	288	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	289	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
290	290	AM_RANGE(0xe400, 0xe403) AM_WRITENOP        /* pan control */
291	291	AM_RANGE(0xea00, 0xea00) AM_READNOP
292	292	AM_RANGE(0xee00, 0xee00) AM_WRITENOP        /* ? */

trunk/src/mame/drivers/asuka.c

r21620	r21621
318	318	AM_RANGE(0x3b0000, 0x3b0001) AM_READ_PORT("DSWB")
319	319	AM_RANGE(0x3c0000, 0x3c0001) AM_WRITE(watchdog_reset16_w)
320	320	AM_RANGE(0x3d0000, 0x3d0001) AM_READNOP
321		AM_RANGE(0x3e0000, 0x3e0001) AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
322		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	321	AM_RANGE(0x3e0000, 0x3e0001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	322	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
323	323	AM_RANGE(0x800000, 0x8007ff) AM_READWRITE(bonzeadv_cchip_ram_r, bonzeadv_cchip_ram_w)
324	324	AM_RANGE(0x800802, 0x800803) AM_READWRITE(bonzeadv_cchip_ctrl_r, bonzeadv_cchip_ctrl_w)
325	325	AM_RANGE(0x800c00, 0x800c01) AM_WRITE(bonzeadv_cchip_bank_w)
r21620	r21621
334	334	AM_RANGE(0x1076f0, 0x1076f1) AM_READNOP /* Mofflott init does dummy reads here */
335	335	AM_RANGE(0x200000, 0x20000f) AM_DEVREADWRITE_LEGACY("tc0110pcr", tc0110pcr_word_r, tc0110pcr_step1_word_w)
336	336	AM_RANGE(0x3a0000, 0x3a0003) AM_WRITE(asuka_spritectrl_w)
337		AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
338		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	337	AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	338	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
339	339	AM_RANGE(0x400000, 0x40000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
340	340	AM_RANGE(0xc00000, 0xc0ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
341	341	AM_RANGE(0xc10000, 0xc103ff) AM_WRITENOP    /* error in Asuka init code */
r21620	r21621
346	346	static ADDRESS_MAP_START( cadash_map, AS_PROGRAM, 16, asuka_state )
347	347	AM_RANGE(0x000000, 0x07ffff) AM_ROM
348	348	AM_RANGE(0x080000, 0x080003) AM_WRITE(asuka_spritectrl_w)
349		AM_RANGE(0x0c0000, 0x0c0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
350		AM_RANGE(0x0c0002, 0x0c0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	349	AM_RANGE(0x0c0000, 0x0c0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	350	AM_RANGE(0x0c0002, 0x0c0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
351	351	AM_RANGE(0x100000, 0x107fff) AM_RAM
352	352	AM_RANGE(0x800000, 0x800fff) AM_READWRITE(cadash_share_r,cadash_share_w)    /* network ram */
353	353	AM_RANGE(0x900000, 0x90000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
r21620	r21621
364	364	AM_RANGE(0x300000, 0x30000f) AM_DEVREADWRITE8_LEGACY("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff)
365	365	AM_RANGE(0x400000, 0x40000f) AM_DEVREAD8_LEGACY("tc0220ioc", tc0220ioc_r, 0x00ff)   /* service mode mirror */
366	366	AM_RANGE(0x4a0000, 0x4a0003) AM_WRITE(asuka_spritectrl_w)
367		AM_RANGE(0x4e0000, 0x4e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
368		AM_RANGE(0x4e0002, 0x4e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
	367	AM_RANGE(0x4e0000, 0x4e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	368	AM_RANGE(0x4e0002, 0x4e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0x00ff)
369	369	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE_LEGACY("pc090oj", pc090oj_word_r, pc090oj_word_w)  /* sprite ram */
370	370	AM_RANGE(0xc00000, 0xc0ffff) AM_DEVWRITE_LEGACY("tc0100scn", tc0100scn_word_w)
371	371	AM_RANGE(0xd00000, 0xd0ffff) AM_DEVREADWRITE_LEGACY("tc0100scn", tc0100scn_word_r, tc0100scn_word_w)    /* tilemaps */
r21620	r21621
380	380	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
381	381	AM_RANGE(0xc000, 0xdfff) AM_RAM
382	382	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
383		AM_RANGE(0xe200, 0xe200) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
384		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	383	AM_RANGE(0xe200, 0xe200) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	384	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
385	385	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
386	386	AM_RANGE(0xe600, 0xe600) AM_WRITENOP
387	387	AM_RANGE(0xee00, 0xee00) AM_WRITENOP
r21620	r21621
395	395	AM_RANGE(0x8000, 0x8fff) AM_RAM
396	396	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
397	397	//  AM_RANGE(0x9002, 0x9100) AM_READNOP
398		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
399		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	398	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	399	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
400	400	AM_RANGE(0xb000, 0xb000) AM_WRITE(asuka_msm5205_address_w)
401	401	AM_RANGE(0xc000, 0xc000) AM_WRITE(asuka_msm5205_start_w)
402	402	AM_RANGE(0xd000, 0xd000) AM_WRITE(asuka_msm5205_stop_w)
r21620	r21621
408	408	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank1")
409	409	AM_RANGE(0x8000, 0x8fff) AM_RAM
410	410	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
411		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
412		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	411	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	412	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
413	413	ADDRESS_MAP_END
414	414
415	415	/*

trunk/src/mame/drivers/opwolf.c

r21620	r21621
367	367	AM_RANGE(0x380000, 0x380003) AM_WRITE(opwolf_spritectrl_w)  // usually 0x4, changes when you fire
368	368	AM_RANGE(0x3a0000, 0x3a0003) AM_READ(opwolf_lightgun_r)     /* lightgun, read at $11e0/6 */
369	369	AM_RANGE(0x3c0000, 0x3c0001) AM_WRITENOP                    /* watchdog ?? */
370		AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
371		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	370	AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	371	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
372	372	AM_RANGE(0xc00000, 0xc0ffff) AM_DEVREADWRITE_LEGACY("pc080sn", pc080sn_word_r, pc080sn_word_w)
373	373	AM_RANGE(0xc10000, 0xc1ffff) AM_WRITEONLY                   /* error in init code (?) */
374	374	AM_RANGE(0xc20000, 0xc20003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_yscroll_word_w)
r21620	r21621
388	388	AM_RANGE(0x380000, 0x380003) AM_WRITE(opwolf_spritectrl_w)  // usually 0x4, changes when you fire
389	389	AM_RANGE(0x3a0000, 0x3a0003) AM_READ(opwolf_lightgun_r)     /* lightgun, read at $11e0/6 */
390	390	AM_RANGE(0x3c0000, 0x3c0001) AM_WRITENOP                    /* watchdog ?? */
391		AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0xff00)
392		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
	391	AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0xff00)
	392	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
393	393	AM_RANGE(0xc00000, 0xc0ffff) AM_DEVREADWRITE_LEGACY("pc080sn", pc080sn_word_r, pc080sn_word_w)
394	394	AM_RANGE(0xc10000, 0xc1ffff) AM_WRITEONLY                   /* error in init code (?) */
395	395	AM_RANGE(0xc20000, 0xc20003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_yscroll_word_w)
r21620	r21621
540	540	AM_RANGE(0x8000, 0x8fff) AM_RAM
541	541	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device,read,write)
542	542	AM_RANGE(0x9002, 0x9100) AM_READNOP
543		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
544		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	543	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	544	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
545	545	AM_RANGE(0xb000, 0xb006) AM_WRITE(opwolf_adpcm_b_w)
546	546	AM_RANGE(0xc000, 0xc006) AM_WRITE(opwolf_adpcm_c_w)
547	547	AM_RANGE(0xd000, 0xd000) AM_WRITE(opwolf_adpcm_d_w)

trunk/src/mame/drivers/taito_l.c

r21620	r21621
672	672	AM_RANGE(0x0000, 0x7fff) AM_ROM
673	673	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("bank6")
674	674	AM_RANGE(0xc000, 0xc000) AM_WRITE(rombank2switch_w)
675		AM_RANGE(0xc800, 0xc800) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_port_w)
676		AM_RANGE(0xc801, 0xc801) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w)
	675	AM_RANGE(0xc800, 0xc800) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_port_w)
	676	AM_RANGE(0xc801, 0xc801) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w)
677	677	AM_RANGE(0xd000, 0xd000) AM_READ_PORT("DSWA") AM_WRITENOP   // Direct copy of input port 0
678	678	AM_RANGE(0xd001, 0xd001) AM_READ_PORT("DSWB")
679	679	AM_RANGE(0xd002, 0xd002) AM_READ_PORT("IN0")
r21620	r21621
688	688	AM_RANGE(0x0000, 0x3fff) AM_ROM
689	689	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank7")
690	690	AM_RANGE(0x8000, 0x9fff) AM_RAM
691		AM_RANGE(0xe000, 0xe000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
692		AM_RANGE(0xe001, 0xe001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	691	AM_RANGE(0xe000, 0xe000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	692	AM_RANGE(0xe001, 0xe001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
693	693	AM_RANGE(0xf000, 0xf001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
694	694	ADDRESS_MAP_END
695	695
r21620	r21621
699	699	AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("share1")
700	700	AM_RANGE(0x8800, 0x8800) AM_READWRITE(mux_r, mux_w)
701	701	AM_RANGE(0x8801, 0x8801) AM_WRITE(mux_ctrl_w) AM_READNOP    // Watchdog or interrupt ack (value ignored)
702		AM_RANGE(0x8c00, 0x8c00) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_port_w)
703		AM_RANGE(0x8c01, 0x8c01) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w)
	702	AM_RANGE(0x8c00, 0x8c00) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_port_w)
	703	AM_RANGE(0x8c01, 0x8c01) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w)
704	704	AM_RANGE(0xa000, 0xbfff) AM_RAM
705	705	ADDRESS_MAP_END
706	706
r21620	r21621
724	724	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank7")
725	725	AM_RANGE(0xc000, 0xdfff) AM_RAM
726	726	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
727		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
728		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	727	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	728	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
729	729	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
730	730	AM_RANGE(0xe600, 0xe600) AM_WRITENOP /* ? */
731	731	AM_RANGE(0xee00, 0xee00) AM_WRITENOP /* ? */
r21620	r21621
751	751	AM_RANGE(0xe004, 0xe004) AM_WRITE(control2_w)
752	752	AM_RANGE(0xe007, 0xe007) AM_READ_PORT("IN2")
753	753	AM_RANGE(0xe008, 0xe00f) AM_READNOP
754		AM_RANGE(0xe800, 0xe800) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_port_w)
755		AM_RANGE(0xe801, 0xe801) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w)
	754	AM_RANGE(0xe800, 0xe800) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_port_w)
	755	AM_RANGE(0xe801, 0xe801) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_comm_r, tc0140syt_comm_w)
756	756	AM_RANGE(0xf000, 0xf000) AM_READWRITE(rombank2switch_r, rombank2switch_w)
757	757	ADDRESS_MAP_END
758	758
r21620	r21621
761	761	AM_RANGE(0x4000, 0x7fff) AM_ROMBANK("bank7")
762	762	AM_RANGE(0x8000, 0x8fff) AM_RAM
763	763	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ymsnd", ym2203_r, ym2203_w)
764		AM_RANGE(0xa000, 0xa000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
765		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	764	AM_RANGE(0xa000, 0xa000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	765	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
766	766	AM_RANGE(0xb000, 0xb000) AM_WRITE(champwr_msm5205_hi_w)
767	767	AM_RANGE(0xc000, 0xc000) AM_WRITE(champwr_msm5205_lo_w)
768	768	AM_RANGE(0xd000, 0xd000) AM_WRITE(champwr_msm5205_start_w)

trunk/src/mame/drivers/zn.c

r21620	r21621
1105	1105
1106	1106	READ32_MEMBER(zn_state::taitofx1a_ymsound_r)
1107	1107	{
1108		device_t *tc0140syt = machine().device("tc0140syt");
1109		return tc0140syt_comm_r(tc0140syt, space, 0) << 16;
	1108	tc0140syt_device *tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
	1109	return tc0140syt->tc0140syt_comm_r(space, 0) << 16;
1110	1110	}
1111	1111
1112	1112	WRITE32_MEMBER(zn_state::taitofx1a_ymsound_w)
1113	1113	{
1114		device_t *tc0140syt = machine().device("tc0140syt");
	1114	tc0140syt_device *tc0140syt = machine().device<tc0140syt_device>("tc0140syt");
1115	1115
1116	1116	if (mem_mask == 0x0000ffff)
1117	1117	{
1118		tc0140syt_port_w(tc0140syt, space, 0, data & 0xff);
	1118	tc0140syt->tc0140syt_port_w(space, 0, data & 0xff);
1119	1119	}
1120	1120	else
1121	1121	{
1122		tc0140syt_comm_w(tc0140syt, space, 0, (data >> 16) & 0xff);
	1122	tc0140syt->tc0140syt_comm_w(space, 0, (data >> 16) & 0xff);
1123	1123	}
1124	1124	}
1125	1125
r21620	r21621
1147	1147	AM_RANGE(0x0000, 0x7fff) AM_ROM
1148	1148	AM_RANGE(0xc000, 0xdfff) AM_RAM
1149	1149	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE_LEGACY("ymsnd", ym2610_r, ym2610_w)
1150		AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
1151		AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	1150	AM_RANGE(0xe200, 0xe200) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	1151	AM_RANGE(0xe201, 0xe201) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
1152	1152	AM_RANGE(0xe400, 0xe403) AM_WRITENOP /* pan */
1153	1153	AM_RANGE(0xee00, 0xee00) AM_NOP /* ? */
1154	1154	AM_RANGE(0xf000, 0xf000) AM_WRITENOP /* ? */

trunk/src/mame/drivers/rainbow.c

r21620	r21621
352	352	AM_RANGE(0x3a0000, 0x3a0001) AM_WRITE(rbisland_spritectrl_w)
353	353	AM_RANGE(0x3b0000, 0x3b0003) AM_READ_PORT("DSWB")
354	354	AM_RANGE(0x3c0000, 0x3c0003) AM_WRITENOP        /* written very often, watchdog? */
355		AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8_LEGACY("tc0140syt", tc0140syt_port_w, 0x00ff)
356		AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8_LEGACY("tc0140syt", tc0140syt_comm_r,tc0140syt_comm_w, 0x00ff)
	355	AM_RANGE(0x3e0000, 0x3e0001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, tc0140syt_port_w, 0x00ff)
	356	AM_RANGE(0x3e0002, 0x3e0003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, tc0140syt_comm_r,tc0140syt_comm_w, 0x00ff)
357	357	AM_RANGE(0x800000, 0x8007ff) AM_READWRITE(rbisland_cchip_ram_r,rbisland_cchip_ram_w)
358	358	AM_RANGE(0x800802, 0x800803) AM_READWRITE(rbisland_cchip_ctrl_r,rbisland_cchip_ctrl_w)
359	359	AM_RANGE(0x800c00, 0x800c01) AM_WRITE(rbisland_cchip_bank_w)
r21620	r21621
411	411	AM_RANGE(0x8000, 0x8fff) AM_RAM
412	412	AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ymsnd", ym2151_device,read,write)
413	413	AM_RANGE(0x9002, 0x9100) AM_READNOP
414		AM_RANGE(0xa000, 0xa000) AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
415		AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
	414	AM_RANGE(0xa000, 0xa000) AM_DEVWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_port_w)
	415	AM_RANGE(0xa001, 0xa001) AM_DEVREADWRITE("tc0140syt", tc0140syt_device, tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
416	416	ADDRESS_MAP_END
417	417
418	418	static ADDRESS_MAP_START( jumping_sound_map, AS_PROGRAM, 8, rbisland_state )

trunk/src/mame/audio/taitosnd.c

r21620	r21621
15	15	#define TC0140SYT_PORT01_FULL_MASTER  (0x04)
16	16	#define TC0140SYT_PORT23_FULL_MASTER  (0x08)
17	17
18		struct tc0140syt_state
	18
	19	// device type definition
	20	const device_type TC0140SYT = &device_creator<tc0140syt_device>;
	21
	22
	23	//**************************************************************************
	24	//  LIVE DEVICE
	25	//**************************************************************************
	26
	27	//-------------------------------------------------
	28	//  tc0140syt_device - constructor
	29	//-------------------------------------------------
	30
	31	tc0140syt_device::tc0140syt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	32	: device_t(mconfig, TC0140SYT, "Taito TC0140SYT", tag, owner, clock),
	33	m_mainmode(0),
	34	m_submode(0),
	35	m_status(0),
	36	m_nmi_enabled(0),
	37	m_nmi_req(0),
	38	m_mastercpu(NULL),
	39	m_slavecpu(NULL)
19	40	{
20		UINT8     slavedata[4];  /* Data on master->slave port (4 nibbles) */
21		UINT8     masterdata[4]; /* Data on slave->master port (4 nibbles) */
22		UINT8     mainmode;      /* Access mode on master cpu side */
23		UINT8     submode;       /* Access mode on slave cpu side */
24		UINT8     status;        /* Status data */
25		UINT8     nmi_enabled;   /* 1 if slave cpu has nmi's enabled */
26		UINT8     nmi_req;       /* 1 if slave cpu has a pending nmi */
	41	memset(m_slavedata, 0, sizeof(UINT8)*4);
	42	memset(m_masterdata, 0, sizeof(UINT8)*4);
	43	}
27	44
28		device_t *mastercpu;    /* this is the maincpu */
29		device_t *slavecpu; /* this is the audiocpu */
30		};
31	45
32		/*****************************************************************************
33		INLINE FUNCTIONS
34		*****************************************************************************/
	46	//-------------------------------------------------
	47	//  device_start - device-specific startup
	48	//-------------------------------------------------
35	49
36		INLINE tc0140syt_state *get_safe_token( device_t *device )
	50	void tc0140syt_device::device_start()
37	51	{
38		assert(device != NULL);
39		assert(device->type() == TC0140SYT);
	52	const tc0140syt_interface *intf = reinterpret_cast<const tc0140syt_interface*>(static_config());
40	53
41		return (tc0140syt_state *)downcast<tc0140syt_device *>(device)->token();
	54	/* use the given gfx set */
	55	m_mastercpu = machine().device(intf->master);
	56	m_slavecpu = machine().device(intf->slave);
	57
	58	save_item(NAME(m_mainmode));
	59	save_item(NAME(m_submode));
	60	save_item(NAME(m_status));
	61	save_item(NAME(m_nmi_enabled));
	62	save_item(NAME(m_nmi_req));
	63	save_item(NAME(m_slavedata));
	64	save_item(NAME(m_masterdata));
42	65	}
43	66
44		INLINE const tc0140syt_interface *get_interface( device_t *device )
	67
	68	//-------------------------------------------------
	69	//  device_reset - device-specific reset
	70	//-------------------------------------------------
	71
	72	void tc0140syt_device::device_reset()
45	73	{
46		assert(device != NULL);
47		assert((device->type() == TC0140SYT));
48		return (const tc0140syt_interface *) device->static_config();
	74	int i;
	75
	76	m_mainmode = 0;
	77	m_submode = 0;
	78	m_status = 0;
	79	m_nmi_enabled = 0;
	80	m_nmi_req = 0;
	81
	82	for (i = 0; i < 4; i++)
	83	{
	84	m_slavedata[i] = 0;
	85	m_masterdata[i] = 0;
	86	}
49	87	}
50	88
51		/*****************************************************************************
52		DEVICE HANDLERS
53		*****************************************************************************/
54	89
55		static void interrupt_controller( device_t *device )
56		{
57		tc0140syt_state *tc0140syt = get_safe_token(device);
	90	//-------------------------------------------------
	91	//  DEVICE HANDLERS
	92	//-------------------------------------------------
58	93
59		if (tc0140syt->nmi_req && tc0140syt->nmi_enabled)
	94	void tc0140syt_device::interrupt_controller( )
	95	{
	96	if (m_nmi_req && m_nmi_enabled)
60	97	{
61		tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
62		tc0140syt->nmi_req = 0;
	98	m_slavecpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	99	m_nmi_req = 0;
63	100	}
64	101	}
65	102
66		WRITE8_DEVICE_HANDLER( tc0140syt_port_w )
	103
	104	//-------------------------------------------------
	105	//  MASTER SIDE
	106	//-------------------------------------------------
	107
	108	WRITE8_MEMBER( tc0140syt_device::tc0140syt_port_w )
67	109	{
68		tc0140syt_state *tc0140syt = get_safe_token(device);
69	110	data &= 0x0f;
70	111
71		tc0140syt->mainmode = data;
	112	m_mainmode = data;
72	113	//logerror("taitosnd: Master cpu mode [%02x]\n", data);
73	114	if (data > 4)
74	115	{
r21620	r21621
76	117	}
77	118	}
78	119
79		WRITE8_DEVICE_HANDLER( tc0140syt_comm_w )
80		{
81		tc0140syt_state *tc0140syt = get_safe_token(device);
82	120
	121	WRITE8_MEMBER( tc0140syt_device::tc0140syt_comm_w )
	122	{
83	123	data &= 0x0f;   /*this is important, otherwise ballbros won't work*/
84	124
85		switch (tc0140syt->mainmode)
	125	switch (m_mainmode)
86	126	{
87	127	case 0x00:      // mode #0
88		tc0140syt->slavedata[tc0140syt->mainmode ++] = data;
	128	m_slavedata[m_mainmode ++] = data;
89	129	//logerror("taitosnd: Master cpu written port 0, data %01x\n", data);
90	130	break;
91	131
92	132	case 0x01:      // mode #1
93		tc0140syt->slavedata[tc0140syt->mainmode ++] = data;
94		tc0140syt->status |= TC0140SYT_PORT01_FULL;
95		tc0140syt->nmi_req = 1;
96		//logerror("taitosnd: Master cpu sends 0/1 : %01x%01x\n", tc0140syt->slavedata[1], tc0140syt->slavedata[0]);
	133	m_slavedata[m_mainmode ++] = data;
	134	m_status |= TC0140SYT_PORT01_FULL;
	135	m_nmi_req = 1;
	136	//logerror("taitosnd: Master cpu sends 0/1 : %01x%01x\n", m_slavedata[1], m_slavedata[0]);
97	137	break;
98	138
99	139	case 0x02:      // mode #2
100		tc0140syt->slavedata[tc0140syt->mainmode ++] = data;
	140	m_slavedata[m_mainmode ++] = data;
101	141	//logerror("taitosnd: Master cpu written port 2, data %01\n", data);
102	142	break;
103	143
104	144	case 0x03:      // mode #3
105		tc0140syt->slavedata[tc0140syt->mainmode ++] = data;
106		tc0140syt->status |= TC0140SYT_PORT23_FULL;
107		tc0140syt->nmi_req = 1;
108		//logerror("taitosnd: Master cpu sends 2/3 : %01x%01x\n", tc0140syt->slavedata[3], tc0140syt->slavedata[2]);
	145	m_slavedata[m_mainmode ++] = data;
	146	m_status |= TC0140SYT_PORT23_FULL;
	147	m_nmi_req = 1;
	148	//logerror("taitosnd: Master cpu sends 2/3 : %01x%01x\n", m_slavedata[3], m_slavedata[2]);
109	149	break;
110	150
111	151	case 0x04:      // port status
112	152	//logerror("taitosnd: Master issued control value %02x (PC = %08x) \n",data, space.device().safe_pc() );
113	153	/* this does a hi-lo transition to reset the sound cpu */
114	154	if (data)
115		tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	155	m_slavecpu->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
116	156	else
117	157	{
118		tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
119		tc0140syt->mastercpu->execute().spin(); /* otherwise no sound in driftout */
	158	m_slavecpu->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	159	m_mastercpu->execute().spin(); /* otherwise no sound in driftout */
120	160	}
121	161	break;
122	162
123	163	default:
124		//logerror("taitosnd: Master cpu written in mode [%02x] data[%02x]\n", tc0140syt->mainmode, data);
	164	//logerror("taitosnd: Master cpu written in mode [%02x] data[%02x]\n", m_mainmode, data);
125	165	break;
126	166	}
127	167
128	168	}
129	169
130		READ8_DEVICE_HANDLER( tc0140syt_comm_r )
131		{
132		tc0140syt_state *tc0140syt = get_safe_token(device);
133	170
134		switch( tc0140syt->mainmode )
	171	READ8_MEMBER( tc0140syt_device::tc0140syt_comm_r )
	172	{
	173	switch( m_mainmode )
135	174	{
136	175	case 0x00:      // mode #0
137		//logerror("taitosnd: Master cpu read portdata %01x\n", tc0140syt->masterdata[0]);
138		return tc0140syt->masterdata[tc0140syt->mainmode ++];
	176	//logerror("taitosnd: Master cpu read portdata %01x\n", m_masterdata[0]);
	177	return m_masterdata[m_mainmode ++];
139	178
140	179	case 0x01:      // mode #1
141		//logerror("taitosnd: Master cpu receives 0/1 : %01x%01x\n", tc0140syt->masterdata[1], tc0140syt->masterdata[0]);
142		tc0140syt->status &= ~TC0140SYT_PORT01_FULL_MASTER;
143		return tc0140syt->masterdata[tc0140syt->mainmode ++];
	180	//logerror("taitosnd: Master cpu receives 0/1 : %01x%01x\n", m_masterdata[1], m_masterdata[0]);
	181	m_status &= ~TC0140SYT_PORT01_FULL_MASTER;
	182	return m_masterdata[m_mainmode ++];
144	183
145	184	case 0x02:      // mode #2
146		//logerror("taitosnd: Master cpu read masterdata %01x\n", tc0140syt->masterdata[2]);
147		return tc0140syt->masterdata[tc0140syt->mainmode ++];
	185	//logerror("taitosnd: Master cpu read masterdata %01x\n", m_masterdata[2]);
	186	return m_masterdata[m_mainmode ++];
148	187
149	188	case 0x03:      // mode #3
150		//logerror("taitosnd: Master cpu receives 2/3 : %01x%01x\n", tc0140syt->masterdata[3], tc0140syt->masterdata[2]);
151		tc0140syt->status &= ~TC0140SYT_PORT23_FULL_MASTER;
152		return tc0140syt->masterdata[tc0140syt->mainmode ++];
	189	//logerror("taitosnd: Master cpu receives 2/3 : %01x%01x\n", m_masterdata[3], m_masterdata[2]);
	190	m_status &= ~TC0140SYT_PORT23_FULL_MASTER;
	191	return m_masterdata[m_mainmode ++];
153	192
154	193	case 0x04:      // port status
155		//logerror("tc0140syt : Master cpu read status : %02x\n", tc0140syt->status);
156		return tc0140syt->status;
	194	//logerror("tc0140syt : Master cpu read status : %02x\n", m_status);
	195	return m_status;
157	196
158	197	default:
159		//logerror("tc0140syt : Master cpu read in mode [%02x]\n", tc0140syt->mainmode);
	198	//logerror("tc0140syt : Master cpu read in mode [%02x]\n", m_mainmode);
160	199	return 0;
161	200	}
162	201	}
163	202
	203	//-------------------------------------------------
164	204	//SLAVE SIDE
	205	//-------------------------------------------------
165	206
166		WRITE8_DEVICE_HANDLER( tc0140syt_slave_port_w )
	207	WRITE8_MEMBER( tc0140syt_device::tc0140syt_slave_port_w )
167	208	{
168		tc0140syt_state *tc0140syt = get_safe_token(device);
169
170	209	data &= 0x0f;
171		tc0140syt->submode = data;
	210	m_submode = data;
172	211	//logerror("taitosnd: Slave cpu mode [%02x]\n", data);
173	212	if (data > 6)
174	213	logerror("tc0140syt error : Slave cpu unknown mode[%02x]\n", data);
175	214	}
176	215
177		WRITE8_DEVICE_HANDLER( tc0140syt_slave_comm_w )
	216	WRITE8_MEMBER( tc0140syt_device::tc0140syt_slave_comm_w )
178	217	{
179		tc0140syt_state *tc0140syt = get_safe_token(device);
180
181	218	data &= 0x0f;
182		switch (tc0140syt->submode)
	219	switch (m_submode)
183	220	{
184	221	case 0x00:      // mode #0
185		tc0140syt->masterdata[tc0140syt->submode ++] = data;
	222	m_masterdata[m_submode ++] = data;
186	223	//logerror("taitosnd: Slave cpu written port 0, data %01x\n", data);
187	224	break;
188	225
189	226	case 0x01:      // mode #1
190		tc0140syt->masterdata[tc0140syt->submode ++] = data;
191		tc0140syt->status |= TC0140SYT_PORT01_FULL_MASTER;
192		//logerror("taitosnd: Slave cpu sends 0/1 : %01x%01x\n" , tc0140syt->masterdata[1] , tc0140syt->masterdata[0]);
193		tc0140syt->slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
	227	m_masterdata[m_submode ++] = data;
	228	m_status |= TC0140SYT_PORT01_FULL_MASTER;
	229	//logerror("taitosnd: Slave cpu sends 0/1 : %01x%01x\n" , m_masterdata[1] , m_masterdata[0]);
	230	m_slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
194	231	break;
195	232
196	233	case 0x02:      // mode #2
197	234	//logerror("taitosnd: Slave cpu written port 2, data %01x\n", data);
198		tc0140syt->masterdata[tc0140syt->submode ++] = data;
	235	m_masterdata[m_submode ++] = data;
199	236	break;
200	237
201	238	case 0x03:      // mode #3
202		tc0140syt->masterdata[tc0140syt->submode ++] = data;
203		tc0140syt->status |= TC0140SYT_PORT23_FULL_MASTER;
204		//logerror("taitosnd: Slave cpu sends 2/3 : %01x%01x\n" , tc0140syt->masterdata[3] , tc0140syt->masterdata[2]);
205		tc0140syt->slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
	239	m_masterdata[m_submode ++] = data;
	240	m_status |= TC0140SYT_PORT23_FULL_MASTER;
	241	//logerror("taitosnd: Slave cpu sends 2/3 : %01x%01x\n" , m_masterdata[3] , m_masterdata[2]);
	242	m_slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
206	243	break;
207	244
208	245	case 0x04:      // port status
209		//tc0140syt->status = TC0140SYT_SET_OK;
	246	//m_status = TC0140SYT_SET_OK;
210	247	//logerror("tc0140syt : Slave cpu status ok.\n");
211	248	break;
212	249
213	250	case 0x05:      // nmi disable
214		tc0140syt->nmi_enabled = 0;
	251	m_nmi_enabled = 0;
215	252	break;
216	253
217	254	case 0x06:      // nmi enable
218		tc0140syt->nmi_enabled = 1;
	255	m_nmi_enabled = 1;
219	256	break;
220	257
221	258	default:
222		//logerror("tc0140syt: Slave cpu written in mode [%02x] data[%02x]\n" , tc0140syt->submode, data & 0xff);
	259	//logerror("tc0140syt: Slave cpu written in mode [%02x] data[%02x]\n" , m_submode, data & 0xff);
223	260	break;
224	261	}
225	262
226		interrupt_controller(device);
	263	interrupt_controller();
227	264
228	265	}
229	266
230		READ8_DEVICE_HANDLER( tc0140syt_slave_comm_r )
	267	READ8_MEMBER( tc0140syt_device::tc0140syt_slave_comm_r )
231	268	{
232		tc0140syt_state *tc0140syt = get_safe_token(device);
233	269	UINT8 res = 0;
234	270
235		switch ( tc0140syt->submode )
	271	switch ( m_submode )
236	272	{
237	273	case 0x00:      // mode #0
238		//logerror("taitosnd: Slave cpu read slavedata %01x\n", tc0140syt->slavedata[0]);
239		res = tc0140syt->slavedata[tc0140syt->submode ++];
	274	//logerror("taitosnd: Slave cpu read slavedata %01x\n", m_slavedata[0]);
	275	res = m_slavedata[m_submode ++];
240	276	break;
241	277
242	278	case 0x01:      // mode #1
243		//logerror("taitosnd: Slave cpu receives 0/1 : %01x%01x PC=%4x\n", tc0140syt->slavedata[1] , tc0140syt->slavedata[0],space.device().safe_pc());
244		tc0140syt->status &= ~TC0140SYT_PORT01_FULL;
245		res = tc0140syt->slavedata[tc0140syt->submode ++];
	279	//logerror("taitosnd: Slave cpu receives 0/1 : %01x%01x PC=%4x\n", m_slavedata[1] , m_slavedata[0],space.device().safe_pc());
	280	m_status &= ~TC0140SYT_PORT01_FULL;
	281	res = m_slavedata[m_submode ++];
246	282	break;
247	283
248	284	case 0x02:      // mode #2
249		//logerror("taitosnd: Slave cpu read slavedata %01x\n", tc0140syt->slavedata[2]);
250		res = tc0140syt->slavedata[tc0140syt->submode ++];
	285	//logerror("taitosnd: Slave cpu read slavedata %01x\n", m_slavedata[2]);
	286	res = m_slavedata[m_submode ++];
251	287	break;
252	288
253	289	case 0x03:      // mode #3
254		//logerror("taitosnd: Slave cpu receives 2/3 : %01x%01x\n", tc0140syt->slavedata[3] , tc0140syt->slavedata[2]);
255		tc0140syt->status &= ~TC0140SYT_PORT23_FULL;
256		res = tc0140syt->slavedata[tc0140syt->submode ++];
	290	//logerror("taitosnd: Slave cpu receives 2/3 : %01x%01x\n", m_slavedata[3] , m_slavedata[2]);
	291	m_status &= ~TC0140SYT_PORT23_FULL;
	292	res = m_slavedata[m_submode ++];
257	293	break;
258	294
259	295	case 0x04:      // port status
260		//logerror("tc0140syt : Slave cpu read status : %02x\n", tc0140syt->status);
261		res = tc0140syt->status;
	296	//logerror("tc0140syt : Slave cpu read status : %02x\n", m_status);
	297	res = m_status;
262	298	break;
263	299
264	300	default:
265		//logerror("tc0140syt : Slave cpu read in mode [%02x]\n", tc0140syt->submode);
	301	//logerror("tc0140syt : Slave cpu read in mode [%02x]\n", m_submode);
266	302	res = 0;
267	303	break;
268	304	}
269	305
270		interrupt_controller(device);
	306	interrupt_controller();
271	307
272	308	return res;
273	309	}
274	310
275		/*****************************************************************************
276		DEVICE INTERFACE
277		*****************************************************************************/
278	311
279		static DEVICE_START( tc0140syt )
280		{
281		tc0140syt_state *tc0140syt = get_safe_token(device);
282		const tc0140syt_interface *intf = get_interface(device);
283
284		/* use the given gfx set */
285		tc0140syt->mastercpu = device->machine().device(intf->master);
286		tc0140syt->slavecpu = device->machine().device(intf->slave);
287
288		device->save_item(NAME(tc0140syt->mainmode));
289		device->save_item(NAME(tc0140syt->submode));
290		device->save_item(NAME(tc0140syt->status));
291		device->save_item(NAME(tc0140syt->nmi_enabled));
292		device->save_item(NAME(tc0140syt->nmi_req));
293		device->save_item(NAME(tc0140syt->slavedata));
294		device->save_item(NAME(tc0140syt->masterdata));
295		}
296
297		static DEVICE_RESET( tc0140syt )
298		{
299		tc0140syt_state *tc0140syt = get_safe_token(device);
300		int i;
301
302		tc0140syt->mainmode = 0;
303		tc0140syt->submode = 0;
304		tc0140syt->status = 0;
305		tc0140syt->nmi_enabled = 0;
306		tc0140syt->nmi_req = 0;
307
308		for (i = 0; i < 4; i++)
309		{
310		tc0140syt->slavedata[i] = 0;
311		tc0140syt->masterdata[i] = 0;
312		}
313		}
314
315		const device_type TC0140SYT = &device_creator<tc0140syt_device>;
316
317		tc0140syt_device::tc0140syt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
318		: device_t(mconfig, TC0140SYT, "Taito TC0140SYT", tag, owner, clock)
319		{
320		m_token = global_alloc_clear(tc0140syt_state);
321		}
322
323		//-------------------------------------------------
324		//  device_config_complete - perform any
325		//  operations now that the configuration is
326		//  complete
327		//-------------------------------------------------
328
329		void tc0140syt_device::device_config_complete()
330		{
331		}
332
333		//-------------------------------------------------
334		//  device_start - device-specific startup
335		//-------------------------------------------------
336
337		void tc0140syt_device::device_start()
338		{
339		DEVICE_START_NAME( tc0140syt )(this);
340		}
341
342		//-------------------------------------------------
343		//  device_reset - device-specific reset
344		//-------------------------------------------------
345
346		void tc0140syt_device::device_reset()
347		{
348		DEVICE_RESET_NAME( tc0140syt )(this);
349		}

trunk/src/mame/audio/taitosnd.h

r21620	r21621
1	1	#ifndef __TAITOSND_H__
2	2	#define __TAITOSND_H__
3	3
4		#include "devlegcy.h"
5	4	#include "devcb.h"
6	5
7		/***************************************************************************
8		TYPE DEFINITIONS
9		***************************************************************************/
	6	//**************************************************************************
	7	//  INTERFACE CONFIGURATION MACROS
	8	//**************************************************************************
10	9
	10	#define MCFG_TC0140SYT_ADD(_tag, _interface) \
	11	MCFG_DEVICE_ADD(_tag, TC0140SYT, 0) \
	12	MCFG_DEVICE_CONFIG(_interface)
	13
	14
	15	//**************************************************************************
	16	//  TYPE DEFINITIONS
	17	//**************************************************************************
	18
11	19	struct tc0140syt_interface
12	20	{
13	21	const char         *master;
14	22	const char         *slave;
15	23	};
16	24
	25
	26	// ======================> tc0140syt_device
	27
17	28	class tc0140syt_device : public device_t
18	29	{
19	30	public:
20	31	tc0140syt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
21		~tc0140syt_device() { global_free(m_token); }
	32	~tc0140syt_device() { }
22	33
23		// access to legacy token
24		void *token() const { assert(m_token != NULL); return m_token; }
25	34	protected:
26	35	// device-level overrides
27		virtual void device_config_complete();
28	36	virtual void device_start();
29	37	virtual void device_reset();
30		private:
31		// internal state
32		void *m_token;
33		};
34	38
35		extern const device_type TC0140SYT;
	39	public:
	40	// MASTER (8bit bus) control functions
	41	DECLARE_WRITE8_MEMBER( tc0140syt_port_w );
	42	DECLARE_WRITE8_MEMBER( tc0140syt_comm_w );
	43	DECLARE_READ8_MEMBER( tc0140syt_comm_r );
36	44
	45	// SLAVE (8bit bus) control functions ONLY
	46	DECLARE_WRITE8_MEMBER( tc0140syt_slave_port_w );
	47	DECLARE_READ8_MEMBER( tc0140syt_slave_comm_r );
	48	DECLARE_WRITE8_MEMBER( tc0140syt_slave_comm_w );
37	49
38		/***************************************************************************
39		DEVICE CONFIGURATION MACROS
40		***************************************************************************/
	50	private:
	51	void interrupt_controller();
41	52
42		#define MCFG_TC0140SYT_ADD(_tag, _interface) \
43		MCFG_DEVICE_ADD(_tag, TC0140SYT, 0) \
44		MCFG_DEVICE_CONFIG(_interface)
	53	private:
	54	UINT8     m_slavedata[4];  /* Data on master->slave port (4 nibbles) */
	55	UINT8     m_masterdata[4]; /* Data on slave->master port (4 nibbles) */
	56	UINT8     m_mainmode;      /* Access mode on master cpu side */
	57	UINT8     m_submode;       /* Access mode on slave cpu side */
	58	UINT8     m_status;        /* Status data */
	59	UINT8     m_nmi_enabled;   /* 1 if slave cpu has nmi's enabled */
	60	UINT8     m_nmi_req;       /* 1 if slave cpu has a pending nmi */
45	61
46		/***************************************************************************
47		DEVICE I/O FUNCTIONS
48		***************************************************************************/
	62	device_t *m_mastercpu;     /* this is the maincpu */
	63	device_t *m_slavecpu;      /* this is the audiocpu */
	64	};
49	65
50		/* MASTER (8bit bus) control functions */
51		DECLARE_WRITE8_DEVICE_HANDLER( tc0140syt_port_w );
52		DECLARE_WRITE8_DEVICE_HANDLER( tc0140syt_comm_w );
53		DECLARE_READ8_DEVICE_HANDLER( tc0140syt_comm_r );
	66	extern const device_type TC0140SYT;
54	67
55	68
56		/* SLAVE (8bit bus) control functions ONLY */
57		DECLARE_WRITE8_DEVICE_HANDLER( tc0140syt_slave_port_w );
58		DECLARE_READ8_DEVICE_HANDLER( tc0140syt_slave_comm_r );
59		DECLARE_WRITE8_DEVICE_HANDLER( tc0140syt_slave_comm_w );
60
61
62	69	#endif /*__TAITOSND_H__*/

trunk/src/emu/sound/beep.c

r21620	r21621
14	14	#include "emu.h"
15	15	#include "sound/beep.h"
16	16
	17	#define BEEP_RATE (48000)
17	18
18		#define BEEP_RATE           48000
19	19
20		struct beep_state
21		{
22		sound_stream *stream;   /* stream number */
23		int enable;             /* enable beep */
24		int frequency;          /* set frequency - this can be changed using the appropiate function */
25		int incr;               /* initial wave state */
26		INT16 signal;           /* current signal */
27		};
	20	// device type definition
	21	const device_type BEEP = &device_creator<beep_device>;
28	22
29	23
30		INLINE beep_state *get_safe_token(device_t *device)
	24	//**************************************************************************
	25	//  LIVE DEVICE
	26	//**************************************************************************
	27
	28	//-------------------------------------------------
	29	//  beep_device - constructor
	30	//-------------------------------------------------
	31
	32	beep_device::beep_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	33	: device_t(mconfig, BEEP, "Beep", tag, owner, clock),
	34	device_sound_interface(mconfig, *this),
	35	m_stream(NULL),
	36	m_enable(0),
	37	m_frequency(0),
	38	m_incr(0),
	39	m_signal(0)
31	40	{
32		assert(device != NULL);
33		assert(device->type() == BEEP);
34		return (beep_state *)downcast<beep_device *>(device)->token();
35	41	}
36	42
37	43
	44	//-------------------------------------------------
	45	//  device_start - device-specific startup
	46	//-------------------------------------------------
38	47
39		/*************************************
40		*
41		*  Stream updater
42		*
43		*************************************/
	48	void beep_device::device_start()
	49	{
	50	m_stream = stream_alloc(0, 1, BEEP_RATE);
	51	m_enable = 0;
	52	m_frequency = 3250;
	53	m_incr = 0;
	54	m_signal = 0x07fff;
	55	}
44	56
45		static STREAM_UPDATE( beep_sound_update )
	57
	58	//-------------------------------------------------
	59	//  sound_stream_update - handle a stream update
	60	//-------------------------------------------------
	61
	62	void beep_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
46	63	{
47		beep_state *bs = (beep_state *) param;
48	64	stream_sample_t *buffer = outputs[0];
49		INT16 signal = bs->signal;
	65	INT16 signal = m_signal;
50	66	int clock = 0, rate = BEEP_RATE / 2;
51	67
52	68	/* get progress through wave */
53		int incr = bs->incr;
	69	int incr = m_incr;
54	70
55		if (bs->frequency > 0)
56		clock = bs->frequency;
	71	if (m_frequency > 0)
	72	clock = m_frequency;
57	73
58	74	/* if we're not enabled, just fill with 0 */
59		if ( !bs->enable || clock == 0 )
	75	if ( !m_enable || clock == 0 )
60	76	{
61	77	memset( buffer, 0, samples * sizeof(*buffer) );
62	78	return;
r21620	r21621
75	91	}
76	92
77	93	/* store progress through wave */
78		bs->incr = incr;
79		bs->signal = signal;
	94	m_incr = incr;
	95	m_signal = signal;
80	96	}
81	97
82	98
	99	//-------------------------------------------------
	100	//  changing state to on from off will restart tone
	101	//-------------------------------------------------
83	102
84		/*************************************
85		*
86		*  Sound handler start
87		*
88		*************************************/
89
90		static DEVICE_START( beep )
	103	void beep_device::set_state(int on)
91	104	{
92		beep_state *pBeep = get_safe_token(device);
93
94		pBeep->stream = device->machine().sound().stream_alloc(*device, 0, 1, BEEP_RATE, pBeep, beep_sound_update );
95		pBeep->enable = 0;
96		pBeep->frequency = 3250;
97		pBeep->incr = 0;
98		pBeep->signal = 0x07fff;
99		}
100
101
102
103		/*************************************
104		*
105		*  changing state to on from off will restart tone
106		*
107		*************************************/
108
109		void beep_set_state(device_t *device, int on)
110		{
111		beep_state *info = get_safe_token(device);
112
113	105	/* only update if new state is not the same as old state */
114		if (info->enable == on)
	106	if (m_enable == on)
115	107	return;
116	108
117		info->stream->update();
	109	m_stream->update();
	110	m_enable = on;
118	111
119		info->enable = on;
120	112	/* restart wave from beginning */
121		info->incr = 0;
122		info->signal = 0x07fff;
	113	m_incr = 0;
	114	m_signal = 0x07fff;
123	115	}
124	116
125	117
126	118
127		/*************************************
128		*
129		*  setting new frequency starts from beginning
130		*
131		*************************************/
	119	//-------------------------------------------------
	120	//  setting new frequency starts from beginning
	121	//-------------------------------------------------
132	122
133		void beep_set_frequency(device_t *device,int frequency)
	123	void beep_device::set_frequency(int frequency)
134	124	{
135		beep_state *info = get_safe_token(device);
136
137		if (info->frequency == frequency)
	125	if (m_frequency == frequency)
138	126	return;
139	127
140		info->stream->update();
141		info->frequency = frequency;
142		info->signal = 0x07fff;
143		info->incr = 0;
	128	m_stream->update();
	129	m_frequency = frequency;
	130	m_signal = 0x07fff;
	131	m_incr = 0;
144	132	}
145	133
146	134
147	135
148		/*************************************
149		*
150		*  change a channel volume
151		*
152		*************************************/
153
154		void beep_set_volume(device_t *device, int volume)
155		{
156		beep_state *info = get_safe_token(device);
157
158		info->stream->update();
159
160		volume = 100 * volume / 7;
161
162		downcast<beep_device *>(device)->set_output_gain(0, volume);
163		}
164
165		const device_type BEEP = &device_creator<beep_device>;
166
167		beep_device::beep_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
168		: device_t(mconfig, BEEP, "Beep", tag, owner, clock),
169		device_sound_interface(mconfig, *this)
170		{
171		m_token = global_alloc_clear(beep_state);
172		}
173
174	136	//-------------------------------------------------
175		//  device_config_complete - perform any
176		//  operations now that the configuration is
177		//  complete
	137	//  change a channel volume
178	138	//-------------------------------------------------
179	139
180		void beep_device::device_config_complete()
	140	void beep_device::set_volume(int volume)
181	141	{
	142	m_stream->update();
	143	volume = 100 * volume / 7;
	144	set_output_gain(0, volume);
182	145	}
183
184		//-------------------------------------------------
185		//  device_start - device-specific startup
186		//-------------------------------------------------
187
188		void beep_device::device_start()
189		{
190		DEVICE_START_NAME( beep )(this);
191		}
192
193		//-------------------------------------------------
194		//  sound_stream_update - handle a stream update
195		//-------------------------------------------------
196
197		void beep_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
198		{
199		// should never get here
200		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
201		}

trunk/src/emu/sound/beep.h

r21620	r21621
3	3	#ifndef __BEEP_H__
4	4	#define __BEEP_H__
5	5
6		#include "devlegcy.h"
7
8	6	#define BEEPER_TAG      "beeper"
9	7
10		void beep_set_state(device_t *device, int on);
11		void beep_set_frequency(device_t *device, int frequency);
12		void beep_set_volume(device_t *device, int volume);
13	8
	9	//**************************************************************************
	10	//  TYPE DEFINITIONS
	11	//**************************************************************************
	12
	13	// ======================> beep_device
	14
14	15	class beep_device : public device_t,
15		public device_sound_interface
	16	public device_sound_interface
16	17	{
17	18	public:
18	19	beep_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
19		~beep_device() { global_free(m_token); }
	20	~beep_device() { }
20	21
21		// access to legacy token
22		void *token() const { assert(m_token != NULL); return m_token; }
23	22	protected:
24	23	// device-level overrides
25		virtual void device_config_complete();
26	24	virtual void device_start();
27	25
28	26	// sound stream update overrides
29	27	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	28
	29	public:
	30	void set_state(int on);
	31	void set_frequency(int frequency);
	32	void set_volume(int volume);
	33
30	34	private:
31		// internal state
32		void *m_token;
	35	sound_stream *m_stream;   /* stream number */
	36	int m_enable;             /* enable beep */
	37	int m_frequency;          /* set frequency - this can be changed using the appropiate function */
	38	int m_incr;               /* initial wave state */
	39	INT16 m_signal;           /* current signal */
33	40	};
34	41
35	42	extern const device_type BEEP;

trunk/src/mess/drivers/vk100.c

r21620	r21621
500	500	#ifdef LED_VERBOSE
501	501	if (BIT(data, 6)) logerror("kb keyclick bit 6 set: not emulated yet (multivibrator)!\n");
502	502	#endif
503		beep_set_state( m_speaker, BIT(data, 7));
	503	m_speaker->set_state(BIT(data, 7));
504	504	#ifdef LED_VERBOSE
505	505	logerror("LED state: %02X: %s %s %s %s %s %s\n", data&0xFF, (data&0x20)?"------- LOCAL ":"ON LINE ----- ", (data&0x10)?"--------- ":"NO SCROLL ", (data&0x8)?"----- ":"BASIC ", (data&0x4)?"--------- ":"HARD-COPY ", (data&0x2)?"-- ":"L1 ", (data&0x1)?"-- ":"L2 ");
506	506	#endif
r21620	r21621
865	865
866	866	void vk100_state::machine_start()
867	867	{
868		beep_set_frequency( m_speaker, 116 ); //116 hz (page 172 of TM), but duty cycle is wrong here!
	868	m_speaker->set_frequency(116); //116 hz (page 172 of TM), but duty cycle is wrong here!
869	869	output_set_value("online_led",1);
870	870	output_set_value("local_led", 0);
871	871	output_set_value("noscroll_led",1);

trunk/src/mess/drivers/pc2000.c

r21620	r21621
122	122
123	123	WRITE8_MEMBER( pc2000_state::beep_w )
124	124	{
125		beep_set_state(m_beep, BIT(data, 3));
	125	m_beep->set_state(BIT(data, 3));
126	126	m_beep_state = data;
127	127	}
128	128

trunk/src/mess/drivers/pc8801.c

r21620	r21621
1184	1184	m_rtc->clk_w((data & 4) >> 2);
1185	1185
1186	1186	if(((m_device_ctrl_data & 0x20) == 0x00) && ((data & 0x20) == 0x20))
1187		beep_set_state(machine().device(BEEPER_TAG),1);
	1187	machine().device<beep_device>(BEEPER_TAG)->set_state(1);
1188	1188
1189	1189	if(((m_device_ctrl_data & 0x20) == 0x20) && ((data & 0x20) == 0x00))
1190		beep_set_state(machine().device(BEEPER_TAG),0);
	1190	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1191	1191
1192	1192	if((m_device_ctrl_data & 0x40) != (data & 0x40))
1193	1193	{
r21620	r21621
1214	1214
1215	1215	/* TODO: is SING a buzzer mask? Bastard Special relies on this ... */
1216	1216	if(m_device_ctrl_data & 0x80)
1217		beep_set_state(machine().device(BEEPER_TAG),0);
	1217	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1218	1218
1219	1219	m_device_ctrl_data = data;
1220	1220	}
r21620	r21621
2475	2475	m_crtc.status = 0;
2476	2476	}
2477	2477
2478		beep_set_frequency(machine().device(BEEPER_TAG),2400);
2479		beep_set_state(machine().device(BEEPER_TAG),0);
	2478	machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
	2479	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
2480	2480
2481	2481	#ifdef USE_PROPER_I8214
2482	2482	{

trunk/src/mess/drivers/lx800.c

r21620	r21621
108	108	logerror("--> err: %d, ack: %d, fire: %d, buzzer: %d\n", BIT(data, 4), BIT(data, 5), BIT(data, 6), BIT(data, 7));
109	109
110	110	output_set_value("online_led", !BIT(data, 2));
111		beep_set_state(m_beep, !BIT(data, 7));
	111	m_beep->set_state(!BIT(data, 7));
112	112	}
113	113
114	114
r21620	r21621
146	146
147	147	void lx800_state::machine_start()
148	148	{
149		beep_set_state(m_beep, 0);
150		beep_set_frequency(m_beep, 4000); /* ? */
	149	m_beep->set_state(0);
	150	m_beep->set_frequency(4000); /* ? */
151	151	}
152	152
153	153

trunk/src/mess/drivers/zrt80.c

r21620	r21621
58	58
59	59	TIMER_CALLBACK_MEMBER(zrt80_state::zrt80_beepoff)
60	60	{
61		beep_set_state(m_beep, 0);
	61	m_beep->set_state(0);
62	62	}
63	63
64	64	WRITE8_MEMBER(zrt80_state::zrt80_30_w)
65	65	{
66	66	machine().scheduler().timer_set(attotime::from_msec(100), timer_expired_delegate(FUNC(zrt80_state::zrt80_beepoff),this));
67		beep_set_state(m_beep, 1);
	67	m_beep->set_state(1);
68	68	}
69	69
70	70	WRITE8_MEMBER(zrt80_state::zrt80_38_w)
71	71	{
72	72	machine().scheduler().timer_set(attotime::from_msec(400), timer_expired_delegate(FUNC(zrt80_state::zrt80_beepoff),this));
73		beep_set_state(m_beep, 1);
	73	m_beep->set_state(1);
74	74	}
75	75
76	76	static ADDRESS_MAP_START(zrt80_mem, AS_PROGRAM, 8, zrt80_state)
r21620	r21621
181	181
182	182	void zrt80_state::machine_reset()
183	183	{
184		beep_set_frequency(m_beep, 800);
	184	m_beep->set_frequency(800);
185	185	m_term_data = 0;
186	186	}
187	187

trunk/src/mess/drivers/sc2.c

r21620	r21621
45	45	{
46	46	m_beep_state = ~m_beep_state;
47	47
48		beep_set_state(m_beep, m_beep_state);
	48	m_beep->set_state(m_beep_state);
49	49	}
50	50
51	51	return 0xff;

trunk/src/mess/drivers/psion.c

r21620	r21621
153	153	m_kb_counter = 0;
154	154	break;
155	155	case 0x180:
156		beep_set_state(m_beep, 1);
	156	m_beep->set_state(1);
157	157	break;
158	158	case 0x1c0:
159		beep_set_state(m_beep, 0);
	159	m_beep->set_state(0);
160	160	break;
161	161	case 0x240:
162	162	if (offset == 0x260 && (m_rom_bank_count || m_ram_bank_count))

trunk/src/mess/drivers/pcw.c

r21620	r21621
407	407	WRITE8_MEMBER(pcw_state::pcw_system_control_w)
408	408	{
409	409	upd765a_device *fdc = machine().device<upd765a_device>("upd765");
410		device_t *speaker = machine().device(BEEPER_TAG);
	410	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
411	411	LOG(("SYSTEM CONTROL: %d\n",data));
412	412
413	413	switch (data)
r21620	r21621
545	545	/* beep on */
546	546	case 11:
547	547	{
548		beep_set_state(speaker,1);
	548	speaker->set_state(1);
549	549	}
550	550	break;
551	551
552	552	/* beep off */
553	553	case 12:
554	554	{
555		beep_set_state(speaker,0);
	555	speaker->set_state(0);
556	556	}
557	557	break;
558	558
r21620	r21621
996	996
997	997	TIMER_CALLBACK_MEMBER(pcw_state::setup_beep)
998	998	{
999		device_t *speaker = machine().device(BEEPER_TAG);
1000		beep_set_state(speaker, 0);
1001		beep_set_frequency(speaker, 3750);
	999	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
	1000	speaker->set_state(0);
	1001	speaker->set_frequency(3750);
1002	1002	}
1003	1003
1004	1004

trunk/src/mess/drivers/mmodular.c

r21620	r21621
243	243	m_lcdc->write(space, BIT(data,0), lcd_char);
244	244	}
245	245
246		if (BIT(data,2) || BIT(data,3)) beep_set_state(machine().device("beep"),1); else beep_set_state(machine().device("beep"),0);
	246	if (BIT(data,2) || BIT(data,3))
	247	machine().device<beep_device>("beep")->set_state(1);
	248	else
	249	machine().device<beep_device>("beep")->set_state(0);
247	250
248	251	if (BIT(data,7) && BIT(data, 4)) {
249	252	for (i = 0;i < 8;i++)
r21620	r21621
408	411
409	412	WRITE8_MEMBER(polgar_state::megaiv_write_LED)
410	413	{
411		if (BIT(data,7)) beep_set_state(machine().device("beep"),1); else beep_set_state(machine().device("beep"),0);
412		output_set_led_value(102,BIT(data,1)?1:0);
413		output_set_led_value(107,BIT(data,6)?1:0);
	414	if (BIT(data,7))
	415	machine().device<beep_device>("beep")->set_state(1);
	416	else
	417	machine().device<beep_device>("beep")->set_state(0);
	418	output_set_led_value(102,BIT(data,1)?1:0);
	419	output_set_led_value(107,BIT(data,6)?1:0);
414	420
415	421	//  logerror("LEDs  FUNC = %02x found = %d\n",data,found);
416	422	logerror("LED mask %d\n",data);
r21620	r21621
468	474	found = 1;
469	475	}
470	476
471		if (BIT(data,7)) beep_set_state(machine().device("beep"),1); else beep_set_state(machine().device("beep"),0);
472		if (BIT(data,1)) beep_set_state(machine().device("beep"),1); else beep_set_state(machine().device("beep"),0);
	477	if (BIT(data,7))
	478	machine().device<beep_device>("beep")->set_state(1);
	479	else
	480	machine().device<beep_device>("beep")->set_state(0);
	481	if (BIT(data,1))
	482	machine().device<beep_device>("beep")->set_state(1);
	483	else
	484	machine().device<beep_device>("beep")->set_state(0);
473	485	//  logerror("LEDs  FUNC = %02x found = %d\n",data,found);
474	486	if (!found) {
475	487	logerror("unknown LED mask %d\n",data);
r21620	r21621
711	723
712	724	WRITE8_MEMBER(polgar_state::beep_academy)
713	725	{
714		if (!BIT(data,7)) beep_set_state(machine().device("beep"),1); else beep_set_state(machine().device("beep"),0);
	726	if (!BIT(data,7))
	727	machine().device<beep_device>("beep")->set_state(1);
	728	else
	729	machine().device<beep_device>("beep")->set_state(0);
715	730	}
716	731
717	732	WRITE8_MEMBER(polgar_state::megaiv_IO)
r21620	r21621
863	878	void polgar_state::write_IOenable(unsigned char data,address_space &space)
864	879	{
865	880	hd44780_device * hd44780 = space.machine().device<hd44780_device>("hd44780");
866		device_t *speaker = space.machine().device("beep");
	881	beep_device *speaker = machine().device<beep_device>("beep");
867	882
868	883	if (BIT(data,5) && BIT(data,4)) {
869	884	if (BIT(data,1)) {
r21620	r21621
888	903
889	904	logerror("Write to IOENBL data: %08x\n",data);
890	905
891		if (BIT(data,2) || BIT(data,3)) beep_set_state(speaker,1); else beep_set_state(speaker,0);
	906	if (BIT(data,2) || BIT(data,3))
	907	speaker->set_state(1);
	908	else
	909	speaker->set_state(0);
892	910	}
893	911
894	912	}

trunk/src/mess/drivers/pc9801.c

r21620	r21621
3109	3109
3110	3110	WRITE8_MEMBER(pc9801_state::ppi_sys_portc_w)
3111	3111	{
3112		beep_set_state(machine().device(BEEPER_TAG),!(data & 0x08));
	3112	machine().device<beep_device>(BEEPER_TAG)->set_state(!(data & 0x08));
3113	3113	}
3114	3114
3115	3115	static I8255A_INTERFACE( ppi_system_intf )
r21620	r21621
3426	3426	m_tvram[(0x3fe0)+i*2] = default_memsw_data[i];
3427	3427	}
3428	3428
3429		beep_set_frequency(machine().device(BEEPER_TAG),2400);
3430		beep_set_state(machine().device(BEEPER_TAG),0);
	3429	machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
	3430	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
3431	3431
3432	3432	m_nmi_ff = 0;
3433	3433	m_mouse.control = 0xff;

trunk/src/mess/drivers/x07.c

r21620	r21621
1185	1185	#if(1)
1186	1186	if((data & 0x0e) == 0x0e)
1187	1187	{
1188		beep_set_state(m_beep, 1);
1189		beep_set_frequency(m_beep, 192000 / ((m_regs_w[2] | (m_regs_w[3] << 8)) & 0x0fff));
	1188	m_beep->set_state(1);
	1189	m_beep->set_frequency(192000 / ((m_regs_w[2] | (m_regs_w[3] << 8)) & 0x0fff));
1190	1190
1191	1191	m_beep_stop->adjust(attotime::from_msec(m_ram->pointer()[0x450] * 0x20));
1192	1192	}
1193	1193	else
1194		beep_set_state(m_beep, 0);
	1194	m_beep->set_state(0);
1195	1195	#endif
1196	1196	break;
1197	1197
r21620	r21621
1374	1374
1375	1375	TIMER_CALLBACK_MEMBER(x07_state::beep_stop)
1376	1376	{
1377		beep_set_state(m_beep, 0);
	1377	m_beep->set_state(0);
1378	1378	}
1379	1379
1380	1380	static const gfx_layout x07_charlayout =

trunk/src/mess/drivers/fidelz80.c

r21620	r21621
667	667
668	668	WRITE8_MEMBER( fidelz80_state::cc10_porta_w )
669	669	{
670		beep_set_state(m_beep, (data & 0x80) ? 0 : 1);
	670	m_beep->set_state((data & 0x80) ? 0 : 1);
671	671
672	672	m_digit_data = data;
673	673

trunk/src/mess/drivers/smc777.c

r21620	r21621
528	528	m_raminh_prefetch = (UINT8)(space.device().state().state_int(Z80_R)) & 0x7f;
529	529	break;
530	530	case 0x02: printf("Interlace %s\n",data & 0x10 ? "on" : "off"); break;
531		case 0x05: beep_set_state(machine().device(BEEPER_TAG),data & 0x10); break;
	531	case 0x05: machine().device<beep_device>(BEEPER_TAG)->set_state(data & 0x10); break;
532	532	default: printf("System FF W %02x\n",data); break;
533	533	}
534	534	}
r21620	r21621
990	990	m_raminh_prefetch = 0xff;
991	991	m_pal_mode = 0x10;
992	992
993		beep_set_frequency(machine().device(BEEPER_TAG),300); //TODO: correct frequency
994		beep_set_state(machine().device(BEEPER_TAG),0);
	993	machine().device<beep_device>(BEEPER_TAG)->set_frequency(300); //TODO: correct frequency
	994	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
995	995	}
996	996
997	997

trunk/src/mess/drivers/xerox820.c

r21620	r21621
199	199
200	200	TIMER_CALLBACK_MEMBER( bigboard_state::bigboard_beepoff )
201	201	{
202		beep_set_state(m_beeper, 0);
	202	m_beeper->set_state(0);
203	203	}
204	204
205	205	/* Z80 PIO */
r21620	r21621
291	291	if (BIT(data, 5) & (!m_bit5))
292	292	{
293	293	machine().scheduler().timer_set(attotime::from_msec(40), timer_expired_delegate(FUNC(bigboard_state::bigboard_beepoff),this));
294		beep_set_state(m_beeper, 1);
	294	m_beeper->set_state(1);
295	295	}
296	296	m_bit5 = BIT(data, 5);
297	297	}
r21620	r21621
599	599	bankswitch(1);
600	600
601	601	/* bigboard has a one-pulse output to drive a user-supplied beeper */
602		beep_set_state(m_beeper, 0);
603		beep_set_frequency(m_beeper, 950);
	602	m_beeper->set_state(0);
	603	m_beeper->set_frequency(950);
604	604
605	605	m_fdc->reset();
606	606	}

trunk/src/mess/drivers/micronic.c

r21620	r21621
157	157	500,  444,  400,  364,  333, 308, 286, 267
158	158	};
159	159
160		beep_set_frequency(m_beep, frequency[data & 0x0f]);
161		beep_set_state(m_beep, (data & 0x0f) ? 1 : 0);
	160	m_beep->set_frequency(frequency[data & 0x0f]);
	161	m_beep->set_state((data & 0x0f) ? 1 : 0);
162	162	}
163	163
164	164	READ8_MEMBER( micronic_state::irq_flag_r )

trunk/src/mess/drivers/glasgow.c

r21620	r21621
106	106	{
107	107	UINT16 lcd_flag = data & 0x8100;
108	108
109		beep_set_state(m_beep, BIT(lcd_flag, 8));
	109	m_beep->set_state(BIT(lcd_flag, 8));
110	110
111	111	if (lcd_flag)
112	112	m_led7 = 255;
r21620	r21621
153	153	//  UINT8 lcd_flag;
154	154	mboard_lcd_invert = 0;
155	155	//  lcd_flag=data >> 8;
156		//beep_set_state(0, (data >> 8) & 1 ? 1 : 0);
	156	//m_beep->set_state((data >> 8) & 1 ? 1 : 0);
157	157	if ((data >> 8) == 0)
158	158	{
159	159	mboard_key_selector = 1;
r21620	r21621
175	175
176	176	WRITE16_MEMBER( glasgow_state::write_irq_flag )
177	177	{
178		beep_set_state(m_beep, data & 0x100);
	178	m_beep->set_state(data & 0x100);
179	179	logerror("Write 0x800004 = %x \n", data);
180	180	m_irq_flag = 1;
181	181	m_beeper = data;
r21620	r21621
236	236
237	237
238	238	//logerror("LCD Flag 32 = %x \n", data >> 24);
239		//beep_set_state(0, (data >> 24) & 1 ? 1 : 0);
	239	//m_beep->set_state((data >> 24) & 1 ? 1 : 0);
240	240
241	241	//  if (lcd_flag != 0)
242	242	//      m_led7 = 255;
r21620	r21621
269	269
270	270	WRITE32_MEMBER( glasgow_state::write_beeper32 )
271	271	{
272		beep_set_state(m_beep, data & 0x01000000);
	272	m_beep->set_state(data & 0x01000000);
273	273	logerror("Write 0x8000004 = %x \n", data);
274	274	m_irq_flag = 1;
275	275	m_beeper = data;
r21620	r21621
290	290	mboard_key_selector = 0;
291	291	m_irq_flag = 0;
292	292	m_lcd_shift_counter = 3;
293		beep_set_frequency(m_beep, 44);
	293	m_beep->set_frequency(44);
294	294
295	295	mboard_savestate_register();
296	296	}
r21620	r21621
299	299	MACHINE_START_MEMBER(glasgow_state,dallas32)
300	300	{
301	301	m_lcd_shift_counter = 3;
302		beep_set_frequency(m_beep, 44);
	302	m_beep->set_frequency(44);
303	303
304	304	mboard_savestate_register();
305	305	}

trunk/src/mess/drivers/mz2500.c

r21620	r21621
1806	1806
1807	1807	m_cg_clear_flag = 0;
1808	1808
1809		beep_set_frequency(machine().device(BEEPER_TAG),4096);
1810		beep_set_state(machine().device(BEEPER_TAG),0);
	1809	machine().device<beep_device>(BEEPER_TAG)->set_frequency(4096);
	1810	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1811	1811
1812	1812	//  m_monitor_type = machine().root_device().ioport("DSW1")->read() & 0x40 ? 1 : 0;
1813	1813	}
r21620	r21621
1921	1921
1922	1922	m_old_portc = data;
1923	1923
1924		beep_set_state(machine().device(BEEPER_TAG),data & 0x04);
	1924	machine().device<beep_device>(BEEPER_TAG)->set_state(data & 0x04);
1925	1925
1926	1926	m_screen_enable = data & 1;
1927	1927

trunk/src/mess/drivers/multi8.c

r21620	r21621
629	629
630	630	WRITE8_MEMBER( multi8_state::ym2203_porta_w )
631	631	{
632		beep_set_state(m_beep, (data & 0x08));
	632	m_beep->set_state((data & 0x08));
633	633	}
634	634
635	635	static const ym2203_interface ym2203_config =
r21620	r21621
655	655
656	656	void multi8_state::machine_reset()
657	657	{
658		beep_set_frequency(machine().device(BEEPER_TAG),1200); //guesswork
659		beep_set_state(machine().device(BEEPER_TAG),0);
	658	machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200); //guesswork
	659	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
660	660	m_mcu_init = 0;
661	661	}
662	662

trunk/src/mess/drivers/studio2.c

r21620	r21621
446	446
447	447	WRITE_LINE_MEMBER( studio2_state::q_w )
448	448	{
449		beep_set_state(m_speaker, state);
	449	m_speaker->set_state(state);
450	450	}
451	451
452	452	static COSMAC_INTERFACE( studio2_cosmac_intf )
r21620	r21621
629	629
630	630	TIMER_CALLBACK_MEMBER(studio2_state::setup_beep)
631	631	{
632		device_t *speaker = machine().device(BEEPER_TAG);
633		beep_set_state(speaker, 0);
634		beep_set_frequency(speaker, 300);
	632	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
	633	speaker->set_state(0);
	634	speaker->set_frequency(300);
635	635	}
636	636
637	637	DRIVER_INIT_MEMBER(studio2_state,studio2)

trunk/src/mess/drivers/tmc1800.c

r21620	r21621
112	112	*/
113	113
114	114	#include "includes/tmc1800.h"
	115	#include "sound/beep.h"
115	116
116	117	/* Read/Write Handlers */
117	118
r21620	r21621
907	908
908	909	TIMER_CALLBACK_MEMBER(tmc1800_state::setup_beep)
909	910	{
910		device_t *speaker = machine().device(BEEPER_TAG);
911		beep_set_state(speaker, 0);
912		beep_set_frequency( speaker, 0 );
	911	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
	912	speaker->set_state(0);
	913	speaker->set_frequency(0);
913	914	}
914	915
915	916	DRIVER_INIT_MEMBER(tmc1800_state,tmc1800)

trunk/src/mess/drivers/h8.c

r21620	r21621
102	102	if (m_digit) output_set_digit_value(m_digit, m_segment);
103	103
104	104	output_set_value("mon_led",(data & 0x20) ? 0 : 1);
105		beep_set_state(m_beep, (data & 0x80) ? 0 : 1);
	105	m_beep->set_state((data & 0x80) ? 0 : 1);
106	106
107	107	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
108	108	m_irq_ctl &= 0xf0;
r21620	r21621
167	167
168	168	void h8_state::machine_reset()
169	169	{
170		beep_set_frequency(m_beep, H8_BEEP_FRQ);
	170	m_beep->set_frequency(H8_BEEP_FRQ);
171	171	output_set_value("pwr_led", 0);
172	172	m_irq_ctl = 1;
173	173	}

trunk/src/mess/drivers/h19.c

r21620	r21621
73	73
74	74	TIMER_CALLBACK_MEMBER(h19_state::h19_beepoff)
75	75	{
76		beep_set_state(m_beep, 0);
	76	m_beep->set_state(0);
77	77	}
78	78
79	79	READ8_MEMBER( h19_state::h19_80_r )
r21620	r21621
99	99	offset 20-3F = terminal bell */
100	100
101	101	UINT8 length = (offset & 0x20) ? 200 : 4;
102		beep_set_state(m_beep, 1);
	102	m_beep->set_state(1);
103	103	machine().scheduler().timer_set(attotime::from_msec(length), timer_expired_delegate(FUNC(h19_state::h19_beepoff),this));
104	104	}
105	105
r21620	r21621
291	291
292	292	void h19_state::machine_reset()
293	293	{
294		beep_set_frequency(m_beep, H19_BEEP_FRQ);
	294	m_beep->set_frequency(H19_BEEP_FRQ);
295	295	}
296	296
297	297	void h19_state::video_start()

trunk/src/mess/drivers/vt100.c

r21620	r21621
145	145
146	146	WRITE8_MEMBER( vt100_state::vt100_keyboard_w )
147	147	{
148		beep_set_frequency( m_speaker, 786 ); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
	148	m_speaker->set_frequency(786); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
149	149	output_set_value("online_led",BIT(data, 5) ? 0 : 1);
150	150	output_set_value("local_led", BIT(data, 5));
151	151	output_set_value("locked_led",BIT(data, 4) ? 0 : 1);
r21620	r21621
154	154	output_set_value("l3_led", BIT(data, 1) ? 0 : 1);
155	155	output_set_value("l4_led", BIT(data, 0) ? 0 : 1);
156	156	m_key_scan = BIT(data, 6);
157		beep_set_state( m_speaker, BIT(data, 7));
	157	m_speaker->set_state(BIT(data, 7));
158	158	}
159	159
160	160	READ8_MEMBER( vt100_state::vt100_keyboard_r )
r21620	r21621
353	353	m_keyboard_int = 0;
354	354	m_receiver_int = 0;
355	355	m_vertical_int = 0;
356		beep_set_frequency( m_speaker, 786 ); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
	356	m_speaker->set_frequency(786); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
357	357	output_set_value("online_led",1);
358	358	output_set_value("local_led", 0);
359	359	output_set_value("locked_led",1);

trunk/src/mess/drivers/pce220.c

r21620	r21621
376	376
377	377	WRITE8_MEMBER( pce220_state::port18_w )
378	378	{
379		beep_set_state(m_beep, BIT(data, 7));
	379	m_beep->set_state(BIT(data, 7));
380	380
381	381	m_serial->out_busy(BIT(data, 0));
382	382	m_serial->out_dout(BIT(data, 1));

trunk/src/mess/drivers/bmjr.c

r21620	r21621
133	133	{
134	134	if(!m_tape_switch)
135	135	{
136		beep_set_state(m_beep, !BIT(data, 7));
	136	m_beep->set_state(!BIT(data, 7));
137	137	}
138	138	else
139	139	{
r21620	r21621
333	333
334	334	void bmjr_state::machine_start()
335	335	{
336		beep_set_frequency(m_beep, 1200); //guesswork
337		beep_set_state(m_beep, 0);
	336	m_beep->set_frequency(1200); //guesswork
	337	m_beep->set_state(0);
338	338	}
339	339
340	340	void bmjr_state::machine_reset()

trunk/src/mess/drivers/osi.c

r21620	r21621
339	339
340	340	*/
341	341
342		beep_set_state(m_beep, BIT(data, 1));
	342	m_beep->set_state(BIT(data, 1));
343	343	}
344	344
345	345	WRITE8_MEMBER( c1p_state::osi630_sound_w )
346	346	{
347		if (data) beep_set_frequency(m_beep, 49152 / data);
	347	if (data) m_beep->set_frequency(49152 / data);
348	348	}
349	349
350	350	/* Disk Drive */
r21620	r21621
933	933
934	934	TIMER_CALLBACK_MEMBER(sb2m600_state::setup_beep)
935	935	{
936		device_t *speaker = machine().device(BEEPER_TAG);
937		beep_set_state(speaker, 0);
938		beep_set_frequency(speaker, 300);
	936	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
	937	speaker->set_state(0);
	938	speaker->set_frequency(300);
939	939	}
940	940
941	941	DRIVER_INIT_MEMBER(c1p_state,c1p)

trunk/src/mess/drivers/pc100.c

r21620	r21621
217	217	if(offset == 0)
218	218	{
219	219	m_timer_mode = (data & 0x18) >> 3;
220		beep_set_state(machine().device(BEEPER_TAG),((data & 0x40) >> 6) ^ 1);
	220	machine().device<beep_device>(BEEPER_TAG)->set_state(((data & 0x40) >> 6) ^ 1);
221	221	printf("%02x\n",data & 0xc0);
222	222	}
223	223	}
r21620	r21621
427	427
428	428	void pc100_state::machine_reset()
429	429	{
430		beep_set_frequency(machine().device(BEEPER_TAG),2400);
431		beep_set_state(machine().device(BEEPER_TAG),0);
	430	machine().device<beep_device>(BEEPER_TAG)->set_frequency(2400);
	431	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
432	432	}
433	433
434	434	INTERRUPT_GEN_MEMBER(pc100_state::pc100_vblank_irq)

trunk/src/mess/drivers/pb1000.c

r21620	r21621
443	443
444	444	static void port_w(hd61700_cpu_device &device, UINT8 data)
445	445	{
446		beep_set_state(device.machine().device(BEEPER_TAG), (BIT(data,7) ^ BIT(data,6)));
	446	device.machine().device<beep_device>(BEEPER_TAG)->set_state((BIT(data,7) ^ BIT(data,6)));
447	447	//printf("%x\n", data);
448	448	}
449	449

trunk/src/mess/drivers/mz2000.c

r21620	r21621
120	120	required_device<cpu_device> m_maincpu;
121	121	required_device<device_t> m_mb8877a;
122	122	required_device<device_t> m_pit8253;
123		required_device<device_t> m_beeper;
	123	required_device<beep_device> m_beeper;
124	124	required_memory_region m_region_tvram;
125	125	required_memory_region m_region_gvram;
126	126	required_memory_region m_region_chargen;
r21620	r21621
555	555	m_tvram_enable = 0;
556	556	m_gvram_enable = 0;
557	557
558		beep_set_frequency(m_beeper,4096);
559		beep_set_state(m_beeper,0);
	558	m_beeper->set_frequency(4096);
	559	m_beeper->set_state(0);
560	560
561	561	m_color_mode = m_io_config->read() & 1;
562	562	m_has_fdc = (m_io_config->read() & 2) >> 1;
r21620	r21621
732	732	m_maincpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
733	733	}
734	734
735		beep_set_state(m_beeper,data & 0x04);
	735	m_beeper->set_state(data & 0x04);
736	736
737	737	m_old_portc = data;
738	738	}

trunk/src/mess/drivers/nc.c

r21620	r21621
672	672	int on;
673	673	int frequency;
674	674	int period;
675		const char *beep_device = NULL;
	675	const char *beeper_device = NULL;
676	676
677	677	switch(channel)
678	678	{
679	679	case 0:
680		beep_device = "beep.1";
	680	beeper_device = "beep.1";
681	681	break;
682	682	case 1:
683		beep_device = "beep.2";
	683	beeper_device = "beep.2";
684	684	break;
685	685	}
686	686
r21620	r21621
693	693	frequency = (int)(1000000.0f/((float)((period & 0x07fff)<<1) * 1.6276f));
694	694
695	695	/* set state */
696		beep_set_state(machine.device(beep_device), on);
	696	machine.device<beep_device>(beeper_device)->set_state(on);
697	697	/* set frequency */
698		beep_set_frequency(machine.device(beep_device), frequency);
	698	machine.device<beep_device>(beeper_device)->set_frequency(frequency);
699	699	}
700	700
701	701	WRITE8_MEMBER(nc_state::nc_sound_w)

trunk/src/mess/drivers/mephisto.c

r21620	r21621
393	393	m_allowNMI = 0;
394	394	m_maincpu->set_input_line(INPUT_LINE_NMI,PULSE_LINE);
395	395	}
396		beep_set_state(m_beep, m_led_status&64?1:0);
	396	m_beep->set_state(m_led_status&64?1:0);
397	397	}
398	398
399	399	TIMER_DEVICE_CALLBACK_MEMBER(mephisto_state::update_nmi_r5)
400	400	{
401	401	m_maincpu->set_input_line(INPUT_LINE_NMI,PULSE_LINE);
402		beep_set_state(m_beep, m_led_status&64?1:0);
	402	m_beep->set_state(m_led_status&64?1:0);
403	403	}
404	404
405	405	TIMER_DEVICE_CALLBACK_MEMBER(mephisto_state::update_irq)//only mm2
406	406	{
407	407	m_maincpu->set_input_line(M65C02_IRQ_LINE, HOLD_LINE);
408	408
409		beep_set_state(m_beep, m_led_status&64?1:0);
	409	m_beep->set_state(m_led_status&64?1:0);
410	410	}
411	411
412	412	void mephisto_state::machine_start()

trunk/src/mess/drivers/fm7.c

r21620	r21621
236	236
237	237	TIMER_CALLBACK_MEMBER(fm7_state::fm7_beeper_off)
238	238	{
239		beep_set_state(machine().device(BEEPER_TAG),0);
	239	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
240	240	logerror("timed beeper off\n");
241	241	}
242	242
r21620	r21621
246	246
247	247	if(!m_speaker_active)  // speaker not active, disable all beeper sound
248	248	{
249		beep_set_state(machine().device(BEEPER_TAG),0);
	249	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
250	250	return;
251	251	}
252	252
253	253	if(data & 0x80)
254	254	{
255	255	if(m_speaker_active)
256		beep_set_state(machine().device(BEEPER_TAG),1);
	256	machine().device<beep_device>(BEEPER_TAG)->set_state(1);
257	257	}
258	258	else
259		beep_set_state(machine().device(BEEPER_TAG),0);
	259	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
260	260
261	261	if(data & 0x40)
262	262	{
263	263	if(m_speaker_active)
264	264	{
265		beep_set_state(machine().device(BEEPER_TAG),1);
	265	machine().device<beep_device>(BEEPER_TAG)->set_state(1);
266	266	logerror("timed beeper on\n");
267	267	machine().scheduler().timer_set(attotime::from_msec(205), timer_expired_delegate(FUNC(fm7_state::fm7_beeper_off),this));
268	268	}
r21620	r21621
279	279	{
280	280	if(m_speaker_active)
281	281	{
282		beep_set_state(machine().device(BEEPER_TAG),1);
	282	machine().device<beep_device>(BEEPER_TAG)->set_state(1);
283	283	logerror("timed beeper on\n");
284	284	machine().scheduler().timer_set(attotime::from_msec(205), timer_expired_delegate(FUNC(fm7_state::fm7_beeper_off),this));
285	285	}
r21620	r21621
1848	1848	memset(m_shared_ram,0xff,0x80);
1849	1849	m_type = SYS_FM7;
1850	1850
1851		beep_set_frequency(machine().device(BEEPER_TAG),1200);
1852		beep_set_state(machine().device(BEEPER_TAG),0);
	1851	machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
	1852	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1853	1853	}
1854	1854
1855	1855	MACHINE_START_MEMBER(fm7_state,fm77av)
r21620	r21621
1869	1869	membank("bank21")->set_base(RAM+0x800);
1870	1870
1871	1871	m_type = SYS_FM77AV;
1872		beep_set_frequency(machine().device(BEEPER_TAG),1200);
1873		beep_set_state(machine().device(BEEPER_TAG),0);
	1872	machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
	1873	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1874	1874	}
1875	1875
1876	1876	MACHINE_START_MEMBER(fm7_state,fm11)
r21620	r21621
1880	1880
1881	1881	memset(m_shared_ram,0xff,0x80);
1882	1882	m_type = SYS_FM11;
1883		beep_set_frequency(machine().device(BEEPER_TAG),1200);
1884		beep_set_state(machine().device(BEEPER_TAG),0);
	1883	machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
	1884	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1885	1885	// last part of Initiate ROM is visible at the end of RAM too (interrupt vectors)
1886	1886	memcpy(RAM+0x3fff0,ROM+0x0ff0,16);
1887	1887	}
r21620	r21621
1889	1889	MACHINE_START_MEMBER(fm7_state,fm16)
1890	1890	{
1891	1891	m_type = SYS_FM16;
1892		beep_set_frequency(machine().device(BEEPER_TAG),1200);
1893		beep_set_state(machine().device(BEEPER_TAG),0);
	1892	machine().device<beep_device>(BEEPER_TAG)->set_frequency(1200);
	1893	machine().device<beep_device>(BEEPER_TAG)->set_state(0);
1894	1894	}
1895	1895
1896	1896	void fm7_state::machine_reset()

trunk/src/mess/drivers/bml3.c

r21620	r21621
364	364
365	365	WRITE8_MEMBER( bml3_state::bml3_beep_w)
366	366	{
367		beep_set_state(m_beep,!BIT(data, 7));
	367	m_beep->set_state(!BIT(data, 7));
368	368	}
369	369
370	370	READ8_MEMBER( bml3_state::bml3_a000_r) { return m_extram[offset + 0xa000]; }
r21620	r21621
632	632
633	633	void bml3_state::machine_start()
634	634	{
635		beep_set_frequency(machine().device(BEEPER_TAG),1200); //guesswork
636		beep_set_state(machine().device(BEEPER_TAG),0);
	635	m_beep->set_frequency(1200); //guesswork
	636	m_beep->set_state(0);
637	637	m_extram = auto_alloc_array(machine(),UINT8,0x10000);
638	638	}
639	639

trunk/src/mess/drivers/supercon.c

r21620	r21621
566	566
567	567	if ( m_data_1F00 & 0x80 )
568	568	{
569		beep_set_state(m_beep, 1);
	569	m_beep->set_state(1);
570	570	m_emu_started=TRUE;
571	571	}
572	572	else
573		beep_set_state(m_beep ,0);
	573	m_beep->set_state(0);
574	574	}
575	575
576	576	TIMER_CALLBACK_MEMBER(supercon_state::mouse_click)

trunk/src/mess/drivers/ex800.c

r21620	r21621
206	206	void ex800_state::machine_start()
207	207	{
208	208	m_irq_state = ASSERT_LINE;
209		device_t *speaker = machine().device(BEEPER_TAG);
	209	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
210	210	/* Setup beep */
211		beep_set_state(speaker, 0);
212		beep_set_frequency(speaker, 4000); /* measured at 4000 Hz */
	211	speaker->set_state(0);
	212	speaker->set_frequency(4000); /* measured at 4000 Hz */
213	213	}
214	214
215	215
r21620	r21621
265	265
266	266	WRITE8_MEMBER(ex800_state::ex800_portc_w)
267	267	{
268		device_t *speaker = machine().device(BEEPER_TAG);
	268	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
269	269	if (data & 0x80)
270		beep_set_state(speaker, 0);
	270	speaker->set_state(0);
271	271	else
272		beep_set_state(speaker, 1);
	272	speaker->set_state(1);
273	273
274	274	logerror("PC W %x @%x\n", data, space.device().safe_pc());
275	275	}

trunk/src/mess/drivers/alphatro.c

r21620	r21621
76	76
77	77	TIMER_CALLBACK_MEMBER(alphatro_state::alphatro_beepoff)
78	78	{
79		beep_set_state(m_beep, 0);
	79	m_beep->set_state(0);
80	80	}
81	81
82	82	READ8_MEMBER( alphatro_state::port10_r )
r21620	r21621
102	102	if (length)
103	103	{
104	104	machine().scheduler().timer_set(attotime::from_msec(length), timer_expired_delegate(FUNC(alphatro_state::alphatro_beepoff),this));
105		beep_set_state(m_beep, 1);
	105	m_beep->set_state(1);
106	106	}
107	107
108	108	m_cass->change_state( BIT(data, 3) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
r21620	r21621
360	360	m_sys_timer->adjust(attotime::from_usec(10),0,attotime::from_usec(10));
361	361	m_serial_timer->adjust(attotime::from_hz(500),0,attotime::from_hz(500));  // USART clock - this is a guesstimate
362	362	m_timer_bit = 0;
363		beep_set_state(m_beep, 0);
364		beep_set_frequency(m_beep, 950);    /* piezo-device needs to be measured */
	363	m_beep->set_state(0);
	364	m_beep->set_frequency(950);    /* piezo-device needs to be measured */
365	365	}
366	366
367	367	void alphatro_state::palette_init()

trunk/src/mess/drivers/z9001.c

r21620	r21621
129	129	//Bits0,1 not connected; 2,3,4,5 go to a connector; 6 goes to 'graphics' LED; 7 goes to speaker.
130	130	WRITE8_MEMBER( z9001_state::port88_w )
131	131	{
132		beep_set_state(m_beeper, BIT(data, 7));
	132	m_beeper->set_state(BIT(data, 7));
133	133	}
134	134
135	135	WRITE_LINE_MEMBER( z9001_state::cass_w )
r21620	r21621
150	150
151	151	void z9001_state::machine_reset()
152	152	{
153		beep_set_frequency(m_beeper, 800);
	153	m_beeper->set_frequency(800);
154	154	m_maincpu->set_state_int(Z80_PC, 0xf000);
155	155	}
156	156

trunk/src/mess/drivers/pc4.c

r21620	r21621
52	52
53	53	WRITE8_MEMBER( pc4_state::beep_w )
54	54	{
55		beep_set_state(m_beep, data&0x40);
	55	m_beep->set_state(data&0x40);
56	56	}
57	57
58	58	static ADDRESS_MAP_START(pc4_mem, AS_PROGRAM, 8, pc4_state)

trunk/src/mess/drivers/jr100.c

r21620	r21621
68	68	protected:
69	69	required_device<via6522_device> m_via;
70	70	required_device<cassette_image_device> m_cassette;
71		required_device<device_t> m_beeper;
	71	required_device<beep_device> m_beeper;
72	72	required_device<device_t> m_speaker;
73	73	required_memory_region m_region_maincpu;
74	74	required_ioport m_line0;
r21620	r21621
94	94	m_beep_en = ((data & 0xe0) == 0xe0);
95	95
96	96	if(!m_beep_en)
97		beep_set_state(m_beeper,0);
	97	m_beeper->set_state(0);
98	98	}
99	99
100	100	/* T1L-L */
r21620	r21621
113	113	/* writing here actually enables the beeper, if above masking condition is satisfied */
114	114	if(m_beep_en)
115	115	{
116		beep_set_state(m_beeper,1);
117		beep_set_frequency(m_beeper,894886.25 / (double)(m_t1latch) / 2.0);
	116	m_beeper->set_state(1);
	117	m_beeper->set_frequency(894886.25 / (double)(m_t1latch) / 2.0);
118	118	}
119	119	}
120	120	m_via->write(space,offset,data);
r21620	r21621
198	198
199	199	void jr100_state::machine_start()
200	200	{
201		beep_set_frequency(m_beeper,0);
202		beep_set_state(m_beeper,0);
	201	m_beeper->set_frequency(0);
	202	m_beeper->set_state(0);
203	203	}
204	204
205	205	void jr100_state::machine_reset()

trunk/src/mess/drivers/rex6000.c

r21620	r21621
233	233	case 1:     //tone mode control
234	234	if (m_beep_mode)
235	235	{
236		beep_set_state(m_beep, BIT(data, 0));
	236	m_beep->set_state(BIT(data, 0));
237	237
238	238	//the beeper frequency is update only if the bit 1 is set
239	239	if (BIT(data, 1))
240		beep_set_frequency(m_beep, 16384 / (((m_beep_io[2] | (m_beep_io[3]<<8)) & 0x0fff) + 2));
	240	m_beep->set_frequency(16384 / (((m_beep_io[2] | (m_beep_io[3]<<8)) & 0x0fff) + 2));
241	241	}
242	242	break;
243	243	case 4:     //select alarm/tone mode
244	244	if (m_beep_mode != BIT(data, 0))
245		beep_set_state(m_beep, 0);      //turned off when mode changes
	245	m_beep->set_state(0);      //turned off when mode changes
246	246
247	247	m_beep_mode = BIT(data, 0);
248	248	break;

trunk/src/mess/drivers/a5105.c

r21620	r21621
222	222	break;
223	223
224	224	case 6:
225		beep_set_state(m_beep, BIT(data, 0));
	225	m_beep->set_state(BIT(data, 0));
226	226	break;
227	227	}
228	228	}
r21620	r21621
482	482	{
483	483	address_space &space = m_maincpu->space(AS_PROGRAM);
484	484	a5105_ab_w(space, 0, 9); // turn motor off
485		beep_set_frequency(m_beep, 500);
	485	m_beep->set_frequency(500);
486	486
487	487	m_ram_base = (UINT8*)machine().device<ram_device>(RAM_TAG)->pointer();
488	488	m_rom_base = (UINT8*)machine().root_device().memregion("maincpu")->base();

trunk/src/mess/drivers/pcw16.c

r21620	r21621
842	842	/* bleeper on */
843	843	case 0x0b:
844	844	{
845		beep_set_state(m_speaker,1);
	845	m_speaker->set_state(1);
846	846	}
847	847	break;
848	848
849	849	/* bleeper off */
850	850	case 0x0c:
851	851	{
852		beep_set_state(m_speaker,0);
	852	m_speaker->set_state(0);
853	853	}
854	854	break;
855	855
r21620	r21621
1005	1005
1006	1006	void pcw16_state::machine_start()
1007	1007	{
1008		device_t *speaker = machine().device(BEEPER_TAG);
	1008	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
1009	1009	m_system_status = 0;
1010	1010	m_interrupt_counter = 0;
1011	1011
r21620	r21621
1015	1015	at_keyboard_init(machine(), AT_KEYBOARD_TYPE_AT);
1016	1016	at_keyboard_set_scan_code_set(3);
1017	1017
1018		beep_set_state(speaker,0);
1019		beep_set_frequency(speaker,3750);
	1018	speaker->set_state(0);
	1019	speaker->set_frequency(3750);
1020	1020	}
1021	1021
1022	1022	static INPUT_PORTS_START(pcw16)

trunk/src/mess/drivers/bigbord2.c

r21620	r21621
285	285	break;
286	286	case 7:
287	287	// beeper
288		beep_set_state(m_beeper, m_c8[7]);
	288	m_beeper->set_state(m_c8[7]);
289	289	break;
290	290	}
291	291	}
r21620	r21621
556	556	UINT8 i;
557	557	for (i = 0; i < 8; i++)
558	558	m_c8[i] = 0;
559		beep_set_state(m_beeper, 0);
560		beep_set_frequency(m_beeper, 950); // actual frequency is unknown
	559	m_beeper->set_state(0);
	560	m_beeper->set_frequency(950); // actual frequency is unknown
561	561	membank("bankr")->set_entry(0);
562	562	membank("bankv")->set_entry(0);
563	563	membank("banka")->set_entry(0);

trunk/src/mess/drivers/jr200.c

r21620	r21621
73	73
74	74	protected:
75	75	required_device<cpu_device> m_maincpu;
76		required_device<device_t> m_beeper;
	76	required_device<beep_device> m_beeper;
77	77	required_memory_region m_pcg;
78	78	required_memory_region m_gfx_rom;
79	79	required_memory_region m_gfx_ram;
r21620	r21621
297	297	WRITE8_MEMBER(jr200_state::jr200_beep_w)
298	298	{
299	299	/* writing 0x0e enables the beeper, writing anything else disables it */
300		beep_set_state(m_beeper,((data & 0xf) == 0x0e) ? 1 : 0);
	300	m_beeper->set_state(((data & 0xf) == 0x0e) ? 1 : 0);
301	301	}
302	302
303	303	WRITE8_MEMBER(jr200_state::jr200_beep_freq_w)
r21620	r21621
308	308
309	309	beep_freq = ((m_freq_reg[0]<<8) | (m_freq_reg[1] & 0xff)) + 1;
310	310
311		beep_set_frequency(m_beeper,84000 / beep_freq);
	311	m_beeper->set_frequency(84000 / beep_freq);
312	312	}
313	313
314	314	WRITE8_MEMBER(jr200_state::jr200_border_col_w)
r21620	r21621
516	516
517	517	void jr200_state::machine_start()
518	518	{
519		beep_set_frequency(m_beeper,0);
520		beep_set_state(m_beeper,0);
	519	m_beeper->set_frequency(0);
	520	m_beeper->set_state(0);
521	521	m_timer_d = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(jr200_state::timer_d_callback),this));
522	522	}
523	523

trunk/src/mess/machine/kay_kbd.c

r21620	r21621
66	66
67	67	struct kay_kbd_t
68	68	{
69		device_t *beeper;
	69	beep_device *beeper;
70	70	UINT8 buff[16];
71	71	UINT8 head;
72	72	UINT8 tail;
r21620	r21621
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(BEEPER_TAG);
	290	kbd->beeper = machine().device<beep_device>(BEEPER_TAG);
291	291	kbd->beep_on = 1;
292	292	kbd->control_status = 0x14;
293		beep_set_state(kbd->beeper, 0);
294		beep_set_frequency(kbd->beeper, 950);   /* piezo-device needs to be measured */
	293	kbd->beeper->set_state(0);
	294	kbd->beeper->set_frequency(950);   /* piezo-device needs to be measured */
295	295	kbd->head = kbd->tail = 0;          /* init buffer */
296	296	}
297	297
r21620	r21621
471	471	{
472	472	kaypro_state *state = machine.driver_data<kaypro_state>();
473	473	kay_kbd_t *kbd = state->m_kbd;
474		beep_set_state(kbd->beeper, 0);
	474	kbd->beeper->set_state(0);
475	475	kbd->control_status |= 4;
476	476	}
477	477
r21620	r21621
509	509	{
510	510	kbd->control_status &= 0xfb;
511	511	machine.scheduler().timer_set(attotime::from_msec(length), FUNC(kay_kbd_beepoff));
512		beep_set_state(kbd->beeper, 1);
	512	kbd->beeper->set_state(1);
513	513	}
514	514	}
515	515	}

trunk/src/mess/machine/osborne1.c

r21620	r21621
389	389
390	390	if ( (ra==2) || (ra== 6) )
391	391	{
392		beep_set_state( m_beep, m_beep_state );
	392	m_beep->set_state( m_beep_state );
393	393	}
394	394	else
395	395	{
396		beep_set_state( m_beep, 0 );
	396	m_beep->set_state( 0 );
397	397	}
398	398
399	399	m_video_timer->adjust(machine().primary_screen->time_until_pos(y + 1, 0 ));
r21620	r21621
401	401
402	402	TIMER_CALLBACK_MEMBER(osborne1_state::setup_osborne1)
403	403	{
404		beep_set_state( m_beep, 0 );
405		beep_set_frequency( m_beep, 300 /* 60 * 240 / 2 */ );
	404	m_beep->set_state( 0 );
	405	m_beep->set_frequency( 300 /* 60 * 240 / 2 */ );
406	406	m_pia1->ca1_w(0);
407	407	}
408	408

trunk/src/mess/machine/apollo_kbd.c

r21620	r21621
185	185	{
186	186	m_device = device;
187	187	LOG2(("start apollo_kbd::beeper"));
188		m_beeper = m_device->machine().device("beep");
	188	m_beeper = m_device->machine().device<beep_device>("beep");
189	189	m_timer = m_device->machine().scheduler().timer_alloc(FUNC(static_beeper_callback), this);
190	190	}
191	191
r21620	r21621
197	197
198	198	void apollo_kbd_device::beeper::off()
199	199	{
200		beep_set_state(m_beeper, 0);
	200	m_beeper->set_state(0);
201	201	}
202	202
203	203	void apollo_kbd_device::beeper::on()
204	204	{
205	205	if (keyboard_has_beeper())
206	206	{
207		beep_set_frequency(m_beeper, 1000);
208		beep_set_state(m_beeper, 1);
	207	m_beeper->set_frequency(1000);
	208	m_beeper->set_state(1);
209	209	m_timer->adjust( attotime::from_msec(10), 0, attotime::zero);
210	210	}
211	211	}
r21620	r21621
223	223
224	224	TIMER_CALLBACK( apollo_kbd_device::beeper::static_beeper_callback )
225	225	{
226		reinterpret_cast<beeper *> (ptr)->beeper_callback();
	226	reinterpret_cast<beeper*>(ptr)->beeper_callback();
227	227	}
228	228
229	229	//**************************************************************************

trunk/src/mess/machine/apollo_kbd.h

r21620	r21621
15	15	#define __APOLLO_KBD_H__
16	16
17	17	#include "emu.h"
	18	#include "sound/beep.h"
18	19
19	20	// BSD-derived systems get very sad when you party with system reserved names.
20	21	#ifdef getchar
r21620	r21621
105	106	static TIMER_CALLBACK( static_beeper_callback );
106	107
107	108	apollo_kbd_device *m_device; // pointer back to our device
108		device_t *m_beeper; // the keyboard beeper device
	109	beep_device *m_beeper; // the keyboard beeper device
109	110	emu_timer * m_timer; // timer to clock data in
110	111	};
111	112

trunk/src/mess/machine/electron.c

r21620	r21621
177	177
178	178	WRITE8_MEMBER(electron_state::electron_ula_w)
179	179	{
180		device_t *speaker = machine().device(BEEPER_TAG);
	180	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
181	181	int i = electron_palette_offset[(( offset >> 1 ) & 0x03)];
182	182	logerror( "ULA: write offset %02x <- %02x\n", offset & 0x0f, data );
183	183	switch( offset & 0x0f )
r21620	r21621
237	237	case 0x06:  /* Counter divider */
238	238	if ( m_ula.communication_mode == 0x01)
239	239	{
240		beep_set_frequency( speaker, 1000000 / ( 16 * ( data + 1 ) ) );
	240	speaker->set_frequency( 1000000 / ( 16 * ( data + 1 ) ) );
241	241	}
242	242	break;
243	243	case 0x07:  /* Misc. */
r21620	r21621
245	245	switch( m_ula.communication_mode )
246	246	{
247	247	case 0x00:  /* cassette input */
248		beep_set_state( speaker, 0 );
	248	speaker->set_state( 0 );
249	249	electron_tape_start();
250	250	break;
251	251	case 0x01:  /* sound generation */
252		beep_set_state( speaker, 1 );
	252	speaker->set_state( 1 );
253	253	electron_tape_stop();
254	254	break;
255	255	case 0x02:  /* cassette output */
256		beep_set_state( speaker, 0 );
	256	speaker->set_state( 0 );
257	257	electron_tape_stop();
258	258	break;
259	259	case 0x03:  /* not used */
260		beep_set_state( speaker, 0 );
	260	speaker->set_state( 0 );
261	261	electron_tape_stop();
262	262	break;
263	263	}
r21620	r21621
316	316
317	317	TIMER_CALLBACK_MEMBER(electron_state::setup_beep)
318	318	{
319		device_t *speaker = machine().device(BEEPER_TAG);
320		beep_set_state( speaker, 0 );
321		beep_set_frequency( speaker, 300 );
	319	beep_device *speaker = machine().device<beep_device>(BEEPER_TAG);
	320	speaker->set_state( 0 );
	321	speaker->set_frequency( 300 );
322	322	}
323	323
324	324	void electron_state::machine_reset()

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

r21620	r21621
91	91	unsigned int cursor_address;        /* current cursor address (controlled by the computer, affects both display and I/O protocol) */
92	92	unsigned int cursor_address_mask;   /* 1023 for 960-char model, 2047 for 1920-char model */
93	93
94		emu_timer *beep_timer;                  /* beep clock (beeps ends when timer times out) */
	94	emu_timer *beep_timer;              /* beep clock (beeps ends when timer times out) */
95	95	/*void *blink_clock;*/              /* cursor blink clock */
96	96
97	97	UINT8 keyboard_data;                /* last code pressed on keyboard */
r21620	r21621
230	230
231	231	static TIMER_CALLBACK(setup_beep)
232	232	{
233		beep_set_frequency(machine.device(BEEPER_TAG), 2000);
	233	machine.device<beep_device>(BEEPER_TAG)->set_frequency(2000);
234	234	}
235	235
236	236
r21620	r21621
311	311	*/
312	312	static TIMER_CALLBACK(beep_callback)
313	313	{
314		beep_set_state(machine.device(BEEPER_TAG), 0);
	314	machine.device<beep_device>(BEEPER_TAG)->set_state(0);
315	315	}
316	316
317	317	/*
r21620	r21621
485	485
486	486	case 0xe:
487	487	/* beep enable strobe - not tested */
488		beep_set_state(space.machine().device(BEEPER_TAG), 1);
	488	space.machine().device<beep_device>(BEEPER_TAG)->set_state(1);
489	489
490	490	vdt->beep_timer->adjust(attotime::from_usec(300));
491	491	break;

trunk/src/mess/includes/tmc1800.h

r21620	r21621
10	10	#include "imagedev/snapquik.h"
11	11	#include "machine/ram.h"
12	12	#include "machine/rescap.h"
13		#include "sound/beep.h"
14	13	#include "sound/cdp1864.h"
15	14	#include "video/cdp1861.h"
16	15

trunk/src/mess/includes/xerox820.h

r21620	r21621
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_TAG)
118	118	{ }
119	119
120	120	required_device<beep_device> m_beeper;

trunk/src/mess/includes/osi.h

r21620	r21621
93	93	public:
94	94	c1p_state(const machine_config &mconfig, device_type type, const char *tag)
95	95	: sb2m600_state(mconfig, type, tag),
96		m_beep(*this, BEEPER_TAG)
	96	m_beep(*this, BEEPER_TAG)
97	97	{ }
98	98
99	99	required_device<beep_device> m_beep;

trunk/src/mess/includes/psion.h

r21620	r21621
22	22	public:
23	23	psion_state(const machine_config &mconfig, device_type type, const char *tag)
24	24	: driver_device(mconfig, type, tag),
25		m_maincpu(*this, "maincpu"),
26		m_lcdc(*this, "hd44780"),
27		m_beep(*this, BEEPER_TAG),
28		m_pack1(*this, "pack1"),
29		m_pack2(*this, "pack2"),
30		m_sys_register(*this, "sys_register"),
31		m_ram(*this, "ram"){ }
	25	m_maincpu(*this, "maincpu"),
	26	m_lcdc(*this, "hd44780"),
	27	m_beep(*this, BEEPER_TAG),
	28	m_pack1(*this, "pack1"),
	29	m_pack2(*this, "pack2"),
	30	m_sys_register(*this, "sys_register"),
	31	m_ram(*this, "ram"){ }
32	32
33	33	required_device<cpu_device> m_maincpu;
34	34	required_device<hd44780_device> m_lcdc;

trunk/src/mess/includes/studio2.h

r21620	r21621
22	22	public:
23	23	studio2_state(const machine_config &mconfig, device_type type, const char *tag)
24	24	: driver_device(mconfig, type, tag),
25		m_maincpu(*this, CDP1802_TAG),
26		m_speaker(*this, BEEPER_TAG),
27		m_vdc(*this, CDP1861_TAG),
28		m_clear(*this, "CLEAR"),
29		m_a(*this, "A"),
30		m_b(*this, "B")
	25	m_maincpu(*this, CDP1802_TAG),
	26	m_speaker(*this, BEEPER_TAG),
	27	m_vdc(*this, CDP1861_TAG),
	28	m_clear(*this, "CLEAR"),
	29	m_a(*this, "A"),
	30	m_b(*this, "B")
31	31	{ }
32	32
33	33	required_device<cosmac_device> m_maincpu;

trunk/src/mess/includes/fidelz80.h

r21620	r21621
17	17	public:
18	18	fidelz80_state(const machine_config &mconfig, device_type type, const char *tag)
19	19	: driver_device(mconfig, type, tag),
20		m_maincpu(*this, "maincpu"),
21		m_speech(*this, "speech"),
22		m_beep(*this, BEEPER_TAG),
23		m_i8041(*this, "mcu"),
24		m_i8243(*this, "i8243")
	20	m_maincpu(*this, "maincpu"),
	21	m_speech(*this, "speech"),
	22	m_beep(*this, BEEPER_TAG),
	23	m_i8041(*this, "mcu"),
	24	m_i8243(*this, "i8243")
25	25	{ }
26	26
27	27	required_device<cpu_device> m_maincpu;

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team