From cc6559a2d1a0d1ecc76cb7582ba67b90c4fb2ceb Mon Sep 17 00:00:00 2001 From: Angelo Salese Date: Thu, 29 Jan 2015 00:46:51 +0100 Subject: Re-added old version drivers for reference. Added debug for vram attribute & 0xf0, which eventually hides blinking .... --- src/mess/drivers/c65.c | 8 +- src/mess/drivers/c65_old.c | 648 +++++++++++++++++++++ src/mess/machine/c65_old.c | 1338 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1992 insertions(+), 2 deletions(-) create mode 100644 src/mess/drivers/c65_old.c create mode 100644 src/mess/machine/c65_old.c diff --git a/src/mess/drivers/c65.c b/src/mess/drivers/c65.c index 88c500c8375..157b5792632 100644 --- a/src/mess/drivers/c65.c +++ b/src/mess/drivers/c65.c @@ -125,11 +125,13 @@ UINT32 c65_state::screen_update( screen_device &screen, bitmap_ind16 &bitmap, co int ym = (y & 7); UINT8 tile = m_workram[xi+yi*80+0x800]; UINT8 attr = m_cram[xi+yi*80]; + if(attr & 0xf0) + attr = machine().rand() & 0xf; + int enable_dot = ((m_iplrom[(tile<<3)+ym+0xd000] >> xm) & 1); //if(cliprect.contains(x, y)) - - bitmap.pix16(y, x) = m_palette->pen((enable_dot) ? attr & 0xf : border_color); + bitmap.pix16(y, x) = m_palette->pen((enable_dot) ? attr & 0xf : border_color); //gfx->opaque(bitmap,cliprect,tile,0,0,0,x*8,y*8); @@ -247,6 +249,8 @@ void c65_state::DMAgicExecute(address_space &space,UINT32 address) dst|=(space.read_byte(address++)<<8); dst|=(space.read_byte(address++)<<16); + if(cmd & 0xfc) + printf("%02x\n",cmd & 0xfc); switch(cmd & 3) { case 0: // copy - TODO: untested diff --git a/src/mess/drivers/c65_old.c b/src/mess/drivers/c65_old.c new file mode 100644 index 00000000000..466d32aa269 --- /dev/null +++ b/src/mess/drivers/c65_old.c @@ -0,0 +1,648 @@ +/*************************************************************************** + + commodore c65 home computer + PeT mess@utanet.at + + documention + www.funet.fi + +***************************************************************************/ + +/* + +2008 - Driver Updates +--------------------- + +(most of the informations are taken from http://www.zimmers.net/cbmpics/ ) + + +[CBM systems which belong to this driver] + +* Commodore 65 (1989) + +Also known as C64 DX at early stages of the project. It was cancelled +around 1990-1991. Only few units survive (they were sold after Commodore +liquidation in 1994). + +CPU: CSG 4510 (3.54 MHz) +RAM: 128 kilobytes, expandable to 8 megabytes +ROM: 128 kilobytes +Video: CSG 4569 "VIC-III" (6 Video modes; Resolutions from 320x200 to + 1280x400; 80 columns text; Palette of 4096 colors) +Sound: CSG 8580 "SID" x2 (6 voice stereo synthesizer/digital sound + capabilities) +Ports: CSG 4510 (2 Joystick/Mouse ports; CBM Serial port; CBM 'USER' + port; CBM Monitor port; Power and reset switches; C65 bus drive + port; RGBI video port; 2 RCA audio ports; RAM expansion port; C65 + expansion port) +Keyboard: Full-sized 77 key QWERTY (12 programmable function keys; + 4 direction cursor-pad) +Additional Hardware: Built in 3.5" DD disk drive (1581 compatible) +Miscellaneous: Partially implemented Commodore 64 emulation + +[Notes] + +The datasette port was removed here. C65 supports an additional "dumb" +drive externally. It also features, in addition to the standard CBM +bus serial (available in all modes), a Fast and a Burst serial bus +(both available in C65 mode only) + +*/ + + +#include "emu.h" +#include "cpu/m6502/m4510.h" +#include "machine/mos6526.h" +#include "machine/cbm_snqk.h" +#include "includes/c65.h" +#include "bus/cbmiec/cbmiec.h" +#include "machine/ram.h" + +static void cbm_c65_quick_sethiaddress( address_space &space, UINT16 hiaddress ) +{ + space.write_byte(0x82, hiaddress & 0xff); + space.write_byte(0x83, hiaddress >> 8); +} + +QUICKLOAD_LOAD_MEMBER( c65_state, cbm_c65 ) +{ + return general_cbm_loadsnap(image, file_type, quickload_size, m_maincpu->space(AS_PROGRAM), 0, cbm_c65_quick_sethiaddress); +} + +/************************************* + * + * Main CPU memory handlers + * + *************************************/ + +static ADDRESS_MAP_START( c65_mem , AS_PROGRAM, 8, c65_state ) + AM_RANGE(0x00000, 0x07fff) AM_RAMBANK("bank11") + AM_RANGE(0x08000, 0x09fff) AM_READ_BANK("bank1") AM_WRITE_BANK("bank12") + AM_RANGE(0x0a000, 0x0bfff) AM_READ_BANK("bank2") AM_WRITE_BANK("bank13") + AM_RANGE(0x0c000, 0x0cfff) AM_READ_BANK("bank3") AM_WRITE_BANK("bank14") + AM_RANGE(0x0d000, 0x0d7ff) AM_READ_BANK("bank4") AM_WRITE_BANK("bank5") + AM_RANGE(0x0d800, 0x0dbff) AM_READ_BANK("bank6") AM_WRITE_BANK("bank7") + AM_RANGE(0x0dc00, 0x0dfff) AM_READ_BANK("bank8") AM_WRITE_BANK("bank9") + AM_RANGE(0x0e000, 0x0ffff) AM_READ_BANK("bank10") AM_WRITE_BANK("bank15") + AM_RANGE(0x10000, 0x1f7ff) AM_RAM + AM_RANGE(0x1f800, 0x1ffff) AM_RAM AM_SHARE("colorram") + + AM_RANGE(0x20000, 0x23fff) AM_ROM /* &c65_dos, maps to 0x8000 */ + AM_RANGE(0x24000, 0x28fff) AM_ROM /* reserved */ + AM_RANGE(0x29000, 0x29fff) AM_ROM AM_SHARE("c65_chargen") + AM_RANGE(0x2a000, 0x2bfff) AM_ROM AM_SHARE("basic") + AM_RANGE(0x2c000, 0x2cfff) AM_ROM AM_SHARE("interface") + AM_RANGE(0x2d000, 0x2dfff) AM_ROM AM_SHARE("chargen") + AM_RANGE(0x2e000, 0x2ffff) AM_ROM AM_SHARE("kernal") + + AM_RANGE(0x30000, 0x31fff) AM_ROM /*&c65_monitor, monitor maps to 0x6000 */ + AM_RANGE(0x32000, 0x37fff) AM_ROM /*&c65_basic, */ + AM_RANGE(0x38000, 0x3bfff) AM_ROM /*&c65_graphics, */ + AM_RANGE(0x3c000, 0x3dfff) AM_ROM /* reserved */ + AM_RANGE(0x3e000, 0x3ffff) AM_ROM /* &c65_kernal, */ + + AM_RANGE(0x40000, 0x7ffff) AM_NOP + /* 8 megabyte full address space! */ +ADDRESS_MAP_END + + +/************************************* + * + * Input Ports + * + *************************************/ + +static INPUT_PORTS_START( c65 ) + PORT_START( "ROW0" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Crsr Down Up") PORT_CODE(KEYCODE_RALT) PORT_CHAR(UCHAR_MAMEKEY(DOWN)) PORT_CHAR(UCHAR_MAMEKEY(UP)) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F3) PORT_CHAR(UCHAR_MAMEKEY(F5)) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F2) PORT_CHAR(UCHAR_MAMEKEY(F3)) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F1) PORT_CHAR(UCHAR_MAMEKEY(F1)) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F4) PORT_CHAR(UCHAR_MAMEKEY(F7)) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Crsr Right Left") PORT_CODE(KEYCODE_RCONTROL) PORT_CHAR(UCHAR_MAMEKEY(RIGHT)) PORT_CHAR(UCHAR_MAMEKEY(LEFT)) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Return") PORT_CODE(KEYCODE_ENTER) PORT_CHAR(13) + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("INST DEL") PORT_CODE(KEYCODE_BACKSPACE) PORT_CHAR(8) PORT_CHAR(UCHAR_MAMEKEY(INSERT)) + + PORT_START( "ROW1" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Shift (Left)") PORT_CODE(KEYCODE_LSHIFT) PORT_CHAR(UCHAR_SHIFT_1) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_E) PORT_CHAR('E') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_S) PORT_CHAR('S') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_Z) PORT_CHAR('Z') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_4) PORT_CHAR('4') PORT_CHAR('$') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_A) PORT_CHAR('A') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_W) PORT_CHAR('W') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_3) PORT_CHAR('3') PORT_CHAR('#') + + PORT_START( "ROW2" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_X) PORT_CHAR('X') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_T) PORT_CHAR('T') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F) PORT_CHAR('F') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_C) PORT_CHAR('C') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_6) PORT_CHAR('6') PORT_CHAR('&') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_D) PORT_CHAR('D') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_R) PORT_CHAR('R') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_5) PORT_CHAR('5') PORT_CHAR('%') + + PORT_START( "ROW3" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_V) PORT_CHAR('V') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_U) PORT_CHAR('U') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_H) PORT_CHAR('H') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_B) PORT_CHAR('B') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_8) PORT_CHAR('8') PORT_CHAR('(') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_G) PORT_CHAR('G') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_Y) PORT_CHAR('Y') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_7) PORT_CHAR('7') PORT_CHAR('\'') + + PORT_START( "ROW4" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_N) PORT_CHAR('N') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_O) PORT_CHAR('O') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_K) PORT_CHAR('K') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_M) PORT_CHAR('M') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_0) PORT_CHAR('0') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_J) PORT_CHAR('J') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_I) PORT_CHAR('I') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_9) PORT_CHAR('9') PORT_CHAR(')') + + PORT_START( "ROW5" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_COMMA) PORT_CHAR(',') PORT_CHAR('<') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_OPENBRACE) PORT_CHAR('@') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_COLON) PORT_CHAR(':') PORT_CHAR('[') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_STOP) PORT_CHAR('.') PORT_CHAR('>') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_EQUALS) PORT_CHAR('-') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_L) PORT_CHAR('L') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_P) PORT_CHAR('P') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_MINUS) PORT_CHAR('+') + + PORT_START( "ROW6" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_SLASH) PORT_CHAR('/') PORT_CHAR('?') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("\xE2\x86\x91 Pi") PORT_CODE(KEYCODE_DEL) PORT_CHAR(0x2191) PORT_CHAR(0x03C0) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_BACKSLASH) PORT_CHAR('=') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Shift (Right)") PORT_CODE(KEYCODE_RSHIFT) PORT_CHAR(UCHAR_SHIFT_1) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("CLR HOME") PORT_CODE(KEYCODE_INSERT) PORT_CHAR(UCHAR_MAMEKEY(HOME)) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_QUOTE) PORT_CHAR(';') PORT_CHAR(']') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_CLOSEBRACE) PORT_CHAR('*') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_BACKSLASH2) PORT_CHAR('\xA3') + + PORT_START( "ROW7" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("RUN STOP") PORT_CODE(KEYCODE_HOME) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_Q) PORT_CHAR('Q') + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("CBM") PORT_CODE(KEYCODE_LALT) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_SPACE) PORT_CHAR(' ') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_2) PORT_CHAR('2') PORT_CHAR('"') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_TAB) PORT_CHAR(UCHAR_SHIFT_2) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("\xE2\x86\x90") PORT_CODE(KEYCODE_TILDE) PORT_CHAR(0x2190) + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_1) PORT_CHAR('1') PORT_CHAR('!') + PORT_START("FUNCT") + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("ESC") PORT_CODE(KEYCODE_F1) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("F13 F14") PORT_CODE(KEYCODE_F11) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("F11 F12") PORT_CODE(KEYCODE_F10) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("F9 F10") PORT_CODE(KEYCODE_F9) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("HELP") PORT_CODE(KEYCODE_F12) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("ALT") PORT_CODE(KEYCODE_F2) /* non blocking */ + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("TAB") PORT_CODE(KEYCODE_TAB) + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("NO SCRL") PORT_CODE(KEYCODE_F4) + + PORT_START( "SPECIAL" ) /* special keys */ + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Restore") PORT_CODE(KEYCODE_PRTSCR) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Shift Lock (switch)") PORT_CODE(KEYCODE_CAPSLOCK) PORT_TOGGLE PORT_CHAR(UCHAR_MAMEKEY(CAPSLOCK)) + PORT_CONFNAME( 0x20, 0x00, "(C65) Caps Lock (switch)") PORT_CODE(KEYCODE_F3) + PORT_CONFSETTING( 0x00, DEF_STR( Off ) ) + PORT_CONFSETTING( 0x20, DEF_STR( On ) ) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_UNUSED ) + + PORT_START("CTRLSEL") /* Controller selection */ + PORT_CONFNAME( 0x07, 0x00, "Gameport A" ) + PORT_CONFSETTING( 0x00, DEF_STR( Joystick ) ) + PORT_CONFSETTING( 0x01, "Paddles 1 & 2" ) + PORT_CONFSETTING( 0x02, "Mouse 1351" ) + PORT_CONFSETTING( 0x03, "Mouse (Non Proportional) 1350" ) + PORT_CONFSETTING( 0x04, "Lightpen" ) +// PORT_CONFSETTING( 0x05, "Koala Pad" ) + PORT_CONFSETTING( 0x06, "Lightgun" ) + PORT_CONFSETTING( 0x07, "No Device Connected" ) + PORT_CONFNAME( 0x70, 0x00, "Gameport B" ) + PORT_CONFSETTING( 0x00, DEF_STR( Joystick ) ) + PORT_CONFSETTING( 0x10, "Paddles 3 & 4" ) +// PORT_CONFSETTING( 0x20, "Mouse 1351" ) +// PORT_CONFSETTING( 0x30, "Mouse (Non Proportional) 1350" ) + PORT_CONFSETTING( 0x70, "No Device Connected" ) + PORT_CONFNAME( 0x80, 0x00, "Swap Gameport A and B") PORT_CODE(KEYCODE_F1) PORT_TOGGLE + PORT_CONFSETTING( 0x00, DEF_STR( No ) ) + PORT_CONFSETTING( 0x80, DEF_STR( Yes ) ) + + PORT_START("JOY1_1B") + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x00) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x00) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x00) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x00) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x00) + PORT_BIT( 0xe0, IP_ACTIVE_HIGH, IPT_UNUSED ) + + PORT_START("JOY2_1B") + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_HOME) PORT_CODE(JOYCODE_Y_UP_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x00) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_END) PORT_CODE(JOYCODE_Y_DOWN_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x00) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_DEL) PORT_CODE(JOYCODE_X_LEFT_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x00) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_PGDN) PORT_CODE(JOYCODE_X_RIGHT_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x00) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_PLAYER(2) PORT_CODE(KEYCODE_INSERT) PORT_CODE(JOYCODE_BUTTON1) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x00) + PORT_BIT( 0xe0, IP_ACTIVE_HIGH, IPT_UNUSED ) + + /* Mouse Commodore 1350 was basically working as a Joystick */ + PORT_START("JOY1_2B") + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(1) PORT_NAME("Mouse 1350 Up") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(1) PORT_NAME("Mouse 1350 Down") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(1) PORT_NAME("Mouse 1350 Left") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(1) PORT_NAME("Mouse 1350 Right") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_PLAYER(1) PORT_NAME("Mouse 1350 Button 1") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_BUTTON2 ) PORT_PLAYER(1) PORT_NAME("Mouse 1350 Button 2") PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x03) + PORT_BIT( 0xc0, IP_ACTIVE_HIGH, IPT_UNUSED ) + + /* Still to verify how many mices you were able to plug into a c64 */ + /* Only one, for now */ + PORT_START("JOY2_2B") + PORT_BIT( 0xff, IP_ACTIVE_HIGH, IPT_UNUSED ) +/* PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_HOME) PORT_CODE(JOYCODE_Y_UP_SWITCH) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_END) PORT_CODE(JOYCODE_Y_DOWN_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x30) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_DEL) PORT_CODE(JOYCODE_X_LEFT_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x30) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_PLAYER(2) PORT_CODE(KEYCODE_PGDN) PORT_CODE(JOYCODE_X_RIGHT_SWITCH) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x30) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON1 ) PORT_PLAYER(2) PORT_CODE(KEYCODE_INSERT) PORT_CODE(JOYCODE_BUTTON1) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x30) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_BUTTON2 ) PORT_PLAYER(2) PORT_CODE(KEYCODE_PGUP) PORT_CODE(JOYCODE_BUTTON2) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x30) + PORT_BIT( 0xc0, IP_ACTIVE_HIGH, IPT_UNUSED ) +*/ + PORT_START("PADDLE1") + PORT_BIT( 0xff, 128, IPT_PADDLE) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_MINMAX(0,255) PORT_CENTERDELTA(0) PORT_CODE_DEC(KEYCODE_LEFT) PORT_CODE_INC(KEYCODE_RIGHT) PORT_CODE_DEC(JOYCODE_X_LEFT_SWITCH) PORT_CODE_INC(JOYCODE_X_RIGHT_SWITCH) PORT_PLAYER(1) PORT_REVERSE PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x01) + + PORT_START("PADDLE2") + PORT_BIT( 0xff, 128, IPT_PADDLE) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_MINMAX(0,255) PORT_CENTERDELTA(0) PORT_CODE_DEC(KEYCODE_DOWN) PORT_CODE_INC(KEYCODE_UP) PORT_CODE_DEC(JOYCODE_Y_UP_SWITCH) PORT_CODE_INC(JOYCODE_Y_DOWN_SWITCH) PORT_PLAYER(2) PORT_REVERSE PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x01) + + PORT_START("PADDLE3") + PORT_BIT( 0xff, 128, IPT_PADDLE) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_MINMAX(0,255) PORT_CENTERDELTA(0) PORT_CODE_DEC(KEYCODE_HOME) PORT_CODE_INC(KEYCODE_PGUP) PORT_PLAYER(3) PORT_REVERSE PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x10) + + PORT_START("PADDLE4") + PORT_BIT( 0xff, 128, IPT_PADDLE) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_MINMAX(0,255) PORT_CENTERDELTA(0) PORT_CODE_DEC(KEYCODE_END) PORT_CODE_INC(KEYCODE_PGDN) PORT_PLAYER(4) PORT_REVERSE PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x10) + + PORT_START("TRACKX") + PORT_BIT( 0x7e, 0x00, IPT_TRACKBALL_X) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x02) + + PORT_START("TRACKY") + PORT_BIT( 0x7e, 0x00, IPT_TRACKBALL_Y) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_PLAYER(1) PORT_REVERSE PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x02) + + PORT_START("LIGHTX") + PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_X) PORT_NAME("Lightpen X Axis") PORT_CROSSHAIR(X, 1.0, 0.0, 0) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x04) + + PORT_START("LIGHTY") + PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_Y) PORT_NAME("Lightpen Y Axis") PORT_CROSSHAIR(Y, 1.0, 0.0, 0) PORT_SENSITIVITY(30) PORT_KEYDELTA(20) PORT_PLAYER(1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x04) + + PORT_START("OTHER") + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Paddle 1 Button") PORT_CODE(KEYCODE_LCONTROL) PORT_CODE(JOYCODE_BUTTON1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x01) + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Paddle 2 Button") PORT_CODE(KEYCODE_LALT) PORT_CODE(JOYCODE_BUTTON2) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x01) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_BUTTON3) PORT_NAME("Paddle 3 Button") PORT_CODE(KEYCODE_INSERT) PORT_CODE(JOYCODE_BUTTON1) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x10) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON4) PORT_NAME("Paddle 4 Button") PORT_CODE(KEYCODE_DEL) PORT_CODE(JOYCODE_BUTTON2) PORT_CONDITION("CTRLSEL", 0xf0, EQUALS, 0x10) + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Lightpen Signal") PORT_CODE(KEYCODE_LCONTROL) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x04) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Mouse Button Left") PORT_CODE(KEYCODE_LCONTROL) PORT_CODE(JOYCODE_BUTTON1) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x02) + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Mouse Button Right") PORT_CODE(KEYCODE_LALT) PORT_CODE(JOYCODE_BUTTON2) PORT_CONDITION("CTRLSEL", 0x0f, EQUALS, 0x02)INPUT_PORTS_END + + +static INPUT_PORTS_START( c65ger ) + PORT_INCLUDE( c65 ) + + PORT_MODIFY( "ROW1" ) + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Z { Y }") PORT_CODE(KEYCODE_Z) PORT_CHAR('Z') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("3 # { 3 Paragraph }") PORT_CODE(KEYCODE_3) PORT_CHAR('3') PORT_CHAR('#') + + PORT_MODIFY( "ROW3" ) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Y { Z }") PORT_CODE(KEYCODE_Y) PORT_CHAR('Y') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("7 ' { 7 / }") PORT_CODE(KEYCODE_7) PORT_CHAR('7') PORT_CHAR('\'') + + PORT_MODIFY( "ROW4" ) + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("0 { = }") PORT_CODE(KEYCODE_0) PORT_CHAR('0') + + PORT_MODIFY( "ROW5" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME(", < { ; }") PORT_CODE(KEYCODE_COMMA) PORT_CHAR(',') PORT_CHAR('<') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Paragraph \xE2\x86\x91 { \xc3\xbc }") PORT_CODE(KEYCODE_OPENBRACE) PORT_CHAR(0x00A7) PORT_CHAR(0x2191) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME(": [ { \xc3\xa4 }") PORT_CODE(KEYCODE_COLON) PORT_CHAR(':') PORT_CHAR('[') + PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME(". > { : }") PORT_CODE(KEYCODE_STOP) PORT_CHAR('.') PORT_CHAR('>') + PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("- { ' ` }") PORT_CODE(KEYCODE_EQUALS) PORT_CHAR('-') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("+ { \xc3\x9f ? }") PORT_CODE(KEYCODE_MINUS) PORT_CHAR('+') + + PORT_MODIFY( "ROW6" ) + PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("/ ? { - _ }") PORT_CODE(KEYCODE_SLASH) PORT_CHAR('/') PORT_CHAR('?') + PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("Sum Pi { ] \\ }") PORT_CODE(KEYCODE_DEL) PORT_CHAR(0x03A3) PORT_CHAR(0x03C0) + PORT_BIT( 0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("= { # ' }") PORT_CODE(KEYCODE_BACKSLASH) PORT_CHAR('=') + PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("; ] { \xc3\xb6 }") PORT_CODE(KEYCODE_QUOTE) PORT_CHAR(';') PORT_CHAR(']') + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("* ` { + * }") PORT_CODE(KEYCODE_CLOSEBRACE) PORT_CHAR('*') PORT_CHAR('`') + PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("\\ { [ \xE2\x86\x91 }") PORT_CODE(KEYCODE_BACKSLASH2) PORT_CHAR('\xa3') + + PORT_MODIFY( "ROW7" ) + PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("_ { < > }") PORT_CODE(KEYCODE_TILDE) PORT_CHAR('_') + + PORT_MODIFY("SPECIAL") /* special keys */ + PORT_DIPNAME( 0x20, 0x00, "(C65) DIN ASC (switch)") PORT_CODE(KEYCODE_F3) + PORT_DIPSETTING( 0x00, "ASC" ) + PORT_DIPSETTING( 0x20, "DIN" ) +INPUT_PORTS_END + + + +/************************************* + * + * Sound definitions + * + *************************************/ + +int c65_state::c64_paddle_read( device_t *device, address_space &space, int which ) +{ + int pot1 = 0xff, pot2 = 0xff, pot3 = 0xff, pot4 = 0xff, temp; + UINT8 cia0porta = machine().device("cia_0")->pa_r(space, 0); + int controller1 = ioport("CTRLSEL")->read() & 0x07; + int controller2 = ioport("CTRLSEL")->read() & 0x70; + /* Notice that only a single input is defined for Mouse & Lightpen in both ports */ + switch (controller1) + { + case 0x01: + if (which) + pot2 = ioport("PADDLE2")->read(); + else + pot1 = ioport("PADDLE1")->read(); + break; + + case 0x02: + if (which) + pot2 = ioport("TRACKY")->read(); + else + pot1 = ioport("TRACKX")->read(); + break; + + case 0x03: + if (which && (ioport("JOY1_2B")->read() & 0x20)) /* Joy1 Button 2 */ + pot1 = 0x00; + break; + + case 0x04: + if (which) + pot2 = ioport("LIGHTY")->read(); + else + pot1 = ioport("LIGHTX")->read(); + break; + + case 0x06: + if (which && (ioport("OTHER")->read() & 0x04)) /* Lightpen Signal */ + pot2 = 0x00; + break; + + case 0x00: + case 0x07: + break; + + default: + logerror("Invalid Controller Setting %d\n", controller1); + break; + } + + switch (controller2) + { + case 0x10: + if (which) + pot4 = ioport("PADDLE4")->read(); + else + pot3 = ioport("PADDLE3")->read(); + break; + + case 0x20: + if (which) + pot4 = ioport("TRACKY")->read(); + else + pot3 = ioport("TRACKX")->read(); + break; + + case 0x30: + if (which && (ioport("JOY2_2B")->read() & 0x20)) /* Joy2 Button 2 */ + pot4 = 0x00; + break; + + case 0x40: + if (which) + pot4 = ioport("LIGHTY")->read(); + else + pot3 = ioport("LIGHTX")->read(); + break; + + case 0x60: + if (which && (ioport("OTHER")->read() & 0x04)) /* Lightpen Signal */ + pot4 = 0x00; + break; + + case 0x00: + case 0x70: + break; + + default: + logerror("Invalid Controller Setting %d\n", controller1); + break; + } + + if (ioport("CTRLSEL")->read() & 0x80) /* Swap */ + { + temp = pot1; pot1 = pot3; pot3 = temp; + temp = pot2; pot2 = pot4; pot4 = temp; + } + + switch (cia0porta & 0xc0) + { + case 0x40: + return which ? pot2 : pot1; + + case 0x80: + return which ? pot4 : pot3; + + case 0xc0: + return which ? pot2 : pot1; + + default: + return 0; + } +} + +READ8_MEMBER( c65_state::sid_potx_r ) +{ + return c64_paddle_read(m_sid_r, space, 0); +} + +READ8_MEMBER( c65_state::sid_poty_r ) +{ + return c64_paddle_read(m_sid_r, space, 1); +} + + +/************************************* + * + * VIC III interfaces + * + *************************************/ + +UINT32 c65_state::screen_update_c65(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) +{ + m_vic->video_update(bitmap, cliprect); + return 0; +} + +READ8_MEMBER(c65_state::c65_lightpen_x_cb) +{ + return ioport("LIGHTX")->read() & ~0x01; +} + +READ8_MEMBER(c65_state::c65_lightpen_y_cb) +{ + return ioport("LIGHTY")->read() & ~0x01; +} + +READ8_MEMBER(c65_state::c65_lightpen_button_cb) +{ + return ioport("OTHER")->read() & 0x04; +} + +READ8_MEMBER(c65_state::c65_c64_mem_r) +{ + return m_memory[offset]; +} + +INTERRUPT_GEN_MEMBER(c65_state::vic3_raster_irq) +{ + m_vic->raster_interrupt_gen(); +} + +/************************************* + * + * Machine driver + * + *************************************/ + +static MACHINE_CONFIG_START( c65, c65_state ) + /* basic machine hardware */ + MCFG_CPU_ADD("maincpu", M4510, 3500000) /* or VIC6567_CLOCK, */ + MCFG_CPU_PROGRAM_MAP(c65_mem) + MCFG_CPU_VBLANK_INT_DRIVER("screen", c65_state, c65_frame_interrupt) + MCFG_CPU_PERIODIC_INT_DRIVER(c65_state, vic3_raster_irq, VIC6567_HRETRACERATE) + + MCFG_MACHINE_START_OVERRIDE(c65_state, c65 ) + + /* video hardware */ + MCFG_SCREEN_ADD("screen", RASTER) + MCFG_SCREEN_REFRESH_RATE(VIC6567_VRETRACERATE) + MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */ + MCFG_SCREEN_SIZE(525 * 2, 520 * 2) + MCFG_SCREEN_VISIBLE_AREA(VIC6567_STARTVISIBLECOLUMNS ,(VIC6567_STARTVISIBLECOLUMNS + VIC6567_VISIBLECOLUMNS - 1) * 2, VIC6567_STARTVISIBLELINES, VIC6567_STARTVISIBLELINES + VIC6567_VISIBLELINES - 1) + MCFG_SCREEN_UPDATE_DRIVER(c65_state, screen_update_c65) + MCFG_SCREEN_PALETTE("vic3:palette") + + MCFG_DEVICE_ADD("vic3", VIC3, 0) + MCFG_VIC3_CPU("maincpu") + MCFG_VIC3_TYPE(VIC4567_NTSC) + MCFG_VIC3_LIGHTPEN_X_CB(READ8(c65_state, c65_lightpen_x_cb)) + MCFG_VIC3_LIGHTPEN_Y_CB(READ8(c65_state, c65_lightpen_y_cb)) + MCFG_VIC3_LIGHTPEN_BUTTON_CB(READ8(c65_state, c65_lightpen_button_cb)) + MCFG_VIC3_DMA_READ_CB(READ8(c65_state, c65_dma_read)) + MCFG_VIC3_DMA_READ_COLOR_CB(READ8(c65_state, c65_dma_read_color)) + MCFG_VIC3_INTERRUPT_CB(WRITELINE(c65_state, c65_vic_interrupt)) + MCFG_VIC3_PORT_CHANGED_CB(WRITE8(c65_state, c65_bankswitch_interface)) + MCFG_VIC3_C64_MEM_R_CB(READ8(c65_state, c65_c64_mem_r)) + + /* sound hardware */ + MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker") + MCFG_SOUND_ADD("sid_r", MOS8580, 985248) + MCFG_MOS6581_POTX_CALLBACK(READ8(c65_state, sid_potx_r)) + MCFG_MOS6581_POTY_CALLBACK(READ8(c65_state, sid_poty_r)) + MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.50) + MCFG_SOUND_ADD("sid_l", MOS8580, 985248) + MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.50) + + /* quickload */ + MCFG_QUICKLOAD_ADD("quickload", c65_state, cbm_c65, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) + + /* cia */ + MCFG_DEVICE_ADD("cia_0", MOS6526, 3500000) + MCFG_MOS6526_TOD(60) + MCFG_MOS6526_IRQ_CALLBACK(WRITELINE(c65_state, c65_cia0_interrupt)) + MCFG_MOS6526_PA_INPUT_CALLBACK(READ8(c65_state, c65_cia0_port_a_r)) + MCFG_MOS6526_PB_INPUT_CALLBACK(READ8(c65_state, c65_cia0_port_b_r)) + MCFG_MOS6526_PB_OUTPUT_CALLBACK(WRITE8(c65_state, c65_cia0_port_b_w)) + + MCFG_DEVICE_ADD("cia_1", MOS6526, 3500000) + MCFG_MOS6526_TOD(60) + MCFG_MOS6526_IRQ_CALLBACK(WRITELINE(c65_state, c65_cia1_interrupt)) + MCFG_MOS6526_PA_INPUT_CALLBACK(READ8(c65_state, c65_cia1_port_a_r)) + MCFG_MOS6526_PA_OUTPUT_CALLBACK(WRITE8(c65_state, c65_cia1_port_a_w)) + + /* floppy from serial bus */ + MCFG_CBM_IEC_ADD(NULL) + + /* internal ram */ + MCFG_RAM_ADD(RAM_TAG) + MCFG_RAM_DEFAULT_SIZE("128K") + MCFG_RAM_EXTRA_OPTIONS("640K,4224K") +MACHINE_CONFIG_END + +static MACHINE_CONFIG_DERIVED( c65pal, c65 ) + MCFG_SCREEN_MODIFY("screen") + MCFG_SCREEN_REFRESH_RATE(VIC6569_VRETRACERATE) + MCFG_SCREEN_SIZE(625 * 2, 520 * 2) + MCFG_SCREEN_VISIBLE_AREA(VIC6569_STARTVISIBLECOLUMNS, (VIC6569_STARTVISIBLECOLUMNS + VIC6569_VISIBLECOLUMNS - 1) * 2, VIC6569_STARTVISIBLELINES, VIC6569_STARTVISIBLELINES + VIC6569_VISIBLELINES - 1) + MCFG_SCREEN_PALETTE("vic3:palette") + + MCFG_DEVICE_MODIFY("vic3") + MCFG_VIC3_TYPE(VIC4567_PAL) + + /* sound hardware */ + MCFG_SOUND_REPLACE("sid_r", MOS8580, 1022727) + MCFG_MOS6581_POTX_CALLBACK(READ8(c65_state, sid_potx_r)) + MCFG_MOS6581_POTY_CALLBACK(READ8(c65_state, sid_poty_r)) + MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.50) + MCFG_SOUND_REPLACE("sid_l", MOS8580, 1022727) + MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.50) + + /* cia */ + MCFG_DEVICE_MODIFY("cia_0") + MCFG_MOS6526_TOD(50) + + MCFG_DEVICE_MODIFY("cia_1") + MCFG_MOS6526_TOD(50) +MACHINE_CONFIG_END + + +/************************************* + * + * ROM definition(s) + * + *************************************/ + + +ROM_START( c65 ) + ROM_REGION( 0x400000, "maincpu", 0 ) + ROM_SYSTEM_BIOS( 0, "910111", "V0.9.910111" ) + ROMX_LOAD( "910111.bin", 0x20000, 0x20000, CRC(c5d8d32e) SHA1(71c05f098eff29d306b0170e2c1cdeadb1a5f206), ROM_BIOS(1) ) + ROM_SYSTEM_BIOS( 1, "910523", "V0.9.910523" ) + ROMX_LOAD( "910523.bin", 0x20000, 0x20000, CRC(e8235dd4) SHA1(e453a8e7e5b95de65a70952e9d48012191e1b3e7), ROM_BIOS(2) ) + ROM_SYSTEM_BIOS( 2, "910626", "V0.9.910626" ) + ROMX_LOAD( "910626.bin", 0x20000, 0x20000, CRC(12527742) SHA1(07c185b3bc58410183422f7ac13a37ddd330881b), ROM_BIOS(3) ) + ROM_SYSTEM_BIOS( 3, "910828", "V0.9.910828" ) + ROMX_LOAD( "910828.bin", 0x20000, 0x20000, CRC(3ee40b06) SHA1(b63d970727a2b8da72a0a8e234f3c30a20cbcb26), ROM_BIOS(4) ) + ROM_SYSTEM_BIOS( 4, "911001", "V0.9.911001" ) + ROMX_LOAD( "911001.bin", 0x20000, 0x20000, CRC(0888b50f) SHA1(129b9a2611edaebaa028ac3e3f444927c8b1fc5d), ROM_BIOS(5) ) +ROM_END + +ROM_START( c64dx ) + ROM_REGION( 0x400000, "maincpu", 0 ) + ROM_LOAD( "910429.bin", 0x20000, 0x20000, CRC(b025805c) SHA1(c3b05665684f74adbe33052a2d10170a1063ee7d) ) +ROM_END + +/*************************************************************************** + + Game driver(s) + +***************************************************************************/ + +/* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ + +COMP( 1991, c65, 0, 0, c65, c65, c65_state, c65, "Commodore Business Machines", "Commodore 65 Development System (Prototype, NTSC)", GAME_NOT_WORKING ) +COMP( 1991, c64dx, c65, 0, c65pal, c65ger, c65_state, c65pal, "Commodore Business Machines", "Commodore 64DX Development System (Prototype, PAL, German)", GAME_NOT_WORKING ) + + diff --git a/src/mess/machine/c65_old.c b/src/mess/machine/c65_old.c new file mode 100644 index 00000000000..caa68c22fd3 --- /dev/null +++ b/src/mess/machine/c65_old.c @@ -0,0 +1,1338 @@ +/*************************************************************************** + commodore c65 home computer + peter.trauner@jk.uni-linz.ac.at + documention + www.funet.fi + ***************************************************************************/ + +#include "emu.h" + +#include "includes/c65.h" +#include "cpu/m6502/m4510.h" +#include "sound/mos6581.h" +#include "machine/mos6526.h" +#include "bus/cbmiec/cbmiec.h" +#include "machine/ram.h" +#include "video/vic4567.h" +#include "imagedev/cassette.h" +#include "crsshair.h" +#include "formats/cbm_tap.h" + +#define VERBOSE_LEVEL 0 +#define DBG_LOG( MACHINE, N, M, A ) \ + do { \ + if(VERBOSE_LEVEL >= N) \ + { \ + if( M ) \ + logerror("%11.6f: %-24s", MACHINE.time().as_double(), (char*) M ); \ + logerror A; \ + } \ + } while (0) + + + +/*********************************************** + + Input Reading - Common Components + +***********************************************/ + +/* These are needed by c64, c65 and c128, each machine has also additional specific +components in its INTERRUPT_GEN */ + +/* keyboard lines */ +UINT8 c64_keyline[10]; + +void cbm_common_init(void) +{ + int i; + + for (i = 0; i < ARRAY_LENGTH(c64_keyline); i++) + c64_keyline[i] = 0xff; +} + +static TIMER_CALLBACK( lightpen_tick ) +{ + if (((machine.root_device().ioport("CTRLSEL")->read() & 0x07) == 0x04) || ((machine.root_device().ioport("CTRLSEL")->read() & 0x07) == 0x06)) + { + /* enable lightpen crosshair */ + crosshair_set_screen(machine, 0, CROSSHAIR_SCREEN_ALL); + } + else + { + /* disable lightpen crosshair */ + crosshair_set_screen(machine, 0, CROSSHAIR_SCREEN_NONE); + } +} + +void cbm_common_interrupt( device_t *device ) +{ + int value, i; + int controller1 = device->machine().root_device().ioport("CTRLSEL")->read() & 0x07; + int controller2 = device->machine().root_device().ioport("CTRLSEL")->read() & 0x70; + static const char *const c64ports[] = { "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", "ROW5", "ROW6", "ROW7" }; + + /* Lines 0-7 : common keyboard */ + for (i = 0; i < 8; i++) + { + value = 0xff; + value &= ~device->machine().root_device().ioport(c64ports[i])->read(); + + /* Shift Lock is mapped on Left Shift */ + if ((i == 1) && (device->machine().root_device().ioport("SPECIAL")->read() & 0x40)) + value &= ~0x80; + + c64_keyline[i] = value; + } + + + value = 0xff; + switch(controller1) + { + case 0x00: + value &= ~device->machine().root_device().ioport("JOY1_1B")->read(); /* Joy1 Directions + Button 1 */ + break; + + case 0x01: + if (device->machine().root_device().ioport("OTHER")->read() & 0x40) /* Paddle2 Button */ + value &= ~0x08; + if (device->machine().root_device().ioport("OTHER")->read() & 0x80) /* Paddle1 Button */ + value &= ~0x04; + break; + + case 0x02: + if (device->machine().root_device().ioport("OTHER")->read() & 0x02) /* Mouse Button Left */ + value &= ~0x10; + if (device->machine().root_device().ioport("OTHER")->read() & 0x01) /* Mouse Button Right */ + value &= ~0x01; + break; + + case 0x03: + value &= ~(device->machine().root_device().ioport("JOY1_2B")->read() & 0x1f); /* Joy1 Directions + Button 1 */ + break; + + case 0x04: +/* was there any input on the lightpen? where is it mapped? */ +// if (device->machine().root_device().ioport("OTHER")->read() & 0x04) /* Lightpen Signal */ +// value &= ?? ; + break; + + case 0x07: + break; + + default: + logerror("Invalid Controller 1 Setting %d\n", controller1); + break; + } + + c64_keyline[8] = value; + + + value = 0xff; + switch(controller2) + { + case 0x00: + value &= ~device->machine().root_device().ioport("JOY2_1B")->read(); /* Joy2 Directions + Button 1 */ + break; + + case 0x10: + if (device->machine().root_device().ioport("OTHER")->read() & 0x10) /* Paddle4 Button */ + value &= ~0x08; + if (device->machine().root_device().ioport("OTHER")->read() & 0x20) /* Paddle3 Button */ + value &= ~0x04; + break; + + case 0x20: + if (device->machine().root_device().ioport("OTHER")->read() & 0x02) /* Mouse Button Left */ + value &= ~0x10; + if (device->machine().root_device().ioport("OTHER")->read() & 0x01) /* Mouse Button Right */ + value &= ~0x01; + break; + + case 0x30: + value &= ~(device->machine().root_device().ioport("JOY2_2B")->read() & 0x1f); /* Joy2 Directions + Button 1 */ + break; + + case 0x40: +/* was there any input on the lightpen? where is it mapped? */ +// if (device->machine().root_device().ioport("OTHER")->read() & 0x04) /* Lightpen Signal */ +// value &= ?? ; + break; + + case 0x70: + break; + + default: + logerror("Invalid Controller 2 Setting %d\n", controller2); + break; + } + + c64_keyline[9] = value; + +// vic2_frame_interrupt does nothing so this is not necessary +// vic2_frame_interrupt (device); + + /* check if lightpen has been chosen as input: if so, enable crosshair */ + device->machine().scheduler().timer_set(attotime::zero, FUNC(lightpen_tick)); + + set_led_status (device->machine(), 1, device->machine().root_device().ioport("SPECIAL")->read() & 0x40 ? 1 : 0); /* Shift Lock */ + set_led_status (device->machine(), 0, device->machine().root_device().ioport("CTRLSEL")->read() & 0x80 ? 1 : 0); /* Joystick Swap */ +} + + +/*********************************************** + + CIA Common Handlers + +***********************************************/ + +/* These are shared by c64, c65 and c128. c65 and c128 also have additional specific +components (to select/read additional keyboard lines) */ + +/* + * CIA 0 - Port A + * bits 7-0 keyboard line select + * bits 7,6: paddle select( 01 port a, 10 port b) + * bit 4: joystick a fire button + * bits 3,2: Paddles port a fire button + * bits 3-0: joystick a direction + * + * CIA 0 - Port B + * bits 7-0: keyboard raw values + * bit 4: joystick b fire button, lightpen select + * bits 3,2: paddle b fire buttons (left,right) + * bits 3-0: joystick b direction + * + * flag cassette read input, serial request in + * irq to irq connected + */ + +UINT8 cbm_common_cia0_port_a_r( device_t *device, UINT8 output_b ) +{ + UINT8 value = 0xff; + + if (!(output_b & 0x80)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x80)) t &= ~0x80; + if (!(c64_keyline[6] & 0x80)) t &= ~0x40; + if (!(c64_keyline[5] & 0x80)) t &= ~0x20; + if (!(c64_keyline[4] & 0x80)) t &= ~0x10; + if (!(c64_keyline[3] & 0x80)) t &= ~0x08; + if (!(c64_keyline[2] & 0x80)) t &= ~0x04; + if (!(c64_keyline[1] & 0x80)) t &= ~0x02; + if (!(c64_keyline[0] & 0x80)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x40)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x40)) t &= ~0x80; + if (!(c64_keyline[6] & 0x40)) t &= ~0x40; + if (!(c64_keyline[5] & 0x40)) t &= ~0x20; + if (!(c64_keyline[4] & 0x40)) t &= ~0x10; + if (!(c64_keyline[3] & 0x40)) t &= ~0x08; + if (!(c64_keyline[2] & 0x40)) t &= ~0x04; + if (!(c64_keyline[1] & 0x40)) t &= ~0x02; + if (!(c64_keyline[0] & 0x40)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x20)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x20)) t &= ~0x80; + if (!(c64_keyline[6] & 0x20)) t &= ~0x40; + if (!(c64_keyline[5] & 0x20)) t &= ~0x20; + if (!(c64_keyline[4] & 0x20)) t &= ~0x10; + if (!(c64_keyline[3] & 0x20)) t &= ~0x08; + if (!(c64_keyline[2] & 0x20)) t &= ~0x04; + if (!(c64_keyline[1] & 0x20)) t &= ~0x02; + if (!(c64_keyline[0] & 0x20)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x10)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x10)) t &= ~0x80; + if (!(c64_keyline[6] & 0x10)) t &= ~0x40; + if (!(c64_keyline[5] & 0x10)) t &= ~0x20; + if (!(c64_keyline[4] & 0x10)) t &= ~0x10; + if (!(c64_keyline[3] & 0x10)) t &= ~0x08; + if (!(c64_keyline[2] & 0x10)) t &= ~0x04; + if (!(c64_keyline[1] & 0x10)) t &= ~0x02; + if (!(c64_keyline[0] & 0x10)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x08)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x08)) t &= ~0x80; + if (!(c64_keyline[6] & 0x08)) t &= ~0x40; + if (!(c64_keyline[5] & 0x08)) t &= ~0x20; + if (!(c64_keyline[4] & 0x08)) t &= ~0x10; + if (!(c64_keyline[3] & 0x08)) t &= ~0x08; + if (!(c64_keyline[2] & 0x08)) t &= ~0x04; + if (!(c64_keyline[1] & 0x08)) t &= ~0x02; + if (!(c64_keyline[0] & 0x08)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x04)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x04)) t &= ~0x80; + if (!(c64_keyline[6] & 0x04)) t &= ~0x40; + if (!(c64_keyline[5] & 0x04)) t &= ~0x20; + if (!(c64_keyline[4] & 0x04)) t &= ~0x10; + if (!(c64_keyline[3] & 0x04)) t &= ~0x08; + if (!(c64_keyline[2] & 0x04)) t &= ~0x04; + if (!(c64_keyline[1] & 0x04)) t &= ~0x02; + if (!(c64_keyline[0] & 0x04)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x02)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x02)) t &= ~0x80; + if (!(c64_keyline[6] & 0x02)) t &= ~0x40; + if (!(c64_keyline[5] & 0x02)) t &= ~0x20; + if (!(c64_keyline[4] & 0x02)) t &= ~0x10; + if (!(c64_keyline[3] & 0x02)) t &= ~0x08; + if (!(c64_keyline[2] & 0x02)) t &= ~0x04; + if (!(c64_keyline[1] & 0x02)) t &= ~0x02; + if (!(c64_keyline[0] & 0x02)) t &= ~0x01; + value &= t; + } + + if (!(output_b & 0x01)) + { + UINT8 t = 0xff; + if (!(c64_keyline[7] & 0x01)) t &= ~0x80; + if (!(c64_keyline[6] & 0x01)) t &= ~0x40; + if (!(c64_keyline[5] & 0x01)) t &= ~0x20; + if (!(c64_keyline[4] & 0x01)) t &= ~0x10; + if (!(c64_keyline[3] & 0x01)) t &= ~0x08; + if (!(c64_keyline[2] & 0x01)) t &= ~0x04; + if (!(c64_keyline[1] & 0x01)) t &= ~0x02; + if (!(c64_keyline[0] & 0x01)) t &= ~0x01; + value &= t; + } + + if ( device->machine().root_device().ioport("CTRLSEL")->read() & 0x80 ) + value &= c64_keyline[8]; + else + value &= c64_keyline[9]; + + return value; +} + +UINT8 cbm_common_cia0_port_b_r( device_t *device, UINT8 output_a ) +{ + UINT8 value = 0xff; + + if (!(output_a & 0x80)) value &= c64_keyline[7]; + if (!(output_a & 0x40)) value &= c64_keyline[6]; + if (!(output_a & 0x20)) value &= c64_keyline[5]; + if (!(output_a & 0x10)) value &= c64_keyline[4]; + if (!(output_a & 0x08)) value &= c64_keyline[3]; + if (!(output_a & 0x04)) value &= c64_keyline[2]; + if (!(output_a & 0x02)) value &= c64_keyline[1]; + if (!(output_a & 0x01)) value &= c64_keyline[0]; + + if ( device->machine().root_device().ioport("CTRLSEL")->read() & 0x80 ) + value &= c64_keyline[9]; + else + value &= c64_keyline[8]; + + return value; +} + + +/*********************************************** + + CBM Cartridges + +***********************************************/ + + +/* All the cartridge specific code has been moved + to machine/ drivers. Once more informations + surface about the cart expansions for systems + in c65.c, c128.c, cbmb.c and pet.c, the shared + code could be refactored to have here the + common functions */ + + + +/*********************************************** + + CBM Datasette Tapes + +***********************************************/ + +#if 0 +const cassette_interface cbm_cassette_interface = +{ + cbm_cassette_formats, + NULL, + (cassette_state) (CASSETTE_STOPPED | CASSETTE_MOTOR_DISABLED | CASSETTE_SPEAKER_ENABLED), + NULL +}; +#endif + + +/*UINT8 *c65_basic; */ +/*UINT8 *c65_kernal; */ +/*UINT8 *c65_dos; */ +/*UINT8 *c65_monitor; */ +/*UINT8 *c65_graphics; */ + + +void c65_state::c65_nmi( ) +{ + if (m_nmilevel != (ioport("SPECIAL")->read() & 0x80) || m_cia1_irq) /* KEY_RESTORE */ + { + m_maincpu->set_input_line(INPUT_LINE_NMI, (ioport("SPECIAL")->read() & 0x80) || m_cia1_irq); + + m_nmilevel = (ioport("SPECIAL")->read() & 0x80) || m_cia1_irq; + } +} + + +/*********************************************** + + CIA Interfaces + +***********************************************/ + +/* + * CIA 0 - Port A keyboard line select + * CIA 0 - Port B keyboard line read + * + * flag cassette read input, serial request in + * irq to irq connected + * + * see machine/cbm.c + */ + +READ8_MEMBER(c65_state::c65_cia0_port_a_r) +{ + UINT8 cia0portb = m_cia0->pb_r(space, 0); + + return cbm_common_cia0_port_a_r(m_cia0, cia0portb); +} + +READ8_MEMBER(c65_state::c65_cia0_port_b_r) +{ + UINT8 value = 0xff; + UINT8 cia0porta = m_cia0->pa_r(space, 0); + + value &= cbm_common_cia0_port_b_r(m_cia0, cia0porta); + + if (!(m_6511_port & 0x02)) + value &= m_keyline; + + return value; +} + +WRITE8_MEMBER(c65_state::c65_cia0_port_b_w) +{ +// was there lightpen support in c65 video chip? +// vic3_device *vic3 = machine().device("vic3"); +// vic3->lightpen_write(data & 0x10); +} + +void c65_state::c65_irq( int level ) +{ + if (level != m_old_level) + { + DBG_LOG(machine(), 3, "mos4510", ("irq %s\n", level ? "start" : "end")); + m_maincpu->set_input_line(M4510_IRQ_LINE, level); + m_old_level = level; + } +} + +/* is this correct for c65 as well as c64? */ +WRITE_LINE_MEMBER(c65_state::c65_cia0_interrupt) +{ + m_cia0_irq = state; + c65_irq(state || m_vicirq); +} + +/* is this correct for c65 as well as c64? */ +WRITE_LINE_MEMBER(c65_state::c65_vic_interrupt) +{ +#if 1 + if (state != m_vicirq) + { + c65_irq (state || m_cia0_irq); + m_vicirq = state; + } +#endif +} + +/* + * CIA 1 - Port A + * bit 7 serial bus data input + * bit 6 serial bus clock input + * bit 5 serial bus data output + * bit 4 serial bus clock output + * bit 3 serial bus atn output + * bit 2 rs232 data output + * bits 1-0 vic-chip system memory bank select + * + * CIA 1 - Port B + * bit 7 user rs232 data set ready + * bit 6 user rs232 clear to send + * bit 5 user + * bit 4 user rs232 carrier detect + * bit 3 user rs232 ring indicator + * bit 2 user rs232 data terminal ready + * bit 1 user rs232 request to send + * bit 0 user rs232 received data + * + * flag restore key or rs232 received data input + * irq to nmi connected ? + */ +READ8_MEMBER(c65_state::c65_cia1_port_a_r) +{ + UINT8 value = 0xff; + + if (!m_iec->clk_r()) + value &= ~0x40; + + if (!m_iec->data_r()) + value &= ~0x80; + + return value; +} + +WRITE8_MEMBER(c65_state::c65_cia1_port_a_w) +{ + static const int helper[4] = {0xc000, 0x8000, 0x4000, 0x0000}; + + m_iec->atn_w(!BIT(data, 3)); + m_iec->clk_w(!BIT(data, 4)); + m_iec->data_w(!BIT(data, 5)); + + m_vicaddr = m_memory + helper[data & 0x03]; +} + +WRITE_LINE_MEMBER(c65_state::c65_cia1_interrupt) +{ + m_cia1_irq = state; + c65_nmi(); +} + +/*********************************************** + + Memory Handlers + +***********************************************/ + +/* processor has only 1 mega address space !? */ +/* and system 8 megabyte */ +/* dma controller and bankswitch hardware ?*/ +READ8_MEMBER( c65_state::c65_read_mem ) +{ + UINT8 result; + if (offset <= 0x0ffff) + result = m_memory[offset]; + else + result = space.read_byte(offset); + return result; +} + +WRITE8_MEMBER( c65_state::c65_write_mem ) +{ + if (offset <= 0x0ffff) + m_memory[offset] = data; + else + space.write_byte(offset, data); +} + +/* dma chip at 0xd700 + used: + writing banknumber to offset 2 + writing hibyte to offset 1 + writing lobyte to offset 0 + cpu holded, dma transfer(data at address) executed, cpu activated + + command data: + 0 command (0 copy, 3 fill) + 1,2 length + 3,4,5 source + 6,7,8 dest + 9 subcommand + 10 mod + + version 1: + seldom copy (overlapping) from 0x402002 to 0x402008 + (making place for new line in basic area) + for whats this bit 0x400000, or is this really the address? + maybe means add counter to address for access, + so allowing up or down copies, and reordering copies + + version 2: + cmd 0x30 used for this +*/ +void c65_state::c65_dma_port_w( int offset, int value ) +{ + PAIR pair, src, dst, len; + UINT8 cmd, fill; + int i; + address_space &space = m_maincpu->space(AS_PROGRAM); + + switch (offset & 3) + { + case 2: + case 1: + m_dma.data[offset & 3] = value; + break; + case 0: + pair.b.h3 = 0; + pair.b.h2 = m_dma.data[2]; + pair.b.h = m_dma.data[1]; + pair.b.l = m_dma.data[0]=value; + cmd = c65_read_mem(space, pair.d++); + len.w.h = 0; + len.b.l = c65_read_mem(space, pair.d++); + len.b.h = c65_read_mem(space, pair.d++); + src.b.h3 = 0; + fill = src.b.l = c65_read_mem(space, pair.d++); + src.b.h = c65_read_mem(space, pair.d++); + src.b.h2 = c65_read_mem(space, pair.d++); + dst.b.h3 = 0; + dst.b.l = c65_read_mem(space, pair.d++); + dst.b.h = c65_read_mem(space, pair.d++); + dst.b.h2 = c65_read_mem(space, pair.d++); + + switch (cmd) + { + case 0: + if (src.d == 0x3ffff) m_dump_dma = 1; + if (m_dump_dma) + DBG_LOG(space.machine(), 1,"dma copy job", + ("len:%.4x src:%.6x dst:%.6x sub:%.2x modrm:%.2x\n", + len.w.l, src.d, dst.d, c65_read_mem(space, pair.d), + c65_read_mem(space, pair.d + 1) ) ); + if ((m_dma.version == 1) + && ( (src.d&0x400000) || (dst.d & 0x400000))) + { + if (!(src.d & 0x400000)) + { + dst.d &= ~0x400000; + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, dst.d--, c65_read_mem(space, src.d++)); + } + else if (!(dst.d & 0x400000)) + { + src.d &= ~0x400000; + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, dst.d++, c65_read_mem(space, src.d--)); + } + else + { + src.d &= ~0x400000; + dst.d &= ~0x400000; + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, --dst.d, c65_read_mem(space, --src.d)); + } + } + else + { + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, dst.d++, c65_read_mem(space, src.d++)); + } + break; + case 3: + DBG_LOG(space.machine(), 3,"dma fill job", + ("len:%.4x value:%.2x dst:%.6x sub:%.2x modrm:%.2x\n", + len.w.l, fill, dst.d, c65_read_mem(space, pair.d), + c65_read_mem(space, pair.d + 1))); + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, dst.d++, fill); + break; + case 0x30: + DBG_LOG(space.machine(), 1,"dma copy down", + ("len:%.4x src:%.6x dst:%.6x sub:%.2x modrm:%.2x\n", + len.w.l, src.d, dst.d, c65_read_mem(space, pair.d), + c65_read_mem(space, pair.d + 1) ) ); + for (i = 0; i < len.w.l; i++) + c65_write_mem(space, dst.d--,c65_read_mem(space, src.d--)); + break; + default: + DBG_LOG(space.machine(), 1,"dma job", + ("cmd:%.2x len:%.4x src:%.6x dst:%.6x sub:%.2x modrm:%.2x\n", + cmd,len.w.l, src.d, dst.d, c65_read_mem(space, pair.d), + c65_read_mem(space, pair.d + 1))); + } + break; + default: + DBG_LOG(space.machine(), 1, "dma chip write", ("%.3x %.2x\n", offset, value)); + break; + } +} + +int c65_state::c65_dma_port_r( int offset ) +{ + /* offset 3 bit 7 in progress ? */ + DBG_LOG(machine(), 2, "dma chip read", ("%.3x\n", offset)); + return 0x7f; +} + +void c65_state::c65_6511_port_w( int offset, int value ) +{ + if (offset == 7) + { + m_6511_port = value; + } + DBG_LOG(machine(), 2, "r6511 write", ("%.2x %.2x\n", offset, value)); +} + +int c65_state::c65_6511_port_r( int offset ) +{ + int data = 0xff; + + if (offset == 7) + { + if (ioport("SPECIAL")->read() & 0x20) + data &= ~1; + } + DBG_LOG(machine(), 2, "r6511 read", ("%.2x\n", offset)); + + return data; +} + +/* one docu states custom 4191 disk controller + (for 2 1MB MFM disk drives, 1 internal, the other extern (optional) 1565 + with integrated 512 byte buffer + + 0->0 reset ? + + 0->1, 0->0, wait until 2 positiv, 1->0 ??? + + 0->0, 0 not 0 means no drive ???, other system entries + + + reg 0 write/read + 0,1 written + bit 1 set + bit 2 set + bit 3 set + bit 4 set + + + reg 0 read + bit 0 + bit 1 + bit 2 + 0..2 ->$1d4 + + reg 1 write + $01 written + $18 written + $46 written + $80 written + $a1 written + $01 written, dec + $10 written + + reg 2 read/write?(lsr) + bit 2 + bit 4 + bit 5 busy waiting until zero, then reading reg 7 + bit 6 operation not activ flag!? or set overflow pin used + bit 7 busy flag? + + reg 3 read/write?(rcr) + bit 1 + bit 3 + bit 7 busy flag? + + reg 4 + track?? + 0 written + read -> $1d2 + cmp #$50 + bcs + + + reg 5 + sector ?? + 1 written + read -> $1d3 + cmp #$b bcc + + + reg 6 + head ?? + 0 written + read -> $1d1 + cmp #2 bcc + + reg 7 read + #4e written + 12 times 0, a1 a1 a1 fe written + + reg 8 read + #ff written + 16 times #ff written + + reg 9 + #60 written + +might use the set overflow input + +$21a6c 9a6c format +$21c97 9c97 write operation +$21ca0 9ca0 get byte? +$21cab 9cab read reg 7 +$21caf 9caf write reg 7 +$21cb3 +*/ + +#define FDC_LOST 4 +#define FDC_CRC 8 +#define FDC_RNF 0x10 +#define FDC_BUSY 0x80 +#define FDC_IRQ 0x200 + +#define FDC_CMD_MOTOR_SPIN_UP 0x10 + +#if 0 +void c65_state::c65_fdc_state(void) +{ + switch (m_fdc.state) + { + case FDC_CMD_MOTOR_SPIN_UP: + if (machine().time() - m_fdc.time) + { + m_fdc.state = 0; + m_fdc.status &= ~FDC_BUSY; + } + break; + } +} +#endif + +void c65_state::c65_fdc_w( int offset, int data ) +{ + DBG_LOG(machine(), 1, "fdc write", ("%.5x %.2x %.2x\n", machine().device("maincpu")->safe_pc(), offset, data)); + switch (offset & 0xf) + { + case 0: + m_fdc.reg[0] = data; + break; + case 1: + m_fdc.reg[1] = data; + switch (data & 0xf9) + { + case 0x20: // wait for motor spin up + m_fdc.status &= ~(FDC_IRQ|FDC_LOST|FDC_CRC|FDC_RNF); + m_fdc.status |= FDC_BUSY; + m_fdc.time = machine().time(); + m_fdc.state = FDC_CMD_MOTOR_SPIN_UP; + break; + case 0: // cancel + m_fdc.status &= ~(FDC_BUSY); + m_fdc.state = 0; + break; + case 0x80: // buffered write + case 0x40: // buffered read + case 0x81: // unbuffered write + case 0x41: // unbuffered read + case 0x30:case 0x31: // step + break; + } + break; + case 2: case 3: // read only + break; + case 4: + m_fdc.reg[offset & 0xf] = data; + m_fdc.track = data; + break; + case 5: + m_fdc.reg[offset & 0xf] = data; + m_fdc.sector = data; + break; + case 6: + m_fdc.reg[offset & 0xf] = data; + m_fdc.head = data; + break; + case 7: + m_fdc.buffer[m_fdc.cpu_pos++] = data; + break; + default: + m_fdc.reg[offset & 0xf] = data; + break; + } +} + +int c65_state::c65_fdc_r( int offset ) +{ + UINT8 data = 0; + switch (offset & 0xf) + { + case 0: + data = m_fdc.reg[0]; + break; + case 1: + data = m_fdc.reg[1]; + break; + case 2: + data = m_fdc.status; + break; + case 3: + data = m_fdc.status >> 8; + break; + case 4: + data = m_fdc.track; + break; + case 5: + data = m_fdc.sector; + break; + case 6: + data = m_fdc.head; + break; + case 7: + data = m_fdc.buffer[m_fdc.cpu_pos++]; + break; + default: + data = m_fdc.reg[offset & 0xf]; + break; + } + DBG_LOG(machine(), 1, "fdc read", ("%.5x %.2x %.2x\n", machine().device("maincpu")->safe_pc(), offset, data)); + return data; +} + +/* version 1 ramcheck + write 0:0 + read write read write 80000,90000,f0000 + write 0:8 + read write read write 80000,90000,f0000 + + version 2 ramcheck??? + read 0: + write 0:0 + read 0: + first read and second read bit 0x80 set --> nothing + write 0:0 + read 0 + write 0:ff +*/ + +READ8_MEMBER( c65_state::c65_ram_expansion_r ) +{ + UINT8 data = 0xff; + if (m_ram->size() > (128 * 1024)) + data = m_expansion_ram.reg; + return data; +} + +WRITE8_MEMBER( c65_state::c65_ram_expansion_w ) +{ + offs_t expansion_ram_begin; + offs_t expansion_ram_end; + + if (m_ram->size() > (128 * 1024)) + { + m_expansion_ram.reg = data; + + expansion_ram_begin = 0x80000; + expansion_ram_end = 0x80000 + (m_ram->size() - 128*1024) - 1; + + if (data == 0x00) { + space.install_readwrite_bank(expansion_ram_begin, expansion_ram_end,"bank16"); + membank("bank16")->set_base(m_ram->pointer() + 128*1024); + } else { + space.nop_readwrite(expansion_ram_begin, expansion_ram_end); + } + } +} + +WRITE8_MEMBER( c65_state::c65_write_io ) +{ + mos6581_device *sid_0 = machine().device("sid_r"); + mos6581_device *sid_1 = machine().device("sid_l"); + vic3_device *vic3 = machine().device("vic3"); + + switch (offset & 0xf00) + { + case 0x000: + if (offset < 0x80) + vic3->port_w(space, offset & 0x7f, data); + else if (offset < 0xa0) + c65_fdc_w(offset & 0x1f, data); + else + { + c65_ram_expansion_w(space, offset & 0x1f, data, mem_mask); + /*ram expansion crtl optional */ + } + break; + case 0x100: + case 0x200: + case 0x300: + vic3->palette_w(space, offset - 0x100, data); + break; + case 0x400: + if (offset<0x420) /* maybe 0x20 */ + sid_0->write(space, offset & 0x3f, data); + else if (offset<0x440) + sid_1->write(space, offset & 0x3f, data); + else + DBG_LOG(machine(), 1, "io write", ("%.3x %.2x\n", offset, data)); + break; + case 0x500: + DBG_LOG(machine(), 1, "io write", ("%.3x %.2x\n", offset, data)); + break; + case 0x600: + c65_6511_port_w(offset & 0xff,data); + break; + case 0x700: + c65_dma_port_w(offset & 0xff, data); + break; + } +} + +WRITE8_MEMBER( c65_state::c65_write_io_dc00 ) +{ + switch (offset & 0xf00) + { + case 0x000: + m_cia0->write(space, offset, data); + break; + case 0x100: + m_cia1->write(space, offset, data); + break; + case 0x200: + case 0x300: + DBG_LOG(machine(), 1, "io write", ("%.3x %.2x\n", offset+0xc00, data)); + break; + } +} + +READ8_MEMBER( c65_state::c65_read_io ) +{ + mos6581_device *sid_0 = machine().device("sid_r"); + mos6581_device *sid_1 = machine().device("sid_l"); + vic3_device *vic3 = machine().device("vic3"); + + switch (offset & 0xf00) + { + case 0x000: + if (offset < 0x80) + return vic3->port_r(space, offset & 0x7f); + if (offset < 0xa0) + return c65_fdc_r(offset & 0x1f); + else + { + return c65_ram_expansion_r(space, offset & 0x1f, mem_mask); + /*return; ram expansion crtl optional */ + } + case 0x100: + case 0x200: + case 0x300: + /* read only !? */ + DBG_LOG(machine(), 1, "io read", ("%.3x\n", offset)); + break; + case 0x400: + if (offset < 0x420) + return sid_0->read(space, offset & 0x3f); + if (offset < 0x440) + return sid_1->read(space, offset & 0x3f); + DBG_LOG(machine(), 1, "io read", ("%.3x\n", offset)); + break; + case 0x500: + DBG_LOG(machine(), 1, "io read", ("%.3x\n", offset)); + break; + case 0x600: + return c65_6511_port_r(offset&0xff); + case 0x700: + return c65_dma_port_r(offset&0xff); + } + return 0xff; +} + +READ8_MEMBER( c65_state::c65_read_io_dc00 ) +{ + switch (offset & 0x300) + { + case 0x000: + return m_cia0->read(space, offset); + case 0x100: + return m_cia1->read(space, offset); + case 0x200: + case 0x300: + DBG_LOG(machine(), 1, "io read", ("%.3x\n", offset+0xc00)); + break; + } + return 0xff; +} + + +/* +d02f: + init a5 96 written (seems to be switch to c65 or vic3 mode) + go64 0 written +*/ + +/* bit 1 external sync enable (genlock) + bit 2 palette enable + bit 6 vic3 c65 character set */ +WRITE8_MEMBER(c65_state::c65_bankswitch_interface) +{ + DBG_LOG(machine(), 2, "c65 bankswitch", ("%.2x\n",data)); + + if (m_io_on) + { + if (data & 1) + { + membank("bank8")->set_base(m_colorram + 0x400); + membank("bank9")->set_base(m_colorram + 0x400); + m_maincpu->space(AS_PROGRAM).install_read_bank(0x0dc00, 0x0dfff, "bank8"); + m_maincpu->space(AS_PROGRAM).install_write_bank(0x0dc00, 0x0dfff, "bank9"); + } + else + { + m_maincpu->space(AS_PROGRAM).install_read_handler(0x0dc00, 0x0dfff, read8_delegate(FUNC(c65_state::c65_read_io_dc00),this)); + m_maincpu->space(AS_PROGRAM).install_write_handler(0x0dc00, 0x0dfff, write8_delegate(FUNC(c65_state::c65_write_io_dc00),this)); + } + } + + m_io_dc00_on = !(data & 1); +#if 0 + /* cartridge roms !?*/ + if (data & 0x08) + membank("bank1")->set_base(m_roml); + else + membank("bank1")->set_base(m_memory + 0x8000); + + if (data & 0x10) + membank("bank2")->set_base(m_basic); + else + membank("bank2")->set_base(m_memory + 0xa000); +#endif + if ((m_old_value^data) & 0x20) + { + /* bankswitching faulty when doing actual page */ + if (data & 0x20) + membank("bank3")->set_base(m_basic); + else + membank("bank3")->set_base(m_memory + 0xc000); + } + m_charset_select = data & 0x40; +#if 0 + /* cartridge roms !?*/ + if (data & 0x80) + membank("bank8")->set_base(m_kernal); + else + membank("bank6")->set_base(m_memory + 0xe000); +#endif + m_old_value = data; +} + +void c65_state::c65_bankswitch( ) +{ + int data, loram, hiram, charen; + + data = 0x00; // machine().device("maincpu")->get_port(); + if (data == m_old_data) + return; + + DBG_LOG(machine(), 1, "bankswitch", ("%d\n", data & 7)); + loram = (data & 1) ? 1 : 0; + hiram = (data & 2) ? 1 : 0; + charen = (data & 4) ? 1 : 0; + + if ((!m_game && m_exrom) || (loram && hiram && !m_exrom)) + membank("bank1")->set_base(m_roml); + else + membank("bank1")->set_base(m_memory + 0x8000); + + if ((!m_game && m_exrom && hiram) || (!m_exrom)) + membank("bank2")->set_base(m_romh); + else if (loram && hiram) + membank("bank2")->set_base(m_basic); + else + membank("bank2")->set_base(m_memory + 0xa000); + + if ((!m_game && m_exrom) || (charen && (loram || hiram))) + { + m_io_on = 1; + membank("bank6")->set_base(m_colorram); + membank("bank7")->set_base(m_colorram); + + if (m_io_dc00_on) + { + m_maincpu->space(AS_PROGRAM).install_read_handler(0x0dc00, 0x0dfff, read8_delegate(FUNC(c65_state::c65_read_io_dc00),this)); + m_maincpu->space(AS_PROGRAM).install_write_handler(0x0dc00, 0x0dfff, write8_delegate(FUNC(c65_state::c65_write_io_dc00),this)); + } + else + { + m_maincpu->space(AS_PROGRAM).install_read_bank(0x0dc00, 0x0dfff, "bank8"); + m_maincpu->space(AS_PROGRAM).install_write_bank(0x0dc00, 0x0dfff, "bank9"); + membank("bank8")->set_base(m_colorram + 0x400); + membank("bank9")->set_base(m_colorram + 0x400); + } + m_maincpu->space(AS_PROGRAM).install_read_handler(0x0d000, 0x0d7ff, read8_delegate(FUNC(c65_state::c65_read_io),this)); + m_maincpu->space(AS_PROGRAM).install_write_handler(0x0d000, 0x0d7ff, write8_delegate(FUNC(c65_state::c65_write_io),this)); + } + else + { + m_io_on = 0; + membank("bank5")->set_base(m_memory + 0xd000); + membank("bank7")->set_base(m_memory + 0xd800); + membank("bank9")->set_base(m_memory + 0xdc00); + if (!charen && (loram || hiram)) + { + membank("bank4")->set_base(m_chargen); + membank("bank6")->set_base(m_chargen + 0x800); + membank("bank8")->set_base(m_chargen + 0xc00); + } + else + { + membank("bank4")->set_base(m_memory + 0xd000); + membank("bank6")->set_base(m_memory + 0xd800); + membank("bank8")->set_base(m_memory + 0xdc00); + } + m_maincpu->space(AS_PROGRAM).install_read_bank(0x0d000, 0x0d7ff, "bank4"); + m_maincpu->space(AS_PROGRAM).install_write_bank(0x0d000, 0x0d7ff, "bank5"); + } + + if (!m_game && m_exrom) + { + membank("bank10")->set_base(m_romh); + } + else + { + if (hiram) + { + membank("bank10")->set_base(m_kernal); + } + else + { + membank("bank10")->set_base(m_memory + 0xe000); + } + } + m_old_data = data; +} + +#ifdef UNUSED_FUNCTION +void c65_state::c65_colorram_write( int offset, int value ) +{ + m_colorram[offset & 0x7ff] = value | 0xf0; +} +#endif + +/* + * only 14 address lines + * a15 and a14 portlines + * 0x1000-0x1fff, 0x9000-0x9fff char rom + */ +READ8_MEMBER(c65_state::c65_dma_read) +{ + if (!m_game && m_exrom) + { + if (offset < 0x3000) + return m_memory[offset]; + return m_romh[offset & 0x1fff]; + } + if ((m_vicaddr == m_memory) || (m_vicaddr == m_memory + 0x8000)) + { + if (offset < 0x1000) + return m_vicaddr[offset & 0x3fff]; + if (offset < 0x2000) { + if (m_charset_select) + return m_chargen[offset & 0xfff]; + else + return m_chargen[offset & 0xfff]; + } + return m_vicaddr[offset & 0x3fff]; + } + return m_vicaddr[offset & 0x3fff]; +} + +READ8_MEMBER(c65_state::c65_dma_read_color) +{ + if (m_c64mode) + return m_colorram[offset & 0x3ff] & 0xf; + return m_colorram[offset & 0x7ff]; +} + +void c65_state::c65_common_driver_init( ) +{ + m_memory = auto_alloc_array_clear(machine(), UINT8, 0x10000); + membank("bank11")->set_base(m_memory + 0x00000); + membank("bank12")->set_base(m_memory + 0x08000); + membank("bank13")->set_base(m_memory + 0x0a000); + membank("bank14")->set_base(m_memory + 0x0c000); + membank("bank15")->set_base(m_memory + 0x0e000); + + cbm_common_init(); + m_keyline = 0xff; + + m_pal = 0; + m_charset_select = 0; + m_6511_port = 0xff; + m_vicirq = 0; + m_old_data = -1; + + /* C65 had no datasette port */ + m_tape_on = 0; + m_game = 1; + m_exrom = 1; + + /*memset(m_memory + 0x40000, 0, 0x800000 - 0x40000); */ +} + +DRIVER_INIT_MEMBER(c65_state,c65) +{ + m_dma.version = 2; + c65_common_driver_init(); +} + +DRIVER_INIT_MEMBER(c65_state,c65pal) +{ + m_dma.version = 1; + c65_common_driver_init(); + m_pal = 1; +} + +MACHINE_START_MEMBER(c65_state,c65) +{ + /* clear upper memory */ + memset(m_ram->pointer() + 128*1024, 0xff, m_ram->size() - 128*1024); + +//removed cbm_drive_0_config (SERIAL, 10); +//removed cbm_drive_1_config (SERIAL, 11); + m_vicaddr = m_memory; + + m_c64mode = 0; + + c65_bankswitch_interface(m_maincpu->space(AS_PROGRAM),0,0xff); + c65_bankswitch(); +} + + +INTERRUPT_GEN_MEMBER(c65_state::c65_frame_interrupt) +{ + int value; + + c65_nmi(); + + /* common keys input ports */ + cbm_common_interrupt(&device); + + /* c65 specific: function keys input ports */ + value = 0xff; + + value &= ~ioport("FUNCT")->read(); + m_keyline = value; +} + -- cgit v1.2.3 From 916aaee5b6557b0949a544ad6751ff3efb6b5a45 Mon Sep 17 00:00:00 2001 From: arbee Date: Wed, 28 Jan 2015 23:53:51 -0500 Subject: (MESS) nes: MIDI In support for Miracle Piano [R. Belmont] --- src/emu/bus/nes_ctrl/ctrl.c | 2 +- src/emu/bus/nes_ctrl/miracle.c | 45 ++++++++++++++++++++++++++++++++++++------ src/emu/bus/nes_ctrl/miracle.h | 6 ++++-- 3 files changed, 44 insertions(+), 9 deletions(-) diff --git a/src/emu/bus/nes_ctrl/ctrl.c b/src/emu/bus/nes_ctrl/ctrl.c index 9e81d228f6a..ea41b6285bc 100644 --- a/src/emu/bus/nes_ctrl/ctrl.c +++ b/src/emu/bus/nes_ctrl/ctrl.c @@ -168,7 +168,7 @@ SLOT_INTERFACE_START( nes_control_port1_devices ) SLOT_INTERFACE("joypad", NES_JOYPAD) SLOT_INTERFACE("zapper", NES_ZAPPER) SLOT_INTERFACE("4score_p1p3", NES_4SCORE_P1P3) -// SLOT_INTERFACE("miracle_piano", NES_MIRACLE) + SLOT_INTERFACE("miracle_piano", NES_MIRACLE) SLOT_INTERFACE_END SLOT_INTERFACE_START( nes_control_port2_devices ) diff --git a/src/emu/bus/nes_ctrl/miracle.c b/src/emu/bus/nes_ctrl/miracle.c index 00b70cd3e2d..bcf596b8d72 100644 --- a/src/emu/bus/nes_ctrl/miracle.c +++ b/src/emu/bus/nes_ctrl/miracle.c @@ -24,6 +24,8 @@ const device_type NES_MIRACLE = &device_creator; MACHINE_CONFIG_FRAGMENT( nes_miracle ) MCFG_MIDI_PORT_ADD("mdin", midiin_slot, "midiin") + MCFG_MIDI_RX_HANDLER(WRITELINE(nes_miracle_device, rx_w)) + MCFG_MIDI_PORT_ADD("mdout", midiout_slot, "midiout") MACHINE_CONFIG_END @@ -99,6 +101,8 @@ void nes_miracle_device::device_reset() set_tra_rate(31250); m_xmit_read = m_xmit_write = 0; + m_recv_read = m_recv_write = 0; + m_read_status = m_status_bit = false; m_tx_busy = false; } @@ -107,16 +111,22 @@ void nes_miracle_device::device_reset() // read //------------------------------------------------- -// TODO: here, reads from serial midi in bit0, when in MIDI_SEND mode - UINT8 nes_miracle_device::read_bit0() { UINT8 ret = 0; if (m_midi_mode == MIRACLE_MIDI_RECEIVE) { - //NES reads from Miracle Piano! - // ret |= ... + if (m_status_bit) + { + m_status_bit = false; + ret = (m_read_status) ? 1 : 0; + } + else + { + ret = (m_data_sent & 0x80) ? 0 : 1; + m_data_sent <<= 1; + } } return ret; @@ -126,7 +136,6 @@ UINT8 nes_miracle_device::read_bit0() // write //------------------------------------------------- -// TODO: here, writes to serial midi in bit0, when in MIDI_RECEIVE mode // c4fc = start of recv routine // c53a = start of send routine @@ -175,6 +184,23 @@ void nes_miracle_device::write(UINT8 data) strobe_timer->reset(); m_strobe_on = 0; m_strobe_clock = 0; + + m_status_bit = true; + if (m_recv_read != m_recv_write) + { +// printf("Getting %02x from Miracle[%d]\n", m_recvring[m_recv_read], m_recv_read); + m_data_sent = m_recvring[m_recv_read++]; + if (m_recv_read >= RECV_RING_SIZE) + { + m_recv_read = 0; + } + m_read_status = true; + } + else + { + m_read_status = false; +// printf("Miracle has no data\n"); + } return; } else if (m_strobe_clock >= 66) @@ -202,7 +228,14 @@ void nes_miracle_device::write(UINT8 data) void nes_miracle_device::rcv_complete() // Rx completed receiving byte { receive_register_extract(); -// UINT8 rcv = get_received_char(); + UINT8 rcv = get_received_char(); + +// printf("Got %02x -> [%d]\n", rcv, m_recv_write); + m_recvring[m_recv_write++] = rcv; + if (m_recv_write >= RECV_RING_SIZE) + { + m_recv_write = 0; + } } void nes_miracle_device::tra_complete() // Tx completed sending byte diff --git a/src/emu/bus/nes_ctrl/miracle.h b/src/emu/bus/nes_ctrl/miracle.h index 1ea7580bc40..5763f0d6059 100644 --- a/src/emu/bus/nes_ctrl/miracle.h +++ b/src/emu/bus/nes_ctrl/miracle.h @@ -29,6 +29,7 @@ class nes_miracle_device : public device_t, { public: static const int XMIT_RING_SIZE = 64; + static const int RECV_RING_SIZE = 64; // construction/destruction nes_miracle_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); @@ -59,9 +60,10 @@ protected: int m_strobe_on, m_midi_mode, m_sent_bits; UINT32 m_strobe_clock; UINT8 m_data_sent; - UINT8 m_xmitring[XMIT_RING_SIZE]; + UINT8 m_xmitring[XMIT_RING_SIZE], m_recvring[RECV_RING_SIZE]; int m_xmit_read, m_xmit_write; - bool m_tx_busy; + int m_recv_read, m_recv_write; + bool m_tx_busy, m_read_status, m_status_bit; }; // device type definition -- cgit v1.2.3 From a49eee8559083442b5b647d27158ecd8e4b3aebe Mon Sep 17 00:00:00 2001 From: Cesare Falco Date: Thu, 29 Jan 2015 12:55:14 +0100 Subject: *nix: Fixed linking tools against system libraries --- makefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/makefile b/makefile index 66760d2574f..9a762b8d259 100644 --- a/makefile +++ b/makefile @@ -756,6 +756,7 @@ INCPATH += -I$(3RDPARTY)/zlib ZLIB = $(OBJ)/libz.a else LIBS += -lz +BASELIBS += -lz ZLIB = endif @@ -766,6 +767,7 @@ FLAC_LIB = $(OBJ)/libflac.a # $(OBJ)/libflac++.a else LIBS += -lFLAC +BASELIBS += -lFLAC FLAC_LIB = endif -- cgit v1.2.3 From e3f6b06fdd5719043933d954ccbbd903a9f88d84 Mon Sep 17 00:00:00 2001 From: Ivan Vangelista Date: Thu, 29 Jan 2015 18:07:41 +0100 Subject: limenko.c, lordgun.c: added save state support (nw) --- src/mame/drivers/limenko.c | 56 ++++++++++++++++++------------- src/mame/drivers/lordgun.c | 82 ++++++++++++++++++++++++++++----------------- src/mame/includes/lordgun.h | 45 ++++++++++++++----------- 3 files changed, 111 insertions(+), 72 deletions(-) diff --git a/src/mame/drivers/limenko.c b/src/mame/drivers/limenko.c index e0f7c166535..9f6868de4dd 100644 --- a/src/mame/drivers/limenko.c +++ b/src/mame/drivers/limenko.c @@ -34,18 +34,25 @@ class limenko_state : public driver_device public: limenko_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), + m_maincpu(*this, "maincpu"), + m_oki(*this, "oki"), + m_qs1000(*this, "qs1000"), + m_gfxdecode(*this, "gfxdecode"), + m_palette(*this, "palette"), m_mainram(*this, "mainram"), m_fg_videoram(*this, "fg_videoram"), m_md_videoram(*this, "md_videoram"), m_bg_videoram(*this, "bg_videoram"), m_spriteram(*this, "spriteram"), m_spriteram2(*this, "spriteram2"), - m_videoreg(*this, "videoreg"), - m_maincpu(*this, "maincpu"), - m_oki(*this, "oki"), - m_gfxdecode(*this, "gfxdecode"), - m_palette(*this, "palette") { } + m_videoreg(*this, "videoreg") { } + required_device m_maincpu; + optional_device m_oki; + optional_device m_qs1000; + required_device m_gfxdecode; + required_device m_palette; + required_shared_ptr m_mainram; required_shared_ptr m_fg_videoram; required_shared_ptr m_md_videoram; @@ -53,14 +60,17 @@ public: required_shared_ptr m_spriteram; required_shared_ptr m_spriteram2; required_shared_ptr m_videoreg; + tilemap_t *m_bg_tilemap; tilemap_t *m_md_tilemap; tilemap_t *m_fg_tilemap; + int m_spriteram_bit; bitmap_ind16 m_sprites_bitmap; bitmap_ind8 m_sprites_bitmap_pri; int m_prev_sprites_count; UINT8 m_spotty_sound_cmd; + DECLARE_WRITE32_MEMBER(limenko_coincounter_w); DECLARE_WRITE32_MEMBER(bg_videoram_w); DECLARE_WRITE32_MEMBER(md_videoram_w); @@ -75,29 +85,28 @@ public: DECLARE_READ32_MEMBER(legendoh_speedup_r); DECLARE_READ32_MEMBER(sb2003_speedup_r); DECLARE_READ32_MEMBER(spotty_speedup_r); - DECLARE_CUSTOM_INPUT_MEMBER(spriteram_bit_r); - DECLARE_READ8_MEMBER(qs1000_p1_r); DECLARE_WRITE8_MEMBER(qs1000_p1_w); DECLARE_WRITE8_MEMBER(qs1000_p2_w); DECLARE_WRITE8_MEMBER(qs1000_p3_w); + + DECLARE_CUSTOM_INPUT_MEMBER(spriteram_bit_r); + DECLARE_DRIVER_INIT(common); DECLARE_DRIVER_INIT(sb2003); DECLARE_DRIVER_INIT(dynabomb); DECLARE_DRIVER_INIT(legendoh); DECLARE_DRIVER_INIT(spotty); + TILE_GET_INFO_MEMBER(get_bg_tile_info); TILE_GET_INFO_MEMBER(get_md_tile_info); TILE_GET_INFO_MEMBER(get_fg_tile_info); + virtual void video_start(); UINT32 screen_update_limenko(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); void draw_single_sprite(bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,UINT32 code,UINT32 color,int flipx,int flipy,int sx,int sy,int priority); void draw_sprites(UINT32 *sprites, const rectangle &cliprect, int count); void copy_sprites(bitmap_ind16 &bitmap, bitmap_ind16 &sprites_bitmap, bitmap_ind8 &priority_bitmap, const rectangle &cliprect); - required_device m_maincpu; - optional_device m_oki; - required_device m_gfxdecode; - required_device m_palette; }; /***************************************************************************************************** @@ -165,10 +174,8 @@ WRITE32_MEMBER(limenko_state::spriteram_buffer_w) WRITE32_MEMBER(limenko_state::limenko_soundlatch_w) { - qs1000_device *qs1000 = machine().device("qs1000"); - soundlatch_byte_w(space, 0, data >> 16); - qs1000->set_irq(ASSERT_LINE); + m_qs1000->set_irq(ASSERT_LINE); machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(100)); } @@ -198,12 +205,10 @@ WRITE8_MEMBER(limenko_state::qs1000_p3_w) // ...x .... - ? // ..x. .... - /IRQ clear - qs1000_device *qs1000 = machine().device("qs1000"); - membank("qs1000:bank")->set_entry(data & 0x07); if (!BIT(data, 5)) - qs1000->set_irq(CLEAR_LINE); + m_qs1000->set_irq(CLEAR_LINE); } /***************************************************************************************************** @@ -500,6 +505,9 @@ void limenko_state::video_start() m_sprites_bitmap.allocate(384,240); m_sprites_bitmap_pri.allocate(384,240); + + save_item(NAME(m_spriteram_bit)); + save_item(NAME(m_prev_sprites_count)); } UINT32 limenko_state::screen_update_limenko(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) @@ -1138,12 +1146,14 @@ DRIVER_INIT_MEMBER(limenko_state,spotty) m_maincpu->space(AS_PROGRAM).install_read_handler(0x6626c, 0x6626f, read32_delegate(FUNC(limenko_state::spotty_speedup_r), this)); m_spriteram_bit = 1; + + save_item(NAME(m_spotty_sound_cmd)); } -GAME( 2000, dynabomb, 0, limenko, sb2003, limenko_state, dynabomb, ROT0, "Limenko", "Dynamite Bomber (Korea, Rev 1.5)", GAME_IMPERFECT_SOUND ) -GAME( 2000, legendoh, 0, limenko, legendoh, limenko_state, legendoh, ROT0, "Limenko", "Legend of Heroes", GAME_IMPERFECT_SOUND ) -GAME( 2003, sb2003, 0, limenko, sb2003, limenko_state, sb2003, ROT0, "Limenko", "Super Bubble 2003 (World, Ver 1.0)", GAME_IMPERFECT_SOUND ) -GAME( 2003, sb2003a, sb2003, limenko, sb2003, limenko_state, sb2003, ROT0, "Limenko", "Super Bubble 2003 (Asia, Ver 1.0)", GAME_IMPERFECT_SOUND ) +GAME( 2000, dynabomb, 0, limenko, sb2003, limenko_state, dynabomb, ROT0, "Limenko", "Dynamite Bomber (Korea, Rev 1.5)", GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) +GAME( 2000, legendoh, 0, limenko, legendoh, limenko_state, legendoh, ROT0, "Limenko", "Legend of Heroes", GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) +GAME( 2003, sb2003, 0, limenko, sb2003, limenko_state, sb2003, ROT0, "Limenko", "Super Bubble 2003 (World, Ver 1.0)", GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) +GAME( 2003, sb2003a, sb2003, limenko, sb2003, limenko_state, sb2003, ROT0, "Limenko", "Super Bubble 2003 (Asia, Ver 1.0)", GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) -// this game only use the same graphics chip used in limenko's system -GAME( 2001, spotty, 0, spotty, spotty, limenko_state, spotty, ROT0, "Prince Co.", "Spotty (Ver. 2.0.2)", GAME_NO_SOUND ) +// this game only uses the same graphics chip used in Limenko's system +GAME( 2001, spotty, 0, spotty, spotty, limenko_state, spotty, ROT0, "Prince Co.", "Spotty (Ver. 2.0.2)", GAME_NO_SOUND | GAME_SUPPORTS_SAVE ) diff --git a/src/mame/drivers/lordgun.c b/src/mame/drivers/lordgun.c index d091a181e67..e025a8347ef 100644 --- a/src/mame/drivers/lordgun.c +++ b/src/mame/drivers/lordgun.c @@ -47,6 +47,7 @@ Notes: #include "sound/ymf278b.h" #include "includes/lordgun.h" + /*************************************************************************** Memory Maps - Main @@ -59,15 +60,15 @@ WRITE16_MEMBER(lordgun_state::lordgun_protection_w) { case 0x00/2: // increment counter { - m_lordgun_protection_data++; - m_lordgun_protection_data &= 0x1f; + m_protection_data++; + m_protection_data &= 0x1f; return; } case 0xc0/2: // reset protection device { - m_lordgun_protection_data = 0; + m_protection_data = 0; return; } @@ -80,22 +81,22 @@ READ16_MEMBER(lordgun_state::lordgun_protection_r) { case 0x40/2: // bitswap and xor counter { - UINT8 x = m_lordgun_protection_data; + UINT8 x = m_protection_data; - m_lordgun_protection_data = ((( x >> 0) | ( x >> 1)) & 1) << 4; - m_lordgun_protection_data |= ((~x >> 2) & 1) << 3; - m_lordgun_protection_data |= (((~x >> 4) | ( x >> 0)) & 1) << 2; - m_lordgun_protection_data |= (( x >> 3) & 1) << 1; - m_lordgun_protection_data |= (((~x >> 0) | ( x >> 2)) & 1) << 0; + m_protection_data = ((( x >> 0) | ( x >> 1)) & 1) << 4; + m_protection_data |= ((~x >> 2) & 1) << 3; + m_protection_data |= (((~x >> 4) | ( x >> 0)) & 1) << 2; + m_protection_data |= (( x >> 3) & 1) << 1; + m_protection_data |= (((~x >> 0) | ( x >> 2)) & 1) << 0; return 0; } case 0x80/2: // return value if conditions are met { - if ((m_lordgun_protection_data & 0x11) == 0x01) return 0x10; - if ((m_lordgun_protection_data & 0x06) == 0x02) return 0x10; - if ((m_lordgun_protection_data & 0x09) == 0x08) return 0x10; + if ((m_protection_data & 0x11) == 0x01) return 0x10; + if ((m_protection_data & 0x06) == 0x02) return 0x10; + if ((m_protection_data & 0x09) == 0x08) return 0x10; return 0; } @@ -110,7 +111,7 @@ WRITE16_MEMBER(lordgun_state::aliencha_protection_w) { case 0xc0/2: // reset protection device { - m_lordgun_protection_data = 0; + m_protection_data = 0; return; } @@ -123,30 +124,30 @@ READ16_MEMBER(lordgun_state::aliencha_protection_r) { case 0x00/2: // de-increment counter { - m_lordgun_protection_data--; - m_lordgun_protection_data &= 0x1f; + m_protection_data--; + m_protection_data &= 0x1f; return 0; } case 0x40/2: // bitswap and xor counter { - UINT8 x = m_lordgun_protection_data; + UINT8 x = m_protection_data; - m_lordgun_protection_data = (((x >> 3) ^ (x >> 2)) & 1) << 4; - m_lordgun_protection_data |= (((x >> 2) ^ (x >> 1)) & 1) << 3; - m_lordgun_protection_data |= (((x >> 1) ^ (x >> 0)) & 1) << 2; - m_lordgun_protection_data |= (((x >> 4) ^ (x >> 0)) & 1) << 1; - m_lordgun_protection_data |= (((x >> 4) ^ (x >> 3)) & 1) << 0; + m_protection_data = (((x >> 3) ^ (x >> 2)) & 1) << 4; + m_protection_data |= (((x >> 2) ^ (x >> 1)) & 1) << 3; + m_protection_data |= (((x >> 1) ^ (x >> 0)) & 1) << 2; + m_protection_data |= (((x >> 4) ^ (x >> 0)) & 1) << 1; + m_protection_data |= (((x >> 4) ^ (x >> 3)) & 1) << 0; return 0; } case 0x80/2: // return value if conditions are met { - if ((m_lordgun_protection_data & 0x11) == 0x00) return 0x20; - if ((m_lordgun_protection_data & 0x06) != 0x06) return 0x20; - if ((m_lordgun_protection_data & 0x18) == 0x00) return 0x20; + if ((m_protection_data & 0x11) == 0x00) return 0x20; + if ((m_protection_data & 0x06) != 0x06) return 0x20; + if ((m_protection_data & 0x18) == 0x00) return 0x20; return 0; } @@ -622,6 +623,13 @@ INPUT_PORTS_END ***************************************************************************/ +void lordgun_state::machine_start() +{ + save_item(NAME(m_protection_data)); + save_item(NAME(m_priority)); + save_item(NAME(m_whitescreen)); +} + static MACHINE_CONFIG_START( lordgun, lordgun_state ) MCFG_CPU_ADD("maincpu", M68000, XTAL_20MHz / 2) MCFG_CPU_PROGRAM_MAP(lordgun_map) @@ -1027,13 +1035,12 @@ ROM_END ***************************************************************************/ -DRIVER_INIT_MEMBER(lordgun_state,lordgun) +DRIVER_INIT_MEMBER(lordgun_state, lordgun) { - int i; UINT16 *rom = (UINT16 *)memregion("maincpu")->base(); int rom_size = 0x100000; - for(i = 0; i < rom_size/2; i++) + for(int i = 0; i < rom_size/2; i++) { UINT16 x = rom[i]; @@ -1042,6 +1049,21 @@ DRIVER_INIT_MEMBER(lordgun_state,lordgun) rom[i] = x; } + + save_item(NAME(m_old)); + + for (int i = 0; i < 2; i++) + { + save_item(NAME(m_gun[i].scr_x), i); + save_item(NAME(m_gun[i].scr_y), i); + save_item(NAME(m_gun[i].hw_x), i); + save_item(NAME(m_gun[i].hw_y), i); + } +} + +DRIVER_INIT_MEMBER(lordgun_state, aliencha) +{ + save_item(NAME(m_aliencha_dip_sel)); } /*************************************************************************** @@ -1050,6 +1072,6 @@ DRIVER_INIT_MEMBER(lordgun_state,lordgun) ***************************************************************************/ -GAME( 1994, lordgun, 0, lordgun, lordgun, lordgun_state, lordgun, ROT0, "IGS", "Lord of Gun (USA)", GAME_IMPERFECT_GRAPHICS ) -GAME( 1994, aliencha, 0, aliencha, aliencha, driver_device, 0, ROT0, "IGS", "Alien Challenge (World)", 0 ) -GAME( 1994, alienchac, aliencha, aliencha, aliencha, driver_device, 0, ROT0, "IGS", "Alien Challenge (China)", 0 ) +GAME( 1994, lordgun, 0, lordgun, lordgun, lordgun_state, lordgun, ROT0, "IGS", "Lord of Gun (USA)", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE ) +GAME( 1994, aliencha, 0, aliencha, aliencha, driver_device, 0, ROT0, "IGS", "Alien Challenge (World)", GAME_SUPPORTS_SAVE ) +GAME( 1994, alienchac, aliencha, aliencha, aliencha, driver_device, 0, ROT0, "IGS", "Alien Challenge (China)", GAME_SUPPORTS_SAVE ) diff --git a/src/mame/includes/lordgun.h b/src/mame/includes/lordgun.h index a9f4e9d3906..16fabd759b2 100644 --- a/src/mame/includes/lordgun.h +++ b/src/mame/includes/lordgun.h @@ -17,12 +17,6 @@ class lordgun_state : public driver_device public: lordgun_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), - m_priority_ram(*this, "priority_ram"), - m_scrollram(*this, "scrollram"), - m_spriteram(*this, "spriteram"), - m_vram(*this, "vram"), - m_scroll_x(*this, "scroll_x"), - m_scroll_y(*this, "scroll_y") , m_maincpu(*this, "maincpu"), m_soundcpu(*this, "soundcpu"), m_oki(*this, "oki"), @@ -30,24 +24,39 @@ public: m_gfxdecode(*this, "gfxdecode"), m_screen(*this, "screen"), m_palette(*this, "palette"), - m_generic_paletteram_16(*this, "paletteram") { } + m_generic_paletteram_16(*this, "paletteram"), + m_priority_ram(*this, "priority_ram"), + m_scrollram(*this, "scrollram"), + m_spriteram(*this, "spriteram"), + m_vram(*this, "vram"), + m_scroll_x(*this, "scroll_x"), + m_scroll_y(*this, "scroll_y") { } + required_device m_maincpu; + required_device m_soundcpu; + required_device m_oki; + required_device m_eeprom; + required_device m_gfxdecode; + required_device m_screen; + required_device m_palette; + + required_shared_ptr m_generic_paletteram_16; required_shared_ptr m_priority_ram; required_shared_ptr m_scrollram; required_shared_ptr m_spriteram; + required_shared_ptr_array m_vram; + required_shared_ptr_array m_scroll_x; + required_shared_ptr_array m_scroll_y; UINT8 m_old; UINT8 m_aliencha_dip_sel; UINT16 m_priority; - required_shared_ptr_array m_vram; - required_shared_ptr_array m_scroll_x; - required_shared_ptr_array m_scroll_y; int m_whitescreen; lordgun_gun_data m_gun[2]; tilemap_t *m_tilemap[4]; bitmap_ind16 *m_bitmaps[5]; - UINT16 m_lordgun_protection_data; + UINT16 m_protection_data; DECLARE_WRITE16_MEMBER(lordgun_protection_w); DECLARE_READ16_MEMBER(lordgun_protection_r); DECLARE_WRITE16_MEMBER(aliencha_protection_w); @@ -71,26 +80,24 @@ public: DECLARE_READ8_MEMBER(aliencha_dip_r); DECLARE_WRITE8_MEMBER(aliencha_dip_w); DECLARE_WRITE8_MEMBER(lordgun_okibank_w); + + DECLARE_DRIVER_INIT(aliencha); DECLARE_DRIVER_INIT(lordgun); + TILE_GET_INFO_MEMBER(get_tile_info_0); TILE_GET_INFO_MEMBER(get_tile_info_1); TILE_GET_INFO_MEMBER(get_tile_info_2); TILE_GET_INFO_MEMBER(get_tile_info_3); + + virtual void machine_start(); virtual void video_start(); + UINT32 screen_update_lordgun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); inline void get_tile_info(tile_data &tileinfo, tilemap_memory_index tile_index, int _N_); inline void lordgun_vram_w(offs_t offset, UINT16 data, UINT16 mem_mask, int _N_); void lorddgun_calc_gun_scr(int i); void lordgun_update_gun(int i); void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect); - required_device m_maincpu; - required_device m_soundcpu; - required_device m_oki; - required_device m_eeprom; - required_device m_gfxdecode; - required_device m_screen; - required_device m_palette; - required_shared_ptr m_generic_paletteram_16; }; /*----------- defined in video/lordgun.c -----------*/ -- cgit v1.2.3 From 537326b28232b7bbff28f542b27de3d97c9ecbaf Mon Sep 17 00:00:00 2001 From: hap Date: Thu, 29 Jan 2015 19:00:02 +0100 Subject: mnemonics to uppercase --- src/emu/cpu/tms0980/tms0980d.c | 41 ++++++++++++++++++++--------------------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/src/emu/cpu/tms0980/tms0980d.c b/src/emu/cpu/tms0980/tms0980d.c index cf0efae29ae..ea72ba9be2e 100644 --- a/src/emu/cpu/tms0980/tms0980d.c +++ b/src/emu/cpu/tms0980/tms0980d.c @@ -1,18 +1,16 @@ -/******************************************************************* +// license:BSD-3-Clause +// copyright-holders:Wilbert Pol, hap +/* - TMS0980 disassembly + TMS0980/TMS1000-family disassembler -*******************************************************************/ +*/ #include "emu.h" #include "debugger.h" #include "tms0980.h" -#define _OVER DASMFLAG_STEP_OVER -#define _OUT DASMFLAG_STEP_OUT - - enum e_mnemonics { zA10AAC=0, zA6AAC, zA8AAC, zAC1AC, zACACC, zACNAA, zALEC, zALEM, zAMAAC, zBRANCH, zCALL, zCCLA, zCLA, zCLO, zCOMC, zCOMX, zCOMX8, zCPAIZ, zCTMDYN, zDAN, zDMAN, zDMEA, zDNAA, @@ -24,24 +22,21 @@ enum e_mnemonics { zILL }; - -enum e_addressing { - zB0=0, zI2, zI3, zI4, zB7 -}; - - static const char *const s_mnemonic[] = { - "a10aac", "a6aac", "a8aac", "ac1ac", "acacc", "acnaa", "alec", "alem", "amaac", "branch", "call", "ccla", - "cla", "clo", "comc", "comx", "comx8", "cpaiz", "ctmdyn", "dan", "dman", "dmea", "dnaa", - "dyn", "ia", "imac", "iyc", "knez", "ldp", "ldx", "ldx", "ldx", "mnea", "mnez", - "ndmea", "off", "rbit", "reac", "retn", "rstr", "sal", "saman", "sbit", - "sbl", "seac", "setr", "tam", "tamacs", "tamdyn", "tamiy", "tamiyc", "tamza", - "tay", "tbit", "tcmiy", "tcy", "tdo", "tka", "tkm", "tma", - "tmy", "tya", "xda", "xma", "ymcy", "ynea", "ynec", - "illegal" + "A10AAC", "A6AAC", "A8AAC", "AC1AC", "ACACC", "ACNAA", "ALEC", "ALEM", "AMAAC", "BRANCH", "CALL", "CCLA", + "CLA", "CLO", "COMC", "COMX", "COMX8", "CPAIZ", "CTMDYN", "DAN", "DMAN", "DMEA", "DNAA", + "DYN", "IA", "IMAC", "IYC", "KNEZ", "LDP", "LDX", "LDX", "LDX", "MNEA", "MNEZ", + "NDMEA", "OFF", "RBIT", "REAC", "RETN", "RSTR", "SAL", "SAMAN", "SBIT", + "SBL", "SEAC", "SETR", "TAM", "TAMACS", "TAMDYN", "TAMIY", "TAMIYC", "TAMZA", + "TAY", "TBIT", "TCMIY", "TCY", "TDO", "TKA", "TKM", "TMA", + "TMY", "TYA", "XDA", "XMA", "YMCY", "YNEA", "YNEC", + "?" }; +#define _OVER DASMFLAG_STEP_OVER +#define _OUT DASMFLAG_STEP_OUT + static const UINT32 s_flags[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _OVER, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -54,6 +49,10 @@ static const UINT32 s_flags[] = { }; +enum e_addressing { + zB0=0, zI2, zI3, zI4, zB7 +}; + static const UINT8 s_addressing[] = { zB0, zB0, zB0, zI4, zI4, zI4, zI4, zB0, zB0, zB7, zB7, zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, -- cgit v1.2.3