Previous

199869 Revisions

Next

r22734 Friday 10th May, 2013 at 14:02:35 UTC by smf
modernised YMZ280B [smf]

[src/emu/sound]	ymz280b.c ymz280b.h
[src/mame/drivers]	backfire.c bfm_sc4h.c bfm_sc5.c bfm_swp.c bishi.c cave.c coinmvga.c deco156.c deco_mlc.c firebeat.c galpani3.c gunpey.c jchan.c maygayep.c midas.c realbrk.c seibuspi.c sigmab98.c suprnova.c tecmosys.c tetrisp2.c toaplan2.c zn.c

trunk/src/emu/sound/ymz280b.c

r22733	r22734
26	26
27	27
28	28	#define MAX_SAMPLE_CHUNK    10000
29		#define MAKE_WAVS           0
30	29
31	30	#define FRAC_BITS           14
32	31	#define FRAC_ONE            (1 << FRAC_BITS)
33	32	#define FRAC_MASK           (FRAC_ONE - 1)
34	33
35	34	#define INTERNAL_BUFFER_SIZE    (1 << 15)
36		#define INTERNAL_SAMPLE_RATE    (chip->master_clock * 2.0)
	35	#define INTERNAL_SAMPLE_RATE    (m_master_clock * 2.0)
37	36
38	37	#if MAKE_WAVS
39	38	#include "wavwrite.h"
40	39	#endif
41	40
42	41
43		/* struct describing a single playing ADPCM voice */
44		struct YMZ280BVoice
45		{
46		UINT8 playing;          /* 1 if we are actively playing */
47	42
48		UINT8 keyon;            /* 1 if the key is on */
49		UINT8 looping;          /* 1 if looping is enabled */
50		UINT8 mode;             /* current playback mode */
51		UINT16 fnum;            /* frequency */
52		UINT8 level;            /* output level */
53		UINT8 pan;              /* panning */
54
55		UINT32 start;           /* start address, in nibbles */
56		UINT32 stop;            /* stop address, in nibbles */
57		UINT32 loop_start;      /* loop start address, in nibbles */
58		UINT32 loop_end;        /* loop end address, in nibbles */
59		UINT32 position;        /* current position, in nibbles */
60
61		INT32 signal;           /* current ADPCM signal */
62		INT32 step;             /* current ADPCM step */
63
64		INT32 loop_signal;      /* signal at loop start */
65		INT32 loop_step;        /* step at loop start */
66		UINT32 loop_count;      /* number of loops so far */
67
68		INT32 output_left;      /* output volume (left) */
69		INT32 output_right;     /* output volume (right) */
70		INT32 output_step;      /* step value for frequency conversion */
71		INT32 output_pos;       /* current fractional position */
72		INT16 last_sample;      /* last sample output */
73		INT16 curr_sample;      /* current sample target */
74		UINT8 irq_schedule;     /* 1 if the IRQ state is updated by timer */
75		};
76
77		struct ymz280b_state
78		{
79		sound_stream * stream;          /* which stream are we using */
80		UINT8 *region_base;             /* pointer to the base of the region */
81		UINT32 region_size;
82		UINT8 current_register;         /* currently accessible register */
83		UINT8 status_register;          /* current status register */
84		UINT8 irq_state;                /* current IRQ state */
85		UINT8 irq_mask;                 /* current IRQ mask */
86		UINT8 irq_enable;               /* current IRQ enable */
87		UINT8 keyon_enable;             /* key on enable */
88		UINT8 ext_mem_enable;           /* external memory enable */
89		double master_clock;            /* master clock frequency */
90		devcb_resolved_write_line irq_callback;  /* IRQ callback */
91		struct YMZ280BVoice voice[8];   /* the 8 voices */
92		UINT32 rom_addr_hi;
93		UINT32 rom_addr_mid;
94		UINT32 rom_readback_addr;       /* where the CPU can read the ROM */
95		devcb_resolved_read8 ext_ram_read;      /* external RAM read handler */
96		devcb_resolved_write8 ext_ram_write;    /* external RAM write handler */
97
98		#if MAKE_WAVS
99		void * wavresample;             /* resampled waveform */
100		#endif
101
102		INT16 *scratch;
103		device_t *device;
104		};
105
106		static void write_to_register(ymz280b_state *, int);
107
108
109	43	/* step size index shift table */
110	44	static const int index_scale[8] = { 0x0e6, 0x0e6, 0x0e6, 0x0e6, 0x133, 0x199, 0x200, 0x266 };
111	45
112	46	/* lookup table for the precomputed difference */
113	47	static int diff_lookup[16];
114	48
115		/* timer callback */
116		static TIMER_CALLBACK( update_irq_state_timer_0 );
117		static TIMER_CALLBACK( update_irq_state_timer_1 );
118		static TIMER_CALLBACK( update_irq_state_timer_2 );
119		static TIMER_CALLBACK( update_irq_state_timer_3 );
120		static TIMER_CALLBACK( update_irq_state_timer_4 );
121		static TIMER_CALLBACK( update_irq_state_timer_5 );
122		static TIMER_CALLBACK( update_irq_state_timer_6 );
123		static TIMER_CALLBACK( update_irq_state_timer_7 );
124	49
125		static const struct { timer_expired_func func; const char *name; } update_irq_state_cb[] =
	50	UINT8 ymz280b_device::ymz280b_read_memory(UINT32 offset)
126	51	{
127		{ FUNC(update_irq_state_timer_0) },
128		{ FUNC(update_irq_state_timer_1) },
129		{ FUNC(update_irq_state_timer_2) },
130		{ FUNC(update_irq_state_timer_3) },
131		{ FUNC(update_irq_state_timer_4) },
132		{ FUNC(update_irq_state_timer_5) },
133		{ FUNC(update_irq_state_timer_6) },
134		{ FUNC(update_irq_state_timer_7) }
135		};
136
137
138		INLINE ymz280b_state *get_safe_token(device_t *device)
139		{
140		assert(device != NULL);
141		assert(device->type() == YMZ280B);
142		return (ymz280b_state *)downcast<ymz280b_device *>(device)->token();
143		}
144
145
146		INLINE UINT8 ymz280b_read_memory(ymz280b_state *chip, UINT32 offset)
147		{
148		if (chip->ext_ram_read.isnull())
	52	if (m_ext_read_handler.isnull())
149	53	{
150		if (offset < chip->region_size)
151		return chip->region_base[offset];
	54	if (offset < m_region_size)
	55	return m_region_base[offset];
152	56
153	57	/* 16MB chip limit (shouldn't happen) */
154	58	else if (offset > 0xffffff)
155		return chip->region_base[offset & 0xffffff];
	59	return m_region_base[offset & 0xffffff];
156	60
157	61	else
158	62	return 0;
159	63	}
160	64	else
161		return chip->ext_ram_read(offset);
	65	return m_ext_read_handler(offset);
162	66	}
163	67
164	68
165		INLINE void update_irq_state(ymz280b_state *chip)
	69	void ymz280b_device::update_irq_state()
166	70	{
167		int irq_bits = chip->status_register & chip->irq_mask;
	71	int irq_bits = m_status_register & m_irq_mask;
168	72
169	73	/* always off if the enable is off */
170		if (!chip->irq_enable)
	74	if (!m_irq_enable)
171	75	irq_bits = 0;
172	76
173	77	/* update the state if changed */
174		if (irq_bits && !chip->irq_state)
	78	if (irq_bits && !m_irq_state)
175	79	{
176		chip->irq_state = 1;
177		if (!chip->irq_callback.isnull())
178		chip->irq_callback(1);
	80	m_irq_state = 1;
	81	if (!m_irq_handler.isnull())
	82	m_irq_handler(1);
179	83	else logerror("YMZ280B: IRQ generated, but no callback specified!");
180	84	}
181		else if (!irq_bits && chip->irq_state)
	85	else if (!irq_bits && m_irq_state)
182	86	{
183		chip->irq_state = 0;
184		if (!chip->irq_callback.isnull())
185		chip->irq_callback(0);
	87	m_irq_state = 0;
	88	if (!m_irq_handler.isnull())
	89	m_irq_handler(0);
186	90	else logerror("YMZ280B: IRQ generated, but no callback specified!");
187	91	}
188	92	}
189	93
190	94
191		INLINE void update_step(ymz280b_state *chip, struct YMZ280BVoice *voice)
	95	void ymz280b_device::update_step(struct YMZ280BVoice *voice)
192	96	{
193	97	double frequency;
194	98
195	99	/* compute the frequency */
196	100	if (voice->mode == 1)
197		frequency = chip->master_clock * (double)((voice->fnum & 0x0ff) + 1) * (1.0 / 256.0);
	101	frequency = m_master_clock * (double)((voice->fnum & 0x0ff) + 1) * (1.0 / 256.0);
198	102	else
199		frequency = chip->master_clock * (double)((voice->fnum & 0x1ff) + 1) * (1.0 / 256.0);
	103	frequency = m_master_clock * (double)((voice->fnum & 0x1ff) + 1) * (1.0 / 256.0);
200	104	voice->output_step = (UINT32)(frequency * (double)FRAC_ONE / INTERNAL_SAMPLE_RATE);
201	105	}
202	106
203	107
204		INLINE void update_volumes(struct YMZ280BVoice *voice)
	108	void ymz280b_device::update_volumes(struct YMZ280BVoice *voice)
