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

c-chip: use dumped c-chip for Volfied and Superman, remove simulation [Team Caps0ff] (#3298)

Browse Source 
* c-chip: use dumped c-chip for Volfied [Team Caps0ff]

interrupt source still needs to be verified, but I've tested this to the end and it works fine with the real dump.

* less static (nw)

* hook the coin counters back up (nw)

* tweaks (nw)

* was too close after tweak (nw)

* add support for dumped superman c-chip too, removed simulation [Team Caps0ff]

also made the 68k and upd7810 use different banked windows into the RAM, this seems to prevent the fighting I was seeing, and also superman suggests that it might be correct, as it puts response values in a bank for the 68k but then changes the window so the 68k can't see them.  needs further testing tho (other c-chip dumps might tell us more later)

* use the 68k side handlers on megab too, even if it really doesn't care about anything (nw)

* remove debug structure (nw)
This commit is contained in:
David Haywood 2018-03-06 01:32:52 +00:00 committed by R. Belmont
parent 4431d2e723
commit db566d4954
10 changed files with 374 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/target/mame/arcade.lua
View File

@ -3859,7 +3859,6 @@ files {
MAME_DIR .. "src/mame/video/undrfire.cpp",
MAME_DIR .. "src/mame/drivers/volfied.cpp",
MAME_DIR .. "src/mame/includes/volfied.h",
MAME_DIR .. "src/mame/machine/volfied.cpp",
MAME_DIR .. "src/mame/video/volfied.cpp",
MAME_DIR .. "src/mame/drivers/warriorb.cpp",
MAME_DIR .. "src/mame/includes/warriorb.h",

17
src/devices/cpu/upd7810/upd7810.cpp
View File

@ -1476,10 +1476,11 @@ void upd7810_device::handle_timers(int cycles)
m_adcnt -= m_adtot;
switch (m_adout)
{
case 0: CR0 = m_tmpcr; break;
case 1: CR1 = m_tmpcr; break;
case 2: CR2 = m_tmpcr; break;
case 3: CR3 = m_tmpcr; break;
// volfied code checks bit 0x80, old code set bit 0x01, TODO: verify which bits are set on real hw
case 0: CR0 = m_tmpcr ? 0xff:0x00; break;
case 1: CR1 = m_tmpcr ? 0xff:0x00; break;
case 2: CR2 = m_tmpcr ? 0xff:0x00; break;
case 3: CR3 = m_tmpcr ? 0xff:0x00; break;
}
m_adout = (m_adout + 1) & 0x03;
if (m_adout == 0)
@ -1510,10 +1511,10 @@ void upd7810_device::handle_timers(int cycles)
m_adcnt -= m_adtot;
switch (m_adout)
{
case 0: CR0 = m_tmpcr; break;
case 1: CR1 = m_tmpcr; break;
case 2: CR2 = m_tmpcr; break;
case 3: CR3 = m_tmpcr; break;
case 0: CR0 = m_tmpcr ? 0xff:0x00; break;
case 1: CR1 = m_tmpcr ? 0xff:0x00; break;
case 2: CR2 = m_tmpcr ? 0xff:0x00; break;
case 3: CR3 = m_tmpcr ? 0xff:0x00; break;
}
m_adin = (m_adin + 1) & 0x07;
m_adout = (m_adout + 1) & 0x03;

4
src/mame/drivers/taito_f2.cpp
View File

@ -653,8 +653,8 @@ ADDRESS_MAP_START(taitof2_state::megab_map)
AM_RANGE(0x100000, 0x100001) AM_DEVWRITE8("tc0140syt", tc0140syt_device, master_port_w, 0xff00)
AM_RANGE(0x100002, 0x100003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, master_comm_r, master_comm_w, 0xff00)
AM_RANGE(0x120000, 0x12000f) AM_DEVREADWRITE8("tc0220ioc", tc0220ioc_device, read, write, 0x00ff)
AM_RANGE(0x180000, 0x1807ff) AM_DEVREADWRITE8("cchip", taito_cchip_device, mem_r, mem_w, 0x00ff)
AM_RANGE(0x180800, 0x180fff) AM_DEVREADWRITE8("cchip", taito_cchip_device, asic_r, asic_w, 0x00ff)
AM_RANGE(0x180000, 0x1807ff) AM_DEVREADWRITE8("cchip", taito_cchip_device, mem68_r, mem68_w, 0x00ff)
AM_RANGE(0x180800, 0x180fff) AM_DEVREADWRITE8("cchip", taito_cchip_device, asic_r, asic68_w, 0x00ff)
AM_RANGE(0x200000, 0x20ffff) AM_RAM
AM_RANGE(0x300000, 0x301fff) AM_RAM_DEVWRITE("palette", palette_device, write16) AM_SHARE("palette")
AM_RANGE(0x400000, 0x40001f) AM_DEVWRITE8("tc0360pri", tc0360pri_device, write, 0x00ff) /* ?? */

188
src/mame/drivers/taito_x.cpp
View File

@ -27,23 +27,6 @@ Supported games:
This file contains routines to interface with the Taito Controller Chip
(or "Command Chip") version 1. It's currently used by Superman.
Superman (revised SJ 060601)
--------
In Superman, the C-chip's main purpose is to handle player inputs and
coins and pass commands along to the sound chip.
The 68k queries the c-chip, which passes back $100 bytes of 68k code which
are then executed in RAM. To get around this, we hack in our own code to
communicate with the sound board, since we are familiar with the interface
as it's used in Rastan and Super Space Invaders '91.
It is believed that the NOPs in the 68k code are there to supply the
necessary cycles to the cchip to switch banks.
This code requires that the player & coin inputs be in input ports 2-4.
Memory map:
----------------------------------------------------
0x000000 - 0x07ffff : ROM
@ -345,114 +328,14 @@ Stephh's notes (based on the game M68000 code and some tests) :
#include "screen.h"
#include "speaker.h"
/* This code for sound communication is a hack, it will not be
identical to the code derived from the real c-chip */
static const uint8_t superman_code[40] =
WRITE8_MEMBER(taitox_state::superman_counters_w)
{
0x48, 0xe7, 0x80, 0x80, /* MOVEM.L D0/A0,-(A7) ( Preserve Regs ) */
0x20, 0x6d, 0x1c, 0x40, /* MOVEA.L ($1C40,A5),A0 ( Load sound pointer in A0 ) */
0x30, 0x2f, 0x00, 0x0c, /* MOVE.W ($0C,A7),D0 ( Fetch sound number ) */
0x10, 0x80, /* MOVE.B D0,(A0) ( Store it on sound pointer ) */
0x52, 0x88, /* ADDQ.W #1,A0 ( Increment sound pointer ) */
0x20, 0x3c, 0x00, 0xf0, 0x1c, 0x40, /* MOVE.L #$F01C40,D0 ( Load top of buffer in D0 ) */
0xb1, 0xc0, /* CMPA.L D0,A0 ( Are we there yet? ) */
0x66, 0x04, /* BNE.S *+$6 ( No, we arent, skip next line ) */
0x41, 0xed, 0x1c, 0x20, /* LEA ($1C20,A5),A0 ( Point to the start of the buffer ) */
0x2b, 0x48, 0x1c, 0x40, /* MOVE.L A0,($1C40,A5) ( Store new sound pointer ) */
0x4c, 0xdf, 0x01, 0x01, /* MOVEM.L (A7)+, D0/A0 ( Restore Regs ) */
0x4e, 0x75 /* RTS ( Return ) */
};
/*************************************
*
* Writes to C-Chip - Important Bits
*
*************************************/
WRITE16_MEMBER( taitox_state::cchip1_ctrl_w )
{
/* value 2 is written here */
machine().bookkeeping().coin_lockout_w(1, data & 0x08);
machine().bookkeeping().coin_lockout_w(0, data & 0x04);
machine().bookkeeping().coin_counter_w(1, data & 0x02);
machine().bookkeeping().coin_counter_w(0, data & 0x01);
}
WRITE16_MEMBER( taitox_state::cchip1_bank_w )
{
m_current_bank = data & 7;
}
WRITE16_MEMBER( taitox_state::cchip1_ram_w )
{
if (m_current_bank == 0 && offset == 0x03)
{
m_cc_port = data;
machine().bookkeeping().coin_lockout_w(1, data & 0x08);
machine().bookkeeping().coin_lockout_w(0, data & 0x04);
machine().bookkeeping().coin_counter_w(1, data & 0x02);
machine().bookkeeping().coin_counter_w(0, data & 0x01);
}
else
{
logerror("cchip1_w pc: %06x bank %02x offset %04x: %02x\n",m_maincpu->pc(),m_current_bank,offset,data);
}
}
/*************************************
*
* Reads from C-Chip
*
*************************************/
READ16_MEMBER( taitox_state::cchip1_ctrl_r )
{
/*
Bit 2 = Error signal
Bit 0 = Ready signal
*/
return 0x01; /* Return 0x05 for C-Chip error */
}
READ16_MEMBER( taitox_state::cchip1_ram_r )
{
/* Check for input ports */
if (m_current_bank == 0)
{
switch (offset)
{
case 0x00: return machine().root_device().ioport("IN0")->read(); /* Player 1 controls + START1 */
case 0x01: return machine().root_device().ioport("IN1")->read(); /* Player 2 controls + START2 */
case 0x02: return machine().root_device().ioport("IN2")->read(); /* COINn + SERVICE1 + TILT */
case 0x03: return m_cc_port;
}
}
/* Other non-standard offsets */
if (m_current_bank == 1 && offset <= 0xff)
{
if (offset < 40) /* our hack code is only 40 bytes long */
return superman_code[offset];
else /* so pad with zeros */
return 0;
}
if (m_current_bank == 2)
{
switch (offset)
{
case 0x000: return 0x47;
case 0x001: return 0x57;
case 0x002: return 0x4b;
}
}
logerror("cchip1_r bank: %02x offset: %04x\n",m_current_bank,offset);
return 0;
}
READ16_MEMBER(taitox_state::superman_dsw_input_r)
{
switch (offset)
@ -542,9 +425,8 @@ ADDRESS_MAP_START(taitox_state::superman_map)
AM_RANGE(0x600000, 0x600001) AM_WRITENOP /* written each frame at $3ab0, mostly 0x10 */
AM_RANGE(0x800000, 0x800001) AM_READNOP AM_DEVWRITE8("tc0140syt", tc0140syt_device, master_port_w, 0x00ff)
AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_device, master_comm_r, master_comm_w, 0x00ff)
AM_RANGE(0x900000, 0x9007ff) AM_READWRITE(cchip1_ram_r, cchip1_ram_w)
AM_RANGE(0x900802, 0x900803) AM_READWRITE(cchip1_ctrl_r, cchip1_ctrl_w)
AM_RANGE(0x900c00, 0x900c01) AM_WRITE(cchip1_bank_w)
AM_RANGE(0x900000, 0x9007ff) AM_DEVREADWRITE8("cchip", taito_cchip_device, mem68_r, mem68_w, 0x00ff)
AM_RANGE(0x900800, 0x900fff) AM_DEVREADWRITE8("cchip", taito_cchip_device, asic_r, asic68_w, 0x00ff)
AM_RANGE(0xb00000, 0xb00fff) AM_RAM_DEVWRITE("palette", palette_device, write16) AM_SHARE("palette")
AM_RANGE(0xd00000, 0xd005ff) AM_RAM AM_DEVREADWRITE("spritegen", seta001_device, spriteylow_r16, spriteylow_w16) // Sprites Y
AM_RANGE(0xd00600, 0xd00607) AM_RAM AM_DEVREADWRITE("spritegen", seta001_device, spritectrl_r16, spritectrl_w16)
@ -737,6 +619,16 @@ static INPUT_PORTS_START( superman )
PORT_DIPSETTING( 0x30, "3" )
PORT_DIPSETTING( 0x10, "4" )
PORT_DIPSETTING( 0x00, "5" )
PORT_MODIFY("IN2")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_COIN1 )
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_COIN2 )
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE1 )
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_TILT )
INPUT_PORTS_END
static INPUT_PORTS_START( supermanu )
@ -904,17 +796,26 @@ MACHINE_START_MEMBER(taitox_state,taitox)
membank("z80bank")->configure_entries(0, banks, memregion("audiocpu")->base(), 0x4000);
}
MACHINE_START_MEMBER(taitox_state,superman)
TIMER_DEVICE_CALLBACK_MEMBER(taitox_state::scanline)
{
int banks = memregion("audiocpu")->bytes() / 0x4000;
membank("z80bank")->configure_entries(0, banks, memregion("audiocpu")->base(), 0x4000);
m_current_bank = 0;
m_cc_port = 0;
save_item(NAME(m_current_bank));
save_item(NAME(m_cc_port));
if (param == 240)
{
m_maincpu->set_input_line(6, HOLD_LINE);
}
else if (param == 40)
{
// see notes in volfied.cpp
m_cchip->ext_interrupt(ASSERT_LINE);
m_cchip_irq_clear->adjust(attotime::zero);
}
}
TIMER_DEVICE_CALLBACK_MEMBER(taitox_state::cchip_irq_clear_cb)
{
m_cchip->ext_interrupt(CLEAR_LINE);
}
/**************************************************************************/
MACHINE_CONFIG_START(taitox_state::superman)
@ -922,16 +823,23 @@ MACHINE_CONFIG_START(taitox_state::superman)
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", M68000, XTAL(16'000'000)/2) /* verified on pcb */
MCFG_CPU_PROGRAM_MAP(superman_map)
MCFG_CPU_VBLANK_INT_DRIVER("screen", taitox_state, irq6_line_hold)
//MCFG_CPU_VBLANK_INT_DRIVER("screen", taitox_state, irq6_line_hold)
MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", taitox_state, scanline, "screen", 0, 1)
MCFG_CPU_ADD("audiocpu", Z80, XTAL(16'000'000)/4) /* verified on pcb */
MCFG_CPU_PROGRAM_MAP(sound_map)
MCFG_TAITO_CCHIP_ADD("cchip", XTAL(12'000'000)/2) /* ? MHz */
MCFG_TAITO_CCHIP_ADD("cchip", XTAL(12'000'000)) /* ? MHz */
MCFG_CCHIP_IN_PORTA_CB(IOPORT("IN0"))
MCFG_CCHIP_IN_PORTB_CB(IOPORT("IN1"))
MCFG_CCHIP_IN_PORTAD_CB(IOPORT("IN2"))
MCFG_CCHIP_OUT_PORTC_CB(WRITE8(taitox_state, superman_counters_w))
MCFG_TIMER_DRIVER_ADD("cchip_irq_clear", taitox_state, cchip_irq_clear_cb)
MCFG_QUANTUM_TIME(attotime::from_hz(600)) /* 10 CPU slices per frame - enough for the sound CPU to read all commands */
MCFG_MACHINE_START_OVERRIDE(taitox_state,superman)
MCFG_MACHINE_START_OVERRIDE(taitox_state,taitox)
MCFG_DEVICE_ADD("spritegen", SETA001_SPRITE, 0)
MCFG_SETA001_SPRITE_GFXDECODE("gfxdecode")
@ -1178,7 +1086,7 @@ ROM_START( superman )
ROM_LOAD( "b61-01.e18", 0x00000, 0x80000, CRC(3cf99786) SHA1(f6febf9bda87ca04f0a5890d0e8001c26dfa6c81) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, CRC(3bc5d44b) SHA1(6ba3ba35fe313af77d732412572d91a202b50542) )
ROM_END
ROM_START( supermanu ) /* No US copyright notice or FBI logo - Just a coinage difference, see notes above */
@ -1201,7 +1109,7 @@ ROM_START( supermanu ) /* No US copyright notice or FBI logo - Just a coinage di
ROM_LOAD( "b61-01.e18", 0x00000, 0x80000, CRC(3cf99786) SHA1(f6febf9bda87ca04f0a5890d0e8001c26dfa6c81) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, CRC(3bc5d44b) SHA1(6ba3ba35fe313af77d732412572d91a202b50542) )
ROM_END
ROM_START( supermanj ) /* Shows a Japan copyright notice */
@ -1224,7 +1132,7 @@ ROM_START( supermanj ) /* Shows a Japan copyright notice */
ROM_LOAD( "b61-01.e18", 0x00000, 0x80000, CRC(3cf99786) SHA1(f6febf9bda87ca04f0a5890d0e8001c26dfa6c81) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "b61_11.m11", 0x0000, 0x2000, CRC(3bc5d44b) SHA1(6ba3ba35fe313af77d732412572d91a202b50542) )
ROM_END
/*

64
src/mame/drivers/volfied.cpp
View File

@ -78,9 +78,8 @@ ADDRESS_MAP_START(volfied_state::main_map)
AM_RANGE(0xd00000, 0xd00001) AM_READWRITE(video_ctrl_r, video_ctrl_w)
AM_RANGE(0xe00000, 0xe00001) AM_DEVWRITE8("ciu", pc060ha_device, master_port_w, 0x00ff)
AM_RANGE(0xe00002, 0xe00003) AM_DEVREADWRITE8("ciu", pc060ha_device, master_comm_r, master_comm_w, 0x00ff)
AM_RANGE(0xf00000, 0xf007ff) AM_READWRITE(cchip_ram_r, cchip_ram_w)
AM_RANGE(0xf00802, 0xf00803) AM_READWRITE(cchip_ctrl_r, cchip_ctrl_w)
AM_RANGE(0xf00c00, 0xf00c01) AM_WRITE(cchip_bank_w)
AM_RANGE(0xf00000, 0xf007ff) AM_DEVREADWRITE8("cchip", taito_cchip_device, mem68_r, mem68_w, 0x00ff)
AM_RANGE(0xf00800, 0xf00fff) AM_DEVREADWRITE8("cchip", taito_cchip_device, asic_r, asic68_w, 0x00ff)
ADDRESS_MAP_END
ADDRESS_MAP_START(volfied_state::z80_map)
@ -161,11 +160,11 @@ static INPUT_PORTS_START( volfied )
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_COCKTAIL
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_COCKTAIL
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_COCKTAIL
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY PORT_COCKTAIL
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_COCKTAIL
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_8WAY PORT_COCKTAIL // TODO: probably correct based on initial analysis, but why is this on bit 0x80 when read through the c-chip when it was 0x08 in the simulation and for P1, is it just a Taito workaround for reading through ADC?
INPUT_PORTS_END
static INPUT_PORTS_START( volfiedu )
@ -211,28 +210,63 @@ GFXDECODE_END
void volfied_state::machine_start()
{
cchip_init();
}
void volfied_state::machine_reset()
{
cchip_reset();
}
WRITE8_MEMBER(volfied_state::counters_w)
{
machine().bookkeeping().coin_lockout_w(1, data & 0x80);
machine().bookkeeping().coin_lockout_w(0, data & 0x40);
machine().bookkeeping().coin_counter_w(1, data & 0x20);
machine().bookkeeping().coin_counter_w(0, data & 0x10);
}
TIMER_DEVICE_CALLBACK_MEMBER(volfied_state::scanline)
{
if (param == 240)
{
m_maincpu->set_input_line(4, HOLD_LINE);
}
else if (param == 40)
{
/* it isn't clear when / how this should be generated. if it's too close to the main vblank you get spurious inputs, including TILT and additional coins when ingame
so for now we generate it at a fixed interval after vbl. test mode doesn't use 68k interrupts so you get the odd bad frame in the input test as the idle loop
drifts out of sync with the vbl signal */
m_cchip->ext_interrupt(ASSERT_LINE);
m_cchip_irq_clear->adjust(attotime::zero);
}
}
TIMER_DEVICE_CALLBACK_MEMBER(volfied_state::cchip_irq_clear_cb)
{
m_cchip->ext_interrupt(CLEAR_LINE);
}
MACHINE_CONFIG_START(volfied_state::volfied)
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", M68000, CPU_CLOCK) /* 8MHz */
MCFG_CPU_PROGRAM_MAP(main_map)
MCFG_CPU_VBLANK_INT_DRIVER("screen", volfied_state, irq4_line_hold)
// MCFG_CPU_VBLANK_INT_DRIVER("screen", volfied_state, irq4_line_hold)
MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", volfied_state, scanline, "screen", 0, 1)
MCFG_CPU_ADD("audiocpu", Z80, SOUND_CPU_CLOCK) /* 4MHz sound CPU, required to run the game */
MCFG_CPU_PROGRAM_MAP(z80_map)
MCFG_TAITO_CCHIP_ADD("cchip", XTAL(12'000'000)/2) /* ? MHz */
MCFG_TAITO_CCHIP_ADD("cchip", XTAL(12'000'000)) /* ? MHz */
MCFG_CCHIP_IN_PORTA_CB(IOPORT("F00007"))
MCFG_CCHIP_IN_PORTB_CB(IOPORT("F00009"))
MCFG_CCHIP_IN_PORTC_CB(IOPORT("F0000B"))
MCFG_CCHIP_IN_PORTAD_CB(IOPORT("F0000D"))
MCFG_CCHIP_OUT_PORTB_CB(WRITE8(volfied_state, counters_w))
MCFG_QUANTUM_TIME(attotime::from_hz(1200))
MCFG_TIMER_DRIVER_ADD("cchip_irq_clear", volfied_state, cchip_irq_clear_cb)
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
@ -285,7 +319,7 @@ ROM_START( volfied )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )
@ -317,7 +351,7 @@ ROM_START( volfiedo )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )
@ -349,7 +383,7 @@ ROM_START( volfiedu )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )
@ -381,7 +415,7 @@ ROM_START( volfieduo )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )
@ -413,7 +447,7 @@ ROM_START( volfiedj )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )
@ -445,7 +479,7 @@ ROM_START( volfiedjo )
ROM_LOAD16_BYTE( "c04-21.8", 0xc0001, 0x20000, CRC(8598d38e) SHA1(4ec1b819586b50e2f6aff2aaa5e3b06704b9bec2) )
ROM_REGION( 0x2000, "cchip:cchip_eprom", 0 )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, NO_DUMP )
ROM_LOAD( "cchip_c04-23", 0x0000, 0x2000, CRC(46b0b479) SHA1(73aa2267eb468c5aa5db67183047e9aef8321215) )
ROM_REGION( 0xc0000, "gfx1", 0 ) /* sprites 16x16 */
ROM_LOAD16_BYTE( "c04-16.2", 0x00000, 0x20000, CRC(8c2476ef) SHA1(972ddc8e47a669f1aeca67d02b4a0bed867ddb7d) )

