MAME SVN History

199869 Revisions

r20675 Saturday 2nd February, 2013 at 19:25:25 UTC by Andrew Gardner
Modernized digitalker, x1_010, tiaintf, and n63701x sound devices. [Andrew Gardner]

[src/emu/sound]	digitalk.c digitalk.h n63701x.c n63701x.h tiaintf.c tiaintf.h x1_010.c x1_010.h
[src/mame/drivers]	champbwl.c galaxian.c namcos86.c seta.c seta2.c tourtabl.c
[src/mame/video]	seta.c tia.c
[src/mess/drivers]	a2600.c a7800.c
[src/mess/machine]	a7800.c

trunk/src/emu/sound/x1_010.c
r20674	r20675
51	51	#include "emu.h"
52	52	#include "x1_010.h"
53	53
54
55	54	#define VERBOSE_SOUND 0
56	55	#define VERBOSE_REGISTER_WRITE 0
57	56	#define VERBOSE_REGISTER_READ 0
r20674	r20675
60	59	#define LOG_REGISTER_WRITE(x) do { if (VERBOSE_REGISTER_WRITE) logerror x; } while (0)
61	60	#define LOG_REGISTER_READ(x) do { if (VERBOSE_REGISTER_READ) logerror x; } while (0)
62	61
63		#define SETA_NUM_CHANNELS 16
64
65	62	#define FREQ_BASE_BITS 8 // Frequency fixed decimal shift bits
66	63	#define ENV_BASE_BITS 16 // wave form envelope fixed decimal shift bits
67		#define VOL_BASE (232256/30) // Volume base
	64	#define VOL_BASE (232256/30) // Volume base
68	65
69	66	/* this structure defines the parameters for a channel */
70	67	struct X1_010_CHANNEL {
r20674	r20675
77	74	unsigned char reserve[2];
78	75	};
79	76
80		struct x1_010_state
	77	/* mixer tables and internal buffers */
	78	//static short *mixer_buffer = NULL;
	79
	80
	81	// device type definition
	82	const device_type X1_010 = &device_creator<x1_010_device>;
	83
	84
	85	//**************************************************************************
	86	// LIVE DEVICE
	87	//**************************************************************************
	88
	89	//-------------------------------------------------
	90	// x1_010_device - constructor
	91	//-------------------------------------------------
	92
	93	x1_010_device::x1_010_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	94	: device_t(mconfig, X1_010, "X1-010", tag, owner, clock),
	95	device_sound_interface(mconfig, *this),
	96	m_rate(0),
	97	m_stream(NULL),
	98	m_address(0),
	99	m_region(NULL),
	100	m_sound_enable(0),
	101	m_base_clock(0)
81	102	{
82		/* Variables only used here */
83		int rate; // Output sampling rate (Hz)
84		sound_stream * stream; // Stream handle
85		int address; // address eor data
86		const UINT8 *region; // region name
87		int sound_enable; // sound output enable/disable
88		UINT8 reg[0x2000]; // X1-010 Register & wave form area
89		UINT8 HI_WORD_BUF[0x2000]; // X1-010 16bit access ram check avoidance work
90		UINT32 smp_offset[SETA_NUM_CHANNELS];
91		UINT32 env_offset[SETA_NUM_CHANNELS];
	103	}
92	104
93		UINT32 base_clock;
94		};
95	105
96		/* mixer tables and internal buffers */
97		//static short *mixer_buffer = NULL;
	106	//-------------------------------------------------
	107	// device_start - device-specific startup
	108	//-------------------------------------------------
98	109
99		~~INLINE~~ x1_010_~~state get_safe_token(~~device_t device)
	110	void x1_010_device::device_start()
100	111	{
101		assert(device != NULL);
102		assert(device->type() == X1_010);
103		return (x1_010_state )downcast<x1_010_device >(device)->token();
	112	int i;
	113	const x1_010_interface intf = (const x1_010_interface )static_config();
	114
	115	m_region = *region();
	116	m_base_clock = clock();
	117	m_rate = clock() / 1024;
	118	m_address = intf->adr;
	119
	120	for( i = 0; i < SETA_NUM_CHANNELS; i++ ) {
	121	m_smp_offset[i] = 0;
	122	m_env_offset[i] = 0;
	123	}
	124	/* Print some more debug info */
	125	LOG_SOUND(("masterclock = %d rate = %d\n", clock(), m_rate ));
	126
	127	/* get stream channels */
	128	m_stream = stream_alloc(0, 2, m_rate);
104	129	}
105	130
106	131
107		/*--------------------------------------------------------------
108		generate sound to the mix buffer
109		--------------------------------------------------------------*/
110		static STREAM_UPDATE( seta_update )
	132	//-------------------------------------------------
	133	// sound_stream_update - handle a stream update
	134	//-------------------------------------------------
	135
	136	void x1_010_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