205	109	{
206	110	if (voice->pan == 8)
207	111	{
r22733	r22734
223	127	}
224	128
225	129
226		static void YMZ280B_state_save_update_step(ymz280b_state *chip)
	130	void ymz280b_device::post_load()
227	131	{
228	132	for (int j = 0; j < 8; j++)
229	133	{
230		struct YMZ280BVoice *voice = &chip->voice[j];
231		update_step(chip, voice);
	134	struct YMZ280BVoice *voice = &m_voice[j];
	135	update_step(voice);
232	136	if(voice->irq_schedule)
233		chip->device->machine().scheduler().timer_set(attotime::zero, update_irq_state_cb[j].func, update_irq_state_cb[j].name, 0, chip);
	137	voice->timer->adjust(attotime::zero);
234	138	}
235	139	}
236	140
237	141
238		static void update_irq_state_timer_common(void *param, int voicenum)
	142	void ymz280b_device::update_irq_state_timer_common(int voicenum)
239	143	{
240		ymz280b_state *chip = (ymz280b_state *)param;
241		struct YMZ280BVoice *voice = &chip->voice[voicenum];
	144	struct YMZ280BVoice *voice = &m_voice[voicenum];
242	145
243	146	if(!voice->irq_schedule) return;
244	147
245	148	voice->playing = 0;
246		chip->status_register |= 1 << voicenum;
247		update_irq_state(chip);
	149	m_status_register |= 1 << voicenum;
	150	update_irq_state();
248	151	voice->irq_schedule = 0;
249	152	}
250	153
251		static TIMER_CALLBACK( update_irq_state_timer_0 ) { update_irq_state_timer_common(ptr, 0); }
252		static TIMER_CALLBACK( update_irq_state_timer_1 ) { update_irq_state_timer_common(ptr, 1); }
253		static TIMER_CALLBACK( update_irq_state_timer_2 ) { update_irq_state_timer_common(ptr, 2); }
254		static TIMER_CALLBACK( update_irq_state_timer_3 ) { update_irq_state_timer_common(ptr, 3); }
255		static TIMER_CALLBACK( update_irq_state_timer_4 ) { update_irq_state_timer_common(ptr, 4); }
256		static TIMER_CALLBACK( update_irq_state_timer_5 ) { update_irq_state_timer_common(ptr, 5); }
257		static TIMER_CALLBACK( update_irq_state_timer_6 ) { update_irq_state_timer_common(ptr, 6); }
258		static TIMER_CALLBACK( update_irq_state_timer_7 ) { update_irq_state_timer_common(ptr, 7); }
259
260
261	154	/**********************************************************************************************
262	155
263	156	compute_tables -- compute the difference tables
r22733	r22734
282	175
283	176	***********************************************************************************************/
284	177
285		static int generate_adpcm(ymz280b_state *chip, struct YMZ280BVoice *voice, INT16 *buffer, int samples)
	178	int ymz280b_device::generate_adpcm(struct YMZ280BVoice *voice, INT16 *buffer, int samples)
286	179	{
287	180	int position = voice->position;
288	181	int signal = voice->signal;
r22733	r22734
296	189	while (samples)
297	190	{
298	191	/* compute the new amplitude and update the current step */
299		val = ymz280b_read_memory(chip, position / 2) >> ((~position & 1) << 2);
	192	val = ymz280b_read_memory(position / 2) >> ((~position & 1) << 2);
300	193	signal += (step * diff_lookup[val & 15]) / 8;
301	194
302	195	/* clamp to the maximum */
r22733	r22734
335	228	while (samples)
336	229	{
337	230	/* compute the new amplitude and update the current step */
338		val = ymz280b_read_memory(chip, position / 2) >> ((~position & 1) << 2);
	231	val = ymz280b_read_memory(position / 2) >> ((~position & 1) << 2);
339	232	signal += (step * diff_lookup[val & 15]) / 8;
340	233
341	234	/* clamp to the maximum */
r22733	r22734
398	291
399	292	***********************************************************************************************/
400	293
401		static int generate_pcm8(ymz280b_state *chip, struct YMZ280BVoice *voice, INT16 *buffer, int samples)
	294	int ymz280b_device::generate_pcm8(struct YMZ280BVoice *voice, INT16 *buffer, int samples)
402	295	{
403	296	int position = voice->position;
404	297	int val;
r22733	r22734
410	303	while (samples)
411	304	{
412	305	/* fetch the current value */
413		val = ymz280b_read_memory(chip, position / 2);
	306	val = ymz280b_read_memory(position / 2);
414	307
415	308	/* output to the buffer, scaling by the volume */
416	309	*buffer++ = (INT8)val * 256;
r22733	r22734
435	328	while (samples)
436	329	{
437	330	/* fetch the current value */
438		val = ymz280b_read_memory(chip, position / 2);
	331	val = ymz280b_read_memory(position / 2);
439	332
440	333	/* output to the buffer, scaling by the volume */
441	334	*buffer++ = (INT8)val * 256;
r22733	r22734
472	365
473	366	***********************************************************************************************/
474	367
475		static int generate_pcm16(ymz280b_state *chip, struct YMZ280BVoice *voice, INT16 *buffer, int samples)
	368	int ymz280b_device::generate_pcm16(struct YMZ280BVoice *voice, INT16 *buffer, int samples)
476	369	{
477	370	int position = voice->position;
478	371	int val;
r22733	r22734
484	377	while (samples)
485	378	{
486	379	/* fetch the current value */
487		val = (INT16)((ymz280b_read_memory(chip, position / 2 + 0) << 8) + ymz280b_read_memory(chip, position / 2 + 1));
	380	val = (INT16)((ymz280b_read_memory(position / 2 + 0) << 8) + ymz280b_read_memory(position / 2 + 1));
488	381
489	382	/* output to the buffer, scaling by the volume */
490	383	*buffer++ = val;
r22733	r22734
509	402	while (samples)
510	403	{
511	404	/* fetch the current value */
512		val = (INT16)((ymz280b_read_memory(chip, position / 2 + 0) << 8) + ymz280b_read_memory(chip, position / 2 + 1));
	405	val = (INT16)((ymz280b_read_memory(position / 2 + 0) << 8) + ymz280b_read_memory(position / 2 + 1));
513	406
514	407	/* output to the buffer, scaling by the volume */
515	408	*buffer++ = val;
r22733	r22734
540	433
541	434
542	435
543		/**********************************************************************************************
544	436
545		ymz280b_update -- update the sound chip so that it is in sync with CPU execution
	437	//-------------------------------------------------
	438	//  sound_stream_update - handle a stream update
	439	//-------------------------------------------------
546	440
547		***********************************************************************************************/
548
549		static STREAM_UPDATE( ymz280b_update )
	441	void ymz280b_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
550	442	{
551		ymz280b_state *chip = (ymz280b_state *)param;
552	443	stream_sample_t *lacc = outputs[0];
553	444	stream_sample_t *racc = outputs[1];
554	445	int v;
r22733	r22734
560	451	/* loop over voices */
561	452	for (v = 0; v < 8; v++)
562	453	{
563		struct YMZ280BVoice *voice = &chip->voice[v];
	454	struct YMZ280BVoice *voice = &m_voice[v];
564	455	INT16 prev = voice->last_sample;
565	456	INT16 curr = voice->curr_sample;
566		INT16 *curr_data = chip->scratch;
	457	INT16 *curr_data = m_scratch;
567	458	INT32 *ldest = lacc;
568	459	INT32 *rdest = racc;
569	460	UINT32 new_samples, samples_left;
r22733	r22734
608	499	/* generate them into our buffer */
609	500	switch (voice->playing << 7 | voice->mode)
610	501	{
611		case 0x81:  samples_left = generate_adpcm(chip, voice, chip->scratch, new_samples); break;
612		case 0x82:  samples_left = generate_pcm8(chip, voice, chip->scratch, new_samples); break;
613		case 0x83:  samples_left = generate_pcm16(chip, voice, chip->scratch, new_samples); break;
614		default:    samples_left = 0; memset(chip->scratch, 0, new_samples * sizeof(chip->scratch[0])); break;
	502	case 0x81:  samples_left = generate_adpcm(voice, m_scratch, new_samples); break;
	503	case 0x82:  samples_left = generate_pcm8(voice, m_scratch, new_samples); break;
	504	case 0x83:  samples_left = generate_pcm16(voice, m_scratch, new_samples); break;
	505	default:    samples_left = 0; memset(m_scratch, 0, new_samples * sizeof(m_scratch[0])); break;
615	506	}
616	507
617	508	/* if there are leftovers, ramp back to 0 */
r22733	r22734
619	510	{
620	511	/* note: samples_left bit 16 is set if the voice was finished at the same time the function ended */
621	512	int base = new_samples - (samples_left & 0xffff);
622		int i, t = (base == 0) ? curr : chip->scratch[base - 1];
	513	int i, t = (base == 0) ? curr : m_scratch[base - 1];
623	514	for (i = 0; i < (samples_left & 0xffff); i++)
624	515	{
625	516	if (t < 0) t = -((-t * 15) >> 4);
626	517	else if (t > 0) t = (t * 15) >> 4;
627		chip->scratch[base + i] = t;
	518	m_scratch[base + i] = t;
628	519	}
629	520
630	521	/* if we hit the end and IRQs are enabled, signal it */
r22733	r22734
633	524	voice->playing = 0;
634	525
635	526	/* set update_irq_state_timer. IRQ is signaled on next CPU execution. */
636		chip->device->machine().scheduler().timer_set(attotime::zero, update_irq_state_cb[v].func, update_irq_state_cb[v].name, 0, chip);
	527	voice->timer->adjust(attotime::zero);
637	528	voice->irq_schedule = 1;
638	529	}
639	530	}
r22733	r22734
678	569
679	570
680	571
681		/**********************************************************************************************
	572	//-------------------------------------------------
	573	//  device_start - device-specific startup
	574	//-------------------------------------------------
682	575
683		DEVICE_START/RESET( ymz280b ) -- start/reset emulation of the YMZ280B
684
685		***********************************************************************************************/
686
687		static DEVICE_START( ymz280b )
	576	void ymz280b_device::device_start()
688	577	{
689		static const ymz280b_interface defintrf = { DEVCB_NULL };
690		const ymz280b_interface *intf = (device->static_config() != NULL) ? (const ymz280b_interface *)device->static_config() : &defintrf;
691		ymz280b_state *chip = get_safe_token(device);
	578	m_ext_read_handler.resolve();
	579	m_ext_write_handler.resolve();
692	580
693		chip->device = device;
694		chip->ext_ram_read.resolve(intf->ext_read, *device);
695		chip->ext_ram_write.resolve(intf->ext_write, *device);
696
697	581	/* compute ADPCM tables */
698	582	compute_tables();
699	583
700	584	/* initialize the rest of the structure */
701		chip->master_clock = (double)device->clock() / 384.0;
702		chip->region_base = *device->region();
703		chip->region_size = device->region()->bytes();
704		chip->irq_callback.resolve(intf->irq_callback, *device);
	585	m_master_clock = (double)clock() / 384.0;
	586	m_region_base = *region();
	587	m_region_size = region()->bytes();
	588	m_irq_handler.resolve();
705	589
	590	for (int i = 0; i < 8; i++)
	591	{
	592	m_voice[i].timer = timer_alloc(i);
	593	}
	594
706	595	/* create the stream */
707		chip->stream = device->machine().sound().stream_alloc(*device, 0, 2, INTERNAL_SAMPLE_RATE, chip, ymz280b_update);
	596	m_stream = machine().sound().stream_alloc(*this, 0, 2, INTERNAL_SAMPLE_RATE);
708	597
709	598	/* allocate memory */
710	599	assert(MAX_SAMPLE_CHUNK < 0x10000);
711		chip->scratch = auto_alloc_array(device->machine(), INT16, MAX_SAMPLE_CHUNK);
	600	m_scratch = auto_alloc_array(machine(), INT16, MAX_SAMPLE_CHUNK);
712	601
713	602	/* state save */
	603	save_item(NAME(m_current_register));
	604	save_item(NAME(m_status_register));
	605	save_item(NAME(m_irq_state));
	606	save_item(NAME(m_irq_mask));
	607	save_item(NAME(m_irq_enable));
	608	save_item(NAME(m_keyon_enable));
	609	save_item(NAME(m_ext_mem_enable));
	610	save_item(NAME(m_rom_readback_addr));
	611	save_item(NAME(m_rom_addr_hi));
	612	save_item(NAME(m_rom_addr_mid));
	613	for (int j = 0; j < 8; j++)
714	614	{
715		int j;
716		device->save_item(NAME(chip->current_register));
717		device->save_item(NAME(chip->status_register));
718		device->save_item(NAME(chip->irq_state));
719		device->save_item(NAME(chip->irq_mask));
720		device->save_item(NAME(chip->irq_enable));
721		device->save_item(NAME(chip->keyon_enable));
722		device->save_item(NAME(chip->ext_mem_enable));
723		device->save_item(NAME(chip->rom_readback_addr));
724		device->save_item(NAME(chip->rom_addr_hi));
725		device->save_item(NAME(chip->rom_addr_mid));
726		for (j = 0; j < 8; j++)
727		{
728		device->save_item(NAME(chip->voice[j].playing), j);
729		device->save_item(NAME(chip->voice[j].keyon), j);
730		device->save_item(NAME(chip->voice[j].looping), j);
731		device->save_item(NAME(chip->voice[j].mode), j);
732		device->save_item(NAME(chip->voice[j].fnum), j);
733		device->save_item(NAME(chip->voice[j].level), j);
734		device->save_item(NAME(chip->voice[j].pan), j);
735		device->save_item(NAME(chip->voice[j].start), j);
736		device->save_item(NAME(chip->voice[j].stop), j);
737		device->save_item(NAME(chip->voice[j].loop_start), j);
738		device->save_item(NAME(chip->voice[j].loop_end), j);
739		device->save_item(NAME(chip->voice[j].position), j);
740		device->save_item(NAME(chip->voice[j].signal), j);
741		device->save_item(NAME(chip->voice[j].step), j);
742		device->save_item(NAME(chip->voice[j].loop_signal), j);
743		device->save_item(NAME(chip->voice[j].loop_step), j);
744		device->save_item(NAME(chip->voice[j].loop_count), j);
745		device->save_item(NAME(chip->voice[j].output_left), j);
746		device->save_item(NAME(chip->voice[j].output_right), j);
747		device->save_item(NAME(chip->voice[j].output_pos), j);
748		device->save_item(NAME(chip->voice[j].last_sample), j);
749		device->save_item(NAME(chip->voice[j].curr_sample), j);
750		device->save_item(NAME(chip->voice[j].irq_schedule), j);
751		}
	615	save_item(NAME(m_voice[j].playing), j);
	616	save_item(NAME(m_voice[j].keyon), j);
	617	save_item(NAME(m_voice[j].looping), j);
	618	save_item(NAME(m_voice[j].mode), j);
	619	save_item(NAME(m_voice[j].fnum), j);
	620	save_item(NAME(m_voice[j].level), j);
	621	save_item(NAME(m_voice[j].pan), j);
	622	save_item(NAME(m_voice[j].start), j);
	623	save_item(NAME(m_voice[j].stop), j);
	624	save_item(NAME(m_voice[j].loop_start), j);
	625	save_item(NAME(m_voice[j].loop_end), j);
	626	save_item(NAME(m_voice[j].position), j);
	627	save_item(NAME(m_voice[j].signal), j);
	628	save_item(NAME(m_voice[j].step), j);
	629	save_item(NAME(m_voice[j].loop_signal), j);
	630	save_item(NAME(m_voice[j].loop_step), j);
	631	save_item(NAME(m_voice[j].loop_count), j);
	632	save_item(NAME(m_voice[j].output_left), j);
	633	save_item(NAME(m_voice[j].output_right), j);
	634	save_item(NAME(m_voice[j].output_pos), j);
	635	save_item(NAME(m_voice[j].last_sample), j);
	636	save_item(NAME(m_voice[j].curr_sample), j);
	637	save_item(NAME(m_voice[j].irq_schedule), j);
752	638	}
753	639
754		device->machine().save().register_postload(save_prepost_delegate(FUNC(YMZ280B_state_save_update_step), chip));
755
756	640	#if MAKE_WAVS
757		chip->wavresample = wav_open("resamp.wav", INTERNAL_SAMPLE_RATE, 2);
	641	m_wavresample = wav_open("resamp.wav", INTERNAL_SAMPLE_RATE, 2);
758	642	#endif
759	643	}
760	644
761		static DEVICE_RESET( ymz280b )
	645	//-------------------------------------------------
	646	//  device_reset - device-specific reset
	647	//-------------------------------------------------
	648
	649	void ymz280b_device::device_reset()
762	650	{
763	651	int i;
764		ymz280b_state *chip = get_safe_token(device);
765	652
766	653	/* initial clear registers */
767	654	for (i = 0xff; i >= 0; i--)
768	655	{
769		chip->current_register = i;
770		write_to_register(chip, 0);
	656	m_current_register = i;
	657	write_to_register(0);
771	658	}
772	659
773		chip->current_register = 0;
774		chip->status_register = 0;
775		chip->rom_readback_addr = 0;
	660	m_current_register = 0;
	661	m_status_register = 0;
	662	m_rom_readback_addr = 0;
776	663
777	664	/* clear other voice parameters */
778	665	for (i = 0; i < 8; i++)
779	666	{
780		struct YMZ280BVoice *voice = &chip->voice[i];
	667	struct YMZ280BVoice *voice = &m_voice[i];
781	668
782	669	voice->curr_sample = 0;
783	670	voice->last_sample = 0;
r22733	r22734
787	674	}
788	675
789	676
	677	void ymz280b_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	678	{
	679	update_irq_state_timer_common( param );
	680	}
790	681
	682
791	683	/**********************************************************************************************
792	684
793	685	write_to_register -- handle a write to the current register
794	686
795	687	***********************************************************************************************/
796	688
797		static void write_to_register(ymz280b_state *chip, int data)
	689	void ymz280b_device::write_to_register(int data)
798	690	{
799	691	struct YMZ280BVoice *voice;
800	692	int i;
801	693
802	694	/* lower registers follow a pattern */
803		if (chip->current_register < 0x80)
	695	if (m_current_register < 0x80)
804	696	{
805		voice = &chip->voice[(chip->current_register >> 2) & 7];
	697	voice = &m_voice[(m_current_register >> 2) & 7];
806	698
807		switch (chip->current_register & 0xe3)
	699	switch (m_current_register & 0xe3)
808	700	{
809	701	case 0x00:      /* pitch low 8 bits */
810	702	voice->fnum = (voice->fnum & 0x100) | (data & 0xff);
811		update_step(chip, voice);
	703	update_step(voice);
812	704	break;
813	705
814	706	case 0x01:      /* pitch upper 1 bit, loop, key on, mode */
r22733	r22734
816	708	voice->looping = (data & 0x10) >> 4;
817	709	if ((data & 0x60) == 0) data &= 0x7f; /* ignore mode setting and set to same state as KON=0 */
818	710	else voice->mode = (data & 0x60) >> 5;
819		if (!voice->keyon && (data & 0x80) && chip->keyon_enable)
	711	if (!voice->keyon && (data & 0x80) && m_keyon_enable)
820	712	{
821	713	voice->playing = 1;
822	714	voice->position = voice->start;
r22733	r22734
835	727	voice->irq_schedule = 0;
836	728	}
837	729	voice->keyon = (data & 0x80) >> 7;
838		update_step(chip, voice);
	730	update_step(voice);
839	731	break;
840	732
841	733	case 0x02:      /* total level */
r22733	r22734
897	789	break;
898	790
899	791	default:
900		logerror("YMZ280B: unknown register write %02X = %02X\n", chip->current_register, data);
	792	logerror("YMZ280B: unknown register write %02X = %02X\n", m_current_register, data);
901	793	break;
902	794	}
903	795	}
r22733	r22734
905	797	/* upper registers are special */
906	798	else
907	799	{
908		switch (chip->current_register)
	800	switch (m_current_register)
909	801	{
910	802	/* DSP related (not implemented yet) */
911	803	case 0x80: // d0-2: DSP Rch, d3: enable Rch (0: yes, 1: no), d4-6: DSP Lch, d7: enable Lch (0: yes, 1: no)
912	804	case 0x81: // d0: enable control of $82 (0: yes, 1: no)
913	805	case 0x82: // DSP data
914		logerror("YMZ280B: DSP register write %02X = %02X\n", chip->current_register, data);
	806	logerror("YMZ280B: DSP register write %02X = %02X\n", m_current_register, data);
915	807	break;
916	808
917	809	case 0x84:      /* ROM readback / RAM write (high) */
918		chip->rom_addr_hi = data << 16;
	810	m_rom_addr_hi = data << 16;
919	811	break;
920	812
921	813	case 0x85:      /* ROM readback / RAM write (middle) */
922		chip->rom_addr_mid = data << 8;
	814	m_rom_addr_mid = data << 8;
923	815	break;
924	816
925	817	case 0x86:      /* ROM readback / RAM write (low) -> update latch */
926		chip->rom_readback_addr = chip->rom_addr_hi | chip->rom_addr_mid | data;
	818	m_rom_readback_addr = m_rom_addr_hi | m_rom_addr_mid | data;
927	819	break;
928	820
929	821	case 0x87:      /* RAM write */
930		if (chip->ext_mem_enable)
	822	if (m_ext_mem_enable)
931	823	{
932		if (!chip->ext_ram_write.isnull())
933		chip->ext_ram_write(chip->rom_readback_addr, data);
	824	if (!m_ext_write_handler.isnull())
	825	m_ext_write_handler(m_rom_readback_addr, data);
934	826	else
935		logerror("YMZ280B attempted RAM write to %X\n", chip->rom_readback_addr);
936		chip->rom_readback_addr = (chip->rom_readback_addr + 1) & 0xffffff;
	827	logerror("YMZ280B attempted RAM write to %X\n", m_rom_readback_addr);
	828	m_rom_readback_addr = (m_rom_readback_addr + 1) & 0xffffff;
937	829	}
938	830	break;
939	831
940	832	case 0xfe:      /* IRQ mask */
941		chip->irq_mask = data;
942		update_irq_state(chip);
	833	m_irq_mask = data;
	834	update_irq_state();
943	835	break;
944	836
945	837	case 0xff:      /* IRQ enable, test, etc */
946		chip->ext_mem_enable = (data & 0x40) >> 6;
947		chip->irq_enable = (data & 0x10) >> 4;
948		update_irq_state(chip);
	838	m_ext_mem_enable = (data & 0x40) >> 6;
	839	m_irq_enable = (data & 0x10) >> 4;
	840	update_irq_state();
949	841
950		if (chip->keyon_enable && !(data & 0x80))
	842	if (m_keyon_enable && !(data & 0x80))
951	843	{
952	844	for (i = 0; i < 8; i++)
953	845	{
954		chip->voice[i].playing = 0;
	846	m_voice[i].playing = 0;
955	847
956	848	/* if update_irq_state_timer is set, cancel it. */
957		chip->voice[i].irq_schedule = 0;
	849	m_voice[i].irq_schedule = 0;
958	850	}
959	851	}
960		else if (!chip->keyon_enable && (data & 0x80))
	852	else if (!m_keyon_enable && (data & 0x80))
961	853	{
962	854	for (i = 0; i < 8; i++)
963	855	{
964		if (chip->voice[i].keyon && chip->voice[i].looping)
965		chip->voice[i].playing = 1;
	856	if (m_voice[i].keyon && m_voice[i].looping)
	857	m_voice[i].playing = 1;
966	858	}
967	859	}
968		chip->keyon_enable = (data & 0x80) >> 7;
	860	m_keyon_enable = (data & 0x80) >> 7;
969	861	break;
970	862
971	863	default:
972		logerror("YMZ280B: unknown register write %02X = %02X\n", chip->current_register, data);
	864	logerror("YMZ280B: unknown register write %02X = %02X\n", m_current_register, data);
973	865	break;
974	866	}
975	867	}
r22733	r22734
983	875
984	876	***********************************************************************************************/
985	877
986		static int compute_status(ymz280b_state *chip)
	878	int ymz280b_device::compute_status()
987	879	{
988	880	UINT8 result;
989	881
990	882	/* force an update */
991		chip->stream->update();
	883	m_stream->update();
992	884
993		result = chip->status_register;
	885	result = m_status_register;
994	886
995	887	/* clear the IRQ state */
996		chip->status_register = 0;
997		update_irq_state(chip);
	888	m_status_register = 0;
	889	update_irq_state();
998	890
999	891	return result;
1000	892	}
r22733	r22734
1007	899
1008	900	***********************************************************************************************/
1009	901
1010		READ8_DEVICE_HANDLER( ymz280b_r )
	902	READ8_MEMBER( ymz280b_device::read )
1011	903	{
1012		ymz280b_state *chip = get_safe_token(device);
1013
1014	904	if ((offset & 1) == 0)
1015	905	{
1016		if (!chip->ext_mem_enable)
	906	if (!m_ext_mem_enable)
1017	907	return 0xff;
1018	908
1019	909	/* read from external memory */
1020		UINT8 result = ymz280b_read_memory(chip, chip->rom_readback_addr);
1021		chip->rom_readback_addr = (chip->rom_readback_addr + 1) & 0xffffff;
	910	UINT8 result = ymz280b_read_memory(m_rom_readback_addr);
	911	m_rom_readback_addr = (m_rom_readback_addr + 1) & 0xffffff;
1022	912	return result;
1023	913	}
1024	914	else
1025		return compute_status(chip);
	915	return compute_status();
1026	916	}
1027	917
1028	918
1029		WRITE8_DEVICE_HANDLER( ymz280b_w )
	919	WRITE8_MEMBER( ymz280b_device::write )
1030	920	{
1031		ymz280b_state *chip = get_safe_token(device);
1032
1033	921	if ((offset & 1) == 0)
1034		chip->current_register = data;
	922	m_current_register = data;
1035	923	else
1036	924	{
1037	925	/* force an update */
1038		chip->stream->update();
	926	m_stream->update();
1039	927
1040		write_to_register(chip, data);
	928	write_to_register(data);
1041	929	}
1042	930	}
1043	931
r22733	r22734
1046	934
1047	935	ymz280b_device::ymz280b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1048	936	: device_t(mconfig, YMZ280B, "YMZ280B", tag, owner, clock),
1049		device_sound_interface(mconfig, *this)
	937	device_sound_interface(mconfig, *this),
	938	m_irq_handler(*this),
	939	m_ext_read_handler(*this),
	940	m_ext_write_handler(*this)
1050	941	{
1051		m_token = global_alloc_clear(ymz280b_state);
1052	942	}
1053	943
1054	944	//-------------------------------------------------
r22733	r22734
1060	950	void ymz280b_device::device_config_complete()
1061	951	{
1062	952	}
1063
1064		//-------------------------------------------------
1065		//  device_start - device-specific startup
1066		//-------------------------------------------------
1067
1068		void ymz280b_device::device_start()
1069		{
1070		DEVICE_START_NAME( ymz280b )(this);
1071		}
1072
1073		//-------------------------------------------------
1074		//  device_reset - device-specific reset
1075		//-------------------------------------------------
1076
1077		void ymz280b_device::device_reset()
1078		{
1079		DEVICE_RESET_NAME( ymz280b )(this);
1080		}
1081
1082		//-------------------------------------------------
1083		//  sound_stream_update - handle a stream update
1084		//-------------------------------------------------
1085
1086		void ymz280b_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
1087		{
1088		// should never get here
1089		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
1090		}

trunk/src/emu/sound/ymz280b.h

r22733	r22734
10	10	#ifndef __YMZ280B_H__
11	11	#define __YMZ280B_H__
12	12
13		#include "devlegcy.h"
	13	#include "emu.h"
14	14
	15	#define MAKE_WAVS           0
15	16
16		struct ymz280b_interface
17		{
18		devcb_write_line irq_callback;  /* irq callback */
19		devcb_read8 ext_read;           /* external RAM read */
20		devcb_write8 ext_write;     /* external RAM write */
21		};
	17	#define MCFG_YMZ280B_IRQ_HANDLER(_devcb) \
	18	devcb = &ymz280b_device::set_irq_handler(*device, DEVCB2_##_devcb);
22	19
23		DECLARE_READ8_DEVICE_HANDLER ( ymz280b_r );
24		DECLARE_WRITE8_DEVICE_HANDLER( ymz280b_w );
	20	#define MCFG_YMZ280B_EXT_READ_HANDLER(_devcb) \
	21	devcb = &ymz280b_device::set_ext_read_handler(*device, DEVCB2_##_devcb);
25	22
	23	#define MCFG_YMZ280B_EXT_WRITE_HANDLER(_devcb) \
	24	devcb = &ymz280b_device::set_ext_write_handler(*device, DEVCB2_##_devcb);
	25
26	26	class ymz280b_device : public device_t,
27	27	public device_sound_interface
28	28	{
29	29	public:
30	30	ymz280b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
31		~ymz280b_device() { global_free(m_token); }
32	31
33		// access to legacy token
34		void *token() const { assert(m_token != NULL); return m_token; }
	32	// static configuration helpers
	33	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<ymz280b_device &>(device).m_irq_handler.set_callback(object); }
	34	template<class _Object> static devcb2_base &set_ext_read_handler(device_t &device, _Object object) { return downcast<ymz280b_device &>(device).m_ext_read_handler.set_callback(object); }
	35	template<class _Object> static devcb2_base &set_ext_write_handler(device_t &device, _Object object) { return downcast<ymz280b_device &>(device).m_ext_write_handler.set_callback(object); }
	36
	37	DECLARE_READ8_MEMBER( read );
	38	DECLARE_WRITE8_MEMBER( write );
	39
35	40	protected:
36	41	// device-level overrides
37	42	virtual void device_config_complete();
38	43	virtual void device_start();
	44	virtual void post_load();
39	45	virtual void device_reset();
	46	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
40	47
41	48	// sound stream update overrides
42	49	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
43	50	private:
	51
	52	/* struct describing a single playing ADPCM voice */
	53	struct YMZ280BVoice
	54	{
	55	UINT8 playing;          /* 1 if we are actively playing */
	56
	57	UINT8 keyon;            /* 1 if the key is on */
	58	UINT8 looping;          /* 1 if looping is enabled */
	59	UINT8 mode;             /* current playback mode */
	60	UINT16 fnum;            /* frequency */
	61	UINT8 level;            /* output level */
	62	UINT8 pan;              /* panning */
	63
	64	UINT32 start;           /* start address, in nibbles */
	65	UINT32 stop;            /* stop address, in nibbles */
	66	UINT32 loop_start;      /* loop start address, in nibbles */
	67	UINT32 loop_end;        /* loop end address, in nibbles */
	68	UINT32 position;        /* current position, in nibbles */
	69
	70	INT32 signal;           /* current ADPCM signal */
	71	INT32 step;             /* current ADPCM step */
	72
	73	INT32 loop_signal;      /* signal at loop start */
	74	INT32 loop_step;        /* step at loop start */
	75	UINT32 loop_count;      /* number of loops so far */
	76
	77	INT32 output_left;      /* output volume (left) */
	78	INT32 output_right;     /* output volume (right) */
	79	INT32 output_step;      /* step value for frequency conversion */
	80	INT32 output_pos;       /* current fractional position */
	81	INT16 last_sample;      /* last sample output */
	82	INT16 curr_sample;      /* current sample target */
	83	UINT8 irq_schedule;     /* 1 if the IRQ state is updated by timer */
	84
	85	emu_timer *timer;
	86	};
	87
	88	UINT8 ymz280b_read_memory(UINT32 offset);
	89	void update_irq_state();
	90	void update_step(struct YMZ280BVoice *voice);
	91	void update_volumes(struct YMZ280BVoice *voice);
	92	void update_irq_state_timer_common(int voicenum);
	93	int generate_adpcm(struct YMZ280BVoice *voice, INT16 *buffer, int samples);
	94	int generate_pcm8(struct YMZ280BVoice *voice, INT16 *buffer, int samples);
	95	int generate_pcm16(struct YMZ280BVoice *voice, INT16 *buffer, int samples);
	96	void write_to_register(int data);
	97	int compute_status();
	98
44	99	// internal state
45		void *m_token;
	100	sound_stream * m_stream;          /* which stream are we using */
	101	UINT8 *m_region_base;             /* pointer to the base of the region */
	102	UINT32 m_region_size;
	103	UINT8 m_current_register;         /* currently accessible register */
	104	UINT8 m_status_register;          /* current status register */
	105	UINT8 m_irq_state;                /* current IRQ state */
	106	UINT8 m_irq_mask;                 /* current IRQ mask */
	107	UINT8 m_irq_enable;               /* current IRQ enable */
	108	UINT8 m_keyon_enable;             /* key on enable */
	109	UINT8 m_ext_mem_enable;           /* external memory enable */
	110	double m_master_clock;            /* master clock frequency */
	111	devcb2_write_line m_irq_handler;  /* IRQ callback */
	112	struct YMZ280BVoice m_voice[8];   /* the 8 voices */
	113	UINT32 m_rom_addr_hi;
	114	UINT32 m_rom_addr_mid;
	115	UINT32 m_rom_readback_addr;       /* where the CPU can read the ROM */
	116	devcb2_read8 m_ext_read_handler;  /* external RAM read handler */
	117	devcb2_write8 m_ext_write_handler;/* external RAM write handler */
	118
	119	#if MAKE_WAVS
	120	void * m_wavresample;             /* resampled waveform */
	121	#endif
	122
	123	INT16 *m_scratch;
46	124	};
47	125
48	126	extern const device_type YMZ280B;

trunk/src/mame/drivers/tetrisp2.c

r22733	r22734
305	305	AM_RANGE(0x500000, 0x50ffff) AM_RAM                                                         // Line
306	306	AM_RANGE(0x600000, 0x60ffff) AM_RAM_WRITE(tetrisp2_vram_rot_w) AM_SHARE("vram_rot") // Rotation
307	307	AM_RANGE(0x650000, 0x651fff) AM_RAM_WRITE(tetrisp2_vram_rot_w)                              // Rotation (mirror)
308		AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)   // Sound
	308	AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)   // Sound
309	309	AM_RANGE(0x900000, 0x903fff) AM_READ(tetrisp2_nvram_r) AM_WRITE(tetrisp2_nvram_w) AM_SHARE("nvram") // NVRAM
310	310	AM_RANGE(0x904000, 0x907fff) AM_READ(tetrisp2_nvram_r) AM_WRITE(tetrisp2_nvram_w)               // NVRAM (mirror)
311	311	AM_RANGE(0xb00000, 0xb00001) AM_WRITE(tetrisp2_coincounter_w)                               // Coin Counter
r22733	r22734
409	409	AM_RANGE(0x600000, 0x60ffff) AM_RAM_WRITE(tetrisp2_vram_rot_w) AM_SHARE("vram_rot") // Rotation
410	410	AM_RANGE(0x900000, 0x903fff) AM_READ(rockn_nvram_r) AM_WRITE(tetrisp2_nvram_w) AM_SHARE("nvram")    // NVRAM
411	411	AM_RANGE(0xa30000, 0xa30001) AM_READWRITE(rockn_soundvolume_r, rockn_soundvolume_w)         // Sound Volume
412		AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)   // Sound
	412	AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)   // Sound
413	413	AM_RANGE(0xa44000, 0xa44001) AM_READWRITE(rockn_adpcmbank_r, rockn_adpcmbank_w)             // Sound Bank
414	414	AM_RANGE(0xa48000, 0xa48001) AM_NOP                                                         // YMZ280 Reset
415	415	AM_RANGE(0xb00000, 0xb00001) AM_WRITE(tetrisp2_coincounter_w)                               // Coin Counter
r22733	r22734
443	443	AM_RANGE(0x808000, 0x809fff) AM_RAM                                                         // ???
444	444	AM_RANGE(0x900000, 0x903fff) AM_READ(rockn_nvram_r) AM_WRITE(tetrisp2_nvram_w) AM_SHARE("nvram")    // NVRAM
445	445	AM_RANGE(0xa30000, 0xa30001) AM_READWRITE(rockn_soundvolume_r, rockn_soundvolume_w)         // Sound Volume
446		AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)   // Sound
	446	AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)   // Sound
447	447	AM_RANGE(0xa44000, 0xa44001) AM_READWRITE(rockn_adpcmbank_r, rockn2_adpcmbank_w)            // Sound Bank
448	448	AM_RANGE(0xa48000, 0xa48001) AM_WRITENOP                                                    // YMZ280 Reset
449	449	AM_RANGE(0xb00000, 0xb00001) AM_WRITE(tetrisp2_coincounter_w)                               // Coin Counter
r22733	r22734
477	477	//  AM_RANGE(0x808000, 0x809fff) AM_RAM                                                         // ???
478	478	AM_RANGE(0x900000, 0x903fff) AM_READ(rockn_nvram_r) AM_WRITE(tetrisp2_nvram_w) AM_SHARE("nvram")    // NVRAM
479	479	AM_RANGE(0xa30000, 0xa30001) AM_READWRITE(rockn_soundvolume_r, rockn_soundvolume_w)         // Sound Volume
480		AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)   // Sound
	480	AM_RANGE(0xa40000, 0xa40003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)   // Sound
481	481	AM_RANGE(0xa44000, 0xa44001) AM_READWRITE(rockn_adpcmbank_r, rockn_adpcmbank_w)             // Sound Bank
482	482	AM_RANGE(0xa48000, 0xa48001) AM_WRITENOP                                                    // YMZ280 Reset
483	483	AM_RANGE(0xa00000, 0xa00001) AM_WRITE(rocknms_main2sub_w)                                   // MAIN -> SUB Communication
r22733	r22734
512	512	//  AM_RANGE(0x808000, 0x809fff) AM_RAM                                                         // ???
513	513	AM_RANGE(0x900000, 0x907fff) AM_RAM                                                         // NVRAM
514	514	AM_RANGE(0xa30000, 0xa30001) AM_WRITE(rockn_soundvolume_w)                                  // Sound Volume
515		AM_RANGE(0xa40000, 0xa40003) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff)                  // Sound
	515	AM_RANGE(0xa40000, 0xa40003) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff)             // Sound
516	516	AM_RANGE(0xa44000, 0xa44001) AM_WRITE(rockn_adpcmbank_w)                                    // Sound Bank
517	517	AM_RANGE(0xa48000, 0xa48001) AM_WRITENOP                                                    // YMZ280 Reset
518	518	AM_RANGE(0xb00000, 0xb00001) AM_WRITE(rocknms_sub2main_w)                                   // MAIN <- SUB Communication
r22733	r22734
618	618	//  AM_RANGE(0xa48000, 0xa48001) AM_WRITENOP    // PC?
619	619	//  AM_RANGE(0xa4c000, 0xa4c001) AM_WRITENOP    // PC?
620	620	AM_RANGE(0xa50000, 0xa50001) AM_READWRITE( soundlatch_word_r, stepstag_soundlatch_word_w )
621		AM_RANGE(0xa60000, 0xa60003) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff)                  // Sound
	621	AM_RANGE(0xa60000, 0xa60003) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff)             // Sound
622	622
623	623	AM_RANGE(0xb00000, 0xb00001) AM_WRITENOP                                                    // Coin Counter plus other things
624	624	AM_RANGE(0xb20000, 0xb20001) AM_WRITENOP                                                    // protection related?

trunk/src/mame/drivers/bfm_sc5.c

r22733	r22734
191	191	logerror("YMZ280 is generating an interrupt. State=%08x\n",state);
192	192	}
193	193
194		static const ymz280b_interface ymz280b_config =
195		{
196		DEVCB_DRIVER_LINE_MEMBER(bfm_sc5_state,bfm_sc5_ym_irqhandler)
197		};
198	194
199	195
200
201	196	void bfm_sc5_duart_irq_handler(device_t *device, int state, UINT8 vector)
202	197	{
203	198	printf("bfm_sc5_duart_irq_handler\n");
r22733	r22734
253	248	MCFG_DEFAULT_LAYOUT(layout_bfm_sc5)
254	249
255	250	MCFG_SOUND_ADD("ymz", YMZ280B, 16000000) // ?? Mhz
256		MCFG_SOUND_CONFIG(ymz280b_config)
	251	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(bfm_sc5_state, bfm_sc5_ym_irqhandler))
257	252	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
258	253	MACHINE_CONFIG_END

trunk/src/mame/drivers/firebeat.c

r22733	r22734
1852	1852	AM_RANGE(0x74000000, 0x740003ff) AM_READWRITE(ppc_spu_share_r, ppc_spu_share_w) // SPU shared RAM
1853	1853	AM_RANGE(0x7d000200, 0x7d00021f) AM_READ(cabinet_r)
1854	1854	AM_RANGE(0x7d000340, 0x7d000347) AM_READ(sensor_r)
1855		AM_RANGE(0x7d000400, 0x7d000403) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xffff0000)
	1855	AM_RANGE(0x7d000400, 0x7d000403) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xffff0000)
1856	1856	AM_RANGE(0x7d000800, 0x7d000803) AM_READ(input_r)
1857	1857	AM_RANGE(0x7d400000, 0x7d5fffff) AM_READWRITE(flashram_r, flashram_w)
1858	1858	AM_RANGE(0x7d800000, 0x7dbfffff) AM_READWRITE(soundflash_r, soundflash_w)
r22733	r22734
1897	1897	{
1898	1898	}
1899	1899
1900		static const ymz280b_interface ymz280b_intf =
1901		{
1902		DEVCB_DRIVER_LINE_MEMBER(firebeat_state,sound_irq_callback),         // irq
1903		DEVCB_DRIVER_MEMBER(firebeat_state,soundram_r)
1904		};
1905
1906	1900	static INPUT_PORTS_START(ppp)
1907	1901	PORT_START("IN0")
1908	1902	PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 )            // Left
r22733	r22734
2095	2089	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2096	2090
2097	2091	MCFG_SOUND_ADD("ymz", YMZ280B, 16934400)
2098		MCFG_SOUND_CONFIG(ymz280b_intf)
	2092	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(firebeat_state, sound_irq_callback))
	2093	MCFG_YMZ280B_EXT_READ_HANDLER(READ8(firebeat_state, soundram_r))
