Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-02 16:49:22 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

-arcadia, binbug, cd2650, cvs, dm7000, dolphunk, galaxia, hp48, instruct, konamim2, laserbat, phunsy, pipbug, quasar,

Browse Source 
quizshow, ravens, subhuntr, taitopjc, tx0, vc4000, zac_1, zac_2: Removed MACHINE_CONFIG. [Ryan Holtz]

-bus/arcadia/slot, bus/vc4000/slot, tx0, ppc, s2650, saturn: Removed MCFG macros. [Ryan Holtz]
This commit is contained in:
mooglyguy 2018-12-15 10:39:01 +01:00
parent f41b6e8d81
commit b865623fdf
46 changed files with 802 additions and 869 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/devices/bus/arcadia/slot.h
View File

@ -5,12 +5,12 @@
#include "softlist_dev.h"
#define EA2001SLOT_ROM_REGION_TAG ":cart:rom"
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
/* PCB */
enum
{
@ -18,7 +18,6 @@ enum
ARCADIA_GOLF
};
// ======================> device_arcadia_cart_interface
class device_arcadia_cart_interface : public device_slot_card_interface
@ -51,6 +50,15 @@ class arcadia_cart_slot_device : public device_t,
{
public:
// construction/destruction
template <typename T>
arcadia_cart_slot_device(machine_config const &mconfig, char const *tag, device_t *owner, T &&opts, char const *dflt)
: arcadia_cart_slot_device(mconfig, tag, owner, (uint32_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(false);
}
arcadia_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~arcadia_cart_slot_device();
@ -85,20 +93,6 @@ protected:
device_arcadia_cart_interface* m_cart;
};
// device type definition
DECLARE_DEVICE_TYPE(EA2001_CART_SLOT, arcadia_cart_slot_device)
/***************************************************************************
DEVICE CONFIGURATION MACROS
***************************************************************************/
#define EA2001SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_ARCADIA_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, EA2001_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)
#endif // MAME_BUS_ARCADIA_SLOT_H

38
src/devices/bus/vc4000/slot.h
View File

@ -6,10 +6,7 @@
#include "softlist_dev.h"
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
#define VC4000SLOT_ROM_REGION_TAG ":cart:rom"
/* PCB */
enum
@ -62,6 +59,15 @@ class vc4000_cart_slot_device : public device_t,
{
public:
// construction/destruction
template <typename T>
vc4000_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, T &&opts, char const *dflt)
: vc4000_cart_slot_device(mconfig, tag, owner, (uint32_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(false);
}
vc4000_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~vc4000_cart_slot_device();
@ -111,6 +117,15 @@ class h21_cart_slot_device : public vc4000_cart_slot_device
{
public:
// construction/destruction
template <typename T>
h21_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, T &&opts, char const *dflt)
: h21_cart_slot_device(mconfig, tag, owner, (uint32_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(false);
}
h21_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~h21_cart_slot_device();
@ -121,19 +136,4 @@ public:
DECLARE_DEVICE_TYPE(VC4000_CART_SLOT, vc4000_cart_slot_device)
DECLARE_DEVICE_TYPE(H21_CART_SLOT, h21_cart_slot_device)
/***************************************************************************
DEVICE CONFIGURATION MACROS
***************************************************************************/
#define VC4000SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_VC4000_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, VC4000_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)
#define MCFG_H21_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, H21_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)
#endif // MAME_BUS_VC4000_SLOT_H

33
src/devices/cpu/pdp1/tx0.h
View File

@ -21,33 +21,20 @@ enum
};
#define MCFG_TX0_CONFIG(_cpy_devcb, _r1l_devcb, _dis_devcb, _r3l_devcb, _prt_devcb, _rsv_devcb, _p6h_devcb, _p7h_devcb, _sel_devcb, _res_devcb) \
downcast<tx0_device &>(*device).set_cpy_cb(DEVCB_##_cpy_devcb); \
downcast<tx0_device &>(*device).set_r1l_cb(DEVCB_##_r1l_devcb); \
downcast<tx0_device &>(*device).set_dis_cb(DEVCB_##_dis_devcb); \
downcast<tx0_device &>(*device).set_r3l_cb(DEVCB_##_r3l_devcb); \
downcast<tx0_device &>(*device).set_prt_cb(DEVCB_##_prt_devcb); \
downcast<tx0_device &>(*device).set_rsv_cb(DEVCB_##_rsv_devcb); \
downcast<tx0_device &>(*device).set_p6h_cb(DEVCB_##_p6h_devcb); \
downcast<tx0_device &>(*device).set_p7h_cb(DEVCB_##_p7h_devcb); \
downcast<tx0_device &>(*device).set_sel_cb(DEVCB_##_sel_devcb); \
downcast<tx0_device &>(*device).set_res_cb(DEVCB_##_res_devcb);
class tx0_device : public cpu_device
{
public:
// configuration helpers
template <class Object> devcb_base &set_cpy_cb(Object &&cb) { return m_cpy_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_r1l_cb(Object &&cb) { return m_r1l_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_dis_cb(Object &&cb) { return m_dis_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_r3l_cb(Object &&cb) { return m_r3l_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_prt_cb(Object &&cb) { return m_prt_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_rsv_cb(Object &&cb) { return m_rsv_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_p6h_cb(Object &&cb) { return m_p6h_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_p7h_cb(Object &&cb) { return m_p7h_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_sel_cb(Object &&cb) { return m_sel_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_res_cb(Object &&cb) { return m_io_reset_callback.set_callback(std::forward<Object>(cb)); }
auto cpy() { return m_cpy_handler.bind(); }
auto r1l() { return m_r1l_handler.bind(); }
auto dis() { return m_dis_handler.bind(); }
auto r3l() { return m_r3l_handler.bind(); }
auto prt() { return m_prt_handler.bind(); }
auto rsv() { return m_rsv_handler.bind(); }
auto p6h() { return m_p6h_handler.bind(); }
auto p7h() { return m_p7h_handler.bind(); }
auto sel() { return m_sel_handler.bind(); }
auto res() { return m_io_reset_callback.bind(); }
void pulse_reset();
void io_complete();

4
src/devices/cpu/powerpc/ppc.h
View File

@ -164,10 +164,6 @@ enum
PUBLIC FUNCTIONS
***************************************************************************/
#define MCFG_PPC_BUS_FREQUENCY(_frequency) \
downcast<ppc_device &>(*device).set_bus_frequency(_frequency);
class ppc_device : public cpu_device, public device_vtlb_interface
{
protected:

11
src/devices/cpu/s2650/s2650.h
View File

@ -23,19 +23,8 @@ enum
S2650_DATA_PORT = 1
};
DECLARE_DEVICE_TYPE(S2650, s2650_device)
#define MCFG_S2650_SENSE_INPUT(_devcb) \
downcast<s2650_device &>(*device).set_sense_handler(DEVCB_##_devcb);
#define MCFG_S2650_FLAG_OUTPUT(_devcb) \
downcast<s2650_device &>(*device).set_flag_handler(DEVCB_##_devcb);
#define MCFG_S2650_INTACK_HANDLER(_devcb) \
downcast<s2650_device &>(*device).set_intack_handler(DEVCB_##_devcb);
class s2650_device : public cpu_device, public s2650_disassembler::config
{
public:

27
src/devices/cpu/saturn/saturn.h
View File

@ -62,17 +62,6 @@ enum
#define SATURN_WAKEUP_LINE 2
#define MCFG_SATURN_CONFIG(_out, _in, _reset, _config, _unconfig, _id, _crc, _rsi) \
downcast<saturn_device &>(*device).set_out_func(DEVCB_##_out); \
downcast<saturn_device &>(*device).set_in_func(DEVCB_##_in); \
downcast<saturn_device &>(*device).set_reset_func(DEVCB_##_reset); \
downcast<saturn_device &>(*device).set_config_func(DEVCB_##_config); \
downcast<saturn_device &>(*device).set_unconfig_func(DEVCB_##_unconfig); \
downcast<saturn_device &>(*device).set_id_func(DEVCB_##_id); \
downcast<saturn_device &>(*device).set_crc_func(DEVCB_##_crc); \
downcast<saturn_device &>(*device).set_rsi_func(DEVCB_##_rsi);
class saturn_device : public cpu_device, public saturn_disassembler::config
{
public:
@ -80,14 +69,14 @@ public:
saturn_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// configuration helpers
template <class Object> devcb_base &set_out_func(Object &&cb) { return m_out_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_func(Object &&cb) { return m_in_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_reset_func(Object &&cb) { return m_reset_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_config_func(Object &&cb) { return m_config_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_unconfig_func(Object &&cb) { return m_unconfig_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_id_func(Object &&cb) { return m_id_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_crc_func(Object &&cb) { return m_crc_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_rsi_func(Object &&cb) { return m_rsi_func.set_callback(std::forward<Object>(cb)); }
auto out_func() { return m_out_func.bind(); }
auto in_func() { return m_in_func.bind(); }
auto reset_func() { return m_reset_func.bind(); }
auto config_func() { return m_config_func.bind(); }
auto unconfig_func() { return m_unconfig_func.bind(); }
auto id_func() { return m_id_func.bind(); }
auto crc_func() { return m_crc_func.bind(); }
auto rsi_func() { return m_rsi_func.bind(); }
protected:
// device-level overrides

9
src/devices/cpu/scmp/scmp.h
View File

@ -6,15 +6,6 @@
#pragma once
#define MCFG_SCMP_CONFIG(_flag_out_devcb, _sout_devcb, _sin_devcb, _sensea_devcb, _senseb_devcb, _halt_devcb) \
downcast<scmp_device &>(*device).set_flag_out_cb(DEVCB_##_flag_out_devcb); \
downcast<scmp_device &>(*device).set_sout_cb(DEVCB_##_sout_devcb); \
downcast<scmp_device &>(*device).set_sin_cb(DEVCB_##_sin_devcb); \
downcast<scmp_device &>(*device).set_sensea_cb( DEVCB_##_sensea_devcb); \
downcast<scmp_device &>(*device).set_senseb_cb(DEVCB_##_senseb_devcb); \
downcast<scmp_device &>(*device).set_halt_cb(DEVCB_##_halt_devcb);
class scmp_device : public cpu_device
{
public:

2
src/devices/video/dm9368.h
View File

@ -47,6 +47,8 @@ class dm9368_device : public device_t
public:
template <typename Obj> devcb_base &set_update_callback(Obj &&cb) { return m_update_cb.set_callback(std::forward<Obj>(cb)); }
template <typename Obj> devcb_base &set_rbo_callback(Obj &&cb) { return m_rbo_cb.set_callback(std::forward<Obj>(cb)); }
auto update_cb() { return m_update_cb.bind(); }
auto rbo_cb() { return m_rbo_cb.bind(); }
// construction/destruction
dm9368_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);

12
src/emu/drivers/testcpu.cpp
View File

@ -190,13 +190,13 @@ void testcpu_state::ppc_mem(address_map &map)
// MACHINE DRIVERS
//**************************************************************************
MACHINE_CONFIG_START(testcpu_state::testcpu)
void testcpu_state::testcpu(machine_config &config)
{
// CPUs
MCFG_DEVICE_ADD("maincpu", PPC603E, 66000000)
MCFG_PPC_BUS_FREQUENCY(66000000) // Multiplier 1, Bus = 66MHz, Core = 66MHz
MCFG_DEVICE_PROGRAM_MAP(ppc_mem)
MACHINE_CONFIG_END
PPC603E(config, m_cpu, 66000000);
m_cpu->set_bus_frequency(66000000); // Multiplier 1, Bus = 66MHz, Core = 66MHz
m_cpu->set_addrmap(AS_PROGRAM, &testcpu_state::ppc_mem);
}

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

@ -471,39 +471,41 @@ static void arcadia_cart(device_slot_interface &device)
}
MACHINE_CONFIG_START(arcadia_state::arcadia)
void arcadia_state::arcadia(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 3580000/4) /* 0.895 MHz */
MCFG_DEVICE_PROGRAM_MAP(arcadia_mem)
MCFG_S2650_SENSE_INPUT(READLINE(*this, arcadia_state, vsync_r))
MCFG_DEVICE_PERIODIC_INT_DRIVER(arcadia_state, video_line, 262*60)
MCFG_QUANTUM_TIME(attotime::from_hz(60))
S2650(config, m_maincpu, 3580000/4); /* 0.895 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &arcadia_state::arcadia_mem);
m_maincpu->sense_handler().set(FUNC(arcadia_state::vsync_r));
m_maincpu->set_periodic_int(FUNC(arcadia_state::video_line), attotime::from_hz(262*60));
config.m_minimum_quantum = attotime::from_hz(60);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(128+2*XPOS, 262)
MCFG_SCREEN_VISIBLE_AREA(0, 2*XPOS+128-1, 0, 262-1)
MCFG_SCREEN_UPDATE_DRIVER(arcadia_state, screen_update_arcadia)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(0));
m_screen->set_size(128+2*XPOS, 262);
m_screen->set_visarea(0, 2*XPOS+128-1, 0, 262-1);
m_screen->set_screen_update(FUNC(arcadia_state::screen_update_arcadia));
m_screen->set_palette(m_palette);
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_arcadia)
MCFG_PALETTE_ADD("palette", ARRAY_LENGTH(arcadia_palette))
MCFG_PALETTE_INDIRECT_ENTRIES(8)
MCFG_PALETTE_INIT_OWNER(arcadia_state, arcadia)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_arcadia);
PALETTE(config, m_palette, ARRAY_LENGTH(arcadia_palette));
m_palette->set_indirect_entries(8);
m_palette->set_init(FUNC(arcadia_state::palette_init_arcadia));
/* sound hardware */
SPEAKER(config, "mono").front_center();
MCFG_DEVICE_ADD("custom", ARCADIA_SOUND)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
ARCADIA_SOUND(config, m_custom);
m_custom->add_route(ALL_OUTPUTS, "mono", 1.00);
/* cartridge */
MCFG_ARCADIA_CARTRIDGE_ADD("cartslot", arcadia_cart, nullptr)
EA2001_CART_SLOT(config, "cartslot", arcadia_cart, nullptr);
/* Software lists */
MCFG_SOFTWARE_LIST_ADD("cart_list","arcadia")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_original("arcadia");
}
ROM_START(advsnha)

87
src/mame/drivers/binbug.cpp
View File

@ -89,6 +89,7 @@ public:
required_device<cpu_device> m_maincpu; // S2650 or Z80
required_device<cassette_image_device> m_cass;
void binbug_base(machine_config &config);
void binbug(machine_config &config);
void binbug_data(address_map &map);
void binbug_mem(address_map &map);
@ -299,37 +300,45 @@ static DEVICE_INPUT_DEFAULTS_START( keyboard )
DEVICE_INPUT_DEFAULTS( "RS232_STOPBITS", 0xff, RS232_STOPBITS_1 )
DEVICE_INPUT_DEFAULTS_END
MACHINE_CONFIG_START(binbug_state::binbug)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(1'000'000))
MCFG_DEVICE_PROGRAM_MAP(binbug_mem)
MCFG_DEVICE_DATA_MAP(binbug_data)
MCFG_S2650_SENSE_INPUT(READLINE(*this, binbug_state, binbug_serial_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, binbug_state, binbug_serial_w))
void binbug_state::binbug_base(machine_config &config)
{
/* video hardware */
MCFG_SCREEN_ADD_MONOCHROME("screen", RASTER, rgb_t::amber())
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
MCFG_SCREEN_UPDATE_DRIVER(binbug_state, screen_update)
MCFG_SCREEN_SIZE(512, 256)
MCFG_SCREEN_VISIBLE_AREA(0, 511, 0, 255)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_color(rgb_t::amber());
screen.set_refresh_hz(50);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_screen_update(FUNC(binbug_state::screen_update));
screen.set_size(512, 256);
screen.set_visarea(0, 511, 0, 255);
screen.set_palette("palette");
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_dg640)
MCFG_PALETTE_ADD_MONOCHROME("palette")
GFXDECODE(config, "gfxdecode", "palette", gfx_dg640);
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
/* Cassette */
CASSETTE(config, m_cass);
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
}
void binbug_state::binbug(machine_config &config)
{
binbug_base(config);
/* basic machine hardware */
s2650_device &maincpu(S2650(config, m_maincpu, XTAL(1'000'000)));
maincpu.set_addrmap(AS_PROGRAM, &binbug_state::binbug_mem);
maincpu.set_addrmap(AS_DATA, &binbug_state::binbug_data);
maincpu.sense_handler().set(FUNC(binbug_state::binbug_serial_r));
maincpu.flag_handler().set(FUNC(binbug_state::binbug_serial_w));
/* Keyboard */
RS232_PORT(config, m_rs232, default_rs232_devices, "keyboard").set_option_device_input_defaults("keyboard", DEVICE_INPUT_DEFAULTS_NAME(keyboard));
/* Cassette */
MCFG_CASSETTE_ADD( "cassette" )
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", binbug_state, binbug, "pgm", 1)
MACHINE_CONFIG_END
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(binbug_state, binbug), this), "pgm", 1);
}
/* ROM definition */
@ -429,6 +438,7 @@ public:
void dg680(machine_config &config);
void dg680_io(address_map &map);
void dg680_mem(address_map &map);
private:
uint8_t m_pio_b;
uint8_t m_term_data;
@ -534,34 +544,20 @@ TIMER_DEVICE_CALLBACK_MEMBER(dg680_state::uart_tick)
m_ctc->trg3(0);
}
MACHINE_CONFIG_START(dg680_state::dg680)
void dg680_state::dg680(machine_config &config)
{
binbug_base(config);
/* basic machine hardware */
z80_device& maincpu(Z80(config, m_maincpu, XTAL(8'000'000) / 4));
maincpu.set_addrmap(AS_PROGRAM, &dg680_state::dg680_mem);
maincpu.set_addrmap(AS_IO, &dg680_state::dg680_io);
maincpu.set_daisy_config(dg680_daisy_chain);
/* video hardware */
MCFG_SCREEN_ADD_MONOCHROME("screen", RASTER, rgb_t::amber())
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
MCFG_SCREEN_UPDATE_DRIVER(binbug_state, screen_update)
MCFG_SCREEN_SIZE(512, 256)
MCFG_SCREEN_VISIBLE_AREA(0, 511, 0, 255)
MCFG_SCREEN_PALETTE("palette")
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_dg640)
MCFG_PALETTE_ADD_MONOCHROME("palette")
/* Keyboard */
generic_keyboard_device &keyb(GENERIC_KEYBOARD(config, "keyb", 0));
keyb.set_keyboard_callback(FUNC(dg680_state::kbd_put));
/* Cassette */
MCFG_CASSETTE_ADD( "cassette" )
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
/* Devices */
z80ctc_device& ctc(Z80CTC(config, "z80ctc", XTAL(8'000'000) / 4));
ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
@ -574,10 +570,9 @@ MACHINE_CONFIG_START(dg680_state::dg680)
pio.in_pb_callback().set(FUNC(dg680_state::portb_r));
pio.out_pb_callback().set(FUNC(dg680_state::portb_w));
MCFG_TIMER_DRIVER_ADD_PERIODIC("ctc0", dg680_state, time_tick, attotime::from_hz(200))
MCFG_TIMER_DRIVER_ADD_PERIODIC("ctc3", dg680_state, uart_tick, attotime::from_hz(4800))
MACHINE_CONFIG_END
TIMER(config, "ctc0").configure_periodic(FUNC(dg680_state::time_tick), attotime::from_hz(200));
TIMER(config, "ctc3").configure_periodic(FUNC(dg680_state::uart_tick), attotime::from_hz(4800));
}
/* ROM definition */
ROM_START( dg680 )

38
src/mame/drivers/cd2650.cpp
View File

@ -88,7 +88,7 @@ public:
private:
uint8_t m_term_data;
virtual void machine_reset() override;
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_shared_ptr<uint8_t> m_p_videoram;
required_region_ptr<u8> m_p_chargen;
required_device<cassette_image_device> m_cass;
@ -286,14 +286,15 @@ QUICKLOAD_LOAD_MEMBER( cd2650_state, cd2650 )
return result;
}
MACHINE_CONFIG_START(cd2650_state::cd2650)
void cd2650_state::cd2650(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, XTAL(14'192'640) / 12) // 1.182720MHz according to RE schematic
MCFG_DEVICE_PROGRAM_MAP(cd2650_mem)
MCFG_DEVICE_IO_MAP(cd2650_io)
MCFG_DEVICE_DATA_MAP(cd2650_data)
MCFG_S2650_SENSE_INPUT(READLINE(*this, cd2650_state, cass_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, cd2650_state, cass_w))
S2650(config, m_maincpu, XTAL(14'192'640) / 12); // 1.182720MHz according to RE schematic
m_maincpu->set_addrmap(AS_PROGRAM, &cd2650_state::cd2650_mem);
m_maincpu->set_addrmap(AS_IO, &cd2650_state::cd2650_io);
m_maincpu->set_addrmap(AS_DATA, &cd2650_state::cd2650_data);
m_maincpu->sense_handler().set(FUNC(cd2650_state::cass_r));
m_maincpu->flag_handler().set(FUNC(cd2650_state::cass_w));
f9334_device &outlatch(F9334(config, "outlatch")); // IC26
outlatch.q_out_cb<0>().set(FUNC(cd2650_state::tape_deck_on_w)); // TD ON
@ -304,27 +305,28 @@ MACHINE_CONFIG_START(cd2650_state::cd2650)
// "Morse Code" program by Mike Durham.
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(XTAL(14'192'640), 112 * CHARACTER_WIDTH, 0, 80 * CHARACTER_WIDTH, 22 * CHARACTER_LINES, 0, 16 * CHARACTER_LINES)
MCFG_SCREEN_UPDATE_DRIVER(cd2650_state, screen_update)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_raw(XTAL(14'192'640), 112 * CHARACTER_WIDTH, 0, 80 * CHARACTER_WIDTH, 22 * CHARACTER_LINES, 0, 16 * CHARACTER_LINES);
screen.set_screen_update(FUNC(cd2650_state::screen_update));
screen.set_palette("palette");
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_cd2650)
MCFG_PALETTE_ADD_MONOCHROME("palette")
GFXDECODE(config, "gfxdecode", "palette", gfx_cd2650);
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", cd2650_state, cd2650, "pgm", 1)
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(cd2650_state, cd2650), this), "pgm", 1);
/* Sound */
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.25);
BEEP(config, "beeper", 950).add_route(ALL_OUTPUTS, "mono", 0.50); // guess
/* Devices */
generic_keyboard_device &keyboard(GENERIC_KEYBOARD(config, "keyboard", 0));
keyboard.set_keyboard_callback(FUNC(cd2650_state::kbd_put));
MCFG_CASSETTE_ADD( "cassette" )
MACHINE_CONFIG_END
CASSETTE(config, m_cass);
}
/* ROM definition */
ROM_START( cd2650 )

21
src/mame/drivers/cobra.cpp
View File

@ -3283,20 +3283,19 @@ void cobra_state::machine_reset()
MACHINE_CONFIG_START(cobra_state::cobra)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", PPC603, 100000000) /* 603EV, 100? MHz */
MCFG_PPC_BUS_FREQUENCY(XTAL(66'666'700)) /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
MCFG_DEVICE_PROGRAM_MAP(cobra_main_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", cobra_state, cobra_vblank)
PPC603(config, m_maincpu, 100000000); /* 603EV, 100? MHz */
m_maincpu->set_bus_frequency(XTAL(66'666'700)); /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &cobra_state::cobra_main_map);
m_maincpu->set_vblank_int("screen", FUNC(cobra_state::cobra_vblank));
MCFG_DEVICE_ADD("subcpu", PPC403GA, 32000000) /* 403GA, 33? MHz */
MCFG_DEVICE_PROGRAM_MAP(cobra_sub_map)
PPC403GA(config, m_subcpu, 32000000); /* 403GA, 33? MHz */
m_subcpu->set_addrmap(AS_PROGRAM, &cobra_state::cobra_sub_map);
MCFG_DEVICE_ADD("gfxcpu", PPC604, 100000000) /* 604, 100? MHz */
MCFG_PPC_BUS_FREQUENCY(XTAL(66'666'700)) /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
MCFG_DEVICE_PROGRAM_MAP(cobra_gfx_map)
MCFG_QUANTUM_TIME(attotime::from_hz(15005))
PPC604(config, m_gfxcpu, 100000000); /* 604, 100? MHz */
m_gfxcpu->set_bus_frequency(XTAL(66'666'700)); /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
m_gfxcpu->set_addrmap(AS_PROGRAM, &cobra_state::cobra_gfx_map);
config.m_minimum_quantum = attotime::from_hz(15005);
MCFG_PCI_BUS_LEGACY_ADD(m_legacy_pci, 0)
MCFG_PCI_BUS_LEGACY_DEVICE(0, DEVICE_SELF, cobra_state, mpc106_pci_r, mpc106_pci_w)

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

@ -97,7 +97,6 @@ Todo & FIXME:
#include "emu.h"
#include "includes/cvs.h"
#include "cpu/s2650/s2650.h"
#include "sound/volt_reg.h"
#include "speaker.h"
@ -964,46 +963,45 @@ void cvs_state::machine_reset()
m_stars_scroll = 0;
}
MACHINE_CONFIG_START(cvs_state::cvs)
void cvs_state::cvs(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, XTAL(14'318'181)/16)
MCFG_DEVICE_PROGRAM_MAP(cvs_main_cpu_map)
MCFG_DEVICE_IO_MAP(cvs_main_cpu_io_map)
MCFG_DEVICE_DATA_MAP(cvs_main_cpu_data_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", cvs_state, cvs_main_cpu_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, cvs_state, write_s2650_flag))
S2650(config, m_maincpu, XTAL(14'318'181)/16);
m_maincpu->set_addrmap(AS_PROGRAM, &cvs_state::cvs_main_cpu_map);
m_maincpu->set_addrmap(AS_IO, &cvs_state::cvs_main_cpu_io_map);
m_maincpu->set_addrmap(AS_DATA, &cvs_state::cvs_main_cpu_data_map);
m_maincpu->set_vblank_int("screen", FUNC(cvs_state::cvs_main_cpu_interrupt));
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
m_maincpu->flag_handler().set(FUNC(cvs_state::write_s2650_flag));
MCFG_DEVICE_ADD("audiocpu", S2650, XTAL(14'318'181)/16)
MCFG_DEVICE_PROGRAM_MAP(cvs_dac_cpu_map)
S2650(config, m_audiocpu, XTAL(14'318'181)/16);
m_audiocpu->set_addrmap(AS_PROGRAM, &cvs_state::cvs_dac_cpu_map);
/* doesn't look like it is used at all */
//MCFG_S2650_SENSE_INPUT(READLINE(*this, cvs_state, cvs_393hz_clock_r))
MCFG_DEVICE_ADD("speechcpu", S2650, XTAL(14'318'181)/16)
MCFG_DEVICE_PROGRAM_MAP(cvs_speech_cpu_map)
S2650(config, m_speechcpu, XTAL(14'318'181)/16);
m_speechcpu->set_addrmap(AS_PROGRAM, &cvs_state::cvs_speech_cpu_map);
/* romclk is much more probable, 393 Hz results in timing issues */
//MCFG_S2650_SENSE_INPUT(READLINE(*this, cvs_state, cvs_393hz_clock_r))
MCFG_S2650_SENSE_INPUT(READLINE("tms", tms5110_device, romclk_hack_r))
m_speechcpu->sense_handler().set("tms", FUNC(tms5110_device::romclk_hack_r));
/* video hardware */
MCFG_VIDEO_START_OVERRIDE(cvs_state,cvs)
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_cvs)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_cvs);
MCFG_PALETTE_ADD("palette", (256+4)*8+8+1)
MCFG_PALETTE_INDIRECT_ENTRIES(16)
MCFG_PALETTE_INIT_OWNER(cvs_state,cvs)
PALETTE(config, m_palette, (256+4)*8+8+1);
m_palette->set_indirect_entries(16);
m_palette->set_init(FUNC(cvs_state::palette_init_cvs));
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_ALWAYS_UPDATE)
MCFG_SCREEN_SIZE(32*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 30*8-1, 1*8, 32*8-1)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(1000))
MCFG_SCREEN_UPDATE_DRIVER(cvs_state, screen_update_cvs)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_video_attributes(VIDEO_ALWAYS_UPDATE);
m_screen->set_size(32*8, 32*8);
m_screen->set_visarea(0*8, 30*8-1, 1*8, 32*8-1);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(1000));
m_screen->set_screen_update(FUNC(cvs_state::screen_update_cvs));
m_screen->set_palette(m_palette);
S2636(config, m_s2636[0], 0);
m_s2636[0]->set_offsets(CVS_S2636_Y_OFFSET, CVS_S2636_X_OFFSET);
@ -1019,18 +1017,21 @@ MACHINE_CONFIG_START(cvs_state::cvs)
GENERIC_LATCH_8(config, m_soundlatch);
MCFG_DEVICE_ADD("dac1", DAC_8BIT_R2R, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 0.5) // unknown DAC
MCFG_DEVICE_ADD("dac2", DAC_4BIT_R2R, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 0.5) // unknown DAC
MCFG_DEVICE_ADD("dac3", DAC_1BIT, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 0.99)
MCFG_DEVICE_ADD("vref", VOLTAGE_REGULATOR, 0) MCFG_VOLTAGE_REGULATOR_OUTPUT(5.0)
MCFG_SOUND_ROUTE(0, "dac1", 1.0, DAC_VREF_POS_INPUT) MCFG_SOUND_ROUTE(0, "dac1", -1.0, DAC_VREF_NEG_INPUT)
MCFG_SOUND_ROUTE(0, "dac2", 1.0, DAC_VREF_POS_INPUT) MCFG_SOUND_ROUTE(0, "dac2", -1.0, DAC_VREF_NEG_INPUT)
MCFG_SOUND_ROUTE(0, "dac3", 1.0, DAC_VREF_POS_INPUT)
DAC_8BIT_R2R(config, "dac1", 0).add_route(ALL_OUTPUTS, "speaker", 0.5); // unknown DAC
DAC_4BIT_R2R(config, m_dac2, 0).add_route(ALL_OUTPUTS, "speaker", 0.5); // unknown DAC
DAC_1BIT(config, m_dac3, 0).add_route(ALL_OUTPUTS, "speaker", 0.99);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dac1", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac1", -1.0, DAC_VREF_NEG_INPUT);
vref.add_route(0, "dac2", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac2", -1.0, DAC_VREF_NEG_INPUT);
vref.add_route(0, "dac3", 1.0, DAC_VREF_POS_INPUT);
MCFG_DEVICE_ADD("tms", TMS5100, XTAL(640'000))
MCFG_TMS5110_DATA_CB(READLINE(*this, cvs_state, speech_rom_read_bit))
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 1.0)
MACHINE_CONFIG_END
TMS5100(config, m_tms5110, XTAL(640'000));
m_tms5110->data().set(FUNC(cvs_state::speech_rom_read_bit));
m_tms5110->add_route(ALL_OUTPUTS, "speaker", 1.0);
}
/*************************************

28
src/mame/drivers/dkong.cpp
View File

@ -1860,16 +1860,17 @@ MACHINE_CONFIG_END
*
*************************************/
MACHINE_CONFIG_START(dkong_state::s2650)
void dkong_state::s2650(machine_config &config)
{
dkong2b(config);
/* basic machine hardware */
MCFG_DEVICE_REPLACE(m_maincpu, S2650, CLOCK_1H / 2) /* ??? */
MCFG_DEVICE_PROGRAM_MAP(s2650_map)
MCFG_DEVICE_IO_MAP(s2650_io_map)
MCFG_DEVICE_DATA_MAP(s2650_data_map)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, dkong_state, s2650_fo_w))
s2650_device &s2650(S2650(config.replace(), m_maincpu, CLOCK_1H / 2)); /* ??? */
s2650.set_addrmap(AS_PROGRAM, &dkong_state::s2650_map);
s2650.set_addrmap(AS_IO, &dkong_state::s2650_io_map);
s2650.set_addrmap(AS_DATA, &dkong_state::s2650_data_map);
s2650.sense_handler().set("screen", FUNC(screen_device::vblank));
s2650.flag_handler().set(FUNC(dkong_state::s2650_fo_w));
m_screen->screen_vblank().set(FUNC(dkong_state::s2650_interrupt));
@ -1877,7 +1878,7 @@ MACHINE_CONFIG_START(dkong_state::s2650)
m_dma8257->out_memw_cb().set(FUNC(dkong_state::hb_dma_write_byte));
MCFG_MACHINE_START_OVERRIDE(dkong_state,s2650)
MACHINE_CONFIG_END
}
void dkong_state::herbiedk(machine_config &config)
{
@ -1885,15 +1886,12 @@ void dkong_state::herbiedk(machine_config &config)
downcast<s2650_device &>(*m_maincpu).sense_handler().set(m_screen, FUNC(screen_device::vblank)).invert(); // ???
}
MACHINE_CONFIG_START(dkong_state::spclforc)
void dkong_state::spclforc(machine_config &config)
{
herbiedk(config);
/* basic machine hardware */
MCFG_DEVICE_REMOVE("soundcpu")
/* video hardware */
config.device_remove("soundcpu");
m_screen->set_screen_update(FUNC(dkong_state::screen_update_spclforc));
MACHINE_CONFIG_END
}
/*************************************
*

24
src/mame/drivers/dm7000.cpp
View File

@ -301,26 +301,26 @@ void dm7000_state::kbd_put(u8 data)
m_scc0_lsr = 1;
}
MACHINE_CONFIG_START(dm7000_state::dm7000)
void dm7000_state::dm7000(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",PPC405GP, 252000000 / 10) // Should be PPC405D4?
PPC405GP(config, m_maincpu, 252000000 / 10); // Should be PPC405D4?
// Slowed down 10 times in order to get normal response for now
MCFG_PPC_BUS_FREQUENCY(252000000)
MCFG_DEVICE_PROGRAM_MAP(dm7000_mem)
m_maincpu->set_bus_frequency(252000000);
m_maincpu->set_addrmap(AS_PROGRAM, &dm7000_state::dm7000_mem);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
MCFG_SCREEN_SIZE(640, 480)
MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
MCFG_SCREEN_UPDATE_DRIVER(dm7000_state, screen_update_dm7000)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(50);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_size(640, 480);
screen.set_visarea(0, 640-1, 0, 480-1);
screen.set_screen_update(FUNC(dm7000_state::screen_update_dm7000));
GENERIC_TERMINAL(config, m_terminal, 0);
m_terminal->set_keyboard_callback(FUNC(dm7000_state::kbd_put));
}
MACHINE_CONFIG_END
/* ROM definition */
ROM_START( dm7000 )

25
src/mame/drivers/dolphunk.cpp
View File

@ -120,7 +120,7 @@ private:
bool m_cassold;
bool m_speaker_state;
virtual void machine_start() override { m_digits.resolve(); }
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device<speaker_sound_device> m_speaker;
required_device<cassette_image_device> m_cass;
output_finder<4> m_digits;
@ -233,26 +233,27 @@ static INPUT_PORTS_START( dauphin )
INPUT_PORTS_END
MACHINE_CONFIG_START(dauphin_state::dauphin)
void dauphin_state::dauphin(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(1'000'000))
MCFG_DEVICE_PROGRAM_MAP(dauphin_mem)
MCFG_DEVICE_IO_MAP(dauphin_io)
MCFG_S2650_SENSE_INPUT(READLINE(*this, dauphin_state, cass_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, dauphin_state, cass_w))
S2650(config, m_maincpu, XTAL(1'000'000));
m_maincpu->set_addrmap(AS_PROGRAM, &dauphin_state::dauphin_mem);
m_maincpu->set_addrmap(AS_IO, &dauphin_state::dauphin_io);
m_maincpu->sense_handler().set(FUNC(dauphin_state::cass_r));
m_maincpu->flag_handler().set(FUNC(dauphin_state::cass_w));
/* video hardware */
config.set_default_layout(layout_dolphunk);
/* sound hardware */
SPEAKER(config, "mono").front_center();
SPEAKER_SOUND(config, "speaker").add_route(ALL_OUTPUTS, "mono", 1.00);
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
SPEAKER_SOUND(config, m_speaker).add_route(ALL_OUTPUTS, "mono", 1.00);
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.25);
/* cassette */
MCFG_CASSETTE_ADD( "cassette" )
MCFG_TIMER_DRIVER_ADD_PERIODIC("dauphin_c", dauphin_state, dauphin_c, attotime::from_hz(4000))
MACHINE_CONFIG_END
CASSETTE(config, m_cass);
TIMER(config, "dauphin_c").configure_periodic(FUNC(dauphin_state::dauphin_c), attotime::from_hz(4000));
}
/* ROM definition */
ROM_START( dauphin )

83
src/mame/drivers/galaxia.cpp
View File

@ -300,31 +300,30 @@ static GFXDECODE_START( gfx_astrowar )
GFXDECODE_END
MACHINE_CONFIG_START(galaxia_state::galaxia)
void galaxia_state::galaxia(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, XTAL(14'318'181)/8)
MCFG_DEVICE_PROGRAM_MAP(galaxia_mem_map)
MCFG_DEVICE_IO_MAP(galaxia_io_map)
MCFG_DEVICE_DATA_MAP(galaxia_data_map)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, galaxia_state, write_s2650_flag))
S2650(config, m_maincpu, XTAL(14'318'181)/8);
m_maincpu->set_addrmap(AS_PROGRAM, &galaxia_state::galaxia_mem_map);
m_maincpu->set_addrmap(AS_IO, &galaxia_state::galaxia_io_map);
m_maincpu->set_addrmap(AS_DATA, &galaxia_state::galaxia_data_map);
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
m_maincpu->flag_handler().set(FUNC(galaxia_state::write_s2650_flag));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_ALWAYS_UPDATE)
MCFG_SCREEN_REFRESH_RATE(60) // wrong
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(0*8, 30*8-1, 2*8, 32*8-1)
MCFG_SCREEN_UPDATE_DRIVER(galaxia_state, screen_update_galaxia)
MCFG_SCREEN_PALETTE("palette")
MCFG_SCREEN_VBLANK_CALLBACK(WRITELINE(*this, galaxia_state, vblank_irq))
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_video_attributes(VIDEO_ALWAYS_UPDATE);
m_screen->set_refresh_hz(60); // wrong
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500));
m_screen->set_size(256, 256);
m_screen->set_visarea(0*8, 30*8-1, 2*8, 32*8-1);
m_screen->set_screen_update(FUNC(galaxia_state::screen_update_galaxia));
m_screen->set_palette(m_palette);
m_screen->screen_vblank().set(FUNC(galaxia_state::vblank_irq));
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_galaxia)
MCFG_PALETTE_ADD("palette", 0x18+2)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_galaxia);
PALETTE(config, m_palette, 0x18+2).set_init(FUNC(galaxia_state::palette_init_galaxia));
MCFG_PALETTE_INIT_OWNER(galaxia_state,galaxia)
MCFG_VIDEO_START_OVERRIDE(galaxia_state,galaxia)
S2636(config, m_s2636[0], 0);
@ -341,34 +340,32 @@ MACHINE_CONFIG_START(galaxia_state::galaxia)
/* sound hardware */
SPEAKER(config, "mono").front_center();
MACHINE_CONFIG_END
MACHINE_CONFIG_START(galaxia_state::astrowar)
}
void galaxia_state::astrowar(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, XTAL(14'318'181)/8)
MCFG_DEVICE_PROGRAM_MAP(astrowar_mem_map)
MCFG_DEVICE_IO_MAP(galaxia_io_map)
MCFG_DEVICE_DATA_MAP(galaxia_data_map)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, galaxia_state, write_s2650_flag))
S2650(config, m_maincpu, XTAL(14'318'181)/8);
m_maincpu->set_addrmap(AS_PROGRAM, &galaxia_state::astrowar_mem_map);
m_maincpu->set_addrmap(AS_IO, &galaxia_state::galaxia_io_map);
m_maincpu->set_addrmap(AS_DATA, &galaxia_state::galaxia_data_map);
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
m_maincpu->flag_handler().set(FUNC(galaxia_state::write_s2650_flag));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_ALWAYS_UPDATE)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(1*8, 31*8-1, 2*8, 32*8-1)
MCFG_SCREEN_UPDATE_DRIVER(galaxia_state, screen_update_astrowar)
MCFG_SCREEN_PALETTE("palette")
MCFG_SCREEN_VBLANK_CALLBACK(WRITELINE(*this, galaxia_state, vblank_irq))
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_video_attributes(VIDEO_ALWAYS_UPDATE);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500));
m_screen->set_size(256, 256);
m_screen->set_visarea(1*8, 31*8-1, 2*8, 32*8-1);
m_screen->set_screen_update(FUNC(galaxia_state::screen_update_astrowar));
m_screen->set_palette(m_palette);
m_screen->screen_vblank().set(FUNC(galaxia_state::vblank_irq));
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_astrowar)
MCFG_PALETTE_ADD("palette", 0x18+2)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_astrowar);
PALETTE(config, m_palette, 0x18+2).set_init(FUNC(galaxia_state::palette_init_astrowar));
MCFG_PALETTE_INIT_OWNER(galaxia_state,astrowar)
MCFG_VIDEO_START_OVERRIDE(galaxia_state,astrowar)
S2636(config, m_s2636[0], 0);
@ -377,7 +374,7 @@ MACHINE_CONFIG_START(galaxia_state::astrowar)
/* sound hardware */
SPEAKER(config, "mono").front_center();
MACHINE_CONFIG_END
}
/***************************************************************************

12
src/mame/drivers/galaxold.cpp
View File

@ -727,7 +727,7 @@ void galaxold_state::hunchbkg_data(address_map &map)
}
void galaxold_state::drivfrcg(address_map &map)
void galaxold_state::drivfrcg_program(address_map &map)
{
map(0x0000, 0x0fff).rom();
map(0x1480, 0x14bf).mirror(0x6000).w(FUNC(galaxold_state::galaxold_attributesram_w)).share("attributesram");
@ -2519,11 +2519,11 @@ MACHINE_CONFIG_END
MACHINE_CONFIG_START(galaxold_state::drivfrcg)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, MASTER_CLOCK/6)
MCFG_DEVICE_PROGRAM_MAP(drivfrcg)
MCFG_DEVICE_IO_MAP(drivfrcg_io)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", galaxold_state, hunchbks_vh_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank)) // ???
s2650_device &maincpu(S2650(config, m_maincpu, MASTER_CLOCK/6));
maincpu.set_addrmap(AS_PROGRAM, &galaxold_state::drivfrcg_program);
maincpu.set_addrmap(AS_IO, &galaxold_state::drivfrcg_io);
maincpu.set_vblank_int("screen", FUNC(galaxold_state::hunchbks_vh_interrupt));
maincpu.sense_handler().set("screen", FUNC(screen_device::vblank));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)

259
src/mame/drivers/hp48.cpp
View File

@ -11,7 +11,6 @@
#include "emu.h"
#include "includes/hp48.h"
#include "cpu/saturn/saturn.h"
#include "machine/nvram.h"
#include "sound/volt_reg.h"
#include "screen.h"
@ -1119,6 +1118,130 @@ static INPUT_PORTS_START( hp49g )
INPUT_PORTS_END
/**************************** memory *******************************/
/* In memory, nibbles are unpacked: one nibble at each address.
This is due to the way the SATURN emulation is done.
As a consequence only the 4 lower bits of each byte is used, the 4 higher
bits being zeros.
Another consequence is that ROMs must be unpacked before use.
Because of the complex memory manager, actual address mapping is done at
run-time.
*/
void hp48_state::hp48(address_map &map)
{
map(0x00000, 0xfffff).noprw(); /* configured at run-time */
}
/*************************** driver ********************************/
void hp48_state::hp48_common(machine_config &config)
{
/* cpu */
SATURN(config, m_maincpu, 3937007); /* almost 4 MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &hp48_state::hp48);
m_maincpu->out_func().set(FUNC(hp48_state::reg_out));
m_maincpu->in_func().set(FUNC(hp48_state::reg_in));
m_maincpu->reset_func().set(FUNC(hp48_state::mem_reset));
m_maincpu->config_func().set(FUNC(hp48_state::mem_config));
m_maincpu->unconfig_func().set(FUNC(hp48_state::mem_unconfig));
m_maincpu->id_func().set(FUNC(hp48_state::mem_id));
m_maincpu->crc_func().set(FUNC(hp48_state::mem_crc));
m_maincpu->rsi_func().set(FUNC(hp48_state::rsi));
/* memory */
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
/* video */
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(64);
m_screen->set_vblank_time(0);
m_screen->set_size(131, 64);
m_screen->set_visarea(0, 130, 0, 63);
m_screen->set_screen_update(FUNC(hp48_state::screen_update_hp48));
m_screen->set_palette(m_palette);
/* monochrome, but with varying contrast and grayscale */
PALETTE(config, m_palette, 256).set_init(FUNC(hp48_state::palette_init_hp48));
/* sound */
SPEAKER(config, "speaker").front_center();
DAC_1BIT(config, m_dac, 0).add_route(ALL_OUTPUTS, "speaker", 0.5);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
}
void hp48_state::hp48gx(machine_config &config)
{
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp48gx)
/* expansion ports */
HP48_PORT(config, m_port[0], HP48_CE2, 128*1024);
HP48_PORT(config, m_port[1], HP48_NCE3, 4*1024*1024);
/* serial I/O */
//MCFG_XMODEM_ADD("rs232_x", hp48_xmodem_rs232_conf)
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
void hp48_state::hp48g(machine_config &config)
{
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp48g);
/* serial I/O */
//MCFG_XMODEM_ADD("rs232_x", hp48_xmodem_rs232_conf)
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
void hp48_state::hp48gp(machine_config &config)
{
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp48gp)
/* serial I/O */
//MCFG_XMODEM_ADD("rs232_x", hp48_xmodem_rs232_conf)
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
void hp48_state::hp48sx(machine_config &config)
{
hp48_common(config);
m_maincpu->set_clock(2000000);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp48sx)
/* expansion ports */
HP48_PORT(config, m_port[0], HP48_CE1, 128*1024);
HP48_PORT(config, m_port[1], HP48_CE2, 128*1024);
/* serial I/O */
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
void hp48_state::hp48s(machine_config &config)
{
hp48_common(config);
m_maincpu->set_clock(2000000);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp48s)
/* serial I/O */
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
void hp48_state::hp49g(machine_config &config)
{
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE(hp48_state, hp49g)
/* serial I/O */
//MCFG_XMODEM_ADD("rs232_x", hp48_xmodem_rs232_conf)
//MCFG_KERMIT_ADD("rs232_k", hp48_kermit_rs232_conf)
}
/**************************** I/O **********************************/
@ -1144,7 +1267,7 @@ INPUT_PORTS_END
no extension may be physically present).
The G+ model has always revision R.
*/
ROM_START ( hp48gx )
ROM_START( hp48gx )
ROM_REGION( 0x80000, "maincpu", 0 )
ROM_DEFAULT_BIOS("r")
@ -1179,7 +1302,7 @@ ROM_END
(Note that G/GX revisions start at K, after the S/S revisions ends...)
*/
ROM_START ( hp48sx )
ROM_START( hp48sx )
ROM_REGION( 0x40000, "maincpu", 0 )
ROM_DEFAULT_BIOS("j")
@ -1208,17 +1331,17 @@ ROM_END
#define rom_hp48s rom_hp48sx
ROM_START ( hp38g )
ROM_START( hp38g )
ROM_REGION( 0x80000, "maincpu", 0 )
ROM_LOAD( "hp38g.rom", 0x00000, 0x80000, CRC(31d9affc) SHA1(bab3f5907a16cbb087943fd77230514af8fd5ac0))
ROM_END
ROM_START ( hp39g )
ROM_START( hp39g )
ROM_REGION( 0x100000, "maincpu", 0 )
ROM_LOAD( "hp39g.rom", 0x00000, 0x100000, CRC(28268fdc) SHA1(57a2b19075fe60307a9affa79d8e7cb550c621c3))
ROM_END
ROM_START ( hp49g )
ROM_START( hp49g )
ROM_REGION( 0x200000, "maincpu", 0 )
ROM_SYSTEM_BIOS( 0, "1.00", "Version C-1.00" )
ROMX_LOAD("hp49gv100.rom", 0x00000, 0x200000, CRC(64c9826a) SHA1(da25371b97d439fc0003cb786dba143ee2be9160), ROM_BIOS(0))
@ -1234,130 +1357,6 @@ ROM_START ( hp49g )
ROMX_LOAD("hp49gv119.rom", 0x00000, 0x200000, CRC(75218a18) SHA1(ec0f661f0aa7158d1f6df61f24410260b5324fa9), ROM_BIOS(5))
ROM_END
/**************************** memory *******************************/
/* In memory, nibbles are unpacked: one nibble at each address.
This is due to the way the SATURN emulation is done.
As a consequence only the 4 lower bits of each byte is used, the 4 higher
bits being zeros.
Another consequence is that ROMs must be unpacked before use.
Because of the complex memory manager, actual address mapping is done at
run-time.
*/
void hp48_state::hp48(address_map &map)
{
map(0x00000, 0xfffff).noprw(); /* configured at run-time */
}
/*************************** driver ********************************/
MACHINE_CONFIG_START(hp48_state::hp48_common)
/* cpu */
MCFG_DEVICE_ADD ( "maincpu", SATURN, 3937007 ) /* almost 4 MHz */
MCFG_DEVICE_PROGRAM_MAP ( hp48)
MCFG_SATURN_CONFIG( WRITE32(*this, hp48_state, reg_out), READ32(*this, hp48_state, reg_in),
WRITELINE(*this, hp48_state, mem_reset), WRITE32(*this, hp48_state, mem_config),
WRITE32(*this, hp48_state, mem_unconfig), READ32(*this, hp48_state, mem_id),
WRITE32(*this, hp48_state, mem_crc), WRITELINE(*this, hp48_state, rsi) )
/* memory */
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
/* video */
MCFG_SCREEN_ADD( "screen", RASTER )
MCFG_SCREEN_REFRESH_RATE( 64 )
MCFG_SCREEN_VBLANK_TIME(0)
MCFG_SCREEN_SIZE ( 131, 64 )
MCFG_SCREEN_VISIBLE_AREA( 0, 130, 0, 63 )
MCFG_SCREEN_UPDATE_DRIVER(hp48_state, screen_update_hp48)
MCFG_SCREEN_PALETTE("palette")
MCFG_PALETTE_ADD( "palette", 256 ) /* monochrome, but with varying contrast and grayscale */
MCFG_PALETTE_INIT_OWNER(hp48_state, hp48)
/* sound */
SPEAKER(config, "speaker").front_center();
MCFG_DEVICE_ADD("dac", DAC_1BIT, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 0.5)
MCFG_DEVICE_ADD("vref", VOLTAGE_REGULATOR, 0) MCFG_VOLTAGE_REGULATOR_OUTPUT(5.0)
MCFG_SOUND_ROUTE(0, "dac", 1.0, DAC_VREF_POS_INPUT)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp48gx)
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp48gx )
/* expansion ports */
HP48_PORT(config, m_port[0], HP48_CE2, 128*1024 );
HP48_PORT(config, m_port[1], HP48_NCE3, 4*1024*1024 );
/* serial I/O */
//MCFG_XMODEM_ADD( "rs232_x", hp48_xmodem_rs232_conf )
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp48g)
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp48g )
/* serial I/O */
//MCFG_XMODEM_ADD( "rs232_x", hp48_xmodem_rs232_conf )
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp48gp)
hp48_common(config);
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp48gp )
/* serial I/O */
//MCFG_XMODEM_ADD( "rs232_x", hp48_xmodem_rs232_conf )
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp48sx)
hp48_common(config);
MCFG_DEVICE_MODIFY ( "maincpu" )
MCFG_DEVICE_CLOCK ( 2000000 )
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp48sx )
/* expansion ports */
HP48_PORT(config, m_port[0], HP48_CE1, 128*1024 );
HP48_PORT(config, m_port[1], HP48_CE2, 128*1024 );
/* serial I/O */
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp48s)
hp48_common(config);
MCFG_DEVICE_MODIFY ( "maincpu" )
MCFG_DEVICE_CLOCK ( 2000000 )
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp48s )
/* serial I/O */
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
MACHINE_CONFIG_START(hp48_state::hp49g)
hp48_common(config);
MCFG_DEVICE_MODIFY ( "maincpu" )
MCFG_MACHINE_START_OVERRIDE (hp48_state, hp49g )
/* serial I/O */
//MCFG_XMODEM_ADD( "rs232_x", hp48_xmodem_rs232_conf )
//MCFG_KERMIT_ADD( "rs232_k", hp48_kermit_rs232_conf )
MACHINE_CONFIG_END
COMP( 1990, hp48sx, 0, 0, hp48sx, hp48sx, hp48_state, init_hp48, "Hewlett Packard", "HP48SX", 0 )
COMP( 1991, hp48s, hp48sx, 0, hp48s, hp48sx, hp48_state, init_hp48, "Hewlett Packard", "HP48S", 0 )
COMP( 1993, hp48gx, 0, 0, hp48gx, hp48gx, hp48_state, init_hp48, "Hewlett Packard", "HP48GX", 0 )