111	137	{
112		x1_010_state info = (x1_010_state )param;
113	138	X1_010_CHANNEL *reg;
114	139	int ch, i, volL, volR, freq;
115	140	register INT8 start, end, data;
116	141	register UINT8 *env;
117	142	register UINT32 smp_offs, smp_step, env_offs, env_step, delta;
118		const UINT8 *snd1 = ~~info->~~region;
	143	const UINT8 *snd1 = m_region;
119	144
120	145	// mixer buffer zero clear
121	146	memset( outputs[0], 0, samplessizeof(outputs[0]) );
122	147	memset( outputs[1], 0, samplessizeof(outputs[1]) );
123	148
124		// if( ~~info->~~sound_enable == 0 ) return;
	149	// if( m_sound_enable == 0 ) return;
125	150
126	151	for( ch = 0; ch < SETA_NUM_CHANNELS; ch++ ) {
127		reg = (X1_010_CHANNEL )&(~~info->~~reg[chsizeof(X1_010_CHANNEL)]);
	152	reg = (X1_010_CHANNEL )&(m_reg[chsizeof(X1_010_CHANNEL)]);
128	153	if( (reg->status&1) != 0 ) { // Key On
129	154	stream_sample_t *bufL = outputs[0];
130	155	stream_sample_t *bufR = outputs[1];
r20674	r20675
133	158	end = (INT8 )((0x100-reg->end)0x1000+snd1);
134	159	volL = ((reg->volume>>4)&0xf)*VOL_BASE;
135	160	volR = ((reg->volume>>0)&0xf)*VOL_BASE;
136		smp_offs = ~~info->~~smp_offset[ch];
	161	smp_offs = m_smp_offset[ch];
137	162	freq = reg->frequency&0x1f;
138	163	// Meta Fox does not write the frequency register. Ever
139	164	if( freq == 0 ) freq = 4;
140		smp_step = (UINT32)((float)info->base_clock/8192.0
141		freq(1<<FREQ_BASE_BITS)/(float)info->rate);
	165	smp_step = (UINT32)((float)m_base_clock/8192.0
	166	freq(1<<FREQ_BASE_BITS)/(float)m_rate);
142	167	if( smp_offs == 0 ) {
143	168	LOG_SOUND(( "Play sample %p - %p, channel %X volume %d:%d freq %X step %X offset %X\n",
144	169	start, end, ch, volL, volR, freq, smp_step, smp_offs ));
r20674	r20675
155	180	bufR++ += (datavolR/256);
156	181	smp_offs += smp_step;
157	182	}
158		~~info->~~smp_offset[ch] = smp_offs;
	183	m_smp_offset[ch] = smp_offs;
159	184	} else { // Wave form
160		start = (INT8 )&(info->reg[reg->volume128+0x1000]);
161		smp_offs = info->smp_offset[ch];
	185	start = (INT8 )&(m_reg[reg->volume128+0x1000]);
	186	smp_offs = m_smp_offset[ch];
162	187	freq = (reg->pitch_hi<<8)+reg->frequency;
163		smp_step = (UINT32)((float)~~info->~~base_clock/128.0/1024.0/4.0freq(1<<FREQ_BASE_BITS)/(float)~~info->~~rate);
	188	smp_step = (UINT32)((float)m_base_clock/128.0/1024.0/4.0freq(1<<FREQ_BASE_BITS)/(float)m_rate);
164	189
165		env = (UINT8 )&(info->reg[reg->end128]);
166		env_offs = info->env_offset[ch];
167		env_step = (UINT32)((float)info->base_clock/128.0/1024.0/4.0reg->start(1<<ENV_BASE_BITS)/(float)info->rate);
	190	env = (UINT8 )&(m_reg[reg->end128]);
	191	env_offs = m_env_offset[ch];
	192	env_step = (UINT32)((float)m_base_clock/128.0/1024.0/4.0reg->start(1<<ENV_BASE_BITS)/(float)m_rate);
168	193	/* Print some more debug info */
169	194	if( smp_offs == 0 ) {
170	195	LOG_SOUND(( "Play waveform %X, channel %X volume %X freq %4X step %X offset %X\n",
r20674	r20675
187	212	smp_offs += smp_step;
188	213	env_offs += env_step;
189	214	}
190		info->smp_offset[ch] = smp_offs;
191		info->env_offset[ch] = env_offs;
	215	m_smp_offset[ch] = smp_offs;
	216	m_env_offset[ch] = env_offs;
192	217	}
193	218	}
194	219	}
195	220	}
196	221
197	222
198
199		static DEVICE_START( x1_010 )
	223	void x1_010_device::seta_sound_enable_w(int data)
200	224	{
201		int i;
202		const x1_010_interface intf = (const x1_010_interface )device->static_config();
203		x1_010_state *info = get_safe_token(device);
204
205		info->region = *device->region();
206		info->base_clock = device->clock();
207		info->rate = device->clock() / 1024;
208		info->address = intf->adr;
209
210		for( i = 0; i < SETA_NUM_CHANNELS; i++ ) {
211		info->smp_offset[i] = 0;
212		info->env_offset[i] = 0;
213		}
214		/* Print some more debug info */
215		LOG_SOUND(("masterclock = %d rate = %d\n", device->clock(), info->rate ));
216
217		/* get stream channels */
218		info->stream = device->machine().sound().stream_alloc(*device,0,2,info->rate,info,seta_update);
	225	m_sound_enable = data;
219	226	}
220	227
221	228
222		void seta_sound_enable_w(device_t *device, int data)
	229	//
	230	// Use these for 8 bit CPUs
	231	//
	232	READ8_MEMBER( x1_010_device::seta_sound_r )
223	233	{
224		x1_010_state *info = get_safe_token(device);
225		info->sound_enable = data;
	234	offset ^= m_address;
	235	return m_reg[offset];
226	236	}
227	237
228	238
229
230		/* Use these for 8 bit CPUs */
231
232
233		READ8_DEVICE_HANDLER( seta_sound_r )
	239	WRITE8_MEMBER( x1_010_device::seta_sound_w )
234	240	{
235		x1_010_state *info = get_safe_token(device);
236		offset ^= info->address;
237		return info->reg[offset];
238		}
239
240
241
242
243		WRITE8_DEVICE_HANDLER( seta_sound_w )
244		{
245		x1_010_state *info = get_safe_token(device);
246	241	int channel, reg;
247		offset ^= ~~info->~~address;
	242	offset ^= m_address;
248	243
249	244	channel = offset/sizeof(X1_010_CHANNEL);
250	245	reg = offset%sizeof(X1_010_CHANNEL);
251	246
252	247	if( channel < SETA_NUM_CHANNELS && reg == 0
253		&& (info->reg[offset]&1) == 0 && (data&1) != 0 ) {
254		info->smp_offset[channel] = 0;
255		info->env_offset[channel] = 0;
	248	&& (m_reg[offset]&1) == 0 && (data&1) != 0 ) {
	249	m_smp_offset[channel] = 0;
	250	m_env_offset[channel] = 0;
256	251	}
257		LOG_REGISTER_WRITE(("%s: offset %6X : data %2X\n", device->machine().describe_context(), offset, data ));
258		info->reg[offset] = data;
	252	LOG_REGISTER_WRITE(("%s: offset %6X : data %2X\n", machine().describe_context(), offset, data ));
	253	m_reg[offset] = data;
259	254	}
260	255
261	256
262
263
264		/* Use these for 16 bit CPUs */
265
266		READ16_DEVICE_HANDLER( seta_sound_word_r )
	257	//
	258	// Use these for 16 bit CPUs
	259	//
	260	READ16_MEMBER( x1_010_device::seta_sound_word_r )
267	261	{
268		x1_010_state *info = get_safe_token(device);
269	262	UINT16 ret;
270
271		ret = info->HI_WORD_BUF[offset]<<8;
272		ret += (seta_sound_r( device, space, offset )&0xff);
273		LOG_REGISTER_READ(( "%s: Read X1-010 Offset:%04X Data:%04X\n", device->machine().describe_context(), offset, ret ));
	263	ret = m_HI_WORD_BUF[offset]<<8;
	264	ret += (seta_sound_r( space, offset )&0xff);
	265	LOG_REGISTER_READ(( "%s: Read X1-010 Offset:%04X Data:%04X\n", machine().describe_context(), offset, ret ));
274	266	return ret;
275	267	}
276	268
277		WRITE16_DE~~VIC~~E~~_HANDLE~~R( seta_sound_word_w )
	269	WRITE16_MEMBER( x1_010_device::seta_sound_word_w )
278	270	{
279		x1_010_state *info = get_safe_token(device);
280		info->HI_WORD_BUF[offset] = (data>>8)&0xff;
281		seta_sound_w( device, space, offset, data&0xff );
282		LOG_REGISTER_WRITE(( "%s: Write X1-010 Offset:%04X Data:%04X\n", device->machine().describe_context(), offset, data ));
	271	m_HI_WORD_BUF[offset] = (data>>8)&0xff;
	272	seta_sound_w( space, offset, data&0xff );
	273	LOG_REGISTER_WRITE(( "%s: Write X1-010 Offset:%04X Data:%04X\n", machine().describe_context(), offset, data ));
283	274	}
284
285
286		const device_type X1_010 = &device_creator<x1_010_device>;
287
288		x1_010_device::x1_010_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
289		: device_t(mconfig, X1_010, "X1-010", tag, owner, clock),
290		device_sound_interface(mconfig, *this)
291		{
292		m_token = global_alloc_clear(x1_010_state);
293		}
294
295		//-------------------------------------------------
296		// device_config_complete - perform any
297		// operations now that the configuration is
298		// complete
299		//-------------------------------------------------
300
301		void x1_010_device::device_config_complete()
302		{
303		}
304
305		//-------------------------------------------------
306		// device_start - device-specific startup
307		//-------------------------------------------------
308
309		void x1_010_device::device_start()
310		{
311		DEVICE_START_NAME( x1_010 )(this);
312		}
313
314		//-------------------------------------------------
315		// sound_stream_update - handle a stream update
316		//-------------------------------------------------
317
318		void x1_010_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
319		{
320		// should never get here
321		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
322		}

trunk/src/emu/sound/x1_010.h
r20674	r20675
3	3	#ifndef __X1_010_H__
4	4	#define __X1_010_H__
5	5
6		#in~~clud~~e ~~"devlegcy.h"~~
	6	#define SETA_NUM_CHANNELS 16
7	7
8	8
	9	//**************************************************************************
	10	// INTERFACE CONFIGURATION MACROS
	11	//**************************************************************************
	12
	13	#define MCFG_X1_010_ADD(_tag, _clock) \
	14	MCFG_DEVICE_ADD(_tag, X1_010, _clock)
	15	#define MCFG_X1_010_REPLACE(_tag, _clock) \
	16	MCFG_DEVICE_REPLACE(_tag, X1_010, _clock)
	17
	18
	19	//**************************************************************************
	20	// TYPE DEFINITIONS
	21	//**************************************************************************
	22
9	23	struct x1_010_interface
10	24	{
11	25	int adr; /* address */
12	26	};
13	27
14	28
15		DECLARE_READ8_DEVICE_HANDLER ( seta_sound_r );
16		DECLARE_WRITE8_DEVICE_HANDLER( seta_sound_w );
	29	// ======================> x1_010_device
17	30
18		DECLARE_READ16_DEVICE_HANDLER ( seta_sound_word_r );
19		DECLARE_WRITE16_DEVICE_HANDLER( seta_sound_word_w );
20
21		void seta_sound_enable_w(device_t *device, int data);
22
23	31	class x1_010_device : public device_t,
24		public device_sound_interface
	32	public device_sound_interface
25	33	{
26	34	public:
27	35	x1_010_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
28		~x1_010_device() { ~~global_free(m_token);~~ }
	36	~x1_010_device() { }
29	37
30		// access to legacy token
31		void *token() const { assert(m_token != NULL); return m_token; }
	38	void seta_sound_enable_w(int data);
	39
32	40	protected:
33	41	// device-level overrides
34		virtual void device_config_complete();
35	42	virtual void device_start();
36	43
37	44	// sound stream update overrides
38	45	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
	46
	47	public:
	48	DECLARE_READ8_MEMBER( seta_sound_r );
	49	DECLARE_WRITE8_MEMBER( seta_sound_w );
	50
	51	DECLARE_READ16_MEMBER( seta_sound_word_r );
	52	DECLARE_WRITE16_MEMBER( seta_sound_word_w );
	53
39	54	private:
40		// internal state
41		void *m_token;
	55	int m_rate; // Output sampling rate (Hz)
	56	sound_stream *m_stream; // Stream handle
	57	int m_address; // address eor data
	58	const UINT8 *m_region; // region name
	59	int m_sound_enable; // sound output enable/disable
	60	UINT8 m_reg[0x2000]; // X1-010 Register & wave form area
	61	UINT8 m_HI_WORD_BUF[0x2000]; // X1-010 16bit access ram check avoidance work
	62	UINT32 m_smp_offset[SETA_NUM_CHANNELS];
	63	UINT32 m_env_offset[SETA_NUM_CHANNELS];
	64
	65	UINT32 m_base_clock;
42	66	};
43	67
44	68	extern const device_type X1_010;

trunk/src/emu/sound/n63701x.c
r20674	r20675
17	17	#include "n63701x.h"
18	18
19	19
20		struct voice
21		{
22		int select;
23		int playing;
24		int base_addr;
25		int position;
26		int volume;
27		int silence_counter;
28		};
29
30
31		struct namco_63701x
32		{
33		voice voices[2];
34		sound_stream * stream; /* channel assigned by the mixer */
35		UINT8 rom; / pointer to sample ROM */
36		};
37
38
39	20	/* volume control has three resistors: 22000, 10000 and 3300 Ohm.
40	21	22000 is always enabled, the other two can be turned off.
41	22	Since 0x00 and 0xff samples have special meaning, the available range is
r20674	r20675
43	24	inside 16 bits without overflowing.
44	25	*/
45	26	static const int vol_table[4] = { 26, 84, 200, 258 };
	27
46	28
	29	// device type definition
	30	const device_type NAMCO_63701X = &device_creator<namco_63701x_device>;
47	31
48		INLINE namco_63701x get_safe_token(device_t device)
	32	namco_63701x_device::namco_63701x_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	33	: device_t(mconfig, NAMCO_63701X, "Namco 63701X", tag, owner, clock),
	34	device_sound_interface(mconfig, *this),
	35	m_stream(NULL),
	36	m_rom(NULL)
49	37	{
50		assert(device != NULL);
51		assert(device->type() == NAMCO_63701X);
52		return (namco_63701x )downcast<namco_63701x_device >(device)->token();
53	38	}
54	39
55	40
56		static STREAM_UPDATE( namco_63701x_update )
	41	//-------------------------------------------------
	42	// device_start - device-specific startup
	43	//-------------------------------------------------
	44
	45	void namco_63701x_device::device_start()
57	46	{
58		namco_63701x chip = (namco_63701x )param;
	47	m_rom = *region();
	48	m_stream = stream_alloc(0, 2, clock()/1000);
	49	}
	50
	51
	52	//-------------------------------------------------
	53	// sound_stream_update - handle a stream update
	54	//-------------------------------------------------
	55
	56	void namco_63701x_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
	57	{
59	58	int ch;
60	59
61	60	for (ch = 0;ch < 2;ch++)
62	61	{
63	62	stream_sample_t *buf = outputs[ch];
64		voice *v = &~~chip->~~voices[ch];
	63	voice_63701x *v = &m_voices[ch];
65	64
66	65	if (v->playing)
67	66	{
68		UINT8 *base = ~~chip->~~rom + v->base_addr;
	67	UINT8 *base = m_rom + v->base_addr;
69	68	int pos = v->position;
70	69	int vol = vol_table[v->volume];
71	70	int p;
r20674	r20675
107	106	}
108	107
109	108
110		static DEVICE_START( namco_63701x )
111		{
112		namco_63701x *chip = get_safe_token(device);
113	109
114		chip->rom = *device->region();
115
116		chip->stream = device->machine().sound().stream_alloc(*device, 0, 2, device->clock()/1000, chip, namco_63701x_update);
117		}
118
119
120
121		WRITE8_DEVICE_HANDLER( namco_63701x_w )
	110	WRITE8_MEMBER( namco_63701x_device::namco_63701x_w )
122	111	{
123		namco_63701x *chip = get_safe_token(device);
124	112	int ch = offset / 2;
125	113
126	114	if (offset & 1)
127		~~chip->~~voices[ch].select = data;
	115	m_voices[ch].select = data;
128	116	else
129	117	{
130	118	/*
r20674	r20675
133	121	after the continue counter reaches 0. Either we shouldn't stop
134	122	the sample, or genpeitd is returning to the title screen too soon.
135	123	*/
136		if (~~chip->~~voices[ch].select & 0x1f)
	124	if (m_voices[ch].select & 0x1f)
137	125	{
138	126	int rom_offs;
139	127
140	128	/* update the streams */
141		~~chip->~~stream->update();
	129	m_stream->update();
142	130
143		chip->voices[ch].playing = 1;
144		chip->voices[ch].base_addr = 0x10000 * ((chip->voices[ch].select & 0xe0) >> 5);
145		rom_offs = chip->voices[ch].base_addr + 2 * ((chip->voices[ch].select & 0x1f) - 1);
146		chip->voices[ch].position = (chip->rom[rom_offs] << 8) + chip->rom[rom_offs+1];
	131	m_voices[ch].playing = 1;
	132	m_voices[ch].base_addr = 0x10000 * ((m_voices[ch].select & 0xe0) >> 5);
	133	rom_offs = m_voices[ch].base_addr + 2 * ((m_voices[ch].select & 0x1f) - 1);
	134	m_voices[ch].position = (m_rom[rom_offs] << 8) + m_rom[rom_offs+1];
147	135	/* bits 6-7 = volume */
148		~~chip->~~voices[ch].volume = data >> 6;
	136	m_voices[ch].volume = data >> 6;
149	137	/* bits 0-5 = counter to indicate new sample start? we don't use them */
150	138
151		~~chip->~~voices[ch].silence_counter = 0;
	139	m_voices[ch].silence_counter = 0;
152	140	}
153	141	}
154	142	}
155	143
156		const device_type NAMCO_63701X = &device_creator<namco_63701x_device>;
157
158		namco_63701x_device::namco_63701x_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
159		: device_t(mconfig, NAMCO_63701X, "Namco 63701X", tag, owner, clock),
160		device_sound_interface(mconfig, *this)
161		{
162		m_token = global_alloc_clear(namco_63701x);
163		}
164
165		//-------------------------------------------------
166		// device_config_complete - perform any
167		// operations now that the configuration is
168		// complete
169		//-------------------------------------------------
170
171		void namco_63701x_device::device_config_complete()
172		{
173		}
174
175		//-------------------------------------------------
176		// device_start - device-specific startup
177		//-------------------------------------------------
178
179		void namco_63701x_device::device_start()
180		{
181		DEVICE_START_NAME( namco_63701x )(this);
182		}
183
184		//-------------------------------------------------
185		// sound_stream_update - handle a stream update
186		//-------------------------------------------------
187
188		void namco_63701x_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
189		{
190		// should never get here
191		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
192		}

trunk/src/emu/sound/digitalk.c
r20674	r20675
236	236
237	237	*/
238	238
239
240		struct digitalker {
241		const UINT8 *rom;
242		device_t *device;
243		sound_stream *stream;
244
245		// Port/lines state
246		UINT8 data, cs, cms, wr, intr;
247
248		// Current decoding state
249		UINT16 bpos, apos;
250		UINT8 mode, cur_segment, cur_repeat, segments, repeats;
251		UINT8 prev_pitch, pitch, pitch_pos;
252		UINT8 stop_after, cur_dac, cur_bits;
253
254		// Zero-range size
255		UINT32 zero_count; // 0 for done
256
257		// Waveform and current index in it
258		UINT8 dac_index; // 128 for done
259		INT16 dac[128];
260
261		};
262
263	239	// Quantized intensity values, first index is the volume, second the
264	240	// intensity (positive half only, real value goes -8..7)
265	241	static const short pcm_levels[8][8] = {
r20674	r20675
277	253	static const int delta2[16] = { 0, -1, -2, -3, 1, 0, -1, -2, 2, 1, 0, -1, 3, 2, 1, 0 };
278	254
279	255	// Frequency quantizations, values are in units of 128us.
280
281	256	static const int pitch_vals[32] = {
282	257	97, 95, 92, 89, 87, 84, 82, 80, 77, 75, 73, 71, 69, 67, 65, 63,
283	258	61, 60, 58, 56, 55, 53, 52, 50, 49, 48, 46, 45, 43, 42, 41, 40
284	259	};
285	260
286	261
287		INLINE digitalker get_safe_token(device_t device)
	262	const device_type DIGITALKER = &device_creator<digitalker_device>;
	263
	264	digitalker_device::digitalker_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
	265	: device_t(mconfig, DIGITALKER, "Digitalker", tag, owner, clock),
	266	device_sound_interface(mconfig, *this),
	267	m_rom(NULL),
	268	m_stream(NULL),
	269	m_data(0),
	270	m_cs(0),
	271	m_cms(0),
	272	m_wr(0),
	273	m_intr(0),
	274	m_bpos(0),
	275	m_apos(0),
	276	m_mode(0),
	277	m_cur_segment(0),
	278	m_cur_repeat(0),
	279	m_segments(0),
	280	m_repeats(0),
	281	m_prev_pitch(0),
	282	m_pitch(0),
	283	m_pitch_pos(0),
	284	m_stop_after(0),
	285	m_cur_dac(0),
	286	m_cur_bits(0),
	287	m_zero_count(0),
	288	m_dac_index(0)
288	289	{
289		assert(device != NULL);
290		assert(device->type() == DIGITALKER);
291		return (digitalker )downcast<digitalker_device >(device)->token();
292	290	}
293	291
294	292
295		~~static~~ void digitalker_write(digitalker dg, UINT8 adr, UINT8 vol, INT8 dac)
	293	void digitalker_device::digitalker_write(UINT8 *adr, UINT8 vol, INT8 dac)
296	294	{
297	295	INT16 v;
298	296	dac &= 15;
r20674	r20675
302	300	v = pcm_levels[vol][dac-1];
303	301	else
304	302	v = 0;
305		~~dg->~~dac[(*adr)++] = v;
	303	m_dac[(*adr)++] = v;
306	304	}
307	305
308		~~static~~ UINT8 digitalker_pitch_next(UINT8 val, UINT8 prev, int step)
	306	UINT8 digitalker_device::digitalker_pitch_next(UINT8 val, UINT8 prev, int step)
309	307	{
310	308	int delta, nv;
311	309
r20674	r20675
323	321	return nv;
324	322	}
325	323
326		~~static~~ void digitalker_set_i~~ntr(~~digitalker *dg, UINT8 intr)
	324	void digitalker_device::digitalker_set_intr(UINT8 intr)
327	325	{
328		~~dg->~~intr = intr;
	326	m_intr = intr;
329	327	}
330	328
331		~~static~~ void digitalker_start_command(~~digitalker *dg,~~ UINT8 cmd)
	329	void digitalker_device::digitalker_start_command(UINT8 cmd)
332	330	{
333		dg->bpos = ((dg->rom[cmd2] << 8) \| dg->rom[cmd2+1]) & 0x3fff;
334		dg->cur_segment = dg->segments = dg->cur_repeat = dg->repeats = 0;
335		dg->dac_index = 128;
336		dg->zero_count = 0;
337		digitalker_set_intr(dg, 0);
	331	m_bpos = ((m_rom[cmd2] << 8) \| m_rom[cmd2+1]) & 0x3fff;
	332	m_cur_segment = m_segments = m_cur_repeat = m_repeats = 0;
	333	m_dac_index = 128;
	334	m_zero_count = 0;
	335	digitalker_set_intr(0);
338	336	}
339	337
340		~~static~~ void digitalker_~~step_mo~~de~~_0(~~digitalker *dg)
	338	void digitalker_device::digitalker_step_mode_0()
341	339	{
342	340	INT8 dac = 0;
343	341	int i, k, l;
344	342	UINT8 wpos = 0;
345		UINT8 h = ~~dg->~~rom[~~dg->~~apos];
	343	UINT8 h = m_rom[m_apos];
346	344	UINT16 bits = 0x80;
347	345	UINT8 vol = h >> 5;
348		UINT8 pitch_id = ~~dg->~~cur_segment ? digitalker_pitch_next(h, ~~dg->~~prev_pitch, ~~dg->~~cur_repeat) : h & 0x1f;
	346	UINT8 pitch_id = m_cur_segment ? digitalker_pitch_next(h, m_prev_pitch, m_cur_repeat) : h & 0x1f;
349	347
350		~~dg->~~pitch = pitch_vals[pitch_id];
	348	m_pitch = pitch_vals[pitch_id];
351	349
352	350	for(i=0; i<32; i++)
353		~~dg->~~dac[wpos++] = 0;
	351	m_dac[wpos++] = 0;
354	352
355	353	for(k=1; k != 9; k++) {
356		bits \|= ~~dg->~~rom[~~dg->~~apos+k] << 8;
	354	bits \|= m_rom[m_apos+k] << 8;
357	355	for(l=0; l<4; l++) {
358	356	dac += delta1[(bits >> (6+2*l)) & 15];
359		digitalker_write(~~dg,~~ &wpos, vol, dac);
	357	digitalker_write(&wpos, vol, dac);
360	358	}
361	359	bits >>= 8;
362	360	}
363	361
364		digitalker_write(~~dg,~~ &wpos, vol, dac);
	362	digitalker_write(&wpos, vol, dac);
365	363
366	364	for(k=7; k >= 0; k--) {
367		bits = (bits << 8) \| (k ? ~~dg->~~rom[~~dg->~~apos+k] : 0x80);
	365	bits = (bits << 8) \| (k ? m_rom[m_apos+k] : 0x80);
368	366	for(l=3; l>=0; l--) {
369	367	dac -= delta1[(bits >> (6+2*l)) & 15];
370		digitalker_write(~~dg,~~ &wpos, vol, dac);
	368	digitalker_write(&wpos, vol, dac);
371	369	}
372	370	}
373	371
374	372	for(i=0; i<31; i++)
375		~~dg->~~dac[wpos++] = 0;
	373	m_dac[wpos++] = 0;
376	374
377		dg->cur_repeat++;
378		if(dg->cur_repeat == dg->repeats) {
379		dg->apos += 9;
380		dg->prev_pitch = pitch_id;
381		dg->cur_repeat = 0;
382		dg->cur_segment++;
	375	m_cur_repeat++;
	376	if(m_cur_repeat == m_repeats) {
	377	m_apos += 9;
	378	m_prev_pitch = pitch_id;
	379	m_cur_repeat = 0;
	380	m_cur_segment++;
383	381	}
384	382	}
385	383
386		~~static~~ void digitalker_~~step_mo~~de~~_1(~~digitalker *dg)
	384	void digitalker_device::digitalker_step_mode_1()
387	385	{
388	386	logerror("Digitalker mode 1 unsupported");
389		dg->zero_count = 1;
390		dg->cur_segment = dg->segments;
	387	m_zero_count = 1;
	388	m_cur_segment = m_segments;
391	389	}
392	390
393		~~static~~ void digitalker_~~step_mo~~de~~_2(~~digitalker *dg)
	391	void digitalker_device::digitalker_step_mode_2()
394	392	{
395	393	INT8 dac = 0;
396	394	int k, l;
397	395	UINT8 wpos=0;
398		UINT8 h = ~~dg->~~rom[~~dg->~~apos];
	396	UINT8 h = m_rom[m_apos];
399	397	UINT16 bits = 0x80;
400	398	UINT8 vol = h >> 5;
401		UINT8 pitch_id = ~~dg->~~cur_segment ? digitalker_pitch_next(h, ~~dg->~~prev_pitch, ~~dg->~~cur_repeat) : h & 0x1f;
	399	UINT8 pitch_id = m_cur_segment ? digitalker_pitch_next(h, m_prev_pitch, m_cur_repeat) : h & 0x1f;
402	400
403		~~dg->~~pitch = pitch_vals[pitch_id];
	401	m_pitch = pitch_vals[pitch_id];
404	402
405	403	for(k=1; k != 9; k++) {
406		bits \|= ~~dg->~~rom[~~dg->~~apos+k] << 8;
	404	bits \|= m_rom[m_apos+k] << 8;
407	405	for(l=0; l<4; l++) {
408	406	dac += delta1[(bits >> (6+2*l)) & 15];
409		digitalker_write(~~dg,~~ &wpos, vol, dac);
	407	digitalker_write(&wpos, vol, dac);
410	408	}
411	409	bits >>= 8;
412	410	}
413	411
414		digitalker_write(~~dg,~~ &wpos, vol, dac);
	412	digitalker_write(&wpos, vol, dac);
415	413
416	414	for(k=7; k >= 0; k--) {
417	415	int limit = k ? 0 : 1;
418		bits = (bits << 8) \| (k ? ~~dg->~~rom[~~dg->~~apos+k] : 0x80);
	416	bits = (bits << 8) \| (k ? m_rom[m_apos+k] : 0x80);
419	417	for(l=3; l>=limit; l--) {
420	418	dac -= delta1[(bits >> (6+2*l)) & 15];
421		digitalker_write(~~dg,~~ &wpos, vol, dac);
	419	digitalker_write(&wpos, vol, dac);
422	420	}
423	421	}
424	422
425		digitalker_write(~~dg,~~ &wpos, vol, dac);
	423	digitalker_write(&wpos, vol, dac);
426	424
427	425	for(k=1; k != 9; k++) {
428	426	int start = k == 1 ? 1 : 0;
429		bits \|= ~~dg->~~rom[~~dg->~~apos+k] << 8;
	427	bits \|= m_rom[m_apos+k] << 8;
430	428	for(l=start; l<4; l++) {
431	429	dac += delta1[(bits >> (6+2*l)) & 15];
432		digitalker_write(~~dg,~~ &wpos, vol, dac);
	430	digitalker_write(&wpos, vol, dac);
433	431	}
434	432	bits >>= 8;
435	433	}
436	434
437		digitalker_write(~~dg,~~ &wpos, vol, dac);
	435	digitalker_write(&wpos, vol, dac);
438	436
439	437	for(k=7; k >= 0; k--) {
440	438	int limit = k ? 0 : 1;
441		bits = (bits << 8) \| (k ? ~~dg->~~rom[~~dg->~~apos+k] : 0x80);
	439	bits = (bits << 8) \| (k ? m_rom[m_apos+k] : 0x80);
442	440	for(l=3; l>=limit; l--) {
443	441	dac -= delta1[(bits >> (6+2*l)) & 15];
444		digitalker_write(~~dg,~~ &wpos, vol, dac);
	442	digitalker_write(&wpos, vol, dac);
445	443	}
446	444	}
447	445
448		dg->cur_repeat++;
449		if(dg->cur_repeat == dg->repeats) {
450		dg->apos += 9;
451		dg->prev_pitch = pitch_id;
452		dg->cur_repeat = 0;
453		dg->cur_segment++;
	446	m_cur_repeat++;
	447	if(m_cur_repeat == m_repeats) {
	448	m_apos += 9;
	449	m_prev_pitch = pitch_id;
	450	m_cur_repeat = 0;
	451	m_cur_segment++;
454	452	}
455	453	}
456	454
457		~~static~~ void digitalker_~~step_mo~~de~~_3(~~digitalker *dg)
	455	void digitalker_device::digitalker_step_mode_3()
458	456	{
459		UINT8 h = ~~dg->~~rom[~~dg->~~apos];
	457	UINT8 h = m_rom[m_apos];
460	458	UINT8 vol = h >> 5;
461	459	UINT16 bits;
462	460	UINT8 dac, apos, wpos;
463	461	int k, l;
464	462
465		dg->pitch = pitch_vals[h & 0x1f];
466		if(dg->cur_segment == 0 && dg->cur_repeat == 0) {
467		dg->cur_bits = 0x40;
468		dg->cur_dac = 0;
	463	m_pitch = pitch_vals[h & 0x1f];
	464	if(m_cur_segment == 0 && m_cur_repeat == 0) {
	465	m_cur_bits = 0x40;
	466	m_cur_dac = 0;
469	467	}
470		bits = ~~dg->~~cur_bits;
	468	bits = m_cur_bits;
471	469	dac = 0;
472	470
473		apos = ~~dg->~~apos + 1 + 32*~~dg->~~cur_segment;
	471	apos = m_apos + 1 + 32*m_cur_segment;
474	472	wpos = 0;
475	473	for(k=0; k != 32; k++) {
476		bits \|= ~~dg->~~rom[apos++] << 8;
	474	bits \|= m_rom[apos++] << 8;
477	475	for(l=0; l<4; l++) {
478	476	dac += delta2[(bits >> (6+2*l)) & 15];
479		digitalker_write(~~dg,~~ &wpos, vol, dac);
	477	digitalker_write(&wpos, vol, dac);
480	478	}
481	479	bits >>= 8;
482	480	}
483	481
484		dg->cur_bits = bits;
485		dg->cur_dac = dac;
	482	m_cur_bits = bits;
	483	m_cur_dac = dac;
486	484
487		dg->cur_segment++;
488		if(dg->cur_segment == dg->segments) {
489		dg->cur_segment = 0;
490		dg->cur_repeat++;
	485	m_cur_segment++;
	486	if(m_cur_segment == m_segments) {
	487	m_cur_segment = 0;
	488	m_cur_repeat++;
491	489	}
492	490	}
493	491
494		~~static~~ void digitalker_step(digitalker *dg)
	492	void digitalker_device::digitalker_step()
495	493	{
496		if(dg->cur_segment == dg->segments \|\| dg->cur_repeat == dg->repeats) {
497		if(dg->stop_after == 0 && dg->bpos == 0xffff)
	494	if(m_cur_segment == m_segments \|\| m_cur_repeat == m_repeats) {
	495	if(m_stop_after == 0 && m_bpos == 0xffff)
498	496	return;
499		if(dg->stop_after == 0) {
500		UINT8 v1 = dg->rom[dg->bpos++];
501		UINT8 v2 = dg->rom[dg->bpos++];
502		UINT8 v3 = dg->rom[dg->bpos++];
503		dg->apos = v2 \| ((v3 << 8) & 0x3f00);
504		dg->segments = (v1 & 15) + 1;
505		dg->repeats = ((v1 >> 4) & 7) + 1;
506		dg->mode = (v3 >> 6) & 3;
507		dg->stop_after = (v1 & 0x80) != 0;
	497	if(m_stop_after == 0) {
	498	UINT8 v1 = m_rom[m_bpos++];
	499	UINT8 v2 = m_rom[m_bpos++];
	500	UINT8 v3 = m_rom[m_bpos++];
	501	m_apos = v2 \| ((v3 << 8) & 0x3f00);
	502	m_segments = (v1 & 15) + 1;
	503	m_repeats = ((v1 >> 4) & 7) + 1;
	504	m_mode = (v3 >> 6) & 3;
	505	m_stop_after = (v1 & 0x80) != 0;
508	506
509		dg->cur_segment = 0;
510		dg->cur_repeat = 0;
	507	m_cur_segment = 0;
	508	m_cur_repeat = 0;
511	509
512		if(!dg->apos) {
513		dg->zero_count = 40128dg->segments*dg->repeats;
514		dg->segments = 0;
515		dg->repeats = 0;
	510	if(!m_apos) {
	511	m_zero_count = 40128m_segments*m_repeats;
	512	m_segments = 0;
	513	m_repeats = 0;
516	514	return;
517	515	}
518		} else if(dg->stop_after == 1) {
519		dg->bpos = 0xffff;
520		dg->zero_count = 81920;
521		dg->stop_after = 2;
522		dg->cur_segment = 0;
523		dg->cur_repeat = 0;
524		dg->segments = 0;
525		dg->repeats = 0;
	516	} else if(m_stop_after == 1) {
	517	m_bpos = 0xffff;
	518	m_zero_count = 81920;
	519	m_stop_after = 2;
	520	m_cur_segment = 0;
	521	m_cur_repeat = 0;
	522	m_segments = 0;
	523	m_repeats = 0;
526	524	} else {
527		dg->stop_after = 0;
528		digitalker_set_intr(dg, 1);
	525	m_stop_after = 0;
	526	digitalker_set_intr(1);
529	527	}
530	528	}
531	529
532		switch(dg->mode) {
533		case 0: digitalker_step_mode_0(dg); break;
534		case 1: digitalker_step_mode_1(dg); break;
535		case 2: digitalker_step_mode_2(dg); break;
536		case 3: digitalker_step_mode_3(dg); break;
	530	switch(m_mode) {
	531	case 0: digitalker_step_mode_0(); break;
	532	case 1: digitalker_step_mode_1(); break;
	533	case 2: digitalker_step_mode_2(); break;
	534	case 3: digitalker_step_mode_3(); break;
537	535	}
538		if(!dg->zero_count)
539		dg->dac_index = 0;
	536	if(!m_zero_count)
	537	m_dac_index = 0;
540	538	}
541	539
542		static STREAM_UPDATE(digitalker_update)
	540
	541	//-------------------------------------------------
	542	// sound_stream_update - handle a stream update
	543	//-------------------------------------------------
	544
	545	void digitalker_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
543	546	{
544		digitalker dg = (digitalker )param;
545	547	stream_sample_t *sout = outputs[0];
546	548	int cpos = 0;
547	549	while(cpos != samples) {
548		if(dg->zero_count == 0 && dg->dac_index == 128)
549		digitalker_step(dg);
	550	if(m_zero_count == 0 && m_dac_index == 128)
	551	digitalker_step();
550	552
551		if(~~dg->~~zero_count) {
	553	if(m_zero_count) {
552	554	int n = samples - cpos;
553	555	int i;
554		if(n > dg->zero_count)
555		n = dg->zero_count;
	556	if(n > m_zero_count)
	557	n = m_zero_count;
556	558	for(i=0; i != n; i++)
557	559	sout[cpos++] = 0;
558		~~dg->~~zero_count -= n;
	560	m_zero_count -= n;
559	561
560		} else if(dg->dac_index != 128) {
561		while(cpos != samples && dg->dac_index != 128) {
562		short v = dg->dac[dg->dac_index];
563		int pp = dg->pitch_pos;
564		while(cpos != samples && pp != dg->pitch) {
	562	} else if(m_dac_index != 128) {
	563	while(cpos != samples && m_dac_index != 128) {
	564	short v = m_dac[m_dac_index];
	565	int pp = m_pitch_pos;
	566	while(cpos != samples && pp != m_pitch) {
565	567	sout[cpos++] = v;
566	568	pp++;
567	569	}
568		if(pp == ~~dg->~~pitch) {
	570	if(pp == m_pitch) {
569	571	pp = 0;
570		~~dg->~~dac_index++;
	572	m_dac_index++;
571	573	}
572		~~dg->~~pitch_pos = pp;
	574	m_pitch_pos = pp;
573	575	}
574	576
575	577	} else {
r20674	r20675
579	581	}
580	582	}
581	583
582		~~static~~ void digitalker_c~~s_w(~~digitalker *dg, int line)
	584	void digitalker_device::digitalker_cs_w(int line)
583	585	{
584	586	UINT8 cs = line == ASSERT_LINE ? 1 : 0;
585		if(cs == ~~dg->~~cs)
	587	if(cs == m_cs)
586	588	return;
587		~~dg->~~cs = cs;
	589	m_cs = cs;
588	590	if(cs)
589	591	return;
590		if(!dg->wr) {
591		if(dg->cms)
592		digitalker_set_intr(dg, 1);
	592	if(!m_wr) {
	593	if(m_cms)
	594	digitalker_set_intr(1);
593	595	else
594		digitalker_start_command(~~dg, dg->~~data);
	596	digitalker_start_command(m_data);
595	597	}
596	598	}
597	599
598		~~static~~ void digitalker_c~~ms_w(~~digitalker *dg, int line)
	600	void digitalker_device::digitalker_cms_w(int line)
599	601	{
600		~~dg->~~cms = line == ASSERT_LINE ? 1 : 0;
	602	m_cms = line == ASSERT_LINE ? 1 : 0;
601	603	}
602	604
603		~~static~~ void digitalker_~~wr_w(~~digitalker *dg, int line)
	605	void digitalker_device::digitalker_wr_w(int line)
604	606	{
605	607	UINT8 wr = line == ASSERT_LINE ? 1 : 0;
606		if(wr == ~~dg->~~wr)
	608	if(wr == m_wr)
607	609	return;
608		dg->wr = wr;
609		if(wr \|\| dg->cs)
	610	m_wr = wr;
	611	if(wr \|\| m_cs)
610	612	return;
611		if(dg->cms)
612		digitalker_set_intr(dg, 1);
	613	if(m_cms)
	614	digitalker_set_intr(1);
613	615	else
614		digitalker_start_command(~~dg, dg->~~data);
	616	digitalker_start_command(m_data);
615	617	}
616	618
617		~~stat~~i~~c i~~nt digitalker_i~~ntr_r(~~digitalker *dg)
	619	int digitalker_device::digitalker_intr_r()
618	620	{
619		return ~~dg->~~intr ? ASSERT_LINE : CLEAR_LINE;
	621	return m_intr ? ASSERT_LINE : CLEAR_LINE;
620	622	}
621	623
622		~~static~~ void digitalker_register_for_save(~~digitalker *dg~~)
	624	void digitalker_device::digitalker_register_for_save()
623	625	{
624		dg->device->save_item(NAME(dg->data));
625		dg->device->save_item(NAME(dg->cs));
626		dg->device->save_item(NAME(dg->cms));
627		dg->device->save_item(NAME(dg->wr));
628		dg->device->save_item(NAME(dg->intr));
629		dg->device->save_item(NAME(dg->bpos));
630		dg->device->save_item(NAME(dg->apos));
631		dg->device->save_item(NAME(dg->mode));
632		dg->device->save_item(NAME(dg->cur_segment));
633		dg->device->save_item(NAME(dg->cur_repeat));
634		dg->device->save_item(NAME(dg->segments));
635		dg->device->save_item(NAME(dg->repeats));
636		dg->device->save_item(NAME(dg->prev_pitch));
637		dg->device->save_item(NAME(dg->pitch));
638		dg->device->save_item(NAME(dg->pitch_pos));
639		dg->device->save_item(NAME(dg->stop_after));
640		dg->device->save_item(NAME(dg->cur_dac));
641		dg->device->save_item(NAME(dg->cur_bits));
642		dg->device->save_item(NAME(dg->zero_count));
643		dg->device->save_item(NAME(dg->dac_index));
644		dg->device->save_item(NAME(dg->dac));
	626	save_item(NAME(m_data));
	627	save_item(NAME(m_cs));
	628	save_item(NAME(m_cms));
	629	save_item(NAME(m_wr));
	630	save_item(NAME(m_intr));
	631	save_item(NAME(m_bpos));
	632	save_item(NAME(m_apos));
	633	save_item(NAME(m_mode));
	634	save_item(NAME(m_cur_segment));
	635	save_item(NAME(m_cur_repeat));
	636	save_item(NAME(m_segments));
	637	save_item(NAME(m_repeats));
	638	save_item(NAME(m_prev_pitch));
	639	save_item(NAME(m_pitch));
	640	save_item(NAME(m_pitch_pos));
	641	save_item(NAME(m_stop_after));
	642	save_item(NAME(m_cur_dac));
	643	save_item(NAME(m_cur_bits));
	644	save_item(NAME(m_zero_count));
	645	save_item(NAME(m_dac_index));
	646	save_item(NAME(m_dac));
645	647	}
646	648
647		static DEVICE_START(digitalker)
648		{
649		digitalker *dg = get_safe_token(device);
650		dg->device = device;
651		dg->rom = device->machine().root_device().memregion(device->tag())->base();
652		dg->stream = device->machine().sound().stream_alloc(*device, 0, 1, device->clock()/4, dg, digitalker_update);
653		dg->dac_index = 128;
654		dg->data = 0xff;
655		dg->cs = dg->cms = dg->wr = 1;
656		dg->bpos = 0xffff;
657		digitalker_set_intr(dg, 1);
658	649
659		digitalker_register_for_save(dg);
660		}
	650	//-------------------------------------------------
	651	// device_start - device-specific startup
	652	//-------------------------------------------------
661	653
662		void digitalker_~~0_cs_w(~~device_t *device~~, in~~t ~~line~~)
	654	void digitalker_device::device_start()
663	655	{
664		digitalker *dg = get_safe_token(device);
665		digitalker_cs_w(dg, line);
666		}
	656	m_rom = machine().root_device().memregion(tag())->base();
	657	m_stream = stream_alloc(0, 1, clock()/4);
	658	m_dac_index = 128;
	659	m_data = 0xff;
	660	m_cs = m_cms = m_wr = 1;
	661	m_bpos = 0xffff;
	662	digitalker_set_intr(1);
667	663
668		void digitalker_0_cms_w(device_t *device, int line)
669		{
670		digitalker *dg = get_safe_token(device);
671		digitalker_cms_w(dg, line);
	664	digitalker_register_for_save();
672	665	}
673	666
674		void digitalker_~~0_wr_w(~~device_t *device, int line)
	667	void digitalker_device::digitalker_0_cs_w(int line)
675	668	{
676		digitalker *dg = get_safe_token(device);
677		digitalker_wr_w(dg, line);
	669	digitalker_cs_w(line);
678	670	}
679	671
680		int digitalker_~~0_intr_r(~~device_t *device)
	672	void digitalker_device::digitalker_0_cms_w(int line)
681	673	{
682		digitalker *dg = get_safe_token(device);
683		return digitalker_intr_r(dg);
	674	digitalker_cms_w(line);
684	675	}
685	676
686		~~WRITE8_DEVICE_HANDLER(~~ digitalker_data_w )
	677	void digitalker_device::digitalker_0_wr_w(int line)
687	678	{
688		digitalker *dg = get_safe_token(device);
689		dg->data = data;
	679	digitalker_wr_w(line);
690	680	}
691	681
692
693		const device_type DIGITALKER = &device_creator<digitalker_device>;
694
695		digitalker_device::digitalker_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
696		: device_t(mconfig, DIGITALKER, "Digitalker", tag, owner, clock),
697		device_sound_interface(mconfig, *this)
	682	int digitalker_device::digitalker_0_intr_r()
698	683	{
699		~~m_tok~~en ~~= global_alloc_clear(~~digitalker);
	684	return digitalker_intr_r();
700	685	}
701	686
702		//-------------------------------------------------
703		// device_config_complete - perform any
704		// operations now that the configuration is
705		// complete
706		//-------------------------------------------------
707
708		void digitalker_device::device_config_complete()
	687	WRITE8_MEMBER( digitalker_device::digitalker_data_w )
709	688	{
	689	m_data = data;
710	690	}
711	691
712		//-------------------------------------------------
713		// device_start - device-specific startup
714		//-------------------------------------------------
715
716		void digitalker_device::device_start()
717		{
718		DEVICE_START_NAME( digitalker )(this);
719		}
720
721		//-------------------------------------------------
722		// sound_stream_update - handle a stream update
723		//-------------------------------------------------
724
725		void digitalker_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
726		{
727		// should never get here
728		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
729		}

trunk/src/emu/sound/n63701x.h
r20674	r20675
3	3	#ifndef __N63701X_H__
4	4	#define __N63701X_H__
5	5
6		#include "devlegcy.h"
	6	//**************************************************************************
	7	// INTERFACE CONFIGURATION MACROS
	8	//**************************************************************************
7	9
8		DECLARE_WRITE8_DEVICE_HANDLER( namco_63701x_w );
	10	#define MCFG_NAMCO_63701X_ADD(_tag, _clock) \
	11	MCFG_DEVICE_ADD(_tag, NAMCO_63701X, _clock)
	12	#define MCFG_NAMCO_63701X_REPLACE(_tag, _clock) \
	13	MCFG_DEVICE_REPLACE(_tag, NAMCO_63701X, _clock)
9	14
	15
	16	//**************************************************************************
	17	// TYPE DEFINITIONS
	18	//**************************************************************************
	19
	20	struct voice_63701x
	21	{
	22	int select;
	23	int playing;
	24	int base_addr;
	25	int position;
	26	int volume;
	27	int silence_counter;
	28	};
	29
	30
	31	// ======================> namco_63701x_device
	32
10	33	class namco_63701x_device : public device_t,
11		public device_sound_interface
	34	public device_sound_interface
12	35	{
13	36	public:
14	37	namco_63701x_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
15		~namco_63701x_device() { ~~global_free(m_token);~~ }
	38	~namco_63701x_device() { }
16	39
17		// access to legacy token
18		void *token() const { assert(m_token != NULL); return m_token; }
19	40	protected:
20	41	// device-level overrides
21		virtual void device_config_complete();
22	42	virtual void device_start();
23	43
24	44	// sound stream update overrides
25	45	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
	46
	47	public:
	48	DECLARE_WRITE8_MEMBER(namco_63701x_w);
	49
26	50	private:
27		// internal state
28		void *m_token;
	51	voice_63701x m_voices[2];
	52	sound_stream m_stream; / channel assigned by the mixer */
	53	UINT8 m_rom; / pointer to sample ROM */
29	54	};
30	55
31	56	extern const device_type NAMCO_63701X;

trunk/src/emu/sound/digitalk.h
r20674	r20675
1	1	#ifndef _DIGITALKER_H_
2	2	#define _DIGITALKER_H_
3	3
4		#include "devlegcy.h"
5	4
6		void digitalker_0_cs_w(device_t *device, int line);
7		void digitalker_0_cms_w(device_t *device, int line);
8		void digitalker_0_wr_w(device_t *device, int line);
9		int digitalker_0_intr_r(device_t *device);
10		DECLARE_WRITE8_DEVICE_HANDLER(digitalker_data_w);
	5	//**************************************************************************
	6	// INTERFACE CONFIGURATION MACROS
	7	//**************************************************************************
11	8
	9	#define MCFG_DIGITALKER_ADD(_tag, _clock) \
	10	MCFG_DEVICE_ADD(_tag, DIGITALKER, _clock)
	11	#define MCFG_DIGITALKER_REPLACE(_tag, _clock) \
	12	MCFG_DEVICE_REPLACE(_tag, DIGITALKER, _clock)
	13
	14
	15	//**************************************************************************
	16	// TYPE DEFINITIONS
	17	//**************************************************************************
	18
	19	// ======================> digitalker_device
	20
12	21	class digitalker_device : public device_t,
13		public device_sound_interface
	22	public device_sound_interface
14	23	{
15	24	public:
16	25	digitalker_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
17		~digitalker_device() { ~~global_free(m_token);~~ }
	26	~digitalker_device() { }
18	27
19		// access to legacy token
20		void *token() const { assert(m_token != NULL); return m_token; }
	28	void digitalker_0_cs_w(int line);
	29	void digitalker_0_cms_w(int line);
	30	void digitalker_0_wr_w(int line);
	31	int digitalker_0_intr_r();
	32
21	33	protected:
22	34	// device-level overrides
23		virtual void device_config_complete();
24	35	virtual void device_start();
25	36
26	37	// sound stream update overrides
27	38	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
	39
	40	public:
	41	DECLARE_WRITE8_MEMBER(digitalker_data_w);
	42
28	43	private:
29		// internal state
30		void *m_token;
	44	void digitalker_write(UINT8 *adr, UINT8 vol, INT8 dac);
	45	UINT8 digitalker_pitch_next(UINT8 val, UINT8 prev, int step);
	46	void digitalker_set_intr(UINT8 intr);
	47	void digitalker_start_command(UINT8 cmd);
	48	void digitalker_step_mode_0();
	49	void digitalker_step_mode_1();
	50	void digitalker_step_mode_2();
	51	void digitalker_step_mode_3();
	52	void digitalker_step();
	53	void digitalker_cs_w(int line);
	54	void digitalker_cms_w(int line);
	55	void digitalker_wr_w(int line);
	56	int digitalker_intr_r();
	57	void digitalker_register_for_save();
	58
	59	private:
	60	const UINT8 *m_rom;
	61	sound_stream *m_stream;
	62
	63	// Port/lines state
	64	UINT8 m_data;
	65	UINT8 m_cs;
	66	UINT8 m_cms;
	67	UINT8 m_wr;
	68	UINT8 m_intr;
	69
	70	// Current decoding state
	71	UINT16 m_bpos;
	72	UINT16 m_apos;
	73
	74	UINT8 m_mode;
	75	UINT8 m_cur_segment;
	76	UINT8 m_cur_repeat;
	77	UINT8 m_segments;
	78	UINT8 m_repeats;
	79
	80	UINT8 m_prev_pitch;
	81	UINT8 m_pitch;
	82	UINT8 m_pitch_pos;
	83
	84	UINT8 m_stop_after;
	85	UINT8 m_cur_dac;
	86	UINT8 m_cur_bits;
	87
	88	// Zero-range size
	89	UINT32 m_zero_count; // 0 for done
	90
	91	// Waveform and current index in it
	92	UINT8 m_dac_index; // 128 for done
	93	INT16 m_dac[128];
31	94	};
32	95
33	96	extern const device_type DIGITALKER;

trunk/src/emu/sound/tiaintf.c
r20674	r20675
2	2	#include "tiaintf.h"
3	3	#include "tiasound.h"
4	4
5		struct tia_state
6		{
7		sound_stream * channel;
8		void *chip;
9		};
	5	// device type definition
	6	const device_type TIA = &device_creator<tia_device>;
10	7
11		INLINE tia_state get_safe_token(device_t device)
12		{
13		assert(device != NULL);
14		assert(device->type() == TIA);
15		return (tia_state )downcast<tia_device >(device)->token();
16		}
17	8
	9	//**************************************************************************
	10	// LIVE DEVICE
	11	//**************************************************************************
18	12
19		static STREAM_UPDATE( tia_update )
20		{
21		tia_state info = (tia_state )param;
22		tia_process(info->chip, outputs[0], samples);
23		}
	13	//-------------------------------------------------
	14	// tia_device - constructor
	15	//-------------------------------------------------
24	16
25
26		static DEVICE_START( tia )
27		{
28		tia_state *info = get_safe_token(device);
29
30		info->channel = device->machine().sound().stream_alloc(*device, 0, 1, device->clock(), info, tia_update);
31
32		info->chip = tia_sound_init(device->clock(), device->clock(), 16);
33		assert_always(info->chip != NULL, "Error creating TIA chip");
34		}
35
36		static DEVICE_STOP( tia )
37		{
38		tia_state *info = get_safe_token(device);
39		tia_sound_free(info->chip);
40		}
41
42		WRITE8_DEVICE_HANDLER( tia_sound_w )
43		{
44		tia_state *info = get_safe_token(device);
45		info->channel->update();
46		tia_write(info->chip, offset, data);
47		}
48
49		const device_type TIA = &device_creator<tia_device>;
50
51	17	tia_device::tia_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
52	18	: device_t(mconfig, TIA, "TIA", tag, owner, clock),
53		device_sound_interface(mconfig, *this)
	19	device_sound_interface(mconfig, *this),
	20	m_channel(NULL),
	21	m_chip(NULL)
54	22	{
55		m_token = global_alloc_clear(tia_state);
56	23	}
57	24
58		//-------------------------------------------------
59		// device_config_complete - perform any
60		// operations now that the configuration is
61		// complete
62		//-------------------------------------------------
63	25
64		void tia_device::device_config_complete()
65		{
66		}
67
68	26	//-------------------------------------------------
69	27	// device_start - device-specific startup
70	28	//-------------------------------------------------
71	29
72	30	void tia_device::device_start()
73	31	{
74		DEVICE_START_NAME( tia )(this);
	32	m_channel = stream_alloc(0, 1, clock());
	33	m_chip = tia_sound_init(clock(), clock(), 16);
	34	assert_always(m_chip != NULL, "Error creating TIA chip");
75	35	}
76	36
	37
77	38	//-------------------------------------------------
78	39	// device_stop - device-specific stop
79	40	//-------------------------------------------------
80	41
81	42	void tia_device::device_stop()
82	43	{
83		~~DEVICE_STOP_NAME(~~ tia )(this);
	44	tia_sound_free(m_chip);
84	45	}
85	46
	47
86	48	//-------------------------------------------------
87	49	// sound_stream_update - handle a stream update
88	50	//-------------------------------------------------
89	51
90	52	void tia_device::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
91	53	{
92		// should never get here
93		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
	54	tia_process(m_chip, outputs[0], samples);
94	55	}
	56
	57
	58	WRITE8_MEMBER( tia_device::tia_sound_w )
	59	{
	60	m_channel->update();
	61	tia_write(m_chip, offset, data);
	62	}

trunk/src/emu/sound/tiaintf.h
r20674	r20675
3	3	#ifndef __TIAINTF_H__
4	4	#define __TIAINTF_H__
5	5
6		#include "devlegcy.h"
	6	//**************************************************************************
	7	// INTERFACE CONFIGURATION MACROS
	8	//**************************************************************************
7	9
8		DECLARE_WRITE8_DEVICE_HANDLER( tia_sound_w );
	10	#define MCFG_SOUND_TIA_ADD(_tag, _clock) \
	11	MCFG_DEVICE_ADD(_tag, TIA, _clock)
	12	#define MCFG_SOUND_TIA_REPLACE(_tag, _clock) \
	13	MCFG_DEVICE_REPLACE(_tag, TIA, _clock)
9	14
	15
	16	//**************************************************************************
	17	// TYPE DEFINITIONS
	18	//**************************************************************************
	19
	20	// ======================> tia_device
	21
10	22	class tia_device : public device_t,
11		public device_sound_interface
	23	public device_sound_interface
12	24	{
13	25	public:
14	26	tia_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
15		~tia_device() { ~~global_free(m_token);~~ }
	27	~tia_device() { }
16	28
17		// access to legacy token
18		void *token() const { assert(m_token != NULL); return m_token; }
19	29	protected:
20	30	// device-level overrides
21		virtual void device_config_complete();
22	31	virtual void device_start();
23	32	virtual void device_stop();
24	33
25	34	// sound stream update overrides
26	35	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
	36
	37	public:
	38	DECLARE_WRITE8_MEMBER( tia_sound_w );
	39
27	40	private:
28		// internal state
29		void *m_token;
	41	sound_stream *m_channel;
	42	void *m_chip;
30	43	};
31	44
32	45	extern const device_type TIA;

trunk/src/mess/drivers/a2600.c
r20674	r20675
1951	1951
1952	1952	/* sound hardware */
1953	1953	MCFG_SPEAKER_STANDARD_MONO("mono")
1954		MCFG_SOUND_ADD("tia"~~, TIA~~, MASTER_CLOCK_NTSC/114)
	1954	MCFG_SOUND_TIA_ADD("tia", MASTER_CLOCK_NTSC/114)
1955	1955	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90)
1956	1956	MCFG_SOUND_WAVE_ADD(WAVE_TAG, CASSETTE_TAG)
1957	1957	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
r20674	r20675
1988	1988
1989	1989	/* sound hardware */
1990	1990	MCFG_SPEAKER_STANDARD_MONO("mono")
1991		MCFG_SOUND_ADD("tia"~~, TIA~~, MASTER_CLOCK_PAL/114)
	1991	MCFG_SOUND_TIA_ADD("tia", MASTER_CLOCK_PAL/114)
1992	1992	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.90)
1993	1993	MCFG_SOUND_WAVE_ADD(WAVE_TAG, CASSETTE_TAG)
1994	1994	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)

trunk/src/mess/drivers/a7800.c
r20674	r20675
291	291
292	292	/* sound hardware */
293	293	MCFG_SPEAKER_STANDARD_MONO("mono")
294		MCFG_SOUND_ADD("tia"~~, TIA~~, 31400)
	294	MCFG_SOUND_TIA_ADD("tia", 31400)
295	295	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
296	296	MCFG_POKEY_ADD("pokey", A7800_NTSC_Y1/8)
297	297	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)

trunk/src/mess/machine/a7800.c
r20674	r20675
524	524	}
525	525	break;
526	526	}
527		~~tia_sound_w(~~machine().device("tia"), space, offset, data);
	527	machine().device<tia_device>("tia")->tia_sound_w(space, offset, data);
528	528	m_ROM[offset] = data;
529	529	}

trunk/src/mame/drivers/seta2.c
r20674	r20675
161	161	AM_RANGE(0x700004, 0x700005) AM_READ_PORT("SYSTEM") // Coins
162	162	AM_RANGE(0x70000c, 0x70000d) AM_READ(watchdog_reset16_r) // Watchdog
163	163	AM_RANGE(0x800000, 0x800001) AM_WRITE(grdians_lockout_w)
164		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	164	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
165	165	AM_RANGE(0xc00000, 0xc3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
166	166	AM_RANGE(0xc40000, 0xc4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
167	167	AM_RANGE(0xc50000, 0xc5ffff) AM_RAM // cleared
r20674	r20675
203	203	AM_RANGE(0x70000a, 0x70000b) AM_READ_PORT("IN1") // P2
204	204	AM_RANGE(0x70000c, 0x70000d) AM_WRITE(watchdog_reset16_w)
205	205	AM_RANGE(0x800000, 0x800001) AM_WRITE(grdians_lockout_w)
206		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	206	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
207	207	AM_RANGE(0xc00000, 0xc3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
208	208	AM_RANGE(0xc40000, 0xc4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
209	209	AM_RANGE(0xc50000, 0xc5ffff) AM_RAM // cleared
r20674	r20675
262	262	AM_RANGE(0x600300, 0x600301) AM_READ_PORT("DSW1") // DSW 1
263	263	AM_RANGE(0x600302, 0x600303) AM_READ_PORT("DSW2") // DSW 2
264	264	AM_RANGE(0x600300, 0x60030f) AM_WRITE(seta2_sound_bank_w) // Samples Banks
265		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	265	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
266	266	AM_RANGE(0xc00000, 0xc3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
267	267	AM_RANGE(0xc40000, 0xc4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
268	268	AM_RANGE(0xc60000, 0xc6003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
r20674	r20675
285	285	AM_RANGE(0x700300, 0x700301) AM_READ_PORT("DSW1") // DSW 1
286	286	AM_RANGE(0x700302, 0x700303) AM_READ_PORT("DSW2") // DSW 2
287	287	AM_RANGE(0x700310, 0x70031f) AM_WRITE(seta2_sound_bank_w) // Samples Banks
288		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	288	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
289	289	AM_RANGE(0xc00000, 0xc3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
290	290	AM_RANGE(0xc40000, 0xc4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
291	291	AM_RANGE(0xc60000, 0xc6003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
r20674	r20675
308	308	AM_RANGE(0x600300, 0x600301) AM_READ_PORT("DSW1") // DSW 1
309	309	AM_RANGE(0x600302, 0x600303) AM_READ_PORT("DSW2") // DSW 2
310	310	AM_RANGE(0x600300, 0x60030f) AM_WRITE(seta2_sound_bank_w) // Samples Banks
311		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	311	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
312	312	AM_RANGE(0xd00000, 0xd3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
313	313	AM_RANGE(0xd40000, 0xd4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
314	314	AM_RANGE(0xd60000, 0xd6003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
r20674	r20675
356	356	AM_RANGE(0x800000, 0x83ffff) AM_RAM AM_SHARE("spriteram") // Sprites
357	357	AM_RANGE(0x840000, 0x84ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
358	358	AM_RANGE(0x860000, 0x86003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
359		AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	359	AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
360	360	AM_RANGE(0xfffc00, 0xffffff) AM_READWRITE_LEGACY(tmp68301_regs_r, tmp68301_regs_w) // TMP68301 Registers
361	361	ADDRESS_MAP_END
362	362
r20674	r20675
382	382	AM_RANGE(0xb00000, 0xb3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
383	383	AM_RANGE(0xb40000, 0xb4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
384	384	AM_RANGE(0xb60000, 0xb6003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs")
385		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	385	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
386	386	AM_RANGE(0xfffc00, 0xffffff) AM_READWRITE_LEGACY(tmp68301_regs_r, tmp68301_regs_w) // TMP68301 Registers
387	387	ADDRESS_MAP_END
388	388
r20674	r20675
437	437	AM_RANGE(0x400300, 0x400301) AM_READ_PORT("DSW1") // DSW 1
438	438	AM_RANGE(0x400302, 0x400303) AM_READ_PORT("DSW2") // DSW 2
439	439	AM_RANGE(0x400300, 0x40030f) AM_WRITE(seta2_sound_bank_w) // Samples Banks
440		AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	440	AM_RANGE(0xb00000, 0xb03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
441	441	AM_RANGE(0xc00000, 0xc3ffff) AM_RAM AM_SHARE("spriteram") // Sprites
442	442	AM_RANGE(0xc40000, 0xc4ffff) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
443	443	AM_RANGE(0xc60000, 0xc6003f) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
r20674	r20675
499	499	AM_RANGE( 0x840000, 0x84ffff ) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_word_w) AM_SHARE("paletteram") // Palette
500	500	AM_RANGE( 0x860000, 0x86003f ) AM_WRITE(seta2_vregs_w) AM_SHARE("vregs") // Video Registers
501	501
502		AM_RANGE( 0x900000, 0x903fff ) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r, seta_sound_word_w ) // Sound
	502	AM_RANGE( 0x900000, 0x903fff ) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w ) // Sound
503	503
504	504	AM_RANGE( 0xfffd0a, 0xfffd0b ) AM_READ_PORT("DSW2") // parallel data register (DSW 2)
505	505	AM_RANGE( 0xfffc00, 0xffffff ) AM_READWRITE_LEGACY(tmp68301_regs_r, tmp68301_regs_w) // TMP68301 Registers
r20674	r20675
2042	2042	// sound hardware
2043	2043	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2044	2044
2045		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, XTAL_50MHz/3) // clock?
	2045	MCFG_X1_010_ADD("x1snd", XTAL_50MHz/3) // clock?
2046	2046	MCFG_SOUND_CONFIG(x1_010_sound_intf)
2047	2047	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2048	2048	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)

trunk/src/mame/drivers/galaxian.c
r20674	r20675
1031	1031
1032	1032	READ8_MEMBER(galaxian_state::scorpion_digitalker_intr_r)
1033	1033	{
1034		device_t *digitalker = machine().device("digitalker");
1035		return digitalker_0_intr_r(digitalker);
	1034	digitalker_device *digitalker = machine().device<digitalker_device>("digitalker");
	1035	return digitalker->digitalker_0_intr_r();
1036	1036	}
1037	1037
1038	1038	WRITE8_MEMBER(galaxian_state::scorpion_digitalker_control_w)
1039	1039	{
1040		device_t *device = machine().device("digitalker");
1041		digitalker_0_cs_w(device, data & 1 ? ASSERT_LINE : CLEAR_LINE);
1042		digitalker_0_cms_w(device, data & 2 ? ASSERT_LINE : CLEAR_LINE);
1043		digitalker_0_wr_w(device, data & 4 ? ASSERT_LINE : CLEAR_LINE);
	1040	digitalker_device *device = machine().device<digitalker_device>("digitalker");
	1041	device->digitalker_0_cs_w(data & 1 ? ASSERT_LINE : CLEAR_LINE);
	1042	device->digitalker_0_cms_w(data & 2 ? ASSERT_LINE : CLEAR_LINE);
	1043	device->digitalker_0_wr_w(data & 4 ? ASSERT_LINE : CLEAR_LINE);
1044	1044	}
1045	1045
1046	1046	static I8255A_INTERFACE( scorpion_ppi8255_1_intf )
r20674	r20675
2004	2004	AY8910_DEFAULT_LOADS,
2005	2005	DEVCB_NULL,
2006	2006	DEVCB_NULL,
2007		DEVCB_DEVICE_~~HANDL~~ER("digitalker", digitalker_data_w),
	2007	DEVCB_DEVICE_MEMBER("digitalker", digitalker_device, digitalker_data_w),
2008	2008	DEVCB_DRIVER_MEMBER(galaxian_state,scorpion_digitalker_control_w)
2009	2009	};
2010	2010
r20674	r20675
2416	2416	MCFG_SOUND_CONFIG(scorpion_ay8910_interface)
2417	2417	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
2418	2418
2419		MCFG_~~SOUN~~D_ADD("digitalker"~~, DIGITALKER~~, 4000000)
	2419	MCFG_DIGITALKER_ADD("digitalker", 4000000)
2420	2420	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.16)
2421	2421	MACHINE_CONFIG_END
2422	2422

trunk/src/mame/drivers/seta.c
r20674	r20675
1654	1654
1655	1655	static ADDRESS_MAP_START( downtown_map, AS_PROGRAM, 16, seta_state )
1656	1656	AM_RANGE(0x000000, 0x09ffff) AM_ROM // ROM
1657		AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	1657	AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
1658	1658	AM_RANGE(0x200000, 0x200001) AM_NOP // watchdog? (twineagl)
1659	1659	AM_RANGE(0x300000, 0x300001) AM_WRITENOP // IRQ enable/acknowledge?
1660	1660	AM_RANGE(0x400000, 0x400007) AM_WRITE(twineagl_tilebank_w) // special tile banking to animate water in twineagl
r20674	r20675
1823	1823	static ADDRESS_MAP_START( atehate_map, AS_PROGRAM, 16, seta_state )
1824	1824	AM_RANGE(0x000000, 0x0fffff) AM_ROM // ROM
1825	1825	AM_RANGE(0x900000, 0x9fffff) AM_RAM // RAM
1826		AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	1826	AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
1827	1827	AM_RANGE(0x200000, 0x200001) AM_WRITENOP // ? watchdog ?
1828	1828	AM_RANGE(0x300000, 0x300001) AM_WRITENOP // ? 0 (irq ack lev 2?)
1829	1829	AM_RANGE(0x500000, 0x500001) AM_WRITENOP // ? (end of lev 1: bit 4 goes 1,0,1)
r20674	r20675
1866	1866	AM_RANGE(0xb04000, 0xb0ffff) AM_RAM // (jjsquawk)
1867	1867	AM_RANGE(0xb80000, 0xb83fff) AM_RAM_WRITE(seta_vram_2_w) AM_SHARE("vram_2") // VRAM 2&3
1868	1868	AM_RANGE(0xb84000, 0xb8ffff) AM_RAM // (jjsquawk)
1869		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	1869	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
1870	1870	AM_RANGE(0xd00000, 0xd00007) AM_WRITENOP // ?
1871	1871	AM_RANGE(0xe00000, 0xe00001) AM_WRITENOP // ? VBlank IRQ Ack
1872	1872	AM_RANGE(0xf00000, 0xf00001) AM_WRITENOP // ? Sound IRQ Ack
r20674	r20675
1901	1901	AM_RANGE(0xa00600, 0xa00607) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritectrl_r16, spritectrl_w16)
1902	1902	/**/AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
1903	1903	AM_RANGE(0xb00000, 0xb03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
1904		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	1904	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
1905	1905	AM_RANGE(0xd00000, 0xd00007) AM_WRITENOP // ?
1906	1906	AM_RANGE(0xe00000, 0xe00001) AM_WRITENOP // ? VBlank IRQ Ack
1907	1907	AM_RANGE(0xf00000, 0xf00001) AM_WRITENOP // ? Sound IRQ Ack
r20674	r20675
1981	1981	AM_RANGE(0xa00600, 0xa00607) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritectrl_r16, spritectrl_w16)
1982	1982	/**/AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
1983	1983	AM_RANGE(0xb00000, 0xb03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
1984		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	1984	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
1985	1985	#if __uPD71054_TIMER
1986	1986	AM_RANGE(0xd00000, 0xd00007) AM_WRITE(timer_regs_w) // ?
1987	1987	#else
r20674	r20675
2057	2057	AM_RANGE(0xa0a600, 0xa0a607) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritectrl_r16, spritectrl_w16)
2058	2058	// AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
2059	2059	AM_RANGE(0xb0c000, 0xb0ffff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // RZ: Sprites Code + X + Attr
2060		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2060	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2061	2061	#if __uPD71054_TIMER
2062	2062	AM_RANGE(0xd00000, 0xd00007) AM_WRITE(timer_regs_w) // ?
2063	2063	#else
r20674	r20675
2084	2084	//AM_RANGE(0x600000, 0x60000f) AM_READ(krzybowl_input_r ) // P1
2085	2085	AM_RANGE(0x8000f0, 0x8000f1) AM_RAM // NVRAM
2086	2086	AM_RANGE(0x800100, 0x8001ff) AM_RAM // NVRAM
2087		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2087	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2088	2088	AM_RANGE(0xb00000, 0xb003ff) AM_RAM AM_SHARE("paletteram") // Palette
2089	2089	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2090	2090	/**/AM_RANGE(0xd00000, 0xd00001) AM_RAM // ? 0x4000
r20674	r20675
2165	2165	AM_RANGE(0x800100, 0x8001ff) AM_RAM // NVRAM
2166	2166	AM_RANGE(0x900000, 0x900001) AM_WRITENOP // ?
2167	2167	AM_RANGE(0x900002, 0x900003) AM_WRITE(keroppi_prize_w) //
2168		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2168	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2169	2169	AM_RANGE(0xb00000, 0xb003ff) AM_RAM AM_SHARE("paletteram") // Palette
2170	2170	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2171	2171	/**/AM_RANGE(0xd00000, 0xd00001) AM_RAM // ? 0x4000
r20674	r20675
2196	2196	AM_RANGE(0x500000, 0x500001) AM_READ_PORT("P1") // P1
2197	2197	AM_RANGE(0x500002, 0x500003) AM_READ_PORT("P2") // P2
2198	2198	AM_RANGE(0x500004, 0x500005) AM_READ_PORT("COINS") // Coins
2199		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2199	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2200	2200	AM_RANGE(0xb00000, 0xb003ff) AM_RAM AM_SHARE("paletteram") // Palette
2201	2201	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2202	2202	/**/AM_RANGE(0xd00000, 0xd00001) AM_RAM // ? 0x4000
r20674	r20675
2233	2233	AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
2234	2234	AM_RANGE(0xb00000, 0xb03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2235	2235	AM_RANGE(0xb04000, 0xb13fff) AM_RAM
2236		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2236	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2237	2237	AM_RANGE(0xe00000, 0xe00001) AM_WRITENOP //
2238	2238	ADDRESS_MAP_END
2239	2239
r20674	r20675
2246	2246	AM_RANGE(0x000000, 0x0bffff) AM_ROM // ROM
2247	2247	AM_RANGE(0xf00000, 0xf0ffff) AM_RAM // RAM (qzkklogy)
2248	2248	AM_RANGE(0xffc000, 0xffffff) AM_RAM // RAM (drgnunit,stg)
2249		AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2249	AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2250	2250	AM_RANGE(0x200000, 0x200001) AM_WRITENOP // Watchdog
2251	2251	AM_RANGE(0x300000, 0x300001) AM_WRITENOP // ? IRQ Ack
2252	2252	AM_RANGE(0x500000, 0x500001) AM_RAM_WRITE(seta_vregs_w) AM_SHARE("vregs") // Coin Lockout + Video Registers
r20674	r20675
2364	2364	/**/AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
2365	2365	AM_RANGE(0xb00000, 0xb03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2366	2366	AM_RANGE(0xb04000, 0xb13fff) AM_RAM //
2367		AM_RANGE(0xe00000, 0xe03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2367	AM_RANGE(0xe00000, 0xe03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2368	2368	ADDRESS_MAP_END
2369	2369
2370	2370
r20674	r20675
2401	2401	#else
2402	2402	AM_RANGE(0xc00000, 0xc00007) AM_WRITENOP // ?
2403	2403	#endif
2404		AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2404	AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2405	2405	ADDRESS_MAP_END
2406	2406
2407	2407	/* almost identical to kamenrid */
r20674	r20675
2430	2430	#else
2431	2431	AM_RANGE(0xc00000, 0xc00007) AM_WRITENOP // ?
2432	2432	#endif
2433		AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2433	AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2434	2434	ADDRESS_MAP_END
2435	2435
2436	2436
r20674	r20675
2477	2477	#else
2478	2478	AM_RANGE(0xc00000, 0xc00007) AM_WRITENOP // ?
2479	2479	#endif
2480		AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2480	AM_RANGE(0xd00000, 0xd03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2481	2481	ADDRESS_MAP_END
2482	2482
2483	2483
r20674	r20675
2522	2522	AM_RANGE(0x600000, 0x60000f) AM_READ(krzybowl_input_r) // P1
2523	2523	AM_RANGE(0x8000f0, 0x8000f1) AM_RAM // NVRAM
2524	2524	AM_RANGE(0x800100, 0x8001ff) AM_RAM // NVRAM
2525		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2525	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2526	2526	AM_RANGE(0xb00000, 0xb003ff) AM_RAM AM_SHARE("paletteram") // Palette
2527	2527	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2528	2528	/**/AM_RANGE(0xd00000, 0xd00001) AM_RAM // ? 0x4000
r20674	r20675
2568	2568	AM_RANGE(0xa80000, 0xa83fff) AM_RAM_WRITE(seta_vram_2_w) AM_SHARE("vram_2") // VRAM 2&3
2569	2569	AM_RANGE(0xb00000, 0xb00005) AM_RAM AM_SHARE("vctrl_0") // VRAM 0&1 Ctrl
2570	2570	AM_RANGE(0xb80000, 0xb80005) AM_RAM AM_SHARE("vctrl_2") // VRAM 2&3 Ctrl
2571		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2571	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2572	2572	#if __uPD71054_TIMER
2573	2573	AM_RANGE(0xd00000, 0xd00007) AM_WRITE(timer_regs_w) // ?
2574	2574	#else
r20674	r20675
2592	2592	AM_RANGE(0x400004, 0x400005) AM_READ_PORT("COINS") // Coins
2593	2593	AM_RANGE(0x400000, 0x400001) AM_WRITENOP // ? IRQ Ack
2594	2594	AM_RANGE(0x500000, 0x500005) AM_RAM_WRITE(seta_vregs_w) AM_SHARE("vregs") // Coin Lockout + Video Registers
2595		AM_RANGE(0x700000, 0x703fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2595	AM_RANGE(0x700000, 0x703fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2596	2596	AM_RANGE(0x800000, 0x803fff) AM_RAM_WRITE(seta_vram_0_w) AM_SHARE("vram_0") // VRAM 0&1
2597	2597	AM_RANGE(0x880000, 0x883fff) AM_RAM_WRITE(seta_vram_2_w) AM_SHARE("vram_2") // VRAM 2&3
2598	2598	/**/AM_RANGE(0x900000, 0x900005) AM_RAM AM_SHARE("vctrl_0") // VRAM 0&1 Ctrl
r20674	r20675
2683	2683	/**/AM_RANGE(0xa00000, 0xa005ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r16, spriteylow_w16) // Sprites Y
2684	2684	AM_RANGE(0xa00600, 0xa00607) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritectrl_r16, spritectrl_w16)
2685	2685	AM_RANGE(0xb00000, 0xb003ff) AM_RAM AM_SHARE("paletteram") // Palette
2686		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2686	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2687	2687	AM_RANGE(0xd00000, 0xd00009) AM_READ(kiwame_input_r) // mahjong panel
2688	2688	AM_RANGE(0xe00000, 0xe00003) AM_READ(seta_dsw_r) // DSW
2689	2689	ADDRESS_MAP_END
r20674	r20675
2708	2708	static ADDRESS_MAP_START( thunderl_map, AS_PROGRAM, 16, seta_state )
2709	2709	AM_RANGE(0x000000, 0x00ffff) AM_ROM // ROM
2710	2710	AM_RANGE(0xffc000, 0xffffff) AM_RAM // RAM
2711		AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2711	AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2712	2712	AM_RANGE(0x200000, 0x200001) AM_WRITENOP // ?
2713	2713	AM_RANGE(0x300000, 0x300001) AM_WRITENOP // ?
2714	2714	AM_RANGE(0x400000, 0x40ffff) AM_WRITE(thunderl_protection_w) // Protection (not in wits)
r20674	r20675
2732	2732	static ADDRESS_MAP_START( thunderlbl_map, AS_PROGRAM, 16, seta_state )
2733	2733	AM_RANGE(0x000000, 0x00ffff) AM_ROM // ROM
2734	2734	AM_RANGE(0xffc000, 0xffffff) AM_RAM // RAM
2735		// AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2735	// AM_RANGE(0x100000, 0x103fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2736	2736	AM_RANGE(0x200000, 0x200001) AM_WRITENOP // ?
2737	2737	AM_RANGE(0x300000, 0x300001) AM_WRITENOP // ?
2738	2738	// AM_RANGE(0x400000, 0x40ffff) AM_WRITE(thunderl_protection_w) // Protection (not in wits)
r20674	r20675
2818	2818	AM_RANGE(0xa00600, 0xa00607) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritectrl_r16, spritectrl_w16)
2819	2819	/**/AM_RANGE(0xa80000, 0xa80001) AM_RAM // ? 0x4000
2820	2820	AM_RANGE(0xb00000, 0xb03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2821		AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2821	AM_RANGE(0xc00000, 0xc03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2822	2822	ADDRESS_MAP_END
2823	2823
2824	2824
r20674	r20675
2886	2886	AM_RANGE(0x500002, 0x500003) AM_READ_PORT("P2") // P2
2887	2887	AM_RANGE(0x500004, 0x500005) AM_READ_PORT("COINS") // Coins
2888	2888	AM_RANGE(0x900000, 0x9001ff) AM_READWRITE(pairlove_prot_r,pairlove_prot_w)
2889		AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r,seta_sound_word_w) // Sound
	2889	AM_RANGE(0xa00000, 0xa03fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
2890	2890	AM_RANGE(0xb00000, 0xb00fff) AM_RAM AM_SHARE("paletteram") // Palette
2891	2891	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecode_r16, spritecode_w16) // Sprites Code + X + Attr
2892	2892	AM_RANGE(0xd00000, 0xd00001) AM_RAM // ? 0x4000
r20674	r20675
2976	2976
2977	2977	AM_RANGE(0x800000, 0x80001f) AM_DEVREADWRITE8("rtc", msm6242_device, read, write, 0x00ff)
2978	2978
2979		AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r, seta_sound_word_w ) // Sound
	2979	AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w ) // Sound
2980	2980
2981	2981	AM_RANGE(0xa00000, 0xa00005) AM_WRITEONLY AM_SHARE("vctrl_0") // VRAM 0&1 Ctrl
2982	2982	AM_RANGE(0xb00000, 0xb03fff) AM_RAM_WRITE(seta_vram_0_w) AM_SHARE("vram_0") // VRAM 0&1
r20674	r20675
3038	3038
3039	3039	AM_RANGE(0x800000, 0x80001f) AM_DEVREADWRITE8("rtc", msm6242_device, read, write, 0x00ff)
3040	3040
3041		AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_word_r, seta_sound_word_w) // Sound
	3041	AM_RANGE(0x900000, 0x903fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_word_r, seta_sound_word_w) // Sound
3042	3042
3043	3043	AM_RANGE(0xa00000, 0xa00005) AM_WRITEONLY AM_SHARE("vctrl_0") // VRAM 0&1 Ctrl
3044	3044	AM_RANGE(0xb00000, 0xb03fff) AM_RAM_WRITE(seta_vram_0_w) AM_SHARE("vram_0") // VRAM 0&1
r20674	r20675
3177	3177	}
3178	3178
3179	3179	static ADDRESS_MAP_START( calibr50_sub_map, AS_PROGRAM, 8, seta_state )
3180		AM_RANGE(0x0000, 0x1fff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_r,seta_sound_w) // Sound
	3180	AM_RANGE(0x0000, 0x1fff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_r, seta_sound_w) // Sound
3181	3181	AM_RANGE(0x4000, 0x4000) AM_READ(soundlatch_byte_r) // From Main CPU
3182	3182	AM_RANGE(0x4000, 0x4000) AM_WRITE(sub_bankswitch_w) // Bankswitching
3183	3183	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("bank1") // Banked ROM
r20674	r20675
3213	3213	static ADDRESS_MAP_START( utoukond_sound_map, AS_PROGRAM, 8, seta_state )
3214	3214	AM_RANGE(0x0000, 0xdfff) AM_ROM
3215	3215	AM_RANGE(0xe000, 0xefff) AM_RAM
3216		AM_RANGE(0xf000, 0xffff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_r,seta_sound_w)
	3216	AM_RANGE(0xf000, 0xffff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_r, seta_sound_w)
3217	3217	ADDRESS_MAP_END
3218	3218
3219	3219	static ADDRESS_MAP_START( utoukond_sound_io_map, AS_IO, 8, seta_state )
r20674	r20675
7544	7544	/* sound hardware */
7545	7545	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7546	7546
7547		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7547	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7548	7548	MCFG_SOUND_CONFIG(seta_sound_intf)
7549	7549	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7550	7550	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7585	7585
7586	7586	/* sound hardware */
7587	7587	MCFG_SPEAKER_STANDARD_MONO("mono")
7588		MCFG_~~SOUND~~_ADD("x1snd", ~~X1_010,~~ 16000000) /* 16 MHz */
	7588	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7589	7589	MCFG_SOUND_CONFIG(seta_sound_intf)
7590	7590	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
7591	7591	MACHINE_CONFIG_END
r20674	r20675
7645	7645	/* sound hardware */
7646	7646	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7647	7647
7648		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7648	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7649	7649	MCFG_SOUND_CONFIG(seta_sound_intf2)
7650	7650	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7651	7651	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7692	7692
7693	7693	/* sound hardware */
7694	7694	MCFG_SPEAKER_STANDARD_MONO("mono")
7695		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7695	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7696	7696	MCFG_SOUND_CONFIG(seta_sound_intf2)
7697	7697	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
7698	7698	MACHINE_CONFIG_END
r20674	r20675
7733	7733	/* sound hardware */
7734	7734	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7735	7735
7736		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7736	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7737	7737	MCFG_SOUND_CONFIG(seta_sound_intf)
7738	7738	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7739	7739	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7769	7769	/* sound hardware */
7770	7770	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7771	7771
7772		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7772	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7773	7773	MCFG_SOUND_CONFIG(seta_sound_intf)
7774	7774	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7775	7775	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7813	7813	/* sound hardware */
7814	7814	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7815	7815
7816		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7816	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7817	7817	MCFG_SOUND_CONFIG(seta_sound_intf)
7818	7818	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7819	7819	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7846	7846	/* sound hardware */
7847	7847	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7848	7848
7849		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7849	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7850	7850	MCFG_SOUND_CONFIG(seta_sound_intf)
7851	7851	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7852	7852	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7882	7882	/* sound hardware */
7883	7883	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7884	7884
7885		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7885	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7886	7886	MCFG_SOUND_CONFIG(seta_sound_intf)
7887	7887	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7888	7888	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7918	7918	/* sound hardware */
7919	7919	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7920	7920
7921		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7921	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7922	7922	MCFG_SOUND_CONFIG(seta_sound_intf)
7923	7923	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7924	7924	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7960	7960	/* sound hardware */
7961	7961	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7962	7962
7963		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7963	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7964	7964	MCFG_SOUND_CONFIG(seta_sound_intf)
7965	7965	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
7966	7966	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
7995	7995	/* sound hardware */
7996	7996	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
7997	7997
7998		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	7998	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
7999	7999	MCFG_SOUND_CONFIG(seta_sound_intf)
8000	8000	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8001	8001	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8046	8046	/* sound hardware */
8047	8047	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8048	8048
8049		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8049	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8050	8050	MCFG_SOUND_CONFIG(seta_sound_intf)
8051	8051	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8052	8052	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8082	8082	/* sound hardware */
8083	8083	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8084	8084
8085		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8085	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8086	8086	MCFG_SOUND_CONFIG(seta_sound_intf)
8087	8087	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8088	8088	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8124	8124	/* sound hardware */
8125	8125	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8126	8126
8127		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8127	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8128	8128	MCFG_SOUND_CONFIG(seta_sound_intf)
8129	8129	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8130	8130	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8185	8185	/* sound hardware */
8186	8186	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8187	8187
8188		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8188	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8189	8189	MCFG_SOUND_CONFIG(seta_sound_intf)
8190	8190	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8191	8191	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8226	8226	/* sound hardware */
8227	8227	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8228	8228
8229		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8229	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8230	8230	MCFG_SOUND_CONFIG(seta_sound_intf)
8231	8231	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8232	8232	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8258	8258	/* sound hardware */
8259	8259	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8260	8260
8261		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8261	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8262	8262	MCFG_SOUND_CONFIG(seta_sound_intf)
8263	8263	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8264	8264	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8298	8298	/* sound hardware */
8299	8299	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8300	8300
8301		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8301	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8302	8302	MCFG_SOUND_CONFIG(seta_sound_intf)
8303	8303	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8304	8304	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8335	8335	/* sound hardware */
8336	8336	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8337	8337
8338		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 14318180) /* 14.318180 MHz */
	8338	MCFG_X1_010_ADD("x1snd", 14318180) /* 14.318180 MHz */
8339	8339	MCFG_SOUND_CONFIG(seta_sound_intf)
8340	8340	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8341	8341	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8373	8373	/* sound hardware */
8374	8374	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8375	8375
8376		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 14318180) /* 14.318180 MHz */
	8376	MCFG_X1_010_ADD("x1snd", 14318180) /* 14.318180 MHz */
8377	8377	MCFG_SOUND_CONFIG(seta_sound_intf)
8378	8378	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8379	8379	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8409	8409	/* sound hardware */
8410	8410	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8411	8411
8412		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8412	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8413	8413	MCFG_SOUND_CONFIG(seta_sound_intf)
8414	8414	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8415	8415	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8452	8452	/* sound hardware */
8453	8453	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8454	8454
8455		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8455	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8456	8456	MCFG_SOUND_CONFIG(seta_sound_intf)
8457	8457	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8458	8458	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8492	8492	/* sound hardware */
8493	8493	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8494	8494
8495		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8495	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8496	8496	MCFG_SOUND_CONFIG(seta_sound_intf)
8497	8497	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8498	8498	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8539	8539	/* sound hardware */
8540	8540	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8541	8541
8542		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8542	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8543	8543	MCFG_SOUND_CONFIG(seta_sound_intf)
8544	8544	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8545	8545	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8576	8576	/* sound hardware */
8577	8577	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8578	8578
8579		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8579	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8580	8580	MCFG_SOUND_CONFIG(seta_sound_intf)
8581	8581	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8582	8582	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8648	8648	/* sound hardware */
8649	8649	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8650	8650
8651		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8651	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8652	8652	MCFG_SOUND_CONFIG(seta_sound_intf)
8653	8653	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8654	8654	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8687	8687	/* sound hardware */
8688	8688	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8689	8689
8690		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8690	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8691	8691	MCFG_SOUND_CONFIG(seta_sound_intf)
8692	8692	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8693	8693	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8726	8726	/* sound hardware */
8727	8727	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8728	8728
8729		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8729	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8730	8730	MCFG_SOUND_CONFIG(seta_sound_intf)
8731	8731	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8732	8732	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8831	8831	/* sound hardware */
8832	8832	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8833	8833
8834		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8834	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8835	8835	MCFG_SOUND_CONFIG(seta_sound_intf)
8836	8836	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8837	8837	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8867	8867	/* sound hardware */
8868	8868	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8869	8869
8870		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8870	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8871	8871	MCFG_SOUND_CONFIG(seta_sound_intf)
8872	8872	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8873	8873	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8907	8907	/* sound hardware */
8908	8908	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8909	8909
8910		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000)
	8910	MCFG_X1_010_ADD("x1snd", 16000000)
8911	8911	MCFG_SOUND_CONFIG(seta_sound_intf)
8912	8912	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8913	8913	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
8956	8956	/* sound hardware */
8957	8957	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
8958	8958
8959		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	8959	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
8960	8960	MCFG_SOUND_CONFIG(seta_sound_intf)
8961	8961	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
8962	8962	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
9000	9000	/* sound hardware */
9001	9001	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
9002	9002
9003		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	9003	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
9004	9004	MCFG_SOUND_CONFIG(seta_sound_intf)
9005	9005	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
9006	9006	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
9052	9052	/* sound hardware */
9053	9053	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
9054	9054
9055		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000) /* 16 MHz */
	9055	MCFG_X1_010_ADD("x1snd", 16000000) /* 16 MHz */
9056	9056	MCFG_SOUND_CONFIG(seta_sound_intf)
9057	9057	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
9058	9058	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
9196	9196	/* sound hardware */
9197	9197	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
9198	9198
9199		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000)
	9199	MCFG_X1_010_ADD("x1snd", 16000000)
9200	9200	MCFG_SOUND_CONFIG(seta_sound_intf)
9201	9201	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
9202	9202	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)

trunk/src/mame/drivers/namcos86.c
r20674	r20675
306	306	case 1:
307	307	case 2:
308	308	case 3:
309		namco_63701x_~~w(machine().~~device("namco2"), space, (offset & 0x1e00) >> 9,data);
	309	machine().device<namco_63701x_device>("namco2")->namco_63701x_w(space, (offset & 0x1e00) >> 9,data);
310	310	break;
311	311
312	312	case 4:
r20674	r20675
1064	1064	MCFG_CPU_PROGRAM_MAP(genpeitd_mcu_map)
1065	1065
1066	1066	/* sound hardware */
1067		MCFG_~~SOU~~ND_ADD("namco2"~~, NAMCO_63701X~~, 6000000)
	1067	MCFG_NAMCO_63701X_ADD("namco2", 6000000)
1068	1068	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
1069	1069	MACHINE_CONFIG_END
1070	1070
r20674	r20675
1079	1079	MCFG_CPU_PROGRAM_MAP(rthunder_mcu_map)
1080	1080
1081	1081	/* sound hardware */
1082		MCFG_~~SOU~~ND_ADD("namco2"~~, NAMCO_63701X~~, 6000000)
	1082	MCFG_NAMCO_63701X_ADD("namco2", 6000000)
1083	1083	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
1084	1084	MACHINE_CONFIG_END
1085	1085
r20674	r20675
1094	1094	MCFG_CPU_PROGRAM_MAP(wndrmomo_mcu_map)
1095	1095
1096	1096	/* sound hardware */
1097		MCFG_~~SOU~~ND_ADD("namco2"~~, NAMCO_63701X~~, 6000000)
	1097	MCFG_NAMCO_63701X_ADD("namco2", 6000000)
1098	1098	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
1099	1099	MACHINE_CONFIG_END
1100	1100

trunk/src/mame/drivers/champbwl.c
r20674	r20675
210	210	AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("nvram")
211	211	AM_RANGE(0xa000, 0xafff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecodelow_r8, spritecodelow_w8)
212	212	AM_RANGE(0xb000, 0xbfff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecodehigh_r8, spritecodehigh_w8)
213		AM_RANGE(0xc000, 0xdfff) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_r, seta_sound_w)
	213	AM_RANGE(0xc000, 0xdfff) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_r, seta_sound_w)
214	214	AM_RANGE(0xe000, 0xe2ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r8, spriteylow_w8)
215	215	AM_RANGE(0xe300, 0xe303) AM_MIRROR(0xfc) AM_DEVWRITE_LEGACY("spritegen", spritectrl_w8) /* control registers (0x80 mirror used by Arkanoid 2) */
216	216	AM_RANGE(0xe800, 0xe800) AM_DEVWRITE_LEGACY("spritegen", spritebgflag_w8) /* enable / disable background transparency */
r20674	r20675
249	249	AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("nvram")
250	250	AM_RANGE(0xa000, 0xafff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecodelow_r8, spritecodelow_w8)
251	251	AM_RANGE(0xb000, 0xbfff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spritecodehigh_r8, spritecodehigh_w8)
252		AM_RANGE(0xc000, 0xc07f) AM_DEVREADWRITE~~_LEGACY~~("x1snd", seta_sound_r,seta_sound_w) // Sound
	252	AM_RANGE(0xc000, 0xc07f) AM_DEVREADWRITE("x1snd", x1_010_device, seta_sound_r, seta_sound_w) // Sound
253	253	AM_RANGE(0xe000, 0xe2ff) AM_RAM AM_DEVREADWRITE_LEGACY("spritegen", spriteylow_r8, spriteylow_w8)
254	254	AM_RANGE(0xe300, 0xe303) AM_DEVWRITE_LEGACY("spritegen", spritectrl_w8)
255	255	AM_RANGE(0xe800, 0xe800) AM_DEVWRITE_LEGACY("spritegen", spritebgflag_w8) /* enable / disable background transparency */
r20674	r20675
505	505	/* sound hardware */
506	506	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
507	507
508		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, 16000000)
	508	MCFG_X1_010_ADD("x1snd", 16000000)
509	509	MCFG_SOUND_CONFIG(champbwl_sound_intf)
510	510	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
511	511	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
r20674	r20675
567	567
568	568	/* sound hardware */
569	569	MCFG_SPEAKER_STANDARD_MONO("mono")
570		MCFG_~~SOUND~~_ADD("x1snd"~~, X1_010~~, XTAL_14_31818MHz)
	570	MCFG_X1_010_ADD("x1snd", XTAL_14_31818MHz)
571	571	MCFG_SOUND_CONFIG(champbwl_sound_intf)
572	572	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
573	573	MACHINE_CONFIG_END

trunk/src/mame/drivers/tourtabl.c
r20674	r20675
191	191	/* sound hardware */
192	192	MCFG_SPEAKER_STANDARD_MONO("mono")
193	193
194		MCFG_SOUND_ADD("tia"~~, TIA~~, MASTER_CLOCK/114)
	194	MCFG_SOUND_TIA_ADD("tia", MASTER_CLOCK/114)
195	195	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
196	196	MACHINE_CONFIG_END
197	197

trunk/src/mame/video/seta.c
r20674	r20675
266	266	---- ---- ---- ---0 Coin #0 Counter */
267	267	if (ACCESSING_BITS_0_7)
268	268	{
269		device_t *x1_010 = machine().device("x1snd");
	269	x1_010_device *x1_010 = machine().device<x1_010_device>("x1snd");
270	270	seta_coin_lockout_w (machine(), data & 0x0f);
271	271	if (x1_010 != NULL)
272		seta_sound_enable_w (~~x1_010,~~ data & 0x20);
	272	x1_010->seta_sound_enable_w (data & 0x20);
273	273	coin_counter_w(machine(), 0,data & 0x01);
274	274	coin_counter_w(machine(), 1,data & 0x02);
275	275	}

trunk/src/mame/video/tia.c
r20674	r20675
1804	1804	case 0x18: /* AUDF1 */
1805	1805	case 0x19: /* AUDV0 */
1806	1806	case 0x1A: /* AUDV1 */
1807		~~tia_sound_w(~~machine().device("tia"), space, offset, data);
	1807	machine().device<tia_device>("tia")->tia_sound_w(space, offset, data);
1808	1808	break;
1809	1809
1810	1810	case 0x1B:

199869 Revisions