2099	2094	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2100	2095	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2101	2096
r22733	r22734
2148	2143	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2149	2144
2150	2145	MCFG_SOUND_ADD("ymz", YMZ280B, 16934400)
2151		MCFG_SOUND_CONFIG(ymz280b_intf)
	2146	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(firebeat_state, sound_irq_callback))
	2147	MCFG_YMZ280B_EXT_READ_HANDLER(READ8(firebeat_state, soundram_r))
2152	2148	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2153	2149	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2154	2150

trunk/src/mame/drivers/realbrk.c

r22733	r22734
161	161	AM_RANGE(0x604000, 0x604fff) AM_RAM_WRITE(realbrk_vram_2_w) AM_SHARE("vram_2")  // Text         (2)
162	162	AM_RANGE(0x606000, 0x60600f) AM_RAM_WRITE(realbrk_vregs_w) AM_SHARE("vregs")    // Scroll + Video Regs
163	163	AM_RANGE(0x605000, 0x61ffff) AM_RAM                                         //
164		AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xff00)   // YMZ280
	164	AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xff00)   // YMZ280
165	165	AM_RANGE(0xfe0000, 0xfeffff) AM_RAM                                         // RAM
166	166	AM_RANGE(0xfffc00, 0xffffff) AM_READWRITE_LEGACY(tmp68301_regs_r, tmp68301_regs_w)  // TMP68301 Registers
167	167	ADDRESS_MAP_END