28
src/mame/drivers/instruct.cpp
View File

@ -93,7 +93,7 @@ private:
bool m_valid_digit;
bool m_cassin;
bool m_irqstate;
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_shared_ptr<uint8_t> m_p_ram;
required_shared_ptr<uint8_t> m_p_smiram;
required_shared_ptr<uint8_t> m_p_extram;
@ -421,27 +421,29 @@ QUICKLOAD_LOAD_MEMBER( instruct_state, instruct )
return result;
}
MACHINE_CONFIG_START(instruct_state::instruct)
void instruct_state::instruct(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(3'579'545) / 4)
MCFG_DEVICE_PROGRAM_MAP(mem_map)
MCFG_DEVICE_IO_MAP(io_map)
MCFG_DEVICE_DATA_MAP(data_map)
MCFG_DEVICE_PERIODIC_INT_DRIVER(instruct_state, t2l_int, 120)
MCFG_S2650_SENSE_INPUT(READLINE(*this, instruct_state, sense_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, instruct_state, flag_w))
S2650(config, m_maincpu, XTAL(3'579'545) / 4);
m_maincpu->set_addrmap(AS_PROGRAM, &instruct_state::mem_map);
m_maincpu->set_addrmap(AS_IO, &instruct_state::io_map);
m_maincpu->set_addrmap(AS_DATA, &instruct_state::data_map);
m_maincpu->set_periodic_int(FUNC(instruct_state::t2l_int), attotime::from_hz(120));
m_maincpu->sense_handler().set(FUNC(instruct_state::sense_r));
m_maincpu->flag_handler().set(FUNC(instruct_state::flag_w));
/* video hardware */
config.set_default_layout(layout_instruct);
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", instruct_state, instruct, "pgm", 1)
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(instruct_state, instruct), this), "pgm", 1);
/* cassette */
MCFG_CASSETTE_ADD( "cassette" )
CASSETTE(config, m_cass);
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
MACHINE_CONFIG_END
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.25);
}
/* ROM definition */
ROM_START( instruct )