23
src/mame/includes/taito_x.h
View File

@ -8,34 +8,29 @@
#include "includes/seta.h"
#include "machine/taitocchip.h"
#include "machine/timer.h"
class taitox_state : public seta_state
{
public:
taitox_state(const machine_config &mconfig, device_type type, const char *tag)
: seta_state(mconfig, type, tag),
m_cchip(*this, "cchip")
m_cchip(*this, "cchip"),
m_cchip_irq_clear(*this, "cchip_irq_clear")
{ }
optional_device<taito_cchip_device> m_cchip;
DECLARE_READ16_MEMBER(superman_dsw_input_r);
DECLARE_WRITE8_MEMBER(superman_counters_w);
DECLARE_READ16_MEMBER(daisenpu_input_r);
DECLARE_WRITE16_MEMBER(daisenpu_input_w);
DECLARE_WRITE16_MEMBER(kyustrkr_input_w);
DECLARE_WRITE8_MEMBER(sound_bankswitch_w);
DECLARE_DRIVER_INIT(kyustrkr);
DECLARE_MACHINE_START(taitox);
DECLARE_MACHINE_START(superman);
// superman c-chip
uint16_t m_current_bank;
uint8_t m_cc_port;
DECLARE_READ16_MEMBER( cchip1_ctrl_r );
DECLARE_READ16_MEMBER( cchip1_ram_r );
DECLARE_WRITE16_MEMBER( cchip1_ctrl_w );
DECLARE_WRITE16_MEMBER( cchip1_bank_w );
DECLARE_WRITE16_MEMBER( cchip1_ram_w );
TIMER_DEVICE_CALLBACK_MEMBER(scanline);
TIMER_DEVICE_CALLBACK_MEMBER(cchip_irq_clear_cb);
void superman(machine_config &config);
void ballbros(machine_config &config);
void gigandes(machine_config &config);
@ -46,6 +41,10 @@ public:
void gigandes_map(address_map &map);
void sound_map(address_map &map);
void superman_map(address_map &map);
private:
optional_device<taito_cchip_device> m_cchip;
optional_device<timer_device> m_cchip_irq_clear;
};
#endif // MAME_INCLUDES_TAITO_X_H

