From ae053d119aadb1a0b2a41186935f7c874838c0e5 Mon Sep 17 00:00:00 2001 From: Sergey Svishchev Date: Tue, 25 Nov 2014 21:39:00 +0300 Subject: [PATCH 1/2] Add skeleton support for K1801VM2 (as clone of T11), change relevant drivers to use it. --- src/emu/cpu/t11/t11.c | 43 +++++++++++++++++++++++++++++++++++++++++ src/emu/cpu/t11/t11.h | 16 +++++++++++++++ src/mess/drivers/mk85.c | 4 ++-- src/mess/drivers/mk90.c | 4 ++-- src/mess/drivers/uknc.c | 8 ++++---- 5 files changed, 67 insertions(+), 8 deletions(-) diff --git a/src/emu/cpu/t11/t11.c b/src/emu/cpu/t11/t11.c index 211bbd1f071..97f53e74b34 100644 --- a/src/emu/cpu/t11/t11.c +++ b/src/emu/cpu/t11/t11.c @@ -36,8 +36,24 @@ const device_type T11 = &device_creator; +const device_type K1801VM2 = &device_creator; +k1801vm2_device::k1801vm2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : t11_device(mconfig, K1801VM2, "K1801VM2", tag, owner, clock, "k1801vm2", __FILE__) +{ +} + +t11_device::t11_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source) + : cpu_device(mconfig, type, name, tag, owner, clock, shortname, source) + , m_program_config("program", ENDIANNESS_LITTLE, 16, 16, 0) + , c_initial_mode(0) +{ + m_is_octal = true; + memset(m_reg, 0x00, sizeof(m_reg)); + memset(&m_psw, 0x00, sizeof(m_psw)); +} + t11_device::t11_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : cpu_device(mconfig, T11, "T11", tag, owner, clock, "t11", __FILE__) , m_program_config("program", ENDIANNESS_LITTLE, 16, 16, 0) @@ -294,6 +310,26 @@ void t11_device::state_string_export(const device_state_entry &entry, std::strin } } +void k1801vm2_device::state_string_export(const device_state_entry &entry, std::string &str) +{ + switch (entry.index()) + { + case STATE_GENFLAGS: + strprintf(str, "%c%c%c%c%c%c%c%c%c", + m_psw.b.l & 0x100 ? 'H':'.', + m_psw.b.l & 0x80 ? 'P':'.', + m_psw.b.l & 0x40 ? '?':'.', + m_psw.b.l & 0x20 ? '?':'.', + m_psw.b.l & 0x10 ? 'T':'.', + m_psw.b.l & 0x08 ? 'N':'.', + m_psw.b.l & 0x04 ? 'Z':'.', + m_psw.b.l & 0x02 ? 'V':'.', + m_psw.b.l & 0x01 ? 'C':'.' + ); + break; + } +} + /************************************* * @@ -326,6 +362,13 @@ void t11_device::device_reset() m_wait_state = 0; } +void k1801vm2_device::device_reset() +{ + t11_device::device_reset(); + + PC = RWORD(c_initial_mode); + PSW = RWORD(c_initial_mode+2); +} /************************************* diff --git a/src/emu/cpu/t11/t11.h b/src/emu/cpu/t11/t11.h index d5c8c38fb56..c5044a7ad96 100644 --- a/src/emu/cpu/t11/t11.h +++ b/src/emu/cpu/t11/t11.h @@ -37,6 +37,7 @@ class t11_device : public cpu_device public: // construction/destruction t11_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock); + t11_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source); // static configuration helpers static void set_initial_mode(device_t &device, const UINT16 mode) { downcast(device).c_initial_mode = mode; } @@ -1133,8 +1134,23 @@ private: void sub_ixd_ixd(UINT16 op); }; +class k1801vm2_device : public t11_device +{ +public: + // construction/destruction + k1801vm2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + +protected: + // device-level overrides + virtual void device_reset(); + + // device_state_interface overrides + void state_string_export(const device_state_entry &entry, std::string &str); +}; + extern const device_type T11; +extern const device_type K1801VM2; #endif /* __T11_H__ */ diff --git a/src/mess/drivers/mk85.c b/src/mess/drivers/mk85.c index 5d90dd2b4c1..c84df818ed9 100644 --- a/src/mess/drivers/mk85.c +++ b/src/mess/drivers/mk85.c @@ -63,8 +63,8 @@ UINT32 mk85_state::screen_update_mk85(screen_device &screen, bitmap_ind16 &bitma static MACHINE_CONFIG_START( mk85, mk85_state ) /* basic machine hardware */ - MCFG_CPU_ADD("maincpu",T11, XTAL_4MHz) - MCFG_T11_INITIAL_MODE(5 << 13) /* start from 0000 */ + MCFG_CPU_ADD("maincpu", K1801VM2, XTAL_4MHz) + MCFG_T11_INITIAL_MODE(0) MCFG_CPU_PROGRAM_MAP(mk85_mem) diff --git a/src/mess/drivers/mk90.c b/src/mess/drivers/mk90.c index f0fa54b0cf5..3f9249a899f 100644 --- a/src/mess/drivers/mk90.c +++ b/src/mess/drivers/mk90.c @@ -68,8 +68,8 @@ UINT32 mk90_state::screen_update_mk90(screen_device &screen, bitmap_ind16 &bitma static MACHINE_CONFIG_START( mk90, mk90_state ) /* basic machine hardware */ - MCFG_CPU_ADD("maincpu",T11, XTAL_4MHz) - MCFG_T11_INITIAL_MODE(0xf600) + MCFG_CPU_ADD("maincpu", K1801VM2, XTAL_4MHz) + MCFG_T11_INITIAL_MODE(0x8000) MCFG_CPU_PROGRAM_MAP(mk90_mem) diff --git a/src/mess/drivers/uknc.c b/src/mess/drivers/uknc.c index 45c5a5ecc54..13b266ccb2b 100644 --- a/src/mess/drivers/uknc.c +++ b/src/mess/drivers/uknc.c @@ -58,12 +58,12 @@ UINT32 uknc_state::screen_update_uknc(screen_device &screen, bitmap_ind16 &bitma static MACHINE_CONFIG_START( uknc, uknc_state ) /* basic machine hardware */ - MCFG_CPU_ADD("maincpu", T11, 8000000) - MCFG_T11_INITIAL_MODE(0x36ff) /* initial mode word has DAL15,14,11,8 pulled low */ + MCFG_CPU_ADD("maincpu", K1801VM2, 8000000) + MCFG_T11_INITIAL_MODE(0x8000) MCFG_CPU_PROGRAM_MAP(uknc_mem) - MCFG_CPU_ADD("subcpu", T11, 6000000) - MCFG_T11_INITIAL_MODE(0x36ff) /* initial mode word has DAL15,14,11,8 pulled low */ + MCFG_CPU_ADD("subcpu", K1801VM2, 6000000) + MCFG_T11_INITIAL_MODE(0x8000) MCFG_CPU_PROGRAM_MAP(uknc_sub_mem) From 28287d2970c436de2b1de9ed30270c25f1349fc1 Mon Sep 17 00:00:00 2001 From: Sergey Svishchev Date: Sun, 30 Aug 2015 14:52:33 +0300 Subject: [PATCH 2/2] New skeleton: dvk_kcgd (colour graphics display controller for DVK series) --- scripts/target/mame/mess.lua | 1 + src/mame/mess.lst | 1 + src/mess/drivers/dvk_kcgd.c | 384 +++++++++++++++++++++++++++++++++++ 3 files changed, 386 insertions(+) create mode 100644 src/mess/drivers/dvk_kcgd.c diff --git a/scripts/target/mame/mess.lua b/scripts/target/mame/mess.lua index 29f03266dd2..ede72076788 100644 --- a/scripts/target/mame/mess.lua +++ b/scripts/target/mame/mess.lua @@ -1443,6 +1443,7 @@ files { MAME_DIR .. "src/mess/drivers/bk.c", MAME_DIR .. "src/mess/machine/bk.c", MAME_DIR .. "src/mess/video/bk.c", + MAME_DIR .. "src/mess/drivers/dvk_kcgd.c", MAME_DIR .. "src/mess/drivers/dvk_ksm.c", MAME_DIR .. "src/mess/machine/ms7004.c", MAME_DIR .. "src/mess/drivers/mk85.c", diff --git a/src/mame/mess.lst b/src/mame/mess.lst index 12550729b17..8b98b7ce525 100644 --- a/src/mame/mess.lst +++ b/src/mame/mess.lst @@ -2652,6 +2652,7 @@ itt3030 vax785 ms0515 ie15 +dvk_kcgd dvk_ksm dvk_ksm01 asmapro diff --git a/src/mess/drivers/dvk_kcgd.c b/src/mess/drivers/dvk_kcgd.c new file mode 100644 index 00000000000..cc379085350 --- /dev/null +++ b/src/mess/drivers/dvk_kcgd.c @@ -0,0 +1,384 @@ +/*************************************************************************** + + KCGD (Kontroller Cvetnogo Graficheskogo Displeya = Colour Graphics + Display Controller), a replacement for KSM (dvk_ksm.c) in later + models of DVK desktops. + + MPI (Q-Bus clone) board. Interfaces with MS7004 (DEC LK201 workalike) + keyboard, mouse, and monochrome or color CRT. + + To do: + - K1801VM2 CPU core (interrupts and EVNT pin, full EIS set, other insns) + - Everything else :-) + +****************************************************************************/ + +#include "emu.h" + +#include "bus/rs232/rs232.h" +#include "cpu/t11/t11.h" +#include "machine/clock.h" +#include "machine/ms7004.h" + +#define KCGD_TOTAL_HORZ 1000 // XXX verify +#define KCGD_DISP_HORZ 800 +#define KCGD_HORZ_START 200 // XXX verify + +#define KCGD_TOTAL_VERT 600 // XXX verify +#define KCGD_DISP_VERT 480 +#define KCGD_VERT_START 100 // XXX verify + +#define KCGD_STATUS_PAGE 0 +#define KCGD_STATUS_INTERLACE 1 +#define KCGD_STATUS_TIMER_INT 5 +#define KCGD_STATUS_MODE_INT 6 +#define KCGD_STATUS_MODE_LAST 7 +#define KCGD_STATUS_TIMER_VAL 15 + +#define KCGD_PAGE_0 015574 +#define KCGD_PAGE_1 005574 + +#define VERBOSE_DBG 1 /* general debug messages */ + +#define DBG_LOG(N,M,A) \ + do { \ + if(VERBOSE_DBG>=N) \ + { \ + if( M ) \ + logerror("%11.6f at %s: %-24s",machine().time().as_double(),machine().describe_context(),(char*)M ); \ + logerror A; \ + } \ + } while (0) + + +class kcgd_state : public driver_device +{ +public: + kcgd_state(const machine_config &mconfig, device_type type, const char *tag) : + driver_device(mconfig, type, tag), + m_maincpu(*this, "maincpu"), +// m_ms7004(*this, "ms7004"), + m_palette(*this, "palette"), + m_screen(*this, "screen") + { } + + virtual void machine_reset(); + virtual void video_start(); + UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + TIMER_DEVICE_CALLBACK_MEMBER(scanline_callback); + DECLARE_PALETTE_INIT(kcgd); + + enum + { + TIMER_ID_VSYNC_ON, + TIMER_ID_VSYNC_OFF, + TIMER_ID_500HZ + }; + virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr); + + DECLARE_WRITE_LINE_MEMBER(write_keyboard_clock); + DECLARE_WRITE_LINE_MEMBER(write_line_clock); + + DECLARE_READ16_MEMBER(vram_addr_r); + DECLARE_READ16_MEMBER(vram_data_r); + DECLARE_READ16_MEMBER(vram_mmap_r); + DECLARE_WRITE16_MEMBER(vram_addr_w); + DECLARE_WRITE16_MEMBER(vram_data_w); + DECLARE_WRITE16_MEMBER(vram_mmap_w); + DECLARE_READ16_MEMBER(status_r); + DECLARE_WRITE16_MEMBER(status_w); + DECLARE_READ8_MEMBER(palette_index_r); + DECLARE_READ8_MEMBER(palette_data_r); + DECLARE_WRITE8_MEMBER(palette_index_w); + DECLARE_WRITE8_MEMBER(palette_data_w); + + emu_timer *m_vsync_on_timer; + emu_timer *m_vsync_off_timer; + emu_timer *m_500hz_timer; + +private: + void draw_scanline(UINT16 *p, UINT16 offset); + rectangle m_tmpclip; + bitmap_ind16 m_tmpbmp; + + struct { + UINT16 status; // 167770 + UINT8 control; // 167772 + int palette_index, vram_addr; + UINT8 palette[16]; + } m_video; + UINT32 *m_videoram; + +protected: + required_device m_maincpu; +// required_device m_ms7004; + required_device m_palette; + required_device m_screen; +}; + +static ADDRESS_MAP_START( kcgd_mem, AS_PROGRAM, 16, kcgd_state ) + ADDRESS_MAP_UNMAP_HIGH + AM_RANGE (0000000, 0077777) AM_READWRITE(vram_mmap_r, vram_mmap_w) + AM_RANGE (0100000, 0157777) AM_ROM + AM_RANGE (0160000, 0160001) AM_MIRROR(03774) AM_READWRITE(vram_addr_r, vram_addr_w) + AM_RANGE (0160002, 0160003) AM_MIRROR(03774) AM_READWRITE(vram_data_r, vram_data_w) + AM_RANGE (0167770, 0167771) AM_READWRITE(status_r, status_w) + AM_RANGE (0167772, 0167773) AM_READWRITE8(palette_index_r, palette_index_w, 0x00ff) // reads always return 0 + AM_RANGE (0167772, 0167773) AM_READWRITE8(palette_data_r, palette_data_w, 0xff00) +// AM_RANGE (0176560, 0176567) AM_RAM // USART2 -- host +// AM_RANGE (0177560, 0177567) AM_RAM // USART3 -- keyboard +ADDRESS_MAP_END + +void kcgd_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) +{ + switch (id) + { +/* + case TIMER_ID_VSYNC_ON: + m_maincpu->set_input_line(INPUT_LINE_EVNT, ASSERT_LINE); + break; + + case TIMER_ID_VSYNC_OFF: + m_maincpu->set_input_line(INPUT_LINE_EVNT, CLEAR_LINE); + break; +*/ + case TIMER_ID_500HZ: + m_video.status ^= (1 << KCGD_STATUS_TIMER_VAL); + break; + } +} + +void kcgd_state::machine_reset() +{ + memset(&m_video, 0, sizeof(m_video)); +} + +void kcgd_state::video_start() +{ +// screen_device *screen = machine().device("screen"); + + // 64 kwords, word size is 17 bits + m_videoram = auto_alloc_array(machine(), UINT32, 65536); + + m_tmpclip = rectangle(0, KCGD_DISP_HORZ-1, 0, KCGD_DISP_VERT-1); + m_tmpbmp.allocate(KCGD_DISP_HORZ, KCGD_DISP_VERT); +/* + m_vsync_on_timer = timer_alloc(TIMER_ID_VSYNC_ON); + m_vsync_on_timer->adjust(screen->time_until_pos(0, 0), 0, screen->frame_period()); + + m_vsync_off_timer = timer_alloc(TIMER_ID_VSYNC_OFF); + m_vsync_off_timer->adjust(screen->time_until_pos(16, 0), 0, screen->frame_period()); +*/ + m_500hz_timer = timer_alloc(TIMER_ID_500HZ); + m_500hz_timer->adjust(attotime::from_hz(500), 0, attotime::from_hz(500)); +} + +PALETTE_INIT_MEMBER(kcgd_state, kcgd) +{ + for (int i = 0; i < 16; i++) + { + palette.set_pen_color(i, i?i:255, i?i:255, i?i:255); + } +} + +/* + VRAM is 128K and is word-addressable, so address fits into 16 bits. + Low 32K of VRAM are not used to store pixel data -- XXX. +*/ +WRITE16_MEMBER(kcgd_state::vram_addr_w) +{ + DBG_LOG(3,"VRAM WA", ("%06o\n", data)); + m_video.vram_addr = data; +} + +READ16_MEMBER(kcgd_state::vram_addr_r) +{ + DBG_LOG(3,"VRAM RA", ("\n")); + return m_video.vram_addr; +} + +WRITE16_MEMBER(kcgd_state::vram_data_w) +{ + DBG_LOG(1,"VRAM W2", ("%06o <- %04XH\n", m_video.vram_addr, data)); + m_videoram[m_video.vram_addr] = data | (BIT(m_video.control, 7) << 16); +} + +READ16_MEMBER(kcgd_state::vram_data_r) +{ + DBG_LOG(2,"VRAM R2", ("%06o\n", m_video.vram_addr)); + m_video.status = (m_video.status & 0xff7f) | (BIT(m_videoram[m_video.vram_addr], 16) << 7); + return (UINT16) (m_videoram[m_video.vram_addr] & 0xffff); +} + +WRITE16_MEMBER(kcgd_state::vram_mmap_w) +{ + DBG_LOG(3,"VRAM W1", ("%06o <- %04XH\n", offset, data)); + m_videoram[offset] = data | (BIT(m_video.control, 7) << 16); +} + +READ16_MEMBER(kcgd_state::vram_mmap_r) +{ + DBG_LOG(3,"VRAM R1", ("%06o\n", offset)); + return (UINT16) (m_videoram[offset] & 0xffff); +} + +WRITE16_MEMBER(kcgd_state::status_w) +{ + DBG_LOG(1,"Status W", ("data %04XH (useful %02XH)\n", data, data & 0x63)); + // bits 7 and 15 are read-only + m_video.status = (m_video.status & 0x8080) | (data & 0x7f7f); +} + +READ16_MEMBER(kcgd_state::status_r) +{ + UINT16 data = m_video.status ^ (BIT(m_video.control, 6) << 7); + DBG_LOG(1,"Status R", ("data %04X index %d\n", data, m_video.palette_index)); + return data; +} + +WRITE8_MEMBER(kcgd_state::palette_index_w) +{ + m_video.control = data; + m_video.palette_index = ((data >> 2) & 15); + DBG_LOG(1,"Palette index, Control W", ("data %02XH index %d\n", data, m_video.palette_index)); +} + +WRITE8_MEMBER(kcgd_state::palette_data_w) +{ + DBG_LOG(1,"Palette data W", ("data %02XH index %d\n", data, m_video.palette_index)); + m_video.palette[m_video.palette_index] = data; + m_palette->set_pen_color(m_video.palette_index, + 85*(data & 3), 85*((data >> 2) & 3), 85*((data >> 4) & 3)); +} + +READ8_MEMBER(kcgd_state::palette_index_r) +{ + return 0; +} + +READ8_MEMBER(kcgd_state::palette_data_r) +{ + DBG_LOG(1,"Palette data R", ("index %d\n", m_video.palette_index)); + return m_video.palette[m_video.palette_index]; +} + +/* + Raster sizes are: + - 800(400)x480 in hires(lores) 60 Hz interlaced mode + - 800(400)x240 in hires(lores) 30 Hz progressive mode + + Video memory is 17 bits wide (bit 16 indicates hi/lo res mode for each word, + host writes it separately (via bit 7 in 167772). +*/ + +void kcgd_state::draw_scanline(UINT16 *p, UINT16 offset) +{ + int i; + + for ( i = 0; i < 100; i++ ) + { + UINT32 data = m_videoram[ offset++ ]; + if (BIT(data, 16)) { + *p = ( data >> 12) & 0x0F; p++; + *p = ( data >> 12) & 0x0F; p++; + *p = ( data >> 8 ) & 0x0F; p++; + *p = ( data >> 8 ) & 0x0F; p++; + *p = ( data >> 4 ) & 0x0F; p++; + *p = ( data >> 4 ) & 0x0F; p++; + *p = data & 0x0F; p++; + *p = data & 0x0F; p++; + } else { + *p = 5*(( data >> 14) & 0x03); p++; + *p = 5*(( data >> 12) & 0x03); p++; + *p = 5*(( data >> 10) & 0x03); p++; + *p = 5*(( data >> 8 ) & 0x03); p++; + *p = 5*(( data >> 6 ) & 0x03); p++; + *p = 5*(( data >> 4 ) & 0x03); p++; + *p = 5*(( data >> 2 ) & 0x03); p++; + *p = 5*( data & 0x03); p++; + } + } +} + +TIMER_DEVICE_CALLBACK_MEMBER(kcgd_state::scanline_callback) +{ + UINT16 y = m_screen->vpos(), offset; + + if (y < KCGD_VERT_START) return; + y -= KCGD_VERT_START; + if (y >= KCGD_DISP_VERT) return; + + offset = BIT(m_video.status, KCGD_STATUS_PAGE) ? (KCGD_PAGE_1 >> 1) : (KCGD_PAGE_0 >> 1); + + DBG_LOG(2,"scanline_cb", ("frame %d y %.3d page %d offset %04X *offset %04X\n", + m_screen->frame_number(), BIT(m_video.status, KCGD_STATUS_PAGE), + y, offset + y, m_videoram[offset + y])); + + draw_scanline(&m_tmpbmp.pix16(y), m_videoram[offset + (KCGD_DISP_VERT-1) - y]); +} + +UINT32 kcgd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) +{ + copybitmap(bitmap, m_tmpbmp, 0, 0, KCGD_HORZ_START, KCGD_VERT_START, cliprect); + return 0; +} + +/* F4 Character Displayer */ +static const gfx_layout kcgd_charlayout = +{ + 8, 10, /* 8x10 pixels */ + 256, /* 256 characters */ + 1, /* 1 bits per pixel */ + { 0 }, /* no bitplanes */ + /* x offsets */ + { 0, 1, 2, 3, 4, 5, 6, 7 }, + /* y offsets */ + { 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8, 8*8, 9*8 }, + 8*10 /* every char takes 10 bytes */ +}; + +static GFXDECODE_START( kcgd ) + GFXDECODE_ENTRY("maincpu", 0112236, kcgd_charlayout, 0, 1) +GFXDECODE_END + +static MACHINE_CONFIG_START( kcgd, kcgd_state ) + MCFG_CPU_ADD("maincpu", K1801VM2, XTAL_30_8MHz/4) + MCFG_CPU_PROGRAM_MAP(kcgd_mem) + MCFG_T11_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_8MHz/KCGD_HORZ_START)) + + MCFG_SCREEN_ADD("screen", RASTER) + MCFG_SCREEN_UPDATE_DRIVER(kcgd_state, screen_update) + MCFG_SCREEN_RAW_PARAMS(XTAL_30_8MHz, KCGD_TOTAL_HORZ, KCGD_HORZ_START, + KCGD_HORZ_START+KCGD_DISP_HORZ, KCGD_TOTAL_VERT, KCGD_VERT_START, + KCGD_VERT_START+KCGD_DISP_VERT); + + MCFG_SCREEN_PALETTE("palette") + MCFG_PALETTE_ADD("palette", 16) + MCFG_PALETTE_INIT_OWNER(kcgd_state, kcgd) + + MCFG_GFXDECODE_ADD("gfxdecode", "palette", kcgd) +#if 0 + MCFG_DEVICE_ADD("ms7004", MS7004, 0) + MCFG_MS7004_TX_HANDLER(DEVWRITELINE("i8251kbd", i8251_device, write_rxd)) + + MCFG_DEVICE_ADD("keyboard_clock", CLOCK, 4800*16) + MCFG_CLOCK_SIGNAL_HANDLER(WRITELINE(kcgd_state, write_keyboard_clock)) +#endif +MACHINE_CONFIG_END + +ROM_START( dvk_kcgd ) + ROM_REGION16_BE(0x100000,"maincpu", ROMREGION_ERASE00) + ROM_DEFAULT_BIOS("181") + ROM_SYSTEM_BIOS(0, "181", "mask 181") + ROMX_LOAD("kr1801re2-181.bin", 0100000, 020000, CRC(acac124f) SHA1(412c3eb71bece6f791fc5a9d707cf4692fd0b45b), ROM_BIOS(1)) + ROM_SYSTEM_BIOS(1, "182", "mask 182") + ROMX_LOAD("kr1801re2-182.bin", 0100000, 020000, CRC(3ca2921a) SHA1(389b30c40ed7e41dae71d58c7bff630359a48153), ROM_BIOS(2)) +ROM_END + +/* Driver */ + +/* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ +COMP( 1987, dvk_kcgd, 0, 0, kcgd, 0, driver_device, 0, "USSR", "DVK KCGD", MACHINE_NOT_WORKING | MACHINE_NO_SOUND_HW )