MAME SVN History

199869 Revisions

r17617 Monday 3rd September, 2012 at 15:00:20 UTC by Miodrag Milanović
Cleanup and some inheritance fixes (no whatsnew)

[src/emu]	~~devlegcy.c~~ devlegcy.h emu.mak
[src/emu/machine]	6525tpi.c 68681.c 74148.c 74153.c adc083x.c adc1038.c adc1213x.c idectrl.c k053252.c latch8.c mb14241.c mb87078.c pd4990a.c pic8259.c pit8253.c rp5h01.c smc91c9x.c tms6100.c upd4701.c wd17xx.c
[src/emu/sound]	2151intf.c 2203intf.c 2413intf.c 2608intf.c 2610intf.c 2612intf.c 262intf.c 3526intf.c 3812intf.c 8950intf.c aica.c astrocde.c ay8910.c beep.c c140.c c6280.c cdda.c cem3394.c digitalk.c dmadac.c es5506.c es5506.h es8712.c flt_rc.c flt_vol.c gaelco.c hc55516.c iremga20.c k005289.c k007232.c k051649.c k053260.c k056800.c mos6560.c msm5205.c msm5232.c multipcm.c n63701x.c namco.c nes_apu.c nile.c okim6258.c okim6376.c qsound.c rf5c400.c rf5c68.c s14001a.c s2636.c saa1099.c scsp.c segapcm.c sid6581.c sn76477.c sn76496.c snkwave.c sp0250.c sp0256.c speaker.c st0016.c t6w28.c tiaintf.c tms3615.c tms36xx.c tms5110.c tms5220.c upd7759.c vlm5030.c vrender0.c wave.c x1_010.c ymf271.c ymf278b.c ymz280b.c zsg2.c
[src/emu/video]	hd63484.c i8275.c s2636.c saa5050.c tlc34076.c tms9927.c voodoo.c
[src/mame/audio]	amiga.c beezer.c cps3.c exidy.c exidy440.c flower.c geebee.c gomoku.c gridlee.c hyprolyb.c irem.c leland.c m72.c micro3d.c namco52.c namco54.c phoenix.c pleiads.c polepos.c redbaron.c segag80r.c segasnd.c seibu.c snes_snd.c snk6502.c taitosnd.c tiamc1.c timeplt.c trackfld.c tx1.c warpwarp.c wiping.c
[src/mame/drivers]	mjkjidai.c ninjaw.c renegade.c warriorb.c
[src/mame/includes]	tx1.h
[src/mame/machine]	buggychl.c cd32.c decocass.c gaelco3d.c gaelco3d.h mathbox.c namco06.c namco50.c namco51.c namco53.c namco62.c namcoio.c nmk112.c taitoio.c
[src/mame/video]	atarirle.c deco16ic.c decocomn.c kan_pand.c konicdev.c taitoic.c vrender0.c
[src/mess/audio]	channelf.c dave.c gb.c gmaster.c lynx.c mac.c mea8000.c socrates.c special.c svision.c t6721.c upd1771.c vc4000.c wswan.c
[src/mess/drivers]	pv1000.c
[src/mess/includes]	apollo.h
[src/mess/machine]	990_tap.c apollo.c applefdc.c at45dbxx.c atarifdc.c ay31015.c beta.c ds1315.c e05a03.c er59256.c hd63450.c i8271.c kr2376.c mc68328.c mc6843.c mc6846.c mc6854.c micropolis.c mm58274c.c mos6530.c omti8621.c pc_lpt.c pcf8593.c pf10.c s3c44b0.c s3c44b0.h sst39vfx.c strata.c tf20.c upd7002.c upd71071.c upd765.c
[src/mess/video]	733_asr.c 911_vdt.c apollo.c crt.c dl1416.c k1ge.c odyssey2.c saa505x.c vdc8563.c vic4567.c vic6567.c vtvideo.c

trunk/src/mame/audio/micro3d.c
r17616	r17617
334	334	state->dac[3] = 255;
335	335	}
336	336
337		DEVICE_GET_INFO( micro3d_sound )
338		{
339		switch (state)
340		{
341		/* --- the following bits of info are returned as 64-bit signed integers --- */
342		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(noise_state); break;
343	337
344		/* --- the following bits of info are returned as pointers to data or functions --- */
345		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(micro3d_sound); break;
346		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(micro3d_sound); break;
347
348		/* --- the following bits of info are returned as NULL-terminated strings --- */
349		case DEVINFO_STR_NAME: strcpy(info->s, "Microprose Custom"); break;
350		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
351		}
352		}
353
354
355	338	/***************************************************************************
356	339
357	340	8031 port mappings:

trunk/src/mame/audio/warpwarp.c
r17616	r17617
241	241	}
242	242
243	243
244		DEVICE_GET_INFO( warpwarp_sound )
245		{
246		switch (state)
247		{
248		/* --- the following bits of info are returned as 64-bit signed integers --- */
249		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(warpwarp_sound_state); break;
250	244
251		/* --- the following bits of info are returned as pointers to data or functions --- */
252		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(warpwarp_sound); break;
253
254		/* --- the following bits of info are returned as NULL-terminated strings --- */
255		case DEVINFO_STR_NAME: strcpy(info->s, "Warp Warp Custom"); break;
256		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
257		}
258		}
259
260
261	245	const device_type WARPWARP = &device_creator<warpwarp_sound_device>;
262	246
263	247	warpwarp_sound_device::warpwarp_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/phoenix.c
r17616	r17617
571	571	register_state(device);
572	572	}
573	573
574		DEVICE_GET_INFO( phoenix_sound )
575		{
576		switch (state)
577		{
578		/* --- the following bits of info are returned as 64-bit signed integers --- */
579		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(phoenix_sound_state); break;
580
581		/* --- the following bits of info are returned as pointers to data or functions --- */
582		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(phoenix_sound); break;
583
584		/* --- the following bits of info are returned as NULL-terminated strings --- */
585		case DEVINFO_STR_NAME: strcpy(info->s, "Phoenix Custom"); break;
586		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
587		}
588		}
589
590
591	574	const device_type PHOENIX = &device_creator<phoenix_sound_device>;
592	575
593	576	phoenix_sound_device::phoenix_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/namco52.c
r17616	r17617
224	224	}
225	225
226	226
227		/*-------------------------------------------------
228		device definition
229		-------------------------------------------------*/
230
231		DEVICE_GET_INFO(namco_52xx)
232		{
233		switch (state)
234		{
235		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_52xx_state); break;
236
237		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_52xx); break;
238
239		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_52xx); break;
240
241		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_52xx); break;
242
243		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 52xx"); break;
244
245		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco52"); break;
246		}
247		}
248
249	227	const device_type NAMCO_52XX = &device_creator<namco_52xx_device>;
250	228
251	229	namco_52xx_device::namco_52xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/segasnd.c
r17616	r17617
181	181	}
182	182
183	183
184		DEVICE_GET_INFO( speech_sound )
185		{
186		switch (state)
187		{
188		/* --- the following bits of info are returned as 64-bit signed integers --- */
189		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(speech_state); break;
190
191		/* --- the following bits of info are returned as pointers to data or functions --- */
192		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(speech_sound); break;
193
194		/* --- the following bits of info are returned as NULL-terminated strings --- */
195		case DEVINFO_STR_NAME: strcpy(info->s, "Sega Speech Sound Board"); break;
196		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
197		}
198		}
199
200	184	const device_type SEGASPEECH = &device_creator<speech_sound_device>;
201	185
202	186	speech_sound_device::speech_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
r17616	r17617
900	884	}
901	885
902	886
903		DEVICE_GET_INFO( usb_sound )
904		{
905		switch (state)
906		{
907		/* --- the following bits of info are returned as 64-bit signed integers --- */
908		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(usb_state); break;
909
910		/* --- the following bits of info are returned as pointers to data or functions --- */
911		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(usb_sound); break;
912		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(usb_sound); break;
913
914		/* --- the following bits of info are returned as NULL-terminated strings --- */
915		case DEVINFO_STR_NAME: strcpy(info->s, "Sega Universal Sound Board"); break;
916		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
917		}
918		}
919
920	887	const device_type SEGAUSB = &device_creator<usb_sound_device>;
921	888
922	889	usb_sound_device::usb_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/taitosnd.c
r17616	r17617
313	313	}
314	314	}
315	315
316		DEVICE_GET_INFO(tc0140syt)
317		{
318		switch (state)
319		{
320		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0140syt_state); break;
321
322		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0140syt); break;
323
324		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0140syt); break;
325
326		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0140SYT"); break;
327		}
328		}
329
330	316	const device_type TC0140SYT = &device_creator<tc0140syt_device>;
331	317
332	318	tc0140syt_device::tc0140syt_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/wiping.c
r17616	r17617
210	210	}
211	211
212	212
213		DEVICE_GET_INFO( wiping_sound )
214		{
215		switch (state)
216		{
217		/* --- the following bits of info are returned as 64-bit signed integers --- */
218		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(wiping_sound_state); break;
219
220		/* --- the following bits of info are returned as pointers to data or functions --- */
221		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(wiping_sound); break;
222
223		/* --- the following bits of info are returned as NULL-terminated strings --- */
224		case DEVINFO_STR_NAME: strcpy(info->s, "Wiping Custom"); break;
225		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
226		}
227		}
228
229
230
231	213	/********************************************************************************/
232	214
233	215	WRITE8_DEVICE_HANDLER( wiping_sound_w )

trunk/src/mame/audio/leland.c
r17616	r17617
280	280	}
281	281
282	282
283		DEVICE_GET_INFO( leland_sound )
284		{
285		switch (state)
286		{
287		/* --- the following bits of info are returned as 64-bit signed integers --- */
288		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(leland_sound_state); break;
289
290		/* --- the following bits of info are returned as pointers to data or functions --- */
291		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(leland_sound); break;
292
293		/* --- the following bits of info are returned as NULL-terminated strings --- */
294		case DEVINFO_STR_NAME: strcpy(info->s, "Leland DAC"); break;
295		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
296		}
297		}
298
299
300	283	void leland_dac_update(device_t *device, int dacnum, UINT8 sample)
301	284	{
302	285	leland_sound_state *state = get_safe_token(device);
r17616	r17617
588	571	}
589	572
590	573
591		DEVICE_GET_INFO( leland_80186_sound )
592		{
593		switch (state)
594		{
595		/* --- the following bits of info are returned as 64-bit signed integers --- */
596		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(leland_sound_state); break;
597
598		/* --- the following bits of info are returned as pointers to data or functions --- */
599		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(leland_80186_sound); break;
600		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(leland_80186_sound); break;
601
602		/* --- the following bits of info are returned as NULL-terminated strings --- */
603		case DEVINFO_STR_NAME: strcpy(info->s, "Leland 80186 DAC"); break;
604		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
605		}
606		}
607
608
609		DEVICE_GET_INFO( redline_80186_sound )
610		{
611		switch (state)
612		{
613		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(leland_sound_state); break;
614
615		/* --- the following bits of info are returned as pointers to data or functions --- */
616		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(redline_80186_sound); break;
617		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(leland_80186_sound); break;
618
619		/* --- the following bits of info are returned as NULL-terminated strings --- */
620		case DEVINFO_STR_NAME: strcpy(info->s, "Redline Racer 80186 DAC"); break;
621		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
622		}
623		}
624
625
626	574	const device_type LELAND = &device_creator<leland_sound_device>;
627	575
628	576	leland_sound_device::leland_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/gomoku.c
r17616	r17617
209	209	}
210	210
211	211
212		DEVICE_GET_INFO( gomoku_sound )
213		{
214		switch (state)
215		{
216		/* --- the following bits of info are returned as 64-bit signed integers --- */
217		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gomoku_sound_state); break;
218
219		/* --- the following bits of info are returned as pointers to data or functions --- */
220		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(gomoku_sound); break;
221
222		/* --- the following bits of info are returned as NULL-terminated strings --- */
223		case DEVINFO_STR_NAME: strcpy(info->s, "Gomoku Custom"); break;
224		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
225		}
226		}
227
228
229	212	/********************************************************************************/
230	213
231	214	WRITE8_DEVICE_HANDLER( gomoku_sound1_w )

trunk/src/mame/audio/seibu.c
r17616	r17617
194	194	state->m_adpcm.reset();
195	195	}
196	196
197		DEVICE_GET_INFO( seibu_adpcm )
198		{
199		switch (state)
200		{
201		/* --- the following bits of info are returned as 64-bit signed integers --- */
202		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(seibu_adpcm_state); break;
203
204		/* --- the following bits of info are returned as pointers to data or functions --- */
205		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(seibu_adpcm); break;
206
207		/* --- the following bits of info are returned as NULL-terminated strings --- */
208		case DEVINFO_STR_NAME: strcpy(info->s, "Seibu ADPCM"); break;
209		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
210		}
211		}
212
213
214	197	// "decrypt" is a bit flowery here, as it's probably just line-swapping to
215	198	// simplify PCB layout/routing rather than intentional protection, but it
216	199	// still fits, especially since the Z80s for all these games are truly encrypted.

trunk/src/mame/audio/gridlee.c
r17616	r17617
80	80	}
81	81
82	82
83		DEVICE_GET_INFO( gridlee_sound )
84		{
85		switch (state)
86		{
87		/* --- the following bits of info are returned as 64-bit signed integers --- */
88		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gridlee_sound_state); break;
89
90		/* --- the following bits of info are returned as pointers to data or functions --- */
91		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(gridlee_sound); break;
92
93		/* --- the following bits of info are returned as NULL-terminated strings --- */
94		case DEVINFO_STR_NAME: strcpy(info->s, "Gridlee Custom"); break;
95		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
96		}
97		}
98
99
100
101	83	WRITE8_DEVICE_HANDLER( gridlee_sound_w )
102	84	{
103	85	gridlee_sound_state *state = get_safe_token(device);

trunk/src/mame/audio/tiamc1.c
r17616	r17617
330	330	}
331	331
332	332
333		DEVICE_GET_INFO( tiamc1_sound )
334		{
335		switch (state)
336		{
337		/* --- the following bits of info are returned as 64-bit signed integers --- */
338		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tiamc1_sound_state); break;
339
340		/* --- the following bits of info are returned as pointers to data or functions --- */
341		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tiamc1_sound); break;
342
343		/* --- the following bits of info are returned as NULL-terminated strings --- */
344		case DEVINFO_STR_NAME: strcpy(info->s, "TIA-MC1 Custom"); break;
345		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
346		}
347		}
348
349
350
351	333	const device_type TIAMC1 = &device_creator<tiamc1_sound_device>;
352	334
353	335	tiamc1_sound_device::tiamc1_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/segag80r.c
r17616	r17617
27	27	#define SEGA005_555_TIMER_FREQ (1.44 / ((15000 + 2 * 4700) * 1.5e-6))
28	28	#define SEGA005_COUNTER_FREQ (100000) /* unknown, just a guess */
29	29
30		DEVICE_GET_INFO( sega005_sound );
31
32	30	class sega005_sound_device : public device_t,
33	31	public device_sound_interface
34	32	{
r17616	r17617
627	625	}
628	626
629	627
630		DEVICE_GET_INFO( sega005_sound )
631		{
632		switch (state)
633		{
634		/* --- the following bits of info are returned as pointers to data or functions --- */
635		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(sega005_sound); break;
636
637		/* --- the following bits of info are returned as NULL-terminated strings --- */
638		case DEVINFO_STR_NAME: strcpy(info->s, "005 Custom"); break;
639		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
640		}
641		}
642
643
644	628	static STREAM_UPDATE( sega005_stream_update )
645	629	{
646	630	segag80r_state *state = device->machine().driver_data<segag80r_state>();

trunk/src/mame/audio/flower.c
r17616	r17617
238	238	}
239	239	}
240	240
241		DEVICE_GET_INFO( flower_sound )
242		{
243		switch (state)
244		{
245		/* --- the following bits of info are returned as 64-bit signed integers --- */
246		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(flower_sound_state); break;
247
248		/* --- the following bits of info are returned as pointers to data or functions --- */
249		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(flower_sound); break;
250		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(flower_sound); break;
251
252		/* --- the following bits of info are returned as NULL-terminated strings --- */
253		case DEVINFO_STR_NAME: strcpy(info->s, "Flower Custom"); break;
254		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
255		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
256		}
257		}
258
259
260	241	/********************************************************************************/
261	242
262	243	#if FLOWER_VERBOSE

trunk/src/mame/audio/exidy.c
r17616	r17617
511	511	}
512	512
513	513
514		DEVICE_GET_INFO( exidy_sound )
515		{
516		switch (state)
517		{
518		/* --- the following bits of info are returned as 64-bit signed integers --- */
519		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(exidy_sound_state); break;
520
521		/* --- the following bits of info are returned as pointers to data or functions --- */
522		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(exidy_sound); break;
523		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(exidy_sound); break;
524
525		/* --- the following bits of info are returned as NULL-terminated strings --- */
526		case DEVINFO_STR_NAME: strcpy(info->s, "Exidy SFX"); break;
527		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
528		}
529		}
530
531
532	514	/*************************************
533	515	*
534	516	* 6532 interface
r17616	r17617
903	885	}
904	886
905	887
906		DEVICE_GET_INFO( venture_sound )
907		{
908		switch (state)
909		{
910		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(exidy_sound_state); break;
911
912		/* --- the following bits of info are returned as pointers to data or functions --- */
913		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(venture_sound); break;
914		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(venture_sound); break;
915
916		/* --- the following bits of info are returned as NULL-terminated strings --- */
917		case DEVINFO_STR_NAME: strcpy(info->s, "Exidy SFX+PSG"); break;
918		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
919		}
920		}
921
922	888	const device_type EXIDY_VENTURE = &device_creator<venture_sound_device>;
923	889
924	890	venture_sound_device::venture_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
r17616	r17617
1186	1152	}
1187	1153
1188	1154
1189		DEVICE_GET_INFO( victory_sound )
1190		{
1191		switch (state)
1192		{
1193		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(exidy_sound_state); break;
1194
1195		/* --- the following bits of info are returned as pointers to data or functions --- */
1196		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(victory_sound); break;
1197		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(victory_sound); break;
1198
1199		/* --- the following bits of info are returned as NULL-terminated strings --- */
1200		case DEVINFO_STR_NAME: strcpy(info->s, "Exidy SFX+PSG+Speech"); break;
1201		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1202		}
1203		}
1204
1205
1206	1155	const device_type EXIDY_VICTORY = &device_creator<victory_sound_device>;
1207	1156
1208	1157	victory_sound_device::victory_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/cps3.c
r17616	r17617
117	117	state->m_stream = device->machine().sound().stream_alloc(*device, 0, 2, device->clock() / 384, NULL, cps3_stream_update);
118	118	}
119	119
120		DEVICE_GET_INFO( cps3_sound )
121		{
122		switch (state)
123		{
124		/* --- the following bits of info are returned as 64-bit signed integers --- */
125		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(cps3_sound_state); break;
126
127		/* --- the following bits of info are returned as pointers to data or functions --- */
128		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(cps3_sound); break;
129
130		/* --- the following bits of info are returned as NULL-terminated strings --- */
131		case DEVINFO_STR_NAME: strcpy(info->s, "CPS3 Custom"); break;
132		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
133		}
134		}
135
136
137	120	WRITE32_DEVICE_HANDLER( cps3_sound_w )
138	121	{
139	122	cps3_sound_state *state = get_safe_token(device);

trunk/src/mame/audio/hyprolyb.c
r17616	r17617
136	136	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
137	137	MACHINE_CONFIG_END
138	138
139		/*****************************************************************************
140		DEVICE DEFINITION
141		*****************************************************************************/
142		DEVICE_GET_INFO(hyprolyb_adpcm)
143		{
144		switch (state)
145		{
146		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(hyprolyb_adpcm_state); break;
147
148		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(hyprolyb_adpcm); break;
149
150		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(hyprolyb_adpcm); break;
151
152		case DEVINFO_STR_NAME: strcpy(info->s, "Hyper Olympics Audio"); break;
153		}
154		}
155
156	139	const device_type HYPROLYB_ADPCM = &device_creator<hyprolyb_adpcm_device>;
157	140
158	141	hyprolyb_adpcm_device::hyprolyb_adpcm_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/timeplt.c
r17616	r17617
261	261	DEVICE DEFINITION
262	262	*****************************************************************************/
263	263
264		DEVICE_GET_INFO(timeplt_audio)
265		{
266		switch (state)
267		{
268		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(timeplt_audio_state); break;
269
270		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(timeplt_audio); break;
271
272		case DEVINFO_STR_NAME: strcpy(info->s, "Time Pilot Audio"); break;
273		}
274		}
275
276	264	const device_type TIMEPLT_AUDIO = &device_creator<timeplt_audio_device>;
277	265
278	266	timeplt_audio_device::timeplt_audio_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/amiga.c
r17616	r17617
278	278	}
279	279
280	280
281		DEVICE_GET_INFO( amiga_sound )
282		{
283		switch (state)
284		{
285		/* --- the following bits of info are returned as 64-bit signed integers --- */
286		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(amiga_audio); break;
287
288		/* --- the following bits of info are returned as pointers to data or functions --- */
289		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(amiga_sound); break;
290
291		/* --- the following bits of info are returned as NULL-terminated strings --- */
292		case DEVINFO_STR_NAME: strcpy(info->s, "Amiga Paula"); break;
293		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
294		}
295		}
296
297
298	281	const device_type AMIGA = &device_creator<amiga_sound_device>;
299	282
300	283	amiga_sound_device::amiga_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/trackfld.c
r17616	r17617
161	161	DEVICE DEFINITION
162	162	*****************************************************************************/
163	163
164		DEVICE_GET_INFO(trackfld_audio)
165		{
166		switch (state)
167		{
168		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(trackfld_audio_state); break;
169
170		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(trackfld_audio); break;
171
172		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(trackfld_audio); break;
173
174		case DEVINFO_STR_NAME: strcpy(info->s, "Track And Field Audio"); break;
175		}
176		}
177
178	164	const device_type TRACKFLD_AUDIO = &device_creator<trackfld_audio_device>;
179	165
180	166	trackfld_audio_device::trackfld_audio_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/redbaron.c
r17616	r17617
226	226	state->m_channel = device->machine().sound().stream_alloc(*device, 0, 1, OUTPUT_RATE, 0, redbaron_sound_update);
227	227	}
228	228
229
230		DEVICE_GET_INFO( redbaron_sound )
231		{
232		switch (state)
233		{
234		/* --- the following bits of info are returned as 64-bit signed integers --- */
235		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(redbaron_sound_state); break;
236
237		/* --- the following bits of info are returned as pointers to data or functions --- */
238		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(redbaron_sound);break;
239
240		/* --- the following bits of info are returned as NULL-terminated strings --- */
241		case DEVINFO_STR_NAME: strcpy(info->s, "Red Baron Custom"); break;
242		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
243		}
244		}
245
246
247	229	const device_type REDBARON = &device_creator<redbaron_sound_device>;
248	230
249	231	redbaron_sound_device::redbaron_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/namco54.c
r17616	r17617
180	180	}
181	181
182	182
183		/*-------------------------------------------------
184		device definition
185		-------------------------------------------------*/
186
187		DEVICE_GET_INFO(namco_54xx)
188		{
189		switch (state)
190		{
191
192		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_54xx_state); break;
193
194		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_54xx); break;
195
196		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_54xx); break;
197
198		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_54xx); break;
199
200		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 54xx"); break;
201
202		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco54"); break;
203		}
204		}
205
206	183	const device_type NAMCO_54XX = &device_creator<namco_54xx_device>;
207	184
208	185	namco_54xx_device::namco_54xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/snk6502.c
r17616	r17617
665	665	state->m_tone_stream = device->machine().sound().stream_alloc(*device, 0, 1, SAMPLE_RATE, NULL, snk6502_tone_update);
666	666	}
667	667
668		DEVICE_GET_INFO( snk6502_sound )
669		{
670		switch (state)
671		{
672		/* --- the following bits of info are returned as 64-bit signed integers --- */
673		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(snk6502_sound_state); break;
674
675		/* --- the following bits of info are returned as pointers to data or functions --- */
676		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(snk6502_sound); break;
677
678		/* --- the following bits of info are returned as NULL-terminated strings --- */
679		case DEVINFO_STR_NAME: strcpy(info->s, "snk6502 Custom"); break;
680		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
681		}
682		}
683
684	668	int snk6502_music0_playing(running_machine &machine)
685	669	{
686	670	device_t *device = machine.device("snk6502");

trunk/src/mame/audio/exidy440.c
r17616	r17617
989	989	*
990	990	*************************************/
991	991
992		DEVICE_GET_INFO( exidy440_sound )
993		{
994		switch (state)
995		{
996		/* --- the following bits of info are returned as 64-bit signed integers --- */
997		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(exidy440_audio_state); break;
998
999		/* --- the following bits of info are returned as pointers to data or functions --- */
1000		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(exidy440_sound); break;
1001		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(exidy440_sound); break;
1002
1003		/* --- the following bits of info are returned as NULL-terminated strings --- */
1004		case DEVINFO_STR_NAME: strcpy(info->s, "Exidy 440 CVSD"); break;
1005		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1006		}
1007		}
1008
1009
1010	992	const device_type EXIDY440 = &device_creator<exidy440_sound_device>;
1011	993
1012	994	exidy440_sound_device::exidy440_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/tx1.c
r17616	r17617
320	320	state->m_step0 = state->m_step1 = state->m_step2 = 0;
321	321	}
322	322
323		DEVICE_GET_INFO( tx1_sound )
324		{
325		switch (state)
326		{
327		/* --- the following bits of info are returned as 64-bit signed integers --- */
328		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tx1_sound_state); break;
329
330		/* --- the following bits of info are returned as pointers to data or functions --- */
331		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tx1_sound); break;
332		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tx1_sound); break;
333
334		/* --- the following bits of info are returned as NULL-terminated strings --- */
335		case DEVINFO_STR_NAME: strcpy(info->s, "TX-1 Custom"); break;
336		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
337		}
338		}
339
340
341	323	/*************************************
342	324	*
343	325	* Buggy Boy
r17616	r17617
591	573	state->m_noise_lfsrd = 0;
592	574	}
593	575
594		DEVICE_GET_INFO( buggyboy_sound )
595		{
596		switch (state)
597		{
598		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tx1_sound_state); break;
599
600		/* --- the following bits of info are returned as pointers to data or functions --- */
601		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(buggyboy_sound); break;
602		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(buggyboy_sound); break;
603
604		/* --- the following bits of info are returned as NULL-terminated strings --- */
605		case DEVINFO_STR_NAME: strcpy(info->s, "Buggy Boy Custom"); break;
606		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
607		}
608		}
609
610
611	576	const device_type BUGGYBOY = &device_creator<buggyboy_sound_device>;
612	577
613	578	buggyboy_sound_device::buggyboy_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
614		: device_t(mconfig, BUGGYBOY, "Buggy Boy Custom", tag, owner, clock),
615		device_sound_interface(mconfig, *this)
	579	: tx1_sound_device(mconfig, BUGGYBOY, "Buggy Boy Custom", tag, owner, clock)
616	580	{
617		m_token = global_alloc_array_clear(UINT8, sizeof(tx1_sound_state));
618	581	}
619	582
620	583	//-------------------------------------------------
r17616	r17617
665	628	m_token = global_alloc_array_clear(UINT8, sizeof(tx1_sound_state));
666	629	}
667	630
	631	tx1_sound_device::tx1_sound_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
	632	: device_t(mconfig, type, name, tag, owner, clock),
	633	device_sound_interface(mconfig, *this)
	634	{
	635	m_token = global_alloc_array_clear(UINT8, sizeof(tx1_sound_state));
	636	}
668	637	//-------------------------------------------------
669	638	// device_config_complete - perform any
670	639	// operations now that the configuration is

trunk/src/mame/audio/irem.c
r17616	r17617
486	486	MCFG_CPU_PROGRAM_MAP(m62_sound_map)
487	487	MACHINE_CONFIG_END
488	488
489		/*****************************************************************************
490		DEVICE DEFINITION
491		*****************************************************************************/
492		DEVICE_GET_INFO(irem_audio)
493		{
494		switch (state)
495		{
496		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(irem_audio_state); break;
497
498		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(irem_audio); break;
499
500		case DEVINFO_STR_NAME: strcpy(info->s, "Irem Audio"); break;
501		}
502		}
503
504	489	const device_type IREM_AUDIO = &device_creator<irem_audio_device>;
505	490
506	491	irem_audio_device::irem_audio_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/m72.c
r17616	r17617
254	254	state->sample_addr = (state->sample_addr + 1) & (state->samples_size - 1);
255	255	}
256	256
257		DEVICE_GET_INFO( m72_audio )
258		{
259		switch (state)
260		{
261		/* --- the following bits of info are returned as 64-bit signed integers --- */
262		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(m72_audio_state); break;
263
264		/* --- the following bits of info are returned as pointers to data or functions --- */
265		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(m72_audio); break;
266		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(m72_audio); break;
267
268		/* --- the following bits of info are returned as NULL-terminated strings --- */
269		case DEVINFO_STR_NAME: strcpy(info->s, "M72 Custom"); break;
270		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
271		}
272		}
273
274	257	const device_type M72 = &device_creator<m72_audio_device>;
275	258
276	259	m72_audio_device::m72_audio_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/beezer.c
r17616	r17617
479	479	}
480	480
481	481
482		DEVICE_GET_INFO( beezer_sound )
483		{
484		switch (state)
485		{
486		/* --- the following bits of info are returned as 64-bit signed integers --- */
487		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(beezer_sound_state); break;
488
489		/* --- the following bits of info are returned as pointers to data or functions --- */
490		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(beezer_sound); break;
491		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(beezer_sound); break;
492
493		/* --- the following bits of info are returned as NULL-terminated strings --- */
494		case DEVINFO_STR_NAME: strcpy(info->s, "beezer SFX"); break;
495		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
496		}
497		}
498
499	482	/*************************************
500	483	*
501	484	* 6840 timer handlers

trunk/src/mame/audio/geebee.c
r17616	r17617
144	144	state->m_volume_timer = machine.scheduler().timer_alloc(FUNC(volume_decay), state);
145	145	}
146	146
147		DEVICE_GET_INFO( geebee_sound )
148		{
149		switch (state)
150		{
151		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(geebee_sound_state); break;
152
153		/* --- the following bits of info are returned as pointers to data or functions --- */
154		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(geebee_sound); break;
155
156		/* --- the following bits of info are returned as NULL-terminated strings --- */
157		case DEVINFO_STR_NAME: strcpy(info->s, "Gee Bee Custom"); break;
158		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
159		}
160		}
161
162
163	147	const device_type GEEBEE = &device_creator<geebee_sound_device>;
164	148
165	149	geebee_sound_device::geebee_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/snes_snd.c
r17616	r17617
1359	1359	spc700_reset(device);
1360	1360	}
1361	1361
1362		/*-------------------------------------------------
1363		Device definition
1364		-------------------------------------------------*/
1365
1366		DEVICE_GET_INFO(snes_sound)
1367		{
1368		switch (state)
1369		{
1370		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(snes_sound_state); break;
1371
1372		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(snes_sound); break;
1373
1374		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(snes_sound); break;
1375
1376		case DEVINFO_STR_NAME: strcpy(info->s, "SNES Custom DSP (SPC700)"); break;
1377		}
1378		}
1379
1380	1362	const device_type SNES = &device_creator<snes_sound_device>;
1381	1363
1382	1364	snes_sound_device::snes_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/pleiads.c
r17616	r17617
562	562	DEVICE_START_CALL(common_sh_start);
563	563	}
564	564
565		DEVICE_GET_INFO( pleiads_sound )
566		{
567		switch (state)
568		{
569		/* --- the following bits of info are returned as 64-bit signed integers --- */
570		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pleiads_sound_state); break;
571
572		/* --- the following bits of info are returned as pointers to data or functions --- */
573		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pleiads_sound); break;
574
575		/* --- the following bits of info are returned as NULL-terminated strings --- */
576		case DEVINFO_STR_NAME: strcpy(info->s, "Pleiads Custom"); break;
577		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
578		}
579		}
580
581
582	565	static DEVICE_START( naughtyb_sound )
583	566	{
584	567	pleiads_sound_state *state = get_safe_token(device);
r17616	r17617
638	621	DEVICE_START_CALL(common_sh_start);
639	622	}
640	623
641		DEVICE_GET_INFO( naughtyb_sound )
642		{
643		switch (state)
644		{
645		/* --- the following bits of info are returned as 64-bit signed integers --- */
646		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pleiads_sound_state); break;
647
648		/* --- the following bits of info are returned as pointers to data or functions --- */
649		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(naughtyb_sound);break;
650
651		/* --- the following bits of info are returned as NULL-terminated strings --- */
652		case DEVINFO_STR_NAME: strcpy(info->s, "Naughty Boy Custom"); break;
653		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
654		}
655		}
656
657
658	624	static DEVICE_START( popflame_sound )
659	625	{
660	626	pleiads_sound_state *state = get_safe_token(device);
r17616	r17617
714	680	DEVICE_START_CALL(common_sh_start);
715	681	}
716	682
717		DEVICE_GET_INFO( popflame_sound )
718		{
719		switch (state)
720		{
721		/* --- the following bits of info are returned as 64-bit signed integers --- */
722		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pleiads_sound_state); break;
723
724		/* --- the following bits of info are returned as pointers to data or functions --- */
725		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(popflame_sound); break;
726
727		/* --- the following bits of info are returned as NULL-terminated strings --- */
728		case DEVINFO_STR_NAME: strcpy(info->s, "Pop Flamer Custom"); break;
729		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
730		}
731		}
732
733
734	683	const device_type PLEIADS = &device_creator<pleiads_sound_device>;
735	684
736	685	pleiads_sound_device::pleiads_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/audio/polepos.c
r17616	r17617
139	139	filter2_reset(&state->m_filter_engine[loop]);
140	140	}
141	141
142		DEVICE_GET_INFO( polepos_sound )
143		{
144		switch (state)
145		{
146		/* --- the following bits of info are returned as 64-bit signed integers --- */
147		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(polepos_sound_state); break;
148
149		/* --- the following bits of info are returned as pointers to data or functions --- */
150		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(polepos_sound); break;
151		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(polepos_sound); break;
152
153		/* --- the following bits of info are returned as NULL-terminated strings --- */
154		case DEVINFO_STR_NAME: strcpy(info->s, "Pole Position Custom"); break;
155		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
156		}
157		}
158
159
160	142	/************************************/
161	143	/* Write LSB of engine sound */
162	144	/************************************/