87
src/mame/drivers/konamim2.cpp
View File

@ -279,13 +279,13 @@ private:
virtual void video_start() override;
virtual void machine_reset() override;
uint32_t screen_update_m2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(m2);
INTERRUPT_GEN_MEMBER(m2_irq);
void cde_init();
void cde_handle_command();
void cde_handle_reports();
void cde_dma_transfer(address_space &space, int channel, int next);
required_device<cpu_device> m_maincpu;
required_device<cpu_device> m_subcpu;
required_device<ppc602_device> m_maincpu;
required_device<ppc602_device> m_subcpu;
void _3do_m2_main(address_map &map);
void _3do_m2_main_m(address_map &map);
void _3do_m2_main_s(address_map &map);
@ -1272,7 +1272,7 @@ static INPUT_PORTS_START( m2 )
INPUT_PORTS_END
INTERRUPT_GEN_MEMBER(konamim2_state::m2)
INTERRUPT_GEN_MEMBER(konamim2_state::m2_irq)
{
/*
0x000001
@ -1303,49 +1303,44 @@ void konamim2_state::machine_reset()
cde_init();
}
MACHINE_CONFIG_START(konamim2_state::m2)
void konamim2_state::m2(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", PPC602, 66000000) /* actually PPC602, 66MHz */
MCFG_PPC_BUS_FREQUENCY(33000000) /* Multiplier 2, Bus = 33MHz, Core = 66MHz */
MCFG_DEVICE_PROGRAM_MAP(m2_main_m)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", konamim2_state, m2)
PPC602(config, m_maincpu, 66000000);
m_maincpu->set_bus_frequency(33000000); /* Multiplier 2, Bus = 33MHz, Core = 66MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &konamim2_state::m2_main_m);
m_maincpu->set_vblank_int("screen", FUNC(konamim2_state::m2_irq));
MCFG_DEVICE_ADD("sub", PPC602, 66000000) /* actually PPC602, 66MHz */
MCFG_PPC_BUS_FREQUENCY(33000000) /* Multiplier 2, Bus = 33MHz, Core = 66MHz */
MCFG_DEVICE_PROGRAM_MAP(m2_main_s)
PPC602(config, m_subcpu, 66000000); /* actually PPC602, 66MHz */
m_subcpu->set_bus_frequency(33000000); /* Multiplier 2, Bus = 33MHz, Core = 66MHz */
m_subcpu->set_addrmap(AS_PROGRAM, &konamim2_state::m2_main_s);
// TODO: declaring as second screen causes palette confusion (wants to use palette from the other screen?)
GENERIC_TERMINAL(config, m_terminal, 0);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
MCFG_SCREEN_SIZE(704, 512)
MCFG_SCREEN_VISIBLE_AREA(0, 511, 0, 383)
MCFG_SCREEN_UPDATE_DRIVER(konamim2_state, screen_update_m2)
MCFG_SCREEN_PALETTE("palette")
MCFG_PALETTE_ADD_RRRRRGGGGGBBBBB("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500));
screen.set_size(704, 512);
screen.set_visarea(0, 511, 0, 383);
screen.set_screen_update(FUNC(konamim2_state::screen_update_m2));
screen.set_palette("palette");
PALETTE(config, "palette", 32768).set_init(FUNC(palette_device::palette_init_RRRRRGGGGGBBBBB));
/*cd-rom*/
MCFG_CDROM_ADD( "cdrom" )
MCFG_CDROM_INTERFACE("3do_m2_cdrom")
CDROM(config, "cdrom", 0).set_interface("3do_m2_cdrom");
}
MACHINE_CONFIG_END
MACHINE_CONFIG_START(konamim2_state::_3do_m2)
void konamim2_state::_3do_m2(machine_config &config)
{
m2(config);
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(_3do_m2_main_m)
m_maincpu->set_addrmap(AS_PROGRAM, &konamim2_state::_3do_m2_main_m);
m_subcpu->set_addrmap(AS_PROGRAM, &konamim2_state::_3do_m2_main_s);
MCFG_DEVICE_MODIFY("sub")
MCFG_DEVICE_PROGRAM_MAP(_3do_m2_main_s)
MCFG_SOFTWARE_LIST_ADD("cd_list","3do_m2")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cd_list").set_original("3do_m2");
}
ROM_START( polystar )
@ -1475,19 +1470,15 @@ ROM_START(3do_m2)
ROMX_LOAD( "fz35_jpn.bin", 0x000000, 0x100000, CRC(e1c5bfd3) SHA1(0a3e27d672be79eeee1d2dc2da60d82f6eba7934), ROM_BIOS(0) )
ROM_END
void konamim2_state::init_m2()
{
}
GAME( 1997, polystar, 0, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Tobe! Polystars (ver JAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvice, 0, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Total Vice (ver EBA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvicu, totlvice, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Total Vice (ver UAC)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvicj, totlvice, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Total Vice (ver JAD)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvica, totlvice, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Total Vice (ver AAB)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, btltryst, 0, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Battle Tryst (ver JAC)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, heatof11, 0, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Heat of Eleven '98 (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, evilngt, 0, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Evil Night (ver UBA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, evilngte, evilngt, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Evil Night (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, hellngt, evilngt, m2, m2, konamim2_state, init_m2, ROT0, "Konami", "Hell Night (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, polystar, 0, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Tobe! Polystars (ver JAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvice, 0, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Total Vice (ver EBA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvicu, totlvice, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Total Vice (ver UAC)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvicj, totlvice, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Total Vice (ver JAD)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1997, totlvica, totlvice, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Total Vice (ver AAB)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, btltryst, 0, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Battle Tryst (ver JAC)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, heatof11, 0, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Heat of Eleven '98 (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, evilngt, 0, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Evil Night (ver UBA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, evilngte, evilngt, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Evil Night (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
GAME( 1998, hellngt, evilngt, m2, m2, konamim2_state, empty_init, ROT0, "Konami", "Hell Night (ver EAA)", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
CONS( 199?, 3do_m2, 0, 0, _3do_m2, m2, konamim2_state, empty_init, "3DO", "3DO M2", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )

87
src/mame/drivers/laserbat.cpp
View File

@ -80,7 +80,6 @@
#include "includes/laserbat.h"
#include "cpu/m6800/m6800.h"
#include "cpu/s2650/s2650.h"
#include "machine/clock.h"
@ -463,22 +462,22 @@ void laserbat_state_base::device_timer(emu_timer &timer, device_timer_id id, int
}
MACHINE_CONFIG_START(laserbat_state_base::laserbat_base)
void laserbat_state_base::laserbat_base(machine_config &config)
{
// basic machine hardware
MCFG_DEVICE_ADD(m_maincpu, S2650, XTAL(14'318'181)/4)
MCFG_DEVICE_PROGRAM_MAP(laserbat_map)
MCFG_DEVICE_IO_MAP(laserbat_io_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", laserbat_state_base, laserbat_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE(m_screen, screen_device, vblank))
S2650(config, m_maincpu, XTAL(14'318'181)/4);
m_maincpu->set_addrmap(AS_PROGRAM, &laserbat_state_base::laserbat_map);
m_maincpu->set_addrmap(AS_IO, &laserbat_state_base::laserbat_io_map);
m_maincpu->set_vblank_int("screen", FUNC(laserbat_state_base::laserbat_interrupt));
m_maincpu->sense_handler().set(m_screen, FUNC(screen_device::vblank));
// video hardware
MCFG_SCREEN_ADD(m_screen, RASTER)
MCFG_SCREEN_RAW_PARAMS(XTAL(14'318'181), 227*4, 43*4-1, 227*4-1, 312, 8, 255)
MCFG_SCREEN_UPDATE_DRIVER(laserbat_state_base, screen_update_laserbat)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(XTAL(14'318'181), 227*4, 43*4-1, 227*4-1, 312, 8, 255);
m_screen->set_screen_update(FUNC(laserbat_state_base::screen_update_laserbat));
m_screen->set_palette(m_palette);
MCFG_PLS100_ADD(m_gfxmix)
PLS100(config, m_gfxmix);
S2636(config, m_pvi[0], XTAL(14'318'181)/3);
m_pvi[0]->set_offsets(-8, -16);
@ -492,56 +491,52 @@ MACHINE_CONFIG_START(laserbat_state_base::laserbat_base)
m_pvi[2]->set_offsets(-8, -16);
m_pvi[2]->set_divider(3);
MCFG_DEVICE_ADD(m_gfxdecode, GFXDECODE, "palette", gfx_laserbat)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_laserbat);
}
MACHINE_CONFIG_END
MACHINE_CONFIG_START(laserbat_state::laserbat)
void laserbat_state::laserbat(machine_config &config)
{
laserbat_base(config);
// video hardware
MCFG_PALETTE_ADD(m_palette, 256)
MCFG_PALETTE_INIT_OWNER(laserbat_state, laserbat)
PALETTE(config, m_palette, 256).set_init(FUNC(laserbat_state::palette_init_laserbat));
// sound board devices
SPEAKER(config, "speaker").front_center();
MCFG_DEVICE_ADD(m_csg, SN76477) // audio output not used
MCFG_SN76477_NOISE_PARAMS(RES_K(47), RES_K(270), CAP_P(1000)) // R21, switchable R30/R23/R24/R25/R29/R28/R27/R26, C21
MCFG_SN76477_DECAY_RES(RES_INF) // NC
MCFG_SN76477_ATTACK_PARAMS(0, RES_INF) // NC, NC
MCFG_SN76477_AMP_RES(RES_K(47)) // R26 47k
MCFG_SN76477_FEEDBACK_RES(RES_INF) // NC
MCFG_SN76477_VCO_PARAMS(5.0 * RES_VOLTAGE_DIVIDER(RES_K(4.7), RES_K(2.2)), 0, RES_K(47)) // R22/R19, NC, switchable R47/R40/R41/R42/R46/R45/R44/R43
MCFG_SN76477_PITCH_VOLTAGE(5.0) // tied to Vreg
MCFG_SN76477_SLF_PARAMS(CAP_U(4.7), RES_INF) // C24, switchable NC/R54/R53/R52/R51
MCFG_SN76477_ONESHOT_PARAMS(0, RES_INF) // NC, NC
MCFG_SN76477_VCO_MODE(1) // BIT15
MCFG_SN76477_MIXER_PARAMS(0, 0, 0) // GND, VCO/NOISE, GND
MCFG_SN76477_ENVELOPE_PARAMS(0, 1) // GND, Vreg
MCFG_SN76477_ENABLE(0) // AB SOUND
SN76477(config, m_csg); // audio output not used
m_csg->set_noise_params(RES_K(47), RES_K(270), CAP_P(1000)); // R21, switchable R30/R23/R24/R25/R29/R28/R27/R26, C21
m_csg->set_decay_res(RES_INF); // NC
m_csg->set_attack_params(0, RES_INF); // NC, NC
m_csg->set_amp_res(RES_K(47)); // R26 47k
m_csg->set_feedback_res(RES_INF); // NC
m_csg->set_vco_params(5.0 * RES_VOLTAGE_DIVIDER(RES_K(4.7), RES_K(2.2)), 0, RES_K(47)); // R22/R19, NC, switchable R47/R40/R41/R42/R46/R45/R44/R43
m_csg->set_pitch_voltage(5.0); // tied to Vreg
m_csg->set_slf_params(CAP_U(4.7), RES_INF); // C24, switchable NC/R54/R53/R52/R51
m_csg->set_oneshot_params(0, RES_INF); // NC, NC
m_csg->set_vco_mode(1); // BIT15
m_csg->set_mixer_params(0, 0, 0); // GND, VCO/NOISE, GND
m_csg->set_envelope_params(0, 1); // GND, Vreg
m_csg->set_enable(0); // AB SOUND
MCFG_TMS3615_ADD(m_synth_low, 4_MHz_XTAL/16/2) // from the other one's /2 clock output
MCFG_SOUND_ROUTE(tms3615_device::FOOTAGE_8, "speaker", 1.0)
TMS3615(config, m_synth_low, 4_MHz_XTAL/16/2); // from the other one's /2 clock output
m_synth_low->add_route(tms3615_device::FOOTAGE_8, "speaker", 1.0);
MCFG_TMS3615_ADD(m_synth_high, 4_MHz_XTAL/16) // 4MHz divided down with a 74LS161
MCFG_SOUND_ROUTE(tms3615_device::FOOTAGE_8, "speaker", 1.0)
TMS3615(config, m_synth_high, 4_MHz_XTAL/16); // 4MHz divided down with a 74LS161
m_synth_high->add_route(tms3615_device::FOOTAGE_8, "speaker", 1.0);
}
MACHINE_CONFIG_END
MACHINE_CONFIG_START(catnmous_state::catnmous)
void catnmous_state::catnmous(machine_config &config)
{
laserbat_base(config);
// video hardware
MCFG_PALETTE_ADD(m_palette, 256)
MCFG_PALETTE_INIT_OWNER(catnmous_state, catnmous)
PALETTE(config, m_palette, 256).set_init(FUNC(catnmous_state::palette_init_catnmous));
// sound board devices
SPEAKER(config, "speaker").front_center();
MCFG_DEVICE_ADD(m_audiopcb, ZACCARIA_1B11107)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 1.0)
MACHINE_CONFIG_END
ZACCARIA_1B11107(config, m_audiopcb).add_route(ALL_OUTPUTS, "speaker", 1.0);
}
ROM_START( laserbat )

11
src/mame/drivers/malzak.cpp
View File

@ -67,7 +67,6 @@
#include "emu.h"
#include "includes/malzak.h"
#include "cpu/s2650/s2650.h"
#include "machine/nvram.h"
#include "sound/sn76477.h"
#include "speaker.h"
@ -300,11 +299,11 @@ void malzak_state::machine_reset()
MACHINE_CONFIG_START(malzak_state::malzak)
/* basic machine hardware */
MCFG_DEVICE_ADD(m_maincpu, S2650, 3800000/4)
MCFG_DEVICE_PROGRAM_MAP(malzak_map)
MCFG_DEVICE_IO_MAP(malzak_io_map)
MCFG_DEVICE_DATA_MAP(malzak_data_map)
MCFG_S2650_SENSE_INPUT(READLINE(m_screen, screen_device, vblank))
S2650(config, m_maincpu, 3800000/4);
m_maincpu->set_addrmap(AS_PROGRAM, &malzak_state::malzak_map);
m_maincpu->set_addrmap(AS_IO, &malzak_state::malzak_io_map);
m_maincpu->set_addrmap(AS_DATA, &malzak_state::malzak_data_map);
m_maincpu->sense_handler().set(m_screen, FUNC(screen_device::vblank));
/* video hardware */
MCFG_SCREEN_ADD(m_screen, RASTER)

41
src/mame/drivers/phunsy.cpp
View File

@ -75,7 +75,7 @@ private:
uint8_t m_data_out;
uint8_t m_keyboard_input;
virtual void machine_reset() override;
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device<speaker_sound_device> m_speaker;
required_device<cassette_image_device> m_cass;
required_shared_ptr<uint8_t> m_p_videoram;
@ -341,44 +341,45 @@ void phunsy_state::init_phunsy()
membank("bankq")->set_entry(0);
}
MACHINE_CONFIG_START(phunsy_state::phunsy)
void phunsy_state::phunsy(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(1'000'000))
MCFG_DEVICE_PROGRAM_MAP(phunsy_mem)
MCFG_DEVICE_IO_MAP(phunsy_io)
MCFG_DEVICE_DATA_MAP(phunsy_data)
MCFG_S2650_SENSE_INPUT(READLINE(*this, phunsy_state, cass_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, phunsy_state, cass_w))
S2650(config, m_maincpu, XTAL(1'000'000));
m_maincpu->set_addrmap(AS_PROGRAM, &phunsy_state::phunsy_mem);
m_maincpu->set_addrmap(AS_IO, &phunsy_state::phunsy_io);
m_maincpu->set_addrmap(AS_DATA, &phunsy_state::phunsy_data);
m_maincpu->sense_handler().set(FUNC(phunsy_state::cass_r));
m_maincpu->flag_handler().set(FUNC(phunsy_state::cass_w));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
/* Display (page 12 of pdf)
- 8Mhz clock
- 64 6 pixel characters on a line.
- 16us not active, 48us active: ( 64 * 6 ) * 60 / 48 => 480 pixels wide
- 313 line display of which 256 are displayed.
*/
MCFG_SCREEN_RAW_PARAMS(XTAL(8'000'000), 480, 0, 64*6, 313, 0, 256)
MCFG_SCREEN_UPDATE_DRIVER(phunsy_state, screen_update)
MCFG_SCREEN_PALETTE("palette")
screen.set_raw(XTAL(8'000'000), 480, 0, 64*6, 313, 0, 256);
screen.set_screen_update(FUNC(phunsy_state::screen_update));
screen.set_palette("palette");
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_phunsy)
MCFG_PALETTE_ADD("palette", 8)
MCFG_PALETTE_INIT_OWNER(phunsy_state, phunsy)
GFXDECODE(config, "gfxdecode", "palette", gfx_phunsy);
PALETTE(config, "palette", 8).set_init(FUNC(phunsy_state::palette_init_phunsy));
/* sound hardware */
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
SPEAKER_SOUND(config, "speaker").add_route(ALL_OUTPUTS, "mono", 0.50);
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.25);
SPEAKER_SOUND(config, m_speaker).add_route(ALL_OUTPUTS, "mono", 0.50);
/* Devices */
generic_keyboard_device &keyboard(GENERIC_KEYBOARD(config, "keyboard", 0));
keyboard.set_keyboard_callback(FUNC(phunsy_state::kbd_put));
MCFG_CASSETTE_ADD( "cassette" )
CASSETTE(config, m_cass);
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", phunsy_state, phunsy, "bin", 2)
MACHINE_CONFIG_END
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(phunsy_state, phunsy), this), "bin", 2);
}
/* ROM definition */

20
src/mame/drivers/pipbug.cpp
View File

@ -59,8 +59,8 @@ public:
private:
DECLARE_WRITE8_MEMBER(pipbug_ctrl_w);
required_device<rs232_port_device> m_rs232;
required_device<cpu_device> m_maincpu;
DECLARE_QUICKLOAD_LOAD_MEMBER( pipbug );
required_device<s2650_device> m_maincpu;
DECLARE_QUICKLOAD_LOAD_MEMBER(pipbug);
void pipbug_data(address_map &map);
void pipbug_mem(address_map &map);
};
@ -160,12 +160,13 @@ QUICKLOAD_LOAD_MEMBER( pipbug_state, pipbug )
return result;
}
MACHINE_CONFIG_START(pipbug_state::pipbug)
void pipbug_state::pipbug(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD(m_maincpu, S2650, XTAL(1'000'000))
MCFG_DEVICE_PROGRAM_MAP(pipbug_mem)
MCFG_DEVICE_DATA_MAP(pipbug_data)
MCFG_S2650_FLAG_OUTPUT(WRITELINE("rs232", rs232_port_device, write_txd))
S2650(config, m_maincpu, XTAL(1'000'000));
m_maincpu->set_addrmap(AS_PROGRAM, &pipbug_state::pipbug_mem);
m_maincpu->set_addrmap(AS_DATA, &pipbug_state::pipbug_data);
m_maincpu->flag_handler().set("rs232", FUNC(rs232_port_device::write_txd));
/* video hardware */
RS232_PORT(config, m_rs232, default_rs232_devices, "terminal");
@ -173,8 +174,9 @@ MACHINE_CONFIG_START(pipbug_state::pipbug)
m_rs232->set_option_device_input_defaults("terminal", DEVICE_INPUT_DEFAULTS_NAME(terminal));
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", pipbug_state, pipbug, "pgm", 1)
MACHINE_CONFIG_END
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(pipbug_state, pipbug), this), "pgm", 1);
}
/* ROM definition */