60
src/mame/includes/volfied.h
View File

@ -13,6 +13,7 @@
#include "machine/taitocchip.h"
#include "video/pc090oj.h"
#include "screen.h"
#include "machine/timer.h"
class volfied_state : public driver_device
{
@ -28,23 +29,38 @@ public:
m_audiocpu(*this, "audiocpu"),
m_cchip(*this, "cchip"),
m_pc090oj(*this, "pc090oj"),
m_screen(*this, "screen") { }
m_screen(*this, "screen"),
m_cchip_irq_clear(*this, "cchip_irq_clear")
{ }
DECLARE_READ16_MEMBER(video_ram_r);
DECLARE_WRITE16_MEMBER(video_ram_w);
DECLARE_WRITE16_MEMBER(video_ctrl_w);
DECLARE_READ16_MEMBER(video_ctrl_r);
DECLARE_WRITE16_MEMBER(video_mask_w);
DECLARE_WRITE16_MEMBER(sprite_ctrl_w);
DECLARE_WRITE8_MEMBER(counters_w);
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(scanline);
TIMER_DEVICE_CALLBACK_MEMBER(cchip_irq_clear_cb);
void refresh_pixel_layer( bitmap_ind16 &bitmap );
void volfied(machine_config &config);
void main_map(address_map &map);
void z80_map(address_map &map);
private:
/* memory pointers */
std::unique_ptr<uint16_t[]> m_video_ram;
std::unique_ptr<uint8_t[]> m_cchip_ram;
/* video-related */
uint16_t m_video_ctrl;
uint16_t m_video_mask;
/* c-chip */
uint8_t m_current_bank;
uint8_t m_current_flag;
uint8_t m_cc_port;
uint8_t m_current_cmd;
emu_timer *m_cchip_timer;
/* devices */
required_device<cpu_device> m_maincpu;
required_device<cpu_device> m_audiocpu;
@ -52,31 +68,7 @@ public:
required_device<pc090oj_device> m_pc090oj;
required_device<screen_device> m_screen;
DECLARE_WRITE16_MEMBER(cchip_ctrl_w);
DECLARE_WRITE16_MEMBER(cchip_bank_w);
DECLARE_WRITE16_MEMBER(cchip_ram_w);
DECLARE_READ16_MEMBER(cchip_ctrl_r);
DECLARE_READ16_MEMBER(cchip_ram_r);
DECLARE_READ16_MEMBER(video_ram_r);
DECLARE_WRITE16_MEMBER(video_ram_w);
DECLARE_WRITE16_MEMBER(video_ctrl_w);
DECLARE_READ16_MEMBER(video_ctrl_r);
DECLARE_WRITE16_MEMBER(video_mask_w);
DECLARE_WRITE16_MEMBER(sprite_ctrl_w);
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void video_start() override;
uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(timer_callback);
void refresh_pixel_layer( bitmap_ind16 &bitmap );
void cchip_init();
void cchip_reset();
void volfied(machine_config &config);
void main_map(address_map &map);
void z80_map(address_map &map);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
required_device<timer_device> m_cchip_irq_clear;
};
#endif // MAME_INCLUDES_VOLFIED_H

