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

sm510, sm8500, sparc, superfx, t11: Removed MCFG, nw

Browse Source
This commit is contained in:
mooglyguy 2018-12-07 15:48:49 +01:00
parent e754e43586
commit 97e3929757
27 changed files with 778 additions and 814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/devices/bus/snes/sfx.cpp
View File

@ -86,11 +86,12 @@ WRITE_LINE_MEMBER(sns_rom_superfx_device::snes_extern_irq_w)
}
MACHINE_CONFIG_START(sns_rom_superfx_device::device_add_mconfig)
MCFG_DEVICE_ADD("superfx", SUPERFX, 21480000) /* 21.48MHz */
MCFG_DEVICE_PROGRAM_MAP(sfx_map)
MCFG_SUPERFX_OUT_IRQ(WRITELINE(*this, sns_rom_superfx_device, snes_extern_irq_w)) /* IRQ line from cart */
MACHINE_CONFIG_END
void sns_rom_superfx_device::device_add_mconfig(machine_config &config)
{
SUPERFX(config, m_superfx, 21480000); /* 21.48MHz */
m_superfx->set_addrmap(AS_PROGRAM, &sns_rom_superfx_device::sfx_map);
m_superfx->irq().set(FUNC(sns_rom_superfx_device::snes_extern_irq_w)); /* IRQ line from cart */
}
READ8_MEMBER( sns_rom_superfx_device::chip_read )
{

15
src/devices/cpu/sm510/sm500.h
View File

@ -14,15 +14,6 @@
#include "sm510.h"
// I/O ports setup
// LCD segment outputs: H1/2 as a0, O group as a1-a4, O data as d0-d3
#define MCFG_SM500_WRITE_O_CB(_devcb) \
downcast<sm500_device &>(*device).set_write_o_callback(DEVCB_##_devcb);
// see sm510.h for ACL, K, R, alpha, beta
// pinout reference
/*
@ -79,8 +70,10 @@ class sm500_device : public sm510_base_device
public:
sm500_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock = 32768);
// configuration helpers
template <class Object> devcb_base &set_write_o_callback(Object &&cb) { return m_write_o.set_callback(std::forward<Object>(cb)); }
// see sm510.h for ACL, K, R, alpha, beta
// LCD segment outputs: H1/2 as a0, O group as a1-a4, O data as d0-d3
auto write_o() { return m_write_o.bind(); }
protected:
sm500_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, int stack_levels, int o_pins, int prgwidth, address_map_constructor program, int datawidth, address_map_constructor data);

79
src/devices/cpu/sm510/sm510.h
View File

@ -13,55 +13,12 @@
// I/O ports setup
// 4-bit K input port (pull-down)
#define MCFG_SM510_READ_K_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_read_k_callback(DEVCB_##_devcb);
// when in halt state, any K input going High can wake up the CPU,
// driver is required to use set_input_line(SM510_INPUT_LINE_K, state)
#define SM510_INPUT_LINE_K 0
// 1-bit BA(aka alpha) input pin (pull-up)
#define MCFG_SM510_READ_BA_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_read_ba_callback(DEVCB_##_devcb);
// 1-bit B(beta) input pin (pull-up)
#define MCFG_SM510_READ_B_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_read_b_callback(DEVCB_##_devcb);
// 8-bit S strobe output port
#define MCFG_SM510_WRITE_S_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_s_callback(DEVCB_##_devcb);
// 1/2/4-bit R (buzzer/melody) output port
#define MCFG_SM510_WRITE_R_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_r_callback(DEVCB_##_devcb);
// For SM510, SM500, SM5A, R port output is selected with a mask option,
// either from the divider or direct contol. Documented options are:
// SM510/SM5A: control, 2(4096Hz meant for alarm sound)
// SM500: 14, 11, 3 (divider f1, f4, f12)
#define MCFG_SM510_R_MASK_OPTION(_bit) \
downcast<sm510_base_device &>(*device).set_r_mask_option(_bit);
#define SM510_R_CONTROL_OUTPUT -1
// LCD segment outputs: H1-4 as offset(low), a/b/c 1-16 as data d0-d15
#define MCFG_SM510_WRITE_SEGA_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_sega_callback(DEVCB_##_devcb);
#define MCFG_SM510_WRITE_SEGB_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_segb_callback(DEVCB_##_devcb);
#define MCFG_SM510_WRITE_SEGC_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_segc_callback(DEVCB_##_devcb);
// LCD bs output: same as above, but only up to 2 bits used
#define MCFG_SM510_WRITE_SEGBS_CB(_devcb) \
downcast<sm510_base_device &>(*device).set_write_segbs_callback(DEVCB_##_devcb);
// LCD output lazy combination
#define MCFG_SM510_WRITE_SEGS_CB(_devcb) \
MCFG_SM510_WRITE_SEGA_CB(_devcb) \
MCFG_SM510_WRITE_SEGB_CB(_devcb) \
MCFG_SM510_WRITE_SEGC_CB(_devcb) \
MCFG_SM510_WRITE_SEGBS_CB(_devcb)
// ACL input pin
#define SM510_INPUT_LINE_ACL INPUT_LINE_RESET
@ -125,18 +82,34 @@ public:
, m_write_r(*this)
{ }
// configuration helpers
template <class Object> devcb_base &set_read_k_callback(Object &&cb) { return m_read_k.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_read_ba_callback(Object &&cb) { return m_read_ba.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_read_b_callback(Object &&cb) { return m_read_b.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_write_s_callback(Object &&cb) { return m_write_s.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_write_r_callback(Object &&cb) { return m_write_r.set_callback(std::forward<Object>(cb)); }
// For SM510, SM500, SM5A, R port output is selected with a mask option,
// either from the divider or direct contol. Documented options are:
// SM510/SM5A: control, 2(4096Hz meant for alarm sound)
// SM500: 14, 11, 3 (divider f1, f4, f12)
void set_r_mask_option(int bit) { m_r_mask_option = bit; }
template <class Object> devcb_base &set_write_sega_callback(Object &&cb) { return m_write_sega.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_write_segb_callback(Object &&cb) { return m_write_segb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_write_segc_callback(Object &&cb) { return m_write_segc.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_write_segbs_callback(Object &&cb) { return m_write_segbs.set_callback(std::forward<Object>(cb)); }
// 4-bit K input port (pull-down)
auto read_k() { return m_read_k.bind(); }
// 1-bit BA(aka alpha) input pin (pull-up)
auto read_ba() { return m_read_ba.bind(); }
// 1-bit B(beta) input pin (pull-up)
auto read_b() { return m_read_b.bind(); }
// 8-bit S strobe output port
auto write_s() { return m_write_s.bind(); }
// 1/2/4-bit R (buzzer/melody) output port
auto write_r() { return m_write_r.bind(); }
// LCD segment outputs: H1-4 as offset(low), a/b/c 1-16 as data d0-d15
auto write_sega() { return m_write_sega.bind(); }
auto write_segb() { return m_write_segb.bind(); }
auto write_segc() { return m_write_segc.bind(); }
// LCD bs output: same as above, but only up to 2 bits used
auto write_segbs() { return m_write_segbs.bind(); }
protected:
// device-level overrides

10
src/devices/cpu/sm8500/sm8500.h
View File

@ -5,12 +5,6 @@
#pragma once
#define MCFG_SM8500_DMA_CB(_devcb) \
downcast<sm8500_cpu_device &>(*device).set_dma_cb(DEVCB_##_devcb);
#define MCFG_SM8500_TIMER_CB(_devcb) \
downcast<sm8500_cpu_device &>(*device).set_timer_cb(DEVCB_##_devcb);
enum
{
/* "main" 16 bit register */
@ -29,8 +23,8 @@ public:
sm8500_cpu_device(const machine_config &mconfig, const char *_tag, device_t *_owner, uint32_t _clock);
// configuration helpers
template <class Object> devcb_base &set_dma_cb(Object &&cb) { return m_dma_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_timer_cb(Object &&cb) { return m_timer_func.set_callback(std::forward<Object>(cb)); }
auto dma_cb() { return m_dma_func.bind(); }
auto timer_cb() { return m_timer_func.bind(); }
/* interrupts */
static constexpr int ILL_INT = 0;

4
src/devices/cpu/sparc/sparc.h
View File

@ -19,10 +19,6 @@
#include <map>
#endif
// TODO: when there are more SPARC CPUs, move setter to a base class
#define MCFG_SPARC_ADD_ASI_DESC(desc) \
downcast<mb86901_device &>(*device).add_asi_desc([](sparc_disassembler *dasm) { dasm->add_asi_desc(desc); });
class mb86901_device : public cpu_device, public sparc_mmu_host_interface, protected sparc_disassembler::config
{
public:

6
src/devices/cpu/superfx/superfx.h
View File

@ -89,10 +89,6 @@ enum
#define SUPERFX_CFGR_MS0 0x20 // MS0
#define MCFG_SUPERFX_OUT_IRQ(_devcb) \
downcast<superfx_device &>(*device).set_out_irq_func(DEVCB_##_devcb);
class superfx_device : public cpu_device, public superfx_disassembler::config
{
public:
@ -100,7 +96,7 @@ public:
superfx_device(const machine_config &mconfig, const char *_tag, device_t *_owner, uint32_t _clock);
// configuration helpers
template <class Object> devcb_base &set_out_irq_func(Object &&cb) { return m_out_irq_func.set_callback(std::forward<Object>(cb)); }
auto irq() { return m_out_irq_func.bind(); }
uint8_t mmio_read(uint32_t addr);
void mmio_write(uint32_t addr, uint8_t data);

8
src/devices/cpu/t11/t11.h
View File

@ -28,12 +28,6 @@ enum
#define T11_TRAP 0x01C /* TRAP instruction vector */
#define MCFG_T11_INITIAL_MODE(_mode) \
downcast<t11_device &>(*device).set_initial_mode(_mode);
#define MCFG_T11_RESET(_devcb) \
downcast<t11_device &>(*device).set_out_reset_func(DEVCB_##_devcb);
class t11_device : public cpu_device
{
public:
@ -42,7 +36,7 @@ public:
// configuration helpers
void set_initial_mode(const uint16_t mode) { c_initial_mode = mode; }
template <class Object> devcb_base &set_out_reset_func(Object &&cb) { return m_out_reset_func.set_callback(std::forward<Object>(cb)); }
auto out_reset() { return m_out_reset_func.bind(); }
protected:
t11_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);

6
src/mame/drivers/atarisy2.cpp
View File

@ -1185,9 +1185,9 @@ GFXDECODE_END
MACHINE_CONFIG_START(atarisy2_state::atarisy2)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", T11, MASTER_CLOCK/2)
MCFG_T11_INITIAL_MODE(0x36ff) /* initial mode word has DAL15,14,11,8 pulled low */
MCFG_DEVICE_PROGRAM_MAP(main_map)
T11(config, m_maincpu, MASTER_CLOCK/2);
m_maincpu->set_initial_mode(0x36ff); /* initial mode word has DAL15,14,11,8 pulled low */
m_maincpu->set_addrmap(AS_PROGRAM, &atarisy2_state::main_map);
M6502(config, m_audiocpu, SOUND_CLOCK/8);
m_audiocpu->set_addrmap(AS_PROGRAM, &atarisy2_state::sound_map);

39
src/mame/drivers/bk.cpp
View File

@ -12,7 +12,6 @@
#include "emu.h"
#include "includes/bk.h"
#include "cpu/t11/t11.h"
#include "sound/wave.h"
#include "formats/rk_cas.h"
@ -165,34 +164,34 @@ static INPUT_PORTS_START( bk0010 )
INPUT_PORTS_END
MACHINE_CONFIG_START(bk_state::bk0010)
void bk_state::bk0010(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", T11, 3000000)
MCFG_T11_INITIAL_MODE(0x36ff) /* initial mode word has DAL15,14,11,8 pulled low */
MCFG_DEVICE_PROGRAM_MAP(bk0010_mem)
MCFG_DEVICE_IRQ_ACKNOWLEDGE_DRIVER(bk_state,bk0010_irq_callback)
T11(config, m_maincpu, 3000000);
m_maincpu->set_initial_mode(0x36ff); /* initial mode word has DAL15,14,11,8 pulled low */
m_maincpu->set_addrmap(AS_PROGRAM, &bk_state::bk0010_mem);
m_maincpu->set_irq_acknowledge_callback(FUNC(bk_state::bk0010_irq_callback));
/* 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(512, 256)
MCFG_SCREEN_VISIBLE_AREA(0, 512-1, 0, 256-1)
MCFG_SCREEN_UPDATE_DRIVER(bk_state, screen_update_bk0010)
MCFG_SCREEN_PALETTE("palette")
MCFG_PALETTE_ADD_MONOCHROME("palette")
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(512, 256);
screen.set_visarea(0, 512-1, 0, 256-1);
screen.set_screen_update(FUNC(bk_state::screen_update_bk0010));
screen.set_palette("palette");
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
SPEAKER(config, "mono").front_center();
WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25);
MCFG_CASSETTE_ADD( "cassette" )
MCFG_CASSETTE_DEFAULT_STATE(CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED)
MCFG_CASSETTE_INTERFACE("bk0010_cass")
CASSETTE(config, m_cassette);
m_cassette->set_default_state((cassette_state)(CASSETTE_STOPPED | CASSETTE_SPEAKER_ENABLED | CASSETTE_MOTOR_ENABLED));
m_cassette->set_interface("bk0010_cass");
MCFG_SOFTWARE_LIST_ADD("cass_list","bk0010")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cass_list").set_original("bk0010");
}
MACHINE_CONFIG_START(bk_state::bk0010fd)
bk0010(config);

40
src/mame/drivers/dct11em.cpp
View File

@ -18,17 +18,21 @@ class dct11em_state : public driver_device
{
public:
dct11em_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) ,
m_maincpu(*this, "maincpu") { }
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
{ }
void dct11em(machine_config &config);
private:
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update_dct11em(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<cpu_device> m_maincpu;
void dct11em_mem(address_map &map);
uint32_t screen_update_dct11em(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<t11_device> m_maincpu;
};
void dct11em_state::dct11em_mem(address_map &map)
@ -58,24 +62,24 @@ uint32_t dct11em_state::screen_update_dct11em(screen_device &screen, bitmap_ind1
}
MACHINE_CONFIG_START(dct11em_state::dct11em)
void dct11em_state::dct11em(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",T11, 7500000) // 7.5MHz XTAL
MCFG_T11_INITIAL_MODE(0x1403) /* according to specs */
MCFG_DEVICE_PROGRAM_MAP(dct11em_mem)
T11(config, m_maincpu, 7500000); // 7.5MHz XTAL
m_maincpu->set_initial_mode(0x1403); /* according to specs */
m_maincpu->set_addrmap(AS_PROGRAM, &dct11em_state::dct11em_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(dct11em_state, screen_update_dct11em)
MCFG_SCREEN_PALETTE("palette")
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(dct11em_state::screen_update_dct11em));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
/* ROM definition */
ROM_START( dct11em )

8
src/mame/drivers/dvk_kcgd.cpp
View File

@ -116,7 +116,7 @@ private:
} m_video;
std::unique_ptr<uint32_t[]> m_videoram;
required_device<cpu_device> m_maincpu;
required_device<k1801vm2_device> m_maincpu;
// required_device<ms7004_device> m_ms7004;
required_device<palette_device> m_palette;
required_device<screen_device> m_screen;
@ -347,9 +347,9 @@ static GFXDECODE_START( gfx_kcgd )
GFXDECODE_END
MACHINE_CONFIG_START(kcgd_state::kcgd)
MCFG_DEVICE_ADD("maincpu", K1801VM2, XTAL(30'800'000)/4)
MCFG_DEVICE_PROGRAM_MAP(kcgd_mem)
MCFG_T11_INITIAL_MODE(0100000)
K1801VM2(config, m_maincpu, XTAL(30'800'000)/4);
m_maincpu->set_addrmap(AS_PROGRAM, &kcgd_state::kcgd_mem);
m_maincpu->set_initial_mode(0100000);
MCFG_TIMER_DRIVER_ADD_PERIODIC("scantimer", kcgd_state, scanline_callback, attotime::from_hz(50*28*11)) // XXX verify
MCFG_TIMER_START_DELAY(attotime::from_hz(XTAL(30'800'000)/KCGD_HORZ_START))

35
src/mame/drivers/galgame.cpp
View File

@ -59,7 +59,7 @@ private:
uint32_t screen_update_galaxygame(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(galaxygame_irq);
IRQ_CALLBACK_MEMBER(galaxygame_irq_callback);
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
required_device<palette_device> m_palette;
void galaxygame_map(address_map &map);
};
@ -325,26 +325,25 @@ void galaxygame_state::machine_reset()
m_interrupt = 0;
}
MACHINE_CONFIG_START(galaxygame_state::galaxygame)
MCFG_DEVICE_ADD("maincpu", T11, 3000000 )
MCFG_DEVICE_PROGRAM_MAP(galaxygame_map)
MCFG_T11_INITIAL_MODE(5 << 13)
MCFG_DEVICE_PERIODIC_INT_DRIVER(galaxygame_state, galaxygame_irq, 60)
MCFG_DEVICE_IRQ_ACKNOWLEDGE_DRIVER(galaxygame_state,galaxygame_irq_callback)
void galaxygame_state::galaxygame(machine_config &config)
{
T11(config, m_maincpu, 3000000);
m_maincpu->set_addrmap(AS_PROGRAM, &galaxygame_state::galaxygame_map);
m_maincpu->set_initial_mode(5 << 13);
m_maincpu->set_irq_acknowledge_callback(FUNC(galaxygame_state::galaxygame_irq_callback));
m_maincpu->set_periodic_int(FUNC(galaxygame_state::galaxygame_irq), 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(512, 512)
MCFG_SCREEN_VISIBLE_AREA(0, 511, 0, 511)
MCFG_SCREEN_UPDATE_DRIVER(galaxygame_state, screen_update_galaxygame)
MCFG_SCREEN_PALETTE("palette")
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
screen.set_size(512, 512);
screen.set_visarea(0, 511, 0, 511);
screen.set_screen_update(FUNC(galaxygame_state::screen_update_galaxygame));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
ROM_START(galgame)
// Original Galaxy Game listing, the one used in the 2nd hardware revision (blue dual cabinet)

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

@ -257,11 +257,11 @@ INTERRUPT_GEN_MEMBER(gamecom_state::gamecom_interrupt)
MACHINE_CONFIG_START(gamecom_state::gamecom)
/* basic machine hardware */
MCFG_DEVICE_ADD( "maincpu", SM8500, XTAL(11'059'200)/2 ) /* actually it's an sm8521 microcontroller containing an sm8500 cpu */
MCFG_DEVICE_PROGRAM_MAP( gamecom_mem_map)
MCFG_SM8500_DMA_CB( WRITE8( *this, gamecom_state, gamecom_handle_dma ) )
MCFG_SM8500_TIMER_CB( WRITE8( *this, gamecom_state, gamecom_update_timers ) )
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", gamecom_state, gamecom_interrupt)
SM8500(config, m_maincpu, XTAL(11'059'200)/2); /* actually it's an sm8521 microcontroller containing an sm8500 cpu */
m_maincpu->set_addrmap(AS_PROGRAM, &gamecom_state::gamecom_mem_map);
m_maincpu->dma_cb().set(FUNC(gamecom_state::gamecom_handle_dma));
m_maincpu->timer_cb().set(FUNC(gamecom_state::gamecom_update_timers));
m_maincpu->set_vblank_int("screen", FUNC(gamecom_state::gamecom_interrupt));
MCFG_QUANTUM_TIME(attotime::from_hz(60))

1086
src/mame/drivers/hh_sm510.cpp
View File

File diff suppressed because it is too large Load Diff

35
src/mame/drivers/mk85.cpp
View File

@ -39,9 +39,12 @@ public:
private:
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update_mk85(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<cpu_device> m_maincpu;
void mk85_mem(address_map &map);
uint32_t screen_update_mk85(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<k1801vm2_device> m_maincpu;
};
@ -70,24 +73,24 @@ uint32_t mk85_state::screen_update_mk85(screen_device &screen, bitmap_ind16 &bit
return 0;
}
MACHINE_CONFIG_START(mk85_state::mk85)
void mk85_state::mk85(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", K1801VM2, XTAL(4'000'000))
MCFG_T11_INITIAL_MODE(0)
MCFG_DEVICE_PROGRAM_MAP(mk85_mem)
K1801VM2(config, m_maincpu, XTAL(4'000'000));
m_maincpu->set_initial_mode(0);
m_maincpu->set_addrmap(AS_PROGRAM, &mk85_state::mk85_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(mk85_state, screen_update_mk85)
MCFG_SCREEN_PALETTE("palette")
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(mk85_state::screen_update_mk85));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
/* ROM definition */
ROM_START( mk85 )

35
src/mame/drivers/mk90.cpp
View File

@ -34,9 +34,12 @@ public:
private:
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update_mk90(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<cpu_device> m_maincpu;
void mk90_mem(address_map &map);
uint32_t screen_update_mk90(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<k1801vm2_device> m_maincpu;
};
@ -73,24 +76,24 @@ uint32_t mk90_state::screen_update_mk90(screen_device &screen, bitmap_ind16 &bit
return 0;
}
MACHINE_CONFIG_START(mk90_state::mk90)
void mk90_state::mk90(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", K1801VM2, XTAL(4'000'000))
MCFG_T11_INITIAL_MODE(0x8000)
MCFG_DEVICE_PROGRAM_MAP(mk90_mem)
K1801VM2(config, m_maincpu, XTAL(4'000'000));
m_maincpu->set_initial_mode(0x8000);
m_maincpu->set_addrmap(AS_PROGRAM, &mk90_state::mk90_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(mk90_state, screen_update_mk90)
MCFG_SCREEN_PALETTE("palette")
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(mk90_state::screen_update_mk90));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
/* ROM definition */
ROM_START( mk90 )

8
src/mame/drivers/ms0515.cpp
View File

@ -113,7 +113,7 @@ private:
void irq_encoder(int irq, int state);
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu; // actual CPU is T11 clone, KR1807VM1
required_device<ram_device> m_ram;
required_device<kr1818vg93_device> m_fdc;
required_device<floppy_image_device> m_floppy0;
@ -524,9 +524,9 @@ WRITE_LINE_MEMBER(ms0515_state::irq11_w)
MACHINE_CONFIG_START(ms0515_state::ms0515)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", T11, XTAL(15'000'000) / 2) // actual CPU is T11 clone, KR1807VM1
MCFG_T11_INITIAL_MODE(0xf2ff)
MCFG_DEVICE_PROGRAM_MAP(ms0515_mem)
T11(config, m_maincpu, XTAL(15'000'000) / 2); // actual CPU is T11 clone, KR1807VM1
m_maincpu->set_initial_mode(0xf2ff);
m_maincpu->set_addrmap(AS_PROGRAM, &ms0515_state::ms0515_mem);
/* video hardware -- 50 Hz refresh rate */
MCFG_SCREEN_ADD("screen", RASTER)

14
src/mame/drivers/pdp11.cpp
View File

@ -108,7 +108,7 @@ public:
void pdp11qb(machine_config &config);
private:
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
required_device<generic_terminal_device> m_terminal;
DECLARE_READ16_MEMBER( teletype_ctrl_r );
DECLARE_WRITE16_MEMBER( teletype_ctrl_w );
@ -355,10 +355,9 @@ void pdp11_state::kbd_put(u8 data)
MACHINE_CONFIG_START(pdp11_state::pdp11)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",T11, XTAL(4'000'000)) // Need proper CPU here
MCFG_T11_INITIAL_MODE(6 << 13)
MCFG_DEVICE_PROGRAM_MAP(pdp11_mem)
T11(config, m_maincpu, XTAL(4'000'000)); // Need proper CPU here
m_maincpu->set_initial_mode(6 << 13);
m_maincpu->set_addrmap(AS_PROGRAM, &pdp11_state::pdp11_mem);
/* video hardware */
MCFG_DEVICE_ADD(m_terminal, GENERIC_TERMINAL, 0)
@ -376,9 +375,8 @@ MACHINE_CONFIG_START(pdp11_state::pdp11qb)
pdp11(config);
MCFG_MACHINE_RESET_OVERRIDE(pdp11_state,pdp11qb)
MCFG_DEVICE_MODIFY("maincpu")
MCFG_T11_INITIAL_MODE(0 << 13)
MCFG_DEVICE_PROGRAM_MAP(pdp11qb_mem)
m_maincpu->set_initial_mode(0 << 13);
m_maincpu->set_addrmap(AS_PROGRAM, &pdp11_state::pdp11qb_mem);
MACHINE_CONFIG_END
/* ROM definition */

34
src/mame/drivers/rzone.cpp
View File

@ -245,11 +245,11 @@ INPUT_PORTS_END
MACHINE_CONFIG_START(rzone_state::rzbatfor)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", SM512) // no external XTAL
MCFG_SM510_WRITE_SEGS_CB(WRITE16(*this, hh_sm510_state, sm510_lcd_segment_w))
MCFG_SM510_READ_K_CB(READ8(*this, rzone_state, input_r))
MCFG_SM510_WRITE_S_CB(WRITE8(*this, rzone_state, t2_write_s))
MCFG_SM510_WRITE_R_CB(WRITE8(*this, rzone_state, t2_write_r))
SM512(config, m_maincpu); // no external XTAL
write_segs(config);
m_maincpu->read_k().set(FUNC(rzone_state::input_r));
m_maincpu->write_s().set(FUNC(rzone_state::t2_write_s));
m_maincpu->write_r().set(FUNC(rzone_state::t2_write_r));
/* video hardware */
MCFG_SCREEN_SVG_ADD("screen", "svg")
@ -270,12 +270,12 @@ MACHINE_CONFIG_END
MACHINE_CONFIG_START(rzone_state::rztoshden)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", SM510)
MCFG_SM510_R_MASK_OPTION(SM510_R_CONTROL_OUTPUT)
MCFG_SM510_WRITE_SEGS_CB(WRITE16(*this, hh_sm510_state, sm510_lcd_segment_w))
MCFG_SM510_READ_K_CB(READ8(*this, rzone_state, input_r))
MCFG_SM510_WRITE_S_CB(WRITE8(*this, rzone_state, t1_write_s))
MCFG_SM510_WRITE_R_CB(WRITE8(*this, rzone_state, t1_write_r))
SM510(config, m_maincpu);
m_maincpu->set_r_mask_option(SM510_R_CONTROL_OUTPUT);
write_segs(config);
m_maincpu->read_k().set(FUNC(rzone_state::input_r));
m_maincpu->write_s().set(FUNC(rzone_state::t1_write_s));
m_maincpu->write_r().set(FUNC(rzone_state::t1_write_r));
/* video hardware */
MCFG_SCREEN_SVG_ADD("screen", "svg")
@ -296,12 +296,12 @@ MACHINE_CONFIG_END
MACHINE_CONFIG_START(rzone_state::rzindy500)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", SM510) // no external XTAL
MCFG_SM510_R_MASK_OPTION(SM510_R_CONTROL_OUTPUT) // confirmed
MCFG_SM510_WRITE_SEGS_CB(WRITE16(*this, hh_sm510_state, sm510_lcd_segment_w))
MCFG_SM510_READ_K_CB(READ8(*this, rzone_state, input_r))
MCFG_SM510_WRITE_S_CB(WRITE8(*this, rzone_state, t1_write_s))
MCFG_SM510_WRITE_R_CB(WRITE8(*this, rzone_state, t1_write_r))
SM510(config, m_maincpu); // no external XTAL
m_maincpu->set_r_mask_option(SM510_R_CONTROL_OUTPUT); // confirmed
write_segs(config);
m_maincpu->read_k().set(FUNC(rzone_state::input_r));
m_maincpu->write_s().set(FUNC(rzone_state::t1_write_s));
m_maincpu->write_r().set(FUNC(rzone_state::t1_write_r));
/* video hardware */
MCFG_SCREEN_SVG_ADD("screen", "svg")

8
src/mame/drivers/sun4.cpp
View File

@ -1848,8 +1848,8 @@ void sun4_state::ncr53c90a(device_t *device)
MACHINE_CONFIG_START(sun4_state::sun4)
/* basic machine hardware */
MCFG_DEVICE_ADD(m_maincpu, MB86901, 16'670'000)
MCFG_SPARC_ADD_ASI_DESC(sun4_asi_desc)
MB86901(config, m_maincpu, 16'670'000);
m_maincpu->add_asi_desc([](sparc_disassembler *dasm) { dasm->add_asi_desc(sun4_asi_desc); });
m_maincpu->set_addrmap(0, &sun4_state::sun4c_debugger_map);
// TODO: MMU for sun4 hardware
@ -1934,8 +1934,8 @@ MACHINE_CONFIG_END
MACHINE_CONFIG_START(sun4_state::sun4c)
/* basic machine hardware */
MCFG_DEVICE_ADD(m_maincpu, MB86901, 20'000'000)
MCFG_SPARC_ADD_ASI_DESC(sun4c_asi_desc)
MB86901(config, m_maincpu, 20'000'000);
m_maincpu->add_asi_desc([](sparc_disassembler *dasm) { dasm->add_asi_desc(sun4c_asi_desc); });
m_maincpu->set_addrmap(0, &sun4_state::sun4c_debugger_map);
SUN4C_MMU(config, m_mmu, 20'000'000, 7, 0x7f);

32
src/mame/drivers/terak.cpp
View File

@ -23,7 +23,7 @@ public:
terak_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
{ }
{ }
void terak(machine_config &config);
@ -40,7 +40,7 @@ private:
uint8_t m_cmd;
virtual void machine_reset() override;
virtual void video_start() override;
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
};
READ16_MEMBER( terak_state::terak_fdc_status_r )
@ -102,24 +102,24 @@ uint32_t terak_state::screen_update_terak(screen_device &screen, bitmap_ind16 &b
}
MACHINE_CONFIG_START(terak_state::terak)
void terak_state::terak(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",T11, XTAL(4'000'000))
MCFG_T11_INITIAL_MODE(6 << 13)
MCFG_DEVICE_PROGRAM_MAP(mem_map)
T11(config, m_maincpu, XTAL(4'000'000));
m_maincpu->set_initial_mode(6 << 13);
m_maincpu->set_addrmap(AS_PROGRAM, &terak_state::mem_map);
/* 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(terak_state, screen_update_terak)
MCFG_SCREEN_PALETTE("palette")
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(terak_state::screen_update_terak));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
/* ROM definition */
ROM_START( terak )

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

@ -18,8 +18,9 @@ class uknc_state : public driver_device
{
public:
uknc_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) ,
m_maincpu(*this, "maincpu") { }
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
{ }
void uknc(machine_config &config);
@ -27,7 +28,7 @@ private:
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update_uknc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
required_device<cpu_device> m_maincpu;
required_device<k1801vm2_device> m_maincpu;
void uknc_mem(address_map &map);
void uknc_sub_mem(address_map &map);
@ -66,28 +67,28 @@ uint32_t uknc_state::screen_update_uknc(screen_device &screen, bitmap_ind16 &bit
return 0;
}
MACHINE_CONFIG_START(uknc_state::uknc)
void uknc_state::uknc(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", K1801VM2, 8000000)
MCFG_T11_INITIAL_MODE(0x8000)
MCFG_DEVICE_PROGRAM_MAP(uknc_mem)
MCFG_DEVICE_ADD("subcpu", K1801VM2, 6000000)
MCFG_T11_INITIAL_MODE(0x8000)
MCFG_DEVICE_PROGRAM_MAP(uknc_sub_mem)
K1801VM2(config, m_maincpu, 8000000);
m_maincpu->set_initial_mode(0x8000);
m_maincpu->set_addrmap(AS_PROGRAM, &uknc_state::uknc_mem);
k1801vm2_device &subcpu(K1801VM2(config, "subcpu", 6000000));
subcpu.set_initial_mode(0x8000);
subcpu.set_addrmap(AS_PROGRAM, &uknc_state::uknc_sub_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(uknc_state, screen_update_uknc)
MCFG_SCREEN_PALETTE("palette")
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(uknc_state::screen_update_uknc));
screen.set_palette("palette");
MCFG_PALETTE_ADD_MONOCHROME("palette")
MACHINE_CONFIG_END
PALETTE(config, "palette", 2).set_init("palette", FUNC(palette_device::palette_init_monochrome));
}
/* ROM definition */
ROM_START( uknc )

8
src/mame/drivers/vax11.cpp
View File

@ -83,7 +83,7 @@ public:
void vax11(machine_config &config);
private:
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
required_device<generic_terminal_device> m_terminal;
DECLARE_READ16_MEMBER( term_r );
DECLARE_READ16_MEMBER( term_tx_status_r );
@ -142,9 +142,9 @@ void vax11_state::kbd_put(u8 data)
MACHINE_CONFIG_START(vax11_state::vax11)
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu",T11, XTAL(4'000'000)) // Need proper CPU here
MCFG_T11_INITIAL_MODE(0 << 13)
MCFG_DEVICE_PROGRAM_MAP(vax11_mem)
T11(config, m_maincpu, XTAL(4'000'000)); // Need proper CPU here
m_maincpu->set_initial_mode(0 << 13);
m_maincpu->set_addrmap(AS_PROGRAM, &vax11_state::vax11_mem);
/* video hardware */
MCFG_DEVICE_ADD(m_terminal, GENERIC_TERMINAL, 0)

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

@ -59,7 +59,7 @@ public:
void vt240(machine_config &config);
private:
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
required_device<cpu_device> m_i8085;
required_device<i8251_device> m_i8251;
required_device<scn2681_device> m_duart;
@ -655,10 +655,10 @@ static INPUT_PORTS_START( vt240 )
INPUT_PORTS_END
MACHINE_CONFIG_START(vt240_state::vt240)
MCFG_DEVICE_ADD("maincpu", T11, XTAL(7'372'800)) // confirm
MCFG_DEVICE_PROGRAM_MAP(vt240_mem)
MCFG_T11_INITIAL_MODE(5 << 13)
MCFG_T11_RESET(WRITELINE(*this, vt240_state, t11_reset_w))
T11(config, m_maincpu, XTAL(7'372'800)); // confirm
m_maincpu->set_addrmap(AS_PROGRAM, &vt240_state::vt240_mem);
m_maincpu->set_initial_mode(5 << 13);
m_maincpu->out_reset().set(FUNC(vt240_state::t11_reset_w));
MCFG_DEVICE_ADD("charcpu", I8085A, XTAL(16'097'280) / 2)
MCFG_DEVICE_PROGRAM_MAP(vt240_char_mem)

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

@ -10,6 +10,7 @@
#pragma once
#include "cpu/t11/t11.h"
#include "imagedev/cassette.h"
class bk_state : public driver_device
@ -47,7 +48,7 @@ public:
uint32_t screen_update_bk0010(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(keyboard_callback);
IRQ_CALLBACK_MEMBER(bk0010_irq_callback);
required_device<cpu_device> m_maincpu;
required_device<t11_device> m_maincpu;
required_device<cassette_image_device> m_cassette;
void bk0010(machine_config &config);
void bk0010fd(machine_config &config);

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

@ -283,7 +283,7 @@ private:
virtual void video_start() override;
required_shared_ptr<uint8_t> m_p_videoram;
required_shared_ptr<uint8_t> m_p_nvram;
required_device<cpu_device> m_maincpu;
required_device<sm8500_cpu_device> m_maincpu;
required_device<screen_device> m_screen;
required_device<dac_byte_interface> m_dac;
required_device<dac_byte_interface> m_dac0;

5
src/mame/includes/hh_sm510.h
View File

@ -9,6 +9,7 @@
#ifndef MAME_INCLUDES_HH_SM510_H
#define MAME_INCLUDES_HH_SM510_H
#include "cpu/sm510/sm510.h"
#include "machine/timer.h"
#include "sound/spkrdev.h"
@ -28,7 +29,7 @@ public:
{ }
// devices
required_device<cpu_device> m_maincpu;
required_device<sm510_base_device> m_maincpu;
optional_ioport_array<8> m_inp_matrix; // max 8
output_finder<16, 16, 4> m_out_x;
optional_device<speaker_sound_device> m_speaker;
@ -70,6 +71,8 @@ public:
protected:
virtual void machine_start() override;
virtual void machine_reset() override;
void write_segs(machine_config &config);
};