trunk/src/mame/drivers/deco156.c

r22733	r22734
170	170	AM_RANGE(0x160000, 0x161fff) AM_READWRITE(wcvol95_spriteram_r, wcvol95_spriteram_w)
171	171	AM_RANGE(0x170000, 0x170003) AM_NOP // Irq ack?
172	172	AM_RANGE(0x180000, 0x180fff) AM_RAM_WRITE(wcvol95_nonbuffered_palette_w) AM_SHARE("paletteram")
173		AM_RANGE(0x1a0000, 0x1a0007) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x000000ff)
	173	AM_RANGE(0x1a0000, 0x1a0007) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x000000ff)
174	174	ADDRESS_MAP_END
175	175
176	176
r22733	r22734
314	314	logerror("sound irq\n");
315	315	}
316	316
317		static const ymz280b_interface ymz280b_intf =
318		{
319		DEVCB_DRIVER_LINE_MEMBER(deco156_state,sound_irq_gen)
320		};
321
322	317	INTERRUPT_GEN_MEMBER(deco156_state::deco32_vbl_interrupt)
323	318	{
324	319	device.execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
r22733	r22734
421	416	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
422	417
423	418	MCFG_SOUND_ADD("ymz", YMZ280B, 28000000 / 2)
424		MCFG_SOUND_CONFIG(ymz280b_intf)
	419	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(deco156_state, sound_irq_gen))