trunk/src/mame/machine/taitoio.c
r17616	r17617
510	510	tc0640fio->regs[i] = 0;
511	511	}
512	512
513		DEVICE_GET_INFO( tc0220ioc )
514		{
515		switch (state)
516		{
517		/* --- the following bits of info are returned as 64-bit signed integers --- */
518		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0220ioc_state); break;
519
520		/* --- the following bits of info are returned as pointers to data or functions --- */
521		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0220ioc); break;
522		case DEVINFO_FCT_STOP: /* Nothing */ break;
523		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0220ioc); break;
524
525		/* --- the following bits of info are returned as NULL-terminated strings --- */
526		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0220IOC"); break;
527		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito I/O"); break;
528		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
529		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
530		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
531		}
532		}
533
534		DEVICE_GET_INFO( tc0510nio )
535		{
536		switch (state)
537		{
538		/* --- the following bits of info are returned as 64-bit signed integers --- */
539		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0510nio_state); break;
540
541		/* --- the following bits of info are returned as pointers to data or functions --- */
542		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0510nio); break;
543		case DEVINFO_FCT_STOP: /* Nothing */ break;
544		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0510nio); break;
545
546		/* --- the following bits of info are returned as NULL-terminated strings --- */
547		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0510NIO"); break;
548		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito I/O"); break;
549		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
550		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
551		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
552		}
553		}
554
555		DEVICE_GET_INFO( tc0640fio )
556		{
557		switch (state)
558		{
559		/* --- the following bits of info are returned as 64-bit signed integers --- */
560		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0640fio_state); break;
561
562		/* --- the following bits of info are returned as pointers to data or functions --- */
563		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0640fio); break;
564		case DEVINFO_FCT_STOP: /* Nothing */ break;
565		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0640fio); break;
566
567		/* --- the following bits of info are returned as NULL-terminated strings --- */
568		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0640FIO"); break;
569		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito I/O"); break;
570		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
571		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
572		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
573		}
574		}
575
576
577	513	const device_type TC0220IOC = &device_creator<tc0220ioc_device>;
578	514
579	515	tc0220ioc_device::tc0220ioc_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namco06.c
r17616	r17617
288	288	}
289	289
290	290
291		/*-------------------------------------------------
292		device definition
293		-------------------------------------------------*/
294
295		DEVICE_GET_INFO(namco_06xx)
296		{
297		switch (state)
298		{
299
300		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_06xx_state); break;
301
302		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_06xx); break;
303
304		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(namco_06xx); break;
305
306		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 06xx"); break;
307
308		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco06xx"); break;
309		}
310		}
311
312	291	const device_type NAMCO_06XX = &device_creator<namco_06xx_device>;
313	292
314	293	namco_06xx_device::namco_06xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namcoio.c
r17616	r17617
544	544	namcoio_set_reset_line(device, PULSE_LINE);
545	545	}
546	546
547		DEVICE_GET_INFO(namcoio)
548		{
549		switch (state)
550		{
551		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namcoio_state); break;
552
553		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namcoio); break;
554
555		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(namcoio); break;
556
557		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 56xx, 58xx & 59xx"); break;
558		}
559		}
560
561	547	const device_type NAMCO56XX = &device_creator<namcoio_device>;
562	548
563	549	namcoio_device::namcoio_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/nmk112.c
r17616	r17617
152	152	}
153	153	}
154	154
155
156		/*****************************************************************************
157		DEVICE DEFINITION
158		*****************************************************************************/
159
160		DEVICE_GET_INFO(nmk112)
161		{
162		switch (state)
163		{
164		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(nmk112_state); break;
165
166		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(nmk112); break;
167
168		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(nmk112); break;
169
170		case DEVINFO_STR_NAME: strcpy(info->s, "NMK 112"); break;
171		}
172		}
173
174	155	const device_type NMK112 = &device_creator<nmk112_device>;
175	156
176	157	nmk112_device::nmk112_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namco50.c
r17616	r17617
292	292	}
293	293
294	294
295		/*-------------------------------------------------
296		device definition
297		-------------------------------------------------*/
298
299		DEVICE_GET_INFO(namco_50xx)
300		{
301		switch (state)
302		{
303		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_50xx_state); break;
304
305		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_50xx); break;
306
307		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_50xx); break;
308
309		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_50xx); break;
310
311		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 50xx"); break;
312
313		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco50"); break;
314		}
315		}
316
317	295	const device_type NAMCO_50XX = &device_creator<namco_50xx_device>;
318	296
319	297	namco_50xx_device::namco_50xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namco51.c
r17616	r17617
440	440	}
441	441
442	442
443		/*-------------------------------------------------
444		device definition
445		-------------------------------------------------*/
446
447		DEVICE_GET_INFO(namco_51xx)
448		{
449		switch (state)
450		{
451		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_51xx_state); break;
452
453		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_51xx); break;
454
455		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_51xx); break;
456
457		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_51xx); break;
458
459		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(namco_51xx); break;
460
461		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 51xx"); break;
462
463		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco51"); break;
464
465		}
466		}
467
468	443	const device_type NAMCO_51XX = &device_creator<namco_51xx_device>;
469	444
470	445	namco_51xx_device::namco_51xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/cd32.c
r17616	r17617
913	913	}
914	914	}
915	915
916		/*-------------------------------------------------
917		device definition
918		-------------------------------------------------*/
919
920		DEVICE_GET_INFO(akiko)
921		{
922		switch (state)
923		{
924		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(akiko_state); break;
925
926		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(akiko); break;
927
928		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(akiko); break;
929
930		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(akiko); break;
931
932		case DEVINFO_STR_NAME: strcpy(info->s, "Akiko"); break;
933		}
934		}
935
936	916	const device_type AKIKO = &device_creator<akiko_device>;
937	917
938	918	akiko_device::akiko_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/gaelco3d.c
r17616	r17617
498	498	osd_sharedmem_free(state->m_os_shmem);
499	499	}
500	500
501		DEVICE_GET_INFO( gaelco_serial )
502		{
503		switch (state)
504		{
505		/* --- the following bits of info are returned as 64-bit signed integers --- */
506		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gaelco_serial_state); break;
507
508		/* --- the following bits of info are returned as pointers to data or functions --- */
509		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(gaelco_serial);break;
510		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(gaelco_serial);break;
511		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(gaelco_serial);break;
512
513		/* --- the following bits of info are returned as NULL-terminated strings --- */
514		case DEVINFO_STR_NAME: strcpy(info->s, "gaelco_serial"); break;
515		case DEVINFO_STR_FAMILY: strcpy(info->s, "SERIAL"); break;
516		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
517		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
518		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
519		}
520		}
521
522
523	501	const device_type GAELCO_SERIAL = &device_creator<gaelco_serial_device>;
524	502
525	503	gaelco_serial_device::gaelco_serial_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/gaelco3d.h
r17616	r17617
88	88	};
89	89
90	90	extern const device_type GAELCO_SERIAL;
91
92
93		//DEVICE_GET_INFO( gaelco_serial );

trunk/src/mame/machine/decocass.c
r17616	r17617
2280	2280	}
2281	2281
2282	2282
2283		/*-------------------------------------------------
2284		device get info callback
2285		-------------------------------------------------*/
2286
2287		DEVICE_GET_INFO( decocass_tape )
2288		{
2289		switch (state)
2290		{
2291		/* --- the following bits of info are returned as 64-bit signed integers --- */
2292		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tape_state); break;
2293
2294		/* --- the following bits of info are returned as pointers to data or functions --- */
2295		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(decocass_tape); break;
2296		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(decocass_tape);break;
2297
2298		/* --- the following bits of info are returned as NULL-terminated strings --- */
2299		case DEVINFO_STR_NAME: strcpy(info->s, "DECO Cassette Tape"); break;
2300		case DEVINFO_STR_FAMILY: strcpy(info->s, "Tape Controller"); break;
2301		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
2302		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2303		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
2304		}
2305		}
2306
2307
2308	2283	const device_type DECOCASS_TAPE = &device_creator<decocass_tape_device>;
2309	2284
2310	2285	decocass_tape_device::decocass_tape_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/buggychl.c
r17616	r17617
235	235	state->m_ddr_c = 0;
236	236	}
237	237
238		/*****************************************************************************
239		DEVICE DEFINITION
240		*****************************************************************************/
241
242		DEVICE_GET_INFO(buggychl_mcu)
243		{
244		switch (state)
245		{
246		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(buggychl_mcu_state); break;
247
248		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(buggychl_mcu); break;
249
250		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(buggychl_mcu); break;
251
252		case DEVINFO_STR_NAME: strcpy(info->s, "BuggyChl MCU"); break;
253
254		}
255		}
256
257	238	const device_type BUGGYCHL_MCU = &device_creator<buggychl_mcu_device>;
258	239
259	240	buggychl_mcu_device::buggychl_mcu_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namco53.c
r17616	r17617
192	192	}
193	193
194	194
195		/*-------------------------------------------------
196		device definition
197		-------------------------------------------------*/
198
199		DEVICE_GET_INFO(namco_53xx)
200		{
201		switch (state)
202		{
203		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_53xx_state); break;
204
205		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_53xx); break;
206
207		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_53xx); break;
208
209		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_53xx); break;
210
211		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 53xx"); break;
212
213		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco53"); break;
214		}
215		}
216
217	195	const device_type NAMCO_53XX = &device_creator<namco_53xx_device>;
218	196
219	197	namco_53xx_device::namco_53xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/namco62.c
r17616	r17617
85	85	}
86	86
87	87
88		/*-------------------------------------------------
89		device definition
90		-------------------------------------------------*/
91
92		DEVICE_GET_INFO(namco_62xx)
93		{
94		switch (state)
95		{
96		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_62xx_state); break;
97
98		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(namco_62xx); break;
99
100		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(namco_62xx); break;
101
102		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(namco_62xx); break;
103
104		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 62xx"); break;
105
106		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "namco62"); break;
107		}
108		}
109
110	88	const device_type NAMCO_62XX = &device_creator<namco_62xx_device>;
111	89
112	90	namco_62xx_device::namco_62xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/machine/mathbox.c
r17616	r17617
338	338	}
339	339
340	340
341		DEVICE_GET_INFO( mathbox )
342		{
343		switch (state)
344		{
345		/* --- the following bits of info are returned as 64-bit signed integers --- */
346		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mathbox_state); break;
347
348		/* --- the following bits of info are returned as pointers to data or functions --- */
349		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mathbox);break;
350		case DEVINFO_FCT_STOP: /* Nothing */ break;
351		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mathbox);break;
352
353		/* --- the following bits of info are returned as NULL-terminated strings --- */
354		case DEVINFO_STR_NAME: strcpy(info->s, "MATHBOX"); break;
355		case DEVINFO_STR_FAMILY: strcpy(info->s, "I/O devices"); break;
356		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
357		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
358		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
359		}
360		}
361
362
363	341	const device_type MATHBOX = &device_creator<mathbox_device>;
364	342
365	343	mathbox_device::mathbox_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/includes/tx1.h
r17616	r17617
178	178	WRITE8_DEVICE_HANDLER( bb_ym2_a_w );
179	179	WRITE8_DEVICE_HANDLER( bb_ym2_b_w );
180	180
181		class buggyboy_sound_device : public device_t,
182		public device_sound_interface
	181
	182	WRITE8_DEVICE_HANDLER( tx1_ay8910_a_w );
	183	WRITE8_DEVICE_HANDLER( tx1_ay8910_b_w );
	184
	185	class tx1_sound_device : public device_t,
	186	public device_sound_interface
183	187	{
184	188	public:
185		buggyboy_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
186		~buggyboy_sound_device() { global_free(m_token); }
	189	tx1_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	190	tx1_sound_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock);
	191	~tx1_sound_device() { global_free(m_token); }
187	192
188	193	// access to legacy token
189	194	void *token() const { assert(m_token != NULL); return m_token; }
r17616	r17617
200	205	void *m_token;
201	206	};
202	207
203		extern const device_type ~~BUGGYBOY~~;
	208	extern const device_type TX1;
204	209
205
206		WRITE8_DEVICE_HANDLER( tx1_ay8910_a_w );
207		WRITE8_DEVICE_HANDLER( tx1_ay8910_b_w );
208
209		class tx1_sound_device : public device_t,
210		public device_sound_interface
	210	class buggyboy_sound_device : public tx1_sound_device
211	211	{
212	212	public:
213		tx1_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
214		~tx1_sound_device() { global_free(m_token); }
215
216		// access to legacy token
217		void *token() const { assert(m_token != NULL); return m_token; }
	213	buggyboy_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
218	214	protected:
219	215	// device-level overrides
220	216	virtual void device_config_complete();
r17616	r17617
225	221	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
226	222	private:
227	223	// internal state
228		void *m_token;
229	224	};
230	225
231		extern const device_type ~~TX1~~;
	226	extern const device_type BUGGYBOY;
232	227
233	228
234
235	229	/----------- defined in video/tx1.c -----------/
236	230
237	231	PALETTE_INIT( tx1 );

trunk/src/mame/video/taitoic.c
r17616	r17617
5122	5122	tc0180vcu->video_control = 0;
5123	5123	}
5124	5124
5125
5126		/***************************************************************************/
5127		/* */
5128		/* DEVICE_GET_INFOs */
5129		/* */
5130		/***************************************************************************/
5131
5132		DEVICE_GET_INFO( pc080sn )
5133		{
5134		switch (state)
5135		{
5136		/* --- the following bits of info are returned as 64-bit signed integers --- */
5137		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pc080sn_state); break;
5138
5139		/* --- the following bits of info are returned as pointers to data or functions --- */
5140		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pc080sn); break;
5141		case DEVINFO_FCT_STOP: /* Nothing */ break;
5142		case DEVINFO_FCT_RESET: /* Nothing */ break;
5143
5144		/* --- the following bits of info are returned as NULL-terminated strings --- */
5145		case DEVINFO_STR_NAME: strcpy(info->s, "Taito PC080SN"); break;
5146		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5147		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5148		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5149		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5150		}
5151		}
5152
5153		DEVICE_GET_INFO( pc090oj )
5154		{
5155		switch (state)
5156		{
5157		/* --- the following bits of info are returned as 64-bit signed integers --- */
5158		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pc090oj_state); break;
5159
5160		/* --- the following bits of info are returned as pointers to data or functions --- */
5161		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pc090oj); break;
5162		case DEVINFO_FCT_STOP: /* Nothing */ break;
5163		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pc090oj); break;
5164
5165		/* --- the following bits of info are returned as NULL-terminated strings --- */
5166		case DEVINFO_STR_NAME: strcpy(info->s, "Taito PC090OJ"); break;
5167		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5168		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5169		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5170		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5171		}
5172		}
5173
5174		DEVICE_GET_INFO( tc0080vco )
5175		{
5176		switch (state)
5177		{
5178		/* --- the following bits of info are returned as 64-bit signed integers --- */
5179		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0080vco_state); break;
5180
5181		/* --- the following bits of info are returned as pointers to data or functions --- */
5182		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0080vco); break;
5183		case DEVINFO_FCT_STOP: /* Nothing */ break;
5184		case DEVINFO_FCT_RESET: /* Nothing */ break;
5185
5186		/* --- the following bits of info are returned as NULL-terminated strings --- */
5187		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0080VCO"); break;
5188		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5189		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5190		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5191		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5192		}
5193		}
5194
5195		DEVICE_GET_INFO( tc0110pcr )
5196		{
5197		switch (state)
5198		{
5199		/* --- the following bits of info are returned as 64-bit signed integers --- */
5200		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0110pcr_state); break;
5201
5202		/* --- the following bits of info are returned as pointers to data or functions --- */
5203		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0110pcr); break;
5204		case DEVINFO_FCT_STOP: /* Nothing */ break;
5205		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0110pcr); break;
5206
5207		/* --- the following bits of info are returned as NULL-terminated strings --- */
5208		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0110PCR"); break;
5209		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5210		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5211		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5212		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5213		}
5214		}
5215
5216		DEVICE_GET_INFO( tc0100scn )
5217		{
5218		switch (state)
5219		{
5220		/* --- the following bits of info are returned as 64-bit signed integers --- */
5221		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0100scn_state); break;
5222
5223		/* --- the following bits of info are returned as pointers to data or functions --- */
5224		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0100scn); break;
5225		case DEVINFO_FCT_STOP: /* Nothing */ break;
5226		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0100scn); break;
5227
5228		/* --- the following bits of info are returned as NULL-terminated strings --- */
5229		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0100SCN"); break;
5230		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5231		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5232		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5233		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5234		}
5235		}
5236
5237		DEVICE_GET_INFO( tc0280grd )
5238		{
5239		switch (state)
5240		{
5241		/* --- the following bits of info are returned as 64-bit signed integers --- */
5242		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0280grd_state); break;
5243
5244		/* --- the following bits of info are returned as pointers to data or functions --- */
5245		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0280grd); break;
5246		case DEVINFO_FCT_STOP: /* Nothing */ break;
5247		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0280grd); break;
5248
5249		/* --- the following bits of info are returned as NULL-terminated strings --- */
5250		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0280GRD & TC0430GRW"); break;
5251		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5252		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5253		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5254		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5255		}
5256		}
5257
5258		DEVICE_GET_INFO( tc0360pri )
5259		{
5260		switch (state)
5261		{
5262		/* --- the following bits of info are returned as 64-bit signed integers --- */
5263		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0360pri_state); break;
5264
5265		/* --- the following bits of info are returned as pointers to data or functions --- */
5266		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0360pri); break;
5267		case DEVINFO_FCT_STOP: /* Nothing */ break;
5268		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0360pri); break;
5269
5270		/* --- the following bits of info are returned as NULL-terminated strings --- */
5271		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0360PRI"); break;
5272		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5273		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5274		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5275		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5276		}
5277		}
5278
5279		DEVICE_GET_INFO( tc0480scp )
5280		{
5281		switch (state)
5282		{
5283		/* --- the following bits of info are returned as 64-bit signed integers --- */
5284		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0480scp_state); break;
5285
5286		/* --- the following bits of info are returned as pointers to data or functions --- */
5287		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0480scp); break;
5288		case DEVINFO_FCT_STOP: /* Nothing */ break;
5289		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0480scp); break;
5290
5291		/* --- the following bits of info are returned as NULL-terminated strings --- */
5292		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0480SCP"); break;
5293		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5294		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5295		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5296		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5297		}
5298		}
5299
5300		DEVICE_GET_INFO( tc0150rod )
5301		{
5302		switch (state)
5303		{
5304		/* --- the following bits of info are returned as 64-bit signed integers --- */
5305		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0150rod_state); break;
5306
5307		/* --- the following bits of info are returned as pointers to data or functions --- */
5308		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0150rod); break;
5309		case DEVINFO_FCT_STOP: /* Nothing */ break;
5310		case DEVINFO_FCT_RESET: /* Nothing */ break;
5311
5312		/* --- the following bits of info are returned as NULL-terminated strings --- */
5313		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0150ROD"); break;
5314		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5315		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5316		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5317		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5318		}
5319		}
5320
5321		DEVICE_GET_INFO( tc0180vcu )
5322		{
5323		switch (state)
5324		{
5325		/* --- the following bits of info are returned as 64-bit signed integers --- */
5326		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tc0180vcu_state); break;
5327
5328		/* --- the following bits of info are returned as pointers to data or functions --- */
5329		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tc0180vcu); break;
5330		case DEVINFO_FCT_STOP: /* Nothing */ break;
5331		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tc0180vcu); break;
5332
5333		/* --- the following bits of info are returned as NULL-terminated strings --- */
5334		case DEVINFO_STR_NAME: strcpy(info->s, "Taito TC0180VCU"); break;
5335		case DEVINFO_STR_FAMILY: strcpy(info->s, "Taito Video IC"); break;
5336		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
5337		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
5338		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
5339		}
5340		}
5341
5342
5343	5125	const device_type PC080SN = &device_creator<pc080sn_device>;
5344	5126
5345	5127	pc080sn_device::pc080sn_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/atarirle.c
r17616	r17617
371	371	}
372	372
373	373
374		DEVICE_GET_INFO( atarirle )
375		{
376		switch (state)
377		{
378		/* --- the following bits of info are returned as 64-bit signed integers --- */
379		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(atarirle_data); break;
380
381		/* --- the following bits of info are returned as pointers to data or functions --- */
382		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(atarirle); break;
383
384		/* --- the following bits of info are returned as NULL-terminated strings --- */
385		case DEVINFO_STR_NAME: strcpy(info->s, "Atari RLE"); break;
386		case DEVINFO_STR_FAMILY: strcpy(info->s, "Atari RLE Video IC"); break;
387		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
388		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
389		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
390		}
391		}
392
393	374	const device_type ATARIRLE = &device_creator<atarirle_device>;
394	375
395	376	atarirle_device::atarirle_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/deco16ic.c
r17616	r17617
988	988	}
989	989
990	990
991		DEVICE_GET_INFO( deco16ic )
992		{
993		switch (state)
994		{
995		/* --- the following bits of info are returned as 64-bit signed integers --- */
996		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(deco16ic_state); break;
997
998		/* --- the following bits of info are returned as pointers to data or functions --- */
999		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(deco16ic); break;
1000		case DEVINFO_FCT_STOP: /* Nothing */ break;
1001		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(deco16ic); break;
1002
1003		/* --- the following bits of info are returned as NULL-terminated strings --- */
1004		case DEVINFO_STR_NAME: strcpy(info->s, "Data East IC 55 / 56 / 74 / 141"); break;
1005		case DEVINFO_STR_FAMILY: strcpy(info->s, "Data East Video IC"); break;
1006		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1007		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1008		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
1009		}
1010		}
1011
1012
1013	991	const device_type DECO16IC = &device_creator<deco16ic_device>;
1014	992
1015	993	deco16ic_device::deco16ic_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/decocomn.c
r17616	r17617
140	140	}
141	141
142	142
143		DEVICE_GET_INFO( decocomn )
144		{
145		switch (state)
146		{
147		/* --- the following bits of info are returned as 64-bit signed integers --- */
148		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(decocomn_state); break;
149
150		/* --- the following bits of info are returned as pointers to data or functions --- */
151		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(decocomn); break;
152		case DEVINFO_FCT_STOP: /* Nothing */ break;
153		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(decocomn); break;
154
155		/* --- the following bits of info are returned as NULL-terminated strings --- */
156		case DEVINFO_STR_NAME: strcpy(info->s, "Data East Common Video Functions"); break;
157		case DEVINFO_STR_FAMILY: strcpy(info->s, "Data East Video IC"); break;
158		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
159		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
160		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
161		}
162		}
163
164
165	143	const device_type DECOCOMN = &device_creator<decocomn_device>;
166	144
167	145	decocomn_device::decocomn_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/vrender0.c
r17616	r17617
601	601	vr0->LastPalUpdate = 0xffffffff;
602	602	}
603	603
604		DEVICE_GET_INFO(vr0video)
605		{
606		switch (state)
607		{
608		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vr0video_state); break;
609
610		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vr0video); break;
611
612		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(vr0video); break;
613
614		case DEVINFO_STR_NAME: strcpy(info->s, "VRender0"); break;
615		}
616		}
617	604	const device_type VIDEO_VRENDER0 = &device_creator<vr0video_device>;
618	605
619	606	vr0video_device::vr0video_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/kan_pand.c
r17616	r17617
325	325	pandora->clear_bitmap = 1;
326	326	}
327	327
328		DEVICE_GET_INFO(kaneko_pandora)
329		{
330		switch (state)
331		{
332		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(kaneko_pandora_state); break;
333
334		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(kaneko_pandora); break;
335
336		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(kaneko_pandora); break;
337
338		case DEVINFO_STR_NAME: strcpy(info->s, "Kaneko Pandora - PX79C480FP-3"); break;
339		}
340		}
341
342	328	const device_type KANEKO_PANDORA = &device_creator<kaneko_pandora_device>;
343	329
344	330	kaneko_pandora_device::kaneko_pandora_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/video/konicdev.c
r17616	r17617
10274	10274	return(k053244->regs[offset * 2] << 8 \| k053244->regs[offset * 2 + 1]);
10275	10275	}
10276	10276
10277
10278
10279		/***************************************************************************/
10280		/* */
10281		/* DEVICE_GET_INFOs */
10282		/* */
10283		/***************************************************************************/
10284
10285
10286		DEVICE_GET_INFO( k007121 )
10287		{
10288		switch (state)
10289		{
10290		/* --- the following bits of info are returned as 64-bit signed integers --- */
10291		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k007121_state); break;
10292
10293		/* --- the following bits of info are returned as pointers to data or functions --- */
10294		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k007121); break;
10295		case DEVINFO_FCT_STOP: /* Nothing */ break;
10296		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k007121); break;
10297
10298		/* --- the following bits of info are returned as NULL-terminated strings --- */
10299		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 007121"); break;
10300		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10301		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10302		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10303		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10304		}
10305		}
10306
10307
10308		DEVICE_GET_INFO( k007342 )
10309		{
10310		switch (state)
10311		{
10312		/* --- the following bits of info are returned as 64-bit signed integers --- */
10313		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k007342_state); break;
10314
10315		/* --- the following bits of info are returned as pointers to data or functions --- */
10316		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k007342); break;
10317		case DEVINFO_FCT_STOP: /* Nothing */ break;
10318		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k007342); break;
10319
10320		/* --- the following bits of info are returned as NULL-terminated strings --- */
10321		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 007342"); break;
10322		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10323		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10324		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10325		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10326		}
10327		}
10328
10329
10330		DEVICE_GET_INFO( k007420 )
10331		{
10332		switch (state)
10333		{
10334		/* --- the following bits of info are returned as 64-bit signed integers --- */
10335		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k007420_state); break;
10336
10337		/* --- the following bits of info are returned as pointers to data or functions --- */
10338		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k007420); break;
10339		case DEVINFO_FCT_STOP: /* Nothing */ break;
10340		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k007420); break;
10341
10342		/* --- the following bits of info are returned as NULL-terminated strings --- */
10343		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 007420"); break;
10344		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10345		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10346		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10347		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10348		}
10349		}
10350
10351
10352		DEVICE_GET_INFO( k052109 )
10353		{
10354		switch (state)
10355		{
10356		/* --- the following bits of info are returned as 64-bit signed integers --- */
10357		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k052109_state); break;
10358
10359		/* --- the following bits of info are returned as pointers to data or functions --- */
10360		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k052109); break;
10361		case DEVINFO_FCT_STOP: /* Nothing */ break;
10362		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k052109); break;
10363
10364		/* --- the following bits of info are returned as NULL-terminated strings --- */
10365		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 052109"); break;
10366		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10367		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10368		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10369		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10370		}
10371		}
10372
10373		DEVICE_GET_INFO( k051960 )
10374		{
10375		switch (state)
10376		{
10377		/* --- the following bits of info are returned as 64-bit signed integers --- */
10378		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k051960_state); break;
10379
10380		/* --- the following bits of info are returned as pointers to data or functions --- */
10381		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k051960); break;
10382		case DEVINFO_FCT_STOP: /* Nothing */ break;
10383		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k051960); break;
10384
10385		/* --- the following bits of info are returned as NULL-terminated strings --- */
10386		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 051960"); break;
10387		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10388		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10389		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10390		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10391		}
10392		}
10393
10394		DEVICE_GET_INFO( k05324x )
10395		{
10396		switch (state)
10397		{
10398		/* --- the following bits of info are returned as 64-bit signed integers --- */
10399		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k05324x_state); break;
10400
10401		/* --- the following bits of info are returned as pointers to data or functions --- */
10402		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k05324x); break;
10403		case DEVINFO_FCT_STOP: /* Nothing */ break;
10404		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k05324x); break;
10405
10406		/* --- the following bits of info are returned as NULL-terminated strings --- */
10407		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 053244 & 053245"); break;
10408		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10409		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10410		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10411		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10412		}
10413		}
10414
10415		DEVICE_GET_INFO( k053247 )
10416		{
10417		switch (state)
10418		{
10419		/* --- the following bits of info are returned as 64-bit signed integers --- */
10420		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053247_state); break;
10421
10422		/* --- the following bits of info are returned as pointers to data or functions --- */
10423		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k053247); break;
10424		case DEVINFO_FCT_STOP: /* Nothing */ break;
10425		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k053247); break;
10426
10427		/* --- the following bits of info are returned as NULL-terminated strings --- */
10428		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 053246 & 053247"); break;
10429		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10430		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10431		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10432		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10433		}
10434		}
10435
10436		DEVICE_GET_INFO( k055673 )
10437		{
10438		switch (state)
10439		{
10440		/* --- the following bits of info are returned as 64-bit signed integers --- */
10441		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053247_state); break;
10442
10443		/* --- the following bits of info are returned as pointers to data or functions --- */
10444		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k055673); break;
10445		case DEVINFO_FCT_STOP: /* Nothing */ break;
10446		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k053247); break;
10447
10448		/* --- the following bits of info are returned as NULL-terminated strings --- */
10449		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 055673"); break;
10450		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10451		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10452		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10453		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10454		}
10455		}
10456
10457		DEVICE_GET_INFO( k051316 )
10458		{
10459		switch (state)
10460		{
10461		/* --- the following bits of info are returned as 64-bit signed integers --- */
10462		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k051316_state); break;
10463
10464		/* --- the following bits of info are returned as pointers to data or functions --- */
10465		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k051316); break;
10466		case DEVINFO_FCT_STOP: /* Nothing */ break;
10467		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k051316); break;
10468
10469		/* --- the following bits of info are returned as NULL-terminated strings --- */
10470		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 051316"); break;
10471		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10472		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10473		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10474		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10475		}
10476		}
10477
10478		DEVICE_GET_INFO( k053936 )
10479		{
10480		switch (state)
10481		{
10482		/* --- the following bits of info are returned as 64-bit signed integers --- */
10483		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053936_state); break;
10484
10485		/* --- the following bits of info are returned as pointers to data or functions --- */
10486		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k053936); break;
10487		case DEVINFO_FCT_STOP: /* Nothing */ break;
10488		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k053936); break;
10489
10490		/* --- the following bits of info are returned as NULL-terminated strings --- */
10491		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 053936"); break;
10492		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10493		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10494		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10495		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10496		}
10497		}
10498
10499		DEVICE_GET_INFO( k053251 )
10500		{
10501		switch (state)
10502		{
10503		/* --- the following bits of info are returned as 64-bit signed integers --- */
10504		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053251_state); break;
10505
10506		/* --- the following bits of info are returned as pointers to data or functions --- */
10507		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k053251); break;
10508		case DEVINFO_FCT_STOP: /* Nothing */ break;
10509		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k053251); break;
10510
10511		/* --- the following bits of info are returned as NULL-terminated strings --- */
10512		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 053251"); break;
10513		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10514		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10515		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10516		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10517		}
10518		}
10519
10520		DEVICE_GET_INFO( k054000 )
10521		{
10522		switch (state)
10523		{
10524		/* --- the following bits of info are returned as 64-bit signed integers --- */
10525		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k054000_state); break;
10526
10527		/* --- the following bits of info are returned as pointers to data or functions --- */
10528		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k054000); break;
10529		case DEVINFO_FCT_STOP: /* Nothing */ break;
10530		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k054000); break;
10531
10532		/* --- the following bits of info are returned as NULL-terminated strings --- */
10533		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 054000"); break;
10534		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10535		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10536		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10537		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10538		}
10539		}
10540
10541		DEVICE_GET_INFO( k051733 )
10542		{
10543		switch (state)
10544		{
10545		/* --- the following bits of info are returned as 64-bit signed integers --- */
10546		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k051733_state); break;
10547
10548		/* --- the following bits of info are returned as pointers to data or functions --- */
10549		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k051733); break;
10550		case DEVINFO_FCT_STOP: /* Nothing */ break;
10551		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k051733); break;
10552
10553		/* --- the following bits of info are returned as NULL-terminated strings --- */
10554		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 051733"); break;
10555		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10556		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10557		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10558		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10559		}
10560		}
10561
10562		DEVICE_GET_INFO( k056832 )
10563		{
10564		switch (state)
10565		{
10566		/* --- the following bits of info are returned as 64-bit signed integers --- */
10567		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k056832_state); break;
10568
10569		/* --- the following bits of info are returned as pointers to data or functions --- */
10570		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k056832); break;
10571		case DEVINFO_FCT_STOP: /* Nothing */ break;
10572		case DEVINFO_FCT_RESET: /* Nothing */ break;
10573
10574		/* --- the following bits of info are returned as NULL-terminated strings --- */
10575		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 056832"); break;
10576		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10577		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10578		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10579		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10580		}
10581		}
10582
10583		DEVICE_GET_INFO( k055555 )
10584		{
10585		switch (state)
10586		{
10587		/* --- the following bits of info are returned as 64-bit signed integers --- */
10588		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k055555_state); break;
10589
10590		/* --- the following bits of info are returned as pointers to data or functions --- */
10591		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k055555); break;
10592		case DEVINFO_FCT_STOP: /* Nothing */ break;
10593		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k055555); break;
10594
10595		/* --- the following bits of info are returned as NULL-terminated strings --- */
10596		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 055555"); break;
10597		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10598		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10599		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10600		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10601		}
10602		}
10603
10604		DEVICE_GET_INFO( k054338 )
10605		{
10606		switch (state)
10607		{
10608		/* --- the following bits of info are returned as 64-bit signed integers --- */
10609		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k054338_state); break;
10610
10611		/* --- the following bits of info are returned as pointers to data or functions --- */
10612		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k054338); break;
10613		case DEVINFO_FCT_STOP: /* Nothing */ break;
10614		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k054338); break;
10615
10616		/* --- the following bits of info are returned as NULL-terminated strings --- */
10617		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 054338"); break;
10618		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10619		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10620		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10621		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10622		}
10623		}
10624
10625		DEVICE_GET_INFO( k001006 )
10626		{
10627		switch (state)
10628		{
10629		/* --- the following bits of info are returned as 64-bit signed integers --- */
10630		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k001006_state); break;
10631
10632		/* --- the following bits of info are returned as pointers to data or functions --- */
10633		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k001006); break;
10634		case DEVINFO_FCT_STOP: /* Nothing */ break;
10635		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k001006); break;
10636
10637		/* --- the following bits of info are returned as NULL-terminated strings --- */
10638		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 001006"); break;
10639		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10640		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10641		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10642		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10643		}
10644		}
10645
10646
10647		DEVICE_GET_INFO( k001005 )
10648		{
10649		switch (state)
10650		{
10651		/* --- the following bits of info are returned as 64-bit signed integers --- */
10652		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k001005_state); break;
10653
10654		/* --- the following bits of info are returned as pointers to data or functions --- */
10655		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k001005); break;
10656		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(k001005); break;
10657		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k001005); break;
10658
10659		/* --- the following bits of info are returned as NULL-terminated strings --- */
10660		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 001005"); break;
10661		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10662		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10663		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10664		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10665		}
10666		}
10667
10668
10669		DEVICE_GET_INFO( k001604 )
10670		{
10671		switch (state)
10672		{
10673		/* --- the following bits of info are returned as 64-bit signed integers --- */
10674		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k001604_state); break;
10675
10676		/* --- the following bits of info are returned as pointers to data or functions --- */
10677		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k001604); break;
10678		case DEVINFO_FCT_STOP: /* Nothing */ break;
10679		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k001604); break;
10680
10681		/* --- the following bits of info are returned as NULL-terminated strings --- */
10682		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 001604"); break;
10683		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10684		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10685		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10686		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10687		}
10688		}
10689
10690
10691		DEVICE_GET_INFO( k037122 )
10692		{
10693		switch (state)
10694		{
10695		/* --- the following bits of info are returned as 64-bit signed integers --- */
10696		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k037122_state); break;
10697
10698		/* --- the following bits of info are returned as pointers to data or functions --- */
10699		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k037122); break;
10700		case DEVINFO_FCT_STOP: /* Nothing */ break;
10701		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k037122); break;
10702
10703		/* --- the following bits of info are returned as NULL-terminated strings --- */
10704		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 0371222"); break;
10705		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
10706		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
10707		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
10708		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
10709		}
10710		}
10711
10712
10713	10277	const device_type K007121 = &device_creator<k007121_device>;
10714	10278
10715	10279	k007121_device::k007121_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/drivers/mjkjidai.c
r17616	r17617
101	101	state->m_adpcm.reset();
102	102	}
103	103
104		DEVICE_GET_INFO( mjkjidai_adpcm )
105		{
106		switch (state)
107		{
108		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mjkjidai_adpcm_state); break;
109
110		/* --- the following bits of info are returned as pointers to data or functions --- */
111		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mjkjidai_adpcm);break;
112
113		/* --- the following bits of info are returned as NULL-terminated strings --- */
114		case DEVINFO_STR_NAME: strcpy(info->s, "Custom ADPCM"); break;
115		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
116		}
117		}
118
119	104	const device_type MJKJIDAI = &device_creator<mjkjidai_adpcm_device>;
120	105
121	106	mjkjidai_adpcm_device::mjkjidai_adpcm_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/drivers/renegade.c
r17616	r17617
191	191	state->m_adpcm.reset();
192	192	}
193	193
194		DEVICE_GET_INFO( renegade_adpcm )
195		{
196		switch (state)
197		{
198		/* --- the following bits of info are returned as 64-bit signed integers --- */
199		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(renegade_adpcm_state); break;
200
201		/* --- the following bits of info are returned as pointers to data or functions --- */
202		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(renegade_adpcm);break;
203
204		/* --- the following bits of info are returned as NULL-terminated strings --- */
205		case DEVINFO_STR_NAME: strcpy(info->s, "Renegade Custom ADPCM"); break;
206		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
207		}
208		}
209
210	194	const device_type RENEGADE_ADPCM = &device_creator<renegade_adpcm_device>;
211	195
212	196	renegade_adpcm_device::renegade_adpcm_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mame/drivers/warriorb.c
r17616	r17617
435	435	irqhandler
436	436	};
437	437
438
439		/**************************************************************
440		SUBWOOFEr(SOUND)
441		**************************************************************/
442
443		#if 0
444		static DEVICE_START( subwoofer )
445		{
446		/* Adjust the lowpass filter of the first three YM2610 channels */
447
448		mixer_set_lowpass_frequency(0, 20);
449		mixer_set_lowpass_frequency(1, 20);
450		mixer_set_lowpass_frequency(2, 20);
451		}
452
453		static DEVICE_GET_INFO( subwoofer )
454		{
455		switch (state)
456		{
457		/* --- the following bits of info are returned as pointers to data or functions --- */
458		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(subwoofer); break;
459
460		/* --- the following bits of info are returned as NULL-terminated strings --- */
461		case DEVINFO_STR_NAME: strcpy(info->s, "Subwoofer"); break;
462		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
463		}
464		}
465		#endif
466
467
468	438	/***********************************************************
469	439	MACHINE DRIVERS
470	440	***********************************************************/