61
src/mame/drivers/quasar.cpp
View File

@ -110,7 +110,7 @@ READ_LINE_MEMBER(quasar_state::audio_t1_r)
// memory map taken from the manual
void quasar_state::quasar(address_map &map)
void quasar_state::quasar_program(address_map &map)
{
map(0x0000, 0x13ff).rom();
map(0x1400, 0x14ff).mirror(0x6000).r(FUNC(quasar_state::cvs_bullet_ram_or_palette_r)).w(FUNC(quasar_state::quasar_bullet_w)).share("bullet_ram");
@ -279,7 +279,7 @@ INTERRUPT_GEN_MEMBER(quasar_state::quasar_interrupt)
// Quasar S2650 Main CPU, I8035 sound board
// ****************************************
MACHINE_START_MEMBER(quasar_state,quasar)
void quasar_state::machine_start()
{
cvs_state::machine_start();
@ -289,7 +289,7 @@ MACHINE_START_MEMBER(quasar_state,quasar)
save_item(NAME(m_io_page));
}
MACHINE_RESET_MEMBER(quasar_state,quasar)
void quasar_state::machine_reset()
{
cvs_state::machine_reset();
@ -298,15 +298,15 @@ MACHINE_RESET_MEMBER(quasar_state,quasar)
m_io_page = 8;
}
MACHINE_CONFIG_START(quasar_state::quasar)
void quasar_state::quasar(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 14318000/4) /* 14 mhz crystal divide by 4 on board */
MCFG_DEVICE_PROGRAM_MAP(quasar)
MCFG_DEVICE_IO_MAP(quasar_io)
MCFG_DEVICE_DATA_MAP(quasar_data)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", quasar_state, quasar_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
S2650(config, m_maincpu, 14318000/4); /* 14 mhz crystal divide by 4 on board */
m_maincpu->set_addrmap(AS_PROGRAM, &quasar_state::quasar_program);
m_maincpu->set_addrmap(AS_IO, &quasar_state::quasar_io);
m_maincpu->set_addrmap(AS_DATA, &quasar_state::quasar_data);
m_maincpu->set_vblank_int("screen", FUNC(quasar_state::quasar_interrupt));
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
i8035_device &soundcpu(I8035(config, "soundcpu", 6000000)); /* 6MHz crystal divide by 15 in CPU */
soundcpu.set_addrmap(AS_PROGRAM, &quasar_state::sound_map);
@ -314,24 +314,21 @@ MACHINE_CONFIG_START(quasar_state::quasar)
soundcpu.t1_in_cb().set(FUNC(quasar_state::audio_t1_r));
soundcpu.p1_out_cb().set("dac", FUNC(dac_byte_interface::data_w));
MCFG_MACHINE_START_OVERRIDE(quasar_state,quasar)
MCFG_MACHINE_RESET_OVERRIDE(quasar_state,quasar)
MCFG_QUANTUM_TIME(attotime::from_hz(6000))
config.m_minimum_quantum = attotime::from_hz(6000);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(50) /* From dot clock */
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(1*8+1, 29*8-1, 2*8, 32*8-1)
MCFG_SCREEN_UPDATE_DRIVER(quasar_state, screen_update_quasar)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(50); /* From dot clock */
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
m_screen->set_size(256, 256);
m_screen->set_visarea(1*8+1, 29*8-1, 2*8, 32*8-1);
m_screen->set_screen_update(FUNC(quasar_state::screen_update_quasar));
m_screen->set_palette(m_palette);
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_quasar)
MCFG_PALETTE_ADD("palette", (64+1)*8+(4*256))
MCFG_PALETTE_INDIRECT_ENTRIES(0x500)
MCFG_PALETTE_INIT_OWNER(quasar_state,quasar)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_quasar);
PALETTE(config, m_palette, (64+1)*8+(4*256));
m_palette->set_indirect_entries(0x500);
m_palette->set_init(FUNC(quasar_state::palette_init_quasar));
S2636(config, m_s2636[0], 0);
m_s2636[0]->set_offsets(CVS_S2636_Y_OFFSET - 8, CVS_S2636_X_OFFSET - 9);
@ -342,16 +339,16 @@ MACHINE_CONFIG_START(quasar_state::quasar)
S2636(config, m_s2636[2], 0);
m_s2636[2]->set_offsets(CVS_S2636_Y_OFFSET - 8, CVS_S2636_X_OFFSET - 9);
MCFG_VIDEO_START_OVERRIDE(quasar_state,quasar)
/* sound hardware */
GENERIC_LATCH_8(config, m_soundlatch);
SPEAKER(config, "speaker").front_center();
MCFG_DEVICE_ADD("dac", DAC_8BIT_R2R, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 1.0) // unknown DAC
MCFG_DEVICE_ADD("vref", VOLTAGE_REGULATOR, 0) MCFG_VOLTAGE_REGULATOR_OUTPUT(5.0)
MCFG_SOUND_ROUTE(0, "dac", 1.0, DAC_VREF_POS_INPUT) MCFG_SOUND_ROUTE(0, "dac", -1.0, DAC_VREF_NEG_INPUT)
MACHINE_CONFIG_END
DAC_8BIT_R2R(config, "dac", 0).add_route(ALL_OUTPUTS, "speaker", 1.0); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
ROM_START( quasar )
ROM_REGION( 0x8000, "maincpu", 0 )