425	420	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
426	421	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
427	422	MACHINE_CONFIG_END

trunk/src/mame/drivers/bishi.c

r22733	r22734
153	153	AM_RANGE(0x840000, 0x840007) AM_DEVWRITE_LEGACY("k056832", k056832_b_word_w)    // VSCCS
154	154	AM_RANGE(0x850000, 0x85001f) AM_DEVWRITE_LEGACY("k054338", k054338_word_w)  // CLTC
155	155	AM_RANGE(0x870000, 0x8700ff) AM_DEVWRITE_LEGACY("k055555", k055555_word_w)  // PCU2
156		AM_RANGE(0x880000, 0x880003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xff00)
	156	AM_RANGE(0x880000, 0x880003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xff00)
157	157	AM_RANGE(0xa00000, 0xa01fff) AM_DEVREADWRITE_LEGACY("k056832", k056832_ram_word_r, k056832_ram_word_w)  // Graphic planes
158	158	AM_RANGE(0xb00000, 0xb03fff) AM_RAM_WRITE(paletteram_xbgr_word_be_w) AM_SHARE("paletteram")
159	159	AM_RANGE(0xb04000, 0xb047ff) AM_READ(bishi_mirror_r)    // bug in the ram/rom test?
r22733	r22734
363	363	m_maincpu->set_input_line(M68K_IRQ_1, (state) ? ASSERT_LINE : CLEAR_LINE);
364	364	}
365	365
366		static const ymz280b_interface ymz280b_intf =
367		{
368		DEVCB_DRIVER_LINE_MEMBER(bishi_state,sound_irq_gen)
369		};
370	366
371
372	367	static const k056832_interface bishi_k056832_intf =
373	368	{
374	369	"gfx1", 0,
r22733	r22734
426	421	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
427	422
428	423	MCFG_SOUND_ADD("ymz", YMZ280B, SOUND_CLOCK) /* 16.9344MHz */
429		MCFG_SOUND_CONFIG(ymz280b_intf)
	424	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(bishi_state, sound_irq_gen))