trunk/src/mame/drivers/ninjaw.c
r17616	r17617
673	673	return 0;
674	674	}
675	675
676		static DEVICE_GET_INFO( subwoofer )
677		{
678		switch (state)
679		{
680		/* --- the following bits of info are returned as pointers to data or functions --- */
681		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(subwoofer); break;
682
683		/* --- the following bits of info are returned as NULL-terminated strings --- */
684		case DEVINFO_STR_NAME: strcpy(info->s, "Subwoofer"); break;
685		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
686		}
687		}
688
689	676	class subwoofer_device : public device_t,
690	677	public device_sound_interface
691	678	{

trunk/src/emu/devlegcy.c
r17616	r17617
1		/***************************************************************************
2
3		devlegcy.c
4
5		Legacy device helpers.
6
7		****************************************************************************
8
9		Copyright Aaron Giles
10		All rights reserved.
11
12		Redistribution and use in source and binary forms, with or without
13		modification, are permitted provided that the following conditions are
14		met:
15
16		* Redistributions of source code must retain the above copyright
17		notice, this list of conditions and the following disclaimer.
18		* Redistributions in binary form must reproduce the above copyright
19		notice, this list of conditions and the following disclaimer in
20		the documentation and/or other materials provided with the
21		distribution.
22		* Neither the name 'MAME' nor the names of its contributors may be
23		used to endorse or promote products derived from this software
24		without specific prior written permission.
25
26		THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
27		IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28		WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29		DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
30		INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
31		(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
32		SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33		HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
34		STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
35		IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36		POSSIBILITY OF SUCH DAMAGE.
37
38		***************************************************************************/
39
40		#include "emu.h"
41		#include "devlegcy.h"
42
43
44		//**************************************************************************
45		// LEGACY DEVICE CONFIGURATION
46		//**************************************************************************
47
48		//-------------------------------------------------
49		// legacy_device_base - constructor
50		//-------------------------------------------------
51
52		legacy_device_base::legacy_device_base(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock, device_get_config_func get_config)
53		: device_t(mconfig, type, "Legacy Device", tag, owner, clock),
54		m_get_config_func(get_config),
55		m_token(NULL)
56		{
57		// set the proper name
58		m_name = get_legacy_string(DEVINFO_STR_NAME);
59		m_shortname = get_legacy_string(DEVINFO_STR_SHORTNAME);
60		m_searchpath = m_shortname;
61
62		// create the token
63		int tokenbytes = get_legacy_int(DEVINFO_INT_TOKEN_BYTES);
64		if (tokenbytes != 0)
65		m_token = global_alloc_array_clear(UINT8, tokenbytes);
66		}
67
68
69		//-------------------------------------------------
70		// ~legacy_device_base - destructor
71		//-------------------------------------------------
72
73		legacy_device_base::~legacy_device_base()
74		{
75		global_free(m_token);
76		}
77
78
79		//-------------------------------------------------
80		// get_legacy_int - return a legacy
81		// configuration parameter as an integer
82		//-------------------------------------------------
83
84		INT64 legacy_device_base::get_legacy_int(UINT32 state) const
85		{
86		deviceinfo info = { 0 };
87		(*m_get_config_func)(this, state, &info);
88		return info.i;
89		}
90
91
92		//-------------------------------------------------
93		// get_legacy_ptr - return a legacy
94		// configuration parameter as a pointer
95		//-------------------------------------------------
96
97		void *legacy_device_base::get_legacy_ptr(UINT32 state) const
98		{
99		deviceinfo info = { 0 };
100		(*m_get_config_func)(this, state, &info);
101		return info.p;
102		}
103
104
105		//-------------------------------------------------
106		// get_legacy_fct - return a legacy
107		// configuration parameter as a function pointer
108		//-------------------------------------------------
109
110		genf *legacy_device_base::get_legacy_fct(UINT32 state) const
111		{
112		deviceinfo info = { 0 };
113		(*m_get_config_func)(this, state, &info);
114		return info.f;
115		}
116
117
118		//-------------------------------------------------
119		// get_legacy_string - return a legacy
120		// configuration parameter as a string pointer
121		//-------------------------------------------------
122
123		const char *legacy_device_base::get_legacy_string(UINT32 state) const
124		{
125		deviceinfo info;
126		info.s = get_temp_string_buffer();
127		(*m_get_config_func)(this, state, &info);
128		return info.s;
129		}
130
131
132		//-------------------------------------------------
133		// device_start - called to start up a device
134		//-------------------------------------------------
135
136		void legacy_device_base::device_start()
137		{
138		device_start_func start_func = reinterpret_cast<device_start_func>(get_legacy_fct(DEVINFO_FCT_START));
139		assert(start_func != NULL);
140		(*start_func)(this);
141		}
142
143
144		//-------------------------------------------------
145		// device_reset - called to reset a device
146		//-------------------------------------------------
147
148		void legacy_device_base::device_reset()
149		{
150		device_reset_func reset_func = reinterpret_cast<device_reset_func>(get_legacy_fct(DEVINFO_FCT_RESET));
151		if (reset_func != NULL)
152		(*reset_func)(this);
153		}
154
155
156		//-------------------------------------------------
157		// device_stop - called to stop a device
158		//-------------------------------------------------
159
160		void legacy_device_base::device_stop()
161		{
162		if (started())
163		{
164		device_stop_func stop_func = reinterpret_cast<device_stop_func>(get_legacy_fct(DEVINFO_FCT_STOP));
165		if (stop_func != NULL)
166		(*stop_func)(this);
167		}
168		}
169
170
171		//**************************************************************************
172		// LEGACY SOUND DEVICE
173		//**************************************************************************
174
175		//-------------------------------------------------
176		// legacy_sound_device_base - constructor
177		//-------------------------------------------------
178
179		legacy_sound_device_base::legacy_sound_device_base(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock, device_get_config_func get_config)
180		: legacy_device_base(mconfig, type, tag, owner, clock, get_config),
181		device_sound_interface(mconfig, *this)
182		{
183		}
184
185
186		//-------------------------------------------------
187		// sound_stream_update - handle a stream update
188		//-------------------------------------------------
189
190		void legacy_sound_device_base::sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples)
191		{
192		// should never get here
193		fatalerror("legacy_sound_device_base::sound_stream_update called; not applicable to legacy sound devices\n");
194		}

trunk/src/emu/video/hd63484.c
r17616	r17617
1577	1577	hd63484->fifo_counter = 0;
1578	1578	}
1579	1579
1580		DEVICE_GET_INFO(hd63484)
1581		{
1582		switch (state)
1583		{
1584		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(hd63484_state); break;
1585
1586		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(hd63484); break;
1587
1588		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(hd63484); break;
1589
1590		case DEVINFO_STR_NAME: strcpy(info->s, "HD63484"); break;
1591		}
1592		}
1593
1594	1580	const device_type HD63484 = &device_creator<hd63484_device>;
1595	1581
1596	1582	hd63484_device::hd63484_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/video/tlc34076.c
r17616	r17617
281	281	state_save_register_global(device->machine(), state->dacbits);
282	282	}
283	283
284		DEVICE_GET_INFO(tlc34076)
285		{
286		switch (state)
287		{
288		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tlc34076_state); break;
289
290		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tlc34076); break;
291
292		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tlc34076); break;
293
294		case DEVINFO_STR_NAME: strcpy(info->s, "TLC34076"); break;
295		}
296		}
297
298	284	const device_type TLC34076 = &device_creator<tlc34076_device>;
299	285
300	286	tlc34076_device::tlc34076_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/video/voodoo.c
r17616	r17617
5028	5028	soft_reset(v);
5029	5029	}
5030	5030
5031
5032		/*-------------------------------------------------
5033		device definition
5034		-------------------------------------------------*/
5035
5036		DEVICE_GET_INFO(voodoo)
5037		{
5038		switch (state)
5039		{
5040		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(voodoo_state); break;
5041
5042		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(voodoo); break;
5043
5044		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(voodoo); break;
5045		}
5046		}
5047
5048
5049		DEVICE_GET_INFO(voodoo_1)
5050		{
5051		switch (state)
5052		{
5053		case DEVINFO_STR_NAME: strcpy(info->s, "3dfx Voodoo Graphics"); break;
5054		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(voodoo_1); break;
5055		default: DEVICE_GET_INFO_CALL(voodoo); break;
5056		}
5057		}
5058
5059		DEVICE_GET_INFO(voodoo_2)
5060		{
5061		switch (state)
5062		{
5063		case DEVINFO_STR_NAME: strcpy(info->s, "3dfx Voodoo 2"); break;
5064		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(voodoo_2); break;
5065		default: DEVICE_GET_INFO_CALL(voodoo); break;
5066		}
5067		}
5068		DEVICE_GET_INFO(voodoo_banshee)
5069		{
5070		switch (state)
5071		{
5072		case DEVINFO_STR_NAME: strcpy(info->s, "3dfx Voodoo Banshee"); break;
5073		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(voodoo_banshee); break;
5074		default: DEVICE_GET_INFO_CALL(voodoo); break;
5075		}
5076		}
5077
5078		DEVICE_GET_INFO(voodoo_3)
5079		{
5080		switch (state)
5081		{
5082		case DEVINFO_STR_NAME: strcpy(info->s, "3dfx Voodoo 3"); break;
5083		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(voodoo_3); break;
5084		default: DEVICE_GET_INFO_CALL(voodoo); break;
5085		}
5086		}
5087
5088
5089	5031	/***************************************************************************
5090	5032	COMMAND HANDLERS
5091	5033	***************************************************************************/