45
src/mame/drivers/quizshow.cpp
View File

@ -46,6 +46,7 @@ public:
m_dac(*this, "dac"),
m_main_ram(*this, "main_ram"),
m_gfxdecode(*this, "gfxdecode"),
m_palette(*this, "palette"),
m_screen(*this, "screen"),
m_lamps(*this, "lamp%u", 0U)
{ }
@ -76,10 +77,11 @@ private:
uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(clock_timer_cb);
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device<dac_bit_interface> m_dac;
required_shared_ptr<uint8_t> m_main_ram;
required_device<gfxdecode_device> m_gfxdecode;
required_device<palette_device> m_palette;
required_device<screen_device> m_screen;
output_finder<11> m_lamps;
@ -388,34 +390,35 @@ void quizshow_state::machine_reset()
m_tape_head_pos = 0;
}
MACHINE_CONFIG_START(quizshow_state::quizshow)
void quizshow_state::quizshow(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, MASTER_CLOCK / 16) // divider guessed
MCFG_DEVICE_PROGRAM_MAP(mem_map)
MCFG_S2650_SENSE_INPUT(READLINE(*this, quizshow_state, tape_signal_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, quizshow_state, flag_output_w))
MCFG_TIMER_DRIVER_ADD_PERIODIC("clock_timer", quizshow_state, clock_timer_cb, attotime::from_hz(PIXEL_CLOCK / (HTOTAL * 8))) // 8V
S2650(config, m_maincpu, MASTER_CLOCK / 16); // divider guessed
m_maincpu->set_addrmap(AS_PROGRAM, &quizshow_state::mem_map);
m_maincpu->sense_handler().set(FUNC(quizshow_state::tape_signal_r));
m_maincpu->flag_handler().set(FUNC(quizshow_state::flag_output_w));
TIMER(config, "clock_timer").configure_periodic(FUNC(quizshow_state::clock_timer_cb), attotime::from_hz(PIXEL_CLOCK / (HTOTAL * 8))); // 8V
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(PIXEL_CLOCK, HTOTAL, HBEND, HBSTART, VTOTAL, VBEND, VBSTART)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(PIXEL_CLOCK, HTOTAL, HBEND, HBSTART, VTOTAL, VBEND, VBSTART);
m_screen->set_screen_update(FUNC(quizshow_state::screen_update));
m_screen->set_palette("palette");
MCFG_SCREEN_UPDATE_DRIVER(quizshow_state, screen_update)
MCFG_SCREEN_PALETTE("palette")
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_quizshow)
MCFG_PALETTE_ADD("palette", 8*2)
MCFG_PALETTE_INDIRECT_ENTRIES(2)
MCFG_PALETTE_INIT_OWNER(quizshow_state, quizshow)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_quizshow);
PALETTE(config, m_palette, 8*2);
m_palette->set_indirect_entries(2);
m_palette->set_init(FUNC(quizshow_state::palette_init_quizshow));
/* sound hardware (discrete) */
SPEAKER(config, "speaker").front_center();
MCFG_DEVICE_ADD("dac", DAC_1BIT, 0) MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 0.25)
MCFG_DEVICE_ADD("vref", VOLTAGE_REGULATOR, 0) MCFG_VOLTAGE_REGULATOR_OUTPUT(5.0)
MCFG_SOUND_ROUTE(0, "dac", 1.0, DAC_VREF_POS_INPUT)
MACHINE_CONFIG_END
DAC_1BIT(config, m_dac, 0).add_route(ALL_OUTPUTS, "speaker", 0.25);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
}
/***************************************************************************

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

@ -115,7 +115,7 @@ private:
uint8_t m_term_char;
uint8_t m_term_data;
virtual void machine_start() override { m_digits.resolve(); }
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
optional_device<generic_terminal_device> m_terminal;
required_device<cassette_image_device> m_cass;
output_finder<7> m_digits;
@ -338,33 +338,36 @@ QUICKLOAD_LOAD_MEMBER( ravens_state, ravens )
return result;
}
MACHINE_CONFIG_START(ravens_state::ravens)
void ravens_state::ravens(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(1'000'000)) // frequency is unknown
MCFG_DEVICE_PROGRAM_MAP(ravens_mem)
MCFG_DEVICE_IO_MAP(ravens_io)
MCFG_S2650_SENSE_INPUT(READLINE(*this, ravens_state, cass_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, ravens_state, cass_w))
S2650(config, m_maincpu, XTAL(1'000'000)); // frequency is unknown
m_maincpu->set_addrmap(AS_PROGRAM, &ravens_state::ravens_mem);
m_maincpu->set_addrmap(AS_IO, &ravens_state::ravens_io);
m_maincpu->sense_handler().set(FUNC(ravens_state::cass_r));
m_maincpu->flag_handler().set(FUNC(ravens_state::cass_w));
/* video hardware */
config.set_default_layout(layout_ravens);
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", ravens_state, ravens, "pgm", 1)
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(ravens_state, ravens), this), "pgm", 1);
/* cassette */
MCFG_CASSETTE_ADD( "cassette" )
CASSETTE(config, m_cass);
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.05);
MACHINE_CONFIG_END
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.05);
}
MACHINE_CONFIG_START(ravens_state::ravens2)
void ravens_state::ravens2(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",S2650, XTAL(1'000'000)) // frequency is unknown
MCFG_DEVICE_PROGRAM_MAP(ravens_mem)
MCFG_DEVICE_IO_MAP(ravens2_io)
MCFG_S2650_SENSE_INPUT(READLINE(*this, ravens_state, cass_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, ravens_state, cass_w))
S2650(config, m_maincpu, XTAL(1'000'000)); // frequency is unknown
m_maincpu->set_addrmap(AS_PROGRAM, &ravens_state::ravens_mem);
m_maincpu->set_addrmap(AS_IO, &ravens_state::ravens2_io);
m_maincpu->sense_handler().set(FUNC(ravens_state::cass_r));
m_maincpu->flag_handler().set(FUNC(ravens_state::cass_w));
MCFG_MACHINE_RESET_OVERRIDE(ravens_state, ravens2)
@ -373,13 +376,14 @@ MACHINE_CONFIG_START(ravens_state::ravens2)
m_terminal->set_keyboard_callback(FUNC(ravens_state::kbd_put));
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", ravens_state, ravens, "pgm", 1)
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(ravens_state, ravens), this), "pgm", 1);
/* cassette */
MCFG_CASSETTE_ADD( "cassette" )
CASSETTE(config, m_cass);
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.05);
MACHINE_CONFIG_END
WAVE(config, "wave", m_cass).add_route(ALL_OUTPUTS, "mono", 0.05);
}
/* ROM definition */
ROM_START( ravens )