430	425	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
431	426	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
432	427	MACHINE_CONFIG_END

trunk/src/mame/drivers/deco_mlc.c

r22733	r22734
324	324	AM_RANGE(0x0440008, 0x044000b) AM_READ(mlc_440008_r) AM_MIRROR(0xff000000)
325	325	AM_RANGE(0x044001c, 0x044001f) AM_READWRITE(mlc_44001c_r, mlc_44001c_w) AM_MIRROR(0xff000000)
326	326	AM_RANGE(0x0500000, 0x0500003) AM_WRITE(avengrs_eprom_w) AM_MIRROR(0xff000000)
327		AM_RANGE(0x0600000, 0x0600007) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xff000000) AM_MIRROR(0xff000000)
	327	AM_RANGE(0x0600000, 0x0600007) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xff000000) AM_MIRROR(0xff000000)
328	328	AM_RANGE(0x070f000, 0x070ffff) AM_READWRITE(stadhr96_prot_146_r, stadhr96_prot_146_w) AM_MIRROR(0xff000000)
329	329	ADDRESS_MAP_END
330	330

trunk/src/mame/drivers/bfm_swp.c

r22733	r22734
137	137	{
138	138	}
139	139
140		static const ymz280b_interface ymz280b_config =
141		{
142		DEVCB_DRIVER_LINE_MEMBER(bfm_swp_state,irqhandler)
143		};
144	140
145
146	141	READ32_MEMBER(bfm_swp_state::bfm_swp_mem_r)
147	142	{
148	143	int pc = space.device().safe_pc();
r22733	r22734
223	218	MCFG_SPEAKER_STANDARD_MONO("mono")
224	219
225	220	MCFG_SOUND_ADD("ymz", YMZ280B, 10000000 )
226		MCFG_SOUND_CONFIG(ymz280b_config)
	221	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(bfm_swp_state, irqhandler))
227	222	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
228	223	MACHINE_CONFIG_END
229	224

trunk/src/mame/drivers/midas.c

r22733	r22734
288	288	AM_RANGE(0xb40000, 0xb40001) AM_READ(ret_ffff )
289	289	AM_RANGE(0xb60000, 0xb60001) AM_READ(ret_ffff )
290	290
291		AM_RANGE(0xb80008, 0xb8000b) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff )
	291	AM_RANGE(0xb80008, 0xb8000b) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff )
292	292
293	293	AM_RANGE(0xba0000, 0xba0001) AM_READ_PORT("START3")
294	294	AM_RANGE(0xbc0000, 0xbc0001) AM_READ_PORT("PLAYER3")
r22733	r22734
367	367	AM_RANGE(0xb40000, 0xb40001) AM_READ(ret_ffff )
368	368	AM_RANGE(0xb60000, 0xb60001) AM_READ(ret_ffff )
369	369
370		AM_RANGE(0xb80008, 0xb8000b) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff )
	370	AM_RANGE(0xb80008, 0xb8000b) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff )
371	371
372	372	AM_RANGE(0xba0000, 0xba0001) AM_READ_PORT("IN1")
373	373	AM_RANGE(0xbc0000, 0xbc0001) AM_READ_PORT("HAMMER")
r22733	r22734
694	694	logerror("YMZ280 is generating an interrupt. State=%08x\n",state);
695	695	}
696	696
697		static const ymz280b_interface ymz280b_config =
698		{
699		DEVCB_DRIVER_LINE_MEMBER(midas_state,livequiz_irqhandler)
700		};
701
702	697	static MACHINE_CONFIG_START( livequiz, midas_state )
703	698
704	699	/* basic machine hardware */
r22733	r22734
723	718	/* sound hardware */
724	719	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
725	720	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
726		MCFG_SOUND_CONFIG(ymz280b_config)
	721	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(midas_state, livequiz_irqhandler))
727	722	MCFG_SOUND_ROUTE(0, "lspeaker", 0.80)
728	723	MCFG_SOUND_ROUTE(1, "rspeaker", 0.80)
729	724	MACHINE_CONFIG_END
r22733	r22734
756	751	/* sound hardware */
757	752	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
758	753	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
759		MCFG_SOUND_CONFIG(ymz280b_config)
	754	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(midas_state, livequiz_irqhandler))
760	755	MCFG_SOUND_ROUTE(0, "lspeaker", 0.80)
761	756	MCFG_SOUND_ROUTE(1, "rspeaker", 0.80)
762	757	MACHINE_CONFIG_END

trunk/src/mame/drivers/coinmvga.c

r22733	r22734
374	374
375	375	AM_RANGE(0x600000, 0x600001) AM_WRITE(ramdac_bg_w)
376	376	AM_RANGE(0x600004, 0x600005) AM_WRITE(ramdac_fg_w)
377		AM_RANGE(0x600008, 0x600009) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xffff)
	377	AM_RANGE(0x600008, 0x600009) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xffff)
378	378	AM_RANGE(0x610000, 0x61000f) AM_RAM //touch screen i/o
379	379
380	380	AM_RANGE(0x700000, 0x7fffff) AM_ROM AM_REGION("maincpu", 0) // ?
r22733	r22734
655	655	*    Sound Interface     *
656	656	*************************/
657	657
658		static const ymz280b_interface ymz280b_intf =
659		{
660		DEVCB_NULL   // irq ?
661		};
662
663	658	INTERRUPT_GEN_MEMBER(coinmvga_state::vblank_irq)
664	659	{
665	660	//printf("1\n");
r22733	r22734
698	693	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
699	694
700	695	MCFG_SOUND_ADD("ymz", YMZ280B, SND_CLOCK)
701		MCFG_SOUND_CONFIG(ymz280b_intf)
702	696	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
703	697	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
704	698	MACHINE_CONFIG_END

trunk/src/mame/drivers/galpani3.c

r22733	r22734
493	493	AM_RANGE(0xf00012, 0xf00013) AM_READ_PORT("P2")
494	494	AM_RANGE(0xf00014, 0xf00015) AM_READ_PORT("COIN")
495	495	AM_RANGE(0xf00016, 0xf00017) AM_NOP // ? read, but overwritten
496		AM_RANGE(0xf00020, 0xf00023) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff)  // sound
	496	AM_RANGE(0xf00020, 0xf00023) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff)     // sound
497	497	AM_RANGE(0xf00040, 0xf00041) AM_READWRITE(watchdog_reset16_r, watchdog_reset16_w)   // watchdog
498	498	AM_RANGE(0xf00050, 0xf00051) AM_NOP // ? written once (3rd opcode, $30.b)
499	499	ADDRESS_MAP_END
500	500
501	501
502		static const ymz280b_interface ymz280b_intf =
503		{
504		DEVCB_NULL   // irq ?
505		};
506
507	502	static MACHINE_CONFIG_START( galpani3, galpani3_state )
508	503	MCFG_CPU_ADD("maincpu", M68000, XTAL_28_63636MHz/2) // Confirmed from PCB
509	504	MCFG_CPU_PROGRAM_MAP(galpani3_map)
r22733	r22734
540	535	MCFG_SPEAKER_STANDARD_MONO("mono")
541	536
542	537	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_33_333MHz / 2)  // Confirmed from PCB
543		MCFG_SOUND_CONFIG(ymz280b_intf)
544	538	MCFG_SOUND_ROUTE(0, "mono", 1.0)
545	539	MCFG_SOUND_ROUTE(1, "mono", 1.0)
546	540	MACHINE_CONFIG_END

trunk/src/mame/drivers/toaplan2.c

r22733	r22734
1431	1431	AM_RANGE(0x46, 0x46) AM_WRITE(batrider_clear_nmi_w)
1432	1432	AM_RANGE(0x48, 0x48) AM_READ(soundlatch_byte_r)
1433	1433	AM_RANGE(0x4a, 0x4a) AM_READ(soundlatch2_byte_r)
1434		AM_RANGE(0x80, 0x81) AM_DEVREADWRITE_LEGACY("ymz", ymz280b_r, ymz280b_w)
	1434	AM_RANGE(0x80, 0x81) AM_DEVREADWRITE("ymz", ymz280b_device, read, write)
1435	1435	ADDRESS_MAP_END
1436	1436
1437	1437
r22733	r22734
2984	2984	logerror("YMZ280 is generating an interrupt. State=%08x\n",state);
2985	2985	}
2986	2986
2987		static const ymz280b_interface ymz280b_config =
2988		{
2989		DEVCB_DRIVER_LINE_MEMBER(toaplan2_state,bbakraid_irqhandler)
2990		};
2991	2987
2992
2993	2988	static MACHINE_CONFIG_START( tekipaki, toaplan2_state )
2994	2989
2995	2990	/* basic machine hardware */
r22733	r22734
3845	3840	MCFG_SPEAKER_STANDARD_MONO("mono")
3846	3841
3847	3842	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
3848		MCFG_SOUND_CONFIG(ymz280b_config)
	3843	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(toaplan2_state, bbakraid_irqhandler))
3849	3844	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
3850	3845	MACHINE_CONFIG_END
3851	3846

trunk/src/mame/drivers/cave.c