trunk/src/emu/video/i8275.c
r17616	r17617
588	588	i8275->blink = 0;
589	589	}
590	590
591		DEVICE_GET_INFO( i8275 )
592		{
593		switch (state)
594		{
595		/* --- the following bits of info are returned as 64-bit signed integers --- */
596		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(i8275_t); break;
597
598		/* --- the following bits of info are returned as pointers to data or functions --- */
599		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(i8275); break;
600		case DEVINFO_FCT_STOP: /* Nothing */ break;
601		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(i8275); break;
602
603		/* --- the following bits of info are returned as NULL-terminated strings --- */
604		case DEVINFO_STR_NAME: strcpy(info->s, "Intel 8275"); break;
605		case DEVINFO_STR_FAMILY: strcpy(info->s, "Intel 8275"); break;
606		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
607		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
608		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
609		}
610		}
611
612	591	const device_type I8275 = &device_creator<i8275_device>;
613	592
614	593	i8275_device::i8275_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/video/s2636.c
r17616	r17617
365	365	device->save_item(NAME(*s2636->collision_bitmap));
366	366	}
367	367
368		DEVICE_GET_INFO(s2636)
369		{
370		switch (state)
371		{
372		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(s2636_state); break;
373
374		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(s2636); break;
375
376		case DEVINFO_STR_NAME: strcpy(info->s, "Signetics 2636"); break;
377		}
378		}
379
380	368	const device_type S2636 = &device_creator<s2636_device>;
381	369
382	370	s2636_device::s2636_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/video/tms9927.c
r17616	r17617
307	307	{
308	308	}
309	309
310
311		DEVICE_GET_INFO( tms9927 )
312		{
313		switch (state)
314		{
315		/* --- the following bits of info are returned as 64-bit signed integers --- */
316		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms9927_state); break;
317
318		/* --- the following bits of info are returned as pointers to functions --- */
319		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms9927); break;
320		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(tms9927); break;
321		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tms9927); break;
322
323		/* --- the following bits of info are returned as NULL-terminated strings --- */
324		case DEVINFO_STR_NAME: strcpy(info->s, "TMS9927"); break;
325		case DEVINFO_STR_FAMILY: strcpy(info->s, "TMS9927 CRTC"); break;
326		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
327		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
328		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
329		}
330		}
331
332		DEVICE_GET_INFO( crt5027 )
333		{
334		switch (state)
335		{
336		case DEVINFO_STR_NAME: strcpy(info->s, "CRT5027"); break;
337		default: DEVICE_GET_INFO_CALL(tms9927); break;
338		}
339		}
340
341		DEVICE_GET_INFO( crt5037 )
342		{
343		switch (state)
344		{
345		case DEVINFO_STR_NAME: strcpy(info->s, "CRT5037"); break;
346		default: DEVICE_GET_INFO_CALL(tms9927); break;
347		}
348		}
349
350		DEVICE_GET_INFO( crt5057 )
351		{
352		switch (state)
353		{
354		case DEVINFO_STR_NAME: strcpy(info->s, "CRT5057"); break;
355		default: DEVICE_GET_INFO_CALL(tms9927); break;
356		}
357		}
358
359
360	310	const device_type TMS9927 = &device_creator<tms9927_device>;
361	311
362	312	tms9927_device::tms9927_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/video/saa5050.c
r17616	r17617
381	381	}
382	382
383	383
384		DEVICE_GET_INFO(saa5050)
385		{
386		switch (state)
387		{
388		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(saa5050_state); break;
389
390		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(saa5050); break;
391
392		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(saa5050); break;
393
394		case DEVINFO_STR_NAME: strcpy(info->s, "SAA5050"); break;
395		}
396		}
397
398	384	const device_type SAA5050 = &device_creator<saa5050_device>;
399	385
400	386	saa5050_device::saa5050_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/sp0256.c
r17616	r17617
1365	1365	sp->stream->set_sample_rate(clock / CLOCK_DIVIDER);
1366	1366	}
1367	1367
1368		/**************************************************************************
1369		* Generic get_info
1370		**************************************************************************/
1371
1372		DEVICE_GET_INFO( sp0256 )
1373		{
1374		switch (state)
1375		{
1376		/* --- the following bits of info are returned as 64-bit signed integers --- */
1377		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(sp0256_state); break;
1378
1379		/* --- the following bits of info are returned as pointers to data or functions --- */
1380		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sp0256 ); break;
1381		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( sp0256 ); break;
1382
1383		/* --- the following bits of info are returned as NULL-terminated strings --- */
1384		case DEVINFO_STR_NAME: strcpy(info->s, "SP0256"); break;
1385		case DEVINFO_STR_FAMILY: strcpy(info->s, "GI"); break;
1386		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1387		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1388		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Joseph Zbiciak, tim lindner"); break;
1389		}
1390		}
1391
1392
1393	1368	const device_type SP0256 = &device_creator<sp0256_device>;
1394	1369
1395	1370	sp0256_device::sp0256_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/hc55516.c
r17616	r17617
294	294	}
295	295
296	296
297
298		/**************************************************************************
299		* Generic get_info
300		**************************************************************************/
301
302		DEVICE_GET_INFO( hc55516 )
303		{
304		switch (state)
305		{
306		/* --- the following bits of info are returned as 64-bit signed integers --- */
307		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(hc55516_state); break;
308
309		/* --- the following bits of info are returned as pointers to data or functions --- */
310		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( hc55516 ); break;
311		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( hc55516 ); break;
312
313		/* --- the following bits of info are returned as NULL-terminated strings --- */
314		case DEVINFO_STR_NAME: strcpy(info->s, "HC-55516"); break;
315		case DEVINFO_STR_FAMILY: strcpy(info->s, "CVSD"); break;
316		case DEVINFO_STR_VERSION: strcpy(info->s, "2.1"); break;
317		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
318		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
319		}
320		}
321
322
323		DEVICE_GET_INFO( mc3417 )
324		{
325		switch (state)
326		{
327		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( mc3417 ); break;
328		case DEVINFO_FCT_RESET: /* chip has no reset pin */ break;
329		case DEVINFO_STR_NAME: strcpy(info->s, "MC3417"); break;
330		default: DEVICE_GET_INFO_CALL(hc55516); break;
331		}
332		}
333
334
335		DEVICE_GET_INFO( mc3418 )
336		{
337		switch (state)
338		{
339		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( mc3418 ); break;
340		case DEVINFO_FCT_RESET: /* chip has no reset pin */ break;
341		case DEVINFO_STR_NAME: strcpy(info->s, "MC3418"); break;
342		default: DEVICE_GET_INFO_CALL(hc55516); break;
343		}
344		}
345
346
347	297	const device_type HC55516 = &device_creator<hc55516_device>;
348	298
349	299	hc55516_device::hc55516_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/iremga20.c
r17616	r17617
264	264	}
265	265	}
266	266
267
268
269
270		/**************************************************************************
271		* Generic get_info
272		**************************************************************************/
273
274		DEVICE_GET_INFO( iremga20 )
275		{
276		switch (state)
277		{
278		/* --- the following bits of info are returned as 64-bit signed integers --- */
279		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ga20_state); break;
280
281		/* --- the following bits of info are returned as pointers to data or functions --- */
282		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( iremga20 ); break;
283		case DEVINFO_FCT_STOP: /* nothing */ break;
284		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( iremga20 ); break;
285
286		/* --- the following bits of info are returned as NULL-terminated strings --- */
287		case DEVINFO_STR_NAME: strcpy(info->s, "Irem GA20"); break;
288		case DEVINFO_STR_FAMILY: strcpy(info->s, "Irem custom"); break;
289		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
290		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
291		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
292		}
293		}
294
295
296	267	const device_type IREMGA20 = &device_creator<iremga20_device>;
297	268
298	269	iremga20_device::iremga20_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/tms5110.c
r17616	r17617
1497	1497	TMS 5110 device definition
1498	1498	-------------------------------------------------*/
1499	1499
1500
1501		DEVICE_GET_INFO(tms5110)
1502		{
1503		switch (state)
1504		{
1505		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms5110_state); break;
1506
1507		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5110); break;
1508
1509		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tms5110); break;
1510
1511		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5110"); break;
1512		}
1513		}
1514
1515		DEVICE_GET_INFO(tms5100)
1516		{
1517		switch (state)
1518		{
1519		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5100); break;
1520
1521		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5100"); break;
1522		default: DEVICE_GET_INFO_CALL(tms5110); break;
1523		}
1524		}
1525
1526		DEVICE_GET_INFO(tms5110a)
1527		{
1528		switch (state)
1529		{
1530		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5110a); break;
1531
1532		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5110A"); break;
1533		default: DEVICE_GET_INFO_CALL(tms5110); break;
1534		}
1535		}
1536
1537		DEVICE_GET_INFO(cd2801)
1538		{
1539		switch (state)
1540		{
1541		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(cd2801); break;
1542
1543		case DEVINFO_STR_NAME: strcpy(info->s, "CD2801"); break;
1544		default: DEVICE_GET_INFO_CALL(tms5110); break;
1545		}
1546		}
1547
1548		DEVICE_GET_INFO(tmc0281)
1549		{
1550		switch (state)
1551		{
1552		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tmc0281); break;
1553
1554		case DEVINFO_STR_NAME: strcpy(info->s, "TMC0281"); break;
1555		default: DEVICE_GET_INFO_CALL(tms5110); break;
1556		}
1557		}
1558
1559		DEVICE_GET_INFO(cd2802)
1560		{
1561		switch (state)
1562		{
1563		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(cd2802); break;
1564		case DEVINFO_STR_NAME: strcpy(info->s, "CD2802"); break;
1565		default: DEVICE_GET_INFO_CALL(tms5110); break;
1566		}
1567		}
1568
1569		DEVICE_GET_INFO(m58817)
1570		{
1571		switch (state)
1572		{
1573		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(m58817); break;
1574		case DEVINFO_STR_NAME: strcpy(info->s, "M58817"); break;
1575		default: DEVICE_GET_INFO_CALL(tms5110); break;
1576		}
1577		}
1578
1579		DEVICE_GET_INFO(tmsprom)
1580		{
1581		switch (state)
1582		{
1583		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tmsprom_state); break;
1584		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tmsprom); break;
1585		case DEVINFO_STR_NAME: strcpy(info->s, "TMSPROM"); break;
1586		}
1587		}
1588
1589	1500	const device_type TMS5110 = &device_creator<tms5110_device>;
1590	1501
1591	1502	tms5110_device::tms5110_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2612intf.c
r17616	r17617
157	157	WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w ) { ym2612_w(device, 1, data); }
158	158	WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w ) { ym2612_w(device, 3, data); }
159	159
160
161
162
163		/**************************************************************************
164		* Generic get_info
165		**************************************************************************/
166
167		DEVICE_GET_INFO( ym2612 )
168		{
169		switch (state)
170		{
171		/* --- the following bits of info are returned as 64-bit signed integers --- */
172		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2612_state); break;
173
174		/* --- the following bits of info are returned as pointers to data or functions --- */
175		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2612 ); break;
176		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2612 ); break;
177		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2612 ); break;
178
179		/* --- the following bits of info are returned as NULL-terminated strings --- */
180		case DEVINFO_STR_NAME: strcpy(info->s, "YM2612"); break;
181		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
182		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
183		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
184		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
185		}
186		}
187
188
189		DEVICE_GET_INFO( ym3438 )
190		{
191		switch (state)
192		{
193		/* --- the following bits of info are returned as NULL-terminated strings --- */
194		case DEVINFO_STR_NAME: strcpy(info->s, "YM3438"); break;
195
196		default: DEVICE_GET_INFO_CALL(ym2612); break;
197		}
198		}
199
200
201	160	const device_type YM2612 = &device_creator<ym2612_device>;
202	161
203	162	ym2612_device::ym2612_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/3526intf.c
r17616	r17617
145	145	WRITE8_DEVICE_HANDLER( ym3526_write_port_w ) { ym3526_w(device, 1, data); }
146	146
147	147
148		/**************************************************************************
149		* Generic get_info
150		**************************************************************************/
151
152		DEVICE_GET_INFO( ym3526 )
153		{
154		switch (state)
155		{
156		/* --- the following bits of info are returned as 64-bit signed integers --- */
157		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym3526_state); break;
158
159		/* --- the following bits of info are returned as pointers to data or functions --- */
160		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym3526 ); break;
161		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym3526 ); break;
162		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym3526 ); break;
163
164		/* --- the following bits of info are returned as NULL-terminated strings --- */
165		case DEVINFO_STR_NAME: strcpy(info->s, "YM3526"); break;
166		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
167		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
168		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
169		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
170		}
171		}
172
173
174	148	const device_type YM3526 = &device_creator<ym3526_device>;
175	149
176	150	ym3526_device::ym3526_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/k051649.c
r17616	r17617
281	281	return 0xff;
282	282	}
283	283
284
285
286
287		/**************************************************************************
288		* Generic get_info
289		**************************************************************************/
290
291		DEVICE_GET_INFO( k051649 )
292		{
293		switch (state)
294		{
295		/* --- the following bits of info are returned as 64-bit signed integers --- */
296		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k051649_state); break;
297
298		/* --- the following bits of info are returned as pointers to data or functions --- */
299		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k051649 ); break;
300		case DEVINFO_FCT_STOP: /* nothing */ break;
301		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( k051649 ); break;
302
303		/* --- the following bits of info are returned as NULL-terminated strings --- */
304		case DEVINFO_STR_NAME: strcpy(info->s, "K051649"); break;
305		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami custom"); break;
306		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
307		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
308		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
309		}
310		}
311
312
313	284	const device_type K051649 = &device_creator<k051649_device>;
314	285
315	286	k051649_device::k051649_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/c140.c
r17616	r17617
475	475	info->mixer_buffer_right = info->mixer_buffer_left + info->sample_rate;
476	476	}
477	477
478
479
480
481		/**************************************************************************
482		* Generic get_info
483		**************************************************************************/
484
485		DEVICE_GET_INFO( c140 )
486		{
487		switch (state)
488		{
489		/* --- the following bits of info are returned as 64-bit signed integers --- */
490		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(c140_state); break;
491
492		/* --- the following bits of info are returned as pointers to data or functions --- */
493		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( c140 ); break;
494		case DEVINFO_FCT_STOP: /* nothing */ break;
495		case DEVINFO_FCT_RESET: /* nothing */ break;
496
497		/* --- the following bits of info are returned as NULL-terminated strings --- */
498		case DEVINFO_STR_NAME: strcpy(info->s, "C140"); break;
499		case DEVINFO_STR_FAMILY: strcpy(info->s, "Namco PCM"); break;
500		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
501		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
502		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
503		}
504		}
505
506
507	478	const device_type C140 = &device_creator<c140_device>;
508	479
509	480	c140_device::c140_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/msm5205.c
r17616	r17617
341	341	voice->timer->adjust(period, 0, period);
342	342	}
343	343
344
345		/**************************************************************************
346		* Generic get_info
347		**************************************************************************/
348
349		DEVICE_GET_INFO( msm5205 )
350		{
351		switch (state)
352		{
353		/* --- the following bits of info are returned as 64-bit signed integers --- */
354		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(msm5205_state); break;
355
356		/* --- the following bits of info are returned as pointers to data or functions --- */
357		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( msm5205 ); break;
358		case DEVINFO_FCT_STOP: /* nothing */ break;
359		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( msm5205 ); break;
360
361		/* --- the following bits of info are returned as NULL-terminated strings --- */
362		case DEVINFO_STR_NAME: strcpy(info->s, "MSM5205"); break;
363		case DEVINFO_STR_FAMILY: strcpy(info->s, "ADPCM"); break;
364		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
365		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
366		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
367		}
368		}
369
370		DEVICE_GET_INFO( msm6585 )
371		{
372		switch (state)
373		{
374		case DEVINFO_STR_NAME: strcpy(info->s, "MSM6585"); break;
375		default: DEVICE_GET_INFO_CALL(msm5205); break;
376		}
377		}
378
379
380	344	const device_type MSM5205 = &device_creator<msm5205_device>;
381	345
382	346	msm5205_device::msm5205_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/qsound.c
r17616	r17617
370	370	fwrite(datap[1], samples*sizeof(QSOUND_SAMPLE), 1, chip->fpRawDataR);
371	371	}
372	372
373
374
375		/**************************************************************************
376		* Generic get_info
377		**************************************************************************/
378
379		DEVICE_GET_INFO( qsound )
380		{
381		switch (state)
382		{
383		/* --- the following bits of info are returned as 64-bit signed integers --- */
384		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(qsound_state); break;
385
386		/* --- the following bits of info are returned as pointers to data or functions --- */
387		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( qsound ); break;
388		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( qsound ); break;
389		case DEVINFO_FCT_RESET: /* Nothing */ break;
390
391		/* --- the following bits of info are returned as NULL-terminated strings --- */
392		case DEVINFO_STR_NAME: strcpy(info->s, "Q-Sound"); break;
393		case DEVINFO_STR_FAMILY: strcpy(info->s, "Capcom custom"); break;
394		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
395		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
396		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
397		}
398		}
399
400		/************** end of file **************/
401
402	373	const device_type QSOUND = &device_creator<qsound_device>;
403	374
404	375	qsound_device::qsound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/snkwave.c
r17616	r17617
159	159	update_waveform(chip, offset - 2, data);
160	160	}
161	161
162
163
164		/**************************************************************************
165		* Generic get_info
166		**************************************************************************/
167
168		DEVICE_GET_INFO( snkwave )
169		{
170		switch (state)
171		{
172		/* --- the following bits of info are returned as 64-bit signed integers --- */
173		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(snkwave_state); break;
174
175		/* --- the following bits of info are returned as pointers to data or functions --- */
176		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( snkwave ); break;
177		case DEVINFO_FCT_STOP: /* Nothing */ break;
178		case DEVINFO_FCT_RESET: /* Nothing */ break;
179
180		/* --- the following bits of info are returned as NULL-terminated strings --- */
181		case DEVINFO_STR_NAME: strcpy(info->s, "SNK Wave"); break;
182		case DEVINFO_STR_FAMILY: strcpy(info->s, "SNK Wave"); break;
183		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
184		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
185		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
186		}
187		}
188
189	162	const device_type SNKWAVE = &device_creator<snkwave_device>;
190	163
191	164	snkwave_device::snkwave_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/3812intf.c
r17616	r17617
141	141	WRITE8_DEVICE_HANDLER( ym3812_write_port_w ) { ym3812_w(device, 1, data); }
142	142
143	143
144		/**************************************************************************
145		* Generic get_info
146		**************************************************************************/
147
148		DEVICE_GET_INFO( ym3812 )
149		{
150		switch (state)
151		{
152		/* --- the following bits of info are returned as 64-bit signed integers --- */
153		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym3812_state); break;
154
155		/* --- the following bits of info are returned as pointers to data or functions --- */
156		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym3812 ); break;
157		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym3812 ); break;
158		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym3812 ); break;
159
160		/* --- the following bits of info are returned as NULL-terminated strings --- */
161		case DEVINFO_STR_NAME: strcpy(info->s, "YM3812"); break;
162		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
163		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
164		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
165		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
166		}
167		}
168
169
170	144	const device_type YM3812 = &device_creator<ym3812_device>;
171	145
172	146	ym3812_device::ym3812_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/rf5c400.c
r17616	r17617
558	558	}
559	559	}
560	560
561		/**************************************************************************
562		* Generic get_info
563		**************************************************************************/
564
565		DEVICE_GET_INFO( rf5c400 )
566		{
567		switch (state)
568		{
569		/* --- the following bits of info are returned as 64-bit signed integers --- */
570		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(rf5c400_state); break;
571
572		/* --- the following bits of info are returned as pointers to data or functions --- */
573		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( rf5c400 ); break;
574		case DEVINFO_FCT_STOP: /* nothing */ break;
575		case DEVINFO_FCT_RESET: /* nothing */ break;
576
577		/* --- the following bits of info are returned as NULL-terminated strings --- */
578		case DEVINFO_STR_NAME: strcpy(info->s, "RF5C400"); break;
579		case DEVINFO_STR_FAMILY: strcpy(info->s, "Ricoh PCM"); break;
580		case DEVINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
581		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
582		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team & hoot development team"); break;
583		}
584		}
585
586	561	const device_type RF5C400 = &device_creator<rf5c400_device>;
587	562
588	563	rf5c400_device::rf5c400_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/cem3394.c
r17616	r17617
557	557	return 0.0;
558	558	}
559	559
560
561
562
563		/**************************************************************************
564		* Generic get_info
565		**************************************************************************/
566
567		DEVICE_GET_INFO( cem3394 )
568		{
569		switch (state)
570		{
571		/* --- the following bits of info are returned as 64-bit signed integers --- */
572		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(cem3394_state); break;
573
574		/* --- the following bits of info are returned as pointers to data or functions --- */
575		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( cem3394 ); break;
576		case DEVINFO_FCT_STOP: /* nothing */ break;
577		case DEVINFO_FCT_RESET: /* nothing */ break;
578
579		/* --- the following bits of info are returned as NULL-terminated strings --- */
580		case DEVINFO_STR_NAME: strcpy(info->s, "CEM3394"); break;
581		case DEVINFO_STR_FAMILY: strcpy(info->s, "Analog Synth"); break;
582		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
583		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
584		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
585		}
586		}
587
588
589	560	const device_type CEM3394 = &device_creator<cem3394_device>;
590	561
591	562	cem3394_device::cem3394_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/saa1099.c
r17616	r17617
436	436	}
437	437	}
438	438
439
440		/**************************************************************************
441		* Generic get_info
442		**************************************************************************/
443
444		DEVICE_GET_INFO( saa1099 )
445		{
446		switch (state)
447		{
448		/* --- the following bits of info are returned as 64-bit signed integers --- */
449		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(saa1099_state); break;
450
451		/* --- the following bits of info are returned as pointers to data or functions --- */
452		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( saa1099 ); break;
453		case DEVINFO_FCT_STOP: /* Nothing */ break;
454		case DEVINFO_FCT_RESET: /* Nothing */ break;
455
456		/* --- the following bits of info are returned as NULL-terminated strings --- */
457		case DEVINFO_STR_NAME: strcpy(info->s, "SAA1099"); break;
458		case DEVINFO_STR_FAMILY: strcpy(info->s, "Philips"); break;
459		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
460		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
461		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
462		}
463		}
464
465
466	439	const device_type SAA1099 = &device_creator<saa1099_device>;
467	440
468	441	saa1099_device::saa1099_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/digitalk.c
r17616	r17617
659	659	digitalker_register_for_save(dg);
660	660	}
661	661
662		DEVICE_GET_INFO(digitalker)
663		{
664		switch(state) {
665		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(digitalker); break;
666		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(digitalker); break;
667		case DEVINFO_FCT_STOP: break;
668		case DEVINFO_FCT_RESET: break;
669		case DEVINFO_STR_NAME: strcpy(info->s, "Digitalker"); break;
670		case DEVINFO_STR_FAMILY: strcpy(info->s, "National Semiconductor"); break;
671		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
672		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
673		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Olivier Galibert"); break;
674		}
675		}
676
677	662	void digitalker_0_cs_w(device_t *device, int line)
678	663	{
679	664	digitalker *dg = get_safe_token(device);

trunk/src/emu/sound/ymz280b.c
r17616	r17617
1046	1046	}
1047	1047
1048	1048
1049
1050		/**************************************************************************
1051		* Generic get_info
1052		**************************************************************************/
1053
1054		DEVICE_GET_INFO( ymz280b )
1055		{
1056		switch (state)
1057		{
1058		/* --- the following bits of info are returned as 64-bit signed integers --- */
1059		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ymz280b_state); break;
1060
1061		/* --- the following bits of info are returned as pointers to data or functions --- */
1062		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ymz280b ); break;
1063		case DEVINFO_FCT_STOP: /* Nothing */ break;
1064		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME( ymz280b ); break;
1065
1066		/* --- the following bits of info are returned as NULL-terminated strings --- */
1067		case DEVINFO_STR_NAME: strcpy(info->s, "YMZ280B"); break;
1068		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha Wavetable"); break;
1069		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1070		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1071		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1072		}
1073		}
1074
1075
1076	1049	const device_type YMZ280B = &device_creator<ymz280b_device>;
1077	1050
1078	1051	ymz280b_device::ymz280b_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/rf5c68.c
r17616	r17617
258	258	chip->data[chip->wbank * 0x1000 + offset] = data;
259	259	}
260	260
261
262
263		/**************************************************************************
264		* Generic get_info
265		**************************************************************************/
266
267		DEVICE_GET_INFO( rf5c68 )
268		{
269		switch (state)
270		{
271		/* --- the following bits of info are returned as 64-bit signed integers --- */
272		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(rf5c68_state); break;
273
274		/* --- the following bits of info are returned as pointers to data or functions --- */
275		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( rf5c68 ); break;
276		case DEVINFO_FCT_STOP: /* Nothing */ break;
277		case DEVINFO_FCT_RESET: /* Nothing */ break;
278
279		/* --- the following bits of info are returned as NULL-terminated strings --- */
280		case DEVINFO_STR_NAME: strcpy(info->s, "RF5C68"); break;
281		case DEVINFO_STR_FAMILY: strcpy(info->s, "Ricoh PCM"); break;
282		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
283		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
284		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
285		}
286		}
287
288		/************** end of file **************/
289
290	261	const device_type RF5C68 = &device_creator<rf5c68_device>;
291	262
292	263	rf5c68_device::rf5c68_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/mos6560.c
r17616	r17617
951	951	mos6560->noisesamples = 1;
952	952	}
953	953
954
955		/*-------------------------------------------------
956		Device definition
957		-------------------------------------------------*/
958
959		DEVICE_GET_INFO(mos6560)
960		{
961		switch (state)
962		{
963		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mos6560_state); break;
964
965		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mos6560); break;
966
967		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mos6560); break;
968
969		case DEVINFO_STR_NAME: strcpy(info->s, "MOS 6560 / 6561 VIC"); break;
970		}
971		}
972
973	954	const device_type MOS656X = &device_creator<mos6560_device>;
974	955
975	956	mos6560_device::mos6560_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/k005289.c
r17616	r17617
245	245	k005289_recompute(info);
246	246	}
247	247
248
249
250
251		/**************************************************************************
252		* Generic get_info
253		**************************************************************************/
254
255		DEVICE_GET_INFO( k005289 )
256		{
257		switch (state)
258		{
259		/* --- the following bits of info are returned as 64-bit signed integers --- */
260		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k005289_state); break;
261
262		/* --- the following bits of info are returned as pointers to data or functions --- */
263		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k005289 ); break;
264		case DEVINFO_FCT_STOP: /* nothing */ break;
265		case DEVINFO_FCT_RESET: /* nothing */ break;
266
267		/* --- the following bits of info are returned as NULL-terminated strings --- */
268		case DEVINFO_STR_NAME: strcpy(info->s, "K005289"); break;
269		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami custom"); break;
270		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
271		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
272		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
273		}
274		}
275
276
277	248	const device_type K005289 = &device_creator<k005289_device>;
278	249
279	250	k005289_device::k005289_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/aica.c
r17616	r17617
1354	1354	return val;
1355	1355	}
1356	1356
1357		/**************************************************************************
1358		* Generic get_info
1359		**************************************************************************/
1360
1361		DEVICE_GET_INFO( aica )
1362		{
1363		switch (state)
1364		{
1365		/* --- the following bits of info are returned as 64-bit signed integers --- */
1366		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(aica_state); break;
1367
1368		/* --- the following bits of info are returned as pointers to data or functions --- */
1369		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( aica ); break;
1370		case DEVINFO_FCT_STOP: info->start = DEVICE_STOP_NAME( aica ); break;
1371
1372		/* --- the following bits of info are returned as NULL-terminated strings --- */
1373		case DEVINFO_STR_NAME: strcpy(info->s, "AICA"); break;
1374		case DEVINFO_STR_FAMILY: strcpy(info->s, "Sega/Yamaha custom"); break;
1375		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0.1"); break;
1376		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1377		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1378		}
1379		}
1380
1381
1382
1383	1357	const device_type AICA = &device_creator<aica_device>;
1384	1358
1385	1359	aica_device::aica_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/sn76496.c
r17616	r17617
486	486	generic_start(device, 0x8000, 0x01, 0x08, TRUE, FALSE, 8, FALSE); // todo: verify; from smspower wiki, assumed to have same invert as gamegear
487	487	}
488	488
489
490		/**************************************************************************
491		* Generic get_info
492		**************************************************************************/
493
494		DEVICE_GET_INFO( sn76496 )
495		{
496		switch (state)
497		{
498		/* --- the following bits of info are returned as 64-bit signed integers --- */
499		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(sn76496_state); break;
500
501		/* --- the following bits of info are returned as pointers to data or functions --- */
502		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn76496 ); break;
503		case DEVINFO_FCT_STOP: /* Nothing */ break;
504		case DEVINFO_FCT_RESET: /* Nothing */ break;
505
506		/* --- the following bits of info are returned as NULL-terminated strings --- */
507		case DEVINFO_STR_NAME: strcpy(info->s, "SN76496"); break;
508		case DEVINFO_STR_FAMILY: strcpy(info->s, "TI PSG"); break;
509		case DEVINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
510		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
511		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
512		}
513		}
514
515		DEVICE_GET_INFO( sn76489 )
516		{
517		switch (state)
518		{
519		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn76489 ); break;
520		case DEVINFO_STR_NAME: strcpy(info->s, "SN76489"); break;
521		default: DEVICE_GET_INFO_CALL(sn76496); break;
522		}
523		}
524
525		DEVICE_GET_INFO( sn76489a )
526		{
527		switch (state)
528		{
529		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn76489a ); break;
530		case DEVINFO_STR_NAME: strcpy(info->s, "SN76489A"); break;
531		default: DEVICE_GET_INFO_CALL(sn76496); break;
532		}
533		}
534
535		DEVICE_GET_INFO( u8106 )
536		{
537		switch (state)
538		{
539		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( u8106 ); break;
540		case DEVINFO_STR_NAME: strcpy(info->s, "U8106"); break;
541		default: DEVICE_GET_INFO_CALL(sn76496); break;
542		}
543		}
544
545		DEVICE_GET_INFO( y2404 )
546		{
547		switch (state)
548		{
549		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( y2404 ); break;
550		case DEVINFO_STR_NAME: strcpy(info->s, "Y2404"); break;
551		default: DEVICE_GET_INFO_CALL(sn76496); break;
552		}
553		}
554
555		DEVICE_GET_INFO( sn76494 )
556		{
557		switch (state)
558		{
559		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn76494 ); break;
560		case DEVINFO_STR_NAME: strcpy(info->s, "SN76494"); break;
561		default: DEVICE_GET_INFO_CALL(sn76496); break;
562		}
563		}
564
565		DEVICE_GET_INFO( sn94624 )
566		{
567		switch (state)
568		{
569		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn94624 ); break;
570		case DEVINFO_STR_NAME: strcpy(info->s, "SN94624"); break;
571		default: DEVICE_GET_INFO_CALL(sn76496); break;
572		}
573		}
574
575		DEVICE_GET_INFO( ncr7496 )
576		{
577		switch (state)
578		{
579		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ncr7496 ); break;
580		case DEVINFO_STR_NAME: strcpy(info->s, "NCR7496"); break;
581		default: DEVICE_GET_INFO_CALL(sn76496); break;
582		}
583		}
584
585		DEVICE_GET_INFO( gamegear )
586		{
587		switch (state)
588		{
589		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( gamegear ); break;
590		case DEVINFO_STR_NAME: strcpy(info->s, "Game Gear PSG"); break;
591		default: DEVICE_GET_INFO_CALL(sn76496); break;
592		}
593		}
594
595		DEVICE_GET_INFO( segapsg )
596		{
597		switch (state)
598		{
599		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( segapsg ); break;
600		case DEVINFO_STR_NAME: strcpy(info->s, "SEGA VDP PSG"); break;
601		default: DEVICE_GET_INFO_CALL(sn76496); break;
602		}
603		}
604
605
606	489	const device_type SN76496 = &device_creator<sn76496_device>;
607	490
608	491	sn76496_device::sn76496_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/wave.c
r17616	r17617
82	82	}
83	83
84	84
85
86		/**************************************************************************
87		* Generic get_info
88		**************************************************************************/
89
90		DEVICE_GET_INFO( wave )
91		{
92		switch (state)
93		{
94		/* --- the following bits of info are returned as 64-bit signed integers --- */
95		case DEVINFO_INT_TOKEN_BYTES: info->i = 0; break;
96
97		/* --- the following bits of info are returned as pointers to data or functions --- */
98		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( wave ); break;
99		case DEVINFO_FCT_STOP: /* nothing */ break;
100		case DEVINFO_FCT_RESET: /* nothing */ break;
101
102		/* --- the following bits of info are returned as NULL-terminated strings --- */
103		case DEVINFO_STR_NAME: strcpy(info->s, "Cassette"); break;
104		case DEVINFO_STR_FAMILY: strcpy(info->s, "Cassette"); break;
105		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
106		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
107		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright The MESS Team"); break;
108		}
109		}
110
111
112	85	const device_type WAVE = &device_creator<wave_device>;
113	86
114	87	wave_device::wave_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/astrocde.c
r17616	r17617
302	302	chip->reg[offset & 7] = data;
303	303	}
304	304
305
306
307		/*************************************
308		*
309		* Get/set info callbacks
310		*
311		*************************************/
312
313		DEVICE_GET_INFO( astrocade )
314		{
315		switch (state)
316		{
317		/* --- the following bits of info are returned as 64-bit signed integers --- */
318		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(astrocade_state); break;
319
320		/* --- the following bits of info are returned as pointers to data or functions --- */
321		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( astrocade ); break;
322		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( astrocade ); break;
323
324		/* --- the following bits of info are returned as NULL-terminated strings --- */
325		case DEVINFO_STR_NAME: strcpy(info->s, "Astrocade"); break;
326		case DEVINFO_STR_FAMILY: strcpy(info->s, "Bally"); break;
327		case DEVINFO_STR_VERSION: strcpy(info->s, "2.0"); break;
328		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
329		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
330		}
331		}
332
333
334	305	const device_type ASTROCADE = &device_creator<astrocade_device>;
335	306
336	307	astrocade_device::astrocade_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/x1_010.c
r17616	r17617
284	284	}
285	285
286	286
287
288		/**************************************************************************
289		* Generic get_info
290		**************************************************************************/
291
292		DEVICE_GET_INFO( x1_010 )
293		{
294		switch (state)
295		{
296		/* --- the following bits of info are returned as 64-bit signed integers --- */
297		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(x1_010_state); break;
298
299		/* --- the following bits of info are returned as pointers to data or functions --- */
300		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( x1_010 ); break;
301		case DEVINFO_FCT_STOP: /* Nothing */ break;
302		case DEVINFO_FCT_RESET: /* Nothing */ break;
303
304		/* --- the following bits of info are returned as NULL-terminated strings --- */
305		case DEVINFO_STR_NAME: strcpy(info->s, "X1-010"); break;
306		case DEVINFO_STR_FAMILY: strcpy(info->s, "Seta custom"); break;
307		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
308		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
309		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
310		}
311		}
312
313
314	287	const device_type X1_010 = &device_creator<x1_010_device>;
315	288
316	289	x1_010_device::x1_010_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/k056800.c
r17616	r17617
164	164	k056800->sound_cpu_irq1_enable = 0;
165	165	}
166	166
167
168		DEVICE_GET_INFO(k056800)
169		{
170		switch (state)
171		{
172		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k056800_state); break;
173
174		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k056800); break;
175
176		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k056800); break;
177
178		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 056800 MIRAC"); break;
179		}
180		}
181
182	167	const device_type K056800 = &device_creator<k056800_device>;
183	168
184	169	k056800_device::k056800_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/upd7759.c
r17616	r17617
739	739	chip->romoffset = base;
740	740	}
741	741
742
743
744		/**************************************************************************
745		* Generic get_info
746		**************************************************************************/
747
748		DEVICE_GET_INFO( upd7759 )
749		{
750		switch (state)
751		{
752		/* --- the following bits of info are returned as 64-bit signed integers --- */
753		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd7759_state); break;
754
755		/* --- the following bits of info are returned as pointers to data or functions --- */
756		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( upd7759 ); break;
757		case DEVINFO_FCT_STOP: /* Nothing */ break;
758		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( upd7759 ); break;
759
760		/* --- the following bits of info are returned as NULL-terminated strings --- */
761		case DEVINFO_STR_NAME: strcpy(info->s, "UPD7759"); break;
762		case DEVINFO_STR_FAMILY: strcpy(info->s, "NEC ADPCM"); break;
763		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
764		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
765		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
766		}
767		}
768
769
770	742	const device_type UPD7759 = &device_creator<upd7759_device>;
771	743
772	744	upd7759_device::upd7759_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/ymf271.c
r17616	r17617
1810	1810	}
1811	1811	}
1812	1812
1813		/**************************************************************************
1814		* Generic get_info
1815		**************************************************************************/
1816
1817		DEVICE_GET_INFO( ymf271 )
1818		{
1819		switch (state)
1820		{
1821		/* --- the following bits of info are returned as 64-bit signed integers --- */
1822		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(YMF271Chip); break;
1823
1824		/* --- the following bits of info are returned as pointers to data or functions --- */
1825		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ymf271 ); break;
1826		case DEVINFO_FCT_STOP: /* Nothing */ break;
1827		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ymf271 ); break;
1828
1829		/* --- the following bits of info are returned as NULL-terminated strings --- */
1830		case DEVINFO_STR_NAME: strcpy(info->s, "YMF271"); break;
1831		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
1832		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1833		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1834		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1835		}
1836		}
1837
1838
1839	1813	const device_type YMF271 = &device_creator<ymf271_device>;
1840	1814
1841	1815	ymf271_device::ymf271_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/n63701x.c
r17616	r17617
154	154	}
155	155	}
156	156
157
158
159
160
161
162		/**************************************************************************
163		* Generic get_info
164		**************************************************************************/
165
166		DEVICE_GET_INFO( namco_63701x )
167		{
168		switch (state)
169		{
170		/* --- the following bits of info are returned as 64-bit signed integers --- */
171		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_63701x); break;
172
173		/* --- the following bits of info are returned as pointers to data or functions --- */
174		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( namco_63701x ); break;
175		case DEVINFO_FCT_STOP: /* Nothing */ break;
176		case DEVINFO_FCT_RESET: /* Nothing */ break;
177
178		/* --- the following bits of info are returned as NULL-terminated strings --- */
179		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 63701X"); break;
180		case DEVINFO_STR_FAMILY: strcpy(info->s, "Namco custom"); break;
181		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
182		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
183		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
184		}
185		}
186
187
188	157	const device_type NAMCO_63701X = &device_creator<namco_63701x_device>;
189	158
190	159	namco_63701x_device::namco_63701x_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/sp0250.c
r17616	r17617
238	238	}
239	239
240	240
241
242		/**************************************************************************
243		* Generic get_info
244		**************************************************************************/
245
246		DEVICE_GET_INFO( sp0250 )
247		{
248		switch (state)
249		{
250		/* --- the following bits of info are returned as 64-bit signed integers --- */
251		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(sp0250_state); break;
252
253		/* --- the following bits of info are returned as pointers to data or functions --- */
254		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sp0250 ); break;
255		case DEVINFO_FCT_STOP: /* Nothing */ break;
256		case DEVINFO_FCT_RESET: /* Nothing */ break;
257
258		/* --- the following bits of info are returned as NULL-terminated strings --- */
259		case DEVINFO_STR_NAME: strcpy(info->s, "SP0250"); break;
260		case DEVINFO_STR_FAMILY: strcpy(info->s, "GI speech"); break;
261		case DEVINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
262		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
263		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
264		}
265		}
266
267
268
269	241	const device_type SP0250 = &device_creator<sp0250_device>;
270	242
271	243	sp0250_device::sp0250_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/speaker.c
r17616	r17617
418	418	}
419	419
420	420
421		/**************************************************************************
422		* Generic get_info
423		**************************************************************************/
424
425		DEVICE_GET_INFO( speaker_sound )
426		{
427		switch (state)
428		{
429		/* --- the following bits of info are returned as 64-bit signed integers --- */
430		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(speaker_state); break;
431
432		/* --- the following bits of info are returned as pointers to data or functions --- */
433		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( speaker ); break;
434		case DEVINFO_FCT_STOP: /* nothing */ break;
435		case DEVINFO_FCT_RESET: /* nothing */ break;
436
437		/* --- the following bits of info are returned as NULL-terminated strings --- */
438		case DEVINFO_STR_NAME: strcpy(info->s, "Speaker"); break;
439		case DEVINFO_STR_FAMILY: strcpy(info->s, "Speaker"); break;
440		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
441		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
442		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright The MESS Team"); break;
443		}
444		}
445
446
447	421	const device_type SPEAKER_SOUND = &device_creator<speaker_sound_device>;
448	422
449	423	speaker_sound_device::speaker_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/ay8910.c
r17616	r17617
975	975	ay8910_reset_ym(get_safe_token(device));
976	976	}
977	977
978		DEVICE_GET_INFO( ay8910 )
979		{
980		switch (state)
981		{
982		/* --- the following bits of info are returned as 64-bit signed integers --- */
983		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ay8910_context); break;
984
985		/* --- the following bits of info are returned as pointers to data or functions --- */
986		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ay8910 ); break;
987		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ay8910 ); break;
988		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ay8910 ); break;
989
990		/* --- the following bits of info are returned as NULL-terminated strings --- */
991		case DEVINFO_STR_NAME: strcpy(info->s, "AY-3-8910A"); break;
992		case DEVINFO_STR_FAMILY: strcpy(info->s, "PSG"); break;
993		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
994		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
995		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
996		}
997		}
998
999		DEVICE_GET_INFO( ay8912 )
1000		{
1001		switch (state)
1002		{
1003		case DEVINFO_STR_NAME: strcpy(info->s, "AY-3-8912A"); break;
1004		default: DEVICE_GET_INFO_CALL(ay8910); break;
1005		}
1006		}
1007
1008		DEVICE_GET_INFO( ay8913 )
1009		{
1010		switch (state)
1011		{
1012		case DEVINFO_STR_NAME: strcpy(info->s, "AY-3-8913A"); break;
1013		default: DEVICE_GET_INFO_CALL(ay8910); break;
1014		}
1015		}
1016
1017		DEVICE_GET_INFO( ay8914 )
1018		{
1019		switch (state)
1020		{
1021		case DEVINFO_STR_NAME: strcpy(info->s, "AY-3-8914"); break;
1022		default: DEVICE_GET_INFO_CALL(ay8910); break;
1023		}
1024		}
1025
1026		DEVICE_GET_INFO( ay8930 )
1027		{
1028		switch (state)
1029		{
1030		case DEVINFO_STR_NAME: strcpy(info->s, "AY8930"); break;
1031		default: DEVICE_GET_INFO_CALL(ay8910); break;
1032		}
1033		}
1034
1035		DEVICE_GET_INFO( ym2149 )
1036		{
1037		switch (state)
1038		{
1039		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2149 ); break;
1040		case DEVINFO_STR_NAME: strcpy(info->s, "YM2149"); break;
1041		default: DEVICE_GET_INFO_CALL(ay8910); break;
1042		}
1043		}
1044
1045		DEVICE_GET_INFO( ym3439 )
1046		{
1047		switch (state)
1048		{
1049		case DEVINFO_STR_NAME: strcpy(info->s, "YM3439"); break;
1050		default: DEVICE_GET_INFO_CALL(ym2149); break;
1051		}
1052		}
1053
1054		DEVICE_GET_INFO( ymz284 )
1055		{
1056		switch (state)
1057		{
1058		case DEVINFO_STR_NAME: strcpy(info->s, "YMZ284"); break;
1059		default: DEVICE_GET_INFO_CALL(ym2149); break;
1060		}
1061		}
1062
1063		DEVICE_GET_INFO( ymz294 )
1064		{
1065		switch (state)
1066		{
1067		case DEVINFO_STR_NAME: strcpy(info->s, "YMZ294"); break;
1068		default: DEVICE_GET_INFO_CALL(ym2149); break;
1069		}
1070		}
1071
1072	978	/*************************************
1073	979	*
1074	980	* Read/Write Handlers

trunk/src/emu/sound/cdda.c
r17616	r17617
313	313	cdda->stream->set_output_gain(channel,volume / 100.0);
314	314	}
315	315
316		/**************************************************************************
317		* Generic get_info
318		**************************************************************************/
319
320		DEVICE_GET_INFO( cdda )
321		{
322		switch (state)
323		{
324		/* --- the following bits of info are returned as 64-bit signed integers --- */
325		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(cdda_info); break;
326
327		/* --- the following bits of info are returned as pointers to data or functions --- */
328		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( cdda ); break;
329		case DEVINFO_FCT_STOP: /* nothing */ break;
330		case DEVINFO_FCT_RESET: /* nothing */ break;
331
332		/* --- the following bits of info are returned as NULL-terminated strings --- */
333		case DEVINFO_STR_NAME: strcpy(info->s, "CD/DA"); break;
334		case DEVINFO_STR_FAMILY: strcpy(info->s, "CD Audio"); break;
335		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
336		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
337		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
338		}
339		}
340
341
342	316	const device_type CDDA = &device_creator<cdda_device>;
343	317
344	318	cdda_device::cdda_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/tms36xx.c
r17616	r17617
524	524	}
525	525
526	526
527
528
529		/**************************************************************************
530		* Generic get_info
531		**************************************************************************/
532
533		DEVICE_GET_INFO( tms36xx )
534		{
535		switch (state)
536		{
537		/* --- the following bits of info are returned as 64-bit signed integers --- */
538		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms_state); break;
539
540		/* --- the following bits of info are returned as pointers to data or functions --- */
541		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( tms36xx ); break;
542		case DEVINFO_FCT_STOP: /* Nothing */ break;
543		case DEVINFO_FCT_RESET: /* Nothing */ break;
544
545		/* --- the following bits of info are returned as NULL-terminated strings --- */
546		case DEVINFO_STR_NAME: strcpy(info->s, "TMS36XX"); break;
547		case DEVINFO_STR_FAMILY: strcpy(info->s, "TI PSG"); break;
548		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
549		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
550		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
551		}
552		}
553
554
555	527	const device_type TMS36XX = &device_creator<tms36xx_device>;
556	528
557	529	tms36xx_device::tms36xx_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/st0016.c
r17616	r17617
145	145	info->stream = device->machine().sound().stream_alloc(*device, 0, 2, 44100, info, st0016_update);
146	146	}
147	147
148
149
150		/**************************************************************************
151		* Generic get_info
152		**************************************************************************/
153
154		DEVICE_GET_INFO( st0016 )
155		{
156		switch (state)
157		{
158		/* --- the following bits of info are returned as 64-bit signed integers --- */
159		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(st0016_state); break;
160
161		/* --- the following bits of info are returned as pointers to data or functions --- */
162		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( st0016 ); break;
163		case DEVINFO_FCT_STOP: /* Nothing */ break;
164		case DEVINFO_FCT_RESET: /* Nothing */ break;
165
166		/* --- the following bits of info are returned as NULL-terminated strings --- */
167		case DEVINFO_STR_NAME: strcpy(info->s, "ST0016"); break;
168		case DEVINFO_STR_FAMILY: strcpy(info->s, "Seta custom"); break;
169		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
170		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
171		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
172		}
173		}
174
175
176	148	const device_type ST0016 = &device_creator<st0016_device>;
177	149
178	150	st0016_device::st0016_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/tiaintf.c
r17616	r17617
47	47	tia_write(info->chip, offset, data);
48	48	}
49	49
50
51
52
53		/**************************************************************************
54		* Generic get_info
55		**************************************************************************/
56
57		DEVICE_GET_INFO( tia )
58		{
59		switch (state)
60		{
61		/* --- the following bits of info are returned as 64-bit signed integers --- */
62		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tia_state); break;
63
64		/* --- the following bits of info are returned as pointers to data or functions --- */
65		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( tia ); break;
66		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( tia ); break;
67		case DEVINFO_FCT_RESET: /* Nothing */ break;
68
69		/* --- the following bits of info are returned as NULL-terminated strings --- */
70		case DEVINFO_STR_NAME: strcpy(info->s, "TIA"); break;
71		case DEVINFO_STR_FAMILY: strcpy(info->s, "Atari custom"); break;
72		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
73		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
74		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
75		}
76		}
77
78
79	50	const device_type TIA = &device_creator<tia_device>;
80	51
81	52	tia_device::tia_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/c6280.c
r17616	r17617
344	344	c6280_write(info, offset, data);
345	345	}
346	346
347
348
349		/**************************************************************************
350		* Generic get_info
351		**************************************************************************/
352
353		DEVICE_GET_INFO( c6280 )
354		{
355		switch (state)
356		{
357		/* --- the following bits of info are returned as 64-bit signed integers --- */
358		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(c6280_t); break;
359
360		/* --- the following bits of info are returned as pointers to data or functions --- */
361		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( c6280 ); break;
362		case DEVINFO_FCT_STOP: /* nothing */ break;
363		case DEVINFO_FCT_RESET: /* nothing */ break;
364
365		/* --- the following bits of info are returned as NULL-terminated strings --- */
366		case DEVINFO_STR_NAME: strcpy(info->s, "HuC6280"); break;
367		case DEVINFO_STR_FAMILY: strcpy(info->s, "????"); break;
368		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
369		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
370		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
371		}
372		}
373
374
375	347	const device_type C6280 = &device_creator<c6280_device>;
376	348
377	349	c6280_device::c6280_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/scsp.c
r17616	r17617
1359	1359	return val;
1360	1360	}
1361	1361
1362
1363
1364		/**************************************************************************
1365		* Generic get_info
1366		**************************************************************************/
1367
1368		DEVICE_GET_INFO( scsp )
1369		{
1370		switch (state)
1371		{
1372		/* --- the following bits of info are returned as 64-bit signed integers --- */
1373		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(scsp_state); break;
1374
1375		/* --- the following bits of info are returned as pointers to data or functions --- */
1376		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( scsp ); break;
1377		case DEVINFO_FCT_STOP: /* Nothing */ break;
1378		case DEVINFO_FCT_RESET: /* Nothing */ break;
1379
1380		/* --- the following bits of info are returned as NULL-terminated strings --- */
1381		case DEVINFO_STR_NAME: strcpy(info->s, "SCSP"); break;
1382		case DEVINFO_STR_FAMILY: strcpy(info->s, "Sega/Yamaha custom"); break;
1383		case DEVINFO_STR_VERSION: strcpy(info->s, "2.1.1"); break;
1384		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1385		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1386		}
1387		}
1388
1389
1390	1362	const device_type SCSP = &device_creator<scsp_device>;
1391	1363
1392	1364	scsp_device::scsp_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/msm5232.c
r17616	r17617
850	850	}
851	851	}
852	852
853
854
855		/**************************************************************************
856		* Generic get_info
857		**************************************************************************/
858
859		DEVICE_GET_INFO( msm5232 )
860		{
861		switch (state)
862		{
863		/* --- the following bits of info are returned as 64-bit signed integers --- */
864		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(msm5232_state); break;
865
866		/* --- the following bits of info are returned as pointers to data or functions --- */
867		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( msm5232 ); break;
868		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( msm5232 ); break;
869		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( msm5232 ); break;
870
871		/* --- the following bits of info are returned as NULL-terminated strings --- */
872		case DEVINFO_STR_NAME: strcpy(info->s, "MSM5232"); break;
873		case DEVINFO_STR_FAMILY: strcpy(info->s, "Oki Tone"); break;
874		case DEVINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
875		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
876		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
877		}
878		}
879
880
881	853	const device_type MSM5232 = &device_creator<msm5232_device>;
882	854
883	855	msm5232_device::msm5232_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2610intf.c
r17616	r17617
217	217	WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w ) { ym2610_w(device, 1, data); }
218	218	WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w ) { ym2610_w(device, 3, data); }
219	219
220
221
222		/**************************************************************************
223		* Generic get_info
224		**************************************************************************/
225
226		DEVICE_GET_INFO( ym2610 )
227		{
228		switch (state)
229		{
230		/* --- the following bits of info are returned as 64-bit signed integers --- */
231		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2610_state); break;
232
233		/* --- the following bits of info are returned as pointers to data or functions --- */
234		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2610 ); break;
235		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2610 ); break;
236		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2610 ); break;
237
238		/* --- the following bits of info are returned as NULL-terminated strings --- */
239		case DEVINFO_STR_NAME: strcpy(info->s, "YM2610"); break;
240		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
241		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
242		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
243		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
244		}
245		}
246
247		DEVICE_GET_INFO( ym2610b )
248		{
249		switch (state)
250		{
251		/* --- the following bits of info are returned as NULL-terminated strings --- */
252		case DEVINFO_STR_NAME: strcpy(info->s, "YM2610B"); break;
253
254		default: DEVICE_GET_INFO_CALL(ym2610); break;
255		}
256		}
257
258
259	220	const device_type YM2610 = &device_creator<ym2610_device>;
260	221
261	222	ym2610_device::ym2610_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/flt_rc.c
r17616	r17617
111	111
112	112	}
113	113
114		/**************************************************************************
115		* Generic get_info
116		**************************************************************************/
117
118		DEVICE_GET_INFO( filter_rc )
119		{
120		switch (state)
121		{
122		/* --- the following bits of info are returned as 64-bit signed integers --- */
123		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(filter_rc_state); break;
124
125		/* --- the following bits of info are returned as pointers to data or functions --- */
126		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( filter_rc ); break;
127		case DEVINFO_FCT_STOP: /* Nothing */ break;
128		case DEVINFO_FCT_RESET: /* Nothing */ break;
129
130		/* --- the following bits of info are returned as NULL-terminated strings --- */
131		case DEVINFO_STR_NAME: strcpy(info->s, "RC Filter"); break;
132		case DEVINFO_STR_FAMILY: strcpy(info->s, "Filters"); break;
133		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
134		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
135		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
136		}
137		}
138
139
140	114	const device_type FILTER_RC = &device_creator<filter_rc_device>;
141	115
142	116	filter_rc_device::filter_rc_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/beep.c
r17616	r17617
163	163	downcast<beep_device *>(device)->set_output_gain(0, volume);
164	164	}
165	165
166
167
168		/**************************************************************************
169		* Generic get_info
170		**************************************************************************/
171
172		DEVICE_GET_INFO( beep )
173		{
174		switch (state)
175		{
176		/* --- the following bits of info are returned as 64-bit signed integers --- */
177		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(beep_state); break;
178
179		/* --- the following bits of info are returned as pointers to data or functions --- */
180		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( beep ); break;
181
182		/* --- the following bits of info are returned as NULL-terminated strings --- */
183		case DEVINFO_STR_NAME: strcpy(info->s, "Beep"); break;
184		case DEVINFO_STR_FAMILY: strcpy(info->s, "Beep"); break;
185		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
186		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
187		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright The MESS Team"); break;
188		}
189		}
190
191
192	166	const device_type BEEP = &device_creator<beep_device>;
193	167
194	168	beep_device::beep_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/tms3615.c
r17616	r17617
94	94	tms->basefreq = device->clock();
95	95	}
96	96
97		/**************************************************************************
98		* Generic get_info
99		**************************************************************************/
100
101		DEVICE_GET_INFO( tms3615 )
102		{
103		switch (state)
104		{
105		/* --- the following bits of info are returned as 64-bit signed integers --- */
106		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms_state); break;
107
108		/* --- the following bits of info are returned as pointers to data or functions --- */
109		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( tms3615 ); break;
110		case DEVINFO_FCT_STOP: /* Nothing */ break;
111		case DEVINFO_FCT_RESET: /* Nothing */ break;
112
113		/* --- the following bits of info are returned as NULL-terminated strings --- */
114		case DEVINFO_STR_NAME: strcpy(info->s, "TMS3615"); break;
115		case DEVINFO_STR_FAMILY: strcpy(info->s, "TI PSG"); break;
116		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
117		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
118		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
119		}
120		}
121
122
123	97	const device_type TMS3615 = &device_creator<tms3615_device>;
124	98
125	99	tms3615_device::tms3615_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/s14001a.c
r17616	r17617
629	629	chip->VSU1000_amp = volume;
630	630	}
631	631
632		DEVICE_GET_INFO( s14001a )
633		{
634		switch (state)
635		{
636		/* --- the following bits of info are returned as 64-bit signed integers --- */
637		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(S14001AChip); break;
638
639		/* --- the following bits of info are returned as pointers to data or functions --- */
640		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( s14001a ); break;
641
642		/* --- the following bits of info are returned as NULL-terminated strings --- */
643		case DEVINFO_STR_NAME: strcpy(info->s, "S14001A"); break;
644		case DEVINFO_STR_FAMILY: strcpy(info->s, "TSI S14001A"); break;
645		case DEVINFO_STR_VERSION: strcpy(info->s, "1.32"); break;
646		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
647		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Jonathan Gevaryahu"); break;
648		}
649		}
650
651	632	const device_type S14001A = &device_creator<s14001a_device>;
652	633
653	634	s14001a_device::s14001a_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/gaelco.c
r17616	r17617
284	284	}
285	285
286	286
287
288
289		/**************************************************************************
290		* Generic get_info
291		**************************************************************************/
292
293		DEVICE_GET_INFO( gaelco_gae1 )
294		{
295		switch (state)
296		{
297		/* --- the following bits of info are returned as 64-bit signed integers --- */
298		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gaelco_sound_state); break;
299
300		/* --- the following bits of info are returned as pointers to data or functions --- */
301		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( gaelco ); break;
302		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( gaelco ); break;
303		case DEVINFO_FCT_RESET: /* nothing */ break;
304
305		/* --- the following bits of info are returned as NULL-terminated strings --- */
306		case DEVINFO_STR_NAME: strcpy(info->s, "Gaelco GAE1"); break;
307		case DEVINFO_STR_FAMILY: strcpy(info->s, "Gaelco custom"); break;
308		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
309		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
310		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
311		}
312		}
313
314
315
316		/**************************************************************************
317		* Generic get_info
318		**************************************************************************/
319
320		DEVICE_GET_INFO( gaelco_cg1v )
321		{
322		switch (state)
323		{
324		/* --- the following bits of info are returned as 64-bit signed integers --- */
325		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gaelco_sound_state); break;
326
327		/* --- the following bits of info are returned as pointers to data or functions --- */
328		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( gaelco ); break;
329		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( gaelco ); break;
330		case DEVINFO_FCT_RESET: /* nothing */ break;
331
332		/* --- the following bits of info are returned as NULL-terminated strings --- */
333		case DEVINFO_STR_NAME: strcpy(info->s, "Gaelco CG1V"); break;
334		case DEVINFO_STR_FAMILY: strcpy(info->s, "Gaelco custom"); break;
335		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
336		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
337		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
338		}
339		}
340
341
342	287	const device_type GAELCO_GAE1 = &device_creator<gaelco_gae1_device>;
343	288
344	289	gaelco_gae1_device::gaelco_gae1_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/dmadac.c
r17616	r17617
234	234	}
235	235	}
236	236
237
238
239		/**************************************************************************
240		* Generic get_info
241		**************************************************************************/
242
243		DEVICE_GET_INFO( dmadac_sound )
244		{
245		switch (state)
246		{
247		/* --- the following bits of info are returned as 64-bit signed integers --- */
248		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(dmadac_state); break;
249
250		/* --- the following bits of info are returned as pointers to data or functions --- */
251		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( dmadac ); break;
252		case DEVINFO_FCT_STOP: /* nothing */ break;
253		case DEVINFO_FCT_RESET: /* nothing */ break;
254
255		/* --- the following bits of info are returned as NULL-terminated strings --- */
256		case DEVINFO_STR_NAME: strcpy(info->s, "DMA-driven DAC"); break;
257		case DEVINFO_STR_FAMILY: strcpy(info->s, "DAC"); break;
258		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
259		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
260		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
261		}
262		}
263
264
265	237	const device_type DMADAC = &device_creator<dmadac_sound_device>;
266	238
267	239	dmadac_sound_device::dmadac_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2608intf.c
r17616	r17617
204	204	WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w ) { ym2608_w(device, 1, data); }
205	205	WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w ) { ym2608_w(device, 3, data); }
206	206
207
208
209		/**************************************************************************
210		* Generic get_info
211		**************************************************************************/
212
213		DEVICE_GET_INFO( ym2608 )
214		{
215		switch (state)
216		{
217		/* --- the following bits of info are returned as 64-bit signed integers --- */
218		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2608_state); break;
219
220		/* --- the following bits of info are returned as pointers to data or functions --- */
221		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2608 ); break;
222		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2608 ); break;
223		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2608 ); break;
224
225		/* --- the following bits of info are returned as NULL-terminated strings --- */
226		case DEVINFO_STR_NAME: strcpy(info->s, "YM2608"); break;
227		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
228		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
229		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
230		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
231		}
232		}
233
234
235	207	const device_type YM2608 = &device_creator<ym2608_device>;
236	208
237	209	ym2608_device::ym2608_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/s2636.c
r17616	r17617
82	82	token->channel = device->machine().sound().stream_alloc(*device, 0, 1, device->machine().sample_rate(), 0, s2636_update);
83	83	}
84	84
85
86		DEVICE_GET_INFO( s2636_sound )
87		{
88		switch (state)
89		{
90		/* --- the following bits of info are returned as 64-bit signed integers --- */
91		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(s2636_sound); break;
92
93		/* --- the following bits of info are returned as pointers to data or functions --- */
94		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(s2636_sound); break;
95
96		/* --- the following bits of info are returned as NULL-terminated strings --- */
97		case DEVINFO_STR_NAME: strcpy(info->s, "S2636"); break;
98		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
99		}
100		}
101
102	85	const device_type S2636_SOUND = &device_creator<s2636_sound_device>;
103	86
104	87	s2636_sound_device::s2636_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/okim6376.c
r17616	r17617
619	619	}
620	620
621	621
622
623		/**************************************************************************
624		* Generic get_info
625		**************************************************************************/
626
627		DEVICE_GET_INFO( okim6376 )
628		{
629		switch (state)
630		{
631		/* --- the following bits of info are returned as 64-bit signed integers --- */
632		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(okim6376_state); break;
633
634		/* --- the following bits of info are returned as pointers to data or functions --- */
635		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( okim6376 ); break;
636		case DEVINFO_FCT_STOP: /* nothing */ break;
637		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( okim6376 ); break;
638
639		/* --- the following bits of info are returned as NULL-terminated strings --- */
640		case DEVINFO_STR_NAME: strcpy(info->s, "OKI6376"); break;
641		case DEVINFO_STR_FAMILY: strcpy(info->s, "OKI ADPCM"); break;
642		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
643		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
644		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
645		}
646		}
647
648
649	622	const device_type OKIM6376 = &device_creator<okim6376_device>;
650	623
651	624	okim6376_device::okim6376_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/zsg2.c
r17616	r17617
231	231	info->bank_samples = device->machine().root_device().memregion(intf->samplergn)->base();
232	232	}
233	233
234		/**************************************************************************
235		* Generic get_info
236		**************************************************************************/
237
238		DEVICE_GET_INFO( zsg2 )
239		{
240		switch (state)
241		{
242		/* --- the following bits of info are returned as 64-bit signed integers --- */
243		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(zsg2_state); break;
244
245		/* --- the following bits of info are returned as pointers to data or functions --- */
246		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( zsg2 ); break;
247		case DEVINFO_FCT_STOP: /* nothing */ break;
248		case DEVINFO_FCT_RESET: /* nothing */ break;
249
250		/* --- the following bits of info are returned as NULL-terminated strings --- */
251		case DEVINFO_STR_NAME: strcpy(info->s, "ZSG-2"); break;
252		case DEVINFO_STR_FAMILY: strcpy(info->s, "Zoom custom"); break;
253		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
254		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
255		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
256		}
257		}
258
259
260	234	const device_type ZSG2 = &device_creator<zsg2_device>;
261	235
262	236	zsg2_device::zsg2_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/es5506.c
r17616	r17617
2153	2153	chip->voice[voice].exbank=bank;
2154	2154	}
2155	2155
2156
2157
2158		/**************************************************************************
2159		* Generic get_info
2160		**************************************************************************/
2161
2162		DEVICE_GET_INFO( es5505 )
2163		{
2164		switch (state)
2165		{
2166		/* --- the following bits of info are returned as 64-bit signed integers --- */
2167		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(es5506_state); break;
2168
2169		/* --- the following bits of info are returned as pointers to data or functions --- */
2170		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( es5505 ); break;
2171		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( es5505 ); break;
2172		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( es5505 ); break;
2173
2174		/* --- the following bits of info are returned as NULL-terminated strings --- */
2175		case DEVINFO_STR_NAME: strcpy(info->s, "ES5505"); break;
2176		case DEVINFO_STR_FAMILY: strcpy(info->s, "Ensoniq Wavetable"); break;
2177		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
2178		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2179		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
2180		}
2181		}
2182
2183
2184		/**************************************************************************
2185		* Generic get_info
2186		**************************************************************************/
2187
2188		DEVICE_GET_INFO( es5506 )
2189		{
2190		switch (state)
2191		{
2192		/* --- the following bits of info are returned as 64-bit signed integers --- */
2193		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(es5506_state); break;
2194
2195		/* --- the following bits of info are returned as pointers to data or functions --- */
2196		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( es5506 ); break;
2197		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( es5506 ); break;
2198		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( es5506 ); break;
2199
2200		/* --- the following bits of info are returned as NULL-terminated strings --- */
2201		case DEVINFO_STR_NAME: strcpy(info->s, "ES5506"); break;
2202		case DEVINFO_STR_FAMILY: strcpy(info->s, "Ensoniq Wavetable"); break;
2203		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
2204		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2205		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
2206		}
2207		}
2208
2209
2210	2156	const device_type ES5505 = &device_creator<es5505_device>;
2211	2157
2212	2158	es5505_device::es5505_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
r17616	r17617
2216	2162	m_token = global_alloc_array_clear(UINT8, sizeof(es5506_state));
2217	2163	}
2218	2164
	2165	es5505_device::es5505_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
	2166	: device_t(mconfig, type, name, tag, owner, clock),
	2167	device_sound_interface(mconfig, *this)
	2168	{
	2169	m_token = global_alloc_array_clear(UINT8, sizeof(es5506_state));
	2170	}
	2171
