Previous

199869 Revisions

Next

r24638 Thursday 1st August, 2013 at 23:50:39 UTC by Tafoid
Modernized the Seibu ADPCM device and converted the Seibu sound system to be a device.  [Osso]

[src/mame/audio]	seibu.c seibu.h
[src/mame/drivers]	bloodbro.c cabal.c cshooter.c dcon.c deadang.c dynduke.c goodejan.c legionna.c mustache.c nmk16.c r2dx_v33.c raiden.c raiden2.c sengokmj.c shanghai.c toki.c
[src/mame/includes]	cabal.h deadang.h dynduke.h mustache.h nmk16.h raiden.h raiden2.h toki.h
[src/mame/machine]	seicop.c

trunk/src/mame/machine/seicop.c

r24637	r24638
1592	1592	*/
1593	1593
1594	1594	#include "emu.h"
1595		#include "audio/seibu.h"
1596	1595	#include "includes/legionna.h"
1597	1596	#include "includes/raiden2.h"
1598	1597	#include "machine/seicop.h"
r24637	r24638
3079	3078	READ16_HANDLER( heatbrl_mcu_r )
3080	3079	{
3081	3080	if(offset >= 0x3c0/2 && offset <= 0x3df/2)
3082		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3081	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3083	3082
3084	3083	if(offset >= 0x340/2 && offset <= 0x34f/2)
3085	3084	{
r24637	r24638
3114	3113
3115	3114	if(offset >= 0x3c0/2 && offset <= 0x3df/2)
3116	3115	{
3117		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3116	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3118	3117	return;
3119	3118	}
3120	3119
r24637	r24638
3130	3129	READ16_HANDLER( cupsoc_mcu_r )
3131	3130	{
3132	3131	if(offset >= 0x300/2 && offset <= 0x31f/2)
3133		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3132	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3134	3133
3135	3134	if(offset >= 0x340/2 && offset <= 0x34f/2)
3136	3135	{
r24637	r24638
3163	3162
3164	3163	if(offset >= 0x300/2 && offset <= 0x31f/2)
3165	3164	{
3166		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3165	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3167	3166	return;
3168	3167	}
3169	3168
r24637	r24638
3173	3172	READ16_HANDLER( cupsocs_mcu_r )
3174	3173	{
3175	3174	if(offset >= 0x340/2 && offset <= 0x35f/2)
3176		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3175	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3177	3176
3178	3177	if(offset >= 0x300/2 && offset <= 0x30f/2)
3179	3178	{
r24637	r24638
3212	3211
3213	3212	if(offset >= 0x340/2 && offset <= 0x35f/2)
3214	3213	{
3215		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3214	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3216	3215	return;
3217	3216	}
3218	3217
r24637	r24638
3226	3225	READ16_HANDLER( godzilla_mcu_r )
3227	3226	{
3228	3227	if(offset >= 0x300/2 && offset <= 0x31f/2)
3229		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3228	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3230	3229
3231	3230	if(offset >= 0x340/2 && offset <= 0x34f/2)
3232	3231	{
r24637	r24638
3260	3259
3261	3260	if(offset >= 0x300/2 && offset <= 0x31f/2)
3262	3261	{
3263		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3262	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3264	3263	return;
3265	3264	}
3266	3265
r24637	r24638
3274	3273	READ16_HANDLER( denjinmk_mcu_r )
3275	3274	{
3276	3275	if(offset >= 0x300/2 && offset <= 0x31f/2)
3277		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3276	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3278	3277
3279	3278	if(offset >= 0x340/2 && offset <= 0x34f/2)
3280	3279	{
r24637	r24638
3313	3312
3314	3313	if(offset >= 0x300/2 && offset <= 0x31f/2)
3315	3314	{
3316		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3315	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3317	3316	return;
3318	3317	}
3319	3318
r24637	r24638
3327	3326	READ16_HANDLER( grainbow_mcu_r )
3328	3327	{
3329	3328	if(offset >= 0x300/2 && offset <= 0x31f/2)
3330		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3329	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3331	3330
3332	3331	if(offset >= 0x340/2 && offset <= 0x34f/2)
3333	3332	{
r24637	r24638
3361	3360
3362	3361	if(offset >= 0x300/2 && offset <= 0x31f/2)
3363	3362	{
3364		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3363	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3365	3364	return;
3366	3365	}
3367	3366
r24637	r24638
3376	3375	READ16_HANDLER( legionna_mcu_r )
3377	3376	{
3378	3377	if(offset >= 0x300/2 && offset <= 0x31f/2)
3379		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	3378	return space.machine().device<seibu_sound_device>("seibu_sound")->main_word_r(space,(offset >> 1) & 7,0xffff);
3380	3379
3381	3380	if(offset >= 0x340/2 && offset <= 0x34f/2)
3382	3381	{
r24637	r24638
3407	3406
3408	3407	if(offset >= 0x300/2 && offset <= 0x31f/2)
3409	3408	{
3410		seibu_main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
	3409	space.machine().device<seibu_sound_device>("seibu_sound")->main_word_w(space,(offset >> 1) & 7,cop_mcu_ram[offset],0x00ff);
3411	3410	return;
3412	3411	}
3413	3412

trunk/src/mame/includes/raiden.h

r24637	r24638
4	4
5	5	*******************************************************************************/
6	6
	7	#include "audio/seibu.h"
7	8	#include "video/bufsprite.h"
8	9
9	10	class raiden_state : public driver_device
r24637	r24638
12	13	raiden_state(const machine_config &mconfig, device_type type, const char *tag)
13	14	: driver_device(mconfig, type, tag),
14	15	m_maincpu(*this, "maincpu"),
	16	m_seibu_sound(*this, "seibu_sound"),
15	17	m_spriteram(*this, "spriteram"),
16	18	m_shared_ram(*this, "shared_ram"),
17	19	m_videoram(*this, "videoram"),
r24637	r24638
21	23	{ }
22	24
23	25	required_device<cpu_device> m_maincpu;
	26	required_device<seibu_sound_device> m_seibu_sound;
24	27	required_device<buffered_spriteram16_device> m_spriteram;
25	28	required_shared_ptr<UINT16> m_shared_ram;
26	29	required_shared_ptr<UINT16> m_videoram;

trunk/src/mame/includes/dynduke.h

r24637	r24638
	1	#include "audio/seibu.h"
1	2	#include "video/bufsprite.h"
2	3
3	4	class dynduke_state : public driver_device
r24637	r24638
10	11	m_videoram(*this, "videoram"),
11	12	m_back_data(*this, "back_data"),
12	13	m_fore_data(*this, "fore_data"),
13		m_maincpu(*this, "maincpu") { }
	14	m_maincpu(*this, "maincpu"),
	15	m_seibu_sound(*this, "seibu_sound") { }
14	16
15	17	required_device<buffered_spriteram16_device> m_spriteram;
16	18	required_shared_ptr<UINT16> m_scroll_ram;
17	19	required_shared_ptr<UINT16> m_videoram;
18	20	required_shared_ptr<UINT16> m_back_data;
19	21	required_shared_ptr<UINT16> m_fore_data;
	22
	23	required_device<cpu_device> m_maincpu;
	24	required_device<seibu_sound_device> m_seibu_sound;
20	25
21	26	tilemap_t *m_bg_layer;
22	27	tilemap_t *m_fg_layer;
r24637	r24638
45	50	INTERRUPT_GEN_MEMBER(dynduke_interrupt);
46	51	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,int pri);
47	52	void draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
48		required_device<cpu_device> m_maincpu;
49	53	};

trunk/src/mame/includes/deadang.h

r24637	r24638
	1	#include "audio/seibu.h"
	2
1	3	class deadang_state : public driver_device
2	4	{
3	5	public:
r24637	r24638
8	10	m_scroll_ram(*this, "scroll_ram"),
9	11	m_video_data(*this, "video_data"),
10	12	m_maincpu(*this, "maincpu"),
11		m_subcpu(*this, "sub") { }
	13	m_subcpu(*this, "sub"),
	14	m_seibu_sound(*this, "seibu_sound"),
	15	m_adpcm1(*this, "adpcm1"),
	16	m_adpcm2(*this, "adpcm2") { }
12	17
13	18	required_shared_ptr<UINT16> m_spriteram;
14	19	required_shared_ptr<UINT16> m_videoram;
15	20	required_shared_ptr<UINT16> m_scroll_ram;
16	21	required_shared_ptr<UINT16> m_video_data;
	22
	23	required_device<cpu_device> m_maincpu;
	24	required_device<cpu_device> m_subcpu;
	25	required_device<seibu_sound_device> m_seibu_sound;
	26	required_device<seibu_adpcm_device> m_adpcm1;
	27	required_device<seibu_adpcm_device> m_adpcm2;
	28
17	29	tilemap_t *m_pf3_layer;
18	30	tilemap_t *m_pf2_layer;
19	31	tilemap_t *m_pf1_layer;
r24637	r24638
38	50	TIMER_DEVICE_CALLBACK_MEMBER(deadang_main_scanline);
39	51	TIMER_DEVICE_CALLBACK_MEMBER(deadang_sub_scanline);
40	52	void draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
41		required_device<cpu_device> m_maincpu;
42		required_device<cpu_device> m_subcpu;
43	53	};

trunk/src/mame/includes/toki.h

r24637	r24638
	1	#include "audio/seibu.h"
	2	#include "sound/msm5205.h"
1	3	#include "video/bufsprite.h"
2		#include "sound/msm5205.h"
3	4
4	5	class toki_state : public driver_device
5	6	{
r24637	r24638
13	14	m_scrollram16(*this, "scrollram16"),
14	15	m_maincpu(*this, "maincpu"),
15	16	m_audiocpu(*this, "audiocpu"),
	17	m_seibu_sound(*this, "seibu_sound"),
16	18	m_msm(*this, "msm") { }
17	19
18	20	required_device<buffered_spriteram16_device> m_spriteram;
r24637	r24638
20	22	required_shared_ptr<UINT16> m_background2_videoram16;
21	23	required_shared_ptr<UINT16> m_videoram;
22	24	required_shared_ptr<UINT16> m_scrollram16;
	25
	26	required_device<cpu_device> m_maincpu;
	27	required_device<cpu_device> m_audiocpu;
	28	optional_device<seibu_sound_device> m_seibu_sound;
	29	optional_device<msm5205_device> m_msm;
23	30
24	31	int m_msm5205next;
25	32	int m_toggle;
r24637	r24638
47	54	void toki_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
48	55	void tokib_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
49	56	DECLARE_WRITE_LINE_MEMBER(toki_adpcm_int);
50		required_device<cpu_device> m_maincpu;
51		required_device<cpu_device> m_audiocpu;
52		optional_device<msm5205_device> m_msm;
53	57	};

trunk/src/mame/includes/cabal.h

r24637	r24638
	1	#include "audio/seibu.h"
1	2	#include "sound/msm5205.h"
	3
2	4	class cabal_state : public driver_device
3	5	{
4	6	public:
r24637	r24638
9	11	m_videoram(*this, "videoram"),
10	12	m_maincpu(*this, "maincpu"),
11	13	m_audiocpu(*this, "audiocpu"),
	14	m_seibu_sound(*this, "seibu_sound"),
	15	m_adpcm1(*this, "adpcm1"),
	16	m_adpcm2(*this, "adpcm2"),
12	17	m_msm1(*this, "msm1"),
13	18	m_msm2(*this, "msm2") { }
14	19
15	20	required_shared_ptr<UINT16> m_spriteram;
16	21	required_shared_ptr<UINT16> m_colorram;
17	22	required_shared_ptr<UINT16> m_videoram;
	23
	24	required_device<cpu_device> m_maincpu;
	25	required_device<cpu_device> m_audiocpu;
	26	optional_device<seibu_sound_device> m_seibu_sound;
	27	optional_device<seibu_adpcm_device> m_adpcm1;
	28	optional_device<seibu_adpcm_device> m_adpcm2;
	29	optional_device<msm5205_device> m_msm1;
	30	optional_device<msm5205_device> m_msm2;
	31
18	32	tilemap_t *m_background_layer;
19	33	tilemap_t *m_text_layer;
20	34	int m_sound_command1;
r24637	r24638
42	56	UINT32 screen_update_cabal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	57	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
44	58	void seibu_sound_bootleg(const char *cpu,int length);
45		required_device<cpu_device> m_maincpu;
46		required_device<cpu_device> m_audiocpu;
47		optional_device<msm5205_device> m_msm1;
48		optional_device<msm5205_device> m_msm2;
49	59	};

trunk/src/mame/includes/raiden2.h

r24637	r24638
	1	#include "audio/seibu.h"
	2
1	3	class raiden2_state : public driver_device
2	4	{
3	5	public:
r24637	r24638
8	10	mid_data(*this, "mid_data"),
9	11	text_data(*this, "text_data"),
10	12	sprites(*this, "sprites") ,
11		m_maincpu(*this, "maincpu") { }
	13	m_maincpu(*this, "maincpu"),
	14	m_seibu_sound(*this, "seibu_sound") { }
	15
	16	required_shared_ptr<UINT16> back_data,fore_data,mid_data, text_data, sprites;
	17	required_device<cpu_device> m_maincpu;
	18	required_device<seibu_sound_device> m_seibu_sound;
12	19
13	20	DECLARE_WRITE16_MEMBER( cop_itoa_low_w );
14	21	DECLARE_WRITE16_MEMBER( cop_itoa_high_w );
r24637	r24638
79	86	void common_reset();
80	87
81	88	tilemap_t *background_layer,*midground_layer,*foreground_layer,*text_layer;
82		required_shared_ptr<UINT16> back_data,fore_data,mid_data, text_data, sprites;
83	89	int bg_bank, fg_bank, mid_bank;
84	90	UINT16 raiden2_tilemap_enable;
85	91	UINT8 prg_bank,prot_data;
r24637	r24638
158	164	const UINT8 fade_table(int v);
159	165	void combine32(UINT32 *val, int offset, UINT16 data, UINT16 mem_mask);
160	166	void sprcpt_init(void);
161		required_device<cpu_device> m_maincpu;
162	167	};
163	168
164	169	/*----------- defined in machine/r2crypt.c -----------*/

trunk/src/mame/includes/nmk16.h

r24637	r24638
136	136	TILE_GET_INFO_MEMBER(macross_get_tx_tile_info);
137	137	TILE_GET_INFO_MEMBER(bjtwin_get_bg_tile_info);
138	138	TILE_GET_INFO_MEMBER(get_tile_info_0_8bit);
139		DECLARE_MACHINE_RESET(mustang_sound);
140	139	DECLARE_VIDEO_START(macross);
141	140	DECLARE_MACHINE_RESET(NMK004);
142	141	DECLARE_VIDEO_START(bioship);

trunk/src/mame/includes/mustache.h

r24637	r24638
	1	#include "audio/seibu.h"    // for seibu_sound_decrypt on the MAIN cpu (not sound)
	2
1	3	class mustache_state : public driver_device
2	4	{
3	5	public:
r24637	r24638
5	7	: driver_device(mconfig, type, tag),
6	8	m_videoram(*this, "videoram"),
7	9	m_spriteram(*this, "spriteram"),
8		m_maincpu(*this, "maincpu") { }
	10	m_maincpu(*this, "maincpu"),
	11	m_cpu_decrypt(*this, "seibu_sound") { }
9	12
10	13	required_shared_ptr<UINT8> m_videoram;
	14	required_shared_ptr<UINT8> m_spriteram;
	15
	16	required_device<cpu_device> m_maincpu;
	17	required_device<seibu_sound_device> m_cpu_decrypt;
	18
11	19	tilemap_t *m_bg_tilemap;
12	20	int m_control_byte;
13		required_shared_ptr<UINT8> m_spriteram;
14	21	DECLARE_WRITE8_MEMBER(mustache_videoram_w);
15	22	DECLARE_WRITE8_MEMBER(mustache_video_control_w);
16	23	DECLARE_WRITE8_MEMBER(mustache_scroll_w);
r24637	r24638
21	28	UINT32 screen_update_mustache(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
22	29	TIMER_DEVICE_CALLBACK_MEMBER(mustache_scanline);
23	30	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
24		required_device<cpu_device> m_maincpu;
25	31	};

trunk/src/mame/drivers/deadang.c

r24637	r24638
38	38
39	39	#include "emu.h"
40	40	#include "cpu/nec/nec.h"
41		#include "audio/seibu.h"
42	41	#include "sound/2203intf.h"
43	42	#include "sound/msm5205.h"
44	43	#include "includes/deadang.h"
45		#include "drivlgcy.h"
46	44
	45
47	46	/* Read/Write Handlers */
48	47
49	48	READ16_MEMBER(deadang_state::ghunter_trackball_low_r)
r24637	r24638
62	61	AM_RANGE(0x03800, 0x03fff) AM_RAM AM_SHARE("spriteram")
63	62	AM_RANGE(0x04000, 0x04fff) AM_RAM AM_SHARE("share1")
64	63	AM_RANGE(0x05000, 0x05fff) AM_WRITEONLY
65		AM_RANGE(0x06000, 0x0600f) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	64	AM_RANGE(0x06000, 0x0600f) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
66	65	AM_RANGE(0x06010, 0x07fff) AM_WRITEONLY
67	66	AM_RANGE(0x08000, 0x087ff) AM_WRITE(deadang_text_w) AM_SHARE("videoram")
68	67	AM_RANGE(0x08800, 0x0bfff) AM_WRITEONLY
r24637	r24638
246	245
247	246	MCFG_QUANTUM_TIME(attotime::from_hz(60)) // the game stops working with higher interleave rates..
248	247
249		MCFG_MACHINE_RESET(seibu_sound)
250
251	248	/* video hardware */
252	249	MCFG_SCREEN_ADD("screen", RASTER)
253	250	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
412	409
413	410	DRIVER_INIT_MEMBER(deadang_state,deadang)
414	411	{
415		seibu_sound_decrypt(machine(), "audiocpu", 0x2000);
416		seibu_adpcm_decrypt(machine(), "adpcm1");
417		seibu_adpcm_decrypt(machine(), "adpcm2");
	412	m_seibu_sound->decrypt("audiocpu", 0x2000);
	413	m_adpcm1->decrypt("adpcm1");
	414	m_adpcm2->decrypt("adpcm2");
418	415	}
419	416
420	417	DRIVER_INIT_MEMBER(deadang_state,ghunter)
421	418	{
422		seibu_sound_decrypt(machine(), "audiocpu", 0x2000);
423		seibu_adpcm_decrypt(machine(), "adpcm1");
424		seibu_adpcm_decrypt(machine(), "adpcm2");
	419	m_seibu_sound->decrypt("audiocpu", 0x2000);
	420	m_adpcm1->decrypt("adpcm1");
	421	m_adpcm2->decrypt("adpcm2");
425	422
426	423	m_maincpu->space(AS_PROGRAM).install_read_handler(0x80000, 0x80001, read16_delegate(FUNC(deadang_state::ghunter_trackball_low_r),this));
427	424	m_maincpu->space(AS_PROGRAM).install_read_handler(0xb0000, 0xb0001, read16_delegate(FUNC(deadang_state::ghunter_trackball_high_r),this));

trunk/src/mame/drivers/goodejan.c

r24637	r24638
55	55	#include "audio/seibu.h"
56	56	#include "sound/3812intf.h"
57	57	#include "video/seibu_crtc.h"
58		#include "drivlgcy.h"
59	58
60	59
61	60	class goodejan_state : public driver_device
r24637	r24638
417	416	AM_RANGE(0xc000, 0xc001) AM_READ_PORT("DSW1")
418	417	AM_RANGE(0xc002, 0xc003) AM_READ(mahjong_panel_r)
419	418	AM_RANGE(0xc004, 0xc005) AM_READ_PORT("DSW2") // switches
420		AM_RANGE(0xd000, 0xd00f) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	419	AM_RANGE(0xd000, 0xd00f) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
421	420	ADDRESS_MAP_END
422	421
423	422	static ADDRESS_MAP_START( totmejan_io_map, AS_IO, 16, goodejan_state )
r24637	r24638
656	655
657	656	SEIBU_SOUND_SYSTEM_CPU(GOODEJAN_MHZ1/2)
658	657
659		MCFG_MACHINE_RESET(seibu_sound)
660
661	658	/* video hardware */
662	659	MCFG_SCREEN_ADD("screen", RASTER)
663	660	MCFG_SCREEN_REFRESH_RATE(60)

trunk/src/mame/drivers/cabal.c

r24637	r24638
49	49	#include "cpu/z80/z80.h"
50	50	#include "sound/2151intf.h"
51	51	#include "sound/msm5205.h"
52		#include "audio/seibu.h"
53	52	#include "includes/cabal.h"
54		#include "drivlgcy.h"
55	53
56	54	MACHINE_RESET_MEMBER(cabal_state,cabalbl)
57	55	{
r24637	r24638
101	99
102	100	WRITE16_MEMBER(cabal_state::cabal_sound_irq_trigger_word_w)
103	101	{
104		seibu_main_word_w(space,4,data,mem_mask);
	102	m_seibu_sound->main_word_w(space,4,data,mem_mask);
105	103
106	104	/* spin for a while to let the Z80 read the command, otherwise coins "stick" */
107	105	space.device().execute().spin_until_time(attotime::from_usec(50));
r24637	r24638
130	128	AM_RANGE(0xc0080, 0xc0081) AM_WRITE(cabal_flipscreen_w)
131	129	AM_RANGE(0xe0000, 0xe07ff) AM_RAM_WRITE(paletteram_xxxxBBBBGGGGRRRR_word_w) AM_SHARE("paletteram")
132	130	AM_RANGE(0xe8008, 0xe8009) AM_WRITE(cabal_sound_irq_trigger_word_w) // fix coin insertion
133		AM_RANGE(0xe8000, 0xe800d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	131	AM_RANGE(0xe8000, 0xe800d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
134	132	ADDRESS_MAP_END
135	133
136	134	static ADDRESS_MAP_START( cabalbl_main_map, AS_PROGRAM, 16, cabal_state )
r24637	r24638
176	174	static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8, cabal_state )
177	175	AM_RANGE(0x0000, 0x1fff) AM_ROM
178	176	AM_RANGE(0x2000, 0x27ff) AM_RAM
179		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
180		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
181		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
182		AM_RANGE(0x4005, 0x4006) AM_DEVWRITE_LEGACY("adpcm1", seibu_adpcm_adr_w)
	177	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	178	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	179	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
	180	AM_RANGE(0x4005, 0x4006) AM_DEVWRITE("adpcm1", seibu_adpcm_device, adr_w)
183	181	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
184		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
185		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	182	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	183	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
186	184	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
187		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
188		AM_RANGE(0x401a, 0x401a) AM_DEVWRITE_LEGACY("adpcm1", seibu_adpcm_ctl_w)
189		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
190		AM_RANGE(0x6005, 0x6006) AM_DEVWRITE_LEGACY("adpcm2", seibu_adpcm_adr_w)
191		AM_RANGE(0x601a, 0x601a) AM_DEVWRITE_LEGACY("adpcm2", seibu_adpcm_ctl_w)
	185	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	186	AM_RANGE(0x401a, 0x401a) AM_DEVWRITE("adpcm1", seibu_adpcm_device, ctl_w)
	187	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
	188	AM_RANGE(0x6005, 0x6006) AM_DEVWRITE("adpcm2", seibu_adpcm_device, adr_w)
	189	AM_RANGE(0x601a, 0x601a) AM_DEVWRITE("adpcm2", seibu_adpcm_device, ctl_w)
192	190	AM_RANGE(0x8000, 0xffff) AM_ROM
193	191	ADDRESS_MAP_END
194	192
r24637	r24638
482	480	MCFG_CPU_ADD("audiocpu", Z80, XTAL_3_579545MHz) /* verified on pcb */
483	481	MCFG_CPU_PROGRAM_MAP(sound_map)
484	482
485		MCFG_MACHINE_RESET(seibu_sound)
486
487	483	/* video hardware */
488	484	MCFG_SCREEN_ADD("screen", RASTER)
489	485	MCFG_SCREEN_REFRESH_RATE(59.60)   /* verified on pcb */
r24637	r24638
497	493
498	494
499	495	/* sound hardware */
	496	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	497
500	498	MCFG_SPEAKER_STANDARD_MONO("mono")
501	499
502	500	MCFG_YM2151_ADD("ymsnd", XTAL_3_579545MHz) /* verified on pcb */
503		MCFG_YM2151_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2151_irqhandler>))
	501	MCFG_YM2151_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2151_irqhandler))
504	502	MCFG_SOUND_ROUTE(ALL_OUTPUTS,"mono", 0.80)
505	503
506	504	MCFG_SOUND_ADD("adpcm1", SEIBU_ADPCM, 8000) /* it should use the msm5205 */
r24637	r24638
525	523	MCFG_CPU_PROGRAM_MAP(cabalbl_sound_map)
526	524
527	525	/* there are 2x z80s for the ADPCM */
528		MCFG_CPU_ADD("adpcm1", Z80, XTAL_3_579545MHz) /* verified on pcb */
	526	MCFG_CPU_ADD("adpcm_1", Z80, XTAL_3_579545MHz) /* verified on pcb */
529	527	MCFG_CPU_PROGRAM_MAP(cabalbl_talk1_map)
530	528	MCFG_CPU_IO_MAP(cabalbl_talk1_portmap)
531	529	MCFG_CPU_PERIODIC_INT_DRIVER(cabal_state, irq0_line_hold, 8000)
532	530
533		MCFG_CPU_ADD("adpcm2", Z80, XTAL_3_579545MHz) /* verified on pcb */
	531	MCFG_CPU_ADD("adpcm_2", Z80, XTAL_3_579545MHz) /* verified on pcb */
534	532	MCFG_CPU_PROGRAM_MAP(cabalbl_talk2_map)
535	533	MCFG_CPU_IO_MAP(cabalbl_talk2_portmap)
536	534	MCFG_CPU_PERIODIC_INT_DRIVER(cabal_state, irq0_line_hold, 8000)
r24637	r24638
772	770	ROM_LOAD16_BYTE( "cabal_01.bin",   0x60000, 0x10000, CRC(55c44764) SHA1(7fad1f2084664b5b4d1384c8081371b0c79c4f5e) )
773	771	ROM_LOAD16_BYTE( "cabal_08.bin",   0x60001, 0x10000, CRC(702735c9) SHA1(e4ac799dc85ff5b7c8e578611605989c78f9e8b3) )
774	772
775		ROM_REGION( 0x10000, "adpcm1", 0 )
	773	ROM_REGION( 0x10000, "adpcm_1", 0 )
776	774	ROM_LOAD( "cabal_09.bin",   0x00000, 0x10000, CRC(4ffa7fe3) SHA1(381d8e765a7b94678fb3308965c748bbe9f8e247) ) /* Z80 code/adpcm data */
777	775
778		ROM_REGION( 0x10000, "adpcm2", 0 )
	776	ROM_REGION( 0x10000, "adpcm_2", 0 )
779	777	ROM_LOAD( "cabal_10.bin",   0x00000, 0x10000, CRC(958789b6) SHA1(344c3ee8a1e272b56499e5c0415bb714aec0ddcf) ) /* Z80 code/adpcm data */
780	778	ROM_END
781	779
r24637	r24638
849	847
850	848	DRIVER_INIT_MEMBER(cabal_state,cabal)
851	849	{
852		seibu_sound_decrypt(machine(),"audiocpu",0x2000);
853		seibu_adpcm_decrypt(machine(),"adpcm1");
854		seibu_adpcm_decrypt(machine(),"adpcm2");
	850	m_seibu_sound->decrypt("audiocpu",0x2000);
	851	m_adpcm1->decrypt("adpcm1");
	852	m_adpcm2->decrypt("adpcm2");
855	853	}
856	854
857	855	DRIVER_INIT_MEMBER(cabal_state,cabalbl2)
858	856	{
859	857	seibu_sound_bootleg("audiocpu",0x2000);
860		seibu_adpcm_decrypt(machine(),"adpcm1");
861		seibu_adpcm_decrypt(machine(),"adpcm2");
	858	m_adpcm1->decrypt("adpcm1");
	859	m_adpcm2->decrypt("adpcm2");
862	860	}
863	861
864	862

trunk/src/mame/drivers/nmk16.c

r24637	r24638
195	195	NMK004_init(machine());
196	196	}
197	197
198		MACHINE_RESET_MEMBER(nmk16_state,mustang_sound)
199		{
200		MACHINE_RESET_CALL_LEGACY(seibu_sound);
201		}
202
203	198	WRITE16_MEMBER(nmk16_state::ssmissin_sound_w)
204	199	{
205	200	if (ACCESSING_BITS_0_7)
r24637	r24638
425	420	AM_RANGE(0x08000e, 0x08000f) AM_NOP
426	421	AM_RANGE(0x080014, 0x080015) AM_WRITE(nmk_flipscreen_w)
427	422	AM_RANGE(0x080016, 0x080017) AM_WRITENOP    // frame number?
428		AM_RANGE(0x08001e, 0x08001f) AM_WRITE_LEGACY(seibu_main_mustb_w)
	423	AM_RANGE(0x08001e, 0x08001f) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_mustb_w)
429	424	AM_RANGE(0x088000, 0x0887ff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
430	425	AM_RANGE(0x08c000, 0x08c001) AM_WRITE(mustang_scroll_w)
431	426	AM_RANGE(0x08c002, 0x08c087) AM_WRITENOP    // ??
r24637	r24638
913	908	AM_RANGE(0x0c000a, 0x0c000b) AM_READ_PORT("DSW2")
914	909	AM_RANGE(0x0c0014, 0x0c0015) AM_WRITE(nmk_flipscreen_w) /* Maybe */
915	910	AM_RANGE(0x0c0018, 0x0c0019) AM_WRITE(nmk_tilebank_w) /* Tile Bank ? */
916		AM_RANGE(0x0c001e, 0x0c001f) AM_WRITE_LEGACY(seibu_main_mustb_w)
	911	AM_RANGE(0x0c001e, 0x0c001f) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_mustb_w)
917	912	AM_RANGE(0x0c4000, 0x0c4007) AM_RAM_WRITE(nmk_scroll_w)
918	913	AM_RANGE(0x0c8000, 0x0c87ff) AM_RAM_WRITE(paletteram_RRRRGGGGBBBBRGBx_word_w) AM_SHARE("paletteram")
919	914	AM_RANGE(0x0cc000, 0x0cffff) AM_RAM_WRITE(nmk_bgvideoram0_w) AM_SHARE("nmk_bgvideoram0")
r24637	r24638
3593	3588	MCFG_CPU_PROGRAM_MAP(tharrier_sound_map)
3594	3589	MCFG_CPU_IO_MAP(tharrier_sound_io_map)
3595	3590
3596		MCFG_MACHINE_RESET_OVERRIDE(nmk16_state,mustang_sound)
3597
3598	3591	/* video hardware */
3599	3592	MCFG_SCREEN_ADD("screen", RASTER)
3600	3593	MCFG_SCREEN_REFRESH_RATE(56)
r24637	r24638
3723	3716
3724	3717	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
3725	3718
3726		MCFG_MACHINE_RESET_OVERRIDE(nmk16_state,mustang_sound)
3727
3728	3719	/* video hardware */
3729	3720	MCFG_SCREEN_ADD("screen", RASTER)
3730	3721	MCFG_SCREEN_REFRESH_RATE(56)
r24637	r24638
3919	3910
3920	3911	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
3921	3912
3922		MCFG_MACHINE_RESET_OVERRIDE(nmk16_state,mustang_sound)
3923
3924	3913	/* video hardware */
3925	3914	MCFG_SCREEN_ADD("screen", RASTER)
3926	3915	MCFG_SCREEN_REFRESH_RATE(56)

trunk/src/mame/drivers/raiden2.c

r24637	r24638
147	147	#include "emu.h"
148	148	#include "cpu/nec/nec.h"
149	149	#include "cpu/z80/z80.h"
150		#include "audio/seibu.h"
151	150	#include "machine/eepromser.h"
152	151	#include "sound/okim6295.h"
153	152	#include "includes/raiden2.h"
r24637	r24638
1176	1175	{
1177	1176	common_reset();
1178	1177	sprcpt_init();
1179		MACHINE_RESET_CALL_LEGACY(seibu_sound);
1180
	1178
1181	1179	membank("mainbank")->set_entry(1);
1182	1180
1183	1181	prg_bank = 0;
r24637	r24638
1188	1186	{
1189	1187	common_reset();
1190	1188	sprcpt_init();
1191		MACHINE_RESET_CALL_LEGACY(seibu_sound);
1192
	1189
1193	1190	membank("mainbank")->set_entry(8);
1194	1191
1195	1192	prg_bank = 0x08;
r24637	r24638
1203	1200	fg_bank = 2;
1204	1201	mid_bank = 1;
1205	1202	sprcpt_init();
1206		MACHINE_RESET_CALL_LEGACY(seibu_sound);
1207
	1203
1208	1204	membank("mainbank")->set_entry(1);
1209	1205
1210	1206	prg_bank = 0;
r24637	r24638
1217	1213	fg_bank = 2;
1218	1214	mid_bank = 1;
1219	1215	sprcpt_init();
1220		MACHINE_RESET_CALL_LEGACY(seibu_sound);
1221
	1216
1222	1217	//membank("mainbank")->set_entry(1);
1223	1218
1224	1219	//cop_init();
r24637	r24638
1226	1221
1227	1222	READ16_MEMBER(raiden2_state::raiden2_sound_comms_r)
1228	1223	{
1229		return seibu_main_word_r(space,(offset >> 1) & 7,0xffff);
	1224	return m_seibu_sound->main_word_r(space,(offset >> 1) & 7,0xffff);
1230	1225	}
1231	1226
1232	1227	WRITE16_MEMBER(raiden2_state::raiden2_sound_comms_w)
1233	1228	{
1234		seibu_main_word_w(space,(offset >> 1) & 7,data,0x00ff);
	1229	m_seibu_sound->main_word_w(space,(offset >> 1) & 7,data,0x00ff);
1235	1230	}
1236	1231
1237	1232	WRITE16_MEMBER(raiden2_state::raiden2_bank_w)

trunk/src/mame/drivers/raiden.c

r24637	r24638
50	50	#include "emu.h"
51	51	#include "cpu/nec/nec.h"
52	52	#include "cpu/z80/z80.h"
53		#include "audio/seibu.h"
54	53	#include "sound/3812intf.h"
55	54	#include "sound/okim6295.h"
56	55	#include "includes/raiden.h"
57	56	#include "video/seibu_crtc.h"
58		#include "drivlgcy.h"
59	57
60	58
61	59	/******************************************************************************/
r24637	r24638
64	62	AM_RANGE(0x00000, 0x06fff) AM_RAM
65	63	AM_RANGE(0x07000, 0x07fff) AM_RAM AM_SHARE("spriteram")
66	64	AM_RANGE(0x08000, 0x08fff) AM_RAM AM_SHARE("shared_ram")
67		AM_RANGE(0x0a000, 0x0a00d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	65	AM_RANGE(0x0a000, 0x0a00d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
68	66	AM_RANGE(0x0c000, 0x0c7ff) AM_WRITE(raiden_text_w) AM_SHARE("videoram")
69	67	AM_RANGE(0x0e000, 0x0e001) AM_READ_PORT("P1_P2")
70	68	AM_RANGE(0x0e002, 0x0e003) AM_READ_PORT("DSW")
r24637	r24638
99	97	AM_RANGE(0x0b004, 0x0b005) AM_WRITENOP // watchdog?
100	98	AM_RANGE(0x0b006, 0x0b007) AM_WRITE8(raiden_control_w, 0x00ff)
101	99	AM_RANGE(0x0c000, 0x0c7ff) AM_WRITE(raiden_text_w) AM_SHARE("videoram")
102		AM_RANGE(0x0d000, 0x0d00d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	100	AM_RANGE(0x0d000, 0x0d00d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
103	101	AM_RANGE(0xa0000, 0xfffff) AM_ROM
104	102	ADDRESS_MAP_END
105	103
r24637	r24638
126	124	AM_RANGE(0x0b004, 0x0b005) AM_WRITENOP // watchdog?
127	125	AM_RANGE(0x0b006, 0x0b007) AM_WRITE8(raidenb_control_w, 0x00ff)
128	126	AM_RANGE(0x0c000, 0x0c7ff) AM_WRITE(raiden_text_w) AM_SHARE("videoram")
129		AM_RANGE(0x0d000, 0x0d00d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	127	AM_RANGE(0x0d000, 0x0d00d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
130	128	AM_RANGE(0x0d040, 0x0d08f) AM_DEVREADWRITE("crtc", seibu_crtc_device, read, write)
131	129	AM_RANGE(0xa0000, 0xfffff) AM_ROM
132	130	ADDRESS_MAP_END
r24637	r24638
281	279
282	280	MCFG_QUANTUM_TIME(attotime::from_hz(12000))
283	281
284		MCFG_MACHINE_RESET(seibu_sound)
285
286	282	/* video hardware */
287	283	MCFG_BUFFERED_SPRITERAM16_ADD("spriteram")
288	284
r24637	r24638
620	616	DRIVER_INIT_MEMBER(raiden_state,raiden)
621	617	{
622	618	common_decrypt();
623		seibu_sound_decrypt(machine(),"audiocpu",0x20000);
	619	m_seibu_sound->decrypt("audiocpu",0x20000);
624	620	}
625	621
626	622	DRIVER_INIT_MEMBER(raiden_state,raidenk)
r24637	r24638
630	626
631	627	DRIVER_INIT_MEMBER(raiden_state,raidenu)
632	628	{
633		seibu_sound_decrypt(machine(),"audiocpu",0x20000);
	629	m_seibu_sound->decrypt("audiocpu",0x20000);
634	630	}
635	631
636	632

trunk/src/mame/drivers/dynduke.c

r24637	r24638
65	65	#include "emu.h"
66	66	#include "cpu/nec/nec.h"
67	67	#include "cpu/z80/z80.h"
68		#include "audio/seibu.h"
69	68	#include "sound/3812intf.h"
70	69	#include "sound/okim6295.h"
71	70	#include "includes/dynduke.h"
72		#include "drivlgcy.h"
73	71
	72
74	73	/* Memory Maps */
75	74
76	75	static ADDRESS_MAP_START( master_map, AS_PROGRAM, 16, dynduke_state )
r24637	r24638
83	82	AM_RANGE(0x0b004, 0x0b005) AM_WRITENOP
84	83	AM_RANGE(0x0b006, 0x0b007) AM_WRITE(dynduke_control_w)
85	84	AM_RANGE(0x0c000, 0x0c7ff) AM_RAM_WRITE(dynduke_text_w) AM_SHARE("videoram")
86		AM_RANGE(0x0d000, 0x0d00d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	85	AM_RANGE(0x0d000, 0x0d00d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
87	86	AM_RANGE(0xa0000, 0xfffff) AM_ROM
88	87	ADDRESS_MAP_END
89	88
r24637	r24638
103	102	AM_RANGE(0x00000, 0x06fff) AM_RAM
104	103	AM_RANGE(0x07000, 0x07fff) AM_RAM AM_SHARE("spriteram")
105	104	AM_RANGE(0x08000, 0x087ff) AM_RAM_WRITE(dynduke_text_w) AM_SHARE("videoram")
106		AM_RANGE(0x09000, 0x0900d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	105	AM_RANGE(0x09000, 0x0900d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
107	106	AM_RANGE(0x0c000, 0x0c0ff) AM_RAM AM_SHARE("scroll_ram")
108	107	AM_RANGE(0x0e000, 0x0efff) AM_RAM AM_SHARE("share1")
109	108	AM_RANGE(0x0f000, 0x0f001) AM_READ_PORT("P1_P2")
r24637	r24638
285	284
286	285	MCFG_QUANTUM_TIME(attotime::from_hz(3600))
287	286
288		MCFG_MACHINE_RESET(seibu_sound)
289
290	287	// video hardware
291	288	MCFG_BUFFERED_SPRITERAM16_ADD("spriteram")
292	289
r24637	r24638
607	604
608	605	DRIVER_INIT_MEMBER(dynduke_state,dynduke)
609	606	{
610		seibu_sound_decrypt(machine(),"audiocpu",0x20000);
	607	m_seibu_sound->decrypt("audiocpu",0x20000);
611	608	}
612	609
613	610	/* Game Drivers */

trunk/src/mame/drivers/shanghai.c

r24637	r24638
26	26	#include "cpu/nec/nec.h"
27	27	#include "audio/seibu.h"
28	28	#include "video/hd63484.h"
29		#include "drivlgcy.h"
30	29
31	30
32	31	class shanghai_state : public driver_device
r24637	r24638
190	189	AM_RANGE(0x09014, 0x09015) AM_READ_PORT("SYSTEM")
191	190	AM_RANGE(0x09016, 0x0901f) AM_WRITENOP // 0x9016 is set to 0 at the boot
192	191	AM_RANGE(0x0a000, 0x0a1ff) AM_WRITE(paletteram_xxxxBBBBGGGGRRRR_word_w) AM_SHARE("paletteram")
193		AM_RANGE(0x0b010, 0x0b01f) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	192	AM_RANGE(0x0b010, 0x0b01f) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
194	193	AM_RANGE(0x80000, 0xfffff) AM_ROM
195	194	ADDRESS_MAP_END
196	195
r24637	r24638
514	513
515	514	MCFG_QUANTUM_TIME(attotime::from_hz(12000))
516	515
517		MCFG_MACHINE_RESET(seibu_sound)
518
519	516	/* video hardware */
520	517	MCFG_SCREEN_ADD("screen", RASTER)
521	518	MCFG_SCREEN_REFRESH_RATE(30)
r24637	r24638
533	530
534	531	/* same as standard seibu ym2203, but "ym1" also reads "DSW" */
535	532	MCFG_SOUND_ADD("ym1", YM2203, 14318180/4)
536		MCFG_YM2203_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2203_irqhandler>))
	533	MCFG_YM2203_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2203_irqhandler))
537	534	MCFG_YM2203_AY8910_INTF(&kothello_ay8910_config)
538	535	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.15)
539	536

trunk/src/mame/drivers/bloodbro.c

r24637	r24638
124	124	#include "sound/3812intf.h"
125	125	#include "includes/bloodbro.h"
126	126	#include "video/seibu_crtc.h"
127		#include "drivlgcy.h"
128	127
129	128
130	129	/* Memory Maps */
r24637	r24638
140	139	AM_RANGE(0x08e000, 0x08e7ff) AM_RAM
141	140	AM_RANGE(0x08e800, 0x08f7ff) AM_RAM_WRITE(paletteram_xxxxBBBBGGGGRRRR_word_w) AM_SHARE("paletteram")
142	141	AM_RANGE(0x08f800, 0x08ffff) AM_RAM
143		AM_RANGE(0x0a0000, 0x0a000d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	142	AM_RANGE(0x0a0000, 0x0a000d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
144	143	//  AM_RANGE(0x0c0000, 0x0c007f) AM_RAM AM_SHARE("scroll")
145	144	AM_RANGE(0x0c0080, 0x0c0081) AM_WRITENOP // ??? IRQ Ack VBL?
146	145	AM_RANGE(0x0c00c0, 0x0c00c1) AM_WRITENOP // ??? watchdog?
r24637	r24638
467	466
468	467	SEIBU_SOUND_SYSTEM_CPU(XTAL_7_15909MHz/2) /* verified on pcb */
469	468
470		MCFG_MACHINE_RESET(seibu_sound)
471
472	469	// video hardware
473	470
474	471	MCFG_SCREEN_ADD("screen", RASTER)

trunk/src/mame/drivers/dcon.c

r24637	r24638
18	18	#include "audio/seibu.h"
19	19	#include "includes/dcon.h"
20	20	#include "video/seibu_crtc.h"
21		#include "drivlgcy.h"
22	21
	22
23	23	/***************************************************************************/
24	24
25	25	static ADDRESS_MAP_START( dcon_map, AS_PROGRAM, 16, dcon_state )
r24637	r24638
34	34	AM_RANGE(0x8f800, 0x8ffff) AM_RAM AM_SHARE("spriteram")
35	35	AM_RANGE(0x9d000, 0x9d7ff) AM_WRITE(dcon_gfxbank_w)
36	36
37		AM_RANGE(0xa0000, 0xa000d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	37	AM_RANGE(0xa0000, 0xa000d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
38	38	AM_RANGE(0xc0000, 0xc004f) AM_DEVREADWRITE("crtc", seibu_crtc_device, read, write)
39	39	AM_RANGE(0xc0080, 0xc0081) AM_WRITENOP
40	40	AM_RANGE(0xc00c0, 0xc00c1) AM_WRITENOP
r24637	r24638
273	273
274	274	SEIBU_SOUND_SYSTEM_CPU(4000000) /* Perhaps 14318180/4? */
275	275
276		MCFG_MACHINE_RESET(seibu_sound)
277
278	276	/* video hardware */
279	277	MCFG_SCREEN_ADD("screen", RASTER)
280	278	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
301	299
302	300	SEIBU2_SOUND_SYSTEM_CPU(14318180/4)
303	301
304		MCFG_MACHINE_RESET(seibu_sound)
305
306	302	/* video hardware */
307	303	MCFG_SCREEN_ADD("screen", RASTER)
308	304	MCFG_SCREEN_REFRESH_RATE(60)

trunk/src/mame/drivers/legionna.c

r24637	r24638
75	75	#include "cpu/m68000/m68000.h"
76	76	#include "machine/seicop.h"
77	77	#include "includes/legionna.h"
78		#include "drivlgcy.h"
79	78
80	79	/*****************************************************************************/
81	80
r24637	r24638
1066	1065
1067	1066	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
1068	1067
1069		MCFG_MACHINE_RESET(seibu_sound)
1070
1071	1068	/* video hardware */
1072	1069	MCFG_SCREEN_ADD("screen", RASTER)
1073	1070	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
1096	1093
1097	1094	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
1098	1095
1099		MCFG_MACHINE_RESET(seibu_sound)
1100
1101	1096	/* video hardware */
1102	1097	MCFG_SCREEN_ADD("screen", RASTER)
1103	1098	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
1125	1120
1126	1121	SEIBU2_SOUND_SYSTEM_CPU(14318180/4)
1127	1122
1128		MCFG_MACHINE_RESET(seibu_sound)
1129
1130	1123	/* video hardware */
1131	1124	MCFG_SCREEN_ADD("screen", RASTER)
1132	1125	//  MCFG_SCREEN_REFRESH_RATE(61)
r24637	r24638
1155	1148
1156	1149	SEIBU2_SOUND_SYSTEM_CPU(14318180/4)
1157	1150
1158		MCFG_MACHINE_RESET(seibu_sound)
1159
1160	1151	/* video hardware */
1161	1152	MCFG_SCREEN_ADD("screen", RASTER)
1162	1153	MCFG_SCREEN_SIZE(42*8, 36*8)
r24637	r24638
1184	1175
1185	1176	SEIBU2_SOUND_SYSTEM_CPU(14318180/4)
1186	1177
1187		MCFG_MACHINE_RESET(seibu_sound)
1188
1189	1178	/* video hardware */
1190	1179	MCFG_SCREEN_ADD("screen", RASTER)
1191	1180	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
1214	1203
1215	1204	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
1216	1205
1217		MCFG_MACHINE_RESET(seibu_sound)
1218
1219	1206	/* video hardware */
1220	1207	MCFG_SCREEN_ADD("screen", RASTER)
1221	1208	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
1252	1239	MCFG_CPU_PROGRAM_MAP(cupsocbl_sound_mem)
1253	1240	//MCFG_PERIODIC_INT("screen", nmi_line_pulse)
1254	1241
1255		//MCFG_MACHINE_INIT(seibu_sound)
1256
1257	1242	/* video hardware */
1258	1243	MCFG_SCREEN_ADD("screen", RASTER)
1259	1244	MCFG_SCREEN_REFRESH_RATE(60)

trunk/src/mame/drivers/r2dx_v33.c

r24637	r24638
16	16	#include "emu.h"
17	17	#include "cpu/nec/nec.h"
18	18	#include "cpu/z80/z80.h"
19		#include "audio/seibu.h"
20	19	#include "machine/eepromser.h"
21	20	#include "sound/okim6295.h"
22	21	#include "includes/raiden2.h"
23		#include "drivlgcy.h"
24	22
25	23
26	24	class r2dx_v33_state : public driver_device
r24637	r24638
34	32	m_fg_vram(*this, "fg_vram"),
35	33	m_tx_vram(*this, "tx_vram"),
36	34	m_maincpu(*this, "maincpu"),
	35	m_seibu_sound(*this, "seibu_sound"),
37	36	m_eeprom(*this, "eeprom") { }
38	37
39	38	required_shared_ptr<UINT16> m_spriteram;
	39	required_shared_ptr<UINT16> m_bg_vram;
	40	required_shared_ptr<UINT16> m_md_vram;
	41	required_shared_ptr<UINT16> m_fg_vram;
	42	required_shared_ptr<UINT16> m_tx_vram;
	43
	44	required_device<cpu_device> m_maincpu;
	45	optional_device<seibu_sound_device> m_seibu_sound;
	46	optional_device<eeprom_serial_93cxx_device> m_eeprom;
	47
40	48	DECLARE_WRITE16_MEMBER(rdx_bg_vram_w);
41	49	DECLARE_WRITE16_MEMBER(rdx_md_vram_w);
42	50	DECLARE_WRITE16_MEMBER(rdx_fg_vram_w);
r24637	r24638
60	68	TILE_GET_INFO_MEMBER(get_fg_tile_info);
61	69	TILE_GET_INFO_MEMBER(get_tx_tile_info);
62	70
63		required_shared_ptr<UINT16> m_bg_vram;
64		required_shared_ptr<UINT16> m_md_vram;
65		required_shared_ptr<UINT16> m_fg_vram;
66		required_shared_ptr<UINT16> m_tx_vram;
67	71	tilemap_t *m_bg_tilemap;
68	72	tilemap_t *m_md_tilemap;
69	73	tilemap_t *m_fg_tilemap;
r24637	r24638
72	76	UINT32 screen_update_rdx_v33(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
73	77	INTERRUPT_GEN_MEMBER(rdx_v33_interrupt);
74	78	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,int pri);
75		required_device<cpu_device> m_maincpu;
76		optional_device<eeprom_serial_93cxx_device> m_eeprom;
77	79	};
78	80
79	81
r24637	r24638
440	442	{
441	443	switch(offset+0x780)
442	444	{
443		case (0x788/2): return seibu_main_word_r(space,2,0xffff);
444		case (0x78c/2): return seibu_main_word_r(space,3,0xffff);
445		case (0x794/2): return seibu_main_word_r(space,5,0xffff);
	445	case (0x788/2): return m_seibu_sound->main_word_r(space,2,0xffff);
	446	case (0x78c/2): return m_seibu_sound->main_word_r(space,3,0xffff);
	447	case (0x794/2): return m_seibu_sound->main_word_r(space,5,0xffff);
446	448	}
447	449
448	450	return 0xffff;
r24637	r24638
453	455	{
454	456	switch(offset+0x780)
455	457	{
456		case (0x780/2): { seibu_main_word_w(space,0,data,0x00ff); break; }
457		case (0x784/2): { seibu_main_word_w(space,1,data,0x00ff); break; }
458		//case (0x790/2): { seibu_main_word_w(space,4,data,0x00ff); break; }
459		case (0x794/2): { seibu_main_word_w(space,4,data,0x00ff); break; }
460		case (0x798/2): { seibu_main_word_w(space,6,data,0x00ff); break; }
	458	case (0x780/2): { m_seibu_sound->main_word_w(space,0,data,0x00ff); break; }
	459	case (0x784/2): { m_seibu_sound->main_word_w(space,1,data,0x00ff); break; }
	460	//case (0x790/2): { m_seibu_sound->main_word_w(space,4,data,0x00ff); break; }
	461	case (0x794/2): { m_seibu_sound->main_word_w(space,4,data,0x00ff); break; }
	462	case (0x798/2): { m_seibu_sound->main_word_w(space,6,data,0x00ff); break; }
461	463	}
462	464	}
463	465
r24637	r24638
724	726	MCFG_CPU_PROGRAM_MAP(nzerotea_map)
725	727	MCFG_CPU_VBLANK_INT_DRIVER("screen", r2dx_v33_state,  rdx_v33_interrupt)
726	728
727		MCFG_MACHINE_RESET(seibu_sound)
728
729		//  SEIBU2_RAIDEN2_SOUND_SYSTEM_CPU(14318180/4)
	729	//  SEIBU2_RAIDEN2_SOUND_SYSTEM_CPU(14318180/4)
730	730	SEIBU_NEWZEROTEAM_SOUND_SYSTEM_CPU(14318180/4)
731	731
732	732	/* video hardware */

trunk/src/mame/drivers/mustache.c

r24637	r24638
29	29	***************************************************************************/
30	30	#include "emu.h"
31	31	#include "cpu/z80/z80.h"
32		#include "audio/seibu.h"    // for seibu_sound_decrypt on the MAIN cpu (not sound)
33	32	#include "audio/t5182.h"
34	33	#include "includes/mustache.h"
35	34
r24637	r24638
195	194
196	195
197	196	/* sound hardware */
	197	MCFG_SEIBU_SOUND_ADD("seibu_sound") // for seibu_sound_decrypt on the MAIN cpu (not sound)
	198
198	199	MCFG_SPEAKER_STANDARD_MONO("mono")
199	200
200	201	MCFG_YM2151_ADD("ymsnd", YM_CLOCK)
r24637	r24638
278	279	gfx2[i] = buf[BITSWAP24(i,23,22,21,20,19,18,17,16,15,12,11,10,9,8,7,6,5,4,13,14,3,2,1,0)];
279	280
280	281	auto_free(machine(), buf);
281		seibu_sound_decrypt(machine(),"maincpu",0x8000);
	282	m_cpu_decrypt->decrypt("maincpu",0x8000);
282	283	}
283	284
284	285

trunk/src/mame/drivers/sengokmj.c

r24637	r24638
57	57	#include "sound/3812intf.h"
58	58	#include "video/seibu_crtc.h"
59	59	#include "machine/nvram.h"
60		#include "drivlgcy.h"
61	60
62	61
63	62	class sengokmj_state : public driver_device
r24637	r24638
381	380	ADDRESS_MAP_END
382	381
383	382	static ADDRESS_MAP_START( sengokmj_io_map, AS_IO, 16, sengokmj_state )
384		AM_RANGE(0x4000, 0x400f) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	383	AM_RANGE(0x4000, 0x400f) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
385	384	/*Areas from 8000-804f are for the custom Seibu CRTC.*/
386	385	AM_RANGE(0x8000, 0x804f) AM_DEVREADWRITE("crtc", seibu_crtc_device, read, write)
387	386
r24637	r24638
571	570
572	571	SEIBU_SOUND_SYSTEM_CPU(14318180/4)
573	572
574		MCFG_MACHINE_RESET(seibu_sound)
575	573	MCFG_NVRAM_ADD_0FILL("nvram")
576	574
577	575	/* video hardware */

trunk/src/mame/drivers/toki.c

r24637	r24638
37	37	#include "emu.h"
38	38	#include "cpu/m68000/m68000.h"
39	39	#include "cpu/z80/z80.h"
40		#include "audio/seibu.h"
41	40	#include "sound/3812intf.h"
42	41	#include "sound/msm5205.h"
43	42	#include "sound/3812intf.h"
44	43	#include "includes/toki.h"
45		#include "drivlgcy.h"
46	44
47	45	WRITE16_MEMBER(toki_state::tokib_soundcommand16_w)
48	46	{
r24637	r24638
96	94	AM_RANGE(0x06e800, 0x06efff) AM_RAM_WRITE(toki_background1_videoram16_w) AM_SHARE("bg1_vram16")
97	95	AM_RANGE(0x06f000, 0x06f7ff) AM_RAM_WRITE(toki_background2_videoram16_w) AM_SHARE("bg2_vram16")
98	96	AM_RANGE(0x06f800, 0x06ffff) AM_RAM_WRITE(toki_foreground_videoram16_w) AM_SHARE("videoram")
99		AM_RANGE(0x080000, 0x08000d) AM_READWRITE_LEGACY(seibu_main_word_r, seibu_main_word_w)
	97	AM_RANGE(0x080000, 0x08000d) AM_DEVREADWRITE("seibu_sound", seibu_sound_device, main_word_r, main_word_w)
100	98	AM_RANGE(0x0a0000, 0x0a005f) AM_WRITE(toki_control_w) AM_SHARE("scrollram16")
101	99	AM_RANGE(0x0c0000, 0x0c0001) AM_READ_PORT("DSW")
102	100	AM_RANGE(0x0c0002, 0x0c0003) AM_READ_PORT("INPUTS")
r24637	r24638
420	418
421	419	SEIBU_SOUND_SYSTEM_CPU(XTAL_14_31818MHz/4)  /* verifed on pcb */
422	420
423		MCFG_MACHINE_RESET(seibu_sound)
424
425	421	/* video hardware */
426	422	MCFG_BUFFERED_SPRITERAM16_ADD("spriteram")
427	423
r24637	r24638
797	793
798	794	auto_free(machine(), buffer);
799	795
800		seibu_sound_decrypt(machine(),"audiocpu",0x2000);
	796	m_seibu_sound->decrypt("audiocpu",0x2000);
801	797	}
802	798
803	799

trunk/src/mame/drivers/cshooter.c

r24637	r24638
94	94	cshooter_state(const machine_config &mconfig, device_type type, const char *tag)
95	95	: driver_device(mconfig, type, tag),
96	96	m_maincpu(*this, "maincpu"),
	97	m_seibu_sound(*this, "seibu_sound"),
97	98	m_txram(*this, "txram"),
98	99	m_mainram(*this, "mainram"),
99	100	m_spriteram(*this, "spriteram")
100	101	{ }
101	102
102	103	required_device<cpu_device> m_maincpu;
	104	optional_device<seibu_sound_device> m_seibu_sound;
103	105	required_shared_ptr<UINT8> m_txram;
104	106	optional_shared_ptr<UINT8> m_mainram;
105	107	optional_shared_ptr<UINT8> m_spriteram;
r24637	r24638
121	123	virtual void video_start();
122	124	virtual void palette_init();
123	125	DECLARE_MACHINE_RESET(cshooter);
124		DECLARE_MACHINE_RESET(airraid);
125	126	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
126	127	UINT32 screen_update_cshooter(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
127	128	UINT32 screen_update_airraid(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
r24637	r24638
250	251	m_counter = 0;
251	252	}
252	253
253		MACHINE_RESET_MEMBER(cshooter_state,airraid)
254		{
255		MACHINE_RESET_CALL_LEGACY(seibu_sound);
256		}
257
258	254	READ8_MEMBER(cshooter_state::cshooter_coin_r)
259	255	{
260	256	/* Even reads must return 0xff - Odd reads must return the contents of input port 5.
r24637	r24638
279	275
280	276	READ8_MEMBER(cshooter_state::seibu_sound_comms_r)
281	277	{
282		return seibu_main_word_r(space,offset,0x00ff);
	278	return m_seibu_sound->main_word_r(space,offset,0x00ff);
283	279	}
284	280
285	281	WRITE8_MEMBER(cshooter_state::seibu_sound_comms_w)
286	282	{
287		seibu_main_word_w(space,offset,data,0x00ff);
	283	m_seibu_sound->main_word_w(space,offset,data,0x00ff);
288	284	}
289	285
290	286	#if 0
r24637	r24638
469	465	MCFG_QUANTUM_TIME(attotime::from_hz(6000))
470	466
471	467	MCFG_MACHINE_RESET_OVERRIDE(cshooter_state,cshooter)
472
	468
473	469	/* video hardware */
474	470	MCFG_SCREEN_ADD("screen", RASTER)
475	471	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
483	479
484	480	/* sound hardware */
485	481	/* YM2151 and ym3931 seibu custom cpu running at XTAL_14_31818MHz/4 */
	482	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	483
486	484	MACHINE_CONFIG_END
487	485	#endif
488	486
r24637	r24638
497	495
498	496	MCFG_QUANTUM_TIME(attotime::from_hz(6000))
499	497
500		MCFG_MACHINE_RESET_OVERRIDE(cshooter_state,airraid)
501
502	498	/* video hardware */
503	499	MCFG_SCREEN_ADD("screen", RASTER)
504	500	MCFG_SCREEN_REFRESH_RATE(60)
r24637	r24638
678	674	}
679	675
680	676	membank("bank1")->set_base(&memregion("user1")->base()[0]);
681		seibu_sound_decrypt(machine(),"audiocpu",0x2000);
	677	m_seibu_sound->decrypt("audiocpu",0x2000);
682	678	}
683	679
684	680

trunk/src/mame/audio/seibu.c

r24637	r24638
39	39	#include "sound/2203intf.h"
40	40	#include "sound/okiadpcm.h"
41	41	#include "sound/okim6295.h"
42		#include "devlegcy.h"
43	42
44	43
	44
	45	/***************************************************************************
	46	Seibu Sound System
	47	***************************************************************************/
	48
45	49	/*
46	50	Games using encrypted sound cpu:
47	51
r24637	r24638
69	73	00002CA2: 17 37
70	74	*/
71	75
	76	const device_type SEIBU_SOUND = &device_creator<seibu_sound_device>;
72	77
	78	seibu_sound_device::seibu_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	79	: device_t(mconfig, SEIBU_SOUND, "Seibu Sound System", tag, owner, clock, "seibu_sound", __FILE__),
	80	m_main2sub_pending(0),
	81	m_sub2main_pending(0)
	82	{
	83	}
	84
	85	//-------------------------------------------------
	86	//  device_config_complete - perform any
	87	//  operations now that the configuration is
	88	//  complete
	89	//-------------------------------------------------
	90
	91	void seibu_sound_device::device_config_complete()
	92	{
	93	}
	94
	95	//-------------------------------------------------
	96	//  device_start - device-specific startup
	97	//-------------------------------------------------
	98
	99	void seibu_sound_device::device_start()
	100	{
	101	m_main2sub[0] = m_main2sub[1] = 0;
	102	m_sub2main[0] = m_sub2main[1] = 0;
	103
	104	save_item(NAME(m_main2sub_pending));
	105	save_item(NAME(m_sub2main_pending));
	106
	107	save_item(NAME(m_main2sub));
	108	save_item(NAME(m_sub2main));
	109
	110	for (int i = 0; i < 2; i++)
	111	{
	112	save_item(NAME(m_main2sub[i]), i);
	113	save_item(NAME(m_sub2main[i]), i);
	114	}
	115	}
	116
	117	//-------------------------------------------------
	118	//  device_reset - device-specific reset
	119	//-------------------------------------------------
	120
	121	void seibu_sound_device::device_reset()
	122	{
	123	int romlength = machine().root_device().memregion("audiocpu")->bytes();
	124	UINT8 *rom = machine().root_device().memregion("audiocpu")->base();
	125
	126	m_sound_cpu = machine().device("audiocpu");
	127	update_irq_lines(VECTOR_INIT);
	128	if (romlength > 0x10000)
	129	{
	130	machine().root_device().membank("bank1")->configure_entries(0, (romlength - 0x10000) / 0x8000, rom + 0x10000, 0x8000);
	131
	132	/* Denjin Makai definitely needs this at start-up, it never writes to the bankswitch */
	133	machine().root_device().membank("bank1")->set_entry(0);
	134	}
	135	}
	136
73	137	static UINT8 decrypt_data(int a,int src)
74	138	{
75	139	if ( BIT(a,9)  &  BIT(a,8))             src ^= 0x80;
r24637	r24638
103	167	return src;
104	168	}
105	169
106		void seibu_sound_decrypt(running_machine &machine,const char *cpu,int length)
	170	void seibu_sound_device::decrypt(const char *cpu,int length)
107	171	{
108		address_space &space = machine.device(cpu)->memory().space(AS_PROGRAM);
109		UINT8 *decrypt = auto_alloc_array(machine, UINT8, length);
110		UINT8 *rom = machine.root_device().memregion(cpu)->base();
	172	address_space &space = machine().device(cpu)->memory().space(AS_PROGRAM);
	173	UINT8 *decrypt = auto_alloc_array_clear(machine(), UINT8, length);
	174	UINT8 *rom = machine().root_device().memregion(cpu)->base();
111	175	int i;
112	176
113	177	space.set_decrypted_region(0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
r24637	r24638
121	185	}
122	186
123	187	if (length > 0x10000)
124		machine.root_device().membank("bank1")->configure_decrypted_entries(0, (length - 0x10000) / 0x8000, decrypt + 0x10000, 0x8000);
	188	machine().root_device().membank("bank1")->configure_decrypted_entries(0, (length - 0x10000) / 0x8000, decrypt + 0x10000, 0x8000);
125	189	}
126	190
127
128		/***************************************************************************/
129
130		/*
131		Handlers for early Seibu/Tad games with dual channel ADPCM
132		*/
133
134		const seibu_adpcm_interface seibu_adpcm1_intf =
	191	void seibu_sound_device::update_irq_lines(int param)
135	192	{
136		"adpcm1"
137		};
138
139		const seibu_adpcm_interface seibu_adpcm2_intf =
140		{
141		"adpcm2"
142		};
143
144		struct seibu_adpcm_state
145		{
146		oki_adpcm_state m_adpcm;
147		sound_stream *m_stream;
148		UINT32 m_current;
149		UINT32 m_end;
150		UINT8 m_nibble;
151		UINT8 m_playing;
152		UINT8 m_allocated;
153		UINT8 *m_base;
154		};
155
156		static STREAM_UPDATE( seibu_adpcm_callback )
157		{
158		seibu_adpcm_state *state = (seibu_adpcm_state *)param;
159		stream_sample_t *dest = outputs[0];
160
161		while (state->m_playing && samples > 0)
162		{
163		int val = (state->m_base[state->m_current] >> state->m_nibble) & 15;
164
165		state->m_nibble ^= 4;
166		if (state->m_nibble == 4)
167		{
168		state->m_current++;
169		if (state->m_current >= state->m_end)
170		state->m_playing = 0;
171		}
172
173		*dest++ = state->m_adpcm.clock(val) << 4;
174		samples--;
175		}
176		while (samples > 0)
177		{
178		*dest++ = 0;
179		samples--;
180		}
181		}
182
183		static DEVICE_START( seibu_adpcm )
184		{
185		running_machine &machine = device->machine();
186		seibu_adpcm_state *state = (seibu_adpcm_state *)downcast<seibu_adpcm_device *>(device)->token();
187		const seibu_adpcm_interface *intf;
188
189		intf = (const seibu_adpcm_interface *)device->static_config();
190
191		state->m_playing = 0;
192		state->m_stream = device->machine().sound().stream_alloc(*device, 0, 1, device->clock(), state, seibu_adpcm_callback);
193		state->m_base = machine.root_device().memregion(intf->rom_region)->base();
194		state->m_adpcm.reset();
195		}
196
197		// "decrypt" is a bit flowery here, as it's probably just line-swapping to
198		// simplify PCB layout/routing rather than intentional protection, but it
199		// still fits, especially since the Z80s for all these games are truly encrypted.
200
201		void seibu_adpcm_decrypt(running_machine &machine, const char *region)
202		{
203		UINT8 *ROM = machine.root_device().memregion(region)->base();
204		int len = machine.root_device().memregion(region)->bytes();
205		int i;
206
207		for (i = 0; i < len; i++)
208		{
209		ROM[i] = BITSWAP8(ROM[i], 7, 5, 3, 1, 6, 4, 2, 0);
210		}
211		}
212
213		WRITE8_DEVICE_HANDLER( seibu_adpcm_adr_w )
214		{
215		seibu_adpcm_state *state = (seibu_adpcm_state *)downcast<seibu_adpcm_device *>(device)->token();
216
217		if (state->m_stream)
218		state->m_stream->update();
219		if (offset)
220		{
221		state->m_end = data<<8;
222		}
223		else
224		{
225		state->m_current = data<<8;
226		state->m_nibble = 4;
227		}
228		}
229
230		WRITE8_DEVICE_HANDLER( seibu_adpcm_ctl_w )
231		{
232		seibu_adpcm_state *state = (seibu_adpcm_state *)downcast<seibu_adpcm_device *>(device)->token();
233
234		// sequence is 00 02 01 each time.
235		if (state->m_stream)
236		state->m_stream->update();
237		switch (data)
238		{
239		case 0:
240		state->m_playing = 0;
241		break;
242		case 2:
243		break;
244		case 1:
245		state->m_playing = 1;
246		break;
247
248		}
249		}
250
251		/***************************************************************************/
252
253		static device_t *sound_cpu;
254
255		enum
256		{
257		VECTOR_INIT,
258		RST10_ASSERT,
259		RST10_CLEAR,
260		RST18_ASSERT,
261		RST18_CLEAR
262		};
263
264		static void update_irq_lines(running_machine &machine, int param)
265		{
266	193	static int irq1,irq2;
267	194
268	195	switch(param)
r24637	r24638
288	215	break;
289	216	}
290	217
291		if ((irq1 & irq2) == 0xff)  /* no IRQs pending */
292		sound_cpu->execute().set_input_line(0,CLEAR_LINE);
293		else    /* IRQ pending */
294		sound_cpu->execute().set_input_line_and_vector(0,ASSERT_LINE,irq1 & irq2);
295		}
	218	if (m_sound_cpu != NULL)
	219	if ((irq1 & irq2) == 0xff)  /* no IRQs pending */
	220	m_sound_cpu->execute().set_input_line(0,CLEAR_LINE);
	221	else    /* IRQ pending */
	222	m_sound_cpu->execute().set_input_line_and_vector(0,ASSERT_LINE,irq1 & irq2);
	223	else
	224	return;
	225	}
	226
296	227
297		WRITE8_HANDLER( seibu_irq_clear_w )
	228	WRITE8_MEMBER( seibu_sound_device::irq_clear_w )
298	229	{
299	230	/* Denjin Makai and SD Gundam doesn't like this, it's tied to the rst18 ack ONLY so it could be related to it. */
300		//update_irq_lines(space.machine(), VECTOR_INIT);
	231	//update_irq_lines(VECTOR_INIT);
301	232	}
302	233
303		WRITE8_HANDLER( seibu_rst10_ack_w )
	234	WRITE8_MEMBER( seibu_sound_device::rst10_ack_w )
304	235	{
305	236	/* Unused for now */
306	237	}
307	238
308		WRITE8_HANDLER( seibu_rst18_ack_w )
	239	WRITE8_MEMBER( seibu_sound_device::rst18_ack_w )
309	240	{
310		update_irq_lines(space.machine(), RST18_CLEAR);
	241	update_irq_lines(RST18_CLEAR);
311	242	}
312	243
313		void seibu_ym3812_irqhandler(device_t *device, int linestate)
	244	void seibu_sound_device::ym3812_irqhandler(int linestate)
314	245	{
315		update_irq_lines(device->machine(), linestate ? RST10_ASSERT : RST10_CLEAR);
	246	update_irq_lines(linestate ? RST10_ASSERT : RST10_CLEAR);
316	247	}
317	248
318		WRITE_LINE_DEVICE_HANDLER( seibu_ym2151_irqhandler )
	249	WRITE_LINE_MEMBER( seibu_sound_device::ym2151_irqhandler )
319	250	{
320		update_irq_lines(device->machine(), state ? RST10_ASSERT : RST10_CLEAR);
	251	update_irq_lines(state ? RST10_ASSERT : RST10_CLEAR);
321	252	}
322	253
323		void seibu_ym2203_irqhandler(device_t *device, int linestate)
	254	void seibu_sound_device::ym2203_irqhandler(int linestate)
324	255	{
325		update_irq_lines(device->machine(), linestate ? RST10_ASSERT : RST10_CLEAR);
	256	update_irq_lines(linestate ? RST10_ASSERT : RST10_CLEAR);
326	257	}
327	258
328		/***************************************************************************/
329
330		MACHINE_RESET( seibu_sound )
	259	WRITE8_MEMBER( seibu_sound_device::bank_w )
331	260	{
332		int romlength = machine.root_device().memregion("audiocpu")->bytes();
333		UINT8 *rom = machine.root_device().memregion("audiocpu")->base();
334
335		sound_cpu = machine.device("audiocpu");
336		update_irq_lines(machine, VECTOR_INIT);
337		if (romlength > 0x10000)
338		{
339		machine.root_device().membank("bank1")->configure_entries(0, (romlength - 0x10000) / 0x8000, rom + 0x10000, 0x8000);
340
341		/* Denjin Makai definitely needs this at start-up, it never writes to the bankswitch */
342		machine.root_device().membank("bank1")->set_entry(0);
343		}
344		}
345
346		/***************************************************************************/
347
348		static UINT8 main2sub[2],sub2main[2];
349		static int main2sub_pending,sub2main_pending;
350
351		WRITE8_HANDLER( seibu_bank_w )
352		{
353	261	space.machine().root_device().membank("bank1")->set_entry(data & 1);
354	262	}
355	263
356		WRITE8_HANDLER( seibu_coin_w )
	264	WRITE8_MEMBER( seibu_sound_device::coin_w )
357	265	{
358	266	coin_counter_w(space.machine(), 0,data & 1);
359	267	coin_counter_w(space.machine(), 1,data & 2);
360	268	}
361	269
362		READ8_HANDLER( seibu_soundlatch_r )
	270	READ8_MEMBER( seibu_sound_device::soundlatch_r )
363	271	{
364		return main2sub[offset];
	272	return m_main2sub[offset];
365	273	}
366	274
367		READ8_HANDLER( seibu_main_data_pending_r )
	275	READ8_MEMBER( seibu_sound_device::main_data_pending_r )
368	276	{
369		return sub2main_pending ? 1 : 0;
	277	return m_sub2main_pending ? 1 : 0;
370	278	}
371	279
372		WRITE8_HANDLER( seibu_main_data_w )
	280	WRITE8_MEMBER( seibu_sound_device::main_data_w )
373	281	{
374		sub2main[offset] = data;
	282	m_sub2main[offset] = data;
375	283	}
376	284
377		static WRITE8_HANDLER( seibu_pending_w )
	285	WRITE8_MEMBER( seibu_sound_device::pending_w )
378	286	{
379	287	/* just a guess */
380		main2sub_pending = 0;
381		sub2main_pending = 1;
	288	m_main2sub_pending = 0;
	289	m_sub2main_pending = 1;
382	290	}
383	291
384		READ16_HANDLER( seibu_main_word_r )
	292	READ16_MEMBER( seibu_sound_device::main_word_r )
385	293	{
386	294	//logerror("%06x: seibu_main_word_r(%x)\n",space.device().safe_pc(),offset);
387	295	switch (offset)
388	296	{
389	297	case 2:
390	298	case 3:
391		return sub2main[offset-2];
	299	return m_sub2main[offset-2];
392	300	case 5:
393		return main2sub_pending ? 1 : 0;
	301	return m_main2sub_pending ? 1 : 0;
394	302	default:
395	303	//logerror("%06x: seibu_main_word_r(%x)\n",space.device().safe_pc(),offset);
396	304	return 0xffff;
397	305	}
398	306	}
399	307
400		WRITE16_HANDLER( seibu_main_word_w )
	308	WRITE16_MEMBER( seibu_sound_device::main_word_w )
401	309	{
402	310	//printf("%06x: seibu_main_word_w(%x,%02x)\n",space.device().safe_pc(),offset,data);
403	311	if (ACCESSING_BITS_0_7)
r24637	r24638
406	314	{
407	315	case 0:
408	316	case 1:
409		main2sub[offset] = data;
	317	m_main2sub[offset] = data;
410	318	break;
411	319	case 4:
412		update_irq_lines(space.machine(), RST18_ASSERT);
	320	update_irq_lines(RST18_ASSERT);
413	321	break;
414	322	case 2: //Sengoku Mahjong writes here
415	323	case 6:
416	324	/* just a guess */
417		sub2main_pending = 0;
418		main2sub_pending = 1;
	325	m_sub2main_pending = 0;
	326	m_main2sub_pending = 1;
419	327	break;
420	328	default:
421	329	//logerror("%06x: seibu_main_word_w(%x,%02x)\n",space.device().safe_pc(),offset,data);
r24637	r24638
424	332	}
425	333	}
426	334
427		READ8_HANDLER( seibu_main_v30_r )
	335	READ8_MEMBER( seibu_sound_device::main_v30_r )
428	336	{
429		return seibu_main_word_r(space,offset/2,0xffff) >> (8 * (offset & 1));
	337	return main_word_r(space,offset/2,0xffff) >> (8 * (offset & 1));
430	338	}
431	339
432		WRITE8_HANDLER( seibu_main_v30_w )
	340	WRITE8_MEMBER( seibu_sound_device::main_v30_w )
433	341	{
434		seibu_main_word_w(space,offset/2,data << (8 * (offset & 1)),0x00ff << (8 * (offset & 1)));
	342	main_word_w(space,offset/2,data << (8 * (offset & 1)),0x00ff << (8 * (offset & 1)));
435	343	}
436	344
437		WRITE16_HANDLER( seibu_main_mustb_w )
	345	WRITE16_MEMBER( seibu_sound_device::main_mustb_w )
438	346	{
439		main2sub[0] = data&0xff;
440		main2sub[1] = data>>8;
	347	m_main2sub[0] = data&0xff;
	348	m_main2sub[1] = data>>8;
441	349
442	350	//  logerror("seibu_main_mustb_w: %x -> %x %x\n", data, main2sub[0], main2sub[1]);
443	351
444		update_irq_lines(space.machine(), RST18_ASSERT);
	352	update_irq_lines(RST18_ASSERT);
445	353	}
446	354
447	355	/***************************************************************************/
r24637	r24638
458	366	ADDRESS_MAP_START( seibu_sound_map, AS_PROGRAM, 8, driver_device )
459	367	AM_RANGE(0x0000, 0x1fff) AM_ROM
460	368	AM_RANGE(0x2000, 0x27ff) AM_RAM
461		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
462		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
463		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
464		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
465		AM_RANGE(0x4007, 0x4007) AM_WRITE_LEGACY(seibu_bank_w)
	369	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	370	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	371	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	372	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
	373	AM_RANGE(0x4007, 0x4007) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
466	374	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym3812_device, read, write)
467		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
468		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	375	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	376	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
469	377	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
470		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
471		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	378	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	379	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
472	380	AM_RANGE(0x6000, 0x6000) AM_DEVREADWRITE("oki", okim6295_device, read, write)
473	381	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
474	382	ADDRESS_MAP_END
r24637	r24638
476	384	ADDRESS_MAP_START( seibu2_airraid_sound_map, AS_PROGRAM, 8, driver_device )
477	385	AM_RANGE(0x0000, 0x1fff) AM_ROM
478	386	AM_RANGE(0x2000, 0x27ff) AM_RAM
479		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
480		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
481		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
482		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
	387	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	388	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	389	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	390	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
483	391	AM_RANGE(0x4007, 0x4007) AM_WRITENOP // bank, always 0
484	392	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
485		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
486		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	393	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	394	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
487	395	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
488		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
489		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	396	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	397	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
490	398	//  AM_RANGE(0x6000, 0x6000) AM_DEVREADWRITE("oki", okim6295_device, read, write)
491	399	AM_RANGE(0x8000, 0xffff) AM_ROM
492	400	ADDRESS_MAP_END
r24637	r24638
494	402	ADDRESS_MAP_START( seibu2_sound_map, AS_PROGRAM, 8, driver_device )
495	403	AM_RANGE(0x0000, 0x1fff) AM_ROM
496	404	AM_RANGE(0x2000, 0x27ff) AM_RAM
497		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
498		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
499		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
500		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
501		AM_RANGE(0x4007, 0x4007) AM_WRITE_LEGACY(seibu_bank_w)
	405	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	406	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	407	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	408	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
	409	AM_RANGE(0x4007, 0x4007) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
502	410	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
503		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
504		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	411	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	412	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
505	413	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
506		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
507		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	414	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	415	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
508	416	AM_RANGE(0x6000, 0x6000) AM_DEVREADWRITE("oki", okim6295_device, read, write)
509	417	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
510	418	ADDRESS_MAP_END
r24637	r24638
512	420	ADDRESS_MAP_START( seibu2_raiden2_sound_map, AS_PROGRAM, 8, driver_device )
513	421	AM_RANGE(0x0000, 0x1fff) AM_ROM
514	422	AM_RANGE(0x2000, 0x27ff) AM_RAM
515		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
516		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
517		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
518		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
	423	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	424	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	425	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	426	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
519	427	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
520		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
521		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	428	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	429	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
522	430	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
523		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
524		AM_RANGE(0x401a, 0x401a) AM_WRITE_LEGACY(seibu_bank_w)
525		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	431	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	432	AM_RANGE(0x401a, 0x401a) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
	433	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
526	434	AM_RANGE(0x6000, 0x6000) AM_DEVREADWRITE("oki1", okim6295_device, read, write)
527	435	AM_RANGE(0x6002, 0x6002) AM_DEVREADWRITE("oki2", okim6295_device, read, write)
528	436	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
r24637	r24638
533	441	ADDRESS_MAP_START( seibu_newzeroteam_sound_map, AS_PROGRAM, 8, driver_device )
534	442	AM_RANGE(0x0000, 0x1fff) AM_ROM
535	443	AM_RANGE(0x2000, 0x27ff) AM_RAM
536		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
537		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
538		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
539		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
	444	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	445	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	446	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	447	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
540	448	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ymsnd", ym3812_device, read, write)
541		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
542		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	449	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	450	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
543	451	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
544		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
545		AM_RANGE(0x401a, 0x401a) AM_WRITE_LEGACY(seibu_bank_w)
546		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	452	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	453	AM_RANGE(0x401a, 0x401a) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
	454	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
547	455	AM_RANGE(0x6000, 0x6000) AM_DEVREADWRITE("oki", okim6295_device, read, write)
548	456	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
549	457	ADDRESS_MAP_END
r24637	r24638
551	459	ADDRESS_MAP_START( seibu3_sound_map, AS_PROGRAM, 8, driver_device )
552	460	AM_RANGE(0x0000, 0x1fff) AM_ROM
553	461	AM_RANGE(0x2000, 0x27ff) AM_RAM
554		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
555		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
556		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
557		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
558		AM_RANGE(0x4007, 0x4007) AM_WRITE_LEGACY(seibu_bank_w)
	462	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	463	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	464	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	465	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
	466	AM_RANGE(0x4007, 0x4007) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
559	467	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ym1", ym2203_device, read, write)
560		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
561		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	468	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	469	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
562	470	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
563		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
564		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
	471	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	472	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
565	473	AM_RANGE(0x6008, 0x6009) AM_DEVREADWRITE("ym2", ym2203_device, read, write)
566	474	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
567	475	ADDRESS_MAP_END
r24637	r24638
569	477	ADDRESS_MAP_START( seibu3_adpcm_sound_map, AS_PROGRAM, 8, driver_device )
570	478	AM_RANGE(0x0000, 0x1fff) AM_ROM
571	479	AM_RANGE(0x2000, 0x27ff) AM_RAM
572		AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(seibu_pending_w)
573		AM_RANGE(0x4001, 0x4001) AM_WRITE_LEGACY(seibu_irq_clear_w)
574		AM_RANGE(0x4002, 0x4002) AM_WRITE_LEGACY(seibu_rst10_ack_w)
575		AM_RANGE(0x4003, 0x4003) AM_WRITE_LEGACY(seibu_rst18_ack_w)
576		AM_RANGE(0x4005, 0x4006) AM_DEVWRITE_LEGACY("adpcm1", seibu_adpcm_adr_w)
577		AM_RANGE(0x4007, 0x4007) AM_WRITE_LEGACY(seibu_bank_w)
	480	AM_RANGE(0x4000, 0x4000) AM_DEVWRITE("seibu_sound", seibu_sound_device, pending_w)
	481	AM_RANGE(0x4001, 0x4001) AM_DEVWRITE("seibu_sound", seibu_sound_device, irq_clear_w)
	482	AM_RANGE(0x4002, 0x4002) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst10_ack_w)
	483	AM_RANGE(0x4003, 0x4003) AM_DEVWRITE("seibu_sound", seibu_sound_device, rst18_ack_w)
	484	AM_RANGE(0x4005, 0x4006) AM_DEVWRITE("adpcm1", seibu_adpcm_device, adr_w)
	485	AM_RANGE(0x4007, 0x4007) AM_DEVWRITE("seibu_sound", seibu_sound_device, bank_w)
578	486	AM_RANGE(0x4008, 0x4009) AM_DEVREADWRITE("ym1", ym2203_device, read, write)
579		AM_RANGE(0x4010, 0x4011) AM_READ_LEGACY(seibu_soundlatch_r)
580		AM_RANGE(0x4012, 0x4012) AM_READ_LEGACY(seibu_main_data_pending_r)
	487	AM_RANGE(0x4010, 0x4011) AM_DEVREAD("seibu_sound", seibu_sound_device, soundlatch_r)
	488	AM_RANGE(0x4012, 0x4012) AM_DEVREAD("seibu_sound", seibu_sound_device, main_data_pending_r)
581	489	AM_RANGE(0x4013, 0x4013) AM_READ_PORT("COIN")
582		AM_RANGE(0x4018, 0x4019) AM_WRITE_LEGACY(seibu_main_data_w)
583		AM_RANGE(0x401a, 0x401a) AM_DEVWRITE_LEGACY("adpcm1", seibu_adpcm_ctl_w)
584		AM_RANGE(0x401b, 0x401b) AM_WRITE_LEGACY(seibu_coin_w)
585		AM_RANGE(0x6005, 0x6006) AM_DEVWRITE_LEGACY("adpcm2", seibu_adpcm_adr_w)
	490	AM_RANGE(0x4018, 0x4019) AM_DEVWRITE("seibu_sound", seibu_sound_device, main_data_w)
	491	AM_RANGE(0x401a, 0x401a) AM_DEVWRITE("adpcm1", seibu_adpcm_device, ctl_w)
	492	AM_RANGE(0x401b, 0x401b) AM_DEVWRITE("seibu_sound", seibu_sound_device, coin_w)
	493	AM_RANGE(0x6005, 0x6006) AM_DEVWRITE("adpcm2", seibu_adpcm_device, adr_w)
586	494	AM_RANGE(0x6008, 0x6009) AM_DEVREADWRITE("ym2", ym2203_device, read, write)
587		AM_RANGE(0x601a, 0x601a) AM_DEVWRITE_LEGACY("adpcm2", seibu_adpcm_ctl_w)
	495	AM_RANGE(0x601a, 0x601a) AM_DEVWRITE("adpcm2", seibu_adpcm_device, ctl_w)
588	496	AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1")
589	497	ADDRESS_MAP_END
590	498
	499	/***************************************************************************
	500	Seibu ADPCM device
	501	***************************************************************************/
591	502
592	503	const device_type SEIBU_ADPCM = &device_creator<seibu_adpcm_device>;
593	504
594	505	seibu_adpcm_device::seibu_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
595	506	: device_t(mconfig, SEIBU_ADPCM, "Seibu ADPCM", tag, owner, clock, "seibu_adpcm", __FILE__),
596		device_sound_interface(mconfig, *this)
	507	device_sound_interface(mconfig, *this),
	508	m_stream(NULL),
	509	m_current(0),
	510	m_end(0),
	511	m_nibble(0),
	512	m_playing(0),
	513	m_allocated(0),
	514	m_base(NULL)
597	515	{
598		m_token = global_alloc_clear(seibu_adpcm_state);
599	516	}
600	517
601	518	//-------------------------------------------------
r24637	r24638
606	523
607	524	void seibu_adpcm_device::device_config_complete()
608	525	{
	526	// inherit a copy of the static data
	527	const seibu_adpcm_interface *intf = reinterpret_cast<const seibu_adpcm_interface *>(static_config());
	528	if (intf != NULL)
	529	*static_cast<seibu_adpcm_interface *>(this) = *intf;
	530
	531	// or initialize to defaults if none provided
	532	else
	533	{
	534	m_rom_region = "";
	535	}
609	536	}
610	537
611	538	//-------------------------------------------------
r24637	r24638
614	541
615	542	void seibu_adpcm_device::device_start()
616	543	{
617		DEVICE_START_NAME( seibu_adpcm )(this);
	544	m_playing = 0;
	545	m_stream = machine().sound().stream_alloc(*this, 0, 1, clock(), this);
	546	m_base = machine().root_device().memregion(m_rom_region)->base();
	547	m_adpcm.reset();
618	548	}
619	549
	550	// "decrypt" is a bit flowery here, as it's probably just line-swapping to
	551	// simplify PCB layout/routing rather than intentional protection, but it
	552	// still fits, especially since the Z80s for all these games are truly encrypted.
	553
	554	void seibu_adpcm_device::decrypt(const char *region)
	555	{
	556	UINT8 *ROM = machine().root_device().memregion(region)->base();
	557	int len = machine().root_device().memregion(region)->bytes();
	558	int i;
	559
	560	for (i = 0; i < len; i++)
	561	{
	562	ROM[i] = BITSWAP8(ROM[i], 7, 5, 3, 1, 6, 4, 2, 0);
	563	}
	564	}
	565
	566	WRITE8_MEMBER( seibu_adpcm_device::adr_w )
	567	{
	568	if (m_stream)
	569	m_stream->update();
	570	if (offset)
	571	{
	572	m_end = data<<8;
	573	}
	574	else
	575	{
	576	m_current = data<<8;
	577	m_nibble = 4;
	578	}
	579	}
	580
	581	WRITE8_MEMBER( seibu_adpcm_device::ctl_w )
	582	{
	583	// sequence is 00 02 01 each time.
	584	if (m_stream)
	585	m_stream->update();
	586	switch (data)
	587	{
	588	case 0:
	589	m_playing = 0;
	590	break;
	591	case 2:
	592	break;
	593	case 1:
	594	m_playing = 1;
	595	break;
	596
	597	}
	598	}
	599
	600
620	601	//-------------------------------------------------
621	602	//  sound_stream_update - handle a stream update
622	603	//-------------------------------------------------
623	604
624	605	void seibu_adpcm_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
625	606	{
626		// should never get here
627		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
	607	stream_sample_t *dest = outputs[0];
	608
	609	while (m_playing && samples > 0)
	610	{
	611	int val = (m_base[m_current] >> m_nibble) & 15;
	612
	613	m_nibble ^= 4;
	614	if (m_nibble == 4)
	615	{
	616	m_current++;
	617	if (m_current >= m_end)
	618	m_playing = 0;
	619	}
	620
	621	*dest++ = m_adpcm.clock(val) << 4;
	622	samples--;
	623	}
	624	while (samples > 0)
	625	{
	626	*dest++ = 0;
	627	samples--;
	628	}
628	629	}
	630
	631	//  Handlers for early Seibu/Tad games with dual channel ADPCM
	632
	633
	634	const seibu_adpcm_interface seibu_adpcm1_intf =
	635	{
	636	"adpcm1"
	637	};
	638
	639	const seibu_adpcm_interface seibu_adpcm2_intf =
	640	{
	641	"adpcm2"
	642	};

trunk/src/mame/audio/seibu.h

r24637	r24638
37	37	ADDRESS_MAP_EXTERN(seibu3_sound_map, 8);
38	38	ADDRESS_MAP_EXTERN(seibu3_adpcm_sound_map, 8);
39	39
40		DECLARE_READ16_HANDLER( seibu_main_word_r );
41		DECLARE_READ8_HANDLER( seibu_main_v30_r );
42		DECLARE_WRITE16_HANDLER( seibu_main_word_w );
43		DECLARE_WRITE8_HANDLER( seibu_main_v30_w );
	40	class seibu_sound_device : public device_t
	41	{
	42	public:
	43	seibu_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	44	~seibu_sound_device() {}
44	45
45		DECLARE_WRITE16_HANDLER( seibu_main_mustb_w );
	46	DECLARE_READ16_MEMBER( main_word_r );
	47	DECLARE_READ8_MEMBER( main_v30_r );
	48	DECLARE_WRITE16_MEMBER( main_word_w );
	49	DECLARE_WRITE8_MEMBER( main_v30_w );
46	50
47		DECLARE_WRITE8_HANDLER( seibu_irq_clear_w );
48		DECLARE_WRITE8_HANDLER( seibu_rst10_ack_w );
49		DECLARE_WRITE8_HANDLER( seibu_rst18_ack_w );
50		DECLARE_WRITE8_HANDLER( seibu_bank_w );
51		DECLARE_WRITE8_HANDLER( seibu_coin_w );
52		void seibu_ym3812_irqhandler(device_t *device, int linestate);
53		WRITE_LINE_DEVICE_HANDLER(seibu_ym2151_irqhandler);
54		void seibu_ym2203_irqhandler(device_t *device, int linestate);
55		DECLARE_READ8_HANDLER( seibu_soundlatch_r );
56		DECLARE_READ8_HANDLER( seibu_main_data_pending_r );
57		DECLARE_WRITE8_HANDLER( seibu_main_data_w );
58		MACHINE_RESET( seibu_sound );
59		void seibu_sound_decrypt(running_machine &machine,const char *cpu,int length);
	51	DECLARE_WRITE16_MEMBER( main_mustb_w );
60	52
61		void seibu_adpcm_decrypt(running_machine &machine, const char *region);
62		DECLARE_WRITE8_DEVICE_HANDLER( seibu_adpcm_adr_w );
63		DECLARE_WRITE8_DEVICE_HANDLER( seibu_adpcm_ctl_w );
	53	DECLARE_WRITE8_MEMBER( irq_clear_w );
	54	DECLARE_WRITE8_MEMBER( rst10_ack_w );
	55	DECLARE_WRITE8_MEMBER( rst18_ack_w );
	56	DECLARE_WRITE8_MEMBER( bank_w );
	57	DECLARE_WRITE8_MEMBER( coin_w );
	58	void ym3812_irqhandler(int linestate);
	59	WRITE_LINE_MEMBER(ym2151_irqhandler);
	60	void ym2203_irqhandler(int linestate);
	61	DECLARE_READ8_MEMBER( soundlatch_r );
	62	DECLARE_READ8_MEMBER( main_data_pending_r );
	63	DECLARE_WRITE8_MEMBER( main_data_w );
	64	DECLARE_WRITE8_MEMBER( pending_w );
	65	void decrypt(const char *cpu,int length);
	66	void update_irq_lines(int param);
	67
	68	protected:
	69	// device-level overrides
	70	virtual void device_config_complete();
	71	virtual void device_start();
	72	virtual void device_reset();
64	73
	74	private:
	75	// internal state
	76	device_t *m_sound_cpu;
	77	UINT8 m_main2sub[2];
	78	UINT8 m_sub2main[2];
	79	int m_main2sub_pending;
	80	int m_sub2main_pending;
	81
	82	enum
	83	{
	84	VECTOR_INIT,
	85	RST10_ASSERT,
	86	RST10_CLEAR,
	87	RST18_ASSERT,
	88	RST18_CLEAR
	89	};
	90	};
	91
	92	extern const device_type SEIBU_SOUND;
	93
	94	extern const ay8910_interface seibu_ay8910_config;
	95
	96
	97	// Seibu ADPCM device
	98
	99	struct seibu_adpcm_interface
	100	{
	101	const char *m_rom_region;
	102	};
	103
65	104	class seibu_adpcm_device : public device_t,
66		public device_sound_interface
	105	public device_sound_interface,
	106	public seibu_adpcm_interface
67	107	{
68	108	public:
69	109	seibu_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
70		~seibu_adpcm_device() { global_free(m_token); }
	110	~seibu_adpcm_device() {}
71	111
72		// access to legacy token
73		void *token() const { assert(m_token != NULL); return m_token; }
	112	void decrypt(const char *region);
	113	DECLARE_WRITE8_MEMBER( adr_w );
	114	DECLARE_WRITE8_MEMBER( ctl_w );
	115
74	116	protected:
75	117	// device-level overrides
76	118	virtual void device_config_complete();
r24637	r24638
78	120
79	121	// sound stream update overrides
80	122	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
81		private:
	123
	124	private:
82	125	// internal state
83		void *m_token;
	126	oki_adpcm_state m_adpcm;
	127	sound_stream *m_stream;
	128	UINT32 m_current;
	129	UINT32 m_end;
	130	UINT8 m_nibble;
	131	UINT8 m_playing;
	132	UINT8 m_allocated;
	133	UINT8 *m_base;
84	134	};
85	135
86	136	extern const device_type SEIBU_ADPCM;
87	137
88
89		extern const ay8910_interface seibu_ay8910_config;
90
91		struct seibu_adpcm_interface
92		{
93		const char *rom_region;
94		};
95
96	138	extern const seibu_adpcm_interface seibu_adpcm1_intf;
97	139	extern const seibu_adpcm_interface seibu_adpcm2_intf;
98	140
	141
99	142	/**************************************************************************/
100	143
	144	#define MCFG_SEIBU_SOUND_ADD(_tag) \
	145	MCFG_DEVICE_ADD(_tag, SEIBU_SOUND, 0)
	146
101	147	#define SEIBU_COIN_INPUTS                                           \
102	148	PORT_START("COIN")                                              \
103	149	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_COIN1 ) PORT_IMPULSE(4)     \
r24637	r24638
113	159
114	160	#define SEIBU_SOUND_SYSTEM_CPU(freq)                                \
115	161	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
116		MCFG_CPU_PROGRAM_MAP(seibu_sound_map)
	162	MCFG_CPU_PROGRAM_MAP(seibu_sound_map)                     \
	163	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	164
117	165	#define SEIBU2_SOUND_SYSTEM_CPU(freq)                               \
118	166	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
119		MCFG_CPU_PROGRAM_MAP(seibu2_sound_map)
	167	MCFG_CPU_PROGRAM_MAP(seibu2_sound_map)                     \
	168	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	169
120	170	#define SEIBU2_AIRRAID_SOUND_SYSTEM_CPU(freq)                       \
121	171	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
122		MCFG_CPU_PROGRAM_MAP(seibu2_airraid_sound_map)
	172	MCFG_CPU_PROGRAM_MAP(seibu2_airraid_sound_map)               \
	173	MCFG_SEIBU_SOUND_ADD("seibu_sound")
123	174
124	175	#define SEIBU2_RAIDEN2_SOUND_SYSTEM_CPU(freq)                       \
125		MCFG_CPU_ADD("audiocpu",  Z80, freq)                                \
126		MCFG_CPU_PROGRAM_MAP(seibu2_raiden2_sound_map)
	176	MCFG_CPU_ADD("audiocpu",  Z80, freq)                            \
	177	MCFG_CPU_PROGRAM_MAP(seibu2_raiden2_sound_map)               \
	178	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	179
127	180	#define SEIBU_NEWZEROTEAM_SOUND_SYSTEM_CPU(freq)                    \
128	181	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
129		MCFG_CPU_PROGRAM_MAP(seibu_newzeroteam_sound_map)
	182	MCFG_CPU_PROGRAM_MAP(seibu_newzeroteam_sound_map)            \
	183	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	184
130	185	#define SEIBU3_SOUND_SYSTEM_CPU(freq)                               \
131	186	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
132		MCFG_CPU_PROGRAM_MAP(seibu3_sound_map)
	187	MCFG_CPU_PROGRAM_MAP(seibu3_sound_map)                     \
	188	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	189
133	190	#define SEIBU3A_SOUND_SYSTEM_CPU(freq)                              \
134	191	MCFG_CPU_ADD("audiocpu", Z80, freq)                             \
135		MCFG_CPU_PROGRAM_MAP(seibu3_adpcm_sound_map)
	192	MCFG_CPU_PROGRAM_MAP(seibu3_adpcm_sound_map)               \
	193	MCFG_SEIBU_SOUND_ADD("seibu_sound")
	194
136	195	#define SEIBU_SOUND_SYSTEM_YM3812_INTERFACE(freq1,freq2)            \
137	196	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
138	197	\
139	198	MCFG_SOUND_ADD("ymsnd", YM3812, freq1)                              \
140		MCFG_YM3812_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym3812_irqhandler>)) \
	199	MCFG_YM3812_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym3812_irqhandler)) \
141	200	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)                      \
142	201	\
143	202	MCFG_OKIM6295_ADD("oki", freq2, OKIM6295_PIN7_LOW)              \
r24637	r24638
146	205	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
147	206	\
148	207	MCFG_SOUND_ADD("ymsnd", YM3812, freq1)                              \
149		MCFG_YM3812_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym3812_irqhandler>)) \
	208	MCFG_YM3812_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym3812_irqhandler)) \
150	209	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)                      \
151	210	\
152	211	MCFG_OKIM6295_ADD("oki", freq2, OKIM6295_PIN7_HIGH)             \
r24637	r24638
155	214	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
156	215	\
157	216	MCFG_YM2151_ADD("ymsnd", freq1)                             \
158		MCFG_YM2151_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2151_irqhandler>)) \
	217	MCFG_YM2151_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2151_irqhandler)) \
159	218	MCFG_SOUND_ROUTE(0, "mono", 0.50)                               \
160	219	MCFG_SOUND_ROUTE(1, "mono", 0.50)                               \
161	220	\
r24637	r24638
165	224	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
166	225	\
167	226	MCFG_YM2151_ADD("ymsnd", freq1)                             \
168		MCFG_YM2151_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2151_irqhandler>)) \
	227	MCFG_YM2151_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2151_irqhandler)) \