10
src/mame/drivers/scramble.cpp
View File

@ -1549,11 +1549,11 @@ MACHINE_CONFIG_START(scramble_state::hunchbks)
scramble(config);
/* basic machine hardware */
MCFG_DEVICE_REPLACE("maincpu", S2650, 18432000/6)
MCFG_DEVICE_PROGRAM_MAP(hunchbks_map)
MCFG_DEVICE_IO_MAP(hunchbks_readport)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", scramble_state, hunchbks_vh_interrupt)
s2650_device &maincpu(S2650(config.replace(), m_maincpu, 18432000/6));
maincpu.set_addrmap(AS_PROGRAM, &scramble_state::hunchbks_map);
maincpu.set_addrmap(AS_IO, &scramble_state::hunchbks_readport);
maincpu.sense_handler().set("screen", FUNC(screen_device::vblank));
maincpu.set_vblank_int("screen", FUNC(scramble_state::hunchbks_vh_interrupt));
MCFG_SCREEN_MODIFY("screen")
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))

53
src/mame/drivers/seabattl.cpp
View File

@ -90,7 +90,7 @@ private:
virtual void machine_reset() override;
virtual void video_start() override;
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_shared_ptr<uint8_t> m_videoram;
required_shared_ptr<uint8_t> m_colorram;
required_shared_ptr<uint8_t> m_objram;
@ -482,48 +482,41 @@ GFXDECODE_END
MACHINE_CONFIG_START(seabattl_state::seabattl)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 14318180/4/2)
MCFG_DEVICE_PROGRAM_MAP(seabattl_map)
MCFG_DEVICE_DATA_MAP(seabattl_data_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", seabattl_state, seabattl_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
S2650(config, m_maincpu, 14318180/4/2);
m_maincpu->set_addrmap(AS_PROGRAM, &seabattl_state::seabattl_map);
m_maincpu->set_addrmap(AS_DATA, &seabattl_state::seabattl_data_map);
m_maincpu->set_vblank_int("screen", FUNC(seabattl_state::seabattl_interrupt));
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
S2636(config, m_s2636, 0);
m_s2636->set_offsets(-13, -29);
m_s2636->add_route(ALL_OUTPUTS, "mono", 0.10);
MCFG_DEVICE_ADD("sc_thousand", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<0>))
MCFG_DEVICE_ADD("sc_hundred", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<1>))
MCFG_DEVICE_ADD("sc_half", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<2>))
MCFG_DEVICE_ADD("sc_unity", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<3>))
MCFG_DEVICE_ADD("tm_half", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<4>))
MCFG_DEVICE_ADD("tm_unity", DM9368, 0)
MCFG_DM9368_UPDATE_CALLBACK(WRITE8(*this, seabattl_state, digit_w<5>))
DM9368(config, m_digits[0], 0).update_cb().set(FUNC(seabattl_state::digit_w<0>));
DM9368(config, m_digits[1], 0).update_cb().set(FUNC(seabattl_state::digit_w<1>));
DM9368(config, m_digits[2], 0).update_cb().set(FUNC(seabattl_state::digit_w<2>));
DM9368(config, m_digits[3], 0).update_cb().set(FUNC(seabattl_state::digit_w<3>));
DM9368(config, m_digits[4], 0).update_cb().set(FUNC(seabattl_state::digit_w<4>));
DM9368(config, m_digits[5], 0).update_cb().set(FUNC(seabattl_state::digit_w<5>));
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_ALWAYS_UPDATE)
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(1*8, 29*8-1, 2*8, 32*8-1)
MCFG_SCREEN_UPDATE_DRIVER(seabattl_state, screen_update_seabattl)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_video_attributes(VIDEO_ALWAYS_UPDATE);
m_screen->set_refresh_hz(50);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
m_screen->set_size(256, 256);
m_screen->set_visarea(1*8, 29*8-1, 2*8, 32*8-1);
m_screen->set_screen_update(FUNC(seabattl_state::screen_update_seabattl));
m_screen->set_palette(m_palette);
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_seabattl)
MCFG_PALETTE_ADD("palette", 26)
MCFG_PALETTE_INIT_OWNER(seabattl_state, seabattl)
GFXDECODE(config, m_gfxdecode, m_palette, gfx_seabattl);
PALETTE(config, m_palette, 26).set_init(FUNC(seabattl_state::palette_init_seabattl));
/* sound hardware */
SPEAKER(config, "mono").front_center();
/* discrete sound */
MACHINE_CONFIG_END
}