163
src/mame/machine/taitocchip.cpp
View File

@ -105,10 +105,23 @@ taito_cchip_device::taito_cchip_device(const machine_config &mconfig, const char
: device_t(mconfig, TAITO_CCHIP, tag, owner, clock),
m_upd7811(*this, "upd7811"),
m_upd4464_bank(*this, "upd4464_bank"),
m_upd4464(*this, "upd4464")
m_upd4464_bank68(*this, "upd4464_bank68"),
m_upd4464(*this, "upd4464"),
m_in_pa_cb(*this),
m_in_pb_cb(*this),
m_in_pc_cb(*this),
m_in_ad_cb(*this),
m_out_pa_cb(*this),
m_out_pb_cb(*this),
m_out_pc_cb(*this)
{
}
void taito_cchip_device::ext_interrupt(int state)
{
m_upd7811->set_input_line(UPD7810_INTF1, state);
}
ROM_START( taito_cchip )
ROM_REGION( 0x1000, "upd7811", 0 )
// optically extracted, the internal checksum passes, although that doesn't rule out the possibility of error
@ -120,13 +133,17 @@ ADDRESS_MAP_START(taito_cchip_device::cchip_ram_bank)
AM_RANGE(0x0000, 0x1fff) AM_RAM AM_SHARE("upd4464") // upd4464
ADDRESS_MAP_END
ADDRESS_MAP_START(taito_cchip_device::cchip_ram_bank68)
AM_RANGE(0x0000, 0x1fff) AM_RAM AM_SHARE("upd4464")
ADDRESS_MAP_END
READ8_MEMBER(taito_cchip_device::asic_r)
{
if ((offset != 0x001) && (!machine().side_effects_disabled())) // prevent logerror spam for now
logerror("%s: asic_r %04x\n", machine().describe_context(), offset);
if (offset<0x200) // 400-5ff is asic 'ram'
return m_asic_ram[offset&3];
return 0x00; // 600-7ff is read-only(?) asic banking reg, may read as open bus or never assert /DTACK on read?
return 0x00; // 600-7ff is write-only(?) asic banking reg, may read as open bus or never assert /DTACK on read?
}
WRITE8_MEMBER(taito_cchip_device::asic_w)
@ -141,6 +158,18 @@ WRITE8_MEMBER(taito_cchip_device::asic_w)
m_asic_ram[offset&3] = data;
}
WRITE8_MEMBER(taito_cchip_device::asic68_w)
{
logerror("%s: asic68_w %04x %02x\n", machine().describe_context(), offset, data);
if (offset == 0x200)
{
logerror("cchip (68k side) set bank to %02x\n", data & 0x7);
m_upd4464_bank68->set_bank(data & 0x7);
}
else
m_asic_ram[offset&3] = data;
}
READ8_MEMBER(taito_cchip_device::mem_r)
{
offset &= 0x3ff;
@ -153,16 +182,126 @@ WRITE8_MEMBER(taito_cchip_device::mem_w)
return m_upd4464_bank->write8(space,offset,data);
}
READ8_MEMBER(taito_cchip_device::mem68_r)
{
offset &= 0x3ff;
return m_upd4464_bank68->read8(space,offset);
}
WRITE8_MEMBER(taito_cchip_device::mem68_w)
{
offset &= 0x3ff;
return m_upd4464_bank68->write8(space,offset,data);
}
ADDRESS_MAP_START(taito_cchip_device::cchip_map)
//AM_RANGE(0x0000, 0x0fff) AM_ROM // internal ROM of uPD7811
AM_RANGE(0x1000, 0x13ff) AM_DEVICE("upd4464_bank", address_map_bank_device, amap8)
AM_RANGE(0x1400, 0x17ff) AM_READWRITE(asic_r, asic_w)
AM_RANGE(0x2000, 0x3fff) AM_ROM AM_REGION("cchip_eprom", 0) // might not map here
AM_RANGE(0x2000, 0x3fff) AM_ROM AM_REGION("cchip_eprom", 0)
ADDRESS_MAP_END
WRITE8_MEMBER(taito_cchip_device::porta_w)
{
m_out_pa_cb(data);
}
WRITE8_MEMBER(taito_cchip_device::portb_w)
{
m_out_pb_cb(data);
}
WRITE8_MEMBER(taito_cchip_device::portc_w)
{
m_out_pc_cb(data);
}
WRITE8_MEMBER(taito_cchip_device::portf_w)
{
// internal? related to locking out the 68k?
logerror("%s port F written %.2x\n", machine().describe_context(), data);
}
READ8_MEMBER(taito_cchip_device::porta_r)
{
return m_in_pa_cb();
}
READ8_MEMBER(taito_cchip_device::portb_r)
{
return m_in_pb_cb();
}
READ8_MEMBER(taito_cchip_device::portc_r)
{
return m_in_pc_cb();
}
READ_LINE_MEMBER( taito_cchip_device::an0_r )
{
return BIT(m_in_ad_cb(), 0);
}
READ_LINE_MEMBER( taito_cchip_device::an1_r )
{
return BIT(m_in_ad_cb(), 1);
}
READ_LINE_MEMBER( taito_cchip_device::an2_r )
{
return BIT(m_in_ad_cb(), 2);
}
READ_LINE_MEMBER( taito_cchip_device::an3_r )
{
return BIT(m_in_ad_cb(), 3);
}
READ_LINE_MEMBER( taito_cchip_device::an4_r )
{
return BIT(m_in_ad_cb(), 4);
}
READ_LINE_MEMBER( taito_cchip_device::an5_r )
{
return BIT(m_in_ad_cb(), 5);
}
READ_LINE_MEMBER( taito_cchip_device::an6_r )
{
return BIT(m_in_ad_cb(), 6);
}
READ_LINE_MEMBER( taito_cchip_device::an7_r )
{
return BIT(m_in_ad_cb(), 7);
}
MACHINE_CONFIG_START(taito_cchip_device::device_add_mconfig)
MCFG_CPU_ADD("upd7811", UPD7811, DERIVED_CLOCK(1,1))
MCFG_CPU_PROGRAM_MAP(cchip_map)
MCFG_UPD7810_PORTA_READ_CB(READ8(taito_cchip_device, porta_r))
MCFG_UPD7810_PORTB_READ_CB(READ8(taito_cchip_device, portb_r))
MCFG_UPD7810_PORTC_READ_CB(READ8(taito_cchip_device, portc_r))
MCFG_UPD7810_PORTA_WRITE_CB(WRITE8(taito_cchip_device, porta_w))
MCFG_UPD7810_PORTB_WRITE_CB(WRITE8(taito_cchip_device, portb_w))
MCFG_UPD7810_PORTC_WRITE_CB(WRITE8(taito_cchip_device, portc_w))
MCFG_UPD7810_PORTF_WRITE_CB(WRITE8(taito_cchip_device, portf_w))
MCFG_UPD7810_AN0(READLINE(taito_cchip_device, an0_r))
MCFG_UPD7810_AN1(READLINE(taito_cchip_device, an1_r))
MCFG_UPD7810_AN2(READLINE(taito_cchip_device, an2_r))
MCFG_UPD7810_AN3(READLINE(taito_cchip_device, an3_r))
MCFG_UPD7810_AN4(READLINE(taito_cchip_device, an4_r))
MCFG_UPD7810_AN5(READLINE(taito_cchip_device, an5_r))
MCFG_UPD7810_AN6(READLINE(taito_cchip_device, an6_r))
MCFG_UPD7810_AN7(READLINE(taito_cchip_device, an7_r))
MCFG_DEVICE_ADD("upd4464_bank", ADDRESS_MAP_BANK, 0)
MCFG_DEVICE_PROGRAM_MAP(cchip_ram_bank)
@ -170,14 +309,32 @@ MACHINE_CONFIG_START(taito_cchip_device::device_add_mconfig)
MCFG_ADDRESS_MAP_BANK_DATA_WIDTH(8)
MCFG_ADDRESS_MAP_BANK_ADDR_WIDTH(13)
MCFG_ADDRESS_MAP_BANK_STRIDE(0x400)
// the 68k has a different view into the banked memory?
MCFG_DEVICE_ADD("upd4464_bank68", ADDRESS_MAP_BANK, 0)
MCFG_DEVICE_PROGRAM_MAP(cchip_ram_bank68)
MCFG_ADDRESS_MAP_BANK_ENDIANNESS(ENDIANNESS_LITTLE)
MCFG_ADDRESS_MAP_BANK_DATA_WIDTH(8)
MCFG_ADDRESS_MAP_BANK_ADDR_WIDTH(13)
MCFG_ADDRESS_MAP_BANK_STRIDE(0x400)
MACHINE_CONFIG_END
void taito_cchip_device::device_start()
{
m_upd4464_bank->set_bank(0);
m_upd4464_bank68->set_bank(0);
save_item(NAME(m_asic_ram));
m_asic_ram[0] = m_asic_ram[1] = m_asic_ram[2] = m_asic_ram[3] = 0;
m_in_pa_cb.resolve_safe(0);
m_in_pb_cb.resolve_safe(0);
m_in_pc_cb.resolve_safe(0);
m_in_ad_cb.resolve_safe(0);
m_out_pa_cb.resolve_safe();
m_out_pb_cb.resolve_safe();
m_out_pc_cb.resolve_safe();
}
void taito_cchip_device::device_reset()