169	228	MCFG_SOUND_ROUTE(0, "mono", 0.50)                               \
170	229	MCFG_SOUND_ROUTE(1, "mono", 0.50)
171	230
r24637	r24638
173	232	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
174	233	\
175	234	MCFG_YM2151_ADD("ymsnd", freq1)                             \
176		MCFG_YM2151_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2151_irqhandler>)) \
	235	MCFG_YM2151_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2151_irqhandler)) \
177	236	MCFG_SOUND_ROUTE(0, "mono", 0.50)                               \
178	237	MCFG_SOUND_ROUTE(1, "mono", 0.50)                               \
179	238	\
r24637	r24638
187	246	MCFG_SPEAKER_STANDARD_MONO("mono")                              \
188	247	\
189	248	MCFG_SOUND_ADD("ym1", YM2203, freq)                             \
190		MCFG_YM2203_IRQ_HANDLER(WRITELINE(driver_device, member_wrapper_line<seibu_ym2203_irqhandler>)) \
	249	MCFG_YM2203_IRQ_HANDLER(DEVWRITELINE("seibu_sound", seibu_sound_device, ym2203_irqhandler)) \
191	250	MCFG_YM2203_AY8910_INTF(&seibu_ay8910_config)                   \
192	251	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.15)                     \
193	252	\

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team