41
src/mame/drivers/subhuntr.cpp
View File

@ -50,7 +50,7 @@ private:
void subhuntr_io_map(address_map &map);
void subhuntr_map(address_map &map);
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
};
@ -141,40 +141,39 @@ static GFXDECODE_START( gfx_subhuntr )
GFXDECODE_END
MACHINE_CONFIG_START(subhuntr_state::subhuntr)
void subhuntr_state::subhuntr(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 14318180/4/2)
MCFG_DEVICE_PROGRAM_MAP(subhuntr_map)
MCFG_DEVICE_IO_MAP(subhuntr_io_map)
MCFG_DEVICE_DATA_MAP(subhuntr_data_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", subhuntr_state, subhuntr_interrupt)
MCFG_S2650_SENSE_INPUT(READLINE("screen", screen_device, vblank))
S2650(config, m_maincpu, 14318180/4/2);
m_maincpu->set_addrmap(AS_PROGRAM, &subhuntr_state::subhuntr_map);
m_maincpu->set_addrmap(AS_IO, &subhuntr_state::subhuntr_io_map);
m_maincpu->set_addrmap(AS_DATA, &subhuntr_state::subhuntr_data_map);
m_maincpu->set_vblank_int("screen", FUNC(subhuntr_state::subhuntr_interrupt));
m_maincpu->sense_handler().set("screen", FUNC(screen_device::vblank));
s2636_device &s2636(S2636(config, "s2636", 0));
s2636.set_offsets(3, -21);
s2636.add_route(ALL_OUTPUTS, "mono", 0.10);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_VIDEO_ATTRIBUTES(VIDEO_ALWAYS_UPDATE)
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500) /* not accurate */)
MCFG_SCREEN_SIZE(256, 256)
MCFG_SCREEN_VISIBLE_AREA(1*8, 29*8-1, 2*8, 32*8-1)
MCFG_SCREEN_UPDATE_DRIVER(subhuntr_state, screen_update_subhuntr)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_video_attributes(VIDEO_ALWAYS_UPDATE);
screen.set_refresh_hz(50);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
screen.set_size(256, 256);
screen.set_visarea(1*8, 29*8-1, 2*8, 32*8-1);
screen.set_screen_update(FUNC(subhuntr_state::screen_update_subhuntr));
screen.set_palette("palette");
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfx_subhuntr)
GFXDECODE(config, "gfxdecode", "palette", gfx_subhuntr);
MCFG_PALETTE_ADD("palette", 26)
MCFG_PALETTE_INIT_OWNER(subhuntr_state, subhuntr)
PALETTE(config, "palette", 26).set_init(FUNC(subhuntr_state::palette_init_subhuntr));
/* sound hardware */
SPEAKER(config, "mono").front_center();
/* discrete sound */
MACHINE_CONFIG_END
}

49
src/mame/drivers/taitopjc.cpp
View File

@ -116,7 +116,7 @@ public:
void init_optiger();
private:
required_device<cpu_device> m_maincpu;
required_device<ppc603e_device> m_maincpu;
required_device<tmp95c063_device> m_iocpu;
required_device<cpu_device> m_soundcpu;
required_device<cpu_device> m_dsp;
@ -769,10 +769,11 @@ INTERRUPT_GEN_MEMBER(taitopjc_state::taitopjc_vbi)
}
MACHINE_CONFIG_START(taitopjc_state::taitopjc)
MCFG_DEVICE_ADD("maincpu", PPC603E, 100000000)
MCFG_PPC_BUS_FREQUENCY(XTAL(66'666'700)) /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
MCFG_DEVICE_PROGRAM_MAP(ppc603e_mem)
void taitopjc_state::taitopjc(machine_config &config)
{
PPC603E(config, m_maincpu, 100000000);
m_maincpu->set_bus_frequency(XTAL(66'666'700)); /* Multiplier 1.5, Bus = 66MHz, Core = 100MHz */
m_maincpu->set_addrmap(AS_PROGRAM, &taitopjc_state::ppc603e_mem);
/* TMP95C063F I/O CPU */
TMP95C063(config, m_iocpu, 25000000);
@ -787,33 +788,31 @@ MACHINE_CONFIG_START(taitopjc_state::taitopjc)
m_iocpu->set_vblank_int("screen", FUNC(taitopjc_state::taitopjc_vbi));
/* TMS320C53 DSP */
MCFG_DEVICE_ADD("dsp", TMS32053, 40000000)
MCFG_DEVICE_PROGRAM_MAP(tms_program_map)
MCFG_DEVICE_DATA_MAP(tms_data_map)
MCFG_DEVICE_IO_MAP(tms_io_map)
TMS32053(config, m_dsp, 40000000);
m_dsp->set_addrmap(AS_PROGRAM, &taitopjc_state::tms_program_map);
m_dsp->set_addrmap(AS_DATA, &taitopjc_state::tms_data_map);
m_dsp->set_addrmap(AS_IO, &taitopjc_state::tms_io_map);
MCFG_DEVICE_ADD("mn10200", MN1020012A, 10000000) /* MN1020819DA sound CPU - NOTE: May have 64kB internal ROM */
MCFG_DEVICE_PROGRAM_MAP(mn10200_map)
MN1020012A(config, m_soundcpu, 10000000); /* MN1020819DA sound CPU - NOTE: May have 64kB internal ROM */
m_soundcpu->set_addrmap(AS_PROGRAM, &taitopjc_state::mn10200_map);
MCFG_QUANTUM_TIME(attotime::from_hz(6000))
config.m_minimum_quantum = attotime::from_hz(6000);
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(512, 384)
MCFG_SCREEN_VISIBLE_AREA(0, 511, 0, 383)
MCFG_SCREEN_UPDATE_DRIVER(taitopjc_state, screen_update_taitopjc)
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, 384);
screen.set_visarea(0, 511, 0, 383);
screen.set_screen_update(FUNC(taitopjc_state::screen_update_taitopjc));
screen.set_palette(m_palette);
MCFG_PALETTE_ADD("palette", 32768)
PALETTE(config, m_palette, 32768);
GFXDECODE(config, m_gfxdecode, m_palette, gfxdecode_device::empty);
MCFG_DEVICE_ADD("gfxdecode", GFXDECODE, "palette", gfxdecode_device::empty)
MCFG_DEVICE_ADD("tc0780fpa", TC0780FPA, 0)
MACHINE_CONFIG_END
TC0780FPA(config, m_tc0780fpa, 0);
}
void taitopjc_state::init_optiger()

28
src/mame/drivers/tx0.cpp
View File

@ -1540,22 +1540,20 @@ INTERRUPT_GEN_MEMBER(tx0_state::tx0_interrupt)
MACHINE_CONFIG_START(tx0_state::tx0_64kw)
/* basic machine hardware */
/* TX0 CPU @ approx. 167 kHz (no master clock, but the memory cycle time is approximately 6usec) */
MCFG_DEVICE_ADD("maincpu", TX0_64KW, 166667)
MCFG_TX0_CONFIG(
WRITELINE( *this, tx0_state, tx0_io_cpy ),
WRITELINE( *this, tx0_state, tx0_io_r1l ),
WRITELINE( *this, tx0_state, tx0_io_dis ),
WRITELINE( *this, tx0_state, tx0_io_r3l ),
WRITELINE( *this, tx0_state, tx0_io_prt ),
NOOP,
WRITELINE( *this, tx0_state, tx0_io_p6h ),
WRITELINE( *this, tx0_state, tx0_io_p7h ),
WRITELINE( *this, tx0_state, tx0_sel ),
WRITELINE( *this, tx0_state, tx0_io_reset_callback )
)
MCFG_DEVICE_PROGRAM_MAP(tx0_64kw_map)
TX0_64KW(config, m_maincpu, 166667);
m_maincpu->cpy().set(FUNC(tx0_state::tx0_io_cpy));
m_maincpu->r1l().set(FUNC(tx0_state::tx0_io_r1l));
m_maincpu->dis().set(FUNC(tx0_state::tx0_io_dis));
m_maincpu->r3l().set(FUNC(tx0_state::tx0_io_r3l));
m_maincpu->prt().set(FUNC(tx0_state::tx0_io_prt));
m_maincpu->rsv().set_nop();
m_maincpu->p6h().set(FUNC(tx0_state::tx0_io_p6h));
m_maincpu->p7h().set(FUNC(tx0_state::tx0_io_p7h));
m_maincpu->sel().set(FUNC(tx0_state::tx0_sel));
m_maincpu->res().set(FUNC(tx0_state::tx0_io_reset_callback));
m_maincpu->set_addrmap(AS_PROGRAM, &tx0_state::tx0_64kw_map);
/* dummy interrupt: handles input */
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", tx0_state, tx0_interrupt)
m_maincpu->set_vblank_int("screen", FUNC(tx0_state::tx0_interrupt));
/* video hardware (includes the control panel and typewriter output) */
MCFG_SCREEN_ADD("screen", RASTER)

92
src/mame/drivers/vc4000.cpp
View File

