Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-26 02:07:14 +03:00
Code Issues Actions 15 Packages Projects Releases Wiki Activity

-devices/sound/msm5205: Removed unused MCFG_MSM6585 macros, nw

Browse Source 
-audio/irem, drivers/appoooh, cabal, chinsan, combatsc, crgolf, dacholer, darius, ddragon, de_2: Removed MACHINE_CONFIG macros, nw

-drivers/ashnojoe, battlera: Removed MACHINE_CONFIG macros and updated to use non-legacy MSM5205 VCK callback, nw
This commit is contained in:
mooglyguy 2019-01-02 23:40:39 +01:00
parent fbe69b5f0c
commit 0fc7707b80
17 changed files with 452 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/devices/sound/msm5205.h
View File

@ -16,12 +16,6 @@
#define MCFG_MSM5205_VCLK_CB(cb) \
downcast<msm5205_device &>(*device).set_vck_legacy_callback((DEVCB_##cb));
#define MCFG_MSM6585_PRESCALER_SELECTOR(select) \
downcast<msm5205_device &>(*device).set_prescaler_selector((msm6585_device::select));
#define MCFG_MSM6585_VCK_CALLBACK(cb) \
downcast<msm5205_device &>(*device).set_vck_callback((DEVCB_##cb));
class msm5205_device : public device_t, public device_sound_interface
{

4
src/devices/video/huc6260.h
View File

@ -44,6 +44,10 @@ public:
template <class Object> devcb_base &set_time_til_next_event_callback(Object &&cb) { return m_time_til_next_event_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_vsync_changed_callback(Object &&cb) { return m_vsync_changed_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_hsync_changed_callback(Object &&cb) { return m_hsync_changed_cb.set_callback(std::forward<Object>(cb)); }
auto next_pixel_data() { return m_next_pixel_data_cb.bind(); }
auto time_til_next_event() { return m_time_til_next_event_cb.bind(); }
auto vsync_changed() { return m_vsync_changed_cb.bind(); }
auto hsync_changed() { return m_hsync_changed_cb.bind(); }
void video_update(bitmap_ind16 &bitmap, const rectangle &cliprect);
DECLARE_READ8_MEMBER( read );

1
src/devices/video/huc6270.h
View File

@ -26,6 +26,7 @@ public:
void set_vram_size(uint32_t vram_size) { m_vram_size = vram_size; }
template <class Object> devcb_base &set_irq_changed_callback(Object &&cb) { return m_irq_changed_cb.set_callback(std::forward<Object>(cb)); }
auto irq() { return m_irq_changed_cb.bind(); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

62
src/mame/audio/irem.cpp
View File

@ -398,8 +398,8 @@ void irem_audio_device::m62_sound_map(address_map &map)
// device_add_mconfig - add device configuration
//-------------------------------------------------
MACHINE_CONFIG_START(m62_audio_device::device_add_mconfig)
void m62_audio_device::device_add_mconfig(machine_config &config)
{
/* basic machine hardware */
m6803_cpu_device &cpu(M6803(config, m_cpu, XTAL(3'579'545))); /* verified on pcb */
cpu.set_addrmap(AS_PROGRAM, &m62_audio_device::m62_sound_map);
@ -440,39 +440,35 @@ MACHINE_CONFIG_START(m62_audio_device::device_add_mconfig)
/* NETLIST configuration using internal AY8910 resistor values */
MCFG_DEVICE_ADD("snd_nl", NETLIST_SOUND, 48000)
MCFG_NETLIST_SETUP(kidniki)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
netlist_mame_sound_device &snd_nl(NETLIST_SOUND(config, "snd_nl", 48000));
snd_nl.set_constructor(netlist_kidniki);
snd_nl.add_route(ALL_OUTPUTS, "mono", 1.0);
MCFG_NETLIST_LOGIC_INPUT("snd_nl", "ibd", "I_BD0.IN", 0)
MCFG_NETLIST_LOGIC_INPUT("snd_nl", "isd", "I_SD0.IN", 0)
MCFG_NETLIST_LOGIC_INPUT("snd_nl", "ich", "I_CH0.IN", 0)
MCFG_NETLIST_LOGIC_INPUT("snd_nl", "ioh", "I_OH0.IN", 0)
MCFG_NETLIST_LOGIC_INPUT("snd_nl", "sinh", "SINH.IN", 0)
NETLIST_LOGIC_INPUT(config, "snd_nl:ibd", "I_BD0.IN", 0);
NETLIST_LOGIC_INPUT(config, "snd_nl:isd", "I_SD0.IN", 0);
NETLIST_LOGIC_INPUT(config, "snd_nl:ich", "I_CH0.IN", 0);
NETLIST_LOGIC_INPUT(config, "snd_nl:ioh", "I_OH0.IN", 0);
NETLIST_LOGIC_INPUT(config, "snd_nl:sinh", "SINH.IN", 0);
MCFG_NETLIST_STREAM_INPUT("snd_nl", 0, "R_AY45M_A.R")
MCFG_NETLIST_STREAM_INPUT("snd_nl", 1, "R_AY45M_B.R")
MCFG_NETLIST_STREAM_INPUT("snd_nl", 2, "R_AY45M_C.R")
NETLIST_STREAM_INPUT(config, "snd_nl:cin0", 0, "R_AY45M_A.R");
NETLIST_STREAM_INPUT(config, "snd_nl:cin1", 1, "R_AY45M_B.R");
NETLIST_STREAM_INPUT(config, "snd_nl:cin2", 2, "R_AY45M_C.R");
MCFG_NETLIST_STREAM_INPUT("snd_nl", 3, "R_AY45L_A.R")
MCFG_NETLIST_STREAM_INPUT("snd_nl", 4, "R_AY45L_B.R")
MCFG_NETLIST_STREAM_INPUT("snd_nl", 5, "R_AY45L_C.R")
NETLIST_STREAM_INPUT(config, "snd_nl:cin3", 3, "R_AY45L_A.R");
NETLIST_STREAM_INPUT(config, "snd_nl:cin4", 4, "R_AY45L_B.R");
NETLIST_STREAM_INPUT(config, "snd_nl:cin5", 5, "R_AY45L_C.R");
MCFG_NETLIST_STREAM_INPUT("snd_nl", 6, "I_MSM2K0.IN")
MCFG_NETLIST_ANALOG_MULT_OFFSET(5.0/65535.0, 2.5)
MCFG_NETLIST_STREAM_INPUT("snd_nl", 7, "I_MSM3K0.IN")
MCFG_NETLIST_ANALOG_MULT_OFFSET(5.0/65535.0, 2.5)
NETLIST_STREAM_INPUT(config, "snd_nl:cin6", 6, "I_MSM2K0.IN").set_mult_offset(5.0/65535.0, 2.5);
NETLIST_STREAM_INPUT(config, "snd_nl:cin7", 7, "I_MSM3K0.IN").set_mult_offset(5.0/65535.0, 2.5);
//MCFG_NETLIST_STREAM_OUTPUT("snd_nl", 0, "RV1.1")
//MCFG_NETLIST_ANALOG_MULT_OFFSET(30000.0, -35000.0)
MCFG_NETLIST_STREAM_OUTPUT("snd_nl", 0, "R26.1")
MCFG_NETLIST_ANALOG_MULT_OFFSET(30000.0 * 10.0, 0.0)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(m52_soundc_audio_device::device_add_mconfig)
NETLIST_STREAM_OUTPUT(config, "snd_nl:cout0", 0, "R26.1").set_mult_offset(30000.0 * 10.0, 0.0);
}
void m52_soundc_audio_device::device_add_mconfig(machine_config &config)
{
/* basic machine hardware */
m6803_cpu_device &cpu(M6803(config, m_cpu, XTAL(3'579'545))); /* verified on pcb */
cpu.set_addrmap(AS_PROGRAM, &m52_soundc_audio_device::m52_small_sound_map);
@ -497,15 +493,13 @@ MACHINE_CONFIG_START(m52_soundc_audio_device::device_add_mconfig)
m_ay_45L->port_a_write_callback().set(FUNC(irem_audio_device::ay8910_45L_porta_w));
m_ay_45L->add_route(0, "filtermix", 1.0, 1);
MCFG_DEVICE_ADD("msm1", MSM5205, XTAL(384'000)) /* verified on pcb */
MCFG_MSM5205_VCK_CALLBACK(INPUTLINE("iremsound", INPUT_LINE_NMI)) // driven through NPN inverter
MCFG_MSM5205_PRESCALER_SELECTOR(S96_4B) /* default to 4KHz, but can be changed at run time */
MCFG_SOUND_ROUTE(0, "filtermix", 1.0, 2)
MSM5205(config, m_adpcm1, XTAL(384'000)); /* verified on pcb */
m_adpcm1->vck_callback().set_inputline(m_cpu, INPUT_LINE_NMI); // driven through NPN inverter
m_adpcm1->set_prescaler_selector(msm5205_device::S96_4B); /* default to 4KHz, but can be changed at run time */
m_adpcm1->add_route(0, "filtermix", 1.0, 2);
MCFG_DEVICE_ADD("filtermix", DISCRETE, m52_sound_c_discrete)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
MACHINE_CONFIG_END
DISCRETE(config, "filtermix", m52_sound_c_discrete).add_route(ALL_OUTPUTS, "mono", 1.0);
}
void m52_large_audio_device::device_add_mconfig(machine_config &config) /* 10 yard fight */
{

76
src/mame/drivers/appoooh.cpp
View File

@ -419,69 +419,63 @@ INTERRUPT_GEN_MEMBER(appoooh_state::vblank_irq)
device.execute().pulse_input_line(INPUT_LINE_NMI, attotime::zero);
}
MACHINE_CONFIG_START(appoooh_state::appoooh_common)
void appoooh_state::appoooh_common(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", Z80,18432000/6) /* ??? the main xtal is 18.432 MHz */
MCFG_DEVICE_PROGRAM_MAP(main_map)
MCFG_DEVICE_IO_MAP(main_portmap)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", appoooh_state, vblank_irq)
Z80(config, m_maincpu, 18432000/6); /* ??? the main xtal is 18.432 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &appoooh_state::main_map);
m_maincpu->set_addrmap(AS_IO, &appoooh_state::main_portmap);
m_maincpu->set_vblank_int("screen", FUNC(appoooh_state::vblank_irq));
/* sound hardware */
SPEAKER(config, "mono").front_center();
MCFG_DEVICE_ADD("sn1", SN76489, 18432000/6)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.30)
SN76489(config, "sn1", 18432000/6).add_route(ALL_OUTPUTS, "mono", 0.30);
SN76489(config, "sn2", 18432000/6).add_route(ALL_OUTPUTS, "mono", 0.30);
SN76489(config, "sn3", 18432000/6).add_route(ALL_OUTPUTS, "mono", 0.30);
MCFG_DEVICE_ADD("sn2", SN76489, 18432000/6)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.30)
MSM5205(config, m_msm, 384000);
m_msm->vck_legacy_callback().set(FUNC(appoooh_state::adpcm_int)); /* interrupt function */
m_msm->set_prescaler_selector(msm5205_device::S64_4B); /* 6KHz */
m_msm->add_route(ALL_OUTPUTS, "mono", 0.50);
}
MCFG_DEVICE_ADD("sn3", SN76489, 18432000/6)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.30)
MCFG_DEVICE_ADD("msm", MSM5205, 384000)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, appoooh_state, adpcm_int)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S64_4B) /* 6KHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(appoooh_state::appoooh)
void appoooh_state::appoooh(machine_config &config)
{
appoooh_common(config);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(32*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_UPDATE_DRIVER(appoooh_state, screen_update_appoooh)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(32*8, 32*8);
screen.set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
screen.set_screen_update(FUNC(appoooh_state::screen_update_appoooh));
screen.set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_appoooh);
PALETTE(config, m_palette, FUNC(appoooh_state::appoooh_palette), 32*8+32*8);
MACHINE_CONFIG_END
}
MACHINE_CONFIG_START(appoooh_state::robowres)
void appoooh_state::robowres(machine_config &config)
{
appoooh_common(config);
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_OPCODES_MAP(decrypted_opcodes_map)
m_maincpu->set_addrmap(AS_OPCODES, &appoooh_state::decrypted_opcodes_map);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(32*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_UPDATE_DRIVER(appoooh_state, screen_update_robowres)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(32*8, 32*8);
screen.set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
screen.set_screen_update(FUNC(appoooh_state::screen_update_robowres));
screen.set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_robowres);
PALETTE(config, m_palette, FUNC(appoooh_state::robowres_palette), 32*8+32*8);
MACHINE_CONFIG_END
}
void appoooh_state::robowrese(machine_config &config)
{

46
src/mame/drivers/ashnojoe.cpp
View File

@ -279,7 +279,7 @@ WRITE8_MEMBER(ashnojoe_state::ym2203_write_b)
WRITE_LINE_MEMBER(ashnojoe_state::ashnojoe_vclk_cb)
{
if (m_msm5205_vclk_toggle == 0)
if (state)
{
m_msm->write_data(m_adpcm_byte >> 4);
}
@ -288,42 +288,38 @@ WRITE_LINE_MEMBER(ashnojoe_state::ashnojoe_vclk_cb)
m_msm->write_data(m_adpcm_byte & 0xf);
m_audiocpu->pulse_input_line(INPUT_LINE_NMI, attotime::zero);
}
m_msm5205_vclk_toggle ^= 1;
}
void ashnojoe_state::machine_start()
{
save_item(NAME(m_adpcm_byte));
save_item(NAME(m_msm5205_vclk_toggle));
}
void ashnojoe_state::machine_reset()
{
m_adpcm_byte = 0;
m_msm5205_vclk_toggle = 0;
}
MACHINE_CONFIG_START(ashnojoe_state::ashnojoe)
void ashnojoe_state::ashnojoe(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, 8000000)
MCFG_DEVICE_PROGRAM_MAP(ashnojoe_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", ashnojoe_state, irq1_line_hold)
M68000(config, m_maincpu, 8000000);
m_maincpu->set_addrmap(AS_PROGRAM, &ashnojoe_state::ashnojoe_map);
m_maincpu->set_vblank_int("screen", FUNC(ashnojoe_state::irq1_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80, 4000000)
MCFG_DEVICE_PROGRAM_MAP(sound_map)
MCFG_DEVICE_IO_MAP(sound_portmap)
Z80(config, m_audiocpu, 4000000);
m_audiocpu->set_addrmap(AS_PROGRAM, &ashnojoe_state::sound_map);
m_audiocpu->set_addrmap(AS_IO, &ashnojoe_state::sound_portmap);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(512, 512)
MCFG_SCREEN_VISIBLE_AREA(14*8, 50*8-1, 3*8, 29*8-1)
MCFG_SCREEN_UPDATE_DRIVER(ashnojoe_state, screen_update_ashnojoe)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(512, 512);
screen.set_visarea(14*8, 50*8-1, 3*8, 29*8-1);
screen.set_screen_update(FUNC(ashnojoe_state::screen_update_ashnojoe));
screen.set_palette("palette");
GFXDECODE(config, m_gfxdecode, "palette", gfx_ashnojoe);
PALETTE(config, "palette").set_format(palette_device::xRGB_555, 0x1000/2);
@ -339,11 +335,11 @@ MACHINE_CONFIG_START(ashnojoe_state::ashnojoe)
ymsnd.port_b_write_callback().set(FUNC(ashnojoe_state::ym2203_write_b));
ymsnd.add_route(ALL_OUTPUTS, "mono", 0.1);
MCFG_DEVICE_ADD("msm", MSM5205, 384000)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, ashnojoe_state, ashnojoe_vclk_cb))
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
MACHINE_CONFIG_END
MSM5205(config, m_msm, 384000);
m_msm->vck_callback().set(FUNC(ashnojoe_state::ashnojoe_vclk_cb));
m_msm->set_prescaler_selector(msm5205_device::S48_4B);
m_msm->add_route(ALL_OUTPUTS, "mono", 1.0);
}
ROM_START( scessjoe )
ROM_REGION( 0xc0000, "maincpu", 0 ) /* 68000 code */

51
src/mame/drivers/battlera.cpp
View File

@ -102,7 +102,12 @@ void battlera_state::machine_start()
{
save_item(NAME(m_control_port_select));
save_item(NAME(m_msm5205next));
save_item(NAME(m_toggle));
}
void battlera_state::machine_reset()
{
m_control_port_select = 0;
m_msm5205next = 0;
}
/******************************************************************************/
@ -151,8 +156,7 @@ WRITE_LINE_MEMBER(battlera_state::adpcm_int)
m_msm->write_data(m_msm5205next >> 4);
m_msm5205next <<= 4;
m_toggle = 1 - m_toggle;
if (m_toggle)
if (state)
m_audiocpu->set_input_line(1, HOLD_LINE);
}
@ -250,8 +254,8 @@ uint32_t battlera_state::screen_update(screen_device &screen, bitmap_ind16 &bitm
}
MACHINE_CONFIG_START(battlera_state::battlera)
void battlera_state::battlera(machine_config &config)
{
/* basic machine hardware */
H6280(config, m_maincpu, 21477200/3);
m_maincpu->set_addrmap(AS_PROGRAM, &battlera_state::battlera_map);
@ -267,20 +271,20 @@ MACHINE_CONFIG_START(battlera_state::battlera)
m_audiocpu->add_route(ALL_OUTPUTS, "mono", 0.60); // music data is stereo, but hardware isn't
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(MAIN_CLOCK, huc6260_device::WPF, 64, 64 + 1024 + 64, huc6260_device::LPF, 18, 18 + 242)
MCFG_SCREEN_UPDATE_DRIVER( battlera_state, screen_update )
MCFG_SCREEN_PALETTE("huc6260")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(MAIN_CLOCK, huc6260_device::WPF, 64, 64 + 1024 + 64, huc6260_device::LPF, 18, 18 + 242);
m_screen->set_screen_update(FUNC(battlera_state::screen_update));
m_screen->set_palette(m_huc6260);
MCFG_DEVICE_ADD( "huc6260", HUC6260, MAIN_CLOCK )
MCFG_HUC6260_NEXT_PIXEL_DATA_CB(READ16("huc6270", huc6270_device, next_pixel))
MCFG_HUC6260_TIME_TIL_NEXT_EVENT_CB(READ16("huc6270", huc6270_device, time_until_next_event))
MCFG_HUC6260_VSYNC_CHANGED_CB(WRITELINE("huc6270", huc6270_device, vsync_changed))
MCFG_HUC6260_HSYNC_CHANGED_CB(WRITELINE("huc6270", huc6270_device, hsync_changed))
HUC6260(config, m_huc6260, MAIN_CLOCK);
m_huc6260->next_pixel_data().set("huc6270", FUNC(huc6270_device::next_pixel));
m_huc6260->time_til_next_event().set("huc6270", FUNC(huc6270_device::time_until_next_event));
m_huc6260->vsync_changed().set("huc6270", FUNC(huc6270_device::vsync_changed));
m_huc6260->hsync_changed().set("huc6270", FUNC(huc6270_device::hsync_changed));
MCFG_DEVICE_ADD( "huc6270", HUC6270, 0 )
MCFG_HUC6270_VRAM_SIZE(0x20000)
MCFG_HUC6270_IRQ_CHANGED_CB(INPUTLINE("maincpu", 0))
huc6270_device &huc6270(HUC6270(config, "huc6270", 0));
huc6270.set_vram_size(0x20000);
huc6270.irq().set_inputline(m_maincpu, 0);
/* sound hardware */
SPEAKER(config, "mono").front_center();
@ -288,14 +292,13 @@ MACHINE_CONFIG_START(battlera_state::battlera)
GENERIC_LATCH_8(config, m_soundlatch);
m_soundlatch->data_pending_callback().set_inputline(m_audiocpu, 0);
MCFG_DEVICE_ADD("ymsnd", YM2203, 12000000 / 8)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.40)
YM2203(config, "ymsnd", 12000000 / 8).add_route(ALL_OUTPUTS, "mono", 0.40);
MCFG_DEVICE_ADD("msm", MSM5205, 384000)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, battlera_state, adpcm_int)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8KHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.85)
MACHINE_CONFIG_END
MSM5205(config, m_msm, 384000);
m_msm->vck_callback().set(FUNC(battlera_state::adpcm_int));
m_msm->set_prescaler_selector(msm5205_device::S48_4B); /* 8KHz */
m_msm->add_route(ALL_OUTPUTS, "mono", 0.85);
}
/******************************************************************************/

113
src/mame/drivers/cabal.cpp
View File

@ -501,28 +501,28 @@ static GFXDECODE_START( gfx_cabal )
GFXDECODE_END
MACHINE_CONFIG_START(cabal_state::cabal)
void cabal_state::cabal(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, XTAL(20'000'000)/2) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(main_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", cabal_state, irq1_line_hold)
M68000(config, m_maincpu, XTAL(20'000'000)/2); /* verified on pcb */
m_maincpu->set_addrmap(AS_PROGRAM, &cabal_state::main_map);
m_maincpu->set_vblank_int("screen", FUNC(cabal_state::irq1_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80, XTAL(3'579'545)) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(sound_map)
MCFG_DEVICE_OPCODES_MAP(sound_decrypted_opcodes_map)
MCFG_DEVICE_IRQ_ACKNOWLEDGE_DEVICE("seibu_sound", seibu_sound_device, im0_vector_cb)
Z80(config, m_audiocpu, XTAL(3'579'545)); /* verified on pcb */
m_audiocpu->set_addrmap(AS_PROGRAM, &cabal_state::sound_map);
m_audiocpu->set_addrmap(AS_OPCODES, &cabal_state::sound_decrypted_opcodes_map);
m_audiocpu->set_irq_acknowledge_callback("seibu_sound", FUNC(seibu_sound_device::im0_vector_cb));
SEI80BU(config, "sei80bu", 0).set_device_rom_tag("audiocpu");
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(59.60) /* verified on pcb */
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_UPDATE_DRIVER(cabal_state, screen_update)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(59.60); /* verified on pcb */
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_size(256, 256);
screen.set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
screen.set_screen_update(FUNC(cabal_state::screen_update));
screen.set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_cabal);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 1024);
@ -541,14 +541,13 @@ MACHINE_CONFIG_START(cabal_state::cabal)
ymsnd.add_route(ALL_OUTPUTS, "mono", 0.80);
SEIBU_ADPCM(config, m_adpcm1, 8000).add_route(ALL_OUTPUTS, "mono", 0.40); /* it should use the msm5205 */
SEIBU_ADPCM(config, m_adpcm2, 8000).add_route(ALL_OUTPUTS, "mono", 0.40); /* it should use the msm5205 */
MACHINE_CONFIG_END
}
MACHINE_CONFIG_START(cabal_state::cabalt)
void cabal_state::cabalt(machine_config &config)
{
cabal(config);
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(trackball_main_map)
m_maincpu->set_addrmap(AS_PROGRAM, &cabal_state::trackball_main_map);
upd4701_device &upd4701l(UPD4701A(config, "upd4701l"));
upd4701l.set_portx_tag("IN0");
@ -557,53 +556,53 @@ MACHINE_CONFIG_START(cabal_state::cabalt)
upd4701_device &upd4701h(UPD4701A(config, "upd4701h"));
upd4701h.set_portx_tag("IN2");
upd4701h.set_porty_tag("IN3");
MACHINE_CONFIG_END
}
MACHINE_CONFIG_START(cabal_state::cabalbl2)
void cabal_state::cabalbl2(machine_config &config)
{
cabal(config);
config.device_remove("sei80bu");
MCFG_DEVICE_MODIFY("audiocpu")
MCFG_DEVICE_PROGRAM_MAP(cabalbl2_sound_map)
MCFG_DEVICE_OPCODES_MAP(cabalbl2_predecrypted_opcodes_map)
MACHINE_CONFIG_END
m_audiocpu->set_addrmap(AS_PROGRAM, &cabal_state::cabalbl2_sound_map);
m_audiocpu->set_addrmap(AS_OPCODES, &cabal_state::cabalbl2_predecrypted_opcodes_map);
}
/* the bootleg has different sound hardware (2 extra Z80s for ADPCM playback) */
MACHINE_CONFIG_START(cabal_state::cabalbl)
void cabal_state::cabalbl(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, XTAL(20'000'000)/2) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(cabalbl_main_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", cabal_state, irq1_line_hold)
M68000(config, m_maincpu, XTAL(20'000'000)/2); /* verified on pcb */
m_maincpu->set_addrmap(AS_PROGRAM, &cabal_state::cabalbl_main_map);
m_maincpu->set_vblank_int("screen", FUNC(cabal_state::irq1_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80, XTAL(3'579'545)) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(cabalbl_sound_map)
Z80(config, m_audiocpu, XTAL(3'579'545)); /* verified on pcb */
m_audiocpu->set_addrmap(AS_PROGRAM, &cabal_state::cabalbl_sound_map);
/* there are 2x z80s for the ADPCM */
MCFG_DEVICE_ADD("adpcm_1", Z80, XTAL(3'579'545)) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(cabalbl_talk1_map)
MCFG_DEVICE_IO_MAP(cabalbl_talk1_portmap)
MCFG_DEVICE_PERIODIC_INT_DRIVER(cabal_state, irq0_line_hold, 8000)
z80_device &adpcm_1(Z80(config, "adpcm_1", XTAL(3'579'545))); /* verified on pcb */
adpcm_1.set_addrmap(AS_PROGRAM, &cabal_state::cabalbl_talk1_map);
adpcm_1.set_addrmap(AS_IO, &cabal_state::cabalbl_talk1_portmap);
adpcm_1.set_periodic_int(FUNC(cabal_state::irq0_line_hold), attotime::from_hz(8000));
MCFG_DEVICE_ADD("adpcm_2", Z80, XTAL(3'579'545)) /* verified on pcb */
MCFG_DEVICE_PROGRAM_MAP(cabalbl_talk2_map)
MCFG_DEVICE_IO_MAP(cabalbl_talk2_portmap)
MCFG_DEVICE_PERIODIC_INT_DRIVER(cabal_state, irq0_line_hold, 8000)
z80_device &adpcm_2(Z80(config, "adpcm_2", XTAL(3'579'545))); /* verified on pcb */
adpcm_2.set_addrmap(AS_PROGRAM, &cabal_state::cabalbl_talk2_map);
adpcm_2.set_addrmap(AS_IO, &cabal_state::cabalbl_talk2_portmap);
adpcm_2.set_periodic_int(FUNC(cabal_state::irq0_line_hold), attotime::from_hz(8000));
MCFG_QUANTUM_TIME(attotime::from_hz(600))
config.m_minimum_quantum = attotime::from_hz(600);
MCFG_MACHINE_START_OVERRIDE(cabal_state,cabalbl)
MCFG_MACHINE_RESET_OVERRIDE(cabal_state,cabalbl)
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_UPDATE_DRIVER(cabal_state, screen_update)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_size(256, 256);
screen.set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
screen.set_screen_update(FUNC(cabal_state::screen_update));
screen.set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_cabal);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 1024);
@ -619,14 +618,14 @@ MACHINE_CONFIG_START(cabal_state::cabalbl)
ymsnd.irq_handler().set_inputline(m_audiocpu, 0);
ymsnd.add_route(ALL_OUTPUTS, "mono", 0.80);
MCFG_DEVICE_ADD("msm1", MSM5205, XTAL(12'000'000)/32) /* verified on pcb (no resonator) */
MCFG_MSM5205_PRESCALER_SELECTOR(SEX_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.60)
MSM5205(config, m_msm1, XTAL(12'000'000)/32); /* verified on pcb (no resonator) */
m_msm1->set_prescaler_selector(msm5205_device::SEX_4B);
m_msm1->add_route(ALL_OUTPUTS, "mono", 0.60);
MCFG_DEVICE_ADD("msm2", MSM5205, XTAL(12'000'000)/32) /* verified on pcb (no resonator)*/
MCFG_MSM5205_PRESCALER_SELECTOR(SEX_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.60)
MACHINE_CONFIG_END
MSM5205(config, m_msm2, XTAL(12'000'000)/32); /* verified on pcb (no resonator)*/
m_msm2->set_prescaler_selector(msm5205_device::SEX_4B);
m_msm2->add_route(ALL_OUTPUTS, "mono", 0.60);
}
ROM_START( cabal )
ROM_REGION( 0x50000, "maincpu", 0 ) /* 64k for cpu code */

55
src/mame/drivers/chinsan.cpp
View File

@ -506,12 +506,13 @@ void chinsan_state::init_chinsan()
//**************************************************************************
// C1-00114-B
MACHINE_CONFIG_START(chinsan_state::chinsan)
MCFG_DEVICE_ADD("maincpu", MC8123, XTAL(10'000'000)/2) // 317-5012
MCFG_DEVICE_PROGRAM_MAP(chinsan_map)
MCFG_DEVICE_IO_MAP(chinsan_io_map)
MCFG_DEVICE_OPCODES_MAP(decrypted_opcodes_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", chinsan_state, vblank_int)
void chinsan_state::chinsan(machine_config &config)
{
MC8123(config, m_maincpu, XTAL(10'000'000)/2); // 317-5012
m_maincpu->set_addrmap(AS_PROGRAM, &chinsan_state::chinsan_map);
m_maincpu->set_addrmap(AS_IO, &chinsan_state::chinsan_io_map);
m_maincpu->set_addrmap(AS_OPCODES, &chinsan_state::decrypted_opcodes_map);
m_maincpu->set_vblank_int("screen", FUNC(chinsan_state::vblank_int));
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
@ -521,15 +522,15 @@ MACHINE_CONFIG_START(chinsan_state::chinsan)
ppi.in_pc_callback().set(FUNC(chinsan_state::input_p1_r));
// video hardware
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_SIZE(512, 256)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_VISIBLE_AREA(24, 512-24-1, 16, 256-16-1)
MCFG_SCREEN_UPDATE_DRIVER(chinsan_state, screen_update)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(512, 256);
screen.set_visarea(24, 512-24-1, 16, 256-16-1);
screen.set_screen_update(FUNC(chinsan_state::screen_update));
screen.set_palette("palette");
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_chinsan)
GFXDECODE(config, m_gfxdecode, "palette", gfx_chinsan);
PALETTE(config, "palette", palette_device::RGB_444_PROMS, "proms", 256);
// sound hardware
@ -543,24 +544,24 @@ MACHINE_CONFIG_START(chinsan_state::chinsan)
ymsnd.add_route(2, "mono", 0.15);
ymsnd.add_route(3, "mono", 0.10);
MCFG_DEVICE_ADD("adpcm", MSM5205, XTAL(384'000))
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, chinsan_state, adpcm_int_w))
MCFG_MSM5205_PRESCALER_SELECTOR(S64_4B) // 8kHz
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MACHINE_CONFIG_END
MSM5205(config, m_adpcm, XTAL(384'000));
m_adpcm->vck_legacy_callback().set(FUNC(chinsan_state::adpcm_int_w));
m_adpcm->set_prescaler_selector(msm5205_device::S64_4B); // 8kHz
m_adpcm->add_route(ALL_OUTPUTS, "mono", 0.50);
}
MACHINE_CONFIG_START(chinsan_state::mayumi)
void chinsan_state::mayumi(machine_config &config)
{
chinsan(config);
// standard Z80 instead of MC-8123
MCFG_DEVICE_REMOVE("maincpu")
MCFG_DEVICE_ADD("maincpu", Z80, XTAL(10'000'000)/2)
MCFG_DEVICE_PROGRAM_MAP(chinsan_map)
MCFG_DEVICE_IO_MAP(mayumi_io_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", chinsan_state, vblank_int)
Z80(config.replace(), m_maincpu, XTAL(10'000'000)/2);
m_maincpu->set_addrmap(AS_PROGRAM, &chinsan_state::chinsan_map);
m_maincpu->set_addrmap(AS_IO, &chinsan_state::mayumi_io_map);
m_maincpu->set_vblank_int("screen", FUNC(chinsan_state::vblank_int));
// no ADPCM
MCFG_DEVICE_REMOVE("adpcm")
MACHINE_CONFIG_END
config.device_remove("adpcm");
}
//**************************************************************************

79
src/mame/drivers/combatsc.cpp
View File

@ -700,36 +700,37 @@ void combatsc_state::machine_reset()
}
/* combat school (original) */
MACHINE_CONFIG_START(combatsc_state::combatsc)
void combatsc_state::combatsc(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", HD6309, 3000000*4) /* 3 MHz? */
MCFG_DEVICE_PROGRAM_MAP(combatsc_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", combatsc_state, irq0_line_hold)
HD6309(config, m_maincpu, 3000000*4); /* 3 MHz? */
m_maincpu->set_addrmap(AS_PROGRAM, &combatsc_state::combatsc_map);
m_maincpu->set_vblank_int("screen", FUNC(combatsc_state::irq0_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80,3579545) /* 3.579545 MHz */
MCFG_DEVICE_PROGRAM_MAP(combatsc_sound_map)
Z80(config, m_audiocpu, 3579545); /* 3.579545 MHz */
m_audiocpu->set_addrmap(AS_PROGRAM, &combatsc_state::combatsc_sound_map);
MCFG_QUANTUM_TIME(attotime::from_hz(1200))
config.m_minimum_quantum = attotime::from_hz(1200);
MCFG_MACHINE_START_OVERRIDE(combatsc_state,combatsc)
WATCHDOG_TIMER(config, "watchdog");
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
// MCFG_SCREEN_REFRESH_RATE(60)
// MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
// MCFG_SCREEN_SIZE(32*8, 32*8)
// MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_RAW_PARAMS(XTAL(24'000'000)/3, 528, 0, 256, 256, 16, 240) // not accurate, assuming same to other Konami games (59.17)
MCFG_SCREEN_UPDATE_DRIVER(combatsc_state, screen_update_combatsc)
MCFG_SCREEN_PALETTE(m_palette)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
// m_screen->set_refresh_hz(60);
// m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
// m_screen->set_size(32*8, 32*8);
// m_screen->set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
m_screen->set_raw(XTAL(24'000'000)/3, 528, 0, 256, 256, 16, 240); // not accurate, assuming same to other Konami games (59.17)
m_screen->set_screen_update(FUNC(combatsc_state::screen_update_combatsc));
m_screen->set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_combatsc);
PALETTE(config, m_palette, FUNC(combatsc_state::combatsc_palette));
m_palette->set_format(palette_device::xBGR_555, 8 * 16 * 16, 128);
m_palette->set_endianness(ENDIANNESS_LITTLE);
MCFG_VIDEO_START_OVERRIDE(combatsc_state,combatsc)
K007121(config, m_k007121_1, 0);
@ -747,37 +748,38 @@ MACHINE_CONFIG_START(combatsc_state::combatsc)
ymsnd.add_route(ALL_OUTPUTS, "mono", 0.20);
UPD7759(config, m_upd7759).add_route(ALL_OUTPUTS, "mono", 0.70);
MACHINE_CONFIG_END
}
/* combat school (bootleg on different hardware) */
MACHINE_CONFIG_START(combatsc_state::combatscb)
void combatsc_state::combatscb(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", HD6309, 3000000*4) /* 3 MHz? */
MCFG_DEVICE_PROGRAM_MAP(combatscb_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", combatsc_state, irq0_line_hold)
HD6309(config, m_maincpu, 3000000*4); /* 3 MHz? */
m_maincpu->set_addrmap(AS_PROGRAM, &combatsc_state::combatscb_map);
m_maincpu->set_vblank_int("screen", FUNC(combatsc_state::irq0_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80,3579545) /* 3.579545 MHz */
MCFG_DEVICE_PROGRAM_MAP(combatscb_sound_map)
Z80(config, m_audiocpu, 3579545); /* 3.579545 MHz */
m_audiocpu->set_addrmap(AS_PROGRAM, &combatsc_state::combatscb_sound_map);
MCFG_QUANTUM_TIME(attotime::from_hz(1200))
config.m_minimum_quantum = attotime::from_hz(1200);
MCFG_MACHINE_START_OVERRIDE(combatsc_state,combatscb)
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(32*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
MCFG_SCREEN_UPDATE_DRIVER(combatsc_state, screen_update_combatscb)
MCFG_SCREEN_PALETTE(m_palette)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
m_screen->set_size(32*8, 32*8);
m_screen->set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
m_screen->set_screen_update(FUNC(combatsc_state::screen_update_combatscb));
m_screen->set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_combatscb);
PALETTE(config, m_palette, FUNC(combatsc_state::combatscb_palette));
m_palette->set_format(palette_device::xBGR_555, 8 * 16 * 16, 128);
m_palette->set_endianness(ENDIANNESS_LITTLE);
MCFG_VIDEO_START_OVERRIDE(combatsc_state,combatscb)
SPEAKER(config, "mono").front_center();
@ -785,14 +787,13 @@ MACHINE_CONFIG_START(combatsc_state::combatscb)
GENERIC_LATCH_8(config, m_soundlatch);
m_soundlatch->data_pending_callback().set_inputline(m_audiocpu, INPUT_LINE_NMI);
MCFG_DEVICE_ADD("ymsnd", YM2203, 3000000)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20)
YM2203(config, "ymsnd", 3000000).add_route(ALL_OUTPUTS, "mono", 0.20);
MCFG_DEVICE_ADD("msm", MSM5205, 384000)
MCFG_MSM5205_PRESCALER_SELECTOR(S96_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.30)
MCFG_MSM5205_VCK_CALLBACK(ASSERTLINE("audiocpu", 0))
MACHINE_CONFIG_END
MSM5205(config, m_msm, 384000);
m_msm->vck_callback().set_inputline("audiocpu", 0, ASSERT_LINE);
m_msm->set_prescaler_selector(msm5205_device::S96_4B);
m_msm->add_route(ALL_OUTPUTS, "mono", 0.30);
}

70
src/mame/drivers/crgolf.cpp
View File

@ -465,18 +465,18 @@ INPUT_PORTS_END
*
*************************************/
MACHINE_CONFIG_START(crgolf_state::crgolf)
void crgolf_state::crgolf(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", Z80,MASTER_CLOCK/3/2)
MCFG_DEVICE_PROGRAM_MAP(main_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", crgolf_state, irq0_line_hold)
Z80(config, m_maincpu, MASTER_CLOCK/3/2);
m_maincpu->set_addrmap(AS_PROGRAM, &crgolf_state::main_map);
m_maincpu->set_vblank_int("screen", FUNC(crgolf_state::irq0_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80,MASTER_CLOCK/3/2)
MCFG_DEVICE_PROGRAM_MAP(sound_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", crgolf_state, irq0_line_hold)
Z80(config, m_audiocpu, MASTER_CLOCK/3/2);
m_audiocpu->set_addrmap(AS_PROGRAM, &crgolf_state::sound_map);
m_audiocpu->set_vblank_int("screen", FUNC(crgolf_state::irq0_line_hold));
MCFG_QUANTUM_TIME(attotime::from_hz(6000))
config.m_minimum_quantum = attotime::from_hz(6000);
ls259_device &mainlatch(LS259(config, "mainlatch")); // 1H
mainlatch.q_out_cb<3>().set(FUNC(crgolf_state::color_select_w));
@ -486,56 +486,52 @@ MACHINE_CONFIG_START(crgolf_state::crgolf)
mainlatch.q_out_cb<7>().set(FUNC(crgolf_state::screena_enable_w));
GENERIC_LATCH_8(config, "soundlatch1").data_pending_callback().set_inputline(m_audiocpu, INPUT_LINE_NMI);
GENERIC_LATCH_8(config, "soundlatch2").data_pending_callback().set_inputline(m_maincpu, INPUT_LINE_NMI);
/* stride is technically 0x6000, but powers of 2 makes the memory map / address masking cleaner. */
ADDRESS_MAP_BANK(config, "vrambank").set_map(&crgolf_state::vrambank_map).set_options(ENDIANNESS_LITTLE, 8, 16, 0x8000);
PALETTE(config, m_palette, FUNC(crgolf_state::crgolf_palette), 0x20);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(0, 255, 8, 247)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_UPDATE_DRIVER(crgolf_state, screen_update_crgolf)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_size(256, 256);
screen.set_visarea(0, 255, 8, 247);
screen.set_screen_update(FUNC(crgolf_state::screen_update_crgolf));
screen.set_palette(m_palette);
/* sound hardware */
SPEAKER(config, "mono").front_center();
AY8910(config, "aysnd", MASTER_CLOCK/3/2/2).add_route(ALL_OUTPUTS, "mono", 1.0);
MACHINE_CONFIG_END
}
MACHINE_CONFIG_START(crgolf_state::crgolfhi)
void crgolf_state::crgolfhi(machine_config &config)
{
crgolf(config);
MCFG_DEVICE_ADD("msm", MSM5205, 384000)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, crgolf_state, vck_callback))
MCFG_MSM5205_PRESCALER_SELECTOR(S64_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
MACHINE_CONFIG_END
MSM5205(config, m_msm, 384000);
m_msm->vck_legacy_callback().set(FUNC(crgolf_state::vck_callback));
m_msm->set_prescaler_selector(msm5205_device::S64_4B);
m_msm->add_route(ALL_OUTPUTS, "mono", 1.0);
}
MACHINE_CONFIG_START(crgolf_state::mastrglf)
void crgolf_state::mastrglf(machine_config &config)
{
crgolfhi(config);
/* basic machine hardware */
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(mastrglf_map)
MCFG_DEVICE_IO_MAP(mastrglf_io)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", crgolf_state, irq0_line_hold)
m_maincpu->set_addrmap(AS_PROGRAM, &crgolf_state::mastrglf_map);
m_maincpu->set_addrmap(AS_IO, &crgolf_state::mastrglf_io);
m_maincpu->set_vblank_int("screen", FUNC(crgolf_state::irq0_line_hold));
MCFG_DEVICE_MODIFY("audiocpu")
MCFG_DEVICE_PROGRAM_MAP(mastrglf_submap)
MCFG_DEVICE_IO_MAP(mastrglf_subio)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", crgolf_state, irq0_line_hold)
m_audiocpu->set_addrmap(AS_PROGRAM, &crgolf_state::mastrglf_submap);
m_audiocpu->set_addrmap(AS_IO, &crgolf_state::mastrglf_subio);
m_audiocpu->set_vblank_int("screen", FUNC(crgolf_state::irq0_line_hold));
PALETTE(config.replace(), m_palette, FUNC(crgolf_state::mastrglf_palette), 0x100);
MACHINE_CONFIG_END
}
/*************************************

65
src/mame/drivers/dacholer.cpp
View File

@ -667,27 +667,27 @@ void dacholer_state::dacholer_palette(palette_device &palette) const
}
/* note: clocks are taken from itaten sound reference recording */
MACHINE_CONFIG_START(dacholer_state::dacholer)
void dacholer_state::dacholer(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", Z80, XTAL(16'000'000)/4) /* ? */
MCFG_DEVICE_PROGRAM_MAP(main_map)
MCFG_DEVICE_IO_MAP(main_io_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", dacholer_state, irq0_line_assert)
Z80(config, m_maincpu, XTAL(16'000'000)/4); /* ? */
m_maincpu->set_addrmap(AS_PROGRAM, &dacholer_state::main_map);
m_maincpu->set_addrmap(AS_IO, &dacholer_state::main_io_map);
m_maincpu->set_vblank_int("screen", FUNC(dacholer_state::irq0_line_assert));
MCFG_DEVICE_ADD("audiocpu", Z80, XTAL(19'968'000)/8) /* ? */
MCFG_DEVICE_PROGRAM_MAP(snd_map)
MCFG_DEVICE_IO_MAP(snd_io_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", dacholer_state, sound_irq)
Z80(config, m_audiocpu, XTAL(19'968'000)/8); /* ? */
m_audiocpu->set_addrmap(AS_PROGRAM, &dacholer_state::snd_map);
m_audiocpu->set_addrmap(AS_IO, &dacholer_state::snd_io_map);
m_audiocpu->set_vblank_int("screen", FUNC(dacholer_state::sound_irq));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(0, 256-1, 16, 256-1-16)
MCFG_SCREEN_UPDATE_DRIVER(dacholer_state, screen_update_dacholer)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(256, 256);
screen.set_visarea(0, 256-1, 16, 256-1-16);
screen.set_screen_update(FUNC(dacholer_state::screen_update_dacholer));
screen.set_palette(m_palette);
PALETTE(config, m_palette, FUNC(dacholer_state::dacholer_palette), 32);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_dacholer);
@ -698,31 +698,28 @@ MACHINE_CONFIG_START(dacholer_state::dacholer)
GENERIC_LATCH_8(config, "soundlatch").data_pending_callback().set_inputline(m_audiocpu, INPUT_LINE_NMI);
AY8910(config, "ay1", XTAL(19'968'000)/16).add_route(ALL_OUTPUTS, "mono", 0.15);
AY8910(config, "ay2", XTAL(19'968'000)/16).add_route(ALL_OUTPUTS, "mono", 0.15);
AY8910(config, "ay3", XTAL(19'968'000)/16).add_route(ALL_OUTPUTS, "mono", 0.15);
MCFG_DEVICE_ADD("msm", MSM5205, XTAL(384'000))
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, dacholer_state, adpcm_int)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S96_4B) /* 1 / 96 = 3906.25Hz playback - guess */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.30)
MACHINE_CONFIG_END
MSM5205(config, m_msm, XTAL(384'000));
m_msm->vck_legacy_callback().set(FUNC(dacholer_state::adpcm_int)); /* interrupt function */
m_msm->set_prescaler_selector(msm5205_device::S96_4B); /* 1 / 96 = 3906.25Hz playback - guess */
m_msm->add_route(ALL_OUTPUTS, "mono", 0.30);
}
MACHINE_CONFIG_START(dacholer_state::itaten)
void dacholer_state::itaten(machine_config &config)
{
dacholer(config);
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(itaten_main_map)
m_maincpu->set_addrmap(AS_PROGRAM, &dacholer_state::itaten_main_map);
MCFG_DEVICE_MODIFY("audiocpu")
MCFG_DEVICE_PROGRAM_MAP(itaten_snd_map)
MCFG_DEVICE_IO_MAP(itaten_snd_io_map)
MCFG_DEVICE_VBLANK_INT_REMOVE()
m_audiocpu->set_addrmap(AS_PROGRAM, &dacholer_state::itaten_snd_map);
m_audiocpu->set_addrmap(AS_IO, &dacholer_state::itaten_snd_io_map);
m_audiocpu->set_vblank_int(device_interrupt_delegate(), nullptr);
MCFG_GFXDECODE_MODIFY("gfxdecode", gfx_itaten)
m_gfxdecode->set_info(gfx_itaten);
MCFG_DEVICE_REMOVE("msm")
MACHINE_CONFIG_END
config.device_remove("msm");
}
ROM_START( dacholer )
ROM_REGION( 0x10000, "maincpu", 0 )

119
src/mame/drivers/darius.cpp
View File

@ -703,26 +703,25 @@ void darius_state::machine_reset()
}
}
MACHINE_CONFIG_START(darius_state::darius)
void darius_state::darius(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, XTAL(16'000'000)/2) /* 8 MHz */
MCFG_DEVICE_PROGRAM_MAP(darius_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("lscreen", darius_state, irq4_line_hold)
M68000(config, m_maincpu, XTAL(16'000'000)/2); /* 8 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &darius_state::darius_map);
m_maincpu->set_vblank_int("lscreen", FUNC(darius_state::irq4_line_hold));
MCFG_DEVICE_ADD("audiocpu", Z80, XTAL(8'000'000)/2) /* 4 MHz */
MCFG_DEVICE_PROGRAM_MAP(darius_sound_map)
Z80(config, m_audiocpu, XTAL(8'000'000)/2); /* 4 MHz */
m_audiocpu->set_addrmap(AS_PROGRAM, &darius_state::darius_sound_map);
MCFG_DEVICE_ADD("cpub", M68000, XTAL(16'000'000)/2) /* 8 MHz */
MCFG_DEVICE_PROGRAM_MAP(darius_cpub_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("lscreen", darius_state, irq4_line_hold)
M68000(config, m_cpub, XTAL(16'000'000)/2); /* 8 MHz */
m_cpub->set_addrmap(AS_PROGRAM, &darius_state::darius_cpub_map);
m_cpub->set_vblank_int("lscreen", FUNC(darius_state::irq4_line_hold));
MCFG_DEVICE_ADD("adpcm", Z80, XTAL(8'000'000)/2) /* 4 MHz */ /* ADPCM player using MSM5205 */
MCFG_DEVICE_PROGRAM_MAP(darius_sound2_map)
MCFG_DEVICE_IO_MAP(darius_sound2_io_map)
Z80(config, m_adpcm, XTAL(8'000'000)/2); /* 4 MHz */ /* ADPCM player using MSM5205 */
m_adpcm->set_addrmap(AS_PROGRAM, &darius_state::darius_sound2_map);
m_adpcm->set_addrmap(AS_IO, &darius_state::darius_sound2_io_map);
MCFG_QUANTUM_TIME(attotime::from_hz(600)) /* 10 CPU slices per frame ? */
config.m_minimum_quantum = attotime::from_hz(600); /* 10 CPU slices per frame ? */
WATCHDOG_TIMER(config, "watchdog");
@ -731,29 +730,29 @@ MACHINE_CONFIG_START(darius_state::darius)
PALETTE(config, m_palette).set_format(palette_device::xBGR_555, 2048);
config.set_default_layout(layout_darius);
MCFG_SCREEN_ADD("lscreen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(36*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 36*8-1, 1*8, 29*8-1)
MCFG_SCREEN_UPDATE_DRIVER(darius_state, screen_update_darius_left)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &lscreen(SCREEN(config, "lscreen", SCREEN_TYPE_RASTER));
lscreen.set_refresh_hz(60);
lscreen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
lscreen.set_size(36*8, 32*8);
lscreen.set_visarea(0*8, 36*8-1, 1*8, 29*8-1);
lscreen.set_screen_update(FUNC(darius_state::screen_update_darius_left));
lscreen.set_palette(m_palette);
MCFG_SCREEN_ADD("mscreen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(36*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 36*8-1, 1*8, 29*8-1)
MCFG_SCREEN_UPDATE_DRIVER(darius_state, screen_update_darius_middle)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &mscreen(SCREEN(config, "mscreen", SCREEN_TYPE_RASTER));
mscreen.set_refresh_hz(60);
mscreen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
mscreen.set_size(36*8, 32*8);
mscreen.set_visarea(0*8, 36*8-1, 1*8, 29*8-1);
mscreen.set_screen_update(FUNC(darius_state::screen_update_darius_middle));
mscreen.set_palette(m_palette);
MCFG_SCREEN_ADD("rscreen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(36*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 36*8-1, 1*8, 29*8-1)
MCFG_SCREEN_UPDATE_DRIVER(darius_state, screen_update_darius_right)
MCFG_SCREEN_PALETTE(m_palette)
screen_device &rscreen(SCREEN(config, "rscreen", SCREEN_TYPE_RASTER));
rscreen.set_refresh_hz(60);
rscreen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
rscreen.set_size(36*8, 32*8);
rscreen.set_visarea(0*8, 36*8-1, 1*8, 29*8-1);
rscreen.set_screen_update(FUNC(darius_state::screen_update_darius_right));
rscreen.set_palette(m_palette);
PC080SN(config, m_pc080sn, 0);
m_pc080sn->set_gfx_region(1);
@ -791,37 +790,37 @@ MACHINE_CONFIG_START(darius_state::darius)
ym2.add_route(3, "filter1.3l", 0.60);
ym2.add_route(3, "filter1.3r", 0.60);
MCFG_DEVICE_ADD("msm", MSM5205, XTAL(384'000))
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, darius_state, darius_adpcm_int)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8KHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "msm5205.l", 1.0)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "msm5205.r", 1.0)
MSM5205(config, m_msm, XTAL(384'000));
m_msm->vck_legacy_callback().set(FUNC(darius_state::darius_adpcm_int)); /* interrupt function */
m_msm->set_prescaler_selector(msm5205_device::S48_4B); /* 8KHz */
m_msm->add_route(ALL_OUTPUTS, "msm5205.l", 1.0);
m_msm->add_route(ALL_OUTPUTS, "msm5205.r", 1.0);
FILTER_VOLUME(config, "filter0.0l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter0.0r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter0.1l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter0.1r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter0.2l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter0.2r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter0.3l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter0.3r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_0l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_0r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_1l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_1r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_2l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_2r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_3l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter0_3r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter1.0l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter1.0r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter1.1l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter1.1r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter1.2l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter1.2r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "filter1.3l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "filter1.3r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_0l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_0r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_1l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_1r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_2l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_2r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_3l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_filter1_3r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, "msm5205.l").add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, "msm5205.r").add_route(ALL_OUTPUTS, "rspeaker", 1.0);
FILTER_VOLUME(config, m_msm5205_l).add_route(ALL_OUTPUTS, "lspeaker", 1.0);
FILTER_VOLUME(config, m_msm5205_r).add_route(ALL_OUTPUTS, "rspeaker", 1.0);
pc060ha_device &ciu(PC060HA(config, "ciu", 0));
ciu.set_master_tag(m_maincpu);
ciu.set_slave_tag(m_audiocpu);
MACHINE_CONFIG_END
}
/***************************************************************************

166
src/mame/drivers/ddragon.cpp
View File

@ -941,20 +941,20 @@ GFXDECODE_END
*
*************************************/
MACHINE_CONFIG_START(ddragon_state::ddragon)
void ddragon_state::ddragon(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", HD6309E, MAIN_CLOCK / 4) /* HD63C09EP, 3 MHz */
MCFG_DEVICE_PROGRAM_MAP(ddragon_map)
MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", ddragon_state, ddragon_scanline, "screen", 0, 1)
HD6309E(config, m_maincpu, MAIN_CLOCK / 4); /* HD63C09EP, 3 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &ddragon_state::ddragon_map);
TIMER(config, "scantimer").configure_scanline(FUNC(ddragon_state::ddragon_scanline), "screen", 0, 1);
MCFG_DEVICE_ADD("sub", HD63701, MAIN_CLOCK / 2) /* HD63701YOP, 6 MHz / 4 internally */
MCFG_DEVICE_PROGRAM_MAP(sub_map)
HD63701(config, m_subcpu, MAIN_CLOCK / 2); /* HD63701YOP, 6 MHz / 4 internally */
m_subcpu->set_addrmap(AS_PROGRAM, &ddragon_state::sub_map);
MCFG_DEVICE_ADD("soundcpu", MC6809, MAIN_CLOCK / 2) /* HD68A09P, 6 MHz / 4 internally */
MCFG_DEVICE_PROGRAM_MAP(sound_map)
MC6809(config, m_soundcpu, MAIN_CLOCK / 2); /* HD68A09P, 6 MHz / 4 internally */
m_soundcpu->set_addrmap(AS_PROGRAM, &ddragon_state::sound_map);
MCFG_QUANTUM_TIME(attotime::from_hz(60000)) /* heavy interleaving to sync up sprite<->main CPUs */
config.m_minimum_quantum = attotime::from_hz(60000); /* heavy interleaving to sync up sprite<->main CPUs */
MCFG_MACHINE_START_OVERRIDE(ddragon_state,ddragon)
MCFG_MACHINE_RESET_OVERRIDE(ddragon_state,ddragon)
@ -963,10 +963,10 @@ MACHINE_CONFIG_START(ddragon_state::ddragon)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_ddragon);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 512);
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240)
MCFG_SCREEN_UPDATE_DRIVER(ddragon_state, screen_update_ddragon)
MCFG_SCREEN_PALETTE(m_palette)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240);
m_screen->set_screen_update(FUNC(ddragon_state::screen_update_ddragon));
m_screen->set_palette(m_palette);
MCFG_VIDEO_START_OVERRIDE(ddragon_state,ddragon)
@ -981,26 +981,25 @@ MACHINE_CONFIG_START(ddragon_state::ddragon)
fmsnd.add_route(0, "mono", 0.60);
fmsnd.add_route(1, "mono", 0.60);
MCFG_DEVICE_ADD("adpcm1", MSM5205, MAIN_CLOCK / 32)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, ddragon_state, dd_adpcm_int_1)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8kHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MSM5205(config, m_adpcm[0], MAIN_CLOCK / 32);
m_adpcm[0]->vck_legacy_callback().set(FUNC(ddragon_state::dd_adpcm_int_1)); /* interrupt function */
m_adpcm[0]->set_prescaler_selector(msm5205_device::S48_4B); /* 8kHz */
m_adpcm[0]->add_route(ALL_OUTPUTS, "mono", 0.50);
MCFG_DEVICE_ADD("adpcm2", MSM5205, MAIN_CLOCK / 32)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, ddragon_state, dd_adpcm_int_2)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8kHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MACHINE_CONFIG_END
MSM5205(config, m_adpcm[1], MAIN_CLOCK / 32);
m_adpcm[1]->vck_legacy_callback().set(FUNC(ddragon_state::dd_adpcm_int_2)); /* interrupt function */
m_adpcm[1]->set_prescaler_selector(msm5205_device::S48_4B); /* 8kHz */
m_adpcm[1]->add_route(ALL_OUTPUTS, "mono", 0.50);
}
MACHINE_CONFIG_START(ddragon_state::ddragonb)
void ddragon_state::ddragonb(machine_config &config)
{
ddragon(config);
/* basic machine hardware */
MCFG_DEVICE_REPLACE("sub", HD6309E, MAIN_CLOCK / 8) /* 1.5MHz; labeled "ENC EL1200AR" on one PCB */
MCFG_DEVICE_PROGRAM_MAP(sub_map)
MACHINE_CONFIG_END
HD6309E(config.replace(), m_subcpu, MAIN_CLOCK / 8); /* 1.5MHz; labeled "ENC EL1200AR" on one PCB */
m_subcpu->set_addrmap(AS_PROGRAM, &ddragon_state::sub_map);
}
void ddragon_state::ddragonba(machine_config &config)
{
@ -1013,20 +1012,20 @@ void ddragon_state::ddragonba(machine_config &config)
}
MACHINE_CONFIG_START(ddragon_state::ddragon6809)
void ddragon_state::ddragon6809(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", MC6809E, MAIN_CLOCK / 8) /* 1.5 MHz */
MCFG_DEVICE_PROGRAM_MAP(ddragon_map)
MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", ddragon_state, ddragon_scanline, "screen", 0, 1)
MC6809E(config, m_maincpu, MAIN_CLOCK / 8); /* 1.5 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &ddragon_state::ddragon_map);
TIMER(config, "scantimer").configure_scanline(FUNC(ddragon_state::ddragon_scanline), "screen", 0, 1);
MCFG_DEVICE_ADD("sub", MC6809E, MAIN_CLOCK / 8) /* 1.5 Mhz */
MCFG_DEVICE_PROGRAM_MAP(sub_map)
MC6809E(config, m_subcpu, MAIN_CLOCK / 8); /* 1.5 Mhz */
m_subcpu->set_addrmap(AS_PROGRAM, &ddragon_state::sub_map);
MCFG_DEVICE_ADD("soundcpu", MC6809E, MAIN_CLOCK / 8) /* 1.5 MHz */
MCFG_DEVICE_PROGRAM_MAP(sound_map)
MC6809E(config, m_soundcpu, MAIN_CLOCK / 8); /* 1.5 MHz */
m_soundcpu->set_addrmap(AS_PROGRAM, &ddragon_state::sound_map);
MCFG_QUANTUM_TIME(attotime::from_hz(60000)) /* heavy interleaving to sync up sprite<->main CPUs */
config.m_minimum_quantum = attotime::from_hz(60000); /* heavy interleaving to sync up sprite<->main CPUs */
MCFG_MACHINE_START_OVERRIDE(ddragon_state,ddragon)
MCFG_MACHINE_RESET_OVERRIDE(ddragon_state,ddragon)
@ -1035,10 +1034,10 @@ MACHINE_CONFIG_START(ddragon_state::ddragon6809)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_ddragon);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 512);
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240)
MCFG_SCREEN_UPDATE_DRIVER(ddragon_state, screen_update_ddragon)
MCFG_SCREEN_PALETTE(m_palette)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240);
m_screen->set_screen_update(FUNC(ddragon_state::screen_update_ddragon));
m_screen->set_palette(m_palette);
MCFG_VIDEO_START_OVERRIDE(ddragon_state,ddragon)
@ -1053,32 +1052,31 @@ MACHINE_CONFIG_START(ddragon_state::ddragon6809)
fmsnd.add_route(0, "mono", 0.60);
fmsnd.add_route(1, "mono", 0.60);
MCFG_DEVICE_ADD("adpcm1", MSM5205, MAIN_CLOCK/32)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, ddragon_state, dd_adpcm_int_1)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8kHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MSM5205(config, m_adpcm[0], MAIN_CLOCK/32);
m_adpcm[0]->vck_legacy_callback().set(FUNC(ddragon_state::dd_adpcm_int_1)); /* interrupt function */
m_adpcm[0]->set_prescaler_selector(msm5205_device::S48_4B); /* 8kHz */
m_adpcm[0]->add_route(ALL_OUTPUTS, "mono", 0.50);
MCFG_DEVICE_ADD("adpcm2", MSM5205, MAIN_CLOCK/32)
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, ddragon_state, dd_adpcm_int_2)) /* interrupt function */
MCFG_MSM5205_PRESCALER_SELECTOR(S48_4B) /* 8kHz */
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(ddragon_state::ddragon2)
MSM5205(config, m_adpcm[1], MAIN_CLOCK/32);
m_adpcm[1]->vck_legacy_callback().set(FUNC(ddragon_state::dd_adpcm_int_2)); /* interrupt function */
m_adpcm[1]->set_prescaler_selector(msm5205_device::S48_4B); /* 8kHz */
m_adpcm[1]->add_route(ALL_OUTPUTS, "mono", 0.50);
}
void ddragon_state::ddragon2(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", HD6309E, MAIN_CLOCK / 4) /* HD63C09EP, 3 MHz */
MCFG_DEVICE_PROGRAM_MAP(dd2_map)
MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", ddragon_state, ddragon_scanline, "screen", 0, 1)
HD6309E(config, m_maincpu, MAIN_CLOCK / 4); /* HD63C09EP, 3 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &ddragon_state::dd2_map);
TIMER(config, "scantimer").configure_scanline(FUNC(ddragon_state::ddragon_scanline), "screen", 0, 1);
MCFG_DEVICE_ADD("sub", Z80, MAIN_CLOCK / 3) /* 4 MHz */
MCFG_DEVICE_PROGRAM_MAP(dd2_sub_map)
Z80(config, m_subcpu, MAIN_CLOCK / 3); /* 4 MHz */
m_subcpu->set_addrmap(AS_PROGRAM, &ddragon_state::dd2_sub_map);
MCFG_DEVICE_ADD("soundcpu", Z80, 3579545)
MCFG_DEVICE_PROGRAM_MAP(dd2_sound_map)
Z80(config, m_soundcpu, 3579545);
m_soundcpu->set_addrmap(AS_PROGRAM, &ddragon_state::dd2_sound_map);
MCFG_QUANTUM_TIME(attotime::from_hz(60000)) /* heavy interleaving to sync up sprite<->main CPUs */
config.m_minimum_quantum = attotime::from_hz(60000); /* heavy interleaving to sync up sprite<->main CPUs */
MCFG_MACHINE_START_OVERRIDE(ddragon_state,ddragon)
MCFG_MACHINE_RESET_OVERRIDE(ddragon_state,ddragon)
@ -1087,10 +1085,10 @@ MACHINE_CONFIG_START(ddragon_state::ddragon2)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_ddragon);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 512);
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240)
MCFG_SCREEN_UPDATE_DRIVER(ddragon_state, screen_update_ddragon)
MCFG_SCREEN_PALETTE(m_palette)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(PIXEL_CLOCK, 384, 0, 256, 272, 0, 240);
m_screen->set_screen_update(FUNC(ddragon_state::screen_update_ddragon));
m_screen->set_palette(m_palette);
MCFG_VIDEO_START_OVERRIDE(ddragon_state,ddragon)
@ -1105,42 +1103,36 @@ MACHINE_CONFIG_START(ddragon_state::ddragon2)
fmsnd.add_route(0, "mono", 0.60);
fmsnd.add_route(1, "mono", 0.60);
MCFG_DEVICE_ADD("oki", OKIM6295, 1056000, okim6295_device::PIN7_HIGH) // clock frequency & pin 7 not verified
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20)
MACHINE_CONFIG_END
okim6295_device &oki(OKIM6295(config, "oki", 1056000, okim6295_device::PIN7_HIGH)); // clock frequency & pin 7 not verified
oki.add_route(ALL_OUTPUTS, "mono", 0.20);
}
MACHINE_CONFIG_START(darktowr_state::darktowr)
void darktowr_state::darktowr(machine_config &config)
{
ddragon(config);
/* basic machine hardware */
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(darktowr_map)
m_maincpu->set_addrmap(AS_PROGRAM, &darktowr_state::darktowr_map);
M68705P3(config, m_mcu, XTAL(4'000'000));
m_mcu->porta_w().set(FUNC(darktowr_state::mcu_port_a_w));
ADDRESS_MAP_BANK(config, "darktowr_bank").set_map(&darktowr_state::darktowr_banked_map).set_options(ENDIANNESS_BIG, 8, 17, 0x4000);
}
/* video hardware */
MACHINE_CONFIG_END
MACHINE_CONFIG_START(toffy_state::toffy)
void toffy_state::toffy(machine_config &config)
{
ddragon(config);
/* basic machine hardware */
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(toffy_map)
m_maincpu->set_addrmap(AS_PROGRAM, &toffy_state::toffy_map);
MCFG_DEVICE_REMOVE("sub")
config.device_remove("sub");
/* sound hardware */
MCFG_DEVICE_REMOVE("adpcm1")
MCFG_DEVICE_REMOVE("adpcm2")
MACHINE_CONFIG_END
config.device_remove("adpcm1");
config.device_remove("adpcm2");
}
/*************************************
*

17
src/mame/drivers/de_2.cpp
View File

@ -528,10 +528,11 @@ WRITE8_MEMBER(de_2_state::lamps_w)
}
MACHINE_CONFIG_START(de_2_state::de_bg_audio)
void de_2_state::de_bg_audio(machine_config &config)
{
/* sound CPU */
MCFG_DEVICE_ADD("audiocpu", MC6809E, XTAL(8'000'000) / 4) // MC68B09E
MCFG_DEVICE_PROGRAM_MAP(de_2_audio_map)
MC6809E(config, m_audiocpu, XTAL(8'000'000) / 4); // MC68B09E
m_audiocpu->set_addrmap(AS_PROGRAM, &de_2_state::de_2_audio_map);
SPEAKER(config, "bg").front_center();
@ -539,11 +540,11 @@ MACHINE_CONFIG_START(de_2_state::de_bg_audio)
m_ym2151->irq_handler().set(FUNC(de_2_state::ym2151_irq_w));
m_ym2151->add_route(ALL_OUTPUTS, "bg", 0.50);
MCFG_DEVICE_ADD("msm5205", MSM5205, XTAL(384'000))
MCFG_MSM5205_VCLK_CB(WRITELINE(*this, de_2_state, msm5205_irq_w))
MCFG_MSM5205_PRESCALER_SELECTOR(S96_4B)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "bg", 0.50)
MACHINE_CONFIG_END
MSM5205(config, m_msm5205, XTAL(384'000));
m_msm5205->vck_legacy_callback().set(FUNC(de_2_state::msm5205_irq_w));
m_msm5205->set_prescaler_selector(msm5205_device::S96_4B);
m_msm5205->add_route(ALL_OUTPUTS, "bg", 0.50);
}
void de_2_state::de_type1(machine_config &config)
{

1
src/mame/includes/ashnojoe.h
View File

@ -56,7 +56,6 @@ public:
/* sound-related */
uint8_t m_adpcm_byte;
int m_msm5205_vclk_toggle;
/* devices */
required_device<cpu_device> m_maincpu;

2
src/mame/includes/battlera.h
View File

@ -32,7 +32,6 @@ public:
int m_control_port_select;
int m_msm5205next;
int m_toggle;
DECLARE_WRITE8_MEMBER(control_data_w);
DECLARE_READ8_MEMBER(control_data_r);
@ -41,6 +40,7 @@ public:
DECLARE_WRITE_LINE_MEMBER(adpcm_int);
virtual void machine_start() override;
virtual void machine_reset() override;
uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void battlera(machine_config &config);