r22733	r22734
423	423	static ADDRESS_MAP_START( dfeveron_map, AS_PROGRAM, 16, cave_state )
424	424	AM_RANGE(0x000000, 0x0fffff) AM_ROM                                                                 // ROM
425	425	AM_RANGE(0x100000, 0x10ffff) AM_RAM                                                                 // RAM
426		AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	426	AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)                   // YMZ280
427	427	/**/AM_RANGE(0x400000, 0x407fff) AM_RAM AM_SHARE("spriteram")       // Sprites
428	428	/**/AM_RANGE(0x408000, 0x40ffff) AM_RAM AM_SHARE("spriteram_2")                         // Sprites?
429	429	/**/AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
r22733	r22734
448	448	static ADDRESS_MAP_START( ddonpach_map, AS_PROGRAM, 16, cave_state )
449	449	AM_RANGE(0x000000, 0x0fffff) AM_ROM                                                                 // ROM
450	450	AM_RANGE(0x100000, 0x10ffff) AM_RAM                                                                 // RAM
451		AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	451	AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)           // YMZ280
452	452	/**/AM_RANGE(0x400000, 0x407fff) AM_RAM AM_SHARE("spriteram")       // Sprites
453	453	/**/AM_RANGE(0x408000, 0x40ffff) AM_RAM AM_SHARE("spriteram_2")                         // Sprites?
454	454	/**/AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
r22733	r22734
524	524	static ADDRESS_MAP_START( esprade_map, AS_PROGRAM, 16, cave_state )
525	525	AM_RANGE(0x000000, 0x0fffff) AM_ROM                                                                 // ROM
526	526	AM_RANGE(0x100000, 0x10ffff) AM_RAM                                                                 // RAM
527		AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	527	AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)           // YMZ280
528	528	/**/AM_RANGE(0x400000, 0x407fff) AM_RAM AM_SHARE("spriteram")       // Sprites
529	529	/**/AM_RANGE(0x408000, 0x40ffff) AM_RAM AM_SHARE("spriteram_2")                         // Sprites?
530	530	/**/AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
r22733	r22734
549	549	static ADDRESS_MAP_START( gaia_map, AS_PROGRAM, 16, cave_state )
550	550	AM_RANGE(0x000000, 0x0fffff) AM_ROM                                                                 // ROM
551	551	AM_RANGE(0x100000, 0x10ffff) AM_RAM                                                                 // RAM
552		AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	552	AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)           // YMZ280
553	553	AM_RANGE(0x400000, 0x407fff) AM_RAM AM_SHARE("spriteram")       // Sprite bank 1
554	554	AM_RANGE(0x408000, 0x40ffff) AM_RAM AM_SHARE("spriteram_2")                         // Sprite bank 2
555	555	AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
r22733	r22734
586	586	/**/AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
587	587	/**/AM_RANGE(0x600000, 0x607fff) AM_RAM_WRITE(cave_vram_1_w) AM_SHARE("vram.1")         // Layer 1
588	588	/**/AM_RANGE(0x700000, 0x707fff) AM_RAM_WRITE(cave_vram_2_w) AM_SHARE("vram.2")         // Layer 2
589		AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	589	AM_RANGE(0x800000, 0x800003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)           // YMZ280
590	590	/**/AM_RANGE(0x900000, 0x900005) AM_RAM AM_SHARE("vctrl.0")                             // Layer 0 Control
591	591	/**/AM_RANGE(0xa00000, 0xa00005) AM_RAM AM_SHARE("vctrl.1")                             // Layer 1 Control
592	592	/**/AM_RANGE(0xb00000, 0xb00005) AM_RAM AM_SHARE("vctrl.2")                             // Layer 2 Control
r22733	r22734
700	700	AM_RANGE(0x1c0000, 0x1c0007) AM_READ(cave_irq_cause_r)                                                  // IRQ Cause
701	701	AM_RANGE(0x1c0000, 0x1c007f) AM_WRITEONLY AM_SHARE("videoregs")                         // Video Regs
702	702	AM_RANGE(0x200000, 0x207fff) AM_WRITEONLY AM_SHARE("paletteram")    // Palette
703		//  AM_RANGE(0x240000, 0x240003) AM_DEVREAD8_LEGACY("ymz", ymz280b_r, 0x00ff)                                     // YMZ280
704		AM_RANGE(0x240000, 0x240003) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff)                                  // YMZ280
	703	//  AM_RANGE(0x240000, 0x240003) AM_DEVREAD8("ymz", ymz280b_device, read, 0x00ff)                           // YMZ280
	704	AM_RANGE(0x240000, 0x240003) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff)                         // YMZ280
705	705	AM_RANGE(0x280000, 0x280001) AM_READ_PORT("IN0")                                                        // Inputs + ???
706	706	AM_RANGE(0x280002, 0x280003) AM_READ_PORT("IN1")                                                        // Inputs + EEPROM
707	707	AM_RANGE(0x280008, 0x280009) AM_WRITE(korokoro_leds_w)                                                  // Leds
r22733	r22734
716	716	AM_RANGE(0x140000, 0x140005) AM_WRITEONLY AM_SHARE("vctrl.0")                           // Layer 0 Control
717	717	AM_RANGE(0x180000, 0x187fff) AM_WRITEONLY AM_SHARE("spriteram") // Sprites
718	718	AM_RANGE(0x200000, 0x207fff) AM_WRITEONLY AM_SHARE("paletteram")    // Palette
719		AM_RANGE(0x240000, 0x240003) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff)                                  // YMZ280
	719	AM_RANGE(0x240000, 0x240003) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff)                         // YMZ280
720	720	AM_RANGE(0x280000, 0x280001) AM_READ_PORT("IN0")                                                        // Inputs + ???
721	721	AM_RANGE(0x280002, 0x280003) AM_READ_PORT("IN1")                                                        // Inputs + EEPROM
722	722	AM_RANGE(0x280008, 0x280009) AM_WRITE(korokoro_leds_w)                                                  // Leds
r22733	r22734
991	991	static ADDRESS_MAP_START( uopoko_map, AS_PROGRAM, 16, cave_state )
992	992	AM_RANGE(0x000000, 0x0fffff) AM_ROM                                                                 // ROM
993	993	AM_RANGE(0x100000, 0x10ffff) AM_RAM                                                                 // RAM
994		AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x00ff)                   // YMZ280
	994	AM_RANGE(0x300000, 0x300003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x00ff)                   // YMZ280
995	995	/**/AM_RANGE(0x400000, 0x407fff) AM_RAM AM_SHARE("spriteram")       // Sprites
996	996	/**/AM_RANGE(0x408000, 0x40ffff) AM_RAM AM_SHARE("spriteram_2")                         // Sprites?
997	997	/**/AM_RANGE(0x500000, 0x507fff) AM_RAM_WRITE(cave_vram_0_w) AM_SHARE("vram.0")         // Layer 0
r22733	r22734
1797	1797	m_agallet_vblank_irq = 0;
1798	1798	}
1799	1799
1800		static const ymz280b_interface ymz280b_intf =
1801		{
1802		DEVCB_DRIVER_LINE_MEMBER(cave_state,sound_irq_gen)
1803		};
1804
1805	1800	WRITE_LINE_MEMBER(cave_state::irqhandler)
1806	1801	{
1807	1802	m_audiocpu->set_input_line(0, state ? ASSERT_LINE : CLEAR_LINE);
r22733	r22734
1852	1847	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
1853	1848
1854	1849	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
1855		MCFG_SOUND_CONFIG(ymz280b_intf)
	1850	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
1856	1851	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
1857	1852	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
1858	1853	MACHINE_CONFIG_END
r22733	r22734
1894	1889	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
1895	1890
1896	1891	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
1897		MCFG_SOUND_CONFIG(ymz280b_intf)
	1892	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
1898	1893	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
1899	1894	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
1900	1895	MACHINE_CONFIG_END
r22733	r22734
1986	1981	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
1987	1982
1988	1983	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
1989		MCFG_SOUND_CONFIG(ymz280b_intf)
	1984	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
1990	1985	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
1991	1986	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
1992	1987	MACHINE_CONFIG_END
r22733	r22734
2026	2021	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2027	2022
2028	2023	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
2029		MCFG_SOUND_CONFIG(ymz280b_intf)
	2024	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
2030	2025	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2031	2026	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2032	2027	MACHINE_CONFIG_END
r22733	r22734
2067	2062	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2068	2063
2069	2064	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
2070		MCFG_SOUND_CONFIG(ymz280b_intf)
	2065	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
2071	2066	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2072	2067	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2073	2068	MACHINE_CONFIG_END
r22733	r22734
2163	2158	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2164	2159
2165	2160	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
2166		MCFG_SOUND_CONFIG(ymz280b_intf)
	2161	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
2167	2162	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2168	2163	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2169	2164	MACHINE_CONFIG_END
r22733	r22734
2544	2539	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
2545	2540
2546	2541	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
2547		MCFG_SOUND_CONFIG(ymz280b_intf)
	2542	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(cave_state, sound_irq_gen))
2548	2543	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
2549	2544	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
2550	2545	MACHINE_CONFIG_END

trunk/src/mame/drivers/tecmosys.c

r22733	r22734
351	351	AM_RANGE(0x30, 0x30) AM_WRITE(tecmosys_z80_bank_w)
352	352	AM_RANGE(0x40, 0x40) AM_READ(soundlatch_byte_r)
353	353	AM_RANGE(0x50, 0x50) AM_WRITE(soundlatch2_byte_w)
354		AM_RANGE(0x60, 0x61) AM_DEVREADWRITE_LEGACY("ymz", ymz280b_r, ymz280b_w)
	354	AM_RANGE(0x60, 0x61) AM_DEVREADWRITE("ymz", ymz280b_device, read, write)
355	355	ADDRESS_MAP_END
356	356
357	357

trunk/src/mame/drivers/jchan.c

r22733	r22734
468	468	AM_RANGE(0x700000, 0x703fff) AM_RAM_WRITE(jchan_suprnova_sprite32_2_w) AM_SHARE("spriteram_2")
469	469	AM_RANGE(0x780000, 0x78003f) AM_RAM_WRITE(jchan_suprnova_sprite32regs_2_w) AM_SHARE("sprregs_2")
470	470
471		AM_RANGE(0x800000, 0x800003) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x00ff) // sound
	471	AM_RANGE(0x800000, 0x800003) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x00ff) // sound
472	472
473	473	AM_RANGE(0xa00000, 0xa00001) AM_READWRITE(watchdog_reset16_r, watchdog_reset16_w)   // watchdog
474	474	ADDRESS_MAP_END
r22733	r22734
577	577	INPUT_PORTS_END
578	578
579	579
580		/* sound stuff */
581
582		static const ymz280b_interface ymz280b_intf =
583		{
584		DEVCB_NULL   // irq ?
585		};
586
587
588	580	/* machine driver */
589	581
590	582	static MACHINE_CONFIG_START( jchan, jchan_state )
r22733	r22734
626	618	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
627	619
628	620	MCFG_SOUND_ADD("ymz", YMZ280B, 16000000)
629		MCFG_SOUND_CONFIG(ymz280b_intf)
630	621	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
631	622	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
632	623	MACHINE_CONFIG_END