@ -526,80 +526,78 @@ static void vc4000_cart(device_slot_interface &device)
}
MACHINE_CONFIG_START(vc4000_state::vc4000)
void vc4000_state::vc4000(machine_config &config)
{
/* basic machine hardware */
// MCFG_DEVICE_ADD("maincpu", S2650, 865000) /* 3550000/4, 3580000/3, 4430000/3 */
MCFG_DEVICE_ADD("maincpu", S2650, 3546875/4)
MCFG_DEVICE_PROGRAM_MAP(vc4000_mem)
MCFG_S2650_SENSE_INPUT(READLINE(*this, vc4000_state, vc4000_vsync_r))
MCFG_DEVICE_PERIODIC_INT_DRIVER(vc4000_state, vc4000_video_line, 312*53) // GOLF needs this exact value
S2650(config, m_maincpu, 3546875/4);
m_maincpu->set_addrmap(AS_PROGRAM, &vc4000_state::vc4000_mem);
m_maincpu->sense_handler().set(FUNC(vc4000_state::vc4000_vsync_r));
m_maincpu->set_periodic_int(FUNC(vc4000_state::vc4000_video_line), attotime::from_hz(312*53)); // GOLF needs this exact value
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE(50)
MCFG_SCREEN_SIZE(226, 312)
MCFG_SCREEN_VISIBLE_AREA(8, 184, 0, 269)
MCFG_SCREEN_UPDATE_DRIVER(vc4000_state, screen_update_vc4000)
MCFG_SCREEN_PALETTE("palette")
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(50);
m_screen->set_size(226, 312);
m_screen->set_visarea(8, 184, 0, 269);
m_screen->set_screen_update(FUNC(vc4000_state::screen_update_vc4000));
m_screen->set_palette("palette");
MCFG_PALETTE_ADD("palette", 8)
MCFG_PALETTE_INIT_OWNER(vc4000_state, vc4000)
PALETTE(config, "palette", 8).set_init(FUNC(vc4000_state::palette_init_vc4000));
/* sound hardware */
SPEAKER(config, "mono").front_center();
MCFG_DEVICE_ADD("custom", VC4000_SND, 0)
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
VC4000_SND(config, m_custom, 0).add_route(ALL_OUTPUTS, "mono", 0.50);
/* quickload */
MCFG_QUICKLOAD_ADD("quickload", vc4000_state, vc4000, "pgm,tvc", 0)
quickload_image_device &quickload(QUICKLOAD(config, "quickload", 0));
quickload.set_handler(snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(vc4000_state, vc4000), this), "pgm,tvc", 0);
/* cartridge */
MCFG_VC4000_CARTRIDGE_ADD("cartslot", vc4000_cart, nullptr)
VC4000_CART_SLOT(config, "cartslot", vc4000_cart, nullptr);
/* software lists */
MCFG_SOFTWARE_LIST_ADD("cart_list", "vc4000")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_original("vc4000");
}
MACHINE_CONFIG_START(vc4000_state::cx3000tc)
void vc4000_state::cx3000tc(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_REMOVE("cart_list")
MCFG_SOFTWARE_LIST_ADD("cart_list", "cx3000tc")
MACHINE_CONFIG_END
SOFTWARE_LIST(config.replace(), "cart_list").set_original("cx3000tc");
}
MACHINE_CONFIG_START(vc4000_state::mpu1000)
void vc4000_state::mpu1000(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_REMOVE("cart_list")
MCFG_SOFTWARE_LIST_ADD("cart_list", "mpu1000")
MACHINE_CONFIG_END
SOFTWARE_LIST(config.replace(), "cart_list").set_original("mpu1000");
}
MACHINE_CONFIG_START(vc4000_state::database)
void vc4000_state::database(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_REMOVE("cart_list")
MCFG_SOFTWARE_LIST_ADD("cart_list", "database")
MACHINE_CONFIG_END
SOFTWARE_LIST(config.replace(), "cart_list").set_original("database");
}
MACHINE_CONFIG_START(vc4000_state::rwtrntcs)
void vc4000_state::rwtrntcs(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_REMOVE("cart_list")
MCFG_SOFTWARE_LIST_ADD("cart_list", "rwtrntcs")
MACHINE_CONFIG_END
SOFTWARE_LIST(config.replace(), "cart_list").set_original("rwtrntcs");
}
MACHINE_CONFIG_START(vc4000_state::h21)
void vc4000_state::h21(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_REMOVE("cartslot")
MCFG_H21_CARTRIDGE_ADD("cartslot", vc4000_cart, nullptr)
H21_CART_SLOT(config.replace(), "cartslot", vc4000_cart, nullptr);
SOFTWARE_LIST(config.replace(), "cart_list").set_original("h21");
}
MCFG_DEVICE_REMOVE("cart_list")
MCFG_SOFTWARE_LIST_ADD("cart_list", "h21")
MACHINE_CONFIG_END
MACHINE_CONFIG_START(vc4000_state::elektor)
void vc4000_state::elektor(machine_config &config)
{
vc4000(config);
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(elektor_mem)
MCFG_CASSETTE_ADD( "cassette" )
m_maincpu->set_addrmap(AS_PROGRAM, &vc4000_state::elektor_mem);
CASSETTE(config, "cassette");
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
MACHINE_CONFIG_END
}
ROM_START( vc4000 )

36
src/mame/drivers/zac_1.cpp
View File

@ -71,7 +71,7 @@ private:
uint8_t m_input_line;
virtual void machine_reset() override;
virtual void machine_start() override { m_digits.resolve(); }
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_shared_ptr<uint8_t> m_p_ram;
output_finder<78> m_digits;
};
@ -259,25 +259,27 @@ TIMER_DEVICE_CALLBACK_MEMBER(zac_1_state::zac_1_outtimer)
}
}
MACHINE_CONFIG_START(zac_1_state::zac_1)
void zac_1_state::zac_1(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 6000000/2) // no xtal, just 2 chips forming a random oscillator
MCFG_DEVICE_PROGRAM_MAP(zac_1_map)
MCFG_DEVICE_IO_MAP(zac_1_io)
MCFG_DEVICE_DATA_MAP(zac_1_data)
MCFG_S2650_SENSE_INPUT(READLINE(*this, zac_1_state, serial_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, zac_1_state, serial_w))
S2650(config, m_maincpu, 6000000/2); // no xtal, just 2 chips forming a random oscillator
m_maincpu->set_addrmap(AS_PROGRAM, &zac_1_state::zac_1_map);
m_maincpu->set_addrmap(AS_IO, &zac_1_state::zac_1_io);
m_maincpu->set_addrmap(AS_DATA, &zac_1_state::zac_1_data);
m_maincpu->sense_handler().set(FUNC(zac_1_state::serial_r));
m_maincpu->flag_handler().set(FUNC(zac_1_state::serial_w));
NVRAM(config, "ram", nvram_device::DEFAULT_ALL_0);
MCFG_TIMER_DRIVER_ADD_PERIODIC("zac_1_inttimer", zac_1_state, zac_1_inttimer, attotime::from_hz(200))
MCFG_TIMER_DRIVER_ADD_PERIODIC("zac_1_outtimer", zac_1_state, zac_1_outtimer, attotime::from_hz(187500))
TIMER(config, "zac_1_inttimer").configure_periodic(FUNC(zac_1_state::zac_1_inttimer), attotime::from_hz(200));
TIMER(config, "zac_1_outtimer").configure_periodic(FUNC(zac_1_state::zac_1_outtimer), attotime::from_hz(187500));
/* Video */
config.set_default_layout(layout_zac_1);
/* Sound */
genpin_audio(config);
MACHINE_CONFIG_END
}
/*************************** LOCOMOTION ********************************/
@ -306,15 +308,15 @@ READ8_MEMBER( zac_1_state::reset_int_r )
return 0;
}
MACHINE_CONFIG_START(zac_1_state::locomotp)
void zac_1_state::locomotp(machine_config &config)
{
zac_1(config);
/* basic machine hardware */
MCFG_DEVICE_MODIFY("maincpu")
MCFG_DEVICE_PROGRAM_MAP(locomotp_map)
MCFG_DEVICE_IO_MAP(locomotp_io)
MCFG_DEVICE_DATA_MAP(locomotp_data)
m_maincpu->set_addrmap(AS_PROGRAM, &zac_1_state::locomotp_map);
m_maincpu->set_addrmap(AS_IO, &zac_1_state::locomotp_io);
m_maincpu->set_addrmap(AS_DATA, &zac_1_state::locomotp_data);
// also has sound cpu
MACHINE_CONFIG_END
}
/*--------------------------------

23
src/mame/drivers/zac_2.cpp
View File

@ -45,7 +45,7 @@ private:
uint8_t m_out_offs;
virtual void machine_reset() override;
virtual void machine_start() override { m_digits.resolve(); }
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_shared_ptr<uint8_t> m_p_ram;
required_ioport_array<6> m_row;
output_finder<78> m_digits;
@ -211,22 +211,23 @@ TIMER_DEVICE_CALLBACK_MEMBER(zac_2_state::zac_2_outtimer)
}
}
MACHINE_CONFIG_START(zac_2_state::zac_2)
void zac_2_state::zac_2(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", S2650, 6000000/2)
MCFG_DEVICE_PROGRAM_MAP(zac_2_map)
MCFG_DEVICE_IO_MAP(zac_2_io)
MCFG_DEVICE_DATA_MAP(zac_2_data)
MCFG_S2650_SENSE_INPUT(READLINE(*this, zac_2_state, serial_r))
MCFG_S2650_FLAG_OUTPUT(WRITELINE(*this, zac_2_state, serial_w))
S2650(config, m_maincpu, 6000000/2);
m_maincpu->set_addrmap(AS_PROGRAM, &zac_2_state::zac_2_map);
m_maincpu->set_addrmap(AS_IO, &zac_2_state::zac_2_io);
m_maincpu->set_addrmap(AS_DATA, &zac_2_state::zac_2_data);
m_maincpu->sense_handler().set(FUNC(zac_2_state::serial_r));
m_maincpu->flag_handler().set(FUNC(zac_2_state::serial_w));
NVRAM(config, "ram", nvram_device::DEFAULT_ALL_0);
MCFG_TIMER_DRIVER_ADD_PERIODIC("zac_2_inttimer", zac_2_state, zac_2_inttimer, attotime::from_hz(200))
MCFG_TIMER_DRIVER_ADD_PERIODIC("zac_2_outtimer", zac_2_state, zac_2_outtimer, attotime::from_hz(187500))
TIMER(config, "zac_2_inttimer").configure_periodic(FUNC(zac_2_state::zac_2_inttimer), attotime::from_hz(200));
TIMER(config, "zac_2_outtimer").configure_periodic(FUNC(zac_2_state::zac_2_outtimer), attotime::from_hz(187500));
/* Video */
config.set_default_layout(layout_zac_2);
MACHINE_CONFIG_END
}
/*--------------------------------
/ Black Belt (03/86)

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

@ -130,7 +130,7 @@ private:
required_ioport m_controller2_extra;
required_ioport m_joysticks;
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device<arcadia_cart_slot_device> m_cart;
required_device<gfxdecode_device> m_gfxdecode;
required_device<palette_device> m_palette;

11
src/mame/includes/cvs.h
View File

@ -10,10 +10,11 @@
#pragma once
#include "sound/dac.h"
#include "sound/tms5110.h"
#include "cpu/s2650/s2650.h"
#include "machine/gen_latch.h"
#include "machine/s2636.h"
#include "sound/dac.h"
#include "sound/tms5110.h"
#include "emupal.h"
#include "screen.h"
@ -137,9 +138,9 @@ protected:
uint16_t m_speech_rom_bit_address;
/* devices */
required_device<cpu_device> m_maincpu;
optional_device<cpu_device> m_audiocpu;
optional_device<cpu_device> m_speechcpu;
required_device<s2650_device> m_maincpu;
optional_device<s2650_device> m_audiocpu;
optional_device<s2650_device> m_speechcpu;
optional_device<dac_byte_interface> m_dac2;
optional_device<dac_bit_interface> m_dac3;
optional_device<tms5110_device> m_tms5110;

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

@ -307,7 +307,7 @@ public:
void ckongmc_map(address_map &map);
void dkongjrm_map(address_map &map);
void dkongjrmc_map(address_map &map);
void drivfrcg(address_map &map);
void drivfrcg_program(address_map &map);
void drivfrcg_io(address_map &map);
void galaxold_map(address_map &map);
void guttang_map(address_map &map);

4
src/mame/includes/hp48.h
View File

@ -12,8 +12,8 @@
#pragma once
#include "cpu/saturn/saturn.h"
#include "machine/hp48_port.h"
#include "sound/dac.h"
#include "emupal.h"
#include "screen.h"
@ -127,7 +127,7 @@ private:
void hp48_common(machine_config &config);
void hp48(address_map &map);
required_device<cpu_device> m_maincpu;
required_device<saturn_device> m_maincpu;
required_device<dac_bit_interface> m_dac;
required_device<palette_device> m_palette;
required_device<screen_device> m_screen;

4
src/mame/includes/laserbat.h
View File

@ -12,6 +12,8 @@
#include "audio/zaccaria.h"
#include "cpu/s2650/s2650.h"
#include "machine/6821pia.h"
#include "machine/pla.h"
#include "machine/s2636.h"
@ -105,7 +107,7 @@ protected:
required_ioport m_row2;
// main CPU device
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
// video devices
required_device<screen_device> m_screen;

3
src/mame/includes/malzak.h
View File

@ -10,6 +10,7 @@
#pragma once
#include "cpu/s2650/s2650.h"
#include "machine/s2636.h"
#include "video/saa5050.h"
#include "emupal.h"
@ -39,7 +40,7 @@ protected:
private:
/* devices */
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device_array<s2636_device, 2> m_s2636;
required_device<saa5050_device> m_trom;
required_shared_ptr<uint8_t> m_videoram;

19
src/mame/includes/quasar.h
View File

@ -22,10 +22,10 @@ public:
void quasar(machine_config &config);
private:
std::unique_ptr<uint8_t[]> m_effectram;
uint8_t m_effectcontrol;
uint8_t m_page;
uint8_t m_io_page;
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void video_start() override;
DECLARE_WRITE8_MEMBER(video_page_select_w);
DECLARE_WRITE8_MEMBER(io_page_select_w);
DECLARE_WRITE8_MEMBER(quasar_video_w);
@ -34,17 +34,20 @@ private:
DECLARE_WRITE8_MEMBER(quasar_sh_command_w);
DECLARE_READ8_MEMBER(quasar_sh_command_r);
DECLARE_READ_LINE_MEMBER(audio_t1_r);
DECLARE_MACHINE_START(quasar);
DECLARE_MACHINE_RESET(quasar);
DECLARE_VIDEO_START(quasar);
DECLARE_PALETTE_INIT(quasar);
uint32_t screen_update_quasar(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(quasar_interrupt);
void quasar(address_map &map);
void quasar_program(address_map &map);
void quasar_data(address_map &map);
void quasar_io(address_map &map);
void sound_map(address_map &map);
void sound_portmap(address_map &map);
std::unique_ptr<uint8_t[]> m_effectram;
uint8_t m_effectcontrol;
uint8_t m_page;
uint8_t m_io_page;
};
#endif // MAME_INCLUDES_QUASAR_H

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

@ -141,7 +141,7 @@ private:
void elektor_mem(address_map &map);
void vc4000_mem(address_map &map);
required_device<cpu_device> m_maincpu;
required_device<s2650_device> m_maincpu;
required_device<screen_device> m_screen;
optional_device<cassette_image_device> m_cassette;
required_device<vc4000_cart_slot_device> m_cart;

2
src/mame/video/quasar.cpp
View File

@ -89,7 +89,7 @@ PALETTE_INIT_MEMBER(quasar_state,quasar)
}
VIDEO_START_MEMBER(quasar_state,quasar)
void quasar_state::video_start()
{
m_effectram = std::make_unique<uint8_t[]>(0x400);