2219	2172	//-------------------------------------------------
2220	2173	// device_config_complete - perform any
2221	2174	// operations now that the configuration is
r17616	r17617
2267	2220	const device_type ES5506 = &device_creator<es5506_device>;
2268	2221
2269	2222	es5506_device::es5506_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)
2270		: device_t(mconfig, ES5506, "ES5506", tag, owner, clock),
2271		device_sound_interface(mconfig, *this)
	2223	: es5505_device(mconfig, ES5506, "ES5506", tag, owner, clock)
2272	2224	{
2273		m_token = global_alloc_array_clear(UINT8, sizeof(es5506_state));
2274	2225	}
2275	2226
2276	2227	//-------------------------------------------------

trunk/src/emu/sound/es5506.h
r17616	r17617
30	30	{
31	31	public:
32	32	es5505_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
	33	es5505_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock);
33	34	~es5505_device() { global_free(m_token); }
34	35
35	36	// access to legacy token
r17616	r17617
67	68	WRITE8_DEVICE_HANDLER( es5506_w );
68	69	void es5506_voice_bank_w(device_t *device, int voice, int bank);
69	70
70		class es5506_device : public device_t,
71		public device_sound_interface
	71	class es5506_device : public es5505_device
72	72	{
73	73	public:
74	74	es5506_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock);
75		~es5506_device() { global_free(m_token); }
76
77		// access to legacy token
78		void *token() const { assert(m_token != NULL); return m_token; }
79	75	protected:
80	76	// device-level overrides
81	77	virtual void device_config_complete();
r17616	r17617
87	83	virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
88	84	private:
89	85	// internal state
90		void *m_token;
91	86	};
92	87
93	88	extern const device_type ES5506;

trunk/src/emu/sound/ymf278b.c
r17616	r17617
1085	1085	}
1086	1086
1087	1087
1088		/**************************************************************************
1089		* Generic get_info
1090		**************************************************************************/
1091
1092		DEVICE_GET_INFO( ymf278b )
1093		{
1094		switch (state)
1095		{
1096		/* --- the following bits of info are returned as 64-bit signed integers --- */
1097		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(YMF278BChip); break;
1098
1099		/* --- the following bits of info are returned as pointers to data or functions --- */
1100		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ymf278b ); break;
1101		case DEVINFO_FCT_STOP: /* Nothing */ break;
1102		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME( ymf278b ); break;
1103
1104		/* --- the following bits of info are returned as NULL-terminated strings --- */
1105		case DEVINFO_STR_NAME: strcpy(info->s, "YMF278B"); break;
1106		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
1107		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1108		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1109		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1110		}
1111		}
1112
1113
1114	1088	const device_type YMF278B = &device_creator<ymf278b_device>;
1115	1089
1116	1090	ymf278b_device::ymf278b_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/sid6581.c
r17616	r17617
83	83	sid6581_port_w(get_sid(device), offset, data);
84	84	}
85	85
86
87
88		/**************************************************************************
89		* Generic get_info
90		**************************************************************************/
91
92		DEVICE_GET_INFO( sid6581 )
93		{
94		switch (state)
95		{
96		/* --- the following bits of info are returned as 64-bit signed integers --- */
97		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(_SID6581); break;
98
99		/* --- the following bits of info are returned as pointers to data or functions --- */
100		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sid6581 ); break;
101		case DEVINFO_FCT_STOP: info->stop = NULL; break;
102		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( sid ); break;
103
104		/* --- the following bits of info are returned as NULL-terminated strings --- */
105		case DEVINFO_STR_NAME: strcpy(info->s, "SID6581"); break;
106		case DEVINFO_STR_FAMILY: strcpy(info->s, "SID"); break;
107		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
108		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
109		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright The MESS Team"); break;
110		}
111		}
112
113
114		DEVICE_GET_INFO( sid8580 )
115		{
116		switch (state)
117		{
118		/* --- the following bits of info are returned as pointers to data or functions --- */
119		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sid8580 ); break;
120
121		/* --- the following bits of info are returned as NULL-terminated strings --- */
122		case DEVINFO_STR_NAME: strcpy(info->s, "SID8580"); break;
123		default: DEVICE_GET_INFO_CALL(sid6581); break;
124		}
125		}
126
127
128	86	const device_type SID6581 = &device_creator<sid6581_device>;
129	87
130	88	sid6581_device::sid6581_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/flt_vol.c
r17616	r17617
44	44	info->gain = (int)(volume * 256);
45	45	}
46	46
47
48
49		/**************************************************************************
50		* Generic get_info
51		**************************************************************************/
52
53		DEVICE_GET_INFO( filter_volume )
54		{
55		switch (state)
56		{
57		/* --- the following bits of info are returned as 64-bit signed integers --- */
58		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(filter_volume_state); break;
59
60		/* --- the following bits of info are returned as pointers to data or functions --- */
61		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( filter_volume ); break;
62		case DEVINFO_FCT_STOP: /* Nothing */ break;
63		case DEVINFO_FCT_RESET: /* Nothing */ break;
64
65		/* --- the following bits of info are returned as NULL-terminated strings --- */
66		case DEVINFO_STR_NAME: strcpy(info->s, "Volume Filter"); break;
67		case DEVINFO_STR_FAMILY: strcpy(info->s, "Filters"); break;
68		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
69		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
70		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
71		}
72		}
73
74
75	47	const device_type FILTER_VOLUME = &device_creator<filter_volume_device>;
76	48
77	49	filter_volume_device::filter_volume_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2151intf.c
r17616	r17617
119	119	WRITE8_DEVICE_HANDLER( ym2151_data_port_w ) { ym2151_w(device, 1, data); }
120	120
121	121
122
123		/**************************************************************************
124		* Generic get_info
125		**************************************************************************/
126
127		DEVICE_GET_INFO( ym2151 )
128		{
129		switch (state)
130		{
131		/* --- the following bits of info are returned as 64-bit signed integers --- */
132		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2151_state); break;
133
134		/* --- the following bits of info are returned as pointers to data or functions --- */
135		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2151 ); break;
136		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2151 ); break;
137		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2151 ); break;
138
139		/* --- the following bits of info are returned as NULL-terminated strings --- */
140		case DEVINFO_STR_NAME: strcpy(info->s, "YM2151"); break;
141		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
142		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
143		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
144		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
145		}
146		}
147
148
149	122	const device_type YM2151 = &device_creator<ym2151_device>;
150	123
151	124	ym2151_device::ym2151_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/k053260.c
r17616	r17617
437	437	return ic->regs[offset];
438	438	}
439	439
440		/**************************************************************************
441		* Generic get_info
442		**************************************************************************/
443
444		DEVICE_GET_INFO( k053260 )
445		{
446		switch (state)
447		{
448		/* --- the following bits of info are returned as 64-bit signed integers --- */
449		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053260_state); break;
450
451		/* --- the following bits of info are returned as pointers to data or functions --- */
452		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k053260 ); break;
453		case DEVINFO_FCT_STOP: /* nothing */ break;
454		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( k053260 ); break;
455
456		/* --- the following bits of info are returned as NULL-terminated strings --- */
457		case DEVINFO_STR_NAME: strcpy(info->s, "K053260"); break;
458		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami custom"); break;
459		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
460		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
461		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
462		}
463		}
464
465
466	440	const device_type K053260 = &device_creator<k053260_device>;
467	441
468	442	k053260_device::k053260_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2413intf.c
r17616	r17617
115	115	WRITE8_DEVICE_HANDLER( ym2413_register_port_w ) { ym2413_w(device, 0, data); }
116	116	WRITE8_DEVICE_HANDLER( ym2413_data_port_w ) { ym2413_w(device, 1, data); }
117	117
118
119		/**************************************************************************
120		* Generic get_info
121		**************************************************************************/
122
123		DEVICE_GET_INFO( ym2413 )
124		{
125		switch (state)
126		{
127		/* --- the following bits of info are returned as 64-bit signed integers --- */
128		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2413_state); break;
129
130		/* --- the following bits of info are returned as pointers to data or functions --- */
131		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2413 ); break;
132		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2413 ); break;
133		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2413 ); break;
134
135		/* --- the following bits of info are returned as NULL-terminated strings --- */
136		case DEVINFO_STR_NAME: strcpy(info->s, "YM2413"); break;
137		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
138		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
139		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
140		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
141		}
142		}
143
144
145	118	const device_type YM2413 = &device_creator<ym2413_device>;
146	119
147	120	ym2413_device::ym2413_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/segapcm.c
r17616	r17617
148	148	return spcm->ram[offset & 0x07ff];
149	149	}
150	150
151
152
153		/**************************************************************************
154		* Generic get_info
155		**************************************************************************/
156
157		DEVICE_GET_INFO( segapcm )
158		{
159		switch (state)
160		{
161		/* --- the following bits of info are returned as 64-bit signed integers --- */
162		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(segapcm_state); break;
163
164		/* --- the following bits of info are returned as pointers to data or functions --- */
165		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( segapcm ); break;
166		case DEVINFO_FCT_STOP: /* Nothing */ break;
167		case DEVINFO_FCT_RESET: /* Nothing */ break;
168
169		/* --- the following bits of info are returned as NULL-terminated strings --- */
170		case DEVINFO_STR_NAME: strcpy(info->s, "Sega PCM"); break;
171		case DEVINFO_STR_FAMILY: strcpy(info->s, "Sega custom"); break;
172		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
173		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
174		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
175		}
176		}
177
178
179	151	const device_type SEGAPCM = &device_creator<segapcm_device>;
180	152
181	153	segapcm_device::segapcm_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/vrender0.c
r17616	r17617
239	239	}
240	240
241	241
242
243
244		/**************************************************************************
245		* Generic get_info
246		**************************************************************************/
247
248		DEVICE_GET_INFO( vrender0 )
249		{
250		switch (state)
251		{
252		/* --- the following bits of info are returned as 64-bit signed integers --- */
253		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vr0_state); break;
254
255		/* --- the following bits of info are returned as pointers to data or functions --- */
256		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( vrender0 ); break;
257		case DEVINFO_FCT_STOP: /* Nothing */ break;
258		case DEVINFO_FCT_RESET: /* Nothing */ break;
259
260		/* --- the following bits of info are returned as NULL-terminated strings --- */
261		case DEVINFO_STR_NAME: strcpy(info->s, "VRender0"); break;
262		case DEVINFO_STR_FAMILY: strcpy(info->s, "???"); break;
263		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
264		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
265		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
266		}
267		}
268
269
270	242	const device_type VRENDER0 = &device_creator<vrender0_device>;
271	243
272	244	vrender0_device::vrender0_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/8950intf.c
r17616	r17617
174	174	WRITE8_DEVICE_HANDLER( y8950_write_port_w ) { y8950_w(device, 1, data); }
175	175
176	176
177		/**************************************************************************
178		* Generic get_info
179		**************************************************************************/
180
181		DEVICE_GET_INFO( y8950 )
182		{
183		switch (state)
184		{
185		/* --- the following bits of info are returned as 64-bit signed integers --- */
186		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(y8950_state); break;
187
188		/* --- the following bits of info are returned as pointers to data or functions --- */
189		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( y8950 ); break;
190		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( y8950 ); break;
191		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( y8950 ); break;
192
193		/* --- the following bits of info are returned as NULL-terminated strings --- */
194		case DEVINFO_STR_NAME: strcpy(info->s, "Y8950"); break;
195		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
196		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
197		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
198		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
199		}
200		}
201
202
203	177	const device_type Y8950 = &device_creator<y8950_device>;
204	178
205	179	y8950_device::y8950_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/t6w28.c
r17616	r17617
365	365	device->save_item(NAME(chip->Output));
366	366	}
367	367
368
369		/**************************************************************************
370		* Generic get_info
371		**************************************************************************/
372
373		DEVICE_GET_INFO( t6w28 )
374		{
375		switch (state)
376		{
377		/* --- the following bits of info are returned as 64-bit signed integers --- */
378		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(t6w28_state); break;
379
380		/* --- the following bits of info are returned as pointers to data or functions --- */
381		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( t6w28 ); break;
382		case DEVINFO_FCT_STOP: /* Nothing */ break;
383		case DEVINFO_FCT_RESET: /* Nothing */ break;
384
385		/* --- the following bits of info are returned as NULL-terminated strings --- */
386		case DEVINFO_STR_NAME: strcpy(info->s, "T6W28"); break;
387		case DEVINFO_STR_FAMILY: strcpy(info->s, "PSG"); break;
388		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
389		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
390		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
391		}
392		}
393
394
395	368	const device_type T6W28 = &device_creator<t6w28_device>;
396	369
397	370	t6w28_device::t6w28_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/multipcm.c
r17616	r17617
673	673	}
674	674
675	675
676
677		/**************************************************************************
678		* Generic get_info
679		**************************************************************************/
680
681		DEVICE_GET_INFO( multipcm )
682		{
683		switch (state)
684		{
685		/* --- the following bits of info are returned as 64-bit signed integers --- */
686		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(MultiPCM); break;
687
688		/* --- the following bits of info are returned as pointers to data or functions --- */
689		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( multipcm ); break;
690		case DEVINFO_FCT_STOP: /* Nothing */ break;
691		case DEVINFO_FCT_RESET: /* Nothing */ break;
692
693		/* --- the following bits of info are returned as NULL-terminated strings --- */
694		case DEVINFO_STR_NAME: strcpy(info->s, "Sega/Yamaha 315-5560"); break;
695		case DEVINFO_STR_FAMILY: strcpy(info->s, "Sega custom"); break;
696		case DEVINFO_STR_VERSION: strcpy(info->s, "2.0"); break;
697		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
698		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
699		}
700		}
701
702
703	676	const device_type MULTIPCM = &device_creator<multipcm_device>;
704	677
705	678	multipcm_device::multipcm_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/namco.c
r17616	r17617
812	812	}
813	813	}
814	814
815
816
817
818		/**************************************************************************
819		* Generic get_info
820		**************************************************************************/
821
822		DEVICE_GET_INFO( namco )
823		{
824		switch (state)
825		{
826		/* --- the following bits of info are returned as 64-bit signed integers --- */
827		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_sound); break;
828
829		/* --- the following bits of info are returned as pointers to data or functions --- */
830		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( namco ); break;
831		case DEVINFO_FCT_STOP: /* Nothing */ break;
832		case DEVINFO_FCT_RESET: /* Nothing */ break;
833
834		/* --- the following bits of info are returned as NULL-terminated strings --- */
835		case DEVINFO_STR_NAME: strcpy(info->s, "Namco"); break;
836		case DEVINFO_STR_FAMILY: strcpy(info->s, "Namco custom"); break;
837		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
838		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
839		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
840		}
841		}
842
843		/**************************************************************************
844		* Generic get_info
845		**************************************************************************/
846
847		DEVICE_GET_INFO( namco_15xx )
848		{
849		switch (state)
850		{
851		/* --- the following bits of info are returned as 64-bit signed integers --- */
852		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_sound); break;
853
854		/* --- the following bits of info are returned as pointers to data or functions --- */
855		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( namco ); break;
856		case DEVINFO_FCT_STOP: /* Nothing */ break;
857		case DEVINFO_FCT_RESET: /* Nothing */ break;
858
859		/* --- the following bits of info are returned as NULL-terminated strings --- */
860		case DEVINFO_STR_NAME: strcpy(info->s, "Namco 15XX"); break;
861		case DEVINFO_STR_FAMILY: strcpy(info->s, "Namco custom"); break;
862		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
863		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
864		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
865		}
866		}
867
868		/**************************************************************************
869		* Generic get_info
870		**************************************************************************/
871
872		DEVICE_GET_INFO( namco_cus30 )
873		{
874		switch (state)
875		{
876		/* --- the following bits of info are returned as 64-bit signed integers --- */
877		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(namco_sound); break;
878
879		/* --- the following bits of info are returned as pointers to data or functions --- */
880		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( namco ); break;
881		case DEVINFO_FCT_STOP: /* Nothing */ break;
882		case DEVINFO_FCT_RESET: /* Nothing */ break;
883
884		/* --- the following bits of info are returned as NULL-terminated strings --- */
885		case DEVINFO_STR_NAME: strcpy(info->s, "Namco CUS30"); break;
886		case DEVINFO_STR_FAMILY: strcpy(info->s, "Namco custom"); break;
887		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
888		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
889		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
890		}
891		}
892
893
894	815	const device_type NAMCO = &device_creator<namco_device>;
895	816
896	817	namco_device::namco_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/sn76477.c
r17616	r17617
2467	2467	close_wav_file(sn);
2468	2468	}
2469	2469
2470
2471		DEVICE_GET_INFO( sn76477 )
2472		{
2473		switch (state)
2474		{
2475		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(sn76477_state); break;
2476		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( sn76477 ); break;
2477		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( sn76477 ); break;
2478		case DEVINFO_STR_NAME: strcpy(info->s, "SN76477"); break;
2479		case DEVINFO_STR_FAMILY: strcpy(info->s, "Analog"); break;
2480		case DEVINFO_STR_VERSION: strcpy(info->s, "2.1"); break;
2481		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2482		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
2483		}
2484		}
2485
2486
2487	2470	const device_type SN76477 = &device_creator<sn76477_device>;
2488	2471
2489	2472	sn76477_device::sn76477_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/vlm5030.c
r17616	r17617
688	688	device->machine().save().register_postload(save_prepost_delegate(FUNC(vlm5030_restore_state), chip));
689	689	}
690	690
691
692		/**************************************************************************
693		* Generic get_info
694		**************************************************************************/
695
696		DEVICE_GET_INFO( vlm5030 )
697		{
698		switch (state)
699		{
700		/* --- the following bits of info are returned as 64-bit signed integers --- */
701		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vlm5030_state); break;
702
703		/* --- the following bits of info are returned as pointers to data or functions --- */
704		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( vlm5030 ); break;
705		case DEVINFO_FCT_STOP: /* Nothing */ break;
706		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( vlm5030 ); break;
707
708		/* --- the following bits of info are returned as NULL-terminated strings --- */
709		case DEVINFO_STR_NAME: strcpy(info->s, "VLM5030"); break;
710		case DEVINFO_STR_FAMILY: strcpy(info->s, "VLM speech"); break;
711		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
712		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
713		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
714		}
715		}
716
717
718	691	const device_type VLM5030 = &device_creator<vlm5030_device>;
719	692
720	693	vlm5030_device::vlm5030_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/2203intf.c
r17616	r17617
181	181	WRITE8_DEVICE_HANDLER( ym2203_control_port_w ) { ym2203_w(device, 0, data); }
182	182	WRITE8_DEVICE_HANDLER( ym2203_write_port_w ) { ym2203_w(device, 1, data); }
183	183
184
185		/**************************************************************************
186		* Generic get_info
187		**************************************************************************/
188
189		DEVICE_GET_INFO( ym2203 )
190		{
191		switch (state)
192		{
193		/* --- the following bits of info are returned as 64-bit signed integers --- */
194		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ym2203_state); break;
195
196		/* --- the following bits of info are returned as pointers to data or functions --- */
197		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ym2203 ); break;
198		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ym2203 ); break;
199		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ym2203 ); break;
200
201		/* --- the following bits of info are returned as NULL-terminated strings --- */
202		case DEVINFO_STR_NAME: strcpy(info->s, "YM2203"); break;
203		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
204		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
205		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
206		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
207		}
208		}
209
210
211	184	const device_type YM2203 = &device_creator<ym2203_device>;
212	185
213	186	ym2203_device::ym2203_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/k007232.c
r17616	r17617
443	443
444	444	/*****************************************************************************/
445	445
446
447
448
449
450		/**************************************************************************
451		* Generic get_info
452		**************************************************************************/
453
454		DEVICE_GET_INFO( k007232 )
455		{
456		switch (state)
457		{
458		/* --- the following bits of info are returned as 64-bit signed integers --- */
459		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(KDAC_A_PCM); break;
460
461		/* --- the following bits of info are returned as pointers to data or functions --- */
462		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k007232 ); break;
463		case DEVINFO_FCT_STOP: /* nothing */ break;
464		case DEVINFO_FCT_RESET: /* nothing */ break;
465
466		/* --- the following bits of info are returned as NULL-terminated strings --- */
467		case DEVINFO_STR_NAME: strcpy(info->s, "K007232"); break;
468		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami custom"); break;
469		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
470		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
471		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
472		}
473		}
474
475
476	446	const device_type K007232 = &device_creator<k007232_device>;
477	447
478	448	k007232_device::k007232_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/tms5220.c
r17616	r17617
2004	2004	tms->clock = frequency;
2005	2005	}
2006	2006
2007
2008
2009		/*-------------------------------------------------
2010		device definition
2011		-------------------------------------------------*/
2012
2013		DEVICE_GET_INFO(tms5220)
2014		{
2015		switch (state)
2016		{
2017		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms5220_state); break;
2018
2019		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5220); break;
2020
2021		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tms5220); break;
2022
2023		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5220"); break;
2024		}
2025		}
2026
2027		DEVICE_GET_INFO(tms5220c)
2028		{
2029		switch (state)
2030		{
2031		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5220c); break;
2032
2033		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5220C"); break;
2034		default: DEVICE_GET_INFO_CALL(tms5220); break;
2035		}
2036		}
2037
2038		DEVICE_GET_INFO(tmc0285)
2039		{
2040		switch (state)
2041		{
2042		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tmc0285); break;
2043
2044		case DEVINFO_STR_NAME: strcpy(info->s, "TMC0285"); break;
2045		default: DEVICE_GET_INFO_CALL(tms5220); break;
2046		}
2047		}
2048
2049		DEVICE_GET_INFO(tms5200)
2050		{
2051		switch (state)
2052		{
2053		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms5200); break;
2054
2055		case DEVINFO_STR_NAME: strcpy(info->s, "TMS5200"); break;
2056		default: DEVICE_GET_INFO_CALL(tms5220); break;
2057		}
2058		}
2059
2060	2007	const device_type TMS5220C = &device_creator<tms5220c_device>;
2061	2008
2062	2009	tms5220c_device::tms5220c_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/okim6258.c
r17616	r17617
353	353	}
354	354
355	355
356
357
358		/**************************************************************************
359		* Generic get_info
360		**************************************************************************/
361
362		DEVICE_GET_INFO( okim6258 )
363		{
364		switch (state)
365		{
366		/* --- the following bits of info are returned as 64-bit signed integers --- */
367		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(okim6258_state); break;
368
369		/* --- the following bits of info are returned as pointers to data or functions --- */
370		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(okim6258); break;
371		case DEVINFO_FCT_STOP: /* nothing */ break;
372		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(okim6258); break;
373
374		/* --- the following bits of info are returned as NULL-terminated strings --- */
375		case DEVINFO_STR_NAME: strcpy(info->s, "OKI6258"); break;
376		case DEVINFO_STR_FAMILY: strcpy(info->s, "OKI ADPCM"); break;
377		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
378		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
379		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
380		}
381		}
382
383
384	356	const device_type OKIM6258 = &device_creator<okim6258_device>;
385	357
386	358	okim6258_device::okim6258_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/nile.c
r17616	r17617
230	230	info->stream = device->machine().sound().stream_alloc(*device, 0, 2, 44100, info, nile_update);
231	231	}
232	232
233
234
235		/**************************************************************************
236		* Generic get_info
237		**************************************************************************/
238
239		DEVICE_GET_INFO( nile )
240		{
241		switch (state)
242		{
243		/* --- the following bits of info are returned as 64-bit signed integers --- */
244		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(nile_state); break;
245
246		/* --- the following bits of info are returned as pointers to data or functions --- */
247		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( nile ); break;
248		case DEVINFO_FCT_STOP: /* Nothing */ break;
249		case DEVINFO_FCT_RESET: /* Nothing */ break;
250
251		/* --- the following bits of info are returned as NULL-terminated strings --- */
252		case DEVINFO_STR_NAME: strcpy(info->s, "NiLe"); break;
253		case DEVINFO_STR_FAMILY: strcpy(info->s, "Seta custom"); break;
254		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
255		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
256		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
257		}
258		}
259
260
261	233	const device_type NILE = &device_creator<nile_device>;
262	234
263	235	nile_device::nile_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/es8712.c
r17616	r17617
379	379	chip->start &= 0xfffff; chip->end &= 0xfffff;
380	380	}
381	381
382
383
384		/**************************************************************************
385		* Generic get_info
386		**************************************************************************/
387
388		DEVICE_GET_INFO( es8712 )
389		{
390		switch (state)
391		{
392		/* --- the following bits of info are returned as 64-bit signed integers --- */
393		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(es8712_state); break;
394
395		/* --- the following bits of info are returned as pointers to data or functions --- */
396		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( es8712 ); break;
397		case DEVINFO_FCT_STOP: /* nothing */ break;
398		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( es8712 ); break;
399
400		/* --- the following bits of info are returned as NULL-terminated strings --- */
401		case DEVINFO_STR_NAME: strcpy(info->s, "ES8712"); break;
402		case DEVINFO_STR_FAMILY: strcpy(info->s, "Excellent Systems ADPCM"); break;
403		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
404		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
405		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
406		}
407		}
408
409
410	382	const device_type ES8712 = &device_creator<es8712_device>;
411	383
412	384	es8712_device::es8712_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/nes_apu.c
r17616	r17617
765	765	#endif
766	766	}
767	767
768
769		/**************************************************************************
770		* Generic get_info
771		**************************************************************************/
772
773		DEVICE_GET_INFO( nesapu )
774		{
775		switch (state)
776		{
777		/* --- the following bits of info are returned as 64-bit signed integers --- */
778		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(nesapu_state); break;
779
780		/* --- the following bits of info are returned as pointers to data or functions --- */
781		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( nesapu ); break;
782		case DEVINFO_FCT_STOP: /* Nothing */ break;
783		case DEVINFO_FCT_RESET: /* Nothing */ break;
784
785		/* --- the following bits of info are returned as NULL-terminated strings --- */
786		case DEVINFO_STR_NAME: strcpy(info->s, "N2A03"); break;
787		case DEVINFO_STR_FAMILY: strcpy(info->s, "Nintendo custom"); break;
788		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
789		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
790		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
791		}
792		}
793
794
795	768	const device_type NES = &device_creator<nesapu_device>;
796	769
797	770	nesapu_device::nesapu_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/sound/262intf.c
r17616	r17617
131	131	WRITE8_DEVICE_HANDLER( ymf262_data_a_w ) { ymf262_w(device, 1, data); }
132	132	WRITE8_DEVICE_HANDLER( ymf262_data_b_w ) { ymf262_w(device, 3, data); }
133	133
134
135		/**************************************************************************
136		* Generic get_info
137		**************************************************************************/
138
139		DEVICE_GET_INFO( ymf262 )
140		{
141		switch (state)
142		{
143		/* --- the following bits of info are returned as 64-bit signed integers --- */
144		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ymf262_state); break;
145
146		/* --- the following bits of info are returned as pointers to data or functions --- */
147		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( ymf262 ); break;
148		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( ymf262 ); break;
149		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ymf262 ); break;
150
151		/* --- the following bits of info are returned as NULL-terminated strings --- */
152		case DEVINFO_STR_NAME: strcpy(info->s, "YMF262"); break;
153		case DEVINFO_STR_FAMILY: strcpy(info->s, "Yamaha FM"); break;
154		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
155		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
156		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
157		}
158		}
159
160
161	134	const device_type YMF262 = &device_creator<ymf262_device>;
162	135
163	136	ymf262_device::ymf262_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/devlegcy.h
r17616	r17617
135	135	// MACROS
136	136	//**************************************************************************
137	137
138		// macro for declaring the configuration and device classes of a legacy device
139		#define _DECLARE_LEGACY_DEVICE(name, basename, deviceclass, basedeviceclass) \
140		\
141		DEVICE_GET_INFO( basename ); \
142		\
143		class deviceclass : public basedeviceclass \
144		{ \
145		public: \
146		deviceclass(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock); \
147		}; \
148		\
149		extern const device_type name
150
151		// macro for defining the implementation needed for configuration and device classes
152		#define _DEFINE_LEGACY_DEVICE(name, basename, deviceclass, basedeviceclass) \
153		\
154		deviceclass::deviceclass(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock) \
155		: basedeviceclass(mconfig, type, tag, owner, clock, DEVICE_GET_INFO_NAME(basename)) \
156		{ \
157		} \
158		\
159		const device_type name = &legacy_device_creator<deviceclass>
160
161	138	// this template function creates a stub which constructs a device
162	139	template<class _DeviceClass>
163	140	device_t legacy_device_creator(const machine_config &mconfig, const char tag, device_t *owner, UINT32 clock)
r17616	r17617
165	142	return global_alloc(_DeviceClass(mconfig, &legacy_device_creator<_DeviceClass>, tag, owner, clock));
166	143	}
167	144
168
169		// reduced macros that are easier to use, and map to the above two macros
170		#define DECLARE_LEGACY_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_device_base)
171		#define DECLARE_LEGACY_SOUND_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_sound_device_base)
172
173		#define DEFINE_LEGACY_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_device_base)
174		#define DEFINE_LEGACY_SOUND_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_sound_device_base)
175
176
177		// macros to wrap legacy device functions
178		#define DEVICE_GET_INFO_NAME(name) device_get_config_##name
179		#define DEVICE_GET_INFO(name) void DEVICE_GET_INFO_NAME(name)(const device_t device, UINT32 state, deviceinfo info)
180		#define DEVICE_GET_INFO_CALL(name) DEVICE_GET_INFO_NAME(name)(device, state, info)
181
182	145	#define DEVICE_START_NAME(name) device_start_##name
183	146	#define DEVICE_START(name) void DEVICE_START_NAME(name)(device_t *device)
184	147	#define DEVICE_START_CALL(name) DEVICE_START_NAME(name)(device)
r17616	r17617
195	158	// TYPE DEFINITIONS
196	159	//**************************************************************************
197	160
198		union deviceinfo;
199		class machine_config;
200	161	class device_t;
201	162
202	163	char *get_temp_string_buffer(void);
203		resource_pool &machine_get_pool(running_machine &machine);
204
205
206		// device interface function types
207		typedef void (device_get_config_func)(const device_t device, UINT32 state, deviceinfo *info);
208
209	164	typedef void (device_start_func)(device_t device);
210	165	typedef void (device_stop_func)(device_t device);
211	166	typedef void (device_reset_func)(device_t device);
212	167
213		// the actual deviceinfo union
214		union deviceinfo
215		{
216		INT64 i; // generic integers
217		void * p; // generic pointers
218		genf * f; // generic function pointers
219		char * s; // generic strings
220
221		device_start_func start; // DEVINFO_FCT_START
222		device_stop_func stop; // DEVINFO_FCT_STOP
223		device_reset_func reset; // DEVINFO_FCT_RESET
224		const rom_entry * romregion; // DEVINFO_PTR_ROM_REGION
225		machine_config_constructor machine_config; // DEVINFO_PTR_MACHINE_CONFIG
226		ioport_constructor ipt; // DEVINFO_PTR_INPUT_PORTS
227		address_map_constructor internal_map8; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
228		address_map_constructor internal_map16; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
229		address_map_constructor internal_map32; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
230		address_map_constructor internal_map64; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
231		address_map_constructor default_map8; // DEVINFO_PTR_DEFAULT_MEMORY_MAP
232		address_map_constructor default_map16; // DEVINFO_PTR_DEFAULT_MEMORY_MAP
233		address_map_constructor default_map32; // DEVINFO_PTR_DEFAULT_MEMORY_MAP
234		address_map_constructor default_map64; // DEVINFO_PTR_DEFAULT_MEMORY_MAP
235		};
236
237
238		// ======================> legacy_device_base
239
240		// legacy_device_base serves as a common base class for legacy devices
241		class legacy_device_base : public device_t
242		{
243		protected:
244		// construction/destruction
245		legacy_device_base(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock, device_get_config_func get_config);
246		virtual ~legacy_device_base();
247
248		public:
249		// access to legacy token
250		void *token() const { assert(m_token != NULL); return m_token; }
251
252		protected:
253		// device-level overrides
254		virtual const rom_entry device_rom_region() const { return reinterpret_cast<const rom_entry >(get_legacy_ptr(DEVINFO_PTR_ROM_REGION)); }
255		virtual machine_config_constructor device_mconfig_additions() const { return reinterpret_cast<machine_config_constructor>(get_legacy_ptr(DEVINFO_PTR_MACHINE_CONFIG)); }
256		virtual ioport_constructor device_input_ports() const { return reinterpret_cast<ioport_constructor>(get_legacy_ptr(DEVINFO_PTR_INPUT_PORTS)); }
257		virtual void device_start();
258		virtual void device_reset();
259		virtual void device_stop();
260
261		// access to legacy configuration info
262		INT64 get_legacy_int(UINT32 state) const;
263		void *get_legacy_ptr(UINT32 state) const;
264		genf *get_legacy_fct(UINT32 state) const;
265		const char *get_legacy_string(UINT32 state) const;
266
267		// configuration state
268		device_get_config_func m_get_config_func;
269
270		// internal state
271		void * m_token;
272		};
273
274
275
276		// ======================> legacy_sound_device_base
277
278		// legacy_sound_device is a legacy_device_base with a sound interface
279		class legacy_sound_device_base : public legacy_device_base,
280		public device_sound_interface
281		{
282		protected:
283		// construction/destruction
284		legacy_sound_device_base(const machine_config &mconfig, device_type type, const char tag, device_t owner, UINT32 clock, device_get_config_func get_config);
285
286		// sound stream update overrides
287		virtual void sound_stream_update(sound_stream &stream, stream_sample_t inputs, stream_sample_t outputs, int samples);
288		};
289
290
291
292	168	#endif /* __DEVLEGCY_H__ */