70
src/mame/machine/taitocchip.h
View File

@ -14,6 +14,27 @@ DECLARE_DEVICE_TYPE(TAITO_CCHIP, taito_cchip_device)
#define MCFG_TAITO_CCHIP_ADD(_tag, _clock) \
MCFG_DEVICE_ADD(_tag, TAITO_CCHIP, _clock)
#define MCFG_CCHIP_IN_PORTA_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_in_pa_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_IN_PORTB_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_in_pb_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_IN_PORTC_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_in_pc_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_IN_PORTAD_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_in_ad_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_OUT_PORTA_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_out_pa_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_OUT_PORTB_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_out_pb_callback(DEVCB_##_devcb);
#define MCFG_CCHIP_OUT_PORTC_CB(_devcb) \
devcb = &downcast<taito_cchip_device &>(*device).set_out_pc_callback(DEVCB_##_devcb);
class taito_cchip_device : public device_t
{
@ -21,14 +42,51 @@ public:
// construction/destruction
taito_cchip_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> devcb_base &set_in_pa_callback(Object &&cb) { return m_in_pa_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_pb_callback(Object &&cb) { return m_in_pb_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_pc_callback(Object &&cb) { return m_in_pc_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_ad_callback(Object &&cb) { return m_in_ad_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_pa_callback(Object &&cb) { return m_out_pa_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_pb_callback(Object &&cb) { return m_out_pb_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_pc_callback(Object &&cb) { return m_out_pc_cb.set_callback(std::forward<Object>(cb)); }
// can be accessed externally
DECLARE_READ8_MEMBER(asic_r);
DECLARE_WRITE8_MEMBER(asic_w);
DECLARE_WRITE8_MEMBER(asic68_w);
DECLARE_READ8_MEMBER(mem_r);
DECLARE_WRITE8_MEMBER(mem_w);
DECLARE_READ8_MEMBER(mem68_r);
DECLARE_WRITE8_MEMBER(mem68_w);
void cchip_map(address_map &map);
void cchip_ram_bank(address_map &map);
void cchip_ram_bank68(address_map &map);
DECLARE_READ8_MEMBER(porta_r);
DECLARE_READ8_MEMBER(portb_r);
DECLARE_READ8_MEMBER(portc_r);
DECLARE_WRITE8_MEMBER(porta_w);
DECLARE_WRITE8_MEMBER(portb_w);
DECLARE_WRITE8_MEMBER(portc_w);
DECLARE_WRITE8_MEMBER(portf_w);
DECLARE_READ_LINE_MEMBER(an0_r);
DECLARE_READ_LINE_MEMBER(an1_r);
DECLARE_READ_LINE_MEMBER(an2_r);
DECLARE_READ_LINE_MEMBER(an3_r);
DECLARE_READ_LINE_MEMBER(an4_r);
DECLARE_READ_LINE_MEMBER(an5_r);
DECLARE_READ_LINE_MEMBER(an6_r);
DECLARE_READ_LINE_MEMBER(an7_r);
void ext_interrupt(int state);
protected:
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
@ -36,10 +94,20 @@ protected:
virtual void device_reset() override;
private:
uint8_t m_asic_ram[4];
required_device<cpu_device> m_upd7811;
required_device<address_map_bank_device> m_upd4464_bank;
required_device<address_map_bank_device> m_upd4464_bank68;
required_shared_ptr<uint8_t> m_upd4464;
uint8_t m_asic_ram[4];
devcb_read8 m_in_pa_cb;
devcb_read8 m_in_pb_cb;
devcb_read8 m_in_pc_cb;
devcb_read8 m_in_ad_cb;
devcb_write8 m_out_pa_cb;
devcb_write8 m_out_pb_cb;
devcb_write8 m_out_pc_cb;
};
#endif // MAME_MACHINE_CCHIP_DEV_H

506
src/mame/machine/volfied.cpp
View File

@ -1,506 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Bryan McPhail, Nicola Salmoria
/*************************************************************************
Volfied C-Chip Protection
=========================
The C-Chip (Taito TC0030CMD) contains a NEC D78C11 (with 4k internal ROM) +
8k EPROM + 8k DRAM + logic.
Cheat:
volfied:0:100191:00:001:Complete level with 99.9% Now!
volfied:0:100192:99:501:Complete level with 99.9% Now! (2/3)
volfied:0:100193:09:501:Complete level with 99.9% Now! (3/3)
*************************************************************************/
#include "emu.h"
#include "includes/volfied.h"
static const uint16_t palette_data_01[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x104a, 0xce41, 0x8c39, 0x5252, 0xd662, 0x4a31, 0x0000,
0x1e00, 0x1000, 0x9e01, 0x1e02, 0xde02, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x104a, 0xce41, 0x8c39, 0x5252, 0xd662, 0x4a31, 0x0000,
0x1e00, 0x1000, 0x9e01, 0x1e02, 0xde02, 0x0000, 0x0000, 0x0000,
0x0000, 0xd62a, 0x1002, 0xce01, 0x5a3b, 0xde7b, 0x4a31, 0x0000,
0x1e00, 0x1000, 0x9e01, 0x1e02, 0xde02, 0x0038, 0x0e38, 0x0000
};
static const uint16_t palette_data_02[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x4008, 0x0029, 0xc641, 0x4c52, 0x5473, 0xde7b, 0x1863,
0x524a, 0xce39, 0x0821, 0x9c01, 0x1200, 0x8001, 0xc002, 0xce39,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x4a29, 0xce39, 0xde7b, 0x4001, 0x4002, 0xc003,
0x9e01, 0x1e00, 0x0078, 0x0e00, 0x5401, 0x0040, 0xde03, 0x1600,
0x0000, 0x4208, 0x0c39, 0xd061, 0x547a, 0x1472, 0xde7b, 0xde7b,
0x187b, 0x947a, 0x0821, 0x9e79, 0x1040, 0x8079, 0xc07a, 0x0000
};
static const uint16_t palette_data_03[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xc038, 0x4049, 0xc059, 0x406a, 0xc07a, 0x4208, 0x0821,
0x8c31, 0x1042, 0x9c73, 0x1e03, 0x1a02, 0x0c00, 0x1860, 0x1e78,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x4a29, 0xce39, 0xde7b, 0x4001, 0x4002, 0xc003,
0x9e01, 0x1e00, 0x0078, 0x0e00, 0x5401, 0x0040, 0xde03, 0x1600,
0x0000, 0xc001, 0x4002, 0x8002, 0xc002, 0xc002, 0x0001, 0xc001,
0x9201, 0xc002, 0xc003, 0x0003, 0x8002, 0x4001, 0xc002, 0x4003
};
static const uint16_t palette_data_04[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x1042, 0xce39, 0x8c31, 0x524a, 0xd65a, 0x4a29, 0x0000,
0x1e00, 0x1000, 0x8c21, 0xce29, 0x0039, 0x0038, 0x0e38, 0x0038,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x1002, 0xce01, 0x8c01, 0x5202, 0xd602, 0x4a01, 0x0000,
0x1e00, 0x1000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};
static const uint16_t palette_data_05[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x1200, 0x1600, 0x1a00, 0x9e01, 0x8021, 0xc029, 0x0032,
0x803a, 0x4208, 0x0821, 0x1042, 0xd65a, 0x9c73, 0xde03, 0x5c02,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x5202, 0xd602, 0x5a03, 0xde03, 0x8021, 0xc029, 0x0032,
0x803a, 0x4208, 0x0821, 0x1042, 0xd65a, 0x9c73, 0xde03, 0x5c02
};
static const uint16_t palette_data_06[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x9e52, 0x9028, 0x9428, 0x9828, 0x9e28, 0x4208, 0xde7b,
0xde03, 0x9c02, 0xc03a, 0x0063, 0x586b, 0x9252, 0x8a31, 0x5e31,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0263, 0x9e52, 0x8058, 0x0879, 0x8c79, 0x107a, 0x4208, 0xde7b,
0xde01, 0x1e01, 0xc03a, 0x0063, 0x586b, 0x9252, 0x8a31, 0x527a
};
static const uint16_t palette_data_07[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xc038, 0x4049, 0xc059, 0x406a, 0xc07a, 0x4208, 0x0821,
0x8c31, 0x1042, 0x9c73, 0x1e03, 0x1a02, 0x0c00, 0x1860, 0x1e78,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x4a29, 0xce39, 0xde7b, 0x4001, 0x4002, 0xc003,
0x9e01, 0x1e00, 0x0078, 0x0e00, 0x5401, 0x0040, 0xde03, 0x1600,
0x0000, 0x8001, 0x0002, 0x8002, 0x0003, 0x8003, 0x4208, 0x0821,
0x8c31, 0x1042, 0x9c73, 0x1e00, 0x5c02, 0x0c00, 0x1860, 0x1e78
};
static const uint16_t palette_data_08[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x1042, 0xce39, 0x8c31, 0x524a, 0xd65a, 0x4a29, 0x0000,
0x1e00, 0x1000, 0x9e01, 0x5e02, 0x5e03, 0x0038, 0x0e38, 0x0000,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x5202, 0x1002, 0xce19, 0x9432, 0x1843, 0x8c11, 0x0000,
0x1e00, 0x1000, 0x9e01, 0x5e02, 0x5e03, 0x0038, 0x0e38, 0x0000
};
static const uint16_t palette_data_09[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x1048, 0x1250, 0x1458, 0x1660, 0xd418, 0x9e02, 0xc203,
0x4208, 0x4a29, 0x8c31, 0x1042, 0x1e78, 0x166b, 0x0c38, 0x1868,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x1600, 0x1a21, 0x5c29, 0xde39, 0xd418, 0x9e02, 0xc203,
0x4208, 0x4a29, 0x8c31, 0x1042, 0x1e42, 0x186b, 0x9210, 0x9e31
};
static const uint16_t palette_data_0a[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0038, 0x4a29, 0xce39, 0x9452, 0x9218, 0xde7b,
0xc001, 0xc003, 0xde03, 0x1403, 0xcc01, 0x4a01, 0x0668, 0x4672,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x0000, 0x0038, 0x4a29, 0x5401, 0x9c02, 0x9218, 0xde7b,
0x0003, 0xc003, 0x5e02, 0xde01, 0x5201, 0xd200, 0x0668, 0x4672
};
static const uint16_t palette_data_0b[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0050, 0x8001, 0xc001, 0x0002, 0xc002, 0xd043, 0x9c73, 0x524a,
0xce39, 0x8c31, 0x4208, 0xde03, 0x9c02, 0x1e60, 0x1a00, 0x1000,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x8c01, 0xce01, 0x1002, 0xd62a, 0xde4b, 0x9c73, 0x5202,
0xce01, 0x8c01, 0x4208, 0xde03, 0x9c02, 0x1e60, 0x1a00, 0x1000
};
static const uint16_t palette_data_0c[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0038, 0x4a29, 0xce39, 0x9452, 0x9218, 0x9e52,
0xc001, 0xc003, 0x1e00, 0x1400, 0x0c00, 0x4a01, 0x0668, 0x4672,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0x0000, 0x0038, 0x4a29, 0xce39, 0x9452, 0x9218, 0xde7b,
0xc001, 0xc003, 0xde03, 0x1403, 0xcc01, 0x4a01, 0x0668, 0x4672
};
static const uint16_t palette_data_0d[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0078, 0x4208, 0x1052, 0x9462, 0x1873, 0x5a73, 0xde7b, 0x1863,
0x524a, 0xce39, 0x0821, 0x1600, 0x1000, 0xd201, 0xde03, 0x0a42,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0078, 0x4208, 0x1052, 0x9462, 0x1873, 0x5a73, 0xde7b, 0x1863,
0x524a, 0xce39, 0x0821, 0x1600, 0x1000, 0xd201, 0xde03, 0x0a42,
0x0000, 0x4208, 0x5029, 0x9431, 0xd839, 0x5a4a, 0x9e52, 0x5862,
0xde4b, 0x8e39, 0x0821, 0x1600, 0x1000, 0xd201, 0x1e00, 0x0a42
};
static const uint16_t palette_data_0e[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0e01, 0x5001, 0x9201, 0xd401, 0x1602, 0x1200, 0x1600,
0x4208, 0x0821, 0x8c31, 0x1042, 0x5a6b, 0x8001, 0x0002, 0x9a02,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x4a29, 0xce39, 0xde7b, 0x4001, 0x4002, 0xc003,
0x9e01, 0x1e00, 0x0078, 0x0e00, 0x5401, 0x0040, 0xde03, 0x1600,
0x0000, 0x8a21, 0x0a32, 0x4c3a, 0x8e4a, 0x504b, 0xd203, 0xc003,
0x4208, 0x0821, 0x8c31, 0x1042, 0x5a6b, 0x8001, 0x0002, 0x545b
};
static const uint16_t palette_data_0f[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xc038, 0x4049, 0xc059, 0x406a, 0xc07a, 0x0000, 0x0821,
0x9c31, 0x1042, 0x9c73, 0x1e02, 0x1a02, 0x0c00, 0x4002, 0xc001,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0xde7b, 0x1e00, 0xc003, 0x1042, 0xde03, 0x0000, 0xd65a,
0xce39, 0x8c31, 0x4a29, 0x0078, 0xc07b, 0x1e02, 0x1e78, 0xc003,
0x0000, 0xce00, 0x5201, 0xd601, 0x5a02, 0xde02, 0x0000, 0x0821,
0x8c31, 0x1042, 0x9c73, 0x1e03, 0x1a02, 0x0c00, 0x9e01, 0x0e00
};
static const uint16_t palette_data_10[0x50] =
{
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x0601, 0x8a09, 0x0e1a, 0x922a, 0x163b, 0xde7b, 0xd65a,
0xce39, 0x0821, 0x0000, 0x0c00, 0x5208, 0x1a02, 0x9e03, 0xce39,
0x0000, 0xde7b, 0xde03, 0x5e01, 0x5e02, 0xc07b, 0x0000, 0xde7b,
0x0058, 0x4079, 0x407a, 0x407b, 0xd47b, 0x0000, 0x0000, 0x0000,
0x0000, 0x1400, 0x8002, 0x0068, 0x0000, 0x5e01, 0x5e02, 0x1e03,
0xde03, 0xce39, 0xce39, 0xce39, 0xce39, 0xce39, 0xce39, 0xce39,
0x0078, 0x4208, 0x1052, 0x9462, 0x1873, 0x5a73, 0xde7b, 0x1863,
0x524a, 0xce39, 0x0821, 0x1600, 0x1000, 0xd201, 0xde03, 0x0a42
};
static const uint16_t palette_data_11[0x50] =
{
0x0000, 0x4a29, 0x8c31, 0xce39, 0x1042, 0x524a, 0x9452, 0xd65a,
0x1863, 0x0000, 0xde39, 0xde7b, 0xc001, 0x8002, 0x1800, 0x1e00,
0x0000, 0xde7b, 0x1e00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00,
0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00, 0x1e00,
0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03,
0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03, 0xde03,
0xde03, 0x0e00, 0x9e4a, 0x0000, 0x1042, 0xde7b, 0x9452, 0x4a29,
0xce39, 0x1c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};
static const uint16_t *const palette_data_lookup[] =
{
nullptr,
palette_data_01,
palette_data_02,
palette_data_03,
palette_data_04,
palette_data_05,
palette_data_06,
palette_data_07,
palette_data_08,
palette_data_09,
palette_data_0a,
palette_data_0b,
palette_data_0c,
palette_data_0d,
palette_data_0e,
palette_data_0f,
palette_data_10,
palette_data_11
};
void volfied_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_VOLFIED:
timer_callback(ptr, param);
break;
default:
assert_always(false, "Unknown id in volfied_state::device_timer");
}
}
TIMER_CALLBACK_MEMBER(volfied_state::timer_callback)
{
// Palette commands - palette data written to bank 0: $10 - $af
if (m_current_cmd >= 0x1 && m_current_cmd < 0x12)
{
const uint16_t* palette_data = palette_data_lookup[m_current_cmd];
int i;
for (i = 0; i < 0x50; i++)
{
m_cchip_ram[0x10 + i * 2 + 0] = palette_data[i] >> 8;
m_cchip_ram[0x10 + i * 2 + 1] = palette_data[i] & 0xff;
}
}
// Unknown command - result written to bank 0: $23
if (m_current_cmd >= 0x81 && m_current_cmd < 0x92)
{
switch (m_current_cmd)
{
case 0x81: m_cchip_ram[0x23] = 0xf; break;
case 0x82: m_cchip_ram[0x23] = 0x1; break;
case 0x83: m_cchip_ram[0x23] = 0x6; break;
case 0x84: m_cchip_ram[0x23] = 0xf; break;
case 0x85: m_cchip_ram[0x23] = 0x9; break;
case 0x86: m_cchip_ram[0x23] = 0x6; break;
case 0x87: m_cchip_ram[0x23] = 0x6; break;
case 0x88: m_cchip_ram[0x23] = 0xf; break;
case 0x89: m_cchip_ram[0x23] = 0x8; break;
case 0x8a: m_cchip_ram[0x23] = 0x1; break;
case 0x8b: m_cchip_ram[0x23] = 0xa; break;
case 0x8c: m_cchip_ram[0x23] = 0x1; break;
case 0x8d: m_cchip_ram[0x23] = 0x1; break;
case 0x8e: m_cchip_ram[0x23] = 0x8; break;
case 0x8f: m_cchip_ram[0x23] = 0x6; break;
case 0x90: m_cchip_ram[0x23] = 0xa; break;
case 0x91: m_cchip_ram[0x23] = 0x0; break;
}
}
m_current_cmd = 0;
}
/*************************************
*
* Writes to C-Chip - Important Bits
*
*************************************/
WRITE16_MEMBER(volfied_state::cchip_ctrl_w)
{
/* value 2 is written here */
}
WRITE16_MEMBER(volfied_state::cchip_bank_w)
{
m_current_bank = data & 7;
}
WRITE16_MEMBER(volfied_state::cchip_ram_w)
{
m_cchip_ram[(m_current_bank * 0x400) + offset] = data;
if (m_current_bank == 0)
{
if (offset == 0x008)
{
m_cc_port = data;
machine().bookkeeping().coin_lockout_w(1, data & 0x80);
machine().bookkeeping().coin_lockout_w(0, data & 0x40);
machine().bookkeeping().coin_counter_w(1, data & 0x20);
machine().bookkeeping().coin_counter_w(0, data & 0x10);
}
if (offset == 0x3fe)
{
/*******************
(This table stored in ROM at $146a8)
(Level number stored at $100198.b, from $100118.b, from $100098.b)
(Level number at $b34 stored to $100098.b)
round 01 => data $0A
round 02 => data $01
round 03 => data $03
round 04 => data $08
round 05 => data $05
round 06 => data $04
round 07 => data $0B
round 08 => data $09
round 09 => data $07
round 10 => data $06
round 11 => data $0E
round 12 => data $0D
round 13 => data $02
round 14 => data $0C
round 15 => data $0F
round 16 => data $10
final => data $11
********************/
m_current_cmd = data;
// Palette request cmd - verified to take around 122242 68000 cycles to complete
if (m_current_cmd >= 0x1 && m_current_cmd < 0x12)
{
m_cchip_timer->adjust(m_maincpu->cycles_to_attotime(122242));
}
// Unknown cmd - verified to take around 105500 68000 cycles to complete
else if (m_current_cmd >= 0x81 && m_current_cmd < 0x92)
{
m_cchip_timer->adjust(m_maincpu->cycles_to_attotime(105500));
}
else
{
logerror("unknown cchip cmd %02x\n", data);
m_current_cmd = 0;
}
}
// Some kind of timer command
if (offset == 0x3ff)
{
m_current_flag = data;
}
}
}
/*************************************
*
* Reads from C-Chip
*
*************************************/
READ16_MEMBER(volfied_state::cchip_ctrl_r)
{
/*
Bit 2 = Error signal
Bit 0 = Ready signal
*/
return 0x01; /* Return 0x05 for C-Chip error */
}
READ16_MEMBER(volfied_state::cchip_ram_r)
{
/* Check for input ports */
if (m_current_bank == 0)
{
switch (offset)
{
case 0x03: return ioport("F00007")->read(); /* STARTn + SERVICE1 */
case 0x04: return ioport("F00009")->read(); /* COINn */
case 0x05: return ioport("F0000B")->read(); /* Player controls + TILT */
case 0x06: return ioport("F0000D")->read(); /* Player controls (cocktail) */
case 0x08: return m_cc_port;
}
}
/* Unknown */
if (m_current_bank == 2 && offset == 0x005)
{
/* Not fully understood - Game writes:
0001a0c2: volfied c write 0005 00aa
0001a0ca: volfied c write 0006 0055
0001a0d2: volfied c write 0004 0065
Then expects 0x7c to replace the 0xaa some time later.
*/
return 0x7c; /* makes worm in round 1 appear */
}
/* Unknown - some kind of timer */
if (m_current_bank == 0 && offset == 0x3ff)
{
return 2 * m_current_flag; /* fixes freeze after shield runs out */
}
/* Current command status */
if (m_current_bank == 0 && offset == 0x3fe)
{
return m_current_cmd;
}
return m_cchip_ram[(m_current_bank * 0x400) + offset];
}
/*************************************
*
* C-Chip State Saving
*
*************************************/
void volfied_state::cchip_init()
{
m_cchip_timer = timer_alloc(TIMER_VOLFIED);
m_cchip_ram = make_unique_clear<uint8_t[]>(0x400 * 8);
save_item(NAME(m_current_bank));
save_item(NAME(m_current_cmd));
save_item(NAME(m_current_flag));
save_item(NAME(m_cc_port));
save_pointer(NAME(m_cchip_ram.get()), 0x400 * 8);
}
void volfied_state::cchip_reset()
{
m_current_bank = 0;
m_current_flag = 0;
m_cc_port = 0;
m_current_cmd = 0;
}