trunk/src/mame/drivers/bfm_sc4h.c

r22733	r22734
189	189	return 0x0000;//space.machine().rand();;
190	190
191	191	case 0x1244:
192		return ymz280b_r(m_ymz,space,0);
	192	return m_ymz->read(space,0);
193	193
194	194	case 0x1246:
195		return ymz280b_r(m_ymz,space,1);
	195	return m_ymz->read(space,1);
196	196
197	197	default:
198	198	logerror("%08x maincpu read access offset %08x mem_mask %04x cs %d (LAMPS etc.)\n", pc, offset*2, mem_mask, cs);
r22733	r22734
332	332	break;
333	333
334	334	case 0x1248:
335		ymz280b_w(m_ymz,space,0, data & 0xff);
	335	m_ymz->write(space,0, data & 0xff);
336	336	break;
337	337
338	338	case 0x124a:
339		ymz280b_w(m_ymz,space,1, data & 0xff);
	339	m_ymz->write(space,1, data & 0xff);
340	340	break;
341	341
342	342	case 0x1330:
r22733	r22734
625	625	logerror("YMZ280 is generating an interrupt. State=%08x\n",state);
626	626	}
627	627
628		static const ymz280b_interface ymz280b_config =
629		{
630		DEVCB_DRIVER_LINE_MEMBER(sc4_state,bfm_sc4_irqhandler)
631		};
632	628
633	629
634
635	630	void bfm_sc4_duart_irq_handler(device_t *device, int state, UINT8 vector)
636	631	{
637	632	sc4_state *drvstate = device->machine().driver_data<sc4_state>();
r22733	r22734
760	755	MCFG_DEFAULT_LAYOUT(layout_bfm_sc4)
761	756
762	757	MCFG_SOUND_ADD("ymz", YMZ280B, 16000000) // ?? Mhz
763		MCFG_SOUND_CONFIG(ymz280b_config)
	758	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(sc4_state, bfm_sc4_irqhandler))
764	759	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
765	760	MACHINE_CONFIG_END
766	761

trunk/src/mame/drivers/maygayep.c

r22733	r22734
105	105	{
106	106	}
107	107
108		static const ymz280b_interface ymz280b_config =
109		{
110		DEVCB_DRIVER_LINE_MEMBER(maygayep_state,irqhandler)
111		};
112	108
113
114	109	static MACHINE_CONFIG_START( maygayep, maygayep_state )
115	110	MCFG_CPU_ADD("maincpu", H83002, 16000000 )
116	111	MCFG_CPU_PROGRAM_MAP( maygayep_map )
r22733	r22734
118	113	MCFG_SPEAKER_STANDARD_MONO("mono")
119	114
120	115	MCFG_SOUND_ADD("ymz", YMZ280B, 10000000 )
121		MCFG_SOUND_CONFIG(ymz280b_config)
	116	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(maygayep_state, irqhandler))
122	117	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
123	118	MACHINE_CONFIG_END
124	119

trunk/src/mame/drivers/zn.c

r22733	r22734
2511	2511
2512	2512	static ADDRESS_MAP_START( cbaj_z80_port_map, AS_IO, 8, zn_state )
2513	2513	ADDRESS_MAP_GLOBAL_MASK(0xff)
2514		AM_RANGE( 0x84, 0x85 ) AM_DEVREADWRITE_LEGACY("ymz", ymz280b_r, ymz280b_w )
	2514	AM_RANGE( 0x84, 0x85 ) AM_DEVREADWRITE("ymz", ymz280b_device, read, write )
2515	2515	AM_RANGE( 0x90, 0x90 ) AM_READWRITE(cbaj_z80_latch_r, cbaj_z80_latch_w )
2516	2516	AM_RANGE( 0x91, 0x91 ) AM_READ(cbaj_z80_ready_r )
2517	2517	ADDRESS_MAP_END

trunk/src/mame/drivers/backfire.c

r22733	r22734
326	326	//  AM_RANGE(0x1e8000, 0x1e8003) AM_READ(backfire_wheel1_r)
327	327	//  AM_RANGE(0x1e8004, 0x1e8007) AM_READ(backfire_wheel2_r)
328	328
329		AM_RANGE(0x1c0000, 0x1c0007) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x000000ff)
	329	AM_RANGE(0x1c0000, 0x1c0007) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0x000000ff)
330	330	ADDRESS_MAP_END
331	331
332	332
r22733	r22734
438	438	logerror("sound irq\n");
439	439	}
440	440
441		static const ymz280b_interface ymz280b_intf =
442		{
443		DEVCB_DRIVER_LINE_MEMBER(backfire_state,sound_irq_gen)
444		};
445
446	441	INTERRUPT_GEN_MEMBER(backfire_state::deco32_vbl_interrupt)
447	442	{
448	443	device.execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
r22733	r22734
545	540	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
546	541
547	542	MCFG_SOUND_ADD("ymz", YMZ280B, 28000000 / 2)
548		MCFG_SOUND_CONFIG(ymz280b_intf)
	543	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(backfire_state, sound_irq_gen))
549	544	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
550	545	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
551	546	MACHINE_CONFIG_END

trunk/src/mame/drivers/seibuspi.c

r22733	r22734
1145	1145	AM_RANGE(0x00000090, 0x00000097) AM_RAM /* Unknown */
1146	1146	AM_RANGE(0x00000400, 0x00000403) AM_READNOP AM_WRITE(input_select_w)
1147	1147	AM_RANGE(0x00000404, 0x00000407) AM_WRITE(sys386f2_eeprom_w)
1148		AM_RANGE(0x00000408, 0x0000040f) AM_DEVWRITE8_LEGACY("ymz", ymz280b_w, 0x000000ff)
	1148	AM_RANGE(0x00000408, 0x0000040f) AM_DEVWRITE8("ymz", ymz280b_device, write, 0x000000ff)
1149	1149	AM_RANGE(0x00000484, 0x00000487) AM_WRITE(palette_dma_start_w)
1150	1150	AM_RANGE(0x00000490, 0x00000493) AM_WRITE(video_dma_length_w)
1151	1151	AM_RANGE(0x00000494, 0x00000497) AM_WRITE(video_dma_address_w)
1152	1152	AM_RANGE(0x00000500, 0x0000054f) AM_RAM /* Unknown */
1153	1153	AM_RANGE(0x00000560, 0x00000563) AM_WRITE(sprite_dma_start_w)
1154		AM_RANGE(0x00000600, 0x00000607) AM_DEVREAD8_LEGACY("ymz", ymz280b_r, 0x000000ff)
	1154	AM_RANGE(0x00000600, 0x00000607) AM_DEVREAD8("ymz", ymz280b_device, read, 0x000000ff)
1155	1155	AM_RANGE(0x00000608, 0x0000060b) AM_READ(spi_unknown_r)
1156	1156	AM_RANGE(0x0000060c, 0x0000060f) AM_READ(spi_controls1_r)   /* Player controls */
1157	1157	AM_RANGE(0x00000800, 0x0003ffff) AM_RAM AM_SHARE("spimainram")

trunk/src/mame/drivers/suprnova.c

r22733	r22734
685	685	/* In between is write only */
686	686	AM_RANGE(0x0040000c, 0x0040000f) AM_READ_PORT("40000c")
687	687	AM_RANGE(0x00800000, 0x00801fff) AM_RAM AM_SHARE("nvram") /* 'backup' RAM */
688		AM_RANGE(0x00c00000, 0x00c00003) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xffff0000) /* ymz280_w (sound) */
	688	AM_RANGE(0x00c00000, 0x00c00003) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xffff0000) /* ymz280_w (sound) */
689	689	AM_RANGE(0x01000000, 0x0100000f) AM_DEVREADWRITE8("rtc", msm6242_device, read, write, 0xffffffff)
690	690	AM_RANGE(0x01800000, 0x01800003) AM_WRITE(skns_hit2_w)
691	691	AM_RANGE(0x02000000, 0x02003fff) AM_RAM AM_SHARE("spriteram") /* sprite ram */
r22733	r22734
741	741
742	742	/***** MACHINE DRIVER *****/
743	743
744		static const ymz280b_interface ymz280b_intf =
745		{
746		DEVCB_NULL   // irq ?
747		};
748
749
750	744	static MSM6242_INTERFACE( rtc_intf )
751	745	{
752	746	DEVCB_NULL
r22733	r22734
788	782	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
789	783
790	784	MCFG_SOUND_ADD("ymz", YMZ280B, 33333333 / 2)
791		MCFG_SOUND_CONFIG(ymz280b_intf)
792	785	MCFG_SOUND_ROUTE(0, "lspeaker", 1.0)
793	786	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
794	787	MACHINE_CONFIG_END

trunk/src/mame/drivers/sigmab98.c

r22733	r22734
521	521	static ADDRESS_MAP_START( gegege_io_map, AS_IO, 8, sigmab98_state )
522	522	ADDRESS_MAP_GLOBAL_MASK(0xff)
523	523
524		AM_RANGE( 0x00, 0x01 ) AM_DEVWRITE_LEGACY("ymz", ymz280b_w )
	524	AM_RANGE( 0x00, 0x01 ) AM_DEVWRITE("ymz", ymz280b_device, write )
525	525
526	526	AM_RANGE( 0xa0, 0xa1 ) AM_READWRITE(regs_r,  regs_w )
527	527	//  AM_RANGE( 0xa2, 0xa3 )

trunk/src/mame/drivers/gunpey.c

r22733	r22734
1292	1292	AM_RANGE(0x7f40, 0x7f45) AM_READ8(gunpey_inputs_r,0xffff)
1293	1293
1294	1294	AM_RANGE(0x7f48, 0x7f49) AM_WRITE8(gunpey_output_w,0x00ff)
1295		AM_RANGE(0x7f80, 0x7f81) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0xffff)
	1295	AM_RANGE(0x7f80, 0x7f81) AM_DEVREADWRITE8("ymz", ymz280b_device, read, write, 0xffff)
1296	1296
1297	1297	AM_RANGE(0x7f88, 0x7f89) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff)
1298	1298
r22733	r22734
1316	1316	logerror("sound irq\n");
1317	1317	}
1318	1318
1319		static const ymz280b_interface ymz280b_intf =
1320		{
1321		DEVCB_DRIVER_LINE_MEMBER(gunpey_state,sound_irq_gen)
1322		};
1323	1319
1324
1325	1320	/***************************************************************************************/
1326	1321
1327	1322	static INPUT_PORTS_START( gunpey )
r22733	r22734
1474	1469	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.25)
1475	1470
1476	1471	MCFG_SOUND_ADD("ymz", YMZ280B, XTAL_16_9344MHz)
1477		MCFG_SOUND_CONFIG(ymz280b_intf)
	1472	MCFG_YMZ280B_IRQ_HANDLER(WRITELINE(gunpey_state, sound_irq_gen))
1478	1473	MCFG_SOUND_ROUTE(0, "lspeaker", 0.25)
1479	1474	MCFG_SOUND_ROUTE(1, "rspeaker", 0.25)
1480	1475	MACHINE_CONFIG_END

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team