trunk/src/emu/emu.mak
r17616	r17617
57	57	$(EMUOBJ)/devcb.o \
58	58	$(EMUOBJ)/devcpu.o \
59	59	$(EMUOBJ)/device.o \
60		$(EMUOBJ)/devlegcy.o \
61	60	$(EMUOBJ)/didisasm.o \
62	61	$(EMUOBJ)/diexec.o \
63	62	$(EMUOBJ)/diimage.o \

trunk/src/emu/machine/adc1213x.c
r17616	r17617
354	354	adc1213x->acq_time = ADC1213X_ACQUISITION_TIME_10_CCLK;
355	355	}
356	356
357		/*-------------------------------------------------
358		device definition
359		-------------------------------------------------*/
360
361		DEVICE_GET_INFO(adc12138)
362		{
363		switch (state)
364		{
365		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(adc12138_state); break;
366
367		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(adc12138); break;
368
369		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(adc12138); break;
370
371		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converter 12138"); break;
372		}
373		}
374
375		DEVICE_GET_INFO(adc12130)
376		{
377		switch (state)
378		{
379		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converter 12130"); break;
380		default: DEVICE_GET_INFO_CALL(adc12138); break;
381		}
382		}
383
384		DEVICE_GET_INFO(adc12132)
385		{
386		switch (state)
387		{
388		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converter 12132"); break;
389		default: DEVICE_GET_INFO_CALL(adc12138); break;
390		}
391		}
392
393	357	const device_type ADC12130 = &device_creator<adc12130_device>;
394	358
395	359	adc12130_device::adc12130_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/74153.c
r17616	r17617
176	176	state->last_output[1] = -1;
177	177	}
178	178
179		DEVICE_GET_INFO(ttl74153)
180		{
181		switch (state)
182		{
183
184		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ttl74153_state); break;
185
186		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ttl74153); break;
187
188		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(ttl74153); break;
189
190		case DEVINFO_STR_NAME: strcpy(info->s, "74153"); break;
191		}
192		}
193
194	179	const device_type TTL74153 = &device_creator<ttl74153_device>;
195	180
196	181	ttl74153_device::ttl74153_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/tms6100.c
r17616	r17617
260	260	return tms->data;
261	261	}
262	262
263		/*-------------------------------------------------
264		TMS 6100 device definition
265		-------------------------------------------------*/
266
267		DEVICE_GET_INFO(tms6100)
268		{
269		switch (state)
270		{
271		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tms6100_state); break;
272
273		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tms6100); break;
274
275		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tms6100); break;
276
277		case DEVINFO_STR_NAME: strcpy(info->s, "TMS6100"); break;
278		}
279		}
280
281		DEVICE_GET_INFO(m58819)
282		{
283		switch (state)
284		{
285		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(m58819); break;
286		case DEVINFO_STR_NAME: strcpy(info->s, "M58819"); break;
287		default: DEVICE_GET_INFO_CALL(tms6100); break;
288		}
289		}
290
291	263	const device_type TMS6100 = &device_creator<tms6100_device>;
292	264
293	265	tms6100_device::tms6100_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/smc91c9x.c
r17616	r17617
584	584	}
585	585
586	586
587		/*-------------------------------------------------
588		device get info callback
589		-------------------------------------------------*/
590
591		static DEVICE_GET_INFO( smc91c9x )
592		{
593		switch (state)
594		{
595		/* --- the following bits of info are returned as 64-bit signed integers --- */
596		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(smc91c9x_state); break;
597
598		/* --- the following bits of info are returned as pointers to data or functions --- */
599		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(smc91c9x); break;
600		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(smc91c9x);break;
601
602		/* --- the following bits of info are returned as NULL-terminated strings --- */
603		case DEVINFO_STR_NAME: /* provided by subclasses */ break;
604		case DEVINFO_STR_FAMILY: strcpy(info->s, "SMC91C9X Ethernet Controller");break;
605		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
606		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
607		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
608		}
609		}
610
611		DEVICE_GET_INFO( smc91c94 )
612		{
613		switch (state)
614		{
615		/* --- the following bits of info are returned as NULL-terminated strings --- */
616		case DEVINFO_STR_NAME: strcpy(info->s, "SMC91C94"); break;
617		default: DEVICE_GET_INFO_CALL(smc91c9x); break;
618		}
619		}
620
621		DEVICE_GET_INFO( smc91c96 )
622		{
623		switch (state)
624		{
625		/* --- the following bits of info are returned as NULL-terminated strings --- */
626		case DEVINFO_STR_NAME: strcpy(info->s, "SMC91C96"); break;
627		default: DEVICE_GET_INFO_CALL(smc91c9x); break;
628		}
629		}
630
631	587	smc91c9x_device::smc91c9x_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
632	588	: device_t(mconfig, type, name, tag, owner, clock)
633	589	{

trunk/src/emu/machine/adc083x.c
r17616	r17617
505	505	adc083x->state = STATE_IDLE;
506	506	}
507	507
508		/*-------------------------------------------------
509		device definition
510		-------------------------------------------------*/
511
512		DEVICE_GET_INFO(adc0831)
513		{
514		switch (state)
515		{
516		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(adc0831_state); break;
517
518		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(adc0831); break;
519
520		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(adc0831); break;
521
522		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converters 0831"); break;
523		}
524		}
525
526		DEVICE_GET_INFO(adc0832)
527		{
528		switch (state)
529		{
530		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converters 0832"); break;
531		default: DEVICE_GET_INFO_CALL(adc0831); break;
532		}
533		}
534
535		DEVICE_GET_INFO(adc0834)
536		{
537		switch (state)
538		{
539		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converters 0834"); break;
540		default: DEVICE_GET_INFO_CALL(adc0831); break;
541		}
542		}
543
544		DEVICE_GET_INFO(adc0838)
545		{
546		switch (state)
547		{
548		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converters 0838"); break;
549		default: DEVICE_GET_INFO_CALL(adc0831); break;
550		}
551		}
552
553	508	const device_type ADC0831 = &device_creator<adc0831_device>;
554	509
555	510	adc0831_device::adc0831_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/pic8259.c
r17616	r17617
448	448	pic8259->master = pic8259->sp_en_func();
449	449	}
450	450
451
452		DEVICE_GET_INFO( pic8259 ) {
453		switch ( state ) {
454		/* --- the following bits of info are returned as 64-bit signed integers --- */
455		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pic8259_t); break;
456
457		/* --- the following bits of info are returned as pointers to data or functions --- */
458		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pic8259); break;
459		case DEVINFO_FCT_STOP: /* nothing */ break;
460		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pic8259); break;
461
462		/* --- the following bits of info are returned as NULL-terminated strings --- */
463		case DEVINFO_STR_NAME: strcpy(info->s, "Intel PIC8259"); break;
464		case DEVINFO_STR_FAMILY: strcpy(info->s, "PIC8259"); break;
465		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
466		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
467		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
468		}
469		}
470
471
472	451	const device_type PIC8259 = &device_creator<pic8259_device>;
473	452
474	453	pic8259_device::pic8259_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/upd4701.c
r17616	r17617
301	301	upd4701->cf = 1;
302	302	}
303	303
304		/*-------------------------------------------------
305		device definition
306		-------------------------------------------------*/
307
308		DEVICE_GET_INFO(upd4701)
309		{
310		switch (state)
311		{
312		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd4701_state); break;
313
314		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd4701); break;
315
316		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(upd4701); break;
317
318		case DEVINFO_STR_NAME: strcpy(info->s, "NEC uPD4701 Encoder"); break;
319		}
320		}
321
322	304	const device_type UPD4701 = &device_creator<upd4701_device>;
323	305
324	306	upd4701_device::upd4701_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/wd17xx.c
r17616	r17617
2099	2099	DEVICE_RESET_CALL( wd1770 );
2100	2100	}
2101	2101
2102
2103		/***************************************************************************
2104		DEVICE GETINFO
2105		***************************************************************************/
2106
2107		DEVICE_GET_INFO(wd1770)
2108		{
2109		switch (state)
2110		{
2111		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(wd1770_state); break;
2112
2113		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(wd1770); break;
2114
2115		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(wd1770); break;
2116
2117		case DEVINFO_STR_NAME: strcpy(info->s, "WD1770"); break;
2118		}
2119		}
2120
2121		DEVICE_GET_INFO(fd1771)
2122		{
2123		switch (state)
2124		{
2125		case DEVINFO_STR_NAME: strcpy(info->s, "FD1771"); break;
2126		default: DEVICE_GET_INFO_CALL(wd1770); break;
2127		}
2128		}
2129
2130		DEVICE_GET_INFO(fd1781)
2131		{
2132		switch (state)
2133		{
2134		case DEVINFO_STR_NAME: strcpy(info->s, "FD1781"); break;
2135		default: DEVICE_GET_INFO_CALL(wd1770); break;
2136		}
2137		}
2138
2139		DEVICE_GET_INFO(fd1791)
2140		{
2141		switch (state)
2142		{
2143		case DEVINFO_STR_NAME: strcpy(info->s, "FD1791"); break;
2144		default: DEVICE_GET_INFO_CALL(wd1770); break;
2145		}
2146		}
2147
2148		DEVICE_GET_INFO(fd1792)
2149		{
2150		switch (state)
2151		{
2152		case DEVINFO_STR_NAME: strcpy(info->s, "FD1792"); break;
2153		default: DEVICE_GET_INFO_CALL(wd1770); break;
2154		}
2155		}
2156
2157		DEVICE_GET_INFO(fd1793)
2158		{
2159		switch (state)
2160		{
2161		case DEVINFO_STR_NAME: strcpy(info->s, "FD1793"); break;
2162		default: DEVICE_GET_INFO_CALL(wd1770); break;
2163		}
2164		}
2165
2166		DEVICE_GET_INFO(fd1794)
2167		{
2168		switch (state)
2169		{
2170		case DEVINFO_STR_NAME: strcpy(info->s, "FD1794"); break;
2171		default: DEVICE_GET_INFO_CALL(wd1770); break;
2172		}
2173		}
2174
2175		DEVICE_GET_INFO(fd1795)
2176		{
2177		switch (state)
2178		{
2179		case DEVINFO_STR_NAME: strcpy(info->s, "FD1795"); break;
2180		default: DEVICE_GET_INFO_CALL(wd1770); break;
2181		}
2182		}
2183
2184		DEVICE_GET_INFO(fd1797)
2185		{
2186		switch (state)
2187		{
2188		case DEVINFO_STR_NAME: strcpy(info->s, "FD1797"); break;
2189		default: DEVICE_GET_INFO_CALL(wd1770); break;
2190		}
2191		}
2192
2193		DEVICE_GET_INFO(fd1761)
2194		{
2195		switch (state)
2196		{
2197		case DEVINFO_STR_NAME: strcpy(info->s, "FD1761"); break;
2198		default: DEVICE_GET_INFO_CALL(wd1770); break;
2199		}
2200		}
2201
2202		DEVICE_GET_INFO(fd1762)
2203		{
2204		switch (state)
2205		{
2206		case DEVINFO_STR_NAME: strcpy(info->s, "FD1762"); break;
2207		default: DEVICE_GET_INFO_CALL(wd1770); break;
2208		}
2209		}
2210
2211		DEVICE_GET_INFO(fd1763)
2212		{
2213		switch (state)
2214		{
2215		case DEVINFO_STR_NAME: strcpy(info->s, "FD1763"); break;
2216		default: DEVICE_GET_INFO_CALL(wd1770); break;
2217		}
2218		}
2219
2220		DEVICE_GET_INFO(fd1764)
2221		{
2222		switch (state)
2223		{
2224		case DEVINFO_STR_NAME: strcpy(info->s, "FD1764"); break;
2225		default: DEVICE_GET_INFO_CALL(wd1770); break;
2226		}
2227		}
2228
2229		DEVICE_GET_INFO(fd1765)
2230		{
2231		switch (state)
2232		{
2233		case DEVINFO_STR_NAME: strcpy(info->s, "FD1765"); break;
2234		default: DEVICE_GET_INFO_CALL(wd1770); break;
2235		}
2236		}
2237
2238		DEVICE_GET_INFO(fd1767)
2239		{
2240		switch (state)
2241		{
2242		case DEVINFO_STR_NAME: strcpy(info->s, "FD1767"); break;
2243		default: DEVICE_GET_INFO_CALL(wd1770); break;
2244		}
2245		}
2246
2247		DEVICE_GET_INFO(wd2791)
2248		{
2249		switch (state)
2250		{
2251		case DEVINFO_STR_NAME: strcpy(info->s, "WD2791"); break;
2252		default: DEVICE_GET_INFO_CALL(wd1770); break;
2253		}
2254		}
2255
2256		DEVICE_GET_INFO(wd2793)
2257		{
2258		switch (state)
2259		{
2260		case DEVINFO_STR_NAME: strcpy(info->s, "WD2793"); break;
2261		default: DEVICE_GET_INFO_CALL(wd1770); break;
2262		}
2263		}
2264
2265		DEVICE_GET_INFO(wd2795)
2266		{
2267		switch (state)
2268		{
2269		case DEVINFO_STR_NAME: strcpy(info->s, "WD2795"); break;
2270		default: DEVICE_GET_INFO_CALL(wd1770); break;
2271		}
2272		}
2273
2274		DEVICE_GET_INFO(wd2797)
2275		{
2276		switch (state)
2277		{
2278		case DEVINFO_STR_NAME: strcpy(info->s, "WD2797"); break;
2279		default: DEVICE_GET_INFO_CALL(wd1770); break;
2280		}
2281		}
2282
2283		DEVICE_GET_INFO(wd1772)
2284		{
2285		switch (state)
2286		{
2287		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(wd1772); break;
2288
2289		case DEVINFO_STR_NAME: strcpy(info->s, "WD1772"); break;
2290
2291		default: DEVICE_GET_INFO_CALL(wd1770); break;
2292		}
2293		}
2294
2295		DEVICE_GET_INFO(wd1773)
2296		{
2297		switch (state)
2298		{
2299		case DEVINFO_STR_NAME: strcpy(info->s, "WD1773"); break;
2300		default: DEVICE_GET_INFO_CALL(wd1770); break;
2301		}
2302		}
2303
2304		DEVICE_GET_INFO(mb8866)
2305		{
2306		switch (state)
2307		{
2308		case DEVINFO_STR_NAME: strcpy(info->s, "MB8866"); break;
2309		default: DEVICE_GET_INFO_CALL(wd1770); break;
2310		}
2311		}
2312
2313		DEVICE_GET_INFO(mb8876)
2314		{
2315		switch (state)
2316		{
2317		case DEVINFO_STR_NAME: strcpy(info->s, "MB8876"); break;
2318		default: DEVICE_GET_INFO_CALL(wd1770); break;
2319		}
2320		}
2321
2322		DEVICE_GET_INFO(mb8877)
2323		{
2324		switch (state)
2325		{
2326		case DEVINFO_STR_NAME: strcpy(info->s, "MB8877"); break;
2327		default: DEVICE_GET_INFO_CALL(wd1770); break;
2328		}
2329		}
2330
2331	2102	const device_type FD1771 = &device_creator<fd1771_device>;
2332	2103
2333	2104	fd1771_device::fd1771_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/adc1038.c
r17616	r17617
161	161	adc1038->sars = 1;
162	162	}
163	163
164		/*-------------------------------------------------
165		device definition
166		-------------------------------------------------*/
167
168		DEVICE_GET_INFO(adc1038)
169		{
170		switch (state)
171		{
172		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(adc1038_state); break;
173
174		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(adc1038); break;
175
176		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(adc1038); break;
177
178		case DEVINFO_STR_NAME: strcpy(info->s, "A/D Converters 1038"); break;
179		}
180		}
181
182	164	const device_type ADC1038 = &device_creator<adc1038_device>;
183	165
184	166	adc1038_device::adc1038_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/latch8.c
r17616	r17617
232	232	}
233	233
234	234
235		DEVICE_GET_INFO( latch8 )
236		{
237		switch (state)
238		{
239		/* --- the following bits of info are returned as 64-bit signed integers --- */
240		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(latch8_t); break;
241
242		/* --- the following bits of info are returned as pointers to data or functions --- */
243		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(latch8);break;
244		case DEVINFO_FCT_STOP: /* Nothing */ break;
245		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(latch8);break;
246
247		/* --- the following bits of info are returned as NULL-terminated strings --- */
248		case DEVINFO_STR_NAME: strcpy(info->s, "8 bit latch"); break;
249		case DEVINFO_STR_FAMILY: strcpy(info->s, "Latches"); break;
250		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
251		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
252		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
253		}
254		}
255
256	235	const device_type LATCH8 = &device_creator<latch8_device>;
257	236
258	237	latch8_device::latch8_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/mb14241.c
r17616	r17617
68	68	mb14241->shift_count = 0;
69	69	}
70	70
71		DEVICE_GET_INFO(mb14241)
72		{
73		switch (state)
74		{
75		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mb14241_state); break;
76
77		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mb14241); break;
78
79		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mb14241); break;
80
81		case DEVINFO_STR_NAME: strcpy(info->s, "MB14241"); break;
82		}
83		}
84
85	71	const device_type MB14241 = &device_creator<mb14241_device>;
86	72
87	73	mb14241_device::mb14241_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/idectrl.c
r17616	r17617
1943	1943	SLOT_INTERFACE("hdd", IDE_HARDDISK)
1944	1944	SLOT_INTERFACE_END
1945	1945
1946		/*-------------------------------------------------
1947		device get info callback
1948		-------------------------------------------------*/
1949
1950		DEVICE_GET_INFO( ide_controller )
1951		{
1952		switch (state)
1953		{
1954		/* --- the following bits of info are returned as 64-bit signed integers --- */
1955		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ide_state); break;
1956
1957		/* --- the following bits of info are returned as pointers to data or functions --- */
1958		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ide_controller); break;
1959		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(ide_controller);break;
1960
1961		/* --- the following bits of info are returned as NULL-terminated strings --- */
1962		case DEVINFO_STR_NAME: strcpy(info->s, "IDE Controller"); break;
1963		case DEVINFO_STR_FAMILY: strcpy(info->s, "Disk Controller"); break;
1964		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1965		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1966		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1967		}
1968		}
1969
1970
1971	1946	const device_type IDE_CONTROLLER = &device_creator<ide_controller_device>;
1972	1947
1973	1948	ide_controller_device::ide_controller_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/74148.c
r17616	r17617
214	214	state->last_enable_output = -1;
215	215	}
216	216
217
218		DEVICE_GET_INFO(ttl74148)
219		{
220		switch (state)
221		{
222		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ttl74148_state); break;
223
224		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ttl74148); break;
225
226		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(ttl74148); break;
227
228		case DEVINFO_STR_NAME: strcpy(info->s, "74148"); break;
229		}
230		}
231
232	217	const device_type TTL74148 = &device_creator<ttl74148_device>;
233	218
234	219	ttl74148_device::ttl74148_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/68681.c
r17616	r17617
903	903	duart68681->channel[1].tx_timer->adjust(attotime::never, 1);
904	904	}
905	905
906		/*-------------------------------------------------
907		device get info callback
908		-------------------------------------------------*/
909
910		DEVICE_GET_INFO(duart68681)
911		{
912		switch (state)
913		{
914		/* --- the following bits of info are returned as 64-bit signed integers --- */
915		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(duart68681_state); break;
916
917		/* --- the following bits of info are returned as pointers to data or functions --- */
918		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(duart68681); break;
919		case DEVINFO_FCT_STOP: /* nothing */ break;
920		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(duart68681);break;
921
922		/* --- the following bits of info are returned as NULL-terminated strings --- */
923		case DEVINFO_STR_NAME: strcpy(info->s, "DUART 68681"); break;
924		case DEVINFO_STR_FAMILY: strcpy(info->s, "DUART"); break;
925		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
926		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
927		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
928		}
929		}
930
931	906	const device_type DUART68681 = &device_creator<duart68681_device>;
932	907
933	908	duart68681_device::duart68681_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/pd4990a.c
r17616	r17617
521	521	upd4990a->command_line = 0;
522	522	}
523	523
524		/*-------------------------------------------------
525		device definition
526		-------------------------------------------------*/
527
528		DEVICE_GET_INFO(upd4990a)
529		{
530		switch (state)
531		{
532		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd4990a_state); break;
533
534		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd4990a); break;
535
536		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(upd4990a); break;
537
538		case DEVINFO_STR_NAME: strcpy(info->s, "NEC uPD4990A"); break;
539		}
540		}
541
542	524	const device_type UPD4990A = &device_creator<upd4990a_device>;
543	525
544	526	upd4990a_device::upd4990a_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/rp5h01.c
r17616	r17617
222	222	rp5h01->old_clock = -1;
223	223	}
224	224
225		/*-------------------------------------------------
226		device definition
227		-------------------------------------------------*/
228
229		DEVICE_GET_INFO(rp5h01)
230		{
231		switch (state)
232		{
233		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(rp5h01_state); break;
234
235		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(rp5h01); break;
236
237		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(rp5h01); break;
238
239		case DEVINFO_STR_NAME: strcpy(info->s, "RP5H01"); break;
240		}
241		}
242
243	225	const device_type RP5H01 = &device_creator<rp5h01_device>;
244	226
245	227	rp5h01_device::rp5h01_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/6525tpi.c
r17616	r17617
197	197	tpi6525->in_c = 0xff;
198	198	}
199	199
200
201		DEVICE_GET_INFO( tpi6525 )
202		{
203		switch (state)
204		{
205		/* --- the following bits of info are returned as 64-bit signed integers --- */
206		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tpi6525_state); break;
207
208		/* --- the following bits of info are returned as pointers to data or functions --- */
209		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( tpi6525 ); break;
210		case DEVINFO_FCT_STOP: /* Nothing */ break;
211		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( tpi6525 ); break;
212
213		/* --- the following bits of info are returned as NULL-terminated strings --- */
214		case DEVINFO_STR_NAME: strcpy(info->s, "6525 TPI"); break;
215		case DEVINFO_STR_FAMILY: strcpy(info->s, "6525 TPI"); break;
216		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
217		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
218		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
219		}
220		}
221
222
223	200	/***************************************************************************
224	201	IMPLEMENTATION
225	202	***************************************************************************/

trunk/src/emu/machine/k053252.c
r17616	r17617
231	231	}
232	232
233	233
234		DEVICE_GET_INFO( k053252 )
235		{
236		switch (state)
237		{
238		/* --- the following bits of info are returned as 64-bit signed integers --- */
239		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(k053252_state); break;
240
241		/* --- the following bits of info are returned as pointers to data or functions --- */
242		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(k053252); break;
243		case DEVINFO_FCT_STOP: /* Nothing */ break;
244		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(k053252); break;
245
246		/* --- the following bits of info are returned as NULL-terminated strings --- */
247		case DEVINFO_STR_NAME: strcpy(info->s, "Konami 053252"); break;
248		case DEVINFO_STR_FAMILY: strcpy(info->s, "Konami Video IC"); break;
249		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
250		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
251		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MAME Team"); break;
252		}
253		}
254
255	234	const device_type K053252 = &device_creator<k053252_device>;
256	235
257	236	k053252_device::k053252_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/mb87078.c
r17616	r17617
266	266	mb87078_reset_comp_w(device, 1);
267	267	}
268	268
269		DEVICE_GET_INFO(mb87078)
270		{
271		switch (state)
272		{
273		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mb87078_state); break;
274
275		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mb87078); break;
276
277		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mb87078); break;
278
279		case DEVINFO_STR_NAME: strcpy(info->s, "Fujitsu MB87078"); break;
280		}
281		}
282
283	269	const device_type MB87078 = &device_creator<mb87078_device>;
284	270
285	271	mb87078_device::mb87078_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/emu/machine/pit8253.c
r17616	r17617
1154	1154	}
1155	1155	}
1156	1156
1157
1158		DEVICE_GET_INFO( pit8253 ) {
1159		switch ( state ) {
1160		/* --- the following bits of info are returned as 64-bit signed integers --- */
1161		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pit8253_t); break;
1162
1163		/* --- the following bits of info are returned as pointers to data or functions --- */
1164		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pit8253); break;
1165		case DEVINFO_FCT_STOP: /* nothing */ break;
1166		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pit8253); break;
1167
1168		/* --- the following bits of info are returned as NULL-terminated strings --- */
1169		case DEVINFO_STR_NAME: strcpy(info->s, "Intel PIT8253"); break;
1170		case DEVINFO_STR_FAMILY: strcpy(info->s, "PIT8253"); break;
1171		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
1172		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1173		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
1174		}
1175		}
1176
1177
1178		DEVICE_GET_INFO( pit8254 ) {
1179		switch ( state ) {
1180		/* --- the following bits of info are returned as 64-bit signed integers --- */
1181		case DEVINFO_STR_NAME: strcpy(info->s, "Intel PIT8254"); break;
1182
1183		/* --- the following bits of info are returned as pointers to data or functions --- */
1184		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pit8254); break;
1185
1186		default: DEVICE_GET_INFO_CALL(pit8253); break;
1187		}
1188		}
1189
1190
1191	1157	const device_type PIT8253 = &device_creator<pit8253_device>;
1192	1158
1193	1159	pit8253_device::pit8253_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/wswan.c
r17616	r17617
249	249	}
250	250
251	251
252		DEVICE_GET_INFO( wswan_sound )
253		{
254		switch (state)
255		{
256		/* --- the following bits of info are returned as 64-bit signed integers --- */
257		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(wswan_sound_state); break;
258
259		/* --- the following bits of info are returned as pointers to data or functions --- */
260		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(wswan_sound); break;
261
262		/* --- the following bits of info are returned as NULL-terminated strings --- */
263		case DEVINFO_STR_NAME: strcpy(info->s, "WonderSwan Custom"); break;
264		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
265		}
266		}
267
268	252	const device_type WSWAN = &device_creator<wswan_sound_device>;
269	253
270	254	wswan_sound_device::wswan_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/mac.c
r17616	r17617
188	188	}
189	189
190	190
191		DEVICE_GET_INFO( mac_sound )
192		{
193		switch (state)
194		{
195		/* --- the following bits of info are returned as 64-bit signed integers --- */
196		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mac_sound); break;
197
198		/* --- the following bits of info are returned as pointers to data or functions --- */
199		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mac_sound); break;
200
201		/* --- the following bits of info are returned as NULL-terminated strings --- */
202		case DEVINFO_STR_NAME: strcpy(info->s, "Mac Custom"); break;
203		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
204		}
205		}
206
207	191	const device_type MAC_SOUND = &device_creator<mac_sound_device>;
208	192
209	193	mac_sound_device::mac_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/gmaster.c
r17616	r17617
66	66	token->mixer_channel = device->machine().sound().stream_alloc(*device, 0, 1, device->machine().sample_rate(), 0, gmaster_update);
67	67	}
68	68
69
70		DEVICE_GET_INFO( gmaster_sound )
71		{
72		switch (state)
73		{
74		/* --- the following bits of info are returned as 64-bit signed integers --- */
75		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gmaster_sound); break;
76
77		/* --- the following bits of info are returned as pointers to data or functions --- */
78		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(gmaster_sound); break;
79
80		/* --- the following bits of info are returned as NULL-terminated strings --- */
81		case DEVINFO_STR_NAME: strcpy(info->s, "Game Master Custom"); break;
82		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
83		}
84		}
85
86	69	const device_type GMASTER = &device_creator<gmaster_sound_device>;
87	70
88	71	gmaster_sound_device::gmaster_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/upd1771.c
r17616	r17617
459	459	}
460	460
461	461
462		DEVICE_GET_INFO( upd1771c )
463		{
464		switch (state)
465		{
466		/* --- the following bits of info are returned as 64-bit signed integers --- */
467		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd1771_state); break;
468
469		/* --- the following bits of info are returned as pointers to functions --- */
470		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( upd1771c ); break;
471		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( upd1771c ); break;
472		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME( upd1771c ); break;
473
474		/* --- the following bits of info are returned as NULL-terminated strings --- */
475		case DEVINFO_STR_NAME: strcpy(info->s, "NEC uPD1771C 017"); break;
476		case DEVINFO_STR_FAMILY: strcpy(info->s, "NEC uPD1771"); break;
477		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
478		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
479		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME & MESS Teams"); break;
480		}
481		}
482
483	462	const device_type UPD1771C = &device_creator<upd1771c_device>;
484	463
485	464	upd1771c_device::upd1771c_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/mea8000.c
r17616	r17617
701	701	}
702	702
703	703
704		/************************ configuration **************************/
705
706		DEVICE_GET_INFO( mea8000 ) {
707		switch ( state ) {
708		/* --- the following bits of info are returned as 64-bit signed integers --- */
709		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mea8000_t); break;
710
711		/* --- the following bits of info are returned as pointers to data or functions --- */
712		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mea8000); break;
713		case DEVINFO_FCT_STOP: /* nothing */ break;
714		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mea8000); break;
715
716		/* --- the following bits of info are returned as NULL-terminated strings --- */
717		case DEVINFO_STR_NAME: strcpy(info->s, "Philips / Signetics MEA 8000 speech synthesizer"); break;
718		case DEVINFO_STR_FAMILY: strcpy(info->s, "MEA8000"); break;
719		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
720		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
721		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
722		}
723		}
724
725	704	const device_type MEA8000 = &device_creator<mea8000_device>;
726	705
727	706	mea8000_device::mea8000_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/vc4000.c
r17616	r17617
82	82	token->channel = device->machine().sound().stream_alloc(*device, 0, 1, device->machine().sample_rate(), 0, vc4000_update);
83	83	}
84	84
85
86		DEVICE_GET_INFO( vc4000_sound )
87		{
88		switch (state)
89		{
90		/* --- the following bits of info are returned as 64-bit signed integers --- */
91		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vc4000_sound); break;
92
93		/* --- the following bits of info are returned as pointers to data or functions --- */
94		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vc4000_sound); break;
95
96		/* --- the following bits of info are returned as NULL-terminated strings --- */
97		case DEVINFO_STR_NAME: strcpy(info->s, "VC 4000 Custom"); break;
98		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
99		}
100		}
101
102	85	const device_type VC4000 = &device_creator<vc4000_sound_device>;
103	86
104	87	vc4000_sound_device::vc4000_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/channelf.c
r17616	r17617
132	132	state->envelope = 0;
133	133	}
134	134
135
136		DEVICE_GET_INFO( channelf_sound )
137		{
138		switch (state)
139		{
140		/* --- the following bits of info are returned as 64-bit signed integers --- */
141		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(channelf_sound_state); break;
142
143		/* --- the following bits of info are returned as pointers to data or functions --- */
144		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(channelf_sound); break;
145
146		/* --- the following bits of info are returned as NULL-terminated strings --- */
147		case DEVINFO_STR_NAME: strcpy(info->s, "Channel F"); break;
148		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
149		}
150		}
151
152	135	const device_type CHANNELF = &device_creator<channelf_sound_device>;
153	136
154	137	channelf_sound_device::channelf_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/dave.c
r17616	r17617
817	817
818	818
819	819
820		DEVICE_GET_INFO( dave_sound )
821		{
822		switch (state)
823		{
824		/* --- the following bits of info are returned as 64-bit signed integers --- */
825		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(dave_t); break;
826
827		/* --- the following bits of info are returned as pointers to data or functions --- */
828		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(dave_sound); break;
829		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(dave_sound); break;
830
831		/* --- the following bits of info are returned as NULL-terminated strings --- */
832		case DEVINFO_STR_NAME: strcpy(info->s, "Dave"); break;
833		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
834		}
835		}
836
837	820	const device_type DAVE = &device_creator<dave_sound_device>;
838	821
839	822	dave_sound_device::dave_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/special.c
r17616	r17617
72	72	}
73	73
74	74
75		DEVICE_GET_INFO( specimx_sound )
76		{
77		switch (state)
78		{
79		/* --- the following bits of info are returned as 64-bit signed integers --- */
80		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(specimx_sound_state); break;
81
82		/* --- the following bits of info are returned as pointers to data or functions --- */
83		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(specimx_sound); break;
84
85		/* --- the following bits of info are returned as NULL-terminated strings --- */
86		case DEVINFO_STR_NAME: strcpy(info->s, "Specialist MX Custom"); break;
87		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
88		}
89		}
90
91	75	const device_type SPECIMX = &device_creator<specimx_sound_device>;
92	76
93	77	specimx_sound_device::specimx_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/socrates.c
r17616	r17617
143	143	* Generic get_info
144	144	**************************************************************************/
145	145
146		DEVICE_GET_INFO( socrates_snd )
147		{
148		switch (state)
149		{
150		/* --- the following bits of info are returned as 64-bit signed integers --- */
151		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(SocratesASIC); break;
152
153		/* --- the following bits of info are returned as pointers to data or functions --- */
154		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( socrates_snd ); break;
155
156		/* --- the following bits of info are returned as NULL-terminated strings --- */
157		case DEVINFO_STR_NAME: strcpy(info->s, "Socrates Sound"); break;
158		case DEVINFO_STR_FAMILY: strcpy(info->s, "Socrates Sound"); break;
159		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
160		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
161		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Jonathan Gevaryahu and The MESS Team"); break;
162		}
163		}
164
165	146	const device_type SOCRATES = &device_creator<socrates_snd_device>;
166	147
167	148	socrates_snd_device::socrates_snd_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/t6721.c
r17616	r17617
284	284	t6721->writeindex = 0;
285	285	}
286	286
287
288		/*-------------------------------------------------
289		device definition
290		-------------------------------------------------*/
291
292		DEVICE_GET_INFO(t6721)
293		{
294		switch (state)
295		{
296		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(t6721_state); break;
297
298		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(t6721); break;
299
300		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(t6721); break;
301
302		case DEVINFO_STR_NAME: strcpy(info->s, "Toshiba 6721A"); break;
303		}
304		}
305
306	287	const device_type T6721 = &device_creator<t6721_device>;
307	288
308	289	t6721_device::t6721_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/gb.c
r17616	r17617
756	756	}
757	757
758	758
759		DEVICE_GET_INFO( gameboy_sound )
760		{
761		switch (state)
762		{
763		/* --- the following bits of info are returned as 64-bit signed integers --- */
764		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(gb_sound_t); break;
765
766		/* --- the following bits of info are returned as pointers to data or functions --- */
767		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(gameboy_sound); break;
768
769		/* --- the following bits of info are returned as NULL-terminated strings --- */
770		case DEVINFO_STR_NAME: strcpy(info->s, "LR35902"); break;
771		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
772		}
773		}
774
775	759	const device_type GAMEBOY = &device_creator<gameboy_sound_device>;
776	760
777	761	gameboy_sound_device::gameboy_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/lynx.c
r17616	r17617
501	501	}
502	502
503	503
504		DEVICE_GET_INFO( lynx_sound )
505		{
506		switch (state)
507		{
508		/* --- the following bits of info are returned as 64-bit signed integers --- */
509		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(lynx_sound_state); break;
510
511		/* --- the following bits of info are returned as pointers to data or functions --- */
512		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(lynx_sound); break;
513		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(lynx_sound); break;
514
515		/* --- the following bits of info are returned as NULL-terminated strings --- */
516		case DEVINFO_STR_NAME: strcpy(info->s, "Mikey"); break;
517		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
518		}
519		}
520
521
522		DEVICE_GET_INFO( lynx2_sound )
523		{
524		switch (state)
525		{
526		/* --- the following bits of info are returned as 64-bit signed integers --- */
527		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(lynx_sound_state); break;
528
529		/* --- the following bits of info are returned as pointers to data or functions --- */
530		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(lynx2_sound); break;
531		case DEVINFO_FCT_RESET: info->start = DEVICE_RESET_NAME(lynx_sound); break;
532
533		/* --- the following bits of info are returned as NULL-terminated strings --- */
534		case DEVINFO_STR_NAME: strcpy(info->s, "Mikey (Lynx II)"); break;
535		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
536		}
537		}
538
539	504	const device_type LYNX = &device_creator<lynx_sound_device>;
540	505
541	506	lynx_sound_device::lynx_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/audio/svision.c
r17616	r17617
298	298	state->mixer_channel = device->machine().sound().stream_alloc(*device, 0, 2, device->machine().sample_rate(), 0, svision_update);
299	299	}
300	300
301
302		DEVICE_GET_INFO( svision_sound )
303		{
304		switch (state)
305		{
306		/* --- the following bits of info are returned as 64-bit signed integers --- */
307		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(svision_sound_state); break;
308
309		/* --- the following bits of info are returned as pointers to data or functions --- */
310		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(svision_sound); break;
311
312		/* --- the following bits of info are returned as NULL-terminated strings --- */
313		case DEVINFO_STR_NAME: strcpy(info->s, "Super Vision Custom"); break;
314		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
315		}
316		}
317
318	301	const device_type SVISION = &device_creator<svision_sound_device>;
319	302
320	303	svision_sound_device::svision_sound_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/strata.c
r17616	r17617
99	99	strata->prot_regs[i] = device->machine().rand();
100	100	}
101	101
102		DEVICE_GET_INFO( strataflash )
103		{
104		switch (state)
105		{
106		/* --- the following bits of info are returned as 64-bit signed integers --- */
107		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(strata_t); break;
108
109		/* --- the following bits of info are returned as pointers to data or functions --- */
110		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(strataflash); break;
111
112		/* --- the following bits of info are returned as NULL-terminated strings --- */
113		case DEVINFO_STR_NAME: strcpy(info->s, "Intel 28F640J5"); break;
114		case DEVINFO_STR_FAMILY: strcpy(info->s, "Intel 28F640J5"); break;
115		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
116		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
117		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
118		}
119		}
120
121	102	const device_type STRATAFLASH = &device_creator<strataflash_device>;
122	103
123	104	strataflash_device::strataflash_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/mos6530.c
r17616	r17617
434	434	}
435	435
436	436
437		DEVICE_GET_INFO( mos6530 )
438		{
439		switch (state)
440		{
441		/* --- the following bits of info are returned as 64-bit signed integers --- */
442		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mos6530_state); break;
443
444		/* --- the following bits of info are returned as pointers to data or functions --- */
445		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mos6530); break;
446		case DEVINFO_FCT_STOP: /* Nothing */ break;
447		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mos6530); break;
448
449		/* --- the following bits of info are returned as NULL-terminated strings --- */
450		case DEVINFO_STR_NAME: strcpy(info->s, "MOS6530"); break;
451		case DEVINFO_STR_FAMILY: strcpy(info->s, "MOS6500"); break;
452		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
453		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
454		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
455		}
456		}
457
458	437	const device_type MOS6530 = &device_creator<mos6530_device>;
459	438
460	439	mos6530_device::mos6530_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/mc6854.c
r17616	r17617
1039	1039
1040	1040
1041	1041
1042		/************************ configuration **************************/
1043
1044
1045		DEVICE_GET_INFO( mc6854 ) {
1046		switch ( state ) {
1047		/* --- the following bits of info are returned as 64-bit signed integers --- */
1048		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mc6854_t); break;
1049
1050		/* --- the following bits of info are returned as pointers to data or functions --- */
1051		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mc6854); break;
1052		case DEVINFO_FCT_STOP: /* nothing */ break;
1053		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc6854); break;
1054
1055		/* --- the following bits of info are returned as NULL-terminated strings --- */
1056		case DEVINFO_STR_NAME: strcpy(info->s, "Motorola MC6854 ADLC"); break;
1057		case DEVINFO_STR_FAMILY: strcpy(info->s, "MC6854"); break;
1058		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
1059		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1060		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
1061		}
1062		}
1063
1064	1042	const device_type MC6854 = &device_creator<mc6854_device>;
1065	1043
1066	1044	mc6854_device::mc6854_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/mc6846.c
r17616	r17617
609	609	}
610	610
611	611
612		/************************ configuration **************************/
613
614
615		DEVICE_GET_INFO( mc6846 ) {
616		switch ( state ) {
617		/* --- the following bits of info are returned as 64-bit signed integers --- */
618		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mc6846_t); break;
619
620		/* --- the following bits of info are returned as pointers to data or functions --- */
621		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mc6846); break;
622		case DEVINFO_FCT_STOP: /* nothing */ break;
623		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc6846); break;
624
625		/* --- the following bits of info are returned as NULL-terminated strings --- */
626		case DEVINFO_STR_NAME: strcpy(info->s, "Motorola MC6846 programmable timer"); break;
627		case DEVINFO_STR_FAMILY: strcpy(info->s, "MC6846"); break;
628		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
629		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
630		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
631		}
632		}
633
634	612	const device_type MC6846 = &device_creator<mc6846_device>;
635	613
636	614	mc6846_device::mc6846_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/sst39vfx.c
r17616	r17617
178	178	}
179	179	#endif
180	180
181
182		/*-------------------------------------------------
183		DEVICE_GET_INFO( sst39vf020 )
184		-------------------------------------------------*/
185
186		DEVICE_GET_INFO( sst39vf020 )
187		{
188		switch (state)
189		{
190		/* --- the following bits of info are returned as 64-bit signed integers --- */
191		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(sst39vfx_t); break;
192
193		/* --- the following bits of info are returned as pointers to data or functions --- */
194		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(sst39vf020); break;
195		case DEVINFO_FCT_STOP: /* Nothing */ break;
196		case DEVINFO_FCT_RESET: /* Nothing */ break;
197
198		/* --- the following bits of info are returned as NULL-terminated strings --- */
199		case DEVINFO_STR_NAME: strcpy(info->s, "SST39VF020"); break;
200		case DEVINFO_STR_FAMILY: strcpy(info->s, "SST39VFxx"); break;
201		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
202		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
203		case DEVINFO_STR_CREDITS: /* Nothing */ break;
204		}
205		}
206
207		DEVICE_GET_INFO( sst39vf400a )
208		{
209		switch (state)
210		{
211		/* --- the following bits of info are returned as NULL-terminated strings --- */
212		case DEVINFO_STR_NAME: strcpy(info->s, "SST39VF400A"); break;
213
214		/* --- the following bits of info are returned as pointers to data or functions --- */
215		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(sst39vf400a); break;
216
217		default: DEVICE_GET_INFO_CALL(sst39vf020); break;
218		}
219		}
220
221	181	const device_type SST39VF020 = &device_creator<sst39vf020_device>;
222	182
223	183	sst39vf020_device::sst39vf020_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/upd71071.c
r17616	r17617
417	417	}
418	418	}
419	419
420		DEVICE_GET_INFO(upd71071)
421		{
422		switch (state)
423		{
424		/* --- the following bits of info are returned as 64-bit signed integers --- */
425		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd71071_t); break;
426
427		/* --- the following bits of info are returned as pointers to data or functions --- */
428		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd71071); break;
429		case DEVINFO_FCT_STOP: /* Nothing */ break;
430		case DEVINFO_FCT_RESET: /* Nothing */ break;
431
432		/* --- the following bits of info are returned as NULL-terminated strings --- */
433		case DEVINFO_STR_NAME: strcpy(info->s, "NEC uPD71071"); break;
434		case DEVINFO_STR_FAMILY: strcpy(info->s, "DMA Controller"); break;
435		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
436		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
437		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
438		}
439		}
440
441	420	READ8_DEVICE_HANDLER(upd71071_r) { return upd71071_read(device,offset); }
442	421	WRITE8_DEVICE_HANDLER(upd71071_w) { upd71071_write(device,offset,data); }
443	422

trunk/src/mess/machine/e05a03.c
r17616	r17617
110	110	e05a03->cndlp = 1;
111	111	}
112	112
113		DEVICE_GET_INFO( e05a03 )
114		{
115		switch (state)
116		{
117		/* --- the following bits of info are returned as 64-bit signed integers --- */
118		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(e05a03_state); break;
119
120		/* --- the following bits of info are returned as pointers to data or functions --- */
121		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(e05a03); break;
122		case DEVINFO_FCT_STOP: /* Nothing */ break;
123		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(e05a03); break;
124
125		/* --- the following bits of info are returned as NULL-terminated strings --- */
126		case DEVINFO_STR_NAME: strcpy(info->s, "E05A03"); break;
127		case DEVINFO_STR_FAMILY: strcpy(info->s, "Epson printer gate array"); break;
128		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
129		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
130		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
131		}
132		}
133
134
135	113	/***************************************************************************
136	114	IMPLEMENTATION
137	115	***************************************************************************/

trunk/src/mess/machine/990_tap.c
r17616	r17617
1066	1066	}
1067	1067
1068	1068
1069		DEVICE_GET_INFO( tap_990 )
1070		{
1071		switch (state)
1072		{
1073		/* --- the following bits of info are returned as 64-bit signed integers --- */
1074		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tap_990_t); break;
1075
1076		/* --- the following bits of info are returned as pointers --- */
1077		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(tap_990); break;
1078
1079		/* --- the following bits of info are returned as pointers to data or functions --- */
1080		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tap_990); break;
1081		case DEVINFO_FCT_STOP: /* Nothing */ break;
1082
1083		/* --- the following bits of info are returned as NULL-terminated strings --- */
1084		case DEVINFO_STR_NAME: strcpy(info->s, "Generic TI990 Tape Controller"); break;
1085		case DEVINFO_STR_FAMILY: strcpy(info->s, "TI990 Tape Controller"); break;
1086		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1087		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1088		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
1089		}
1090		}
1091
1092	1069	const device_type TI990_TAPE_CTRL = &device_creator<tap_990_device>;
1093	1070
1094	1071	tap_990_device::tap_990_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/apollo.c
r17616	r17617
146	146	config = device->machine().root_device().ioport("apollo_config")->read();
147	147	}
148	148
149		/*-------------------------------------------------
150		device get info callback
151		-------------------------------------------------*/
152
153		DEVICE_GET_INFO(apollo_config)
154		{
155		switch (state)
156		{
157		/* --- the following bits of info are returned as pointers to data or functions --- */
158		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(apollo_config); break;
159		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(apollo_config);break;
160
161		/* --- the following bits of info are returned as NULL-terminated strings --- */
162		case DEVINFO_STR_NAME: strcpy(info->s, "Apollo Configuration");break;
163		case DEVINFO_STR_FAMILY: strcpy(info->s, "Configuration"); break;
164		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
165		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
166		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
167		}
168		}
169
170	149	class apollo_config_device : public device_t
171	150	{
172	151	public:

trunk/src/mess/machine/ds1315.c
r17616	r17617
239	239	}
240	240
241	241
242		/*-------------------------------------------------
243		DEVICE_GET_INFO( ds1315 )
244		-------------------------------------------------*/
245
246		DEVICE_GET_INFO( ds1315 )
247		{
248		switch (state)
249		{
250		/* --- the following bits of info are returned as 64-bit signed integers --- */
251		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ds1315_t); break;
252
253		/* --- the following bits of info are returned as pointers to data or functions --- */
254		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ds1315); break;
255		case DEVINFO_FCT_STOP: /* Nothing */ break;
256		case DEVINFO_FCT_RESET: /* Nothing */ break;
257
258		/* --- the following bits of info are returned as NULL-terminated strings --- */
259		case DEVINFO_STR_NAME: strcpy(info->s, "Dallas Semiconductor DS1315"); break;
260		case DEVINFO_STR_FAMILY: strcpy(info->s, "Dallas Semiconductor DS1315"); break;
261		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
262		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
263		case DEVINFO_STR_CREDITS: /* Nothing */ break;
264		}
265		}
266
267	242	const device_type DS1315 = &device_creator<ds1315_device>;
268	243
269	244	ds1315_device::ds1315_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/pc_lpt.c
r17616	r17617
115	115	lpt->data = 0xff;
116	116	}
117	117
118		DEVICE_GET_INFO( pc_lpt )
119		{
120		switch (state)
121		{
122		/* --- the following bits of info are returned as 64-bit signed integers --- */
123		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pc_lpt_state); break;
124
125		/* --- the following bits of info are returned as pointers --- */
126		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(pc_lpt); break;
127
128		/* --- the following bits of info are returned as pointers to data or functions --- */
129		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pc_lpt); break;
130		case DEVINFO_FCT_STOP: /* Nothing */ break;
131		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pc_lpt); break;
132
133		/* --- the following bits of info are returned as NULL-terminated strings --- */
134		case DEVINFO_STR_NAME: strcpy(info->s, "PC-LPT"); break;
135		case DEVINFO_STR_FAMILY: strcpy(info->s, "Parallel port"); break;
136		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
137		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
138		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
139		}
140		}
141
142
143	118	/***************************************************************************
144	119	IMPLEMENTATION
145	120	***************************************************************************/

trunk/src/mess/machine/s3c44b0.c
r17616	r17617
2035	2035	space->install_legacy_readwrite_handler( *device, 0x01f80020, 0x01f8003b, 0, 0, FUNC(s3c44b0_bdma_1_r), FUNC(s3c44b0_bdma_1_w));
2036	2036	}
2037	2037
2038		DEVICE_GET_INFO( s3c44b0 )
2039		{
2040		switch ( state )
2041		{
2042		/* --- the following bits of info are returned as 64-bit signed integers --- */
2043		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(s3c44b0_t); break;
2044		// case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
2045		/* --- the following bits of info are returned as pointers to data or functions --- */
2046		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(s3c44b0); break;
2047		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(s3c44b0); break;
2048		/* --- the following bits of info are returned as NULL-terminated strings --- */
2049		case DEVINFO_STR_FAMILY: strcpy(info->s, "S3C44B0"); break;
2050		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
2051		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2052		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
2053		case DEVINFO_STR_NAME: strcpy(info->s, "Samsung S3C44B0"); break;
2054		}
2055		}
2056
2057	2038	const device_type S3C44B0 = &device_creator<s3c44b0_device>;
2058	2039
2059	2040	s3c44b0_device::s3c44b0_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/s3c44b0.h
r17616	r17617
103	103	PROTOTYPES
104	104	*******************************************************************************/
105	105
106		DEVICE_GET_INFO( s3c44b0 );
107
108	106	VIDEO_START( s3c44b0 );
109	107	SCREEN_UPDATE_RGB32( s3c44b0 );
110	108

trunk/src/mess/machine/mc68328.c
r17616	r17617
2808	2808	mc68328_register_state_save(device);
2809	2809	}
2810	2810
2811		DEVICE_GET_INFO( mc68328 )
2812		{
2813		switch ( state )
2814		{
2815		/* --- the following bits of info are returned as 64-bit signed integers --- */
2816		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mc68328_t); break;
2817
2818		/* --- the following bits of info are returned as pointers to data or functions --- */
2819		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mc68328); break;
2820		case DEVINFO_FCT_STOP: /* nothing */ break;
2821		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc68328); break;
2822
2823		/* --- the following bits of info are returned as NULL-terminated strings --- */
2824		case DEVINFO_STR_NAME: strcpy(info->s, "Motorola MC68328 (DragonBall) Integrated Processor"); break;
2825		case DEVINFO_STR_FAMILY: strcpy(info->s, "MC68328"); break;
2826		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
2827		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2828		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Teams and Ryan Holtz"); break;
2829		}
2830		}
2831
2832	2811	const device_type MC68328 = &device_creator<mc68328_device>;
2833	2812
2834	2813	mc68328_device::mc68328_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/micropolis.c
r17616	r17617
377	377	DEVICE_RESET_CALL( micropolis );
378	378	}
379	379
380
381		/***************************************************************************
382		DEVICE GETINFO
383		***************************************************************************/
384
385		DEVICE_GET_INFO(micropolis)
386		{
387		switch (state)
388		{
389		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(micropolis_state); break;
390
391		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(micropolis); break;
392
393		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(micropolis); break;
394
395		case DEVINFO_STR_NAME: strcpy(info->s, "MICROPOLIS"); break;
396		}
397		}
398
399	380	const device_type MICROPOLIS = &device_creator<micropolis_device>;
400	381
401	382	micropolis_device::micropolis_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/tf20.c
r17616	r17617
358	358	prg->install_rom(0x0000, 0x07ff, 0, 0x7800, cpu->region()->base());
359	359	}
360	360
361		DEVICE_GET_INFO( tf20 )
362		{
363		switch (state)
364		{
365		/* --- the following bits of info are returned as 64-bit signed integers --- */
366		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(tf20_state); break;
367
368		/* --- the following bits of info are returned as pointers --- */
369		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(tf20); break;
370		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(tf20); break;
371
372		/* --- the following bits of info are returned as pointers to data or functions --- */
373		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(tf20); break;
374		case DEVINFO_FCT_STOP: /* Nothing */ break;
375		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(tf20); break;
376
377		/* --- the following bits of info are returned as NULL-terminated strings --- */
378		case DEVINFO_STR_NAME: strcpy(info->s, "TF-20"); break;
379		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "tf20"); break;
380		case DEVINFO_STR_FAMILY: strcpy(info->s, "Floppy drive"); break;
381		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
382		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
383		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
384		}
385		}
386
387	361	const device_type TF20 = &device_creator<tf20_device>;
388	362
389	363	tf20_device::tf20_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/hd63450.c
r17616	r17617
461	461	return dmac->reg[channel].eiv;
462	462	}
463	463
464		DEVICE_GET_INFO(hd63450)
465		{
466		switch (state)
467		{
468		/* --- the following bits of info are returned as 64-bit signed integers --- */
469		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(hd63450_t); break;
470
471		/* --- the following bits of info are returned as pointers to data or functions --- */
472		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(hd63450); break;
473		case DEVINFO_FCT_STOP: /* Nothing */ break;
474		case DEVINFO_FCT_RESET: /info->reset = DEVICE_RESET_NAME(hd63450);/ break;
475
476		/* --- the following bits of info are returned as NULL-terminated strings --- */
477		case DEVINFO_STR_NAME: strcpy(info->s, "Hitachi HD63450"); break;
478		case DEVINFO_STR_FAMILY: strcpy(info->s, "DMA Controller"); break;
479		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
480		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
481		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
482		}
483		}
484
485	464	READ16_DEVICE_HANDLER(hd63450_r) { return hd63450_read(device,offset,mem_mask); }
486	465	WRITE16_DEVICE_HANDLER(hd63450_w) { hd63450_write(device,offset,data,mem_mask); }
487	466

trunk/src/mess/machine/kr2376.c
r17616	r17617
372	372	device->save_item(NAME(kr2376->data));
373	373	}
374	374
375		DEVICE_GET_INFO( kr2376 )
376		{
377		switch (state)
378		{
379		/* --- the following bits of info are returned as 64-bit signed integers --- */
380		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(kr2376_t); break;
381
382		/* --- the following bits of info are returned as pointers to data or functions --- */
383		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(kr2376); break;
384		case DEVINFO_FCT_STOP: /* Nothing */ break;
385		case DEVINFO_FCT_RESET: /* Nothing */ break;
386
387		/* --- the following bits of info are returned as NULL-terminated strings --- */
388		case DEVINFO_STR_NAME: strcpy(info->s, "SMC KR2376"); break;
389		case DEVINFO_STR_FAMILY: strcpy(info->s, "SMC"); break;
390		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
391		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
392		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
393		}
394		}
395
396	375	const device_type KR2376 = &device_creator<kr2376_device>;
397	376
398	377	kr2376_device::kr2376_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/applefdc.c
r17616	r17617
735	735	***************************************************************************/
736	736
737	737	/*-------------------------------------------------
738		DEVICE_GET_INFO(applefdc_base) - device get info
739		callback
740		-------------------------------------------------*/
741
742		static DEVICE_GET_INFO(applefdc_base)
743		{
744		switch (state)
745		{
746		/* --- the following bits of info are returned as 64-bit signed integers --- */
747		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(applefdc_token); break;
748
749		/* --- the following bits of info are returned as pointers to data or functions --- */
750		case DEVINFO_FCT_START: /* Nothing */ break;
751		case DEVINFO_FCT_STOP: /* Nothing */ break;
752		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(applefdc); break;
753
754		/* --- the following bits of info are returned as NULL-terminated strings --- */
755		case DEVINFO_STR_FAMILY: strcpy(info->s, "Apple FDC"); break;
756		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
757		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
758		}
759		}
760
761
762
763		/*-------------------------------------------------
764	738	DEVICE_START(oldfdc) - device start
765	739	callback
766	740	-------------------------------------------------*/
r17616	r17617
773	747
774	748
775	749	/*-------------------------------------------------
776		DEVICE_GET_INFO(applefdc) - device get info
777		callback
778		-------------------------------------------------*/
779
780		DEVICE_GET_INFO(applefdc)
781		{
782		switch (state)
783		{
784		/* --- the following bits of info are returned as NULL-terminated strings --- */
785		case DEVINFO_STR_NAME: strcpy(info->s, "Apple FDC"); break;
786
787		/* --- the following bits of info are returned as pointers to data or functions --- */
788		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(oldfdc); break;
789
790		default: DEVICE_GET_INFO_CALL(applefdc_base); break;
791		}
792		}
793
794
795
796		/*-------------------------------------------------
797	750	DEVICE_START(iwm) - device start
798	751	callback
799	752	-------------------------------------------------*/
r17616	r17617
804	757	}
805	758
806	759
807
808	760	/*-------------------------------------------------
809		DEVICE_GET_INFO(iwm) - device get info
810		callback
811		-------------------------------------------------*/
812
813		DEVICE_GET_INFO(iwm)
814		{
815		switch (state)
816		{
817		/* --- the following bits of info are returned as NULL-terminated strings --- */
818		case DEVINFO_STR_NAME: strcpy(info->s, "Apple IWM (Integrated Woz Machine)"); break;
819
820		/* --- the following bits of info are returned as pointers to data or functions --- */
821		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(iwm); break;
822
823		default: DEVICE_GET_INFO_CALL(applefdc_base); break;
824		}
825		}
826
827
828
829		/*-------------------------------------------------
830	761	DEVICE_START(iwm) - device start
831	762	callback
832	763	-------------------------------------------------*/
r17616	r17617
837	768	}
838	769
839	770
840
841		/*-------------------------------------------------
842		DEVICE_GET_INFO(swim) - device get info
843		callback
844		-------------------------------------------------*/
845
846		DEVICE_GET_INFO(swim)
847		{
848		switch (state)
849		{
850		/* --- the following bits of info are returned as NULL-terminated strings --- */
851		case DEVINFO_STR_NAME: strcpy(info->s, "Apple SWIM (Steve Woz Integrated Machine)"); break;
852
853		/* --- the following bits of info are returned as pointers to data or functions --- */
854		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(swim); break;
855
856		default: DEVICE_GET_INFO_CALL(applefdc_base); break;
857		}
858		}
859
860	771	applefdc_base_device::applefdc_base_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
861	772	: device_t(mconfig, type, name, tag, owner, clock)
862	773	{

trunk/src/mess/machine/upd765.c
r17616	r17617
2476	2476	upd765_reset(device,0);
2477	2477	}
2478	2478
2479		DEVICE_GET_INFO( upd765a )
2480		{
2481		switch (state)
2482		{
2483		/* --- the following bits of info are returned as 64-bit signed integers --- */
2484		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(upd765_t); break;
2485
2486		/* --- the following bits of info are returned as pointers to data or functions --- */
2487		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd765a); break;
2488		case DEVINFO_FCT_STOP: /* Nothing */ break;
2489		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(upd765); break;
2490
2491		/* --- the following bits of info are returned as NULL-terminated strings --- */
2492		case DEVINFO_STR_NAME: strcpy(info->s, "UPD765A"); break;
2493		case DEVINFO_STR_FAMILY: strcpy(info->s, "UPD765A"); break;
2494		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
2495		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
2496		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
2497		}
2498		}
2499
2500
2501		DEVICE_GET_INFO( upd765b )
2502		{
2503		switch (state)
2504		{
2505		/* --- the following bits of info are returned as NULL-terminated strings --- */
2506		case DEVINFO_STR_NAME: strcpy(info->s, "UPD765B"); break;
2507
2508		/* --- the following bits of info are returned as pointers to data or functions --- */
2509		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd765b); break;
2510
2511		default: DEVICE_GET_INFO_CALL(upd765a); break;
2512		}
2513		}
2514
2515		DEVICE_GET_INFO( smc37c78 )
2516		{
2517		switch (state)
2518		{
2519		/* --- the following bits of info are returned as NULL-terminated strings --- */
2520		case DEVINFO_STR_NAME: strcpy(info->s, "SMC37C78"); break;
2521
2522		/* --- the following bits of info are returned as pointers to data or functions --- */
2523		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(smc37c78); break;
2524
2525		default: DEVICE_GET_INFO_CALL(upd765a); break;
2526		}
2527		}
2528
2529		DEVICE_GET_INFO( upd72065 )
2530		{
2531		switch (state)
2532		{
2533		/* --- the following bits of info are returned as NULL-terminated strings --- */
2534		case DEVINFO_STR_NAME: strcpy(info->s, "UPD72065"); break;
2535
2536		/* --- the following bits of info are returned as pointers to data or functions --- */
2537		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(upd72065); break;
2538
2539		default: DEVICE_GET_INFO_CALL(upd765a); break;
2540		}
2541		}
2542
2543	2479	const device_type UPD765A = &device_creator<upd765a_device>;
2544	2480
2545	2481	upd765a_device::upd765a_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/at45dbxx.c
r17616	r17617
414	414	#endif
415	415
416	416
417		/*-------------------------------------------------
418		DEVICE_GET_INFO( at45db041 )
419		-------------------------------------------------*/
420
421		DEVICE_GET_INFO( at45db041 )
422		{
423		switch (state)
424		{
425		/* --- the following bits of info are returned as 64-bit signed integers --- */
426		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(at45dbxx_t); break;
427
428		/* --- the following bits of info are returned as pointers to data or functions --- */
429		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(at45db041); break;
430		case DEVINFO_FCT_STOP: /* Nothing */ break;
431		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(at45dbxx); break;
432
433		/* --- the following bits of info are returned as NULL-terminated strings --- */
434		case DEVINFO_STR_NAME: strcpy(info->s, "AT45DB041"); break;
435		case DEVINFO_STR_FAMILY: strcpy(info->s, "AT45DBxx"); break;
436		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
437		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
438		case DEVINFO_STR_CREDITS: /* Nothing */ break;
439		}
440		}
441
442		DEVICE_GET_INFO( at45db081 )
443		{
444		switch (state)
445		{
446		/* --- the following bits of info are returned as NULL-terminated strings --- */
447		case DEVINFO_STR_NAME: strcpy(info->s, "AT45DB081"); break;
448
449		/* --- the following bits of info are returned as pointers to data or functions --- */
450		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(at45db081); break;
451
452		default: DEVICE_GET_INFO_CALL(at45db041); break;
453		}
454		}
455
456		DEVICE_GET_INFO( at45db161 )
457		{
458		switch (state)
459		{
460		/* --- the following bits of info are returned as NULL-terminated strings --- */
461		case DEVINFO_STR_NAME: strcpy(info->s, "AT45DB161"); break;
462
463		/* --- the following bits of info are returned as pointers to data or functions --- */
464		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(at45db161); break;
465
466		default: DEVICE_GET_INFO_CALL(at45db041); break;
467		}
468		}
469
470	417	const device_type AT45DB041 = &device_creator<at45db041_device>;
471	418
472	419	at45db041_device::at45db041_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/er59256.c
r17616	r17617
223	223	er59256->command=CMD_INVALID;
224	224	}
225	225
226		/*-------------------------------------------------
227		DEVICE_GET_INFO( er59256 )
228		-------------------------------------------------*/
229
230		DEVICE_GET_INFO( er59256 )
231		{
232		switch (state)
233		{
234		/* --- the following bits of info are returned as 64-bit signed integers --- */
235		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(er59256_t); break;
236
237		/* --- the following bits of info are returned as pointers to data or functions --- */
238		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(er59256); break;
239		case DEVINFO_FCT_STOP: info->stop = DEVICE_STOP_NAME(er59256); break;
240		case DEVINFO_FCT_RESET: /* Nothing */ break;
241
242		/* --- the following bits of info are returned as NULL-terminated strings --- */
243		case DEVINFO_STR_NAME: strcpy(info->s, "Microchip ER59256 serial eeprom."); break;
244		case DEVINFO_STR_FAMILY: strcpy(info->s, "Microchip ER59256 serial eeprom."); break;
245		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
246		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
247		case DEVINFO_STR_CREDITS: /* Nothing */ break;
248		}
249		}
250
251	226	const device_type ER59256 = &device_creator<er59256_device>;
252	227
253	228	er59256_device::er59256_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/pf10.c
r17616	r17617
101	101	{
102	102	}
103	103
104		DEVICE_GET_INFO( pf10 )
105		{
106		switch (state)
107		{
108		/* --- the following bits of info are returned as 64-bit signed integers --- */
109		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pf10_state); break;
110
111		/* --- the following bits of info are returned as pointers --- */
112		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(pf10); break;
113		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(pf10); break;
114
115		/* --- the following bits of info are returned as pointers to data or functions --- */
116		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pf10); break;
117		case DEVINFO_FCT_STOP: /* Nothing */ break;
118		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pf10); break;
119
120		/* --- the following bits of info are returned as NULL-terminated strings --- */
121		case DEVINFO_STR_NAME: strcpy(info->s, "PF-10"); break;
122		case DEVINFO_STR_FAMILY: strcpy(info->s, "Floppy drive"); break;
123		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
124		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
125		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
126		}
127		}
128
129
130	104	/***************************************************************************
131	105	IMPLEMENTATION
132	106	***************************************************************************/

trunk/src/mess/machine/pcf8593.c
r17616	r17617
445	445	#endif
446	446
447	447
448		/*-------------------------------------------------
449		DEVICE_GET_INFO( pcf8593 )
450		-------------------------------------------------*/
451
452		DEVICE_GET_INFO( pcf8593 )
453		{
454		switch (state)
455		{
456		/* --- the following bits of info are returned as 64-bit signed integers --- */
457		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(pcf8593_t); break;
458
459		/* --- the following bits of info are returned as pointers to data or functions --- */
460		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pcf8593); break;
461		case DEVINFO_FCT_STOP: /* Nothing */ break;
462		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(pcf8593); break;
463
464		/* --- the following bits of info are returned as NULL-terminated strings --- */
465		case DEVINFO_STR_NAME: strcpy(info->s, "PCF8593 RTC"); break;
466		case DEVINFO_STR_FAMILY: strcpy(info->s, "PCF8593 RTC"); break;
467		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
468		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
469		case DEVINFO_STR_CREDITS: /* Nothing */ break;
470		}
471		}
472
473	448	const device_type PCF8593 = &device_creator<pcf8593_device>;
474	449
475	450	pcf8593_device::pcf8593_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/i8271.c
r17616	r17617
1575	1575
1576	1576	}
1577	1577
1578		DEVICE_GET_INFO( i8271 )
1579		{
1580		switch (state)
1581		{
1582		/* --- the following bits of info are returned as 64-bit signed integers --- */
1583		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(i8271_t); break;
1584
1585		/* --- the following bits of info are returned as pointers to data or functions --- */
1586		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(i8271); break;
1587		case DEVINFO_FCT_STOP: /* Nothing */ break;
1588		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(i8271); break;
1589
1590		/* --- the following bits of info are returned as NULL-terminated strings --- */
1591		case DEVINFO_STR_NAME: strcpy(info->s, "Intel 8271"); break;
1592		case DEVINFO_STR_FAMILY: strcpy(info->s, "Intel 8271"); break;
1593		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1594		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1595		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
1596		}
1597		}
1598
1599	1578	const device_type I8271 = &device_creator<i8271_device>;
1600	1579
1601	1580	i8271_device::i8271_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/upd7002.c
r17616	r17617
209	209	uPD7002->conversion_counter = 0;
210	210	}
211	211
212		DEVICE_GET_INFO( uPD7002 )
213		{
214		switch (state)
215		{
216		/* --- the following bits of info are returned as 64-bit signed integers --- */
217		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(uPD7002_t); break;
218
219		/* --- the following bits of info are returned as pointers to data or functions --- */
220		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(uPD7002); break;
221		case DEVINFO_FCT_STOP: /* Nothing */ break;
222		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(uPD7002); break;
223
224		/* --- the following bits of info are returned as NULL-terminated strings --- */
225		case DEVINFO_STR_NAME: strcpy(info->s, "uPD7002"); break;
226		case DEVINFO_STR_FAMILY: strcpy(info->s, "uPD7002"); break;
227		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
228		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
229		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
230		}
231		}
232
233	212	const device_type UPD7002 = &device_creator<uPD7002_device>;
234	213
235	214	uPD7002_device::uPD7002_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/beta.c
r17616	r17617
328	328	{
329	329	}
330	330
331		/*-------------------------------------------------
332		DEVICE_GET_INFO( beta_disk )
333		-------------------------------------------------*/
334
335		DEVICE_GET_INFO( beta_disk )
336		{
337		switch (state)
338		{
339		/* --- the following bits of info are returned as 64-bit signed integers --- */
340		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(beta_disk_state); break;
341
342		/* --- the following bits of info are returned as pointers --- */
343		case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(beta_disk); break;
344		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(beta_disk); break;
345
346		/* --- the following bits of info are returned as pointers to data or functions --- */
347		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(beta_disk); break;
348		case DEVINFO_FCT_STOP: /* Nothing */ break;
349		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(beta_disk); break;
350
351		/* --- the following bits of info are returned as NULL-terminated strings --- */
352		case DEVINFO_STR_NAME: strcpy(info->s, "Beta Disk Interface"); break;
353		case DEVINFO_STR_SHORTNAME: strcpy(info->s, "betadisk"); break;
354		case DEVINFO_STR_FAMILY: strcpy(info->s, "Beta Disk Interface"); break;
355		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
356		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
357		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
358		}
359		}
360
361	331	const device_type BETA_DISK = &device_creator<beta_disk_device>;
362	332
363	333	beta_disk_device::beta_disk_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/ay31015.c
r17616	r17617
716	716	}
717	717
718	718
719		/*-------------------------------------------------
720		DEVICE_GET_INFO(ay31015) - device getinfo
721		function
722		-------------------------------------------------*/
723
724		DEVICE_GET_INFO( ay31015 )
725		{
726		switch(state)
727		{
728		/* --- the following bits of info are returned as 64-bit signed integers --- */
729		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(ay31015_t); break;
730
731		/* --- the following bits of info are returned as pointers to data or functions --- */
732		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(ay31015); break;
733		case DEVINFO_FCT_STOP: /* nothing */ break;
734		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( ay31015 ); break;
735
736		/* --- the following bits of info are returned as NULL-terminated strings --- */
737		case DEVINFO_STR_NAME: strcpy(info->s, "AY-3-1015"); break;
738		case DEVINFO_STR_FAMILY: strcpy(info->s, "AY-3-1015/AY-5-1013 UARTs"); break;
739		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
740		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
741		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
742		}
743		}
744
745	719	const device_type AY31015 = &device_creator<ay31015_device>;
746	720
747	721	ay31015_device::ay31015_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/mc6843.c
r17616	r17617
830	830	}
831	831
832	832
833		/************************ configuration **************************/
834
835		DEVICE_GET_INFO( mc6843 ) {
836		switch ( state ) {
837		/* --- the following bits of info are returned as 64-bit signed integers --- */
838		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mc6843_t); break;
839
840		/* --- the following bits of info are returned as pointers to data or functions --- */
841		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mc6843); break;
842		case DEVINFO_FCT_STOP: /* nothing */ break;
843		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc6843); break;
844
845		/* --- the following bits of info are returned as NULL-terminated strings --- */
846		case DEVINFO_STR_NAME: strcpy(info->s, "Motorola MC6843 floppy controller"); break;
847		case DEVINFO_STR_FAMILY: strcpy(info->s, "MC6843"); break;
848		case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
849		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
850		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
851		}
852		}
853
854	833	const device_type MC6843 = &device_creator<mc6843_device>;
855	834
856	835	mc6843_device::mc6843_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/mm58274c.c
r17616	r17617
517	517	mm58274c->tenths = 0;
518	518	}
519	519
520		DEVICE_GET_INFO( mm58274c )
521		{
522		switch (state)
523		{
524		/* --- the following bits of info are returned as 64-bit signed integers --- */
525		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mm58274c_t); break;
526
527		/* --- the following bits of info are returned as pointers to data or functions --- */
528		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mm58274c); break;
529		case DEVINFO_FCT_STOP: /* Nothing */ break;
530		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mm58274c); break;
531
532		/* --- the following bits of info are returned as NULL-terminated strings --- */
533		case DEVINFO_STR_NAME: strcpy(info->s, "National Semiconductor MM58274C");break;
534		case DEVINFO_STR_FAMILY: strcpy(info->s, "National Semiconductor MM58274C");break;
535		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
536		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
537		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
538		}
539		}
540
541	520	const device_type MM58274C = &device_creator<mm58274c_device>;
542	521
543	522	mm58274c_device::mm58274c_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/atarifdc.c
r17616	r17617
816	816	{
817	817	}
818	818
819		DEVICE_GET_INFO( atari_fdc )
820		{
821		switch (state)
822		{
823		/* --- the following bits of info are returned as 64-bit signed integers --- */
824		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(atari_fdc_t); break;
825
826		/* --- the following bits of info are returned as pointers --- */
827		case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_CONFIG_NAME(atari_fdc); break;
828
829		/* --- the following bits of info are returned as pointers to data or functions --- */
830		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(atari_fdc); break;
831		case DEVINFO_FCT_STOP: /* Nothing */ break;
832		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(atari_fdc); break;
833
834		/* --- the following bits of info are returned as NULL-terminated strings --- */
835		case DEVINFO_STR_NAME: strcpy(info->s, "Atari FDC"); break;
836		case DEVINFO_STR_FAMILY: strcpy(info->s, "Atari FDC"); break;
837		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
838		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
839		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
840		}
841		}
842
843	819	const device_type ATARI_FDC = &device_creator<atari_fdc_device>;
844	820
845	821	atari_fdc_device::atari_fdc_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/machine/omti8621.c
r17616	r17617
1334	1334	omti_reset(state);
1335	1335	}
1336	1336
1337		/*-------------------------------------------------
1338		device get info callback
1339		-------------------------------------------------*/
1340
1341		DEVICE_GET_INFO( omti8621 )
1342		{
1343		switch (state)
1344		{
1345		/* --- the following bits of info are returned as 64-bit signed integers --- */
1346		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(omti8621_state); break;
1347
1348		/* --- the following bits of info are returned as pointers to data or functions --- */
1349		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(omti8621); break;
1350		case DEVINFO_FCT_STOP: /* Nothing */ break;
1351		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(omti8621); break;
1352
1353		/* --- the following bits of info are returned as NULL-terminated strings --- */
1354		case DEVINFO_STR_NAME: strcpy(info->s, "OMTI 8621"); break;
1355		case DEVINFO_STR_FAMILY: strcpy(info->s, "Winchester Disk Controller");break;
1356		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
1357		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
1358		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break;
1359		}
1360		}
1361
1362	1337	const device_type OMTI8621 = &device_creator<omti8621_device>;
1363	1338
1364	1339	omti8621_device::omti8621_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/includes/apollo.h
r17616	r17617
329	329	MCFG_FRAGMENT_ADD(apollo_mono19i) \
330	330	MCFG_DEVICE_ADD(_tag, APOLLO_MONO19I, 0)
331	331
332		DEVICE_GET_INFO( apollo_mono19i );
333
334	332	MACHINE_CONFIG_EXTERN( apollo_mono19i );
335	333
336	334	class apollo_mono15i_device : public apollo_mono_device
r17616	r17617
353	351	MCFG_FRAGMENT_ADD(apollo_mono15i) \
354	352	MCFG_DEVICE_ADD(_tag, APOLLO_MONO15I, 0)
355	353
356		DEVICE_GET_INFO( apollo_mono15i );
357
358	354	MACHINE_CONFIG_EXTERN( apollo_mono15i );
359	355
360	356	READ16_DEVICE_HANDLER( apollo_mcr_r ) ;

trunk/src/mess/video/911_vdt.c
r17616	r17617
268	268	vdt->beep_timer = device->machine().scheduler().timer_alloc(FUNC(beep_callback));
269	269	}
270	270
271		DEVICE_GET_INFO( vdt911 )
272		{
273		switch (state)
274		{
275		/* --- the following bits of info are returned as 64-bit signed integers --- */
276		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vdt_t); break;
277
278		/* --- the following bits of info are returned as pointers to data or functions --- */
279		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vdt911); break;
280
281		/* --- the following bits of info are returned as NULL-terminated strings --- */
282		case DEVINFO_STR_NAME: strcpy(info->s, "911 VDT"); break;
283		case DEVINFO_STR_FAMILY: strcpy(info->s, "911 VDT Video"); break;
284		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
285		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
286		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
287		}
288		}
289
290	271	const device_type VDT911 = &device_creator<vdt911_device>;
291	272
292	273	vdt911_device::vdt911_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/saa505x.c
r17616	r17617
3406	3406	tt->intf = (const saa505x_interface *)device->static_config();
3407	3407	}
3408	3408
3409		DEVICE_GET_INFO( saa505x )
3410		{
3411		switch (state)
3412		{
3413		/* --- the following bits of info are returned as 64-bit signed integers --- */
3414		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(teletext_t); break;
3415
3416		/* --- the following bits of info are returned as pointers to data or functions --- */
3417		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(saa505x); break;
3418
3419		/* --- the following bits of info are returned as NULL-terminated strings --- */
3420		case DEVINFO_STR_NAME: strcpy(info->s, "SAA505x Video"); break;
3421		case DEVINFO_STR_FAMILY: strcpy(info->s, "SAA505x Video"); break;
3422		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
3423		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
3424		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
3425		}
3426		}
3427
3428	3409	const device_type SAA505X = &device_creator<saa505x_device>;
3429	3410
3430	3411	saa505x_device::saa505x_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/apollo.c
r17616	r17617
834	834	DEVICE_RESET_CALL(apollo_mono19i);
835	835	}
836	836
837		/*-------------------------------------------------
838		DEVICE_GET_INFO( apollo_mono19i/15i )
839		-------------------------------------------------*/
840
841		DEVICE_GET_INFO( apollo_mono19i ) {
842		switch (state) {
843		/* --- the following bits of info are returned as 64-bit signed integers --- */
844		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(screen_data_t); break;
845
846		/* --- the following bits of info are returned as pointers to data or functions --- */
847		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(apollo_mono19i); break;
848		case DEVINFO_FCT_STOP: /* Nothing */ break;
849		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(apollo_mono19i); break;
850
851		/* --- the following bits of info are returned as NULL-terminated strings --- */
852		case DEVINFO_STR_NAME: strcpy(info->s, "Apollo 19\" Monochrome Screen"); break;
853		case DEVINFO_STR_FAMILY: strcpy(info->s, "Terminal"); break;
854		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
855		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
856		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
857		}
858		}
859
860		DEVICE_GET_INFO( apollo_mono15i ) {
861		switch (state) {
862		/* --- the following bits of info are returned as 64-bit signed integers --- */
863		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(screen_data_t); break;
864
865		/* --- the following bits of info are returned as pointers to data or functions --- */
866		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(apollo_mono15i); break;
867		case DEVINFO_FCT_STOP: /* Nothing */ break;
868		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(apollo_mono15i); break;
869
870		/* --- the following bits of info are returned as NULL-terminated strings --- */
871		case DEVINFO_STR_NAME: strcpy(info->s, "Apollo 15\" Monochrome Screen"); break;
872		case DEVINFO_STR_FAMILY: strcpy(info->s, "Terminal"); break;
873		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
874		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
875		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
876		}
877		}
878
879	837	apollo_mono_device::apollo_mono_device(const machine_config &mconfig, device_type type, const char name, const char tag, device_t *owner, UINT32 clock)
880	838	: device_t(mconfig, type, name, tag, owner, clock)
881	839	{

trunk/src/mess/video/vic4567.c
r17616	r17617
2150	2150	}
2151	2151
2152	2152
2153		/*-------------------------------------------------
2154		device definition
2155		-------------------------------------------------*/
2156
2157		DEVICE_GET_INFO(vic3)
2158		{
2159		switch (state)
2160		{
2161		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vic3_state); break;
2162
2163		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vic3); break;
2164
2165		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(vic3); break;
2166
2167		case DEVINFO_STR_NAME: strcpy(info->s, "4567 VIC III"); break;
2168		}
2169		}
2170
2171	2153	const device_type VIC3 = &device_creator<vic3_device>;
2172	2154
2173	2155	vic3_device::vic3_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/vtvideo.c
r17616	r17617
448	448	vt->skip_lines = 2; // for 60Hz
449	449	}
450	450
451		/*-------------------------------------------------
452		DEVICE_GET_INFO( vt100_video )
453		-------------------------------------------------*/
454
455		DEVICE_GET_INFO( vt100_video )
456		{
457		switch (state)
458		{
459		/* --- the following bits of info are returned as 64-bit signed integers --- */
460		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vt_video_t); break;
461
462		/* --- the following bits of info are returned as pointers to data or functions --- */
463		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vt_video); break;
464		case DEVINFO_FCT_STOP: /* Nothing */ break;
465		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(vt_video); break;
466
467		/* --- the following bits of info are returned as NULL-terminated strings --- */
468		case DEVINFO_STR_NAME: strcpy(info->s, "VT100 Video"); break;
469		case DEVINFO_STR_FAMILY: strcpy(info->s, "VTxxx Video"); break;
470		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
471		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
472		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
473		}
474		}
475
476	451	const device_type VT100_VIDEO = &device_creator<vt100_video_device>;
477	452
478	453	vt100_video_device::vt100_video_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/vdc8563.c
r17616	r17617
658	658	vdc8563->changed = 0;
659	659	}
660	660
661		/*-------------------------------------------------
662		device definition
663		-------------------------------------------------*/
664
665		DEVICE_GET_INFO(vdc8563)
666		{
667		switch (state)
668		{
669		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vdc8563_state); break;
670
671		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vdc8563); break;
672
673		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(vdc8563); break;
674
675		case DEVINFO_STR_NAME: strcpy(info->s, "8563 / 8568 VDC"); break;
676		}
677		}
678
679	661	const device_type VDC8563 = &device_creator<vdc8563_device>;
680	662
681	663	vdc8563_device::vdc8563_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/vic6567.c
r17616	r17617
2800	2800	}
2801	2801
2802	2802
2803		/*-------------------------------------------------
2804		device definition
2805		-------------------------------------------------*/
2806
2807		DEVICE_GET_INFO(vic2)
2808		{
2809		switch (state)
2810		{
2811		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(vic2_state); break;
2812
2813		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(vic2); break;
2814
2815		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(vic2); break;
2816
2817		case DEVINFO_STR_NAME: strcpy(info->s, "6567 / 6569 VIC II"); break;
2818		}
2819		}
2820
2821	2803	const device_type VIC2 = &device_creator<vic2_device>;
2822	2804
2823	2805	vic2_device::vic2_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/odyssey2.c
r17616	r17617
619	619	}
620	620
621	621
622		DEVICE_GET_INFO( odyssey2_sound )
623		{
624		switch (state)
625		{
626		/* --- the following bits of info are returned as pointers to data or functions --- */
627		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(odyssey2_sound); break;
628
629		/* --- the following bits of info are returned as NULL-terminated strings --- */
630		case DEVINFO_STR_NAME: strcpy(info->s, "P8244/P8245"); break;
631		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
632		}
633		}
634
635	622	STREAM_UPDATE( odyssey2_sh_update )
636	623	{
637	624	odyssey2_state *state = device->machine().driver_data<odyssey2_state>();

trunk/src/mess/video/crt.c
r17616	r17617
99	99	}
100	100
101	101
102		DEVICE_GET_INFO( crt )
103		{
104		switch (state)
105		{
106		/* --- the following bits of info are returned as 64-bit signed integers --- */
107		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(crt_t); break;
108
109		/* --- the following bits of info are returned as pointers to data or functions --- */
110		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(crt); break;
111
112		/* --- the following bits of info are returned as NULL-terminated strings --- */
113		case DEVINFO_STR_NAME: strcpy(info->s, "CRT Video"); break;
114		case DEVINFO_STR_FAMILY: strcpy(info->s, "CRT Video"); break;
115		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
116		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
117		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
118		}
119		}
120
121	102	const device_type CRT = &device_creator<crt_device>;
122	103
123	104	crt_device::crt_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/dl1416.c
r17616	r17617
171	171	}
172	172
173	173
174		DEVICE_GET_INFO( dl1416 )
175		{
176		switch (state)
177		{
178		/* --- the following bits of info are returned as 64-bit signed integers --- */
179		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(dl1416_state); break;
180
181		/* --- the following bits of info are returned as pointers to data or functions --- */
182		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( dl1416 ); break;
183		case DEVINFO_FCT_STOP: /* Nothing */ break;
184		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( dl1416 ); break;
185
186		/* --- the following bits of info are returned as NULL-terminated strings --- */
187		case DEVINFO_STR_NAME: strcpy(info->s, "DL1416"); break;
188		case DEVINFO_STR_FAMILY: strcpy(info->s, "DL1416"); break;
189		case DEVINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
190		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
191		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
192		}
193		}
194
195		DEVICE_GET_INFO( dl1416b )
196		{
197		switch (state)
198		{
199		/* --- the following bits of info are returned as NULL-terminated strings --- */
200		case DEVINFO_STR_NAME: strcpy(info->s, "DL1416B"); break;
201		default: DEVICE_GET_INFO_CALL(dl1416); break;
202		}
203		}
204
205		DEVICE_GET_INFO( dl1416t )
206		{
207		switch (state)
208		{
209		/* --- the following bits of info are returned as NULL-terminated strings --- */
210		case DEVINFO_STR_NAME: strcpy(info->s, "DL1416T"); break;
211		default: DEVICE_GET_INFO_CALL(dl1416); break;
212		}
213		}
214
215	174	/*****************************************************************************
216	175	IMPLEMENTATION
217	176	*****************************************************************************/

trunk/src/mess/video/733_asr.c
r17616	r17617
216	216	asr_field_interrupt(device);
217	217	}
218	218
219		DEVICE_GET_INFO( asr733 )
220		{
221		switch (state)
222		{
223		/* --- the following bits of info are returned as 64-bit signed integers --- */
224		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(asr_t); break;
225
226		/* --- the following bits of info are returned as pointers to data or functions --- */
227		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(asr733); break;
228		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(asr733); break;
229
230		/* --- the following bits of info are returned as NULL-terminated strings --- */
231		case DEVINFO_STR_NAME: strcpy(info->s, "733 ASR"); break;
232		case DEVINFO_STR_FAMILY: strcpy(info->s, "733 ASR Video"); break;
233		case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break;
234		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
235		case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break;
236		}
237		}
238
239	219	const device_type ASR733 = &device_creator<asr733_device>;
240	220
241	221	asr733_device::asr733_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/video/k1ge.c
r17616	r17617
892	892	}
893	893
894	894
895		DEVICE_GET_INFO( k1ge )
896		{
897		switch ( state )
898		{
899		/* --- the following bits of info are returned as 64-bit signed integers --- */
900		case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof( k1ge_t ); break;
901
902		/* --- the following bits of info are returned as pointers to data or functions --- */
903		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k1ge ); break;
904		case DEVINFO_FCT_STOP: break;
905		case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME( k1ge ); break;
906
907		/* --- the following bits of info are returned as NULL-terminated strings --- */
908		case DEVINFO_STR_NAME: strcpy( info->s, "SNK K1GE" ); break;
909		case DEVINFO_STR_FAMILY: strcpy( info->s, "KxGE" ); break;
910		case DEVINFO_STR_VERSION: strcpy( info->s, "1.0" ); break;
911		case DEVINFO_STR_SOURCE_FILE: strcpy( info->s, __FILE__ );
912		case DEVINFO_STR_CREDITS: strcpy( info->s, "Copyright the MESS team" ); break;
913		}
914		}
915
916
917		DEVICE_GET_INFO( k2ge )
918		{
919		switch ( state )
920		{
921		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME( k2ge ); break;
922		default: DEVICE_GET_INFO_CALL( k1ge ); break;
923		}
924		}
925
926	895	const device_type K1GE = &device_creator<k1ge_device>;
927	896
928	897	k1ge_device::k1ge_device(const machine_config &mconfig, const char tag, device_t owner, UINT32 clock)

trunk/src/mess/drivers/pv1000.c
r17616	r17617
340	340	}
341	341
342	342
343		DEVICE_GET_INFO( pv1000_sound )
344		{
345		switch (state)
346		{
347		/* --- the following bits of info are returned as pointers to data or functions --- */
348		case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(pv1000_sound); break;
349
350		/* --- the following bits of info are returned as NULL-terminated strings --- */
351		case DEVINFO_STR_NAME: strcpy(info->s, "NEC D65010G031"); break;
352		case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
353		}
354		}
355
356
357	343	/* Interrupt is triggering 16 times during vblank. */
358	344	/* we have chosen to trigger on scanlines 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255 */
359	345	static TIMER_CALLBACK( d65010_irq_on_cb )

199869 Revisions