summaryrefslogtreecommitdiffstatshomepage
path: root/src
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2012-04-03 09:51:27 +0000
committer Miodrag Milanovic <mmicko@gmail.com>2012-04-03 09:51:27 +0000
commitfd9822e2859faffee41c3f4a90f4f3bbc94ecb3b (patch)
tree287e1ba6e7217bff96ed6edb96daf6ece2f0efb8 /src
parent3783cf95515491d961776534fb5937b76accd464 (diff)
MAME going modern part 4 (no whatsnew)
Diffstat (limited to 'src')
-rw-r--r--src/mame/drivers/39in1.c535
-rw-r--r--src/mame/drivers/aristmk4.c162
-rw-r--r--src/mame/drivers/backfire.c102
-rw-r--r--src/mame/drivers/berzerk.c174
-rw-r--r--src/mame/drivers/bfm_sc2.c596
-rw-r--r--src/mame/drivers/bfm_sc4.c28
-rw-r--r--src/mame/drivers/blitz68k.c722
-rw-r--r--src/mame/drivers/cabaret.c71
-rw-r--r--src/mame/drivers/cham24.c64
-rw-r--r--src/mame/drivers/coolridr.c186
-rw-r--r--src/mame/drivers/corona.c183
-rw-r--r--src/mame/drivers/crystal.c202
-rw-r--r--src/mame/drivers/csplayh5.c202
-rw-r--r--src/mame/drivers/cyclemb.c26
-rw-r--r--src/mame/drivers/dai3wksi.c77
-rw-r--r--src/mame/drivers/ddayjlc.c122
-rw-r--r--src/mame/drivers/ddealer.c83
-rw-r--r--src/mame/drivers/deco156.c64
-rw-r--r--src/mame/drivers/deshoros.c37
-rw-r--r--src/mame/drivers/dunhuang.c309
-rw-r--r--src/mame/drivers/famibox.c101
-rw-r--r--src/mame/drivers/firefox.c246
-rw-r--r--src/mame/drivers/ghosteo.c17
-rw-r--r--src/mame/drivers/gstream.c126
-rw-r--r--src/mame/drivers/halleys.c170
-rw-r--r--src/mame/drivers/highvdeo.c196
-rw-r--r--src/mame/drivers/igs009.c169
-rw-r--r--src/mame/drivers/igs011.c1011
-rw-r--r--src/mame/drivers/igspoker.c195
-rw-r--r--src/mame/drivers/jackie.c183
-rw-r--r--src/mame/drivers/jalmah.c291
-rw-r--r--src/mame/drivers/jangou.c145
-rw-r--r--src/mame/drivers/limenko.c158
-rw-r--r--src/mame/drivers/looping.c127
-rw-r--r--src/mame/drivers/marinedt.c125
-rw-r--r--src/mame/drivers/maygay1b.c144
-rw-r--r--src/mame/drivers/meritm.c112
-rw-r--r--src/mame/drivers/mpu3.c40
-rw-r--r--src/mame/drivers/nexus3d.c27
-rw-r--r--src/mame/drivers/nyny.c44
-rw-r--r--src/mame/drivers/omegrace.c38
-rw-r--r--src/mame/drivers/pasha2.c78
-rw-r--r--src/mame/drivers/pinkiri8.c116
-rw-r--r--src/mame/drivers/poo.c40
-rw-r--r--src/mame/drivers/r2dtank.c30
-rw-r--r--src/mame/drivers/rmhaihai.c111
-rw-r--r--src/mame/drivers/safarir.c57
-rw-r--r--src/mame/drivers/sigmab98.c658
-rw-r--r--src/mame/drivers/srmp6.c103
-rw-r--r--src/mame/drivers/statriv2.c45
-rw-r--r--src/mame/drivers/subsino2.c629
-rw-r--r--src/mame/drivers/supertnk.c80
-rw-r--r--src/mame/drivers/tmspoker.c20
-rw-r--r--src/mame/drivers/umipoker.c125
-rw-r--r--src/mame/drivers/vamphalf.c426
-rw-r--r--src/mame/drivers/witch.c125
56 files changed, 5277 insertions, 4976 deletions
diff --git a/src/mame/drivers/39in1.c b/src/mame/drivers/39in1.c
index bb111121a05..7db9b84e43c 100644
--- a/src/mame/drivers/39in1.c
+++ b/src/mame/drivers/39in1.c
@@ -54,35 +54,52 @@ public:
//FILE* audio_dump;
UINT32 m_words[0x800];
INT16 m_samples[0x1000];
+ DECLARE_READ32_MEMBER(pxa255_i2s_r);
+ DECLARE_WRITE32_MEMBER(pxa255_i2s_w);
+ DECLARE_READ32_MEMBER(pxa255_dma_r);
+ DECLARE_WRITE32_MEMBER(pxa255_dma_w);
+ DECLARE_READ32_MEMBER(pxa255_ostimer_r);
+ DECLARE_WRITE32_MEMBER(pxa255_ostimer_w);
+ DECLARE_READ32_MEMBER(pxa255_intc_r);
+ DECLARE_WRITE32_MEMBER(pxa255_intc_w);
+ DECLARE_READ32_MEMBER(pxa255_gpio_r);
+ DECLARE_WRITE32_MEMBER(pxa255_gpio_w);
+ DECLARE_READ32_MEMBER(pxa255_lcd_r);
+ DECLARE_WRITE32_MEMBER(pxa255_lcd_w);
+ DECLARE_READ32_MEMBER(return_zero);
+ DECLARE_READ32_MEMBER(unknown_r);
+ DECLARE_READ32_MEMBER(cpld_r);
+ DECLARE_WRITE32_MEMBER(cpld_w);
+ DECLARE_READ32_MEMBER(prot_cheater_r);
};
static void pxa255_dma_irq_check(running_machine& machine);
-static READ32_HANDLER( pxa255_dma_r );
-static WRITE32_HANDLER( pxa255_dma_w );
-static READ32_HANDLER( pxa255_i2s_r );
-static WRITE32_HANDLER( pxa255_i2s_w );
+
+
+
+
static void pxa255_ostimer_irq_check(running_machine& machine);
static TIMER_CALLBACK( pxa255_ostimer_match );
-static READ32_HANDLER( pxa255_ostimer_r );
-static WRITE32_HANDLER( pxa255_ostimer_w );
+
+
static void pxa255_update_interrupts(running_machine& machine);
static void pxa255_set_irq_line(running_machine& machine, UINT32 line, int state);
-static READ32_HANDLER( pxa255_intc_r );
-static WRITE32_HANDLER( pxa255_intc_w );
-static READ32_HANDLER( pxa255_gpio_r );
-static WRITE32_HANDLER( pxa255_gpio_w );
+
+
+
+
static void pxa255_lcd_load_dma_descriptor(address_space* space, UINT32 address, int channel);
static void pxa255_lcd_irq_check(running_machine& machine);
static void pxa255_lcd_dma_kickoff(running_machine& machine, int channel);
static void pxa255_lcd_check_load_next_branch(running_machine& machine, int channel);
-static READ32_HANDLER( pxa255_lcd_r );
-static WRITE32_HANDLER( pxa255_lcd_w );
+
+
#define VERBOSE_LEVEL ( 3 )
@@ -108,45 +125,43 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine& machine, int n_level,
*/
-static READ32_HANDLER( pxa255_i2s_r )
+READ32_MEMBER(_39in1_state::pxa255_i2s_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_I2S_Regs *i2s_regs = &state->m_i2s_regs;
+ PXA255_I2S_Regs *i2s_regs = &m_i2s_regs;
switch(PXA255_I2S_BASE_ADDR | (offset << 2))
{
case PXA255_SACR0:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Controller Global Control Register: %08x & %08x\n", i2s_regs->sacr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Controller Global Control Register: %08x & %08x\n", i2s_regs->sacr0, mem_mask );
return i2s_regs->sacr0;
case PXA255_SACR1:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Controller I2S/MSB-Justified Control Register: %08x & %08x\n", i2s_regs->sacr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Controller I2S/MSB-Justified Control Register: %08x & %08x\n", i2s_regs->sacr1, mem_mask );
return i2s_regs->sacr1;
case PXA255_SASR0:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Controller I2S/MSB-Justified Status Register: %08x & %08x\n", i2s_regs->sasr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Controller I2S/MSB-Justified Status Register: %08x & %08x\n", i2s_regs->sasr0, mem_mask );
return i2s_regs->sasr0;
case PXA255_SAIMR:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Interrupt Mask Register: %08x & %08x\n", i2s_regs->saimr, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Interrupt Mask Register: %08x & %08x\n", i2s_regs->saimr, mem_mask );
return i2s_regs->saimr;
case PXA255_SAICR:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Interrupt Clear Register: %08x & %08x\n", i2s_regs->saicr, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Interrupt Clear Register: %08x & %08x\n", i2s_regs->saicr, mem_mask );
return i2s_regs->saicr;
case PXA255_SADIV:
- verboselog( space->machine(), 3, "pxa255_i2s_r: Serial Audio Clock Divider Register: %08x & %08x\n", i2s_regs->sadiv, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_r: Serial Audio Clock Divider Register: %08x & %08x\n", i2s_regs->sadiv, mem_mask );
return i2s_regs->sadiv;
case PXA255_SADR:
- verboselog( space->machine(), 5, "pxa255_i2s_r: Serial Audio Data Register: %08x & %08x\n", i2s_regs->sadr, mem_mask );
+ verboselog( machine(), 5, "pxa255_i2s_r: Serial Audio Data Register: %08x & %08x\n", i2s_regs->sadr, mem_mask );
return i2s_regs->sadr;
default:
- verboselog( space->machine(), 0, "pxa255_i2s_r: Unknown address: %08x\n", PXA255_I2S_BASE_ADDR | (offset << 2));
+ verboselog( machine(), 0, "pxa255_i2s_r: Unknown address: %08x\n", PXA255_I2S_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_i2s_w )
+WRITE32_MEMBER(_39in1_state::pxa255_i2s_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_I2S_Regs *i2s_regs = &state->m_i2s_regs;
+ PXA255_I2S_Regs *i2s_regs = &m_i2s_regs;
#if 0
if(!audio_dump)
@@ -166,23 +181,23 @@ static WRITE32_HANDLER( pxa255_i2s_w )
switch(PXA255_I2S_BASE_ADDR | (offset << 2))
{
case PXA255_SACR0:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Controller Global Control Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Controller Global Control Register: %08x & %08x\n", data, mem_mask );
i2s_regs->sacr0 = data & 0x0000ff3d;
break;
case PXA255_SACR1:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Controller I2S/MSB-Justified Control Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Controller I2S/MSB-Justified Control Register: %08x & %08x\n", data, mem_mask );
i2s_regs->sacr1 = data & 0x00000039;
break;
case PXA255_SASR0:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Controller I2S/MSB-Justified Status Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Controller I2S/MSB-Justified Status Register: %08x & %08x\n", data, mem_mask );
i2s_regs->sasr0 = data & 0x0000ff7f;
break;
case PXA255_SAIMR:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Interrupt Mask Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Interrupt Mask Register: %08x & %08x\n", data, mem_mask );
i2s_regs->saimr = data & 0x00000078;
break;
case PXA255_SAICR:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Interrupt Clear Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Interrupt Clear Register: %08x & %08x\n", data, mem_mask );
if(i2s_regs->saicr & PXA255_SAICR_ROR)
{
i2s_regs->sasr0 &= ~PXA255_SASR0_ROR;
@@ -193,13 +208,13 @@ static WRITE32_HANDLER( pxa255_i2s_w )
}
break;
case PXA255_SADIV:
- verboselog( space->machine(), 3, "pxa255_i2s_w: Serial Audio Clock Divider Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_i2s_w: Serial Audio Clock Divider Register: %08x & %08x\n", data, mem_mask );
i2s_regs->sadiv = data & 0x0000007f;
- dmadac_set_frequency(&state->m_dmadac[0], 2, ((double)147600000 / (double)i2s_regs->sadiv) / 256.0);
- dmadac_enable(&state->m_dmadac[0], 2, 1);
+ dmadac_set_frequency(&m_dmadac[0], 2, ((double)147600000 / (double)i2s_regs->sadiv) / 256.0);
+ dmadac_enable(&m_dmadac[0], 2, 1);
break;
case PXA255_SADR:
- verboselog( space->machine(), 4, "pxa255_i2s_w: Serial Audio Data Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_i2s_w: Serial Audio Data Register: %08x & %08x\n", data, mem_mask );
i2s_regs->sadr = data;
#if 0
if(audio_dump)
@@ -209,7 +224,7 @@ static WRITE32_HANDLER( pxa255_i2s_w )
#endif
break;
default:
- verboselog( space->machine(), 0, "pxa255_i2s_w: Unknown address: %08x = %08x & %08x\n", PXA255_I2S_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_i2s_w: Unknown address: %08x = %08x & %08x\n", PXA255_I2S_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -399,10 +414,9 @@ static TIMER_CALLBACK( pxa255_dma_dma_end )
pxa255_dma_irq_check(machine);
}
-static READ32_HANDLER( pxa255_dma_r )
+READ32_MEMBER(_39in1_state::pxa255_dma_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_DMA_Regs *dma_regs = &state->m_dma_regs;
+ PXA255_DMA_Regs *dma_regs = &m_dma_regs;
switch(PXA255_DMA_BASE_ADDR | (offset << 2))
{
@@ -410,10 +424,10 @@ static READ32_HANDLER( pxa255_dma_r )
case PXA255_DCSR4: case PXA255_DCSR5: case PXA255_DCSR6: case PXA255_DCSR7:
case PXA255_DCSR8: case PXA255_DCSR9: case PXA255_DCSR10: case PXA255_DCSR11:
case PXA255_DCSR12: case PXA255_DCSR13: case PXA255_DCSR14: case PXA255_DCSR15:
- verboselog( space->machine(), 4, "pxa255_dma_r: DMA Channel Control/Status Register %d: %08x & %08x\n", offset, dma_regs->dcsr[offset], mem_mask );
+ verboselog( machine(), 4, "pxa255_dma_r: DMA Channel Control/Status Register %d: %08x & %08x\n", offset, dma_regs->dcsr[offset], mem_mask );
return dma_regs->dcsr[offset];
case PXA255_DINT:
- if (0) verboselog( space->machine(), 3, "pxa255_dma_r: DMA Interrupt Register: %08x & %08x\n", dma_regs->dint, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_dma_r: DMA Interrupt Register: %08x & %08x\n", dma_regs->dint, mem_mask );
return dma_regs->dint;
case PXA255_DRCMR0: case PXA255_DRCMR1: case PXA255_DRCMR2: case PXA255_DRCMR3:
case PXA255_DRCMR4: case PXA255_DRCMR5: case PXA255_DRCMR6: case PXA255_DRCMR7:
@@ -425,43 +439,42 @@ static READ32_HANDLER( pxa255_dma_r )
case PXA255_DRCMR28: case PXA255_DRCMR29: case PXA255_DRCMR30: case PXA255_DRCMR31:
case PXA255_DRCMR32: case PXA255_DRCMR33: case PXA255_DRCMR34: case PXA255_DRCMR35:
case PXA255_DRCMR36: case PXA255_DRCMR37: case PXA255_DRCMR38: case PXA255_DRCMR39:
- verboselog( space->machine(), 3, "pxa255_dma_r: DMA Request to Channel Map Register %d: %08x & %08x\n", offset - (0x100 >> 2), 0, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_r: DMA Request to Channel Map Register %d: %08x & %08x\n", offset - (0x100 >> 2), 0, mem_mask );
return dma_regs->drcmr[offset - (0x100 >> 2)];
case PXA255_DDADR0: case PXA255_DDADR1: case PXA255_DDADR2: case PXA255_DDADR3:
case PXA255_DDADR4: case PXA255_DDADR5: case PXA255_DDADR6: case PXA255_DDADR7:
case PXA255_DDADR8: case PXA255_DDADR9: case PXA255_DDADR10: case PXA255_DDADR11:
case PXA255_DDADR12: case PXA255_DDADR13: case PXA255_DDADR14: case PXA255_DDADR15:
- verboselog( space->machine(), 3, "pxa255_dma_r: DMA Descriptor Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_r: DMA Descriptor Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
return dma_regs->ddadr[(offset - (0x200 >> 2)) >> 2];
case PXA255_DSADR0: case PXA255_DSADR1: case PXA255_DSADR2: case PXA255_DSADR3:
case PXA255_DSADR4: case PXA255_DSADR5: case PXA255_DSADR6: case PXA255_DSADR7:
case PXA255_DSADR8: case PXA255_DSADR9: case PXA255_DSADR10: case PXA255_DSADR11:
case PXA255_DSADR12: case PXA255_DSADR13: case PXA255_DSADR14: case PXA255_DSADR15:
- verboselog( space->machine(), 3, "pxa255_dma_r: DMA Source Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_r: DMA Source Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
return dma_regs->dsadr[(offset - (0x200 >> 2)) >> 2];
case PXA255_DTADR0: case PXA255_DTADR1: case PXA255_DTADR2: case PXA255_DTADR3:
case PXA255_DTADR4: case PXA255_DTADR5: case PXA255_DTADR6: case PXA255_DTADR7:
case PXA255_DTADR8: case PXA255_DTADR9: case PXA255_DTADR10: case PXA255_DTADR11:
case PXA255_DTADR12: case PXA255_DTADR13: case PXA255_DTADR14: case PXA255_DTADR15:
- verboselog( space->machine(), 3, "pxa255_dma_r: DMA Target Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_r: DMA Target Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
return dma_regs->dtadr[(offset - (0x200 >> 2)) >> 2];
case PXA255_DCMD0: case PXA255_DCMD1: case PXA255_DCMD2: case PXA255_DCMD3:
case PXA255_DCMD4: case PXA255_DCMD5: case PXA255_DCMD6: case PXA255_DCMD7:
case PXA255_DCMD8: case PXA255_DCMD9: case PXA255_DCMD10: case PXA255_DCMD11:
case PXA255_DCMD12: case PXA255_DCMD13: case PXA255_DCMD14: case PXA255_DCMD15:
- verboselog( space->machine(), 3, "pxa255_dma_r: DMA Command Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_r: DMA Command Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, 0, mem_mask );
return dma_regs->dcmd[(offset - (0x200 >> 2)) >> 2];
default:
- verboselog( space->machine(), 0, "pxa255_dma_r: Unknown address: %08x\n", PXA255_DMA_BASE_ADDR | (offset << 2));
+ verboselog( machine(), 0, "pxa255_dma_r: Unknown address: %08x\n", PXA255_DMA_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_dma_w )
+WRITE32_MEMBER(_39in1_state::pxa255_dma_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_DMA_Regs *dma_regs = &state->m_dma_regs;
+ PXA255_DMA_Regs *dma_regs = &m_dma_regs;
switch(PXA255_DMA_BASE_ADDR | (offset << 2))
{
@@ -469,7 +482,7 @@ static WRITE32_HANDLER( pxa255_dma_w )
case PXA255_DCSR4: case PXA255_DCSR5: case PXA255_DCSR6: case PXA255_DCSR7:
case PXA255_DCSR8: case PXA255_DCSR9: case PXA255_DCSR10: case PXA255_DCSR11:
case PXA255_DCSR12: case PXA255_DCSR13: case PXA255_DCSR14: case PXA255_DCSR15:
- if (0) verboselog( space->machine(), 3, "pxa255_dma_w: DMA Channel Control/Status Register %d: %08x & %08x\n", offset, data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_dma_w: DMA Channel Control/Status Register %d: %08x & %08x\n", offset, data, mem_mask );
dma_regs->dcsr[offset] &= ~(data & 0x00000007);
dma_regs->dcsr[offset] &= ~0x60000000;
dma_regs->dcsr[offset] |= data & 0x60000000;
@@ -478,21 +491,21 @@ static WRITE32_HANDLER( pxa255_dma_w )
dma_regs->dcsr[offset] |= PXA255_DCSR_RUN;
if(data & PXA255_DCSR_NODESCFETCH)
{
- verboselog( space->machine(), 0, " No-Descriptor-Fetch mode is not supported.\n" );
+ verboselog( machine(), 0, " No-Descriptor-Fetch mode is not supported.\n" );
break;
}
- pxa255_dma_load_descriptor_and_start(space->machine(), offset);
+ pxa255_dma_load_descriptor_and_start(machine(), offset);
}
else if(!(data & PXA255_DCSR_RUN))
{
dma_regs->dcsr[offset] &= ~PXA255_DCSR_RUN;
}
- pxa255_dma_irq_check(space->machine());
+ pxa255_dma_irq_check(machine());
break;
case PXA255_DINT:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Interrupt Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Interrupt Register: %08x & %08x\n", data, mem_mask );
dma_regs->dint &= ~data;
break;
case PXA255_DRCMR0: case PXA255_DRCMR1: case PXA255_DRCMR2: case PXA255_DRCMR3:
@@ -505,39 +518,39 @@ static WRITE32_HANDLER( pxa255_dma_w )
case PXA255_DRCMR28: case PXA255_DRCMR29: case PXA255_DRCMR30: case PXA255_DRCMR31:
case PXA255_DRCMR32: case PXA255_DRCMR33: case PXA255_DRCMR34: case PXA255_DRCMR35:
case PXA255_DRCMR36: case PXA255_DRCMR37: case PXA255_DRCMR38: case PXA255_DRCMR39:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Request to Channel Map Register %d: %08x & %08x\n", offset - (0x100 >> 2), data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Request to Channel Map Register %d: %08x & %08x\n", offset - (0x100 >> 2), data, mem_mask );
dma_regs->drcmr[offset - (0x100 >> 2)] = data & 0x0000008f;
break;
case PXA255_DDADR0: case PXA255_DDADR1: case PXA255_DDADR2: case PXA255_DDADR3:
case PXA255_DDADR4: case PXA255_DDADR5: case PXA255_DDADR6: case PXA255_DDADR7:
case PXA255_DDADR8: case PXA255_DDADR9: case PXA255_DDADR10: case PXA255_DDADR11:
case PXA255_DDADR12: case PXA255_DDADR13: case PXA255_DDADR14: case PXA255_DDADR15:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Descriptor Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Descriptor Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
dma_regs->ddadr[(offset - (0x200 >> 2)) >> 2] = data & 0xfffffff1;
break;
case PXA255_DSADR0: case PXA255_DSADR1: case PXA255_DSADR2: case PXA255_DSADR3:
case PXA255_DSADR4: case PXA255_DSADR5: case PXA255_DSADR6: case PXA255_DSADR7:
case PXA255_DSADR8: case PXA255_DSADR9: case PXA255_DSADR10: case PXA255_DSADR11:
case PXA255_DSADR12: case PXA255_DSADR13: case PXA255_DSADR14: case PXA255_DSADR15:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Source Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Source Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
dma_regs->dsadr[(offset - (0x200 >> 2)) >> 2] = data & 0xfffffffc;
break;
case PXA255_DTADR0: case PXA255_DTADR1: case PXA255_DTADR2: case PXA255_DTADR3:
case PXA255_DTADR4: case PXA255_DTADR5: case PXA255_DTADR6: case PXA255_DTADR7:
case PXA255_DTADR8: case PXA255_DTADR9: case PXA255_DTADR10: case PXA255_DTADR11:
case PXA255_DTADR12: case PXA255_DTADR13: case PXA255_DTADR14: case PXA255_DTADR15:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Target Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Target Address Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
dma_regs->dtadr[(offset - (0x200 >> 2)) >> 2] = data & 0xfffffffc;
break;
case PXA255_DCMD0: case PXA255_DCMD1: case PXA255_DCMD2: case PXA255_DCMD3:
case PXA255_DCMD4: case PXA255_DCMD5: case PXA255_DCMD6: case PXA255_DCMD7:
case PXA255_DCMD8: case PXA255_DCMD9: case PXA255_DCMD10: case PXA255_DCMD11:
case PXA255_DCMD12: case PXA255_DCMD13: case PXA255_DCMD14: case PXA255_DCMD15:
- verboselog( space->machine(), 3, "pxa255_dma_w: DMA Command Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
+ verboselog( machine(), 3, "pxa255_dma_w: DMA Command Register %d: %08x & %08x\n", (offset - (0x200 >> 2)) >> 2, data, mem_mask );
dma_regs->dcmd[(offset - (0x200 >> 2)) >> 2] = data & 0xf067dfff;
break;
default:
- verboselog( space->machine(), 0, "pxa255_dma_w: Unknown address: %08x = %08x & %08x\n", PXA255_DMA_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_dma_w: Unknown address: %08x = %08x & %08x\n", PXA255_DMA_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -572,55 +585,53 @@ static TIMER_CALLBACK( pxa255_ostimer_match )
pxa255_ostimer_irq_check(machine);
}
-static READ32_HANDLER( pxa255_ostimer_r )
+READ32_MEMBER(_39in1_state::pxa255_ostimer_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_OSTMR_Regs *ostimer_regs = &state->m_ostimer_regs;
+ PXA255_OSTMR_Regs *ostimer_regs = &m_ostimer_regs;
switch(PXA255_OSTMR_BASE_ADDR | (offset << 2))
{
case PXA255_OSMR0:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 0: %08x & %08x\n", ostimer_regs->osmr[0], mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 0: %08x & %08x\n", ostimer_regs->osmr[0], mem_mask );
return ostimer_regs->osmr[0];
case PXA255_OSMR1:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 1: %08x & %08x\n", ostimer_regs->osmr[1], mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 1: %08x & %08x\n", ostimer_regs->osmr[1], mem_mask );
return ostimer_regs->osmr[1];
case PXA255_OSMR2:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 2: %08x & %08x\n", ostimer_regs->osmr[2], mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 2: %08x & %08x\n", ostimer_regs->osmr[2], mem_mask );
return ostimer_regs->osmr[2];
case PXA255_OSMR3:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 3: %08x & %08x\n", ostimer_regs->osmr[3], mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Match Register 3: %08x & %08x\n", ostimer_regs->osmr[3], mem_mask );
return ostimer_regs->osmr[3];
case PXA255_OSCR:
- if (0) verboselog( space->machine(), 4, "pxa255_ostimer_r: OS Timer Count Register: %08x & %08x\n", ostimer_regs->oscr, mem_mask );
+ if (0) verboselog( machine(), 4, "pxa255_ostimer_r: OS Timer Count Register: %08x & %08x\n", ostimer_regs->oscr, mem_mask );
// free-running 3.something MHz counter. this is a complete hack.
ostimer_regs->oscr += 0x300;
return ostimer_regs->oscr;
case PXA255_OSSR:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Status Register: %08x & %08x\n", ostimer_regs->ossr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Status Register: %08x & %08x\n", ostimer_regs->ossr, mem_mask );
return ostimer_regs->ossr;
case PXA255_OWER:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Watchdog Match Enable Register: %08x & %08x\n", ostimer_regs->ower, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Watchdog Match Enable Register: %08x & %08x\n", ostimer_regs->ower, mem_mask );
return ostimer_regs->ower;
case PXA255_OIER:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_r: OS Timer Interrupt Enable Register: %08x & %08x\n", ostimer_regs->oier, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_r: OS Timer Interrupt Enable Register: %08x & %08x\n", ostimer_regs->oier, mem_mask );
return ostimer_regs->oier;
default:
- if (0) verboselog( space->machine(), 0, "pxa255_ostimer_r: Unknown address: %08x\n", PXA255_OSTMR_BASE_ADDR | (offset << 2));
+ if (0) verboselog( machine(), 0, "pxa255_ostimer_r: Unknown address: %08x\n", PXA255_OSTMR_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_ostimer_w )
+WRITE32_MEMBER(_39in1_state::pxa255_ostimer_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_OSTMR_Regs *ostimer_regs = &state->m_ostimer_regs;
+ PXA255_OSTMR_Regs *ostimer_regs = &m_ostimer_regs;
switch(PXA255_OSTMR_BASE_ADDR | (offset << 2))
{
case PXA255_OSMR0:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 0: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 0: %08x & %08x\n", data, mem_mask );
ostimer_regs->osmr[0] = data;
if(ostimer_regs->oier & PXA255_OIER_E0)
{
@@ -631,7 +642,7 @@ static WRITE32_HANDLER( pxa255_ostimer_w )
}
break;
case PXA255_OSMR1:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 1: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 1: %08x & %08x\n", data, mem_mask );
ostimer_regs->osmr[1] = data;
if(ostimer_regs->oier & PXA255_OIER_E1)
{
@@ -641,7 +652,7 @@ static WRITE32_HANDLER( pxa255_ostimer_w )
}
break;
case PXA255_OSMR2:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 2: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 2: %08x & %08x\n", data, mem_mask );
ostimer_regs->osmr[2] = data;
if(ostimer_regs->oier & PXA255_OIER_E2)
{
@@ -651,7 +662,7 @@ static WRITE32_HANDLER( pxa255_ostimer_w )
}
break;
case PXA255_OSMR3:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 3: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Match Register 3: %08x & %08x\n", data, mem_mask );
ostimer_regs->osmr[3] = data;
if(ostimer_regs->oier & PXA255_OIER_E3)
{
@@ -661,22 +672,22 @@ static WRITE32_HANDLER( pxa255_ostimer_w )
}
break;
case PXA255_OSCR:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Count Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Count Register: %08x & %08x\n", data, mem_mask );
ostimer_regs->oscr = data;
break;
case PXA255_OSSR:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Status Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Status Register: %08x & %08x\n", data, mem_mask );
ostimer_regs->ossr &= ~data;
- pxa255_ostimer_irq_check(space->machine());
+ pxa255_ostimer_irq_check(machine());
break;
case PXA255_OWER:
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Watchdog Enable Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Watchdog Enable Register: %08x & %08x\n", data, mem_mask );
ostimer_regs->ower = data & 0x00000001;
break;
case PXA255_OIER:
{
int index = 0;
- if (0) verboselog( space->machine(), 3, "pxa255_ostimer_w: OS Timer Interrupt Enable Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_ostimer_w: OS Timer Interrupt Enable Register: %08x & %08x\n", data, mem_mask );
ostimer_regs->oier = data & 0x0000000f;
for(index = 0; index < 4; index++)
{
@@ -691,7 +702,7 @@ static WRITE32_HANDLER( pxa255_ostimer_w )
break;
}
default:
- verboselog( space->machine(), 0, "pxa255_ostimer_w: Unknown address: %08x = %08x & %08x\n", PXA255_OSTMR_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_ostimer_w: Unknown address: %08x = %08x & %08x\n", PXA255_OSTMR_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -726,68 +737,66 @@ static void pxa255_set_irq_line(running_machine& machine, UINT32 line, int irq_s
pxa255_update_interrupts(machine);
}
-static READ32_HANDLER( pxa255_intc_r )
+READ32_MEMBER(_39in1_state::pxa255_intc_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_INTC_Regs *intc_regs = &state->m_intc_regs;
+ PXA255_INTC_Regs *intc_regs = &m_intc_regs;
switch(PXA255_INTC_BASE_ADDR | (offset << 2))
{
case PXA255_ICIP:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller IRQ Pending Register: %08x & %08x\n", intc_regs->icip, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller IRQ Pending Register: %08x & %08x\n", intc_regs->icip, mem_mask );
return intc_regs->icip;
case PXA255_ICMR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller Mask Register: %08x & %08x\n", intc_regs->icmr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller Mask Register: %08x & %08x\n", intc_regs->icmr, mem_mask );
return intc_regs->icmr;
case PXA255_ICLR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller Level Register: %08x & %08x\n", intc_regs->iclr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller Level Register: %08x & %08x\n", intc_regs->iclr, mem_mask );
return intc_regs->iclr;
case PXA255_ICFP:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller FIQ Pending Register: %08x & %08x\n", intc_regs->icfp, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller FIQ Pending Register: %08x & %08x\n", intc_regs->icfp, mem_mask );
return intc_regs->icfp;
case PXA255_ICPR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller Pending Register: %08x & %08x\n", intc_regs->icpr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller Pending Register: %08x & %08x\n", intc_regs->icpr, mem_mask );
return intc_regs->icpr;
case PXA255_ICCR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_r: Interrupt Controller Control Register: %08x & %08x\n", intc_regs->iccr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_r: Interrupt Controller Control Register: %08x & %08x\n", intc_regs->iccr, mem_mask );
return intc_regs->iccr;
default:
- verboselog( space->machine(), 0, "pxa255_intc_r: Unknown address: %08x\n", PXA255_INTC_BASE_ADDR | (offset << 2));
+ verboselog( machine(), 0, "pxa255_intc_r: Unknown address: %08x\n", PXA255_INTC_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_intc_w )
+WRITE32_MEMBER(_39in1_state::pxa255_intc_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_INTC_Regs *intc_regs = &state->m_intc_regs;
+ PXA255_INTC_Regs *intc_regs = &m_intc_regs;
switch(PXA255_INTC_BASE_ADDR | (offset << 2))
{
case PXA255_ICIP:
- verboselog( space->machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller IRQ Pending Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller IRQ Pending Register: %08x & %08x\n", data, mem_mask );
break;
case PXA255_ICMR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_w: Interrupt Controller Mask Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_w: Interrupt Controller Mask Register: %08x & %08x\n", data, mem_mask );
intc_regs->icmr = data & 0xfffe7f00;
break;
case PXA255_ICLR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_w: Interrupt Controller Level Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_w: Interrupt Controller Level Register: %08x & %08x\n", data, mem_mask );
intc_regs->iclr = data & 0xfffe7f00;
break;
case PXA255_ICFP:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller FIQ Pending Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller FIQ Pending Register: %08x & %08x\n", data, mem_mask );
break;
case PXA255_ICPR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller Pending Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_w: (Invalid Write) Interrupt Controller Pending Register: %08x & %08x\n", data, mem_mask );
break;
case PXA255_ICCR:
- if (0) verboselog( space->machine(), 3, "pxa255_intc_w: Interrupt Controller Control Register: %08x & %08x\n", data, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_intc_w: Interrupt Controller Control Register: %08x & %08x\n", data, mem_mask );
intc_regs->iccr = data & 0x00000001;
break;
default:
- verboselog( space->machine(), 0, "pxa255_intc_w: Unknown address: %08x = %08x & %08x\n", PXA255_INTC_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_intc_w: Unknown address: %08x = %08x & %08x\n", PXA255_INTC_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -800,242 +809,240 @@ static WRITE32_HANDLER( pxa255_intc_w )
*/
-static READ32_HANDLER( pxa255_gpio_r )
+READ32_MEMBER(_39in1_state::pxa255_gpio_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_GPIO_Regs *gpio_regs = &state->m_gpio_regs;
+ PXA255_GPIO_Regs *gpio_regs = &m_gpio_regs;
switch(PXA255_GPIO_BASE_ADDR | (offset << 2))
{
case PXA255_GPLR0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Pin-Level Register 0: %08x & %08x\n", gpio_regs->gplr0 | (1 << 1), mem_mask );
- return gpio_regs->gplr0 | (1 << 1) | (state->m_eeprom->read_bit() << 5); // Must be on. Probably a DIP switch.
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Pin-Level Register 0: %08x & %08x\n", gpio_regs->gplr0 | (1 << 1), mem_mask );
+ return gpio_regs->gplr0 | (1 << 1) | (m_eeprom->read_bit() << 5); // Must be on. Probably a DIP switch.
case PXA255_GPLR1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: *Not Yet Implemented* GPIO Pin-Level Register 1: %08x & %08x\n", gpio_regs->gplr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: *Not Yet Implemented* GPIO Pin-Level Register 1: %08x & %08x\n", gpio_regs->gplr1, mem_mask );
return 0xff9fffff;
/*
0x200000 = flip screen
*/
case PXA255_GPLR2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: *Not Yet Implemented* GPIO Pin-Level Register 2: %08x & %08x\n", gpio_regs->gplr2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: *Not Yet Implemented* GPIO Pin-Level Register 2: %08x & %08x\n", gpio_regs->gplr2, mem_mask );
return gpio_regs->gplr2;
case PXA255_GPDR0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 0: %08x & %08x\n", gpio_regs->gpdr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 0: %08x & %08x\n", gpio_regs->gpdr0, mem_mask );
return gpio_regs->gpdr0;
case PXA255_GPDR1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 1: %08x & %08x\n", gpio_regs->gpdr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 1: %08x & %08x\n", gpio_regs->gpdr1, mem_mask );
return gpio_regs->gpdr1;
case PXA255_GPDR2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 2: %08x & %08x\n", gpio_regs->gpdr2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Pin Direction Register 2: %08x & %08x\n", gpio_regs->gpdr2, mem_mask );
return gpio_regs->gpdr2;
case PXA255_GPSR0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 0: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 0: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GPSR1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 1: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 1: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GPSR2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 2: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Set Register 2: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GPCR0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 0: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 0: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GPCR1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 1: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 1: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GPCR2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 2: %08x & %08x\n", space->machine().rand(), mem_mask );
- return space->machine().rand();
+ verboselog( machine(), 3, "pxa255_gpio_r: (Invalid Read) GPIO Pin Output Clear Register 2: %08x & %08x\n", machine().rand(), mem_mask );
+ return machine().rand();
case PXA255_GRER0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 0: %08x & %08x\n", gpio_regs->grer0, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 0: %08x & %08x\n", gpio_regs->grer0, mem_mask );
return gpio_regs->grer0;
case PXA255_GRER1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 1: %08x & %08x\n", gpio_regs->grer1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 1: %08x & %08x\n", gpio_regs->grer1, mem_mask );
return gpio_regs->grer1;
case PXA255_GRER2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 2: %08x & %08x\n", gpio_regs->grer2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Rising Edge Detect Enable Register 2: %08x & %08x\n", gpio_regs->grer2, mem_mask );
return gpio_regs->grer2;
case PXA255_GFER0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 0: %08x & %08x\n", gpio_regs->gfer0, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 0: %08x & %08x\n", gpio_regs->gfer0, mem_mask );
return gpio_regs->gfer0;
case PXA255_GFER1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 1: %08x & %08x\n", gpio_regs->gfer1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 1: %08x & %08x\n", gpio_regs->gfer1, mem_mask );
return gpio_regs->gfer1;
case PXA255_GFER2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 2: %08x & %08x\n", gpio_regs->gfer2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Falling Edge Detect Enable Register 2: %08x & %08x\n", gpio_regs->gfer2, mem_mask );
return gpio_regs->gfer2;
case PXA255_GEDR0:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 0: %08x & %08x\n", gpio_regs->gedr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 0: %08x & %08x\n", gpio_regs->gedr0, mem_mask );
return gpio_regs->gedr0;
case PXA255_GEDR1:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 1: %08x & %08x\n", gpio_regs->gedr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 1: %08x & %08x\n", gpio_regs->gedr1, mem_mask );
return gpio_regs->gedr1;
case PXA255_GEDR2:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 2: %08x & %08x\n", gpio_regs->gedr2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Edge Detect Status Register 2: %08x & %08x\n", gpio_regs->gedr2, mem_mask );
return gpio_regs->gedr2;
case PXA255_GAFR0_L:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 0 Lower: %08x & %08x\n", gpio_regs->gafr0l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 0 Lower: %08x & %08x\n", gpio_regs->gafr0l, mem_mask );
return gpio_regs->gafr0l;
case PXA255_GAFR0_U:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 0 Upper: %08x & %08x\n", gpio_regs->gafr0u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 0 Upper: %08x & %08x\n", gpio_regs->gafr0u, mem_mask );
return gpio_regs->gafr0u;
case PXA255_GAFR1_L:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 1 Lower: %08x & %08x\n", gpio_regs->gafr1l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 1 Lower: %08x & %08x\n", gpio_regs->gafr1l, mem_mask );
return gpio_regs->gafr1l;
case PXA255_GAFR1_U:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 1 Upper: %08x & %08x\n", gpio_regs->gafr1u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 1 Upper: %08x & %08x\n", gpio_regs->gafr1u, mem_mask );
return gpio_regs->gafr1u;
case PXA255_GAFR2_L:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 2 Lower: %08x & %08x\n", gpio_regs->gafr2l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 2 Lower: %08x & %08x\n", gpio_regs->gafr2l, mem_mask );
return gpio_regs->gafr2l;
case PXA255_GAFR2_U:
- verboselog( space->machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 2 Upper: %08x & %08x\n", gpio_regs->gafr2u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_r: GPIO Alternate Function Register 2 Upper: %08x & %08x\n", gpio_regs->gafr2u, mem_mask );
return gpio_regs->gafr2u;
default:
- verboselog( space->machine(), 0, "pxa255_gpio_r: Unknown address: %08x\n", PXA255_GPIO_BASE_ADDR | (offset << 2));
+ verboselog( machine(), 0, "pxa255_gpio_r: Unknown address: %08x\n", PXA255_GPIO_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_gpio_w )
+WRITE32_MEMBER(_39in1_state::pxa255_gpio_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_GPIO_Regs *gpio_regs = &state->m_gpio_regs;
+ PXA255_GPIO_Regs *gpio_regs = &m_gpio_regs;
switch(PXA255_GPIO_BASE_ADDR | (offset << 2))
{
case PXA255_GPLR0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 0: %08x & %08x\n", data, mem_mask );
break;
case PXA255_GPLR1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 1: %08x & %08x\n", data, mem_mask );
break;
case PXA255_GPLR2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: (Invalid Write) GPIO Pin-Level Register 2: %08x & %08x\n", data, mem_mask );
break;
case PXA255_GPDR0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 0: %08x & %08x\n", data, mem_mask );
gpio_regs->gpdr0 = data;
break;
case PXA255_GPDR1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 1: %08x & %08x\n", data, mem_mask );
gpio_regs->gpdr1 = data;
break;
case PXA255_GPDR2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Direction Register 2: %08x & %08x\n", data, mem_mask );
gpio_regs->gpdr2 = data;
break;
case PXA255_GPSR0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 0: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr0 |= data & gpio_regs->gpdr0;
if(data & 0x00000004)
{
- state->m_eeprom->set_cs_line(CLEAR_LINE);
+ m_eeprom->set_cs_line(CLEAR_LINE);
}
if(data & 0x00000008)
{
- state->m_eeprom->set_clock_line(ASSERT_LINE);
+ m_eeprom->set_clock_line(ASSERT_LINE);
}
if(data & 0x00000010)
{
- state->m_eeprom->write_bit(1);
+ m_eeprom->write_bit(1);
}
break;
case PXA255_GPSR1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 1: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr1 |= data & gpio_regs->gpdr1;
break;
case PXA255_GPSR2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Set Register 2: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr2 |= data & gpio_regs->gpdr2;
break;
case PXA255_GPCR0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 0: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr0 &= ~(data & gpio_regs->gpdr0);
if(data & 0x00000004)
{
- state->m_eeprom->set_cs_line(ASSERT_LINE);
+ m_eeprom->set_cs_line(ASSERT_LINE);
}
if(data & 0x00000008)
{
- state->m_eeprom->set_clock_line(CLEAR_LINE);
+ m_eeprom->set_clock_line(CLEAR_LINE);
}
if(data & 0x00000010)
{
- state->m_eeprom->write_bit(0);
+ m_eeprom->write_bit(0);
}
break;
case PXA255_GPCR1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 1: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr1 &= ~(data & gpio_regs->gpdr1);
break;
case PXA255_GPCR2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Pin Output Clear Register 2: %08x & %08x\n", data, mem_mask );
gpio_regs->gpsr2 &= ~(data & gpio_regs->gpdr2);
break;
case PXA255_GRER0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 0: %08x & %08x\n", data, mem_mask );
gpio_regs->grer0 = data;
break;
case PXA255_GRER1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 1: %08x & %08x\n", data, mem_mask );
gpio_regs->grer1 = data;
break;
case PXA255_GRER2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Rising Edge Detect Enable Register 2: %08x & %08x\n", data, mem_mask );
gpio_regs->grer2 = data;
break;
case PXA255_GFER0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 0: %08x & %08x\n", data, mem_mask );
gpio_regs->gfer0 = data;
break;
case PXA255_GFER1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 1: %08x & %08x\n", data, mem_mask );
gpio_regs->gfer1 = data;
break;
case PXA255_GFER2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Falling Edge Detect Enable Register 2: %08x & %08x\n", data, mem_mask );
gpio_regs->gfer2 = data;
break;
case PXA255_GEDR0:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 0: %08x & %08x\n", gpio_regs->gedr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 0: %08x & %08x\n", gpio_regs->gedr0, mem_mask );
gpio_regs->gedr0 &= ~data;
break;
case PXA255_GEDR1:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 1: %08x & %08x\n", gpio_regs->gedr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 1: %08x & %08x\n", gpio_regs->gedr1, mem_mask );
gpio_regs->gedr1 &= ~data;
break;
case PXA255_GEDR2:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 2: %08x & %08x\n", gpio_regs->gedr2, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Edge Detect Status Register 2: %08x & %08x\n", gpio_regs->gedr2, mem_mask );
gpio_regs->gedr2 &= ~data;
break;
case PXA255_GAFR0_L:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 0 Lower: %08x & %08x\n", gpio_regs->gafr0l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 0 Lower: %08x & %08x\n", gpio_regs->gafr0l, mem_mask );
gpio_regs->gafr0l = data;
break;
case PXA255_GAFR0_U:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 0 Upper: %08x & %08x\n", gpio_regs->gafr0u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 0 Upper: %08x & %08x\n", gpio_regs->gafr0u, mem_mask );
gpio_regs->gafr0u = data;
break;
case PXA255_GAFR1_L:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 1 Lower: %08x & %08x\n", gpio_regs->gafr1l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 1 Lower: %08x & %08x\n", gpio_regs->gafr1l, mem_mask );
gpio_regs->gafr1l = data;
break;
case PXA255_GAFR1_U:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 1 Upper: %08x & %08x\n", gpio_regs->gafr1u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 1 Upper: %08x & %08x\n", gpio_regs->gafr1u, mem_mask );
gpio_regs->gafr1u = data;
break;
case PXA255_GAFR2_L:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 2 Lower: %08x & %08x\n", gpio_regs->gafr2l, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 2 Lower: %08x & %08x\n", gpio_regs->gafr2l, mem_mask );
gpio_regs->gafr2l = data;
break;
case PXA255_GAFR2_U:
- verboselog( space->machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 2 Upper: %08x & %08x\n", gpio_regs->gafr2u, mem_mask );
+ verboselog( machine(), 3, "pxa255_gpio_w: GPIO Alternate Function Register 2 Upper: %08x & %08x\n", gpio_regs->gafr2u, mem_mask );
gpio_regs->gafr2u = data;
break;
default:
- verboselog( space->machine(), 0, "pxa255_gpio_w: Unknown address: %08x = %08x & %08x\n", PXA255_GPIO_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_gpio_w: Unknown address: %08x = %08x & %08x\n", PXA255_GPIO_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -1169,138 +1176,136 @@ static TIMER_CALLBACK( pxa255_lcd_dma_eof )
pxa255_lcd_irq_check(machine);
}
-static READ32_HANDLER( pxa255_lcd_r )
+READ32_MEMBER(_39in1_state::pxa255_lcd_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_LCD_Regs *lcd_regs = &state->m_lcd_regs;
+ PXA255_LCD_Regs *lcd_regs = &m_lcd_regs;
switch(PXA255_LCD_BASE_ADDR | (offset << 2))
{
case PXA255_LCCR0: // 0x44000000
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Control 0: %08x & %08x\n", lcd_regs->lccr0, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Control 0: %08x & %08x\n", lcd_regs->lccr0, mem_mask );
return lcd_regs->lccr0;
case PXA255_LCCR1: // 0x44000004
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Control 1: %08x & %08x\n", lcd_regs->lccr1, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Control 1: %08x & %08x\n", lcd_regs->lccr1, mem_mask );
return lcd_regs->lccr1;
case PXA255_LCCR2: // 0x44000008
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Control 2: %08x & %08x\n", lcd_regs->lccr2, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Control 2: %08x & %08x\n", lcd_regs->lccr2, mem_mask );
return lcd_regs->lccr2;
case PXA255_LCCR3: // 0x4400000c
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Control 3: %08x & %08x\n", lcd_regs->lccr3, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Control 3: %08x & %08x\n", lcd_regs->lccr3, mem_mask );
return lcd_regs->lccr3;
case PXA255_FBR0: // 0x44000020
- verboselog( space->machine(), 4, "pxa255_lcd_r: LCD Frame Branch Register 0: %08x & %08x\n", lcd_regs->fbr[0], mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_r: LCD Frame Branch Register 0: %08x & %08x\n", lcd_regs->fbr[0], mem_mask );
return lcd_regs->fbr[0];
case PXA255_FBR1: // 0x44000024
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Frame Branch Register 1: %08x & %08x\n", lcd_regs->fbr[1], mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Frame Branch Register 1: %08x & %08x\n", lcd_regs->fbr[1], mem_mask );
return lcd_regs->fbr[1];
case PXA255_LCSR: // 0x44000038
- verboselog( space->machine(), 4, "pxa255_lcd_r: LCD Status Register: %08x & %08x\n", lcd_regs->lcsr, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_r: LCD Status Register: %08x & %08x\n", lcd_regs->lcsr, mem_mask );
return lcd_regs->lcsr;
case PXA255_LIIDR: // 0x4400003c
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD Interrupt ID Register: %08x & %08x\n", lcd_regs->liidr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD Interrupt ID Register: %08x & %08x\n", lcd_regs->liidr, mem_mask );
return lcd_regs->liidr;
case PXA255_TRGBR: // 0x44000040
- verboselog( space->machine(), 3, "pxa255_lcd_r: TMED RGB Seed Register: %08x & %08x\n", lcd_regs->trgbr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: TMED RGB Seed Register: %08x & %08x\n", lcd_regs->trgbr, mem_mask );
return lcd_regs->trgbr;
case PXA255_TCR: // 0x44000044
- verboselog( space->machine(), 3, "pxa255_lcd_r: TMED RGB Seed Register: %08x & %08x\n", lcd_regs->tcr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: TMED RGB Seed Register: %08x & %08x\n", lcd_regs->tcr, mem_mask );
return lcd_regs->tcr;
case PXA255_FDADR0: // 0x44000200
- if (0) verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame Descriptor Address Register 0: %08x & %08x\n", lcd_regs->dma[0].fdadr, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame Descriptor Address Register 0: %08x & %08x\n", lcd_regs->dma[0].fdadr, mem_mask );
return lcd_regs->dma[0].fdadr;
case PXA255_FSADR0: // 0x44000204
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame Source Address Register 0: %08x & %08x\n", lcd_regs->dma[0].fsadr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame Source Address Register 0: %08x & %08x\n", lcd_regs->dma[0].fsadr, mem_mask );
return lcd_regs->dma[0].fsadr;
case PXA255_FIDR0: // 0x44000208
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame ID Register 0: %08x & %08x\n", lcd_regs->dma[0].fidr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame ID Register 0: %08x & %08x\n", lcd_regs->dma[0].fidr, mem_mask );
return lcd_regs->dma[0].fidr;
case PXA255_LDCMD0: // 0x4400020c
- if (0) verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Command Register 0: %08x & %08x\n", lcd_regs->dma[0].ldcmd & 0xfff00000, mem_mask );
+ if (0) verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Command Register 0: %08x & %08x\n", lcd_regs->dma[0].ldcmd & 0xfff00000, mem_mask );
return lcd_regs->dma[0].ldcmd & 0xfff00000;
case PXA255_FDADR1: // 0x44000210
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame Descriptor Address Register 1: %08x & %08x\n", lcd_regs->dma[1].fdadr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame Descriptor Address Register 1: %08x & %08x\n", lcd_regs->dma[1].fdadr, mem_mask );
return lcd_regs->dma[1].fdadr;
case PXA255_FSADR1: // 0x44000214
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame Source Address Register 1: %08x & %08x\n", lcd_regs->dma[1].fsadr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame Source Address Register 1: %08x & %08x\n", lcd_regs->dma[1].fsadr, mem_mask );
return lcd_regs->dma[1].fsadr;
case PXA255_FIDR1: // 0x44000218
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Frame ID Register 1: %08x & %08x\n", lcd_regs->dma[1].fidr, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Frame ID Register 1: %08x & %08x\n", lcd_regs->dma[1].fidr, mem_mask );
return lcd_regs->dma[1].fidr;
case PXA255_LDCMD1: // 0x4400021c
- verboselog( space->machine(), 3, "pxa255_lcd_r: LCD DMA Command Register 1: %08x & %08x\n", lcd_regs->dma[1].ldcmd & 0xfff00000, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_r: LCD DMA Command Register 1: %08x & %08x\n", lcd_regs->dma[1].ldcmd & 0xfff00000, mem_mask );
return lcd_regs->dma[1].ldcmd & 0xfff00000;
default:
- verboselog( space->machine(), 0, "pxa255_lcd_r: Unknown address: %08x\n", PXA255_LCD_BASE_ADDR | (offset << 2));
+ verboselog( machine(), 0, "pxa255_lcd_r: Unknown address: %08x\n", PXA255_LCD_BASE_ADDR | (offset << 2));
break;
}
return 0;
}
-static WRITE32_HANDLER( pxa255_lcd_w )
+WRITE32_MEMBER(_39in1_state::pxa255_lcd_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- PXA255_LCD_Regs *lcd_regs = &state->m_lcd_regs;
+ PXA255_LCD_Regs *lcd_regs = &m_lcd_regs;
switch(PXA255_LCD_BASE_ADDR | (offset << 2))
{
case PXA255_LCCR0: // 0x44000000
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Control 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Control 0: %08x & %08x\n", data, mem_mask );
lcd_regs->lccr0 = data & 0x00fffeff;
break;
case PXA255_LCCR1: // 0x44000004
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Control 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Control 1: %08x & %08x\n", data, mem_mask );
lcd_regs->lccr1 = data;
break;
case PXA255_LCCR2: // 0x44000008
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Control 2: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Control 2: %08x & %08x\n", data, mem_mask );
lcd_regs->lccr2 = data;
break;
case PXA255_LCCR3: // 0x4400000c
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Control 3: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Control 3: %08x & %08x\n", data, mem_mask );
lcd_regs->lccr3 = data;
break;
case PXA255_FBR0: // 0x44000020
- verboselog( space->machine(), 4l, "pxa255_lcd_w: LCD Frame Branch Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4l, "pxa255_lcd_w: LCD Frame Branch Register 0: %08x & %08x\n", data, mem_mask );
lcd_regs->fbr[0] = data & 0xfffffff3;
if(!lcd_regs->dma[0].eof->enabled())
{
- if (0) verboselog( space->machine(), 3, "ch0 EOF timer is not enabled, taking branch now\n" );
- pxa255_lcd_check_load_next_branch(space->machine(), 0);
- pxa255_lcd_irq_check(space->machine());
+ if (0) verboselog( machine(), 3, "ch0 EOF timer is not enabled, taking branch now\n" );
+ pxa255_lcd_check_load_next_branch(machine(), 0);
+ pxa255_lcd_irq_check(machine());
}
break;
case PXA255_FBR1: // 0x44000024
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Frame Branch Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Frame Branch Register 1: %08x & %08x\n", data, mem_mask );
lcd_regs->fbr[1] = data & 0xfffffff3;
if(!lcd_regs->dma[1].eof->enabled())
{
- verboselog( space->machine(), 3, "ch1 EOF timer is not enabled, taking branch now\n" );
- pxa255_lcd_check_load_next_branch(space->machine(), 1);
- pxa255_lcd_irq_check(space->machine());
+ verboselog( machine(), 3, "ch1 EOF timer is not enabled, taking branch now\n" );
+ pxa255_lcd_check_load_next_branch(machine(), 1);
+ pxa255_lcd_irq_check(machine());
}
break;
case PXA255_LCSR: // 0x44000038
- verboselog( space->machine(), 4, "pxa255_lcd_w: LCD Controller Status Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: LCD Controller Status Register: %08x & %08x\n", data, mem_mask );
lcd_regs->lcsr &= ~data;
- pxa255_lcd_irq_check(space->machine());
+ pxa255_lcd_irq_check(machine());
break;
case PXA255_LIIDR: // 0x4400003c
- verboselog( space->machine(), 3, "pxa255_lcd_w: LCD Controller Interrupt ID Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: LCD Controller Interrupt ID Register: %08x & %08x\n", data, mem_mask );
break;
case PXA255_TRGBR: // 0x44000040
- verboselog( space->machine(), 3, "pxa255_lcd_w: TMED RGB Seed Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: TMED RGB Seed Register: %08x & %08x\n", data, mem_mask );
lcd_regs->trgbr = data & 0x00ffffff;
break;
case PXA255_TCR: // 0x44000044
- verboselog( space->machine(), 3, "pxa255_lcd_w: TMED Control Register: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 3, "pxa255_lcd_w: TMED Control Register: %08x & %08x\n", data, mem_mask );
lcd_regs->tcr = data & 0x00004fff;
break;
case PXA255_FDADR0: // 0x44000200
- verboselog( space->machine(), 4, "pxa255_lcd_w: LCD DMA Frame Descriptor Address Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: LCD DMA Frame Descriptor Address Register 0: %08x & %08x\n", data, mem_mask );
if(!lcd_regs->dma[0].eof->enabled())
{
- pxa255_lcd_load_dma_descriptor(space, data & 0xfffffff0, 0);
+ pxa255_lcd_load_dma_descriptor(&space, data & 0xfffffff0, 0);
}
else
{
@@ -1309,19 +1314,19 @@ static WRITE32_HANDLER( pxa255_lcd_w )
}
break;
case PXA255_FSADR0: // 0x44000204
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame Source Address Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame Source Address Register 0: %08x & %08x\n", data, mem_mask );
break;
case PXA255_FIDR0: // 0x44000208
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame ID Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame ID Register 0: %08x & %08x\n", data, mem_mask );
break;
case PXA255_LDCMD0: // 0x4400020c
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Command Register 0: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Command Register 0: %08x & %08x\n", data, mem_mask );
break;
case PXA255_FDADR1: // 0x44000210
- verboselog( space->machine(), 4, "pxa255_lcd_w: LCD DMA Frame Descriptor Address Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: LCD DMA Frame Descriptor Address Register 1: %08x & %08x\n", data, mem_mask );
if(!lcd_regs->dma[1].eof->enabled())
{
- pxa255_lcd_load_dma_descriptor(space, data & 0xfffffff0, 1);
+ pxa255_lcd_load_dma_descriptor(&space, data & 0xfffffff0, 1);
}
else
{
@@ -1330,16 +1335,16 @@ static WRITE32_HANDLER( pxa255_lcd_w )
}
break;
case PXA255_FSADR1: // 0x44000214
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame Source Address Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame Source Address Register 1: %08x & %08x\n", data, mem_mask );
break;
case PXA255_FIDR1: // 0x44000218
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame ID Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Frame ID Register 1: %08x & %08x\n", data, mem_mask );
break;
case PXA255_LDCMD1: // 0x4400021c
- verboselog( space->machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Command Register 1: %08x & %08x\n", data, mem_mask );
+ verboselog( machine(), 4, "pxa255_lcd_w: (Invalid Write) LCD DMA Command Register 1: %08x & %08x\n", data, mem_mask );
break;
default:
- verboselog( space->machine(), 0, "pxa255_lcd_w: Unknown address: %08x = %08x & %08x\n", PXA255_LCD_BASE_ADDR | (offset << 2), data, mem_mask);
+ verboselog( machine(), 0, "pxa255_lcd_w: Unknown address: %08x = %08x & %08x\n", PXA255_LCD_BASE_ADDR | (offset << 2), data, mem_mask);
break;
}
}
@@ -1349,38 +1354,37 @@ static INTERRUPT_GEN( pxa255_vblank_start )
}
#ifdef UNUSED_FUNCTION
-static READ32_HANDLER( return_zero )
+READ32_MEMBER(_39in1_state::return_zero)
{
return 0;
}
-static READ32_HANDLER( unknown_r )
+READ32_MEMBER(_39in1_state::unknown_r)
{
return 0x00008000;
}
#endif
-static READ32_HANDLER( cpld_r )
+READ32_MEMBER(_39in1_state::cpld_r)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
- //if (cpu_get_pc(&space->device()) != 0xe3af4) printf("CPLD read @ %x (PC %x state %d)\n", offset, cpu_get_pc(&space->device()), state);
+ //if (cpu_get_pc(&space.device()) != 0xe3af4) printf("CPLD read @ %x (PC %x state %d)\n", offset, cpu_get_pc(&space.device()), state);
- if (cpu_get_pc(&space->device()) == 0x3f04)
+ if (cpu_get_pc(&space.device()) == 0x3f04)
{
return 0xf0; // any non-zero value works here
}
- else if (cpu_get_pc(&space->device()) == 0xe3af4)
+ else if (cpu_get_pc(&space.device()) == 0xe3af4)
{
- return input_port_read(space->machine(), "MCUIPT");
+ return input_port_read(machine(), "MCUIPT");
}
else
{
- if (state->m_state == 0)
+ if (m_state == 0)
{
return 0;
}
- else if (state->m_state == 1)
+ else if (m_state == 1)
{
switch (offset & ~1)
{
@@ -1395,10 +1399,10 @@ static READ32_HANDLER( cpld_r )
default: printf("State 1 unknown offset %x\n", offset); break;
}
}
- else if (state->m_state == 2) // 29c0: 53 ac 0c 2b a2 07 e6 be 31
+ else if (m_state == 2) // 29c0: 53 ac 0c 2b a2 07 e6 be 31
{
- UINT32 seed = state->m_seed;
- UINT32 magic = state->m_magic;
+ UINT32 seed = m_seed;
+ UINT32 magic = m_magic;
magic = ( (((~(seed >> 16)) ^ (magic >> 1)) & 0x01) |
(((~((seed >> 19) << 1)) ^ ((magic >> 5) << 1)) & 0x02) |
@@ -1409,7 +1413,7 @@ static READ32_HANDLER( cpld_r )
(((~(((seed >> 16) >> 1) << 6)) ^ ((magic >> 7) << 6)) & 0x40) |
(((~(((seed >> 16) >> 5) << 7)) ^ (magic << 7)) & 0x80));
- state->m_magic = magic;
+ m_magic = magic;
return magic;
}
}
@@ -1417,23 +1421,22 @@ static READ32_HANDLER( cpld_r )
return 0;
}
-static WRITE32_HANDLER( cpld_w )
+WRITE32_MEMBER(_39in1_state::cpld_w)
{
- _39in1_state *state = space->machine().driver_data<_39in1_state>();
if (mem_mask == 0xffff)
{
- state->m_seed = data<<16;
+ m_seed = data<<16;
}
- if (cpu_get_pc(&space->device()) == 0x280c)
+ if (cpu_get_pc(&space.device()) == 0x280c)
{
- state->m_state = 1;
+ m_state = 1;
}
- if (cpu_get_pc(&space->device()) == 0x2874)
+ if (cpu_get_pc(&space.device()) == 0x2874)
{
- state->m_state = 2;
- state->m_magic = space->read_byte(0xa02d4ff0);
+ m_state = 2;
+ m_magic = space.read_byte(0xa02d4ff0);
}
else if (offset == 0xa)
{
@@ -1441,12 +1444,12 @@ static WRITE32_HANDLER( cpld_w )
#if 0
else
{
- printf("%08x: CPLD_W: %08x = %08x & %08x\n", cpu_get_pc(&space->device()), offset, data, mem_mask);
+ printf("%08x: CPLD_W: %08x = %08x & %08x\n", cpu_get_pc(&space.device()), offset, data, mem_mask);
}
#endif
}
-static READ32_HANDLER( prot_cheater_r )
+READ32_MEMBER(_39in1_state::prot_cheater_r)
{
return 0x37;
}
@@ -1460,19 +1463,19 @@ static DRIVER_INIT( 39in1 )
state->m_eeprom = machine.device<eeprom_device>("eeprom");
address_space *space = machine.device<pxa255_device>("maincpu")->space(AS_PROGRAM);
- space->install_legacy_read_handler (0xa0151648, 0xa015164b, FUNC(prot_cheater_r));
+ space->install_read_handler (0xa0151648, 0xa015164b, read32_delegate(FUNC(_39in1_state::prot_cheater_r), state));
}
static ADDRESS_MAP_START( 39in1_map, AS_PROGRAM, 32, _39in1_state )
AM_RANGE(0x00000000, 0x0007ffff) AM_ROM
AM_RANGE(0x00400000, 0x005fffff) AM_ROM AM_REGION("data", 0)
- AM_RANGE(0x04000000, 0x047fffff) AM_READWRITE_LEGACY(cpld_r, cpld_w )
- AM_RANGE(0x40000000, 0x400002ff) AM_READWRITE_LEGACY(pxa255_dma_r, pxa255_dma_w )
- AM_RANGE(0x40400000, 0x40400083) AM_READWRITE_LEGACY(pxa255_i2s_r, pxa255_i2s_w )
- AM_RANGE(0x40a00000, 0x40a0001f) AM_READWRITE_LEGACY(pxa255_ostimer_r, pxa255_ostimer_w )
- AM_RANGE(0x40d00000, 0x40d00017) AM_READWRITE_LEGACY(pxa255_intc_r, pxa255_intc_w )
- AM_RANGE(0x40e00000, 0x40e0006b) AM_READWRITE_LEGACY(pxa255_gpio_r, pxa255_gpio_w )
- AM_RANGE(0x44000000, 0x4400021f) AM_READWRITE_LEGACY(pxa255_lcd_r, pxa255_lcd_w )
+ AM_RANGE(0x04000000, 0x047fffff) AM_READWRITE(cpld_r, cpld_w )
+ AM_RANGE(0x40000000, 0x400002ff) AM_READWRITE(pxa255_dma_r, pxa255_dma_w )
+ AM_RANGE(0x40400000, 0x40400083) AM_READWRITE(pxa255_i2s_r, pxa255_i2s_w )
+ AM_RANGE(0x40a00000, 0x40a0001f) AM_READWRITE(pxa255_ostimer_r, pxa255_ostimer_w )
+ AM_RANGE(0x40d00000, 0x40d00017) AM_READWRITE(pxa255_intc_r, pxa255_intc_w )
+ AM_RANGE(0x40e00000, 0x40e0006b) AM_READWRITE(pxa255_gpio_r, pxa255_gpio_w )
+ AM_RANGE(0x44000000, 0x4400021f) AM_READWRITE(pxa255_lcd_r, pxa255_lcd_w )
AM_RANGE(0xa0000000, 0xa07fffff) AM_RAM AM_BASE(m_ram)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/aristmk4.c b/src/mame/drivers/aristmk4.c
index f289c66a686..f4b7951fd60 100644
--- a/src/mame/drivers/aristmk4.c
+++ b/src/mame/drivers/aristmk4.c
@@ -282,6 +282,20 @@ public:
int m_insnote;
int m_cashcade_c;
int m_printer_motor;
+ DECLARE_READ8_MEMBER(ldsw);
+ DECLARE_READ8_MEMBER(cgdrr);
+ DECLARE_WRITE8_MEMBER(cgdrw);
+ DECLARE_WRITE8_MEMBER(u3_p0);
+ DECLARE_READ8_MEMBER(u3_p2);
+ DECLARE_READ8_MEMBER(u3_p3);
+ DECLARE_READ8_MEMBER(bv_p0);
+ DECLARE_READ8_MEMBER(bv_p1);
+ DECLARE_READ8_MEMBER(mkiv_pia_ina);
+ DECLARE_WRITE8_MEMBER(mkiv_pia_outa);
+ DECLARE_WRITE8_MEMBER(mlamps);
+ DECLARE_READ8_MEMBER(cashcade_r);
+ DECLARE_WRITE8_MEMBER(mk4_printer_w);
+ DECLARE_READ8_MEMBER(mk4_printer_r);
};
/* Partial Cashcade protocol */
@@ -362,88 +376,82 @@ static SCREEN_UPDATE_IND16(aristmk4)
return 0;
}
-static READ8_HANDLER(ldsw)
+READ8_MEMBER(aristmk4_state::ldsw)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- int U3_p2_ret= input_port_read(space->machine(), "5002");
+ int U3_p2_ret= input_port_read(machine(), "5002");
if(U3_p2_ret & 0x1)
{
return 0;
}
- return state->m_cgdrsw = input_port_read(space->machine(), "5005");
+ return m_cgdrsw = input_port_read(machine(), "5005");
}
-static READ8_HANDLER(cgdrr)
+READ8_MEMBER(aristmk4_state::cgdrr)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- if(state->m_cgdrsw) // is the LC closed
+ if(m_cgdrsw) // is the LC closed
{
- return state->m_ripple; // return a positive value from the ripple counter
+ return m_ripple; // return a positive value from the ripple counter
}
return 0x0; // otherwise the counter outputs are set low.
}
-static WRITE8_HANDLER(cgdrw)
+WRITE8_MEMBER(aristmk4_state::cgdrw)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- state->m_ripple = data;
+ m_ripple = data;
}
-static WRITE8_HANDLER(u3_p0)
+WRITE8_MEMBER(aristmk4_state::u3_p0)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- state->m_u3_p0_w = data;
+ m_u3_p0_w = data;
if ((data&0x80)==0) //Printer Motor Off
{
- state->m_printer_motor = 1; // Set this so the next read of u3_p3 returns PTRHOM as OFF.
+ m_printer_motor = 1; // Set this so the next read of u3_p3 returns PTRHOM as OFF.
}
- //logerror("u3_p0_w: %02X\n",state->m_u3_p0_w);
+ //logerror("u3_p0_w: %02X\n",m_u3_p0_w);
}
-static READ8_HANDLER(u3_p2)
+READ8_MEMBER(aristmk4_state::u3_p2)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- int u3_p2_ret= input_port_read(space->machine(), "5002");
- int u3_p3_ret= input_port_read(space->machine(), "5003");
+ int u3_p2_ret= input_port_read(machine(), "5002");
+ int u3_p3_ret= input_port_read(machine(), "5003");
output_set_lamp_value(19, (u3_p2_ret >> 4) & 1); //auditkey light
output_set_lamp_value(20, (u3_p3_ret >> 2) & 1); //jackpotkey light
- if (state->m_u3_p0_w&0x20) // DOPTE on
+ if (m_u3_p0_w&0x20) // DOPTE on
{
if (u3_p3_ret&0x02) // door closed
u3_p2_ret = u3_p2_ret^0x08; // DOPTI on
}
- if (state->m_inscrd==0)
+ if (m_inscrd==0)
{
- state->m_inscrd=input_port_read(space->machine(), "insertcoin");
+ m_inscrd=input_port_read(machine(), "insertcoin");
}
- if (state->m_inscrd==1)
+ if (m_inscrd==1)
u3_p2_ret=u3_p2_ret^0x02;
return u3_p2_ret;
}
-static READ8_HANDLER(u3_p3)
+READ8_MEMBER(aristmk4_state::u3_p3)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- int u3_p3_ret= input_port_read(space->machine(), "5003");
+ int u3_p3_ret= input_port_read(machine(), "5003");
- if ((state->m_printer_motor)==1) // Printer Motor Off
+ if ((m_printer_motor)==1) // Printer Motor Off
{
u3_p3_ret = u3_p3_ret^0x80; // Printer Home Off
- state->m_printer_motor=0;
+ m_printer_motor=0;
}
@@ -457,22 +465,21 @@ static TIMER_CALLBACK(note_input_reset)
state->m_insnote=0; //reset note input after 150msec
}
-static READ8_HANDLER(bv_p0)
+READ8_MEMBER(aristmk4_state::bv_p0)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
int bv_p0_ret=0x00;
- switch(state->m_insnote)
+ switch(m_insnote)
{
case 0x01:
- bv_p0_ret=input_port_read(space->machine(), "NS")+0x81; //check note selector
- state->m_insnote++;
+ bv_p0_ret=input_port_read(machine(), "NS")+0x81; //check note selector
+ m_insnote++;
break;
case 0x02:
bv_p0_ret=0x89;
- state->m_insnote++;
- space->machine().scheduler().timer_set(attotime::from_msec(150), FUNC(note_input_reset));
+ m_insnote++;
+ machine().scheduler().timer_set(attotime::from_msec(150), FUNC(note_input_reset));
break;
default:
break; //timer will reset the input
@@ -482,19 +489,18 @@ static READ8_HANDLER(bv_p0)
}
-static READ8_HANDLER(bv_p1)
+READ8_MEMBER(aristmk4_state::bv_p1)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
int bv_p1_ret=0x00;
- if (state->m_insnote==0)
- state->m_insnote=input_port_read(space->machine(), "insertnote");
+ if (m_insnote==0)
+ m_insnote=input_port_read(machine(), "insertnote");
- if (state->m_insnote==1)
+ if (m_insnote==1)
bv_p1_ret=0x08;
- if (state->m_insnote==2)
+ if (m_insnote==2)
bv_p1_ret=0x08;
return bv_p1_ret;
@@ -516,27 +522,26 @@ PORTB - MECHANICAL METERS
******************************************************************************/
//input a
-static READ8_HANDLER(mkiv_pia_ina)
+READ8_MEMBER(aristmk4_state::mkiv_pia_ina)
{
/* uncomment this code once RTC is fixed */
- //return space->machine().device<mc146818_device>("rtc")->read(*space,1);
+ //return machine().device<mc146818_device>("rtc")->read(*&space,1);
return 0; // OK for now, the aussie version has no RTC on the MB so this is valid.
}
//output a
-static WRITE8_HANDLER(mkiv_pia_outa)
+WRITE8_MEMBER(aristmk4_state::mkiv_pia_outa)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
- mc146818_device *mc = space->machine().device<mc146818_device>("rtc");
- if(state->m_rtc_data_strobe)
+ mc146818_device *mc = machine().device<mc146818_device>("rtc");
+ if(m_rtc_data_strobe)
{
- mc->write(*space,1,data);
+ mc->write(*&space,1,data);
//logerror("rtc protocol write data: %02X\n",data);
}
else
{
- mc->write(*space,0,data);
+ mc->write(*&space,0,data);
//logerror("rtc protocol write address: %02X\n",data);
}
}
@@ -832,7 +837,7 @@ static WRITE8_DEVICE_HANDLER(pbltlp_out)
//logerror("Lights port B: %02X\n",data);
}
-static WRITE8_HANDLER(mlamps)
+WRITE8_MEMBER(aristmk4_state::mlamps)
{
/* TAKE WIN AND GAMBLE LAMPS */
output_set_lamp_value(18, (data >> 5) & 1);
@@ -847,19 +852,18 @@ static WRITE8_DEVICE_HANDLER(zn434_w)
}
-static READ8_HANDLER(cashcade_r)
+READ8_MEMBER(aristmk4_state::cashcade_r)
{
- aristmk4_state *state = space->machine().driver_data<aristmk4_state>();
/* work around for cashcade games */
- return cashcade_p[(state->m_cashcade_c++)%15];
+ return cashcade_p[(m_cashcade_c++)%15];
}
-static WRITE8_HANDLER(mk4_printer_w)
+WRITE8_MEMBER(aristmk4_state::mk4_printer_w)
{
//logerror("Printer: %c %d\n",data,data);
}
-static READ8_HANDLER(mk4_printer_r)
+READ8_MEMBER(aristmk4_state::mk4_printer_r)
{
return 0;
}
@@ -875,28 +879,28 @@ static ADDRESS_MAP_START( aristmk4_map, AS_PROGRAM, 8, aristmk4_state )
AM_RANGE(0x0800, 0x17ff) AM_RAM
AM_RANGE(0x1800, 0x1800) AM_DEVREADWRITE("crtc", mc6845_device, status_r, address_w)
AM_RANGE(0x1801, 0x1801) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
- AM_RANGE(0x1c00, 0x1cff) AM_WRITE_LEGACY(mk4_printer_w)
- AM_RANGE(0x1900, 0x19ff) AM_READ_LEGACY(mk4_printer_r)
+ AM_RANGE(0x1c00, 0x1cff) AM_WRITE(mk4_printer_w)
+ AM_RANGE(0x1900, 0x19ff) AM_READ(mk4_printer_r)
AM_RANGE(0x2000, 0x3fff) AM_ROM // graphics rom map
AM_RANGE(0x4000, 0x4fff) AM_RAMBANK("bank1") AM_SHARE("nvram")
- AM_RANGE(0x5000, 0x5000) AM_WRITE_LEGACY(u3_p0)
- AM_RANGE(0x5002, 0x5002) AM_READ_LEGACY(u3_p2)
- AM_RANGE(0x5003, 0x5003) AM_READ_LEGACY(u3_p3)
- AM_RANGE(0x5005, 0x5005) AM_READ_LEGACY(ldsw)
+ AM_RANGE(0x5000, 0x5000) AM_WRITE(u3_p0)
+ AM_RANGE(0x5002, 0x5002) AM_READ(u3_p2)
+ AM_RANGE(0x5003, 0x5003) AM_READ(u3_p3)
+ AM_RANGE(0x5005, 0x5005) AM_READ(ldsw)
AM_RANGE(0x500d, 0x500d) AM_READ_PORT("500d")
AM_RANGE(0x500e, 0x500e) AM_READ_PORT("500e")
AM_RANGE(0x500f, 0x500f) AM_READ_PORT("500f")
AM_RANGE(0x5010, 0x501f) AM_DEVREADWRITE("via6522_0",via6522_device,read,write)
- AM_RANGE(0x5200, 0x5200) AM_READ_LEGACY(cashcade_r)
+ AM_RANGE(0x5200, 0x5200) AM_READ(cashcade_r)
AM_RANGE(0x5201, 0x5201) AM_READ_PORT("5201")
- AM_RANGE(0x52c0, 0x52c0) AM_READ_LEGACY(bv_p0)
- AM_RANGE(0x52c1, 0x52c1) AM_READ_LEGACY(bv_p1)
+ AM_RANGE(0x52c0, 0x52c0) AM_READ(bv_p0)
+ AM_RANGE(0x52c1, 0x52c1) AM_READ(bv_p1)
AM_RANGE(0x527f, 0x5281) AM_DEVREADWRITE_LEGACY("ppi8255_0", ppi8255_r, ppi8255_w)
AM_RANGE(0x5300, 0x5300) AM_READ_PORT("5300")
AM_RANGE(0x5380, 0x5383) AM_DEVREADWRITE("pia6821_0", pia6821_device, read, write) // RTC data - PORT A , mechanical meters - PORTB ??
- AM_RANGE(0x5440, 0x5440) AM_WRITE_LEGACY(mlamps) // take win and gamble lamps
- AM_RANGE(0x5468, 0x5468) AM_READWRITE_LEGACY(cgdrr,cgdrw) // 4020 ripple counter outputs
+ AM_RANGE(0x5440, 0x5440) AM_WRITE(mlamps) // take win and gamble lamps
+ AM_RANGE(0x5468, 0x5468) AM_READWRITE(cgdrr,cgdrw) // 4020 ripple counter outputs
AM_RANGE(0x6000, 0xffff) AM_ROM // game roms
ADDRESS_MAP_END
@@ -919,27 +923,27 @@ static ADDRESS_MAP_START( aristmk4_poker_map, AS_PROGRAM, 8, aristmk4_state )
AM_RANGE(0x0800, 0x17ff) AM_RAM
AM_RANGE(0x1800, 0x1800) AM_DEVREADWRITE("crtc", mc6845_device, status_r, address_w)
AM_RANGE(0x1801, 0x1801) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
- AM_RANGE(0x1c00, 0x1cff) AM_WRITE_LEGACY(mk4_printer_w)
- AM_RANGE(0x1900, 0x19ff) AM_READ_LEGACY(mk4_printer_r)
+ AM_RANGE(0x1c00, 0x1cff) AM_WRITE(mk4_printer_w)
+ AM_RANGE(0x1900, 0x19ff) AM_READ(mk4_printer_r)
AM_RANGE(0x4000, 0x4fff) AM_RAMBANK("bank1") AM_SHARE("nvram")
- AM_RANGE(0x5000, 0x5000) AM_WRITE_LEGACY(u3_p0)
- AM_RANGE(0x5002, 0x5002) AM_READ_LEGACY(u3_p2)
+ AM_RANGE(0x5000, 0x5000) AM_WRITE(u3_p0)
+ AM_RANGE(0x5002, 0x5002) AM_READ(u3_p2)
AM_RANGE(0x5003, 0x5003) AM_READ_PORT("5003")
- AM_RANGE(0x5005, 0x5005) AM_READ_LEGACY(ldsw)
+ AM_RANGE(0x5005, 0x5005) AM_READ(ldsw)
AM_RANGE(0x500d, 0x500d) AM_READ_PORT("500d")
AM_RANGE(0x500e, 0x500e) AM_READ_PORT("500e")
AM_RANGE(0x500f, 0x500f) AM_READ_PORT("500f")
AM_RANGE(0x5010, 0x501f) AM_DEVREADWRITE("via6522_0",via6522_device,read,write)
- AM_RANGE(0x5200, 0x5200) AM_READ_LEGACY(cashcade_r)
+ AM_RANGE(0x5200, 0x5200) AM_READ(cashcade_r)
AM_RANGE(0x5201, 0x5201) AM_READ_PORT("5201")
- AM_RANGE(0x52c0, 0x52c0) AM_READ_LEGACY(bv_p0)
- AM_RANGE(0x52c1, 0x52c1) AM_READ_LEGACY(bv_p1)
+ AM_RANGE(0x52c0, 0x52c0) AM_READ(bv_p0)
+ AM_RANGE(0x52c1, 0x52c1) AM_READ(bv_p1)
AM_RANGE(0x527f, 0x5281) AM_DEVREADWRITE_LEGACY("ppi8255_0", ppi8255_r, ppi8255_w)
AM_RANGE(0x5300, 0x5300) AM_READ_PORT("5300")
AM_RANGE(0x5380, 0x5383) AM_DEVREADWRITE("pia6821_0", pia6821_device, read, write) // RTC data - PORT A , mechanical meters - PORTB ??
- AM_RANGE(0x5440, 0x5440) AM_WRITE_LEGACY(mlamps) // take win and gamble lamps
- AM_RANGE(0x5468, 0x5468) AM_READWRITE_LEGACY(cgdrr,cgdrw) // 4020 ripple counter outputs
+ AM_RANGE(0x5440, 0x5440) AM_WRITE(mlamps) // take win and gamble lamps
+ AM_RANGE(0x5468, 0x5468) AM_READWRITE(cgdrr,cgdrw) // 4020 ripple counter outputs
AM_RANGE(0x6000, 0x7fff) AM_ROM // graphics rom map
AM_RANGE(0x8000, 0xffff) AM_ROM // game roms
ADDRESS_MAP_END
@@ -1521,13 +1525,13 @@ static const via6522_interface via_interface =
static const pia6821_interface aristmk4_pia1_intf =
{
- DEVCB_MEMORY_HANDLER("maincpu",PROGRAM,mkiv_pia_ina), // port A in
+ DEVCB_DRIVER_MEMBER(aristmk4_state, mkiv_pia_ina), // port A in
DEVCB_NULL, // port B in
DEVCB_NULL, // line CA1 in
DEVCB_NULL, // line CB1 in
DEVCB_NULL, // line CA2 in
DEVCB_NULL, // line CB2 in
- DEVCB_MEMORY_HANDLER("maincpu",PROGRAM,mkiv_pia_outa), // port A out
+ DEVCB_DRIVER_MEMBER(aristmk4_state, mkiv_pia_outa), // port A out
DEVCB_HANDLER(mkiv_pia_outb), // port B out
DEVCB_HANDLER(mkiv_pia_ca2), // line CA2 out
DEVCB_HANDLER(mkiv_pia_cb2), // port CB2 out
diff --git a/src/mame/drivers/backfire.c b/src/mame/drivers/backfire.c
index a4b8422ad11..54f25695868 100644
--- a/src/mame/drivers/backfire.c
+++ b/src/mame/drivers/backfire.c
@@ -52,6 +52,22 @@ public:
UINT16 m_pf2_rowscroll[0x0800/2];
UINT16 m_pf3_rowscroll[0x0800/2];
UINT16 m_pf4_rowscroll[0x0800/2];
+ DECLARE_READ32_MEMBER(backfire_control2_r);
+ DECLARE_READ32_MEMBER(backfire_control3_r);
+ DECLARE_WRITE32_MEMBER(backfire_nonbuffered_palette_w);
+ DECLARE_READ32_MEMBER(backfire_pf1_rowscroll_r);
+ DECLARE_READ32_MEMBER(backfire_pf2_rowscroll_r);
+ DECLARE_READ32_MEMBER(backfire_pf3_rowscroll_r);
+ DECLARE_READ32_MEMBER(backfire_pf4_rowscroll_r);
+ DECLARE_WRITE32_MEMBER(backfire_pf1_rowscroll_w);
+ DECLARE_WRITE32_MEMBER(backfire_pf2_rowscroll_w);
+ DECLARE_WRITE32_MEMBER(backfire_pf3_rowscroll_w);
+ DECLARE_WRITE32_MEMBER(backfire_pf4_rowscroll_w);
+ DECLARE_READ32_MEMBER(backfire_spriteram1_r);
+ DECLARE_WRITE32_MEMBER(backfire_spriteram1_w);
+ DECLARE_READ32_MEMBER(backfire_spriteram2_r);
+ DECLARE_WRITE32_MEMBER(backfire_spriteram2_w);
+ DECLARE_READ32_MEMBER(backfire_speedup_r);
};
//UINT32 *backfire_180010, *backfire_188010;
@@ -160,21 +176,19 @@ static READ32_DEVICE_HANDLER( backfire_eeprom_r )
| ((input_port_read(device->machine(), "IN3") & 0x40) << 16)) ^ (backfire_screen << 26) ;
}
-static READ32_HANDLER( backfire_control2_r )
+READ32_MEMBER(backfire_state::backfire_control2_r)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
-// logerror("%08x:Read eprom %08x (%08x)\n", cpu_get_pc(&space->device()), offset << 1, mem_mask);
- return (state->m_eeprom->read_bit() << 24) | input_port_read(space->machine(), "IN1") | (input_port_read(space->machine(), "IN1") << 16);
+// logerror("%08x:Read eprom %08x (%08x)\n", cpu_get_pc(&space.device()), offset << 1, mem_mask);
+ return (m_eeprom->read_bit() << 24) | input_port_read(machine(), "IN1") | (input_port_read(machine(), "IN1") << 16);
}
#ifdef UNUSED_FUNCTION
-static READ32_HANDLER(backfire_control3_r)
+READ32_MEMBER(backfire_state::backfire_control3_r)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
-// logerror("%08x:Read eprom %08x (%08x)\n", cpu_get_pc(&space->device()), offset << 1, mem_mask);
- return (state->m_eeprom->read_bit() << 24) | input_port_read(space->machine(), "IN2") | (input_port_read(space->machine(), "IN2") << 16);
+// logerror("%08x:Read eprom %08x (%08x)\n", cpu_get_pc(&space.device()), offset << 1, mem_mask);
+ return (m_eeprom->read_bit() << 24) | input_port_read(machine(), "IN2") | (input_port_read(machine(), "IN2") << 16);
}
#endif
@@ -192,22 +206,22 @@ static WRITE32_DEVICE_HANDLER(backfire_eeprom_w)
}
-static WRITE32_HANDLER(backfire_nonbuffered_palette_w)
+WRITE32_MEMBER(backfire_state::backfire_nonbuffered_palette_w)
{
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
- palette_set_color_rgb(space->machine(),offset,pal5bit(space->machine().generic.paletteram.u32[offset] >> 0),pal5bit(space->machine().generic.paletteram.u32[offset] >> 5),pal5bit(space->machine().generic.paletteram.u32[offset] >> 10));
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
+ palette_set_color_rgb(machine(),offset,pal5bit(machine().generic.paletteram.u32[offset] >> 0),pal5bit(machine().generic.paletteram.u32[offset] >> 5),pal5bit(machine().generic.paletteram.u32[offset] >> 10));
}
/* map 32-bit writes to 16-bit */
-static READ32_HANDLER( backfire_pf1_rowscroll_r ) { backfire_state *state = space->machine().driver_data<backfire_state>(); return state->m_pf1_rowscroll[offset] ^ 0xffff0000; }
-static READ32_HANDLER( backfire_pf2_rowscroll_r ) { backfire_state *state = space->machine().driver_data<backfire_state>(); return state->m_pf2_rowscroll[offset] ^ 0xffff0000; }
-static READ32_HANDLER( backfire_pf3_rowscroll_r ) { backfire_state *state = space->machine().driver_data<backfire_state>(); return state->m_pf3_rowscroll[offset] ^ 0xffff0000; }
-static READ32_HANDLER( backfire_pf4_rowscroll_r ) { backfire_state *state = space->machine().driver_data<backfire_state>(); return state->m_pf4_rowscroll[offset] ^ 0xffff0000; }
-static WRITE32_HANDLER( backfire_pf1_rowscroll_w ) { backfire_state *state = space->machine().driver_data<backfire_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf1_rowscroll[offset]); }
-static WRITE32_HANDLER( backfire_pf2_rowscroll_w ) { backfire_state *state = space->machine().driver_data<backfire_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf2_rowscroll[offset]); }
-static WRITE32_HANDLER( backfire_pf3_rowscroll_w ) { backfire_state *state = space->machine().driver_data<backfire_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf3_rowscroll[offset]); }
-static WRITE32_HANDLER( backfire_pf4_rowscroll_w ) { backfire_state *state = space->machine().driver_data<backfire_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf4_rowscroll[offset]); }
+READ32_MEMBER(backfire_state::backfire_pf1_rowscroll_r){ return m_pf1_rowscroll[offset] ^ 0xffff0000; }
+READ32_MEMBER(backfire_state::backfire_pf2_rowscroll_r){ return m_pf2_rowscroll[offset] ^ 0xffff0000; }
+READ32_MEMBER(backfire_state::backfire_pf3_rowscroll_r){ return m_pf3_rowscroll[offset] ^ 0xffff0000; }
+READ32_MEMBER(backfire_state::backfire_pf4_rowscroll_r){ return m_pf4_rowscroll[offset] ^ 0xffff0000; }
+WRITE32_MEMBER(backfire_state::backfire_pf1_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf1_rowscroll[offset]); }
+WRITE32_MEMBER(backfire_state::backfire_pf2_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf2_rowscroll[offset]); }
+WRITE32_MEMBER(backfire_state::backfire_pf3_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf3_rowscroll[offset]); }
+WRITE32_MEMBER(backfire_state::backfire_pf4_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf4_rowscroll[offset]); }
#ifdef UNUSED_FUNCTION
@@ -228,34 +242,30 @@ READ32_HANDLER( backfire_wheel2_r )
#endif
-static READ32_HANDLER( backfire_spriteram1_r )
+READ32_MEMBER(backfire_state::backfire_spriteram1_r)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
- return state->m_spriteram_1[offset] ^ 0xffff0000;
+ return m_spriteram_1[offset] ^ 0xffff0000;
}
-static WRITE32_HANDLER( backfire_spriteram1_w )
+WRITE32_MEMBER(backfire_state::backfire_spriteram1_w)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
data &= 0x0000ffff;
mem_mask &= 0x0000ffff;
- COMBINE_DATA(&state->m_spriteram_1[offset]);
+ COMBINE_DATA(&m_spriteram_1[offset]);
}
-static READ32_HANDLER( backfire_spriteram2_r )
+READ32_MEMBER(backfire_state::backfire_spriteram2_r)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
- return state->m_spriteram_2[offset] ^ 0xffff0000;
+ return m_spriteram_2[offset] ^ 0xffff0000;
}
-static WRITE32_HANDLER( backfire_spriteram2_w )
+WRITE32_MEMBER(backfire_state::backfire_spriteram2_w)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
data &= 0x0000ffff;
mem_mask &= 0x0000ffff;
- COMBINE_DATA(&state->m_spriteram_2[offset]);
+ COMBINE_DATA(&m_spriteram_2[offset]);
}
@@ -265,23 +275,23 @@ static ADDRESS_MAP_START( backfire_map, AS_PROGRAM, 32, backfire_state )
AM_RANGE(0x100000, 0x10001f) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf_control_dword_r, deco16ic_pf_control_dword_w)
AM_RANGE(0x110000, 0x111fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf1_data_dword_r, deco16ic_pf1_data_dword_w)
AM_RANGE(0x114000, 0x115fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf2_data_dword_r, deco16ic_pf2_data_dword_w)
- AM_RANGE(0x120000, 0x120fff) AM_READWRITE_LEGACY(backfire_pf1_rowscroll_r, backfire_pf1_rowscroll_w)
- AM_RANGE(0x124000, 0x124fff) AM_READWRITE_LEGACY(backfire_pf2_rowscroll_r, backfire_pf2_rowscroll_w)
+ AM_RANGE(0x120000, 0x120fff) AM_READWRITE(backfire_pf1_rowscroll_r, backfire_pf1_rowscroll_w)
+ AM_RANGE(0x124000, 0x124fff) AM_READWRITE(backfire_pf2_rowscroll_r, backfire_pf2_rowscroll_w)
AM_RANGE(0x130000, 0x13001f) AM_DEVREADWRITE_LEGACY("tilegen2", deco16ic_pf_control_dword_r, deco16ic_pf_control_dword_w)
AM_RANGE(0x140000, 0x141fff) AM_DEVREADWRITE_LEGACY("tilegen2", deco16ic_pf1_data_dword_r, deco16ic_pf1_data_dword_w)
AM_RANGE(0x144000, 0x145fff) AM_DEVREADWRITE_LEGACY("tilegen2", deco16ic_pf2_data_dword_r, deco16ic_pf2_data_dword_w)
- AM_RANGE(0x150000, 0x150fff) AM_READWRITE_LEGACY(backfire_pf3_rowscroll_r, backfire_pf3_rowscroll_w)
- AM_RANGE(0x154000, 0x154fff) AM_READWRITE_LEGACY(backfire_pf4_rowscroll_r, backfire_pf4_rowscroll_w)
- AM_RANGE(0x160000, 0x161fff) AM_WRITE_LEGACY(backfire_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x150000, 0x150fff) AM_READWRITE(backfire_pf3_rowscroll_r, backfire_pf3_rowscroll_w)
+ AM_RANGE(0x154000, 0x154fff) AM_READWRITE(backfire_pf4_rowscroll_r, backfire_pf4_rowscroll_w)
+ AM_RANGE(0x160000, 0x161fff) AM_WRITE(backfire_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x170000, 0x177fff) AM_RAM AM_BASE(m_mainram)// main ram
// AM_RANGE(0x180010, 0x180013) AM_RAM AM_BASE_LEGACY(&backfire_180010) // always 180010 ?
// AM_RANGE(0x188010, 0x188013) AM_RAM AM_BASE_LEGACY(&backfire_188010) // always 188010 ?
- AM_RANGE(0x184000, 0x185fff) AM_READWRITE_LEGACY(backfire_spriteram1_r, backfire_spriteram1_w)
- AM_RANGE(0x18c000, 0x18dfff) AM_READWRITE_LEGACY(backfire_spriteram2_r, backfire_spriteram2_w)
+ AM_RANGE(0x184000, 0x185fff) AM_READWRITE(backfire_spriteram1_r, backfire_spriteram1_w)
+ AM_RANGE(0x18c000, 0x18dfff) AM_READWRITE(backfire_spriteram2_r, backfire_spriteram2_w)
AM_RANGE(0x190000, 0x190003) AM_DEVREAD_LEGACY("eeprom", backfire_eeprom_r)
- AM_RANGE(0x194000, 0x194003) AM_READ_LEGACY(backfire_control2_r)
+ AM_RANGE(0x194000, 0x194003) AM_READ(backfire_control2_r)
AM_RANGE(0x1a4000, 0x1a4003) AM_DEVWRITE_LEGACY("eeprom", backfire_eeprom_w)
AM_RANGE(0x1a8000, 0x1a8003) AM_RAM AM_BASE(m_left_priority)
@@ -675,16 +685,15 @@ static void descramble_sound( running_machine &machine )
auto_free(machine, buf1);
}
-static READ32_HANDLER( backfire_speedup_r )
+READ32_MEMBER(backfire_state::backfire_speedup_r)
{
- backfire_state *state = space->machine().driver_data<backfire_state>();
- //mame_printf_debug( "%08x\n",cpu_get_pc(&space->device()));
+ //mame_printf_debug( "%08x\n",cpu_get_pc(&space.device()));
- if (cpu_get_pc(&space->device() )== 0xce44) device_spin_until_time(&space->device(), attotime::from_usec(400)); // backfire
- if (cpu_get_pc(&space->device()) == 0xcee4) device_spin_until_time(&space->device(), attotime::from_usec(400)); // backfirea
+ if (cpu_get_pc(&space.device() )== 0xce44) device_spin_until_time(&space.device(), attotime::from_usec(400)); // backfire
+ if (cpu_get_pc(&space.device()) == 0xcee4) device_spin_until_time(&space.device(), attotime::from_usec(400)); // backfirea
- return state->m_mainram[0x18/4];
+ return m_mainram[0x18/4];
}
@@ -695,7 +704,8 @@ static DRIVER_INIT( backfire )
deco156_decrypt(machine);
machine.device("maincpu")->set_clock_scale(4.0f); /* core timings aren't accurate */
descramble_sound(machine);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0170018, 0x017001b, FUNC(backfire_speedup_r) );
+ backfire_state *state = machine.driver_data<backfire_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x0170018, 0x017001b, read32_delegate(FUNC(backfire_state::backfire_speedup_r), state));
}
GAME( 1995, backfire, 0, backfire, backfire, backfire, ROT0, "Data East Corporation", "Backfire! (set 1)", GAME_SUPPORTS_SAVE )
diff --git a/src/mame/drivers/berzerk.c b/src/mame/drivers/berzerk.c
index 66942ebc8ad..97834ffa545 100644
--- a/src/mame/drivers/berzerk.c
+++ b/src/mame/drivers/berzerk.c
@@ -37,6 +37,22 @@ public:
int m_p1_direction;
int m_p2_counter_74ls161;
int m_p2_direction;
+ DECLARE_READ8_MEMBER(led_on_r);
+ DECLARE_WRITE8_MEMBER(led_on_w);
+ DECLARE_READ8_MEMBER(led_off_r);
+ DECLARE_WRITE8_MEMBER(led_off_w);
+ DECLARE_WRITE8_MEMBER(irq_enable_w);
+ DECLARE_WRITE8_MEMBER(nmi_enable_w);
+ DECLARE_WRITE8_MEMBER(nmi_disable_w);
+ DECLARE_READ8_MEMBER(nmi_enable_r);
+ DECLARE_READ8_MEMBER(nmi_disable_r);
+ DECLARE_WRITE8_MEMBER(magicram_w);
+ DECLARE_WRITE8_MEMBER(magicram_control_w);
+ DECLARE_READ8_MEMBER(intercept_v256_r);
+ DECLARE_WRITE8_MEMBER(berzerk_audio_w);
+ DECLARE_READ8_MEMBER(berzerk_audio_r);
+ DECLARE_READ8_MEMBER(moonwarp_p1_r);
+ DECLARE_READ8_MEMBER(moonwarp_p2_r);
};
@@ -70,31 +86,31 @@ static const UINT8 nmi_trigger_v256s [NMIS_PER_FRAME] = { 0x00, 0x00, 0x00, 0x00
*
*************************************/
-static READ8_HANDLER( led_on_r )
+READ8_MEMBER(berzerk_state::led_on_r)
{
- set_led_status(space->machine(), 0, 1);
+ set_led_status(machine(), 0, 1);
return 0;
}
-static WRITE8_HANDLER( led_on_w )
+WRITE8_MEMBER(berzerk_state::led_on_w)
{
- set_led_status(space->machine(), 0, 1);
+ set_led_status(machine(), 0, 1);
}
-static READ8_HANDLER( led_off_r )
+READ8_MEMBER(berzerk_state::led_off_r)
{
- set_led_status(space->machine(), 0, 0);
+ set_led_status(machine(), 0, 0);
return 0;
}
-static WRITE8_HANDLER( led_off_w )
+WRITE8_MEMBER(berzerk_state::led_off_w)
{
- set_led_status(space->machine(), 0, 0);
+ set_led_status(machine(), 0, 0);
}
@@ -153,10 +169,9 @@ static int vsync_chain_counter_to_vpos(UINT8 counter, UINT8 v256)
*
*************************************/
-static WRITE8_HANDLER( irq_enable_w )
+WRITE8_MEMBER(berzerk_state::irq_enable_w)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
- state->m_irq_enabled = data & 0x01;
+ m_irq_enabled = data & 0x01;
}
@@ -212,33 +227,29 @@ static void start_irq_timer(running_machine &machine)
*
*************************************/
-static WRITE8_HANDLER( nmi_enable_w )
+WRITE8_MEMBER(berzerk_state::nmi_enable_w)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
- state->m_nmi_enabled = 1;
+ m_nmi_enabled = 1;
}
-static WRITE8_HANDLER( nmi_disable_w )
+WRITE8_MEMBER(berzerk_state::nmi_disable_w)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
- state->m_nmi_enabled = 0;
+ m_nmi_enabled = 0;
}
-static READ8_HANDLER( nmi_enable_r )
+READ8_MEMBER(berzerk_state::nmi_enable_r)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
- state->m_nmi_enabled = 1;
+ m_nmi_enabled = 1;
return 0;
}
-static READ8_HANDLER( nmi_disable_r )
+READ8_MEMBER(berzerk_state::nmi_disable_r)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
- state->m_nmi_enabled = 0;
+ m_nmi_enabled = 0;
return 0;
}
@@ -347,65 +358,62 @@ static VIDEO_START( berzerk )
}
-static WRITE8_HANDLER( magicram_w )
+WRITE8_MEMBER(berzerk_state::magicram_w)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
UINT8 alu_output;
- UINT8 current_video_data = state->m_videoram[offset];
+ UINT8 current_video_data = m_videoram[offset];
/* shift data towards LSB. MSB bits are filled by data from last_shift_data.
The shifter consists of 5 74153 devices @ 7A, 8A, 9A, 10A and 11A,
followed by 4 more 153's at 11B, 10B, 9B and 8B, which optionally
reverse the order of the resulting bits */
- UINT8 shift_flop_output = (((UINT16)state->m_last_shift_data << 8) | data) >> (state->m_magicram_control & 0x07);
+ UINT8 shift_flop_output = (((UINT16)m_last_shift_data << 8) | data) >> (m_magicram_control & 0x07);
- if (state->m_magicram_control & 0x08)
+ if (m_magicram_control & 0x08)
shift_flop_output = BITSWAP8(shift_flop_output, 0, 1, 2, 3, 4, 5, 6, 7);
/* collision detection - AND gate output goes to the K pin of the flip-flop,
while J is LO, therefore, it only resets, never sets */
if (shift_flop_output & current_video_data)
- state->m_intercept = 0;
+ m_intercept = 0;
/* perform ALU step */
TTL74181_write(LS181_12C, TTL74181_INPUT_A0, 4, shift_flop_output & 0x0f);
TTL74181_write(LS181_10C, TTL74181_INPUT_A0, 4, shift_flop_output >> 4);
TTL74181_write(LS181_12C, TTL74181_INPUT_B0, 4, current_video_data & 0x0f);
TTL74181_write(LS181_10C, TTL74181_INPUT_B0, 4, current_video_data >> 4);
- TTL74181_write(LS181_12C, TTL74181_INPUT_S0, 4, state->m_magicram_control >> 4);
- TTL74181_write(LS181_10C, TTL74181_INPUT_S0, 4, state->m_magicram_control >> 4);
+ TTL74181_write(LS181_12C, TTL74181_INPUT_S0, 4, m_magicram_control >> 4);
+ TTL74181_write(LS181_10C, TTL74181_INPUT_S0, 4, m_magicram_control >> 4);
alu_output = (TTL74181_read(LS181_10C, TTL74181_OUTPUT_F0, 4) << 4) |
(TTL74181_read(LS181_12C, TTL74181_OUTPUT_F0, 4) << 0);
- state->m_videoram[offset] = alu_output ^ 0xff;
+ m_videoram[offset] = alu_output ^ 0xff;
/* save data for next time */
- state->m_last_shift_data = data & 0x7f;
+ m_last_shift_data = data & 0x7f;
}
-static WRITE8_HANDLER( magicram_control_w )
+WRITE8_MEMBER(berzerk_state::magicram_control_w)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
/* save the control byte, clear the shift data latch,
and set the intercept flip-flop */
- state->m_magicram_control = data;
- state->m_last_shift_data = 0;
- state->m_intercept = 1;
+ m_magicram_control = data;
+ m_last_shift_data = 0;
+ m_intercept = 1;
}
-static READ8_HANDLER( intercept_v256_r )
+READ8_MEMBER(berzerk_state::intercept_v256_r)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
UINT8 counter;
UINT8 v256;
- vpos_to_vsync_chain_counter(space->machine().primary_screen->vpos(), &counter, &v256);
+ vpos_to_vsync_chain_counter(machine().primary_screen->vpos(), &counter, &v256);
- return (!state->m_intercept << 7) | v256;
+ return (!m_intercept << 7) | v256;
}
@@ -492,7 +500,7 @@ static SCREEN_UPDATE_RGB32( berzerk )
*
*************************************/
-static WRITE8_HANDLER( berzerk_audio_w )
+WRITE8_MEMBER(berzerk_state::berzerk_audio_w)
{
device_t *device;
int clock_divisor;
@@ -501,7 +509,7 @@ static WRITE8_HANDLER( berzerk_audio_w )
{
/* offset 4 writes to the S14001A */
case 4:
- device = space->machine().device("speech");
+ device = machine().device("speech");
switch (data >> 6)
{
/* write data to the S14001 */
@@ -519,7 +527,7 @@ static WRITE8_HANDLER( berzerk_audio_w )
break;
case 1:
- device = space->machine().device("speech");
+ device = machine().device("speech");
/* volume */
s14001a_set_volume(device, ((data & 0x38) >> 3) + 1);
@@ -537,21 +545,21 @@ static WRITE8_HANDLER( berzerk_audio_w )
/* offset 6 writes to the sfxcontrol latch */
case 6:
- exidy_sfxctrl_w(space->machine().device("exidy"), data >> 6, data);
+ exidy_sfxctrl_w(machine().device("exidy"), data >> 6, data);
break;
/* everything else writes to the 6840 */
default:
- exidy_sh6840_w(space->machine().device("exidy"), offset, data);
+ exidy_sh6840_w(machine().device("exidy"), offset, data);
break;
}
}
-static READ8_HANDLER( berzerk_audio_r )
+READ8_MEMBER(berzerk_state::berzerk_audio_r)
{
- device_t *device = space->machine().device("speech");
+ device_t *device = machine().device("speech");
switch (offset)
{
/* offset 4 reads from the S14001A */
@@ -563,7 +571,7 @@ static READ8_HANDLER( berzerk_audio_r )
return 0;
/* everything else reads from the 6840 */
default:
- return exidy_sh6840_r(space->machine().device("exidy"), offset);
+ return exidy_sh6840_r(machine().device("exidy"), offset);
}
}
@@ -572,8 +580,9 @@ static READ8_HANDLER( berzerk_audio_r )
static SOUND_RESET(berzerk)
{
address_space *space = machine.device("maincpu")->memory().space(AS_IO);
+ berzerk_state *state = machine.driver_data<berzerk_state>();
/* clears the flip-flop controlling the volume and freq on the speech chip */
- berzerk_audio_w(space, 4, 0x40);
+ state->berzerk_audio_w(*space, 4, 0x40);
}
@@ -589,7 +598,7 @@ static ADDRESS_MAP_START( berzerk_map, AS_PROGRAM, 8, berzerk_state )
AM_RANGE(0x0800, 0x0bff) AM_MIRROR(0x0400) AM_RAM AM_SHARE("nvram")
AM_RANGE(0x1000, 0x3fff) AM_ROM
AM_RANGE(0x4000, 0x5fff) AM_RAM AM_BASE(m_videoram) AM_SIZE(m_videoram_size) AM_SHARE("share1")
- AM_RANGE(0x6000, 0x7fff) AM_RAM_WRITE_LEGACY(magicram_w) AM_SHARE("share1")
+ AM_RANGE(0x6000, 0x7fff) AM_RAM_WRITE(magicram_w) AM_SHARE("share1")
AM_RANGE(0x8000, 0x87ff) AM_MIRROR(0x3800) AM_RAM AM_BASE(m_colorram)
AM_RANGE(0xc000, 0xffff) AM_NOP
ADDRESS_MAP_END
@@ -598,7 +607,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( frenzy_map, AS_PROGRAM, 8, berzerk_state )
AM_RANGE(0x0000, 0x3fff) AM_ROM
AM_RANGE(0x4000, 0x5fff) AM_RAM AM_BASE(m_videoram) AM_SIZE(m_videoram_size) AM_SHARE("share1")
- AM_RANGE(0x6000, 0x7fff) AM_RAM_WRITE_LEGACY(magicram_w) AM_SHARE("share1")
+ AM_RANGE(0x6000, 0x7fff) AM_RAM_WRITE(magicram_w) AM_SHARE("share1")
AM_RANGE(0x8000, 0x87ff) AM_MIRROR(0x3800) AM_RAM AM_BASE(m_colorram)
AM_RANGE(0xc000, 0xcfff) AM_ROM
AM_RANGE(0xf800, 0xfbff) AM_MIRROR(0x0400) AM_RAM AM_SHARE("nvram")
@@ -615,15 +624,15 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( berzerk_io_map, AS_IO, 8, berzerk_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x00, 0x3f) AM_NOP
- AM_RANGE(0x40, 0x47) AM_READWRITE_LEGACY(berzerk_audio_r, berzerk_audio_w)
+ AM_RANGE(0x40, 0x47) AM_READWRITE(berzerk_audio_r, berzerk_audio_w)
AM_RANGE(0x48, 0x48) AM_READ_PORT("P1") AM_WRITENOP
AM_RANGE(0x49, 0x49) AM_READ_PORT("SYSTEM") AM_WRITENOP
AM_RANGE(0x4a, 0x4a) AM_READ_PORT("P2") AM_WRITENOP
- AM_RANGE(0x4b, 0x4b) AM_READNOP AM_WRITE_LEGACY(magicram_control_w)
- AM_RANGE(0x4c, 0x4c) AM_READWRITE_LEGACY(nmi_enable_r, nmi_enable_w)
- AM_RANGE(0x4d, 0x4d) AM_READWRITE_LEGACY(nmi_disable_r, nmi_disable_w)
- AM_RANGE(0x4e, 0x4e) AM_READ_LEGACY(intercept_v256_r) AM_WRITENOP // note reading from here should clear pending frame interrupts, see zfb-1.tiff 74ls74 at 3D pin 13 /CLR
- AM_RANGE(0x4f, 0x4f) AM_READNOP AM_WRITE_LEGACY(irq_enable_w)
+ AM_RANGE(0x4b, 0x4b) AM_READNOP AM_WRITE(magicram_control_w)
+ AM_RANGE(0x4c, 0x4c) AM_READWRITE(nmi_enable_r, nmi_enable_w)
+ AM_RANGE(0x4d, 0x4d) AM_READWRITE(nmi_disable_r, nmi_disable_w)
+ AM_RANGE(0x4e, 0x4e) AM_READ(intercept_v256_r) AM_WRITENOP // note reading from here should clear pending frame interrupts, see zfb-1.tiff 74ls74 at 3D pin 13 /CLR
+ AM_RANGE(0x4f, 0x4f) AM_READNOP AM_WRITE(irq_enable_w)
AM_RANGE(0x50, 0x57) AM_NOP /* second sound board, initialized but not used */
AM_RANGE(0x58, 0x5f) AM_NOP
AM_RANGE(0x60, 0x60) AM_MIRROR(0x18) AM_READ_PORT("F3") AM_WRITENOP
@@ -632,8 +641,8 @@ static ADDRESS_MAP_START( berzerk_io_map, AS_IO, 8, berzerk_state )
AM_RANGE(0x63, 0x63) AM_MIRROR(0x18) AM_READ_PORT("F5") AM_WRITENOP
AM_RANGE(0x64, 0x64) AM_MIRROR(0x18) AM_READ_PORT("F4") AM_WRITENOP
AM_RANGE(0x65, 0x65) AM_MIRROR(0x18) AM_READ_PORT("SW2") AM_WRITENOP
- AM_RANGE(0x66, 0x66) AM_MIRROR(0x18) AM_READWRITE_LEGACY(led_off_r, led_off_w)
- AM_RANGE(0x67, 0x67) AM_MIRROR(0x18) AM_READWRITE_LEGACY(led_on_r, led_on_w)
+ AM_RANGE(0x66, 0x66) AM_MIRROR(0x18) AM_READWRITE(led_off_r, led_off_w)
+ AM_RANGE(0x67, 0x67) AM_MIRROR(0x18) AM_READWRITE(led_on_r, led_on_w)
AM_RANGE(0x80, 0xff) AM_NOP
ADDRESS_MAP_END
@@ -885,40 +894,38 @@ static INPUT_PORTS_START( frenzy )
PORT_DIPSETTING( 0xff, "255" )
INPUT_PORTS_END
-static READ8_HANDLER( moonwarp_p1_r )
+READ8_MEMBER(berzerk_state::moonwarp_p1_r)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
// This seems to be the same type of dial as the later 'moon war 2' set uses
// see http://www.cityofberwyn.com/schematics/stern/MoonWar_opto.tiff for schematic
// I.e. a 74ls161 counts from 0 to 15 which is the absolute number of bars passed on the quadrature
// one difference is it lacks the strobe input (does it?), which if not active causes
// the dial input to go open bus. This is used in moon war 2 to switch between player 1
// and player 2 dials, which share a single port. moonwarp uses separate ports for the dials.
- signed char dialread = input_port_read(space->machine(),"P1_DIAL");
+ signed char dialread = input_port_read(machine(),"P1_DIAL");
UINT8 ret;
- UINT8 buttons = (input_port_read(space->machine(),"P1")&0xe0);
- if (dialread < 0) state->m_p1_direction = 0;
- else if (dialread > 0) state->m_p1_direction = 0x10;
- state->m_p1_counter_74ls161 += abs(dialread);
- state->m_p1_counter_74ls161 &= 0xf;
- ret = state->m_p1_counter_74ls161 | state->m_p1_direction | buttons;
- //fprintf(stderr, "dialread1: %02x, p1_counter_74ls161: %02x, spinner ret is %02x\n", dialread, state->m_p1_counter_74ls161, ret);
+ UINT8 buttons = (input_port_read(machine(),"P1")&0xe0);
+ if (dialread < 0) m_p1_direction = 0;
+ else if (dialread > 0) m_p1_direction = 0x10;
+ m_p1_counter_74ls161 += abs(dialread);
+ m_p1_counter_74ls161 &= 0xf;
+ ret = m_p1_counter_74ls161 | m_p1_direction | buttons;
+ //fprintf(stderr, "dialread1: %02x, p1_counter_74ls161: %02x, spinner ret is %02x\n", dialread, m_p1_counter_74ls161, ret);
return ret;
}
-static READ8_HANDLER( moonwarp_p2_r )
+READ8_MEMBER(berzerk_state::moonwarp_p2_r)
{
- berzerk_state *state = space->machine().driver_data<berzerk_state>();
// same as above, but for player 2 in cocktail mode
- signed char dialread = input_port_read(space->machine(),"P2_DIAL");
+ signed char dialread = input_port_read(machine(),"P2_DIAL");
UINT8 ret;
- UINT8 buttons = (input_port_read(space->machine(),"P2")&0xe0);
- if (dialread < 0) state->m_p2_direction = 0;
- else if (dialread > 0) state->m_p2_direction = 0x10;
- state->m_p2_counter_74ls161 += abs(dialread);
- state->m_p2_counter_74ls161 &= 0xf;
- ret = state->m_p2_counter_74ls161 | state->m_p2_direction | buttons;
- //fprintf(stderr, "dialread2: %02x, p2_counter_74ls161: %02x, spinner ret is %02x\n", dialread, state->m_p2_counter_74ls161, ret);
+ UINT8 buttons = (input_port_read(machine(),"P2")&0xe0);
+ if (dialread < 0) m_p2_direction = 0;
+ else if (dialread > 0) m_p2_direction = 0x10;
+ m_p2_counter_74ls161 += abs(dialread);
+ m_p2_counter_74ls161 &= 0xf;
+ ret = m_p2_counter_74ls161 | m_p2_direction | buttons;
+ //fprintf(stderr, "dialread2: %02x, p2_counter_74ls161: %02x, spinner ret is %02x\n", dialread, m_p2_counter_74ls161, ret);
return ret;
}
@@ -1228,8 +1235,9 @@ ROM_END
static DRIVER_INIT( moonwarp )
{
address_space *io = machine.device("maincpu")->memory().space(AS_IO);
- io->install_legacy_read_handler (0x48, 0x48, FUNC(moonwarp_p1_r));
- io->install_legacy_read_handler (0x4a, 0x4a, FUNC(moonwarp_p2_r));
+ berzerk_state *state = machine.driver_data<berzerk_state>();
+ io->install_read_handler (0x48, 0x48, read8_delegate(FUNC(berzerk_state::moonwarp_p1_r), state));
+ io->install_read_handler (0x4a, 0x4a, read8_delegate(FUNC(berzerk_state::moonwarp_p2_r), state));
}
/*************************************
diff --git a/src/mame/drivers/bfm_sc2.c b/src/mame/drivers/bfm_sc2.c
index b5f709c8c9c..c76aaa2d64d 100644
--- a/src/mame/drivers/bfm_sc2.c
+++ b/src/mame/drivers/bfm_sc2.c
@@ -228,6 +228,53 @@ public:
int m_e2dummywrite;
int m_e2data_to_read;
UINT8 m_codec_data[256];
+ DECLARE_WRITE8_MEMBER(bankswitch_w);
+ DECLARE_WRITE8_MEMBER(reel12_vid_w);
+ DECLARE_WRITE8_MEMBER(reel12_w);
+ DECLARE_WRITE8_MEMBER(reel34_w);
+ DECLARE_WRITE8_MEMBER(reel56_w);
+ DECLARE_WRITE8_MEMBER(mmtr_w);
+ DECLARE_WRITE8_MEMBER(mux_output_w);
+ DECLARE_READ8_MEMBER(mux_input_r);
+ DECLARE_WRITE8_MEMBER(unlock_w);
+ DECLARE_WRITE8_MEMBER(dimas_w);
+ DECLARE_WRITE8_MEMBER(dimcnt_w);
+ DECLARE_WRITE8_MEMBER(unknown_w);
+ DECLARE_WRITE8_MEMBER(volume_override_w);
+ DECLARE_READ8_MEMBER(vfd_status_hop_r);
+ DECLARE_WRITE8_MEMBER(expansion_latch_w);
+ DECLARE_READ8_MEMBER(expansion_latch_r);
+ DECLARE_WRITE8_MEMBER(muxena_w);
+ DECLARE_WRITE8_MEMBER(timerirq_w);
+ DECLARE_READ8_MEMBER(timerirqclr_r);
+ DECLARE_READ8_MEMBER(irqstatus_r);
+ DECLARE_WRITE8_MEMBER(coininhib_w);
+ DECLARE_READ8_MEMBER(coin_input_r);
+ DECLARE_WRITE8_MEMBER(payout_latch_w);
+ DECLARE_WRITE8_MEMBER(payout_triac_w);
+ DECLARE_WRITE8_MEMBER(payout_select_w);
+ DECLARE_WRITE8_MEMBER(vfd2_data_w);
+ DECLARE_WRITE8_MEMBER(vfd_reset_w);
+ DECLARE_READ8_MEMBER(uart1stat_r);
+ DECLARE_READ8_MEMBER(uart1data_r);
+ DECLARE_WRITE8_MEMBER(uart1ctrl_w);
+ DECLARE_WRITE8_MEMBER(uart1data_w);
+ DECLARE_READ8_MEMBER(uart2stat_r);
+ DECLARE_READ8_MEMBER(uart2data_r);
+ DECLARE_WRITE8_MEMBER(uart2ctrl_w);
+ DECLARE_WRITE8_MEMBER(uart2data_w);
+ DECLARE_WRITE8_MEMBER(vid_uart_tx_w);
+ DECLARE_WRITE8_MEMBER(vid_uart_ctrl_w);
+ DECLARE_READ8_MEMBER(vid_uart_rx_r);
+ DECLARE_READ8_MEMBER(vid_uart_ctrl_r);
+ DECLARE_READ8_MEMBER(key_r);
+ DECLARE_READ8_MEMBER(vfd_status_r);
+ DECLARE_WRITE8_MEMBER(vfd1_data_w);
+ DECLARE_WRITE8_MEMBER(e2ram_w);
+ DECLARE_READ8_MEMBER(direct_input_r);
+ DECLARE_READ8_MEMBER(sc3_expansion_r);
+ DECLARE_WRITE8_MEMBER(sc3_expansion_w);
+ int recdata(int changed, int data);
};
@@ -427,9 +474,9 @@ static NVRAM_HANDLER( bfm_sc2 )
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( bankswitch_w )
+WRITE8_MEMBER(bfm_sc2_state::bankswitch_w)
{
- memory_set_bank(space->machine(), "bank1",data & 0x03);
+ memory_set_bank(machine(), "bank1",data & 0x03);
}
///////////////////////////////////////////////////////////////////////////
@@ -450,71 +497,68 @@ static INTERRUPT_GEN( timer_irq )
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( reel12_vid_w ) // in a video cabinet this is used to drive a hopper
+WRITE8_MEMBER(bfm_sc2_state::reel12_vid_w)// in a video cabinet this is used to drive a hopper
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_reel12_latch = data;
+ m_reel12_latch = data;
- if ( state->m_has_hopper )
+ if ( m_has_hopper )
{
- int oldhop = state->m_hopper_running;
+ int oldhop = m_hopper_running;
if ( data & 0x01 )
{ // hopper power
if ( data & 0x02 )
{
- state->m_hopper_running = 1;
+ m_hopper_running = 1;
}
else
{
- state->m_hopper_running = 0;
+ m_hopper_running = 0;
}
}
else
{
- //state->m_hopper_coin_sense = 0;
- state->m_hopper_running = 0;
+ //m_hopper_coin_sense = 0;
+ m_hopper_running = 0;
}
- if ( oldhop != state->m_hopper_running )
+ if ( oldhop != m_hopper_running )
{
- state->m_hopper_coin_sense = 0;
- oldhop = state->m_hopper_running;
+ m_hopper_coin_sense = 0;
+ oldhop = m_hopper_running;
}
}
}
/* Reels 1 and 2 */
-static WRITE8_HANDLER( reel12_w )
+WRITE8_MEMBER(bfm_sc2_state::reel12_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_reel12_latch = data;
+ m_reel12_latch = data;
- if ( stepper_update(0, data&0x0f ) ) state->m_reel_changed |= 0x01;
- if ( stepper_update(1, (data>>4))&0x0f ) state->m_reel_changed |= 0x02;
+ if ( stepper_update(0, data&0x0f ) ) m_reel_changed |= 0x01;
+ if ( stepper_update(1, (data>>4))&0x0f ) m_reel_changed |= 0x02;
- if ( stepper_optic_state(0) ) state->m_optic_pattern |= 0x01;
- else state->m_optic_pattern &= ~0x01;
- if ( stepper_optic_state(1) ) state->m_optic_pattern |= 0x02;
- else state->m_optic_pattern &= ~0x02;
+ if ( stepper_optic_state(0) ) m_optic_pattern |= 0x01;
+ else m_optic_pattern &= ~0x01;
+ if ( stepper_optic_state(1) ) m_optic_pattern |= 0x02;
+ else m_optic_pattern &= ~0x02;
awp_draw_reel(0);
awp_draw_reel(1);
}
-static WRITE8_HANDLER( reel34_w )
+WRITE8_MEMBER(bfm_sc2_state::reel34_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_reel34_latch = data;
+ m_reel34_latch = data;
- if ( stepper_update(2, data&0x0f ) ) state->m_reel_changed |= 0x04;
- if ( stepper_update(3, (data>>4)&0x0f) ) state->m_reel_changed |= 0x08;
+ if ( stepper_update(2, data&0x0f ) ) m_reel_changed |= 0x04;
+ if ( stepper_update(3, (data>>4)&0x0f) ) m_reel_changed |= 0x08;
- if ( stepper_optic_state(2) ) state->m_optic_pattern |= 0x04;
- else state->m_optic_pattern &= ~0x04;
- if ( stepper_optic_state(3) ) state->m_optic_pattern |= 0x08;
- else state->m_optic_pattern &= ~0x08;
+ if ( stepper_optic_state(2) ) m_optic_pattern |= 0x04;
+ else m_optic_pattern &= ~0x04;
+ if ( stepper_optic_state(3) ) m_optic_pattern |= 0x08;
+ else m_optic_pattern &= ~0x08;
awp_draw_reel(2);
awp_draw_reel(3);
@@ -522,18 +566,17 @@ static WRITE8_HANDLER( reel34_w )
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( reel56_w )
+WRITE8_MEMBER(bfm_sc2_state::reel56_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_reel56_latch = data;
+ m_reel56_latch = data;
- if ( stepper_update(4, data&0x0f ) ) state->m_reel_changed |= 0x10;
- if ( stepper_update(5, (data>>4)&0x0f) ) state->m_reel_changed |= 0x20;
+ if ( stepper_update(4, data&0x0f ) ) m_reel_changed |= 0x10;
+ if ( stepper_update(5, (data>>4)&0x0f) ) m_reel_changed |= 0x20;
- if ( stepper_optic_state(4) ) state->m_optic_pattern |= 0x10;
- else state->m_optic_pattern &= ~0x10;
- if ( stepper_optic_state(5) ) state->m_optic_pattern |= 0x20;
- else state->m_optic_pattern &= ~0x20;
+ if ( stepper_optic_state(4) ) m_optic_pattern |= 0x10;
+ else m_optic_pattern &= ~0x10;
+ if ( stepper_optic_state(5) ) m_optic_pattern |= 0x20;
+ else m_optic_pattern &= ~0x20;
awp_draw_reel(4);
awp_draw_reel(5);
@@ -545,13 +588,12 @@ static WRITE8_HANDLER( reel56_w )
// mechanical meters //////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( mmtr_w )
+WRITE8_MEMBER(bfm_sc2_state::mmtr_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
int i;
- int changed = state->m_mmtr_latch ^ data;
+ int changed = m_mmtr_latch ^ data;
- state->m_mmtr_latch = data;
+ m_mmtr_latch = data;
for (i = 0; i<8; i++)
{
@@ -560,12 +602,12 @@ static WRITE8_HANDLER( mmtr_w )
MechMtr_update(i, data & (1 << i) );
}
}
- if ( data & 0x1F ) cputag_set_input_line(space->machine(), "maincpu", M6809_FIRQ_LINE, ASSERT_LINE );
+ if ( data & 0x1F ) cputag_set_input_line(machine(), "maincpu", M6809_FIRQ_LINE, ASSERT_LINE );
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( mux_output_w )
+WRITE8_MEMBER(bfm_sc2_state::mux_output_w)
{
int i;
int off = offset<<3;
@@ -577,26 +619,25 @@ static WRITE8_HANDLER( mux_output_w )
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( mux_input_r )
+READ8_MEMBER(bfm_sc2_state::mux_input_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
int result = 0xFF,t1,t2;
static const char *const port[] = { "STROBE0", "STROBE1", "STROBE2", "STROBE3", "STROBE4", "STROBE5", "STROBE6", "STROBE7", "STROBE8", "STROBE9", "STROBE10", "STROBE11" };
if (offset < 8)
{
int idx = (offset & 4) ? 4 : 8;
- t1 = state->m_input_override[offset]; // strobe 0-7 data 0-4
- t2 = state->m_input_override[offset+idx]; // strobe 8-B data 0-4
+ t1 = m_input_override[offset]; // strobe 0-7 data 0-4
+ t2 = m_input_override[offset+idx]; // strobe 8-B data 0-4
- t1 = (state->m_sc2_Inputs[offset] & t1) | ( ( input_port_read(space->machine(), port[offset]) & ~t1) & 0x1F);
+ t1 = (m_sc2_Inputs[offset] & t1) | ( ( input_port_read(machine(), port[offset]) & ~t1) & 0x1F);
if (idx == 8)
- t2 = (state->m_sc2_Inputs[offset+8] & t2) | ( ( input_port_read(space->machine(), port[offset+8]) & ~t2) << 5);
+ t2 = (m_sc2_Inputs[offset+8] & t2) | ( ( input_port_read(machine(), port[offset+8]) & ~t2) << 5);
else
- t2 = (state->m_sc2_Inputs[offset+4] & t2) | ( ( ( input_port_read(space->machine(), port[offset+4]) & ~t2) << 2) & 0x60);
+ t2 = (m_sc2_Inputs[offset+4] & t2) | ( ( ( input_port_read(machine(), port[offset+4]) & ~t2) << 2) & 0x60);
- state->m_sc2_Inputs[offset] = (state->m_sc2_Inputs[offset] & ~0x1F) | t1;
- state->m_sc2_Inputs[offset+idx] = (state->m_sc2_Inputs[offset+idx] & ~0x60) | t2;
+ m_sc2_Inputs[offset] = (m_sc2_Inputs[offset] & ~0x1F) | t1;
+ m_sc2_Inputs[offset+idx] = (m_sc2_Inputs[offset+idx] & ~0x60) | t2;
result = t1 | t2;
}
@@ -605,42 +646,41 @@ static READ8_HANDLER( mux_input_r )
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( unlock_w )
+WRITE8_MEMBER(bfm_sc2_state::unlock_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( dimas_w )
+WRITE8_MEMBER(bfm_sc2_state::dimas_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( dimcnt_w )
+WRITE8_MEMBER(bfm_sc2_state::dimcnt_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( unknown_w )
+WRITE8_MEMBER(bfm_sc2_state::unknown_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( volume_override_w )
+WRITE8_MEMBER(bfm_sc2_state::volume_override_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- int old = state->m_volume_override;
+ int old = m_volume_override;
- state->m_volume_override = data?1:0;
+ m_volume_override = data?1:0;
- if ( old != state->m_volume_override )
+ if ( old != m_volume_override )
{
- ym2413_device *ym = space->machine().device<ym2413_device>("ymsnd");
- upd7759_device *upd = space->machine().device<upd7759_device>("upd");
- float percent = state->m_volume_override? 1.0f : (32-state->m_global_volume)/32.0f;
+ ym2413_device *ym = machine().device<ym2413_device>("ymsnd");
+ upd7759_device *upd = machine().device<upd7759_device>("upd");
+ float percent = m_volume_override? 1.0f : (32-m_global_volume)/32.0f;
ym->set_output_gain(0, percent);
ym->set_output_gain(1, percent);
@@ -675,45 +715,43 @@ static WRITE8_DEVICE_HANDLER( nec_latch_w )
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( vfd_status_hop_r ) // on video games, hopper inputs are connected to this
+READ8_MEMBER(bfm_sc2_state::vfd_status_hop_r)// on video games, hopper inputs are connected to this
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
// b7 = NEC busy
// b6 = alpha busy (also matrix board)
// b5 - b0 = reel optics
int result = 0;
- if ( state->m_has_hopper )
+ if ( m_has_hopper )
{
result |= 0x04; // hopper high level
result |= 0x08; // hopper low level
result |= 0x01|0x02;
- if ( state->m_hopper_running )
+ if ( m_hopper_running )
{
result &= ~0x01; // set motor running input
- if ( state->m_timercnt & 0x04 ) state->m_hopper_coin_sense ^= 1; // toggle coin seen
+ if ( m_timercnt & 0x04 ) m_hopper_coin_sense ^= 1; // toggle coin seen
- if ( state->m_hopper_coin_sense ) result &= ~0x02; // update coin seen input
+ if ( m_hopper_coin_sense ) result &= ~0x02; // update coin seen input
}
}
- if ( !upd7759_busy_r(space->machine().device("upd")) ) result |= 0x80; // update sound busy input
+ if ( !upd7759_busy_r(machine().device("upd")) ) result |= 0x80; // update sound busy input
return result;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( expansion_latch_w )
+WRITE8_MEMBER(bfm_sc2_state::expansion_latch_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- int changed = state->m_expansion_latch^data;
+ int changed = m_expansion_latch^data;
- state->m_expansion_latch = data;
+ m_expansion_latch = data;
// bit0, 1 = lamp mux disabled, 0 = lamp mux enabled
// bit1, ? used in Del's millions
@@ -730,17 +768,17 @@ static WRITE8_HANDLER( expansion_latch_w )
{ // changed from high to low,
if ( !(data & 0x08) )
{
- if ( state->m_global_volume < 31 ) state->m_global_volume++; //0-31 expressed as 1-32
+ if ( m_global_volume < 31 ) m_global_volume++; //0-31 expressed as 1-32
}
else
{
- if ( state->m_global_volume > 0 ) state->m_global_volume--;
+ if ( m_global_volume > 0 ) m_global_volume--;
}
{
- ym2413_device *ym = space->machine().device<ym2413_device>("ymsnd");
- upd7759_device *upd = space->machine().device<upd7759_device>("upd");
- float percent = state->m_volume_override ? 1.0f : (32-state->m_global_volume)/32.0f;
+ ym2413_device *ym = machine().device<ym2413_device>("ymsnd");
+ upd7759_device *upd = machine().device<upd7759_device>("upd");
+ float percent = m_volume_override ? 1.0f : (32-m_global_volume)/32.0f;
ym->set_output_gain(0, percent);
ym->set_output_gain(1, percent);
@@ -752,56 +790,52 @@ static WRITE8_HANDLER( expansion_latch_w )
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( expansion_latch_r )
+READ8_MEMBER(bfm_sc2_state::expansion_latch_r)
{
return 0;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( muxena_w )
+WRITE8_MEMBER(bfm_sc2_state::muxena_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( timerirq_w )
+WRITE8_MEMBER(bfm_sc2_state::timerirq_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_is_timer_enabled = data & 1;
+ m_is_timer_enabled = data & 1;
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( timerirqclr_r )
+READ8_MEMBER(bfm_sc2_state::timerirqclr_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_irq_timer_stat = 0;
- state->m_irq_status = 0;
+ m_irq_timer_stat = 0;
+ m_irq_status = 0;
return 0;
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( irqstatus_r )
+READ8_MEMBER(bfm_sc2_state::irqstatus_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- int result = state->m_irq_status | state->m_irq_timer_stat | 0x80; // 0x80 = ~MUXERROR
+ int result = m_irq_status | m_irq_timer_stat | 0x80; // 0x80 = ~MUXERROR
- state->m_irq_timer_stat = 0;
+ m_irq_timer_stat = 0;
return result;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( coininhib_w )
+WRITE8_MEMBER(bfm_sc2_state::coininhib_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- int changed = state->m_coin_inhibits^data,i,p;
+ int changed = m_coin_inhibits^data,i,p;
- state->m_coin_inhibits = data;
+ m_coin_inhibits = data;
p = 0x01;
i = 0;
@@ -810,7 +844,7 @@ static WRITE8_HANDLER( coininhib_w )
{
if ( changed & p )
{ // this inhibit line has changed
- coin_lockout_w(space->machine(), i, (~data & p) ); // update lockouts
+ coin_lockout_w(machine(), i, (~data & p) ); // update lockouts
changed &= ~p;
}
@@ -821,29 +855,27 @@ static WRITE8_HANDLER( coininhib_w )
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( coin_input_r )
+READ8_MEMBER(bfm_sc2_state::coin_input_r)
{
- return input_port_read(space->machine(), "COINS");
+ return input_port_read(machine(), "COINS");
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( payout_latch_w )
+WRITE8_MEMBER(bfm_sc2_state::payout_latch_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_pay_latch = data;
+ m_pay_latch = data;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( payout_triac_w )
+WRITE8_MEMBER(bfm_sc2_state::payout_triac_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- if ( state->m_triac_select == 0x57 )
+ if ( m_triac_select == 0x57 )
{
int slide = 0;
- switch ( state->m_pay_latch )
+ switch ( m_pay_latch )
{
case 0x01: slide = 1;
break;
@@ -868,28 +900,28 @@ static WRITE8_HANDLER( payout_triac_w )
{
if ( data == 0x4D )
{
- if ( !state->m_slide_states[slide] )
+ if ( !m_slide_states[slide] )
{
- if ( state->m_slide_pay_sensor[slide] )
+ if ( m_slide_pay_sensor[slide] )
{
- int strobe = state->m_slide_pay_sensor[slide]>>4, data = state->m_slide_pay_sensor[slide]&0x0F;
+ int strobe = m_slide_pay_sensor[slide]>>4, data = m_slide_pay_sensor[slide]&0x0F;
- Scorpion2_SetSwitchState(space->machine(), strobe, data, 0);
+ Scorpion2_SetSwitchState(machine(), strobe, data, 0);
}
- state->m_slide_states[slide] = 1;
+ m_slide_states[slide] = 1;
}
}
else
{
- if ( state->m_slide_states[slide] )
+ if ( m_slide_states[slide] )
{
- if ( state->m_slide_pay_sensor[slide] )
+ if ( m_slide_pay_sensor[slide] )
{
- int strobe = state->m_slide_pay_sensor[slide]>>4, data = state->m_slide_pay_sensor[slide]&0x0F;
+ int strobe = m_slide_pay_sensor[slide]>>4, data = m_slide_pay_sensor[slide]&0x0F;
- Scorpion2_SetSwitchState(space->machine(), strobe, data, 1);
+ Scorpion2_SetSwitchState(machine(), strobe, data, 1);
}
- state->m_slide_states[slide] = 0;
+ m_slide_states[slide] = 0;
}
}
}
@@ -898,27 +930,25 @@ static WRITE8_HANDLER( payout_triac_w )
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( payout_select_w )
+WRITE8_MEMBER(bfm_sc2_state::payout_select_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_triac_select = data;
+ m_triac_select = data;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( vfd2_data_w )
+WRITE8_MEMBER(bfm_sc2_state::vfd2_data_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_vfd2_latch = data;
+ m_vfd2_latch = data;
BFM_BD1_newdata(1, data);
BFM_BD1_draw(1);
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( vfd_reset_w )
+WRITE8_MEMBER(bfm_sc2_state::vfd_reset_w)
{
BFM_BD1_reset(0); // reset both VFD's
BFM_BD1_reset(1);
@@ -930,95 +960,89 @@ static WRITE8_HANDLER( vfd_reset_w )
// serial port ////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( uart1stat_r )
+READ8_MEMBER(bfm_sc2_state::uart1stat_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
int status = 0x06;
- if ( state->m_data_to_uart1 ) status |= 0x01;
- if ( !state->m_data_to_uart2 ) status |= 0x02;
+ if ( m_data_to_uart1 ) status |= 0x01;
+ if ( !m_data_to_uart2 ) status |= 0x02;
return status;
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( uart1data_r )
+READ8_MEMBER(bfm_sc2_state::uart1data_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- return state->m_uart1_data;
+ return m_uart1_data;
}
//////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( uart1ctrl_w )
+WRITE8_MEMBER(bfm_sc2_state::uart1ctrl_w)
{
UART_LOG(("uart1ctrl:%x\n", data));
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( uart1data_w )
+WRITE8_MEMBER(bfm_sc2_state::uart1data_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_data_to_uart2 = 1;
- state->m_uart1_data = data;
+ m_data_to_uart2 = 1;
+ m_uart1_data = data;
UART_LOG(("uart1:%x\n", data));
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( uart2stat_r )
+READ8_MEMBER(bfm_sc2_state::uart2stat_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
int status = 0x06;
- if ( state->m_data_to_uart2 ) status |= 0x01;
- if ( !state->m_data_to_uart1 ) status |= 0x02;
+ if ( m_data_to_uart2 ) status |= 0x01;
+ if ( !m_data_to_uart1 ) status |= 0x02;
return status;
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( uart2data_r )
+READ8_MEMBER(bfm_sc2_state::uart2data_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- return state->m_uart2_data;
+ return m_uart2_data;
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( uart2ctrl_w )
+WRITE8_MEMBER(bfm_sc2_state::uart2ctrl_w)
{
UART_LOG(("uart2ctrl:%x\n", data));
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( uart2data_w )
+WRITE8_MEMBER(bfm_sc2_state::uart2data_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_data_to_uart1 = 1;
- state->m_uart2_data = data;
+ m_data_to_uart1 = 1;
+ m_uart2_data = data;
UART_LOG(("uart2:%x\n", data));
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( vid_uart_tx_w )
+WRITE8_MEMBER(bfm_sc2_state::vid_uart_tx_w)
{
adder2_send(data);
- cputag_set_input_line(space->machine(), "adder2", M6809_IRQ_LINE, HOLD_LINE );
+ cputag_set_input_line(machine(), "adder2", M6809_IRQ_LINE, HOLD_LINE );
LOG_SERIAL(("sadder %02X (%c)\n",data, data ));
}
///////////////////////////////////////////////////////////////////////////
-static WRITE8_HANDLER( vid_uart_ctrl_w )
+WRITE8_MEMBER(bfm_sc2_state::vid_uart_ctrl_w)
{
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( vid_uart_rx_r )
+READ8_MEMBER(bfm_sc2_state::vid_uart_rx_r)
{
int data = adder2_receive();
@@ -1029,21 +1053,20 @@ static READ8_HANDLER( vid_uart_rx_r )
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( vid_uart_ctrl_r )
+READ8_MEMBER(bfm_sc2_state::vid_uart_ctrl_r)
{
return adder2_status();
}
///////////////////////////////////////////////////////////////////////////
-static READ8_HANDLER( key_r )
+READ8_MEMBER(bfm_sc2_state::key_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- int result = state->m_key[ offset ];
+ int result = m_key[ offset ];
if ( offset == 7 )
{
- result = (result & 0xFE) | read_e2ram(space->machine());
+ result = (result & 0xFE) | read_e2ram(machine());
}
return result;
@@ -1079,29 +1102,29 @@ static void e2ram_reset(running_machine &machine)
state->m_e2data_to_read = 0;
}
-static int recdata(bfm_sc2_state *state, int changed, int data)
+int bfm_sc2_state::recdata(int changed, int data)
{
int res = 1;
- if ( state->m_e2cnt < 8 )
+ if ( m_e2cnt < 8 )
{
res = 0;
if ( (changed & SCL) && (data & SCL) )
{ // clocked in new data
- int pattern = 1 << (7-state->m_e2cnt);
+ int pattern = 1 << (7-m_e2cnt);
- if ( data & SDA ) state->m_e2data |= pattern;
- else state->m_e2data &= ~pattern;
+ if ( data & SDA ) m_e2data |= pattern;
+ else m_e2data &= ~pattern;
- state->m_e2data_pin = state->m_e2data_to_read & 0x80 ? 1 : 0;
+ m_e2data_pin = m_e2data_to_read & 0x80 ? 1 : 0;
- state->m_e2data_to_read <<= 1;
+ m_e2data_to_read <<= 1;
- LOG(("e2d pin= %d\n", state->m_e2data_pin));
+ LOG(("e2d pin= %d\n", m_e2data_pin));
- state->m_e2cnt++;
- if ( state->m_e2cnt >= 8 )
+ m_e2cnt++;
+ if ( m_e2cnt >= 8 )
{
res++;
}
@@ -1133,31 +1156,29 @@ static int recAck(int changed, int data)
/* VFD Status */
-static READ8_HANDLER( vfd_status_r )
+READ8_MEMBER(bfm_sc2_state::vfd_status_r)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
/* b7 = NEC busy */
/* b6 = alpha busy (also matrix board) */
/* b5 - b0 = reel optics */
- int result = state->m_optic_pattern;
+ int result = m_optic_pattern;
- if ( !upd7759_busy_r(space->machine().device("upd")) ) result |= 0x80;
+ if ( !upd7759_busy_r(machine().device("upd")) ) result |= 0x80;
- if (space->machine().device("matrix"))
+ if (machine().device("matrix"))
if ( BFM_dm01_busy() ) result |= 0x40;
return result;
}
-static WRITE8_HANDLER( vfd1_data_w )
+WRITE8_MEMBER(bfm_sc2_state::vfd1_data_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>();
- state->m_vfd1_latch = data;
+ m_vfd1_latch = data;
- if (space->machine().device("matrix"))
+ if (machine().device("matrix"))
{
- BFM_dm01_writedata(space->machine(),data);
+ BFM_dm01_writedata(machine(),data);
}
else
{
@@ -1168,17 +1189,16 @@ static WRITE8_HANDLER( vfd1_data_w )
//
-static WRITE8_HANDLER( e2ram_w )
+WRITE8_MEMBER(bfm_sc2_state::e2ram_w)
{
- bfm_sc2_state *state = space->machine().driver_data<bfm_sc2_state>(); // b0 = clock b1 = data
int changed, ack;
data ^= (SDA|SCL); // invert signals
- changed = (state->m_e2reg^data) & 0x03;
+ changed = (m_e2reg^data) & 0x03;
- state->m_e2reg = data;
+ m_e2reg = data;
if ( changed )
{
@@ -1188,13 +1208,13 @@ static WRITE8_HANDLER( e2ram_w )
( !(changed & SCL) && (data & SCL) ) // SCL=1 and not changed
)
{ // X24C08 Start condition (1->0 on SDA while SCL=1)
- state->m_e2dummywrite = ( state->m_e2state == 5 );
+ m_e2dummywrite = ( m_e2state == 5 );
- LOG(("e2ram: c:%d d:%d Start condition dummywrite=%d\n", (data & SCL)?1:0, (data&SDA)?1:0, state->m_e2dummywrite ));
+ LOG(("e2ram: c:%d d:%d Start condition dummywrite=%d\n", (data & SCL)?1:0, (data&SDA)?1:0, m_e2dummywrite ));
- state->m_e2state = 1; // ready for commands
- state->m_e2cnt = 0;
- state->m_e2data = 0;
+ m_e2state = 1; // ready for commands
+ m_e2cnt = 0;
+ m_e2data = 0;
break;
}
@@ -1203,25 +1223,25 @@ static WRITE8_HANDLER( e2ram_w )
)
{ // X24C08 Stop condition (0->1 on SDA while SCL=1)
LOG(("e2ram: c:%d d:%d Stop condition\n", (data & SCL)?1:0, (data&SDA)?1:0 ));
- state->m_e2state = 0;
- state->m_e2data = 0;
+ m_e2state = 0;
+ m_e2data = 0;
break;
}
- switch ( state->m_e2state )
+ switch ( m_e2state )
{
case 1: // Receiving address + R/W bit
- if ( recdata(state, changed, data) )
+ if ( recdata(changed, data) )
{
- state->m_e2address = (state->m_e2address & 0x00FF) | ((state->m_e2data>>1) & 0x03) << 8;
- state->m_e2cnt = 0;
- state->m_e2rw = state->m_e2data & 1;
+ m_e2address = (m_e2address & 0x00FF) | ((m_e2data>>1) & 0x03) << 8;
+ m_e2cnt = 0;
+ m_e2rw = m_e2data & 1;
LOG(("e2ram: Slave address received !! device id=%01X device adr=%01d high order adr %0X RW=%d) %02X\n",
- state->m_e2data>>4, (state->m_e2data & 0x08)?1:0, (state->m_e2data>>1) & 0x03, state->m_e2rw , state->m_e2data ));
+ m_e2data>>4, (m_e2data & 0x08)?1:0, (m_e2data>>1) & 0x03, m_e2rw , m_e2data ));
- state->m_e2state = 2;
+ m_e2state = 2;
}
break;
@@ -1230,59 +1250,59 @@ static WRITE8_HANDLER( e2ram_w )
ack = recAck(changed,data);
if ( ack )
{
- state->m_e2data_pin = 0;
+ m_e2data_pin = 0;
if ( ack < 0 )
{
LOG(("ACK = 0\n"));
- state->m_e2state = 0;
+ m_e2state = 0;
}
else
{
LOG(("ACK = 1\n"));
- if ( state->m_e2dummywrite )
+ if ( m_e2dummywrite )
{
- state->m_e2dummywrite = 0;
+ m_e2dummywrite = 0;
- state->m_e2data_to_read = state->m_e2ram[state->m_e2address];
+ m_e2data_to_read = m_e2ram[m_e2address];
- if ( state->m_e2rw & 1 ) state->m_e2state = 7; // read data
- else state->m_e2state = 0; //?not sure
+ if ( m_e2rw & 1 ) m_e2state = 7; // read data
+ else m_e2state = 0; //?not sure
}
else
{
- if ( state->m_e2rw & 1 ) state->m_e2state = 7; // reading
- else state->m_e2state = 3; // writing
+ if ( m_e2rw & 1 ) m_e2state = 7; // reading
+ else m_e2state = 3; // writing
}
- switch ( state->m_e2state )
+ switch ( m_e2state )
{
case 7:
- LOG(("read address %04X\n",state->m_e2address));
- state->m_e2data_to_read = state->m_e2ram[state->m_e2address];
+ LOG(("read address %04X\n",m_e2address));
+ m_e2data_to_read = m_e2ram[m_e2address];
break;
case 3:
LOG(("write, awaiting address\n"));
break;
default:
- LOG(("?unknow action %04X\n",state->m_e2address));
+ LOG(("?unknow action %04X\n",m_e2address));
break;
}
}
- state->m_e2data = 0;
+ m_e2data = 0;
}
break;
case 3: // writing data, receiving address
- if ( recdata(state, changed, data) )
+ if ( recdata(changed, data) )
{
- state->m_e2data_pin = 0;
- state->m_e2address = (state->m_e2address & 0xFF00) | state->m_e2data;
+ m_e2data_pin = 0;
+ m_e2address = (m_e2address & 0xFF00) | m_e2data;
- LOG(("write address = %04X waiting for ACK\n", state->m_e2address));
- state->m_e2state = 4;
- state->m_e2cnt = 0;
- state->m_e2data = 0;
+ LOG(("write address = %04X waiting for ACK\n", m_e2address));
+ m_e2state = 4;
+ m_e2cnt = 0;
+ m_e2data = 0;
}
break;
@@ -1291,27 +1311,27 @@ static WRITE8_HANDLER( e2ram_w )
ack = recAck(changed,data);
if ( ack )
{
- state->m_e2data_pin = 0; // pin=0, no error !!
+ m_e2data_pin = 0; // pin=0, no error !!
if ( ack < 0 )
{
- state->m_e2state = 0;
+ m_e2state = 0;
LOG(("ACK = 0, cancel write\n" ));
}
else
{
- state->m_e2state = 5;
+ m_e2state = 5;
LOG(("ACK = 1, awaiting data to write\n" ));
}
}
break;
case 5: // receive data to write
- if ( recdata(state, changed, data) )
+ if ( recdata(changed, data) )
{
- LOG(("write data = %02X received, awaiting ACK\n", state->m_e2data));
- state->m_e2cnt = 0;
- state->m_e2state = 6; // wait ack
+ LOG(("write data = %02X received, awaiting ACK\n", m_e2data));
+ m_e2cnt = 0;
+ m_e2state = 6; // wait ack
}
break;
@@ -1322,31 +1342,31 @@ static WRITE8_HANDLER( e2ram_w )
{
if ( ack < 0 )
{
- state->m_e2state = 0;
+ m_e2state = 0;
LOG(("ACK=0, write canceled\n"));
}
else
{
- LOG(("ACK=1, writing %02X to %04X\n", state->m_e2data, state->m_e2address));
+ LOG(("ACK=1, writing %02X to %04X\n", m_e2data, m_e2address));
- state->m_e2ram[state->m_e2address] = state->m_e2data;
+ m_e2ram[m_e2address] = m_e2data;
- state->m_e2address = (state->m_e2address & ~0x000F) | ((state->m_e2address+1)&0x0F);
+ m_e2address = (m_e2address & ~0x000F) | ((m_e2address+1)&0x0F);
- state->m_e2state = 5; // write next address
+ m_e2state = 5; // write next address
}
}
break;
case 7: // receive address from read
- if ( recdata(state, changed, data) )
+ if ( recdata(changed, data) )
{
- //state->m_e2data_pin = 0;
+ //m_e2data_pin = 0;
- LOG(("address read, data = %02X waiting for ACK\n", state->m_e2data ));
+ LOG(("address read, data = %02X waiting for ACK\n", m_e2data ));
- state->m_e2state = 8;
+ m_e2state = 8;
}
break;
@@ -1354,16 +1374,16 @@ static WRITE8_HANDLER( e2ram_w )
if ( recAck(changed, data) )
{
- state->m_e2state = 7;
+ m_e2state = 7;
- state->m_e2address = (state->m_e2address & ~0x0F) | ((state->m_e2address+1)&0x0F); // lower 4 bits wrap around
+ m_e2address = (m_e2address & ~0x0F) | ((m_e2address+1)&0x0F); // lower 4 bits wrap around
- state->m_e2data_to_read = state->m_e2ram[state->m_e2address];
+ m_e2data_to_read = m_e2ram[m_e2address];
- LOG(("ready for next address %04X\n", state->m_e2address));
+ LOG(("ready for next address %04X\n", m_e2address));
- state->m_e2cnt = 0;
- state->m_e2data = 0;
+ m_e2cnt = 0;
+ m_e2data = 0;
}
break;
@@ -1413,7 +1433,7 @@ static SCREEN_UPDATE_IND16( addersc2 )
}
-static READ8_HANDLER( direct_input_r )
+READ8_MEMBER(bfm_sc2_state::direct_input_r)
{
return 0;
}
@@ -1423,49 +1443,49 @@ static READ8_HANDLER( direct_input_r )
static ADDRESS_MAP_START( sc2_basemap, AS_PROGRAM, 8, bfm_sc2_state )
AM_RANGE(0x0000, 0x1fff) AM_RAM AM_SHARE("nvram") //8k
- AM_RANGE(0x2000, 0x2000) AM_READ_LEGACY(vfd_status_r)
- AM_RANGE(0x2000, 0x20FF) AM_WRITE_LEGACY(reel12_w)
- AM_RANGE(0x2100, 0x21FF) AM_WRITE_LEGACY(reel34_w)
- AM_RANGE(0x2200, 0x22FF) AM_WRITE_LEGACY(reel56_w)
-
- AM_RANGE(0x2300, 0x230B) AM_READ_LEGACY(mux_input_r)
- AM_RANGE(0x2300, 0x231F) AM_WRITE_LEGACY(mux_output_w)
- AM_RANGE(0x2320, 0x2323) AM_WRITE_LEGACY(dimas_w) /* ?unknown dim related */
-
- AM_RANGE(0x2324, 0x2324) AM_READWRITE_LEGACY(expansion_latch_r, expansion_latch_w)
- AM_RANGE(0x2325, 0x2327) AM_WRITE_LEGACY(unknown_w)
- AM_RANGE(0x2328, 0x2328) AM_WRITE_LEGACY(muxena_w)
- AM_RANGE(0x2329, 0x2329) AM_READWRITE_LEGACY(timerirqclr_r, timerirq_w)
- AM_RANGE(0x232A, 0x232D) AM_WRITE_LEGACY(unknown_w)
- AM_RANGE(0x232E, 0x232E) AM_READ_LEGACY(irqstatus_r)
-
- AM_RANGE(0x232F, 0x232F) AM_WRITE_LEGACY(coininhib_w)
- AM_RANGE(0x2330, 0x2330) AM_WRITE_LEGACY(payout_latch_w)
- AM_RANGE(0x2331, 0x2331) AM_WRITE_LEGACY(payout_triac_w)
+ AM_RANGE(0x2000, 0x2000) AM_READ(vfd_status_r)
+ AM_RANGE(0x2000, 0x20FF) AM_WRITE(reel12_w)
+ AM_RANGE(0x2100, 0x21FF) AM_WRITE(reel34_w)
+ AM_RANGE(0x2200, 0x22FF) AM_WRITE(reel56_w)
+
+ AM_RANGE(0x2300, 0x230B) AM_READ(mux_input_r)
+ AM_RANGE(0x2300, 0x231F) AM_WRITE(mux_output_w)
+ AM_RANGE(0x2320, 0x2323) AM_WRITE(dimas_w) /* ?unknown dim related */
+
+ AM_RANGE(0x2324, 0x2324) AM_READWRITE(expansion_latch_r, expansion_latch_w)
+ AM_RANGE(0x2325, 0x2327) AM_WRITE(unknown_w)
+ AM_RANGE(0x2328, 0x2328) AM_WRITE(muxena_w)
+ AM_RANGE(0x2329, 0x2329) AM_READWRITE(timerirqclr_r, timerirq_w)
+ AM_RANGE(0x232A, 0x232D) AM_WRITE(unknown_w)
+ AM_RANGE(0x232E, 0x232E) AM_READ(irqstatus_r)
+
+ AM_RANGE(0x232F, 0x232F) AM_WRITE(coininhib_w)
+ AM_RANGE(0x2330, 0x2330) AM_WRITE(payout_latch_w)
+ AM_RANGE(0x2331, 0x2331) AM_WRITE(payout_triac_w)
AM_RANGE(0x2332, 0x2332) AM_WRITE_LEGACY(watchdog_reset_w)
- AM_RANGE(0x2333, 0x2333) AM_WRITE_LEGACY(mmtr_w)
- AM_RANGE(0x2334, 0x2335) AM_WRITE_LEGACY(unknown_w)
- AM_RANGE(0x2336, 0x2336) AM_WRITE_LEGACY(dimcnt_w)
- AM_RANGE(0x2337, 0x2337) AM_WRITE_LEGACY(volume_override_w)
- AM_RANGE(0x2338, 0x2338) AM_WRITE_LEGACY(payout_select_w)
- AM_RANGE(0x2339, 0x2339) AM_WRITE_LEGACY(unknown_w)
- AM_RANGE(0x2400, 0x2400) AM_READWRITE_LEGACY(uart1stat_r, uart1ctrl_w) /* mc6850 compatible uart */
- AM_RANGE(0x2500, 0x2500) AM_READWRITE_LEGACY(uart1data_r, uart1data_w)
- AM_RANGE(0x2600, 0x2600) AM_READWRITE_LEGACY(uart2stat_r, uart2ctrl_w) /* mc6850 compatible uart */
- AM_RANGE(0x2700, 0x2700) AM_READWRITE_LEGACY(uart2data_r, uart2data_w)
- AM_RANGE(0x2800, 0x2800) AM_WRITE_LEGACY(vfd1_data_w) /* vfd1 data */
- AM_RANGE(0x2900, 0x2900) AM_WRITE_LEGACY(vfd_reset_w) /* vfd1+vfd2 reset line */
+ AM_RANGE(0x2333, 0x2333) AM_WRITE(mmtr_w)
+ AM_RANGE(0x2334, 0x2335) AM_WRITE(unknown_w)
+ AM_RANGE(0x2336, 0x2336) AM_WRITE(dimcnt_w)
+ AM_RANGE(0x2337, 0x2337) AM_WRITE(volume_override_w)
+ AM_RANGE(0x2338, 0x2338) AM_WRITE(payout_select_w)
+ AM_RANGE(0x2339, 0x2339) AM_WRITE(unknown_w)
+ AM_RANGE(0x2400, 0x2400) AM_READWRITE(uart1stat_r, uart1ctrl_w) /* mc6850 compatible uart */
+ AM_RANGE(0x2500, 0x2500) AM_READWRITE(uart1data_r, uart1data_w)
+ AM_RANGE(0x2600, 0x2600) AM_READWRITE(uart2stat_r, uart2ctrl_w) /* mc6850 compatible uart */
+ AM_RANGE(0x2700, 0x2700) AM_READWRITE(uart2data_r, uart2data_w)
+ AM_RANGE(0x2800, 0x2800) AM_WRITE(vfd1_data_w) /* vfd1 data */
+ AM_RANGE(0x2900, 0x2900) AM_WRITE(vfd_reset_w) /* vfd1+vfd2 reset line */
AM_RANGE(0x2A00, 0x2AFF) AM_DEVWRITE_LEGACY("upd", nec_latch_w)
AM_RANGE(0x2B00, 0x2BFF) AM_DEVWRITE_LEGACY("upd", nec_reset_w)
- AM_RANGE(0x2C00, 0x2C00) AM_WRITE_LEGACY(unlock_w) /* custom chip unlock */
+ AM_RANGE(0x2C00, 0x2C00) AM_WRITE(unlock_w) /* custom chip unlock */
AM_RANGE(0x2D00, 0x2D01) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w)
- AM_RANGE(0x2E00, 0x2E00) AM_WRITE_LEGACY(bankswitch_w) /* write bank (rom page select for 0x6000 - 0x7fff ) */
- AM_RANGE(0x2F00, 0x2F00) AM_WRITE_LEGACY(vfd2_data_w) /* vfd2 data */
+ AM_RANGE(0x2E00, 0x2E00) AM_WRITE(bankswitch_w) /* write bank (rom page select for 0x6000 - 0x7fff ) */
+ AM_RANGE(0x2F00, 0x2F00) AM_WRITE(vfd2_data_w) /* vfd2 data */
- AM_RANGE(0x3FFE, 0x3FFE) AM_READ_LEGACY(direct_input_r )
- AM_RANGE(0x3FFF, 0x3FFF) AM_READ_LEGACY(coin_input_r)
+ AM_RANGE(0x3FFE, 0x3FFE) AM_READ(direct_input_r )
+ AM_RANGE(0x3FFF, 0x3FFF) AM_READ(coin_input_r)
AM_RANGE(0x4000, 0x5FFF) AM_ROM
- AM_RANGE(0x4000, 0xFFFF) AM_WRITE_LEGACY(unknown_w) // contains unknown I/O registers
+ AM_RANGE(0x4000, 0xFFFF) AM_WRITE(unknown_w) // contains unknown I/O registers
AM_RANGE(0x6000, 0x7FFF) AM_ROMBANK("bank1")
AM_RANGE(0x8000, 0xFFFF) AM_ROM
ADDRESS_MAP_END
@@ -1475,16 +1495,16 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( memmap_vid, AS_PROGRAM, 8, bfm_sc2_state )
AM_IMPORT_FROM( sc2_basemap )
- AM_RANGE(0x2000, 0x2000) AM_READ_LEGACY(vfd_status_hop_r) // vfd status register
- AM_RANGE(0x2000, 0x20FF) AM_WRITE_LEGACY(reel12_vid_w)
+ AM_RANGE(0x2000, 0x2000) AM_READ(vfd_status_hop_r) // vfd status register
+ AM_RANGE(0x2000, 0x20FF) AM_WRITE(reel12_vid_w)
AM_RANGE(0x2100, 0x21FF) AM_WRITENOP
AM_RANGE(0x2200, 0x22FF) AM_WRITENOP
- AM_RANGE(0x3C00, 0x3C07) AM_READ_LEGACY(key_r )
- AM_RANGE(0x3C80, 0x3C80) AM_WRITE_LEGACY(e2ram_w )
+ AM_RANGE(0x3C00, 0x3C07) AM_READ(key_r )
+ AM_RANGE(0x3C80, 0x3C80) AM_WRITE(e2ram_w )
- AM_RANGE(0x3E00, 0x3E00) AM_READWRITE_LEGACY(vid_uart_ctrl_r, vid_uart_ctrl_w) // video uart control reg
- AM_RANGE(0x3E01, 0x3E01) AM_READWRITE_LEGACY(vid_uart_rx_r, vid_uart_tx_w) // video uart data reg
+ AM_RANGE(0x3E00, 0x3E00) AM_READWRITE(vid_uart_ctrl_r, vid_uart_ctrl_w) // video uart control reg
+ AM_RANGE(0x3E01, 0x3E01) AM_READWRITE(vid_uart_rx_r, vid_uart_tx_w) // video uart data reg
ADDRESS_MAP_END
// input ports for pyramid ////////////////////////////////////////
@@ -2546,7 +2566,7 @@ ROM_END
#ifdef UNUSED_FUNCTION
/* Scorpion 3 expansion */
-static READ8_HANDLER( sc3_expansion_r )
+READ8_MEMBER(bfm_sc2_state::sc3_expansion_r)
{
int result = 0;
@@ -2561,7 +2581,7 @@ static READ8_HANDLER( sc3_expansion_r )
}
-static WRITE8_HANDLER( sc3_expansion_w )
+WRITE8_MEMBER(bfm_sc2_state::sc3_expansion_w)
{
switch ( offset )
{
diff --git a/src/mame/drivers/bfm_sc4.c b/src/mame/drivers/bfm_sc4.c
index 492970b99a9..abfecdbb7ba 100644
--- a/src/mame/drivers/bfm_sc4.c
+++ b/src/mame/drivers/bfm_sc4.c
@@ -65,6 +65,8 @@ public:
UINT16* m_mainram;
// devices
required_device<cpu_device> m_maincpu;
+ DECLARE_READ16_MEMBER(sc4_mem_r);
+ DECLARE_WRITE16_MEMBER(sc4_mem_w);
};
class sc4_adder4_state : public sc4_state
@@ -79,19 +81,18 @@ public:
required_device<cpu_device> m_adder4cpu;
};
-static READ16_HANDLER( sc4_mem_r )
+READ16_MEMBER(sc4_state::sc4_mem_r)
{
- sc4_state *state = space->machine().driver_data<sc4_state>();
- int pc = cpu_get_pc(&space->device());
- int cs = m68307_get_cs(state->m_maincpu, offset * 2);
+ int pc = cpu_get_pc(&space.device());
+ int cs = m68307_get_cs(m_maincpu, offset * 2);
int base = 0, end = 0;
-// if (!(space->debugger_access())) printf("cs is %d\n", cs);
+// if (!(debugger_access())) printf("cs is %d\n", cs);
switch ( cs )
{
case 1:
if (offset<0x100000/2)
- return state->m_cpuregion[offset];
+ return m_cpuregion[offset];
else
logerror("%08x maincpu read access offset %08x mem_mask %04x cs %d\n", pc, offset*2, mem_mask, cs);
break;
@@ -103,7 +104,7 @@ static READ16_HANDLER( sc4_mem_r )
if ((offset>=base) && (offset<end))
{
offset-=base;
- return(state->m_mainram[offset]);
+ return(m_mainram[offset]);
}
else
{
@@ -129,11 +130,10 @@ static READ16_HANDLER( sc4_mem_r )
return 0x0000;
}
-static WRITE16_HANDLER( sc4_mem_w )
+WRITE16_MEMBER(sc4_state::sc4_mem_w)
{
- sc4_state *state = space->machine().driver_data<sc4_state>();
- int pc = cpu_get_pc(&space->device());
- int cs = m68307_get_cs(state->m_maincpu, offset * 2);
+ int pc = cpu_get_pc(&space.device());
+ int cs = m68307_get_cs(m_maincpu, offset * 2);
int base = 0, end = 0;
switch ( cs )
@@ -153,7 +153,7 @@ static WRITE16_HANDLER( sc4_mem_w )
if ((offset>=base) && (offset<end))
{
offset-=base;
- COMBINE_DATA(&state->m_mainram[offset]);
+ COMBINE_DATA(&m_mainram[offset]);
}
else
{
@@ -174,8 +174,8 @@ static WRITE16_HANDLER( sc4_mem_w )
}
}
-static ADDRESS_MAP_START( sc4_map, AS_PROGRAM, 16, sc4_adder4_state )
- AM_RANGE(0x000000000, 0xffffffff) AM_READWRITE_LEGACY(sc4_mem_r, sc4_mem_w)
+static ADDRESS_MAP_START( sc4_map, AS_PROGRAM, 16, sc4_state )
+ AM_RANGE(0x000000000, 0xffffffff) AM_READWRITE(sc4_mem_r, sc4_mem_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( sc4_adder4_map, AS_PROGRAM, 32, sc4_adder4_state )
diff --git a/src/mame/drivers/blitz68k.c b/src/mame/drivers/blitz68k.c
index fdbda1818a8..260237abcfa 100644
--- a/src/mame/drivers/blitz68k.c
+++ b/src/mame/drivers/blitz68k.c
@@ -56,6 +56,82 @@ public:
UINT16 *m_blit_vregs;
UINT16 *m_blit_transpen;
UINT16 *m_leds[3];
+ DECLARE_WRITE16_MEMBER(blit_copy_w);
+ DECLARE_READ8_MEMBER(blit_status_r);
+ DECLARE_WRITE8_MEMBER(blit_x_w);
+ DECLARE_WRITE8_MEMBER(blit_y_w);
+ DECLARE_WRITE8_MEMBER(blit_xy_w);
+ DECLARE_WRITE8_MEMBER(blit_w_w);
+ DECLARE_WRITE8_MEMBER(blit_h_w);
+ DECLARE_WRITE8_MEMBER(blit_wh_w);
+ DECLARE_WRITE8_MEMBER(blit_addr0_w);
+ DECLARE_WRITE8_MEMBER(blit_addr1_w);
+ DECLARE_WRITE8_MEMBER(blit_addr01_w);
+ DECLARE_WRITE8_MEMBER(blit_addr2_w);
+ DECLARE_WRITE8_MEMBER(blit_pens_w);
+ DECLARE_WRITE8_MEMBER(blit_pen0_w);
+ DECLARE_WRITE8_MEMBER(blit_pen1_w);
+ DECLARE_WRITE8_MEMBER(blit_pen2_w);
+ DECLARE_WRITE8_MEMBER(blit_pen3_w);
+ DECLARE_WRITE8_MEMBER(blit_flag0_w);
+ DECLARE_WRITE8_MEMBER(blit_flag1_w);
+ DECLARE_WRITE8_MEMBER(blit_flipx_w);
+ DECLARE_WRITE8_MEMBER(blit_flipy_w);
+ DECLARE_WRITE8_MEMBER(blit_solid_w);
+ DECLARE_WRITE8_MEMBER(blit_trans_w);
+ DECLARE_WRITE8_MEMBER(blit_flag6_w);
+ DECLARE_WRITE8_MEMBER(blit_flag7_w);
+ DECLARE_WRITE8_MEMBER(blit_flags_w);
+ DECLARE_WRITE8_MEMBER(blit_draw_w);
+ DECLARE_WRITE8_MEMBER(blit_hwyxa_draw_w);
+ DECLARE_READ16_MEMBER(blitter_status_r);
+ DECLARE_WRITE16_MEMBER(lamps_w);
+ DECLARE_READ16_MEMBER(test_r);
+ DECLARE_WRITE16_MEMBER(irq_callback_w);
+ DECLARE_WRITE16_MEMBER(sound_write_w);
+ DECLARE_READ8_MEMBER(bankrob_mcu1_r);
+ DECLARE_READ8_MEMBER(bankrob_mcu2_r);
+ DECLARE_READ8_MEMBER(bankrob_mcu_status_read_r);
+ DECLARE_READ8_MEMBER(bankrob_mcu_status_write_r);
+ DECLARE_WRITE8_MEMBER(bankrob_mcu1_w);
+ DECLARE_WRITE8_MEMBER(bankrob_mcu2_w);
+ DECLARE_READ8_MEMBER(bankroba_mcu1_r);
+ DECLARE_READ8_MEMBER(bankroba_mcu2_r);
+ DECLARE_READ8_MEMBER(bankroba_mcu1_status_write_r);
+ DECLARE_READ8_MEMBER(bankroba_mcu2_status_write_r);
+ DECLARE_WRITE8_MEMBER(bankroba_mcu1_w);
+ DECLARE_WRITE8_MEMBER(bankroba_mcu2_w);
+ DECLARE_WRITE16_MEMBER(cjffruit_leds1_w);
+ DECLARE_WRITE16_MEMBER(cjffruit_leds2_w);
+ DECLARE_WRITE16_MEMBER(cjffruit_leds3_w);
+ DECLARE_READ8_MEMBER(crtc_r);
+ DECLARE_WRITE8_MEMBER(crtc_w);
+ DECLARE_READ16_MEMBER(cjffruit_mcu_r);
+ DECLARE_WRITE16_MEMBER(cjffruit_mcu_w);
+ DECLARE_READ16_MEMBER(deucesw2_mcu_r);
+ DECLARE_WRITE16_MEMBER(deucesw2_mcu_w);
+ DECLARE_WRITE16_MEMBER(deucesw2_leds1_w);
+ DECLARE_WRITE16_MEMBER(deucesw2_leds2_w);
+ DECLARE_WRITE16_MEMBER(deucesw2_leds3_w);
+ DECLARE_READ8_MEMBER(dualgame_mcu1_r);
+ DECLARE_READ8_MEMBER(dualgame_mcu2_r);
+ DECLARE_READ8_MEMBER(dualgame_mcu_status_read_r);
+ DECLARE_READ8_MEMBER(dualgame_mcu_status_write_r);
+ DECLARE_WRITE8_MEMBER(dualgame_mcu1_w);
+ DECLARE_WRITE8_MEMBER(dualgame_mcu2_w);
+ DECLARE_READ16_MEMBER(hermit_mcu_r);
+ DECLARE_WRITE16_MEMBER(hermit_mcu_w);
+ DECLARE_WRITE16_MEMBER(hermit_leds1_w);
+ DECLARE_WRITE16_MEMBER(hermit_leds2_w);
+ DECLARE_READ16_MEMBER(hermit_track_r);
+ DECLARE_READ8_MEMBER(maxidbl_mcu1_r);
+ DECLARE_READ8_MEMBER(maxidbl_mcu2_r);
+ DECLARE_READ8_MEMBER(maxidbl_mcu_status_read_r);
+ DECLARE_READ8_MEMBER(maxidbl_mcu_status_write_r);
+ DECLARE_WRITE8_MEMBER(maxidbl_mcu1_w);
+ DECLARE_WRITE8_MEMBER(maxidbl_mcu2_w);
+ void show_leds123();
+ void show_leds12();
};
/*************************************************************************************************************
@@ -151,25 +227,24 @@ static SCREEN_UPDATE_RGB32(blitz68k_noblit)
*************************************************************************************************************/
-static WRITE16_HANDLER( blit_copy_w )
+WRITE16_MEMBER(blitz68k_state::blit_copy_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- UINT8 *blit_rom = space->machine().region("blitter")->base();
+ UINT8 *blit_rom = machine().region("blitter")->base();
UINT32 blit_dst_xpos;
UINT32 blit_dst_ypos;
int x,y,x_size,y_size;
UINT32 src;
- logerror("blit copy %04x %04x %04x %04x %04x\n", state->m_blit_romaddr[0], state->m_blit_attr1_ram[0], state->m_blit_dst_ram_loword[0], state->m_blit_attr2_ram[0], state->m_blit_dst_ram_hiword[0] );
- logerror("blit vregs %04x %04x %04x %04x\n",state->m_blit_vregs[0/2],state->m_blit_vregs[2/2],state->m_blit_vregs[4/2],state->m_blit_vregs[6/2]);
- logerror("blit transpen %04x %04x %04x %04x %04x %04x %04x %04x\n",state->m_blit_transpen[0/2],state->m_blit_transpen[2/2],state->m_blit_transpen[4/2],state->m_blit_transpen[6/2],
- state->m_blit_transpen[8/2],state->m_blit_transpen[10/2],state->m_blit_transpen[12/2],state->m_blit_transpen[14/2]);
+ logerror("blit copy %04x %04x %04x %04x %04x\n", m_blit_romaddr[0], m_blit_attr1_ram[0], m_blit_dst_ram_loword[0], m_blit_attr2_ram[0], m_blit_dst_ram_hiword[0] );
+ logerror("blit vregs %04x %04x %04x %04x\n",m_blit_vregs[0/2],m_blit_vregs[2/2],m_blit_vregs[4/2],m_blit_vregs[6/2]);
+ logerror("blit transpen %04x %04x %04x %04x %04x %04x %04x %04x\n",m_blit_transpen[0/2],m_blit_transpen[2/2],m_blit_transpen[4/2],m_blit_transpen[6/2],
+ m_blit_transpen[8/2],m_blit_transpen[10/2],m_blit_transpen[12/2],m_blit_transpen[14/2]);
- blit_dst_xpos = (state->m_blit_dst_ram_loword[0] & 0x00ff)*2;
- blit_dst_ypos = ((state->m_blit_dst_ram_loword[0] & 0xff00)>>8);
+ blit_dst_xpos = (m_blit_dst_ram_loword[0] & 0x00ff)*2;
+ blit_dst_ypos = ((m_blit_dst_ram_loword[0] & 0xff00)>>8);
- y_size = (0x100-((state->m_blit_attr2_ram[0] & 0xff00)>>8));
- x_size = (state->m_blit_attr2_ram[0] & 0x00ff)*2;
+ y_size = (0x100-((m_blit_attr2_ram[0] & 0xff00)>>8));
+ x_size = (m_blit_attr2_ram[0] & 0x00ff)*2;
/* rounding around for 0 size */
if(x_size == 0) { x_size = 0x200; }
@@ -177,8 +252,8 @@ static WRITE16_HANDLER( blit_copy_w )
/* TODO: used by steaser "Game Over" msg on attract mode*/
// if(y_size == 1) { y_size = 32; }
- src = state->m_blit_romaddr[0] | (state->m_blit_attr1_ram[0] & 0x1f00)<<8;
-// src|= (state->m_blit_transpen[0xc/2] & 0x0100)<<12;
+ src = m_blit_romaddr[0] | (m_blit_attr1_ram[0] & 0x1f00)<<8;
+// src|= (m_blit_transpen[0xc/2] & 0x0100)<<12;
for(y=0;y<y_size;y++)
{
@@ -186,20 +261,20 @@ static WRITE16_HANDLER( blit_copy_w )
{
int drawx = (blit_dst_xpos+x)&0x1ff;
int drawy = (blit_dst_ypos+y)&0x0ff;
- if(state->m_blit_transpen[0x8/2] & 0x100)
- state->m_blit_buffer[drawy*512+drawx] = ((state->m_blit_vregs[0] & 0xf00)>>8);
+ if(m_blit_transpen[0x8/2] & 0x100)
+ m_blit_buffer[drawy*512+drawx] = ((m_blit_vregs[0] & 0xf00)>>8);
else
{
UINT8 pen_helper;
pen_helper = blit_rom[src] & 0xff;
- if(state->m_blit_transpen[0xa/2] & 0x100) //pen is opaque register
+ if(m_blit_transpen[0xa/2] & 0x100) //pen is opaque register
{
if(pen_helper)
- state->m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((state->m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
+ m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
}
else
- state->m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((state->m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
+ m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
}
src++;
@@ -214,20 +289,20 @@ static WRITE16_HANDLER( blit_copy_w )
*************************************************************************************************************/
-static READ8_HANDLER( blit_status_r )
+READ8_MEMBER(blitz68k_state::blit_status_r)
{
return 0; // bit 0 = blitter busy
}
-static WRITE8_HANDLER( blit_x_w )
+WRITE8_MEMBER(blitz68k_state::blit_x_w)
{
blit.x = data;
}
-static WRITE8_HANDLER( blit_y_w )
+WRITE8_MEMBER(blitz68k_state::blit_y_w)
{
blit.y = data;
}
-static WRITE8_HANDLER( blit_xy_w )
+WRITE8_MEMBER(blitz68k_state::blit_xy_w)
{
if (offset)
blit_x_w(space, offset, data);
@@ -236,15 +311,15 @@ static WRITE8_HANDLER( blit_xy_w )
}
-static WRITE8_HANDLER( blit_w_w )
+WRITE8_MEMBER(blitz68k_state::blit_w_w)
{
blit.w = data;
}
-static WRITE8_HANDLER( blit_h_w )
+WRITE8_MEMBER(blitz68k_state::blit_h_w)
{
blit.h = data;
}
-static WRITE8_HANDLER( blit_wh_w )
+WRITE8_MEMBER(blitz68k_state::blit_wh_w)
{
if (offset)
blit_w_w(space, offset, data-1);
@@ -253,83 +328,83 @@ static WRITE8_HANDLER( blit_wh_w )
}
-static WRITE8_HANDLER( blit_addr0_w )
+WRITE8_MEMBER(blitz68k_state::blit_addr0_w)
{
blit.addr[0] = data;
}
-static WRITE8_HANDLER( blit_addr1_w )
+WRITE8_MEMBER(blitz68k_state::blit_addr1_w)
{
blit.addr[1] = data;
}
-static WRITE8_HANDLER( blit_addr01_w )
+WRITE8_MEMBER(blitz68k_state::blit_addr01_w)
{
if (offset)
blit_addr0_w(space, offset, data);
else
blit_addr1_w(space, offset, data);
}
-static WRITE8_HANDLER( blit_addr2_w )
+WRITE8_MEMBER(blitz68k_state::blit_addr2_w)
{
blit.addr[2] = data;
}
-static WRITE8_HANDLER( blit_pens_w )
+WRITE8_MEMBER(blitz68k_state::blit_pens_w)
{
blit.pen[offset] = data;
}
-static WRITE8_HANDLER( blit_pen0_w )
+WRITE8_MEMBER(blitz68k_state::blit_pen0_w)
{
blit.pen[0] = data;
}
-static WRITE8_HANDLER( blit_pen1_w )
+WRITE8_MEMBER(blitz68k_state::blit_pen1_w)
{
blit.pen[1] = data;
}
-static WRITE8_HANDLER( blit_pen2_w )
+WRITE8_MEMBER(blitz68k_state::blit_pen2_w)
{
blit.pen[2] = data;
}
-static WRITE8_HANDLER( blit_pen3_w )
+WRITE8_MEMBER(blitz68k_state::blit_pen3_w)
{
blit.pen[3] = data;
}
-static WRITE8_HANDLER( blit_flag0_w )
+WRITE8_MEMBER(blitz68k_state::blit_flag0_w)
{
blit.flag[0] = data;
}
-static WRITE8_HANDLER( blit_flag1_w )
+WRITE8_MEMBER(blitz68k_state::blit_flag1_w)
{
blit.flag[1] = data;
}
-static WRITE8_HANDLER( blit_flipx_w )
+WRITE8_MEMBER(blitz68k_state::blit_flipx_w)
{
blit.flipx = data;
}
-static WRITE8_HANDLER( blit_flipy_w )
+WRITE8_MEMBER(blitz68k_state::blit_flipy_w)
{
blit.flipy = data;
}
-static WRITE8_HANDLER( blit_solid_w )
+WRITE8_MEMBER(blitz68k_state::blit_solid_w)
{
blit.solid = data;
}
-static WRITE8_HANDLER( blit_trans_w )
+WRITE8_MEMBER(blitz68k_state::blit_trans_w)
{
blit.trans = data;
}
-static WRITE8_HANDLER( blit_flag6_w )
+WRITE8_MEMBER(blitz68k_state::blit_flag6_w)
{
blit.flag[6] = data;
}
-static WRITE8_HANDLER( blit_flag7_w )
+WRITE8_MEMBER(blitz68k_state::blit_flag7_w)
{
blit.flag[7] = data;
}
-static WRITE8_HANDLER( blit_flags_w )
+WRITE8_MEMBER(blitz68k_state::blit_flags_w)
{
switch(offset)
{
@@ -340,17 +415,16 @@ static WRITE8_HANDLER( blit_flags_w )
}
}
-static WRITE8_HANDLER( blit_draw_w )
+WRITE8_MEMBER(blitz68k_state::blit_draw_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- UINT8 *blit_rom = space->machine().region("blitter")->base();
- int blit_romsize = space->machine().region("blitter")->bytes();
+ UINT8 *blit_rom = machine().region("blitter")->base();
+ int blit_romsize = machine().region("blitter")->bytes();
UINT32 blit_dst_xpos;
UINT32 blit_dst_ypos;
int x, y, x_size, y_size;
UINT32 src;
- logerror("%s: blit x=%02x y=%02x w=%02x h=%02x addr=%02x%02x%02x pens=%02x %02x %02x %02x flag=%02x %02x %02x %02x - %02x %02x %02x %02x\n", space->machine().describe_context(),
+ logerror("%s: blit x=%02x y=%02x w=%02x h=%02x addr=%02x%02x%02x pens=%02x %02x %02x %02x flag=%02x %02x %02x %02x - %02x %02x %02x %02x\n", machine().describe_context(),
blit.x, blit.y, blit.w, blit.h,
blit.addr[2], blit.addr[1], blit.addr[0],
blit.pen[0], blit.pen[1], blit.pen[2], blit.pen[3],
@@ -397,7 +471,7 @@ static WRITE8_HANDLER( blit_draw_w )
if (pen <= 3)
pen = blit.pen[pen] & 0xf;
- state->m_blit_buffer[drawy * 512 + drawx] = pen;
+ m_blit_buffer[drawy * 512 + drawx] = pen;
}
}
}
@@ -409,7 +483,7 @@ static WRITE8_HANDLER( blit_draw_w )
blit.y = blit_dst_ypos;
}
-static WRITE8_HANDLER( blit_hwyxa_draw_w )
+WRITE8_MEMBER(blitz68k_state::blit_hwyxa_draw_w)
{
switch (offset)
{
@@ -428,16 +502,16 @@ static WRITE8_HANDLER( blit_hwyxa_draw_w )
Outputs
*************************************************************************************************************/
-static void show_leds123(blitz68k_state *state)
+void blitz68k_state::show_leds123()
{
#ifdef MAME_DEBUG
- popmessage("led %02x %02x %02x", state->m_leds[0][0]>>8, state->m_leds[1][0]>>8, state->m_leds[2][0]>>8);
+ popmessage("led %02x %02x %02x", m_leds[0][0]>>8, m_leds[1][0]>>8, m_leds[2][0]>>8);
#endif
}
-static void show_leds12(blitz68k_state *state)
+void blitz68k_state::show_leds12()
{
#ifdef MAME_DEBUG
- popmessage("led %02x %02x", state->m_leds[0][0]>>8, state->m_leds[1][0]>>8);
+ popmessage("led %02x %02x", m_leds[0][0]>>8, m_leds[1][0]>>8);
#endif
}
@@ -448,30 +522,30 @@ static void show_leds12(blitz68k_state *state)
*************************************************************************************************************/
/*bit 0 is the blitter busy flag*/
-static READ16_HANDLER( blitter_status_r )
+READ16_MEMBER(blitz68k_state::blitter_status_r)
{
return 0;
}
/*TODO*/
-static WRITE16_HANDLER( lamps_w )
+WRITE16_MEMBER(blitz68k_state::lamps_w)
{
// popmessage("%02x",data);
}
-static READ16_HANDLER( test_r )
+READ16_MEMBER(blitz68k_state::test_r)
{
- return 0xffff;//space->machine().rand();
+ return 0xffff;//machine().rand();
}
#if 0
-static WRITE16_HANDLER( irq_callback_w )
+WRITE16_MEMBER(blitz68k_state::irq_callback_w)
{
// popmessage("%02x",data);
- cputag_set_input_line(space->machine(), "maincpu", 3, HOLD_LINE );
+ cputag_set_input_line(machine(), "maincpu", 3, HOLD_LINE );
}
-static WRITE16_HANDLER( sound_write_w )
+WRITE16_MEMBER(blitz68k_state::sound_write_w)
{
popmessage("%02x",data);
dac_data_w(0, data & 0x0f); /* Sound DAC? */
@@ -483,8 +557,8 @@ static ADDRESS_MAP_START( ilpag_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x100000, 0x1fffff) AM_ROM AM_REGION("blitter", 0)
AM_RANGE(0x200000, 0x20ffff) AM_RAM AM_SHARE("nvram")
-// AM_RANGE(0x800000, 0x800001) AM_READ_LEGACY(test_r)
-// AM_RANGE(0x880000, 0x880001) AM_READ_LEGACY(test_r)
+// AM_RANGE(0x800000, 0x800001) AM_READ(test_r)
+// AM_RANGE(0x880000, 0x880001) AM_READ(test_r)
AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
@@ -495,14 +569,14 @@ static ADDRESS_MAP_START( ilpag_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_BASE(m_blit_attr1_ram)
AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_BASE(m_blit_dst_ram_loword)
AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_BASE(m_blit_attr2_ram)
- AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE_LEGACY(blit_copy_w ) AM_BASE(m_blit_dst_ram_hiword)
- AM_RANGE(0x9e0000, 0x9e0001) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE(blit_copy_w ) AM_BASE(m_blit_dst_ram_hiword)
+ AM_RANGE(0x9e0000, 0x9e0001) AM_READ(blitter_status_r)
- AM_RANGE(0xc00000, 0xc00001) AM_WRITE_LEGACY(lamps_w)
+ AM_RANGE(0xc00000, 0xc00001) AM_WRITE(lamps_w)
AM_RANGE(0xc00180, 0xc00181) AM_READ_PORT("IN2")
-// AM_RANGE(0xc00200, 0xc00201) AM_WRITE_LEGACY(sound_write_w)
+// AM_RANGE(0xc00200, 0xc00201) AM_WRITE(sound_write_w)
AM_RANGE(0xc00380, 0xc00381) AM_READ_PORT("IN3")
-// AM_RANGE(0xc00300, 0xc00301) AM_WRITE_LEGACY(irq_callback_w)
+// AM_RANGE(0xc00300, 0xc00301) AM_WRITE(irq_callback_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( steaser_map, AS_PROGRAM, 16, blitz68k_state )
@@ -510,10 +584,10 @@ static ADDRESS_MAP_START( steaser_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x100000, 0x1fffff) AM_ROM AM_REGION("blitter", 0)
AM_RANGE(0x200000, 0x20ffff) AM_RAM AM_SHARE("nvram")
- AM_RANGE(0x800000, 0x800001) AM_READ_LEGACY(test_r)
-// AM_RANGE(0x840000, 0x840001) AM_WRITE_LEGACY(sound_write_w)
- AM_RANGE(0x880000, 0x880001) AM_READ_LEGACY(test_r)
-// AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE_LEGACY(sound_write_w)
+ AM_RANGE(0x800000, 0x800001) AM_READ(test_r)
+// AM_RANGE(0x840000, 0x840001) AM_WRITE(sound_write_w)
+ AM_RANGE(0x880000, 0x880001) AM_READ(test_r)
+// AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE(sound_write_w)
AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
@@ -525,17 +599,17 @@ static ADDRESS_MAP_START( steaser_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_BASE(m_blit_attr1_ram)
AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_BASE(m_blit_dst_ram_loword)
AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_BASE(m_blit_attr2_ram)
- AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE_LEGACY(blit_copy_w ) AM_BASE(m_blit_dst_ram_hiword)
+ AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE(blit_copy_w ) AM_BASE(m_blit_dst_ram_hiword)
AM_RANGE(0x9c0002, 0x9c0003) AM_READNOP //pen control?
AM_RANGE(0x9d0000, 0x9d0001) AM_READNOP //?
- AM_RANGE(0x9e0000, 0x9e0001) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0x9e0000, 0x9e0001) AM_READ(blitter_status_r)
AM_RANGE(0x9f0000, 0x9f0001) AM_WRITENOP //???
-// AM_RANGE(0xc00000, 0xc00001) AM_WRITE_LEGACY(lamps_w)
- AM_RANGE(0xbd0000, 0xbd0001) AM_READ_LEGACY(test_r)
-// AM_RANGE(0xc00200, 0xc00201) AM_WRITE_LEGACY(sound_write_w)
+// AM_RANGE(0xc00000, 0xc00001) AM_WRITE(lamps_w)
+ AM_RANGE(0xbd0000, 0xbd0001) AM_READ(test_r)
+// AM_RANGE(0xc00200, 0xc00201) AM_WRITE(sound_write_w)
// AM_RANGE(0xc00380, 0xc00381) AM_READ_PORT("IN3")
-// AM_RANGE(0xc00300, 0xc00301) AM_WRITE_LEGACY(irq_callback_w)
+// AM_RANGE(0xc00300, 0xc00301) AM_WRITE(irq_callback_w)
ADDRESS_MAP_END
/*************************************************************************************************************
@@ -543,36 +617,36 @@ ADDRESS_MAP_END
*************************************************************************************************************/
// MCU simulation (to be done)
-static READ8_HANDLER( bankrob_mcu1_r )
+READ8_MEMBER(blitz68k_state::bankrob_mcu1_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( bankrob_mcu2_r )
+READ8_MEMBER(blitz68k_state::bankrob_mcu2_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( bankrob_mcu_status_read_r )
+READ8_MEMBER(blitz68k_state::bankrob_mcu_status_read_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static READ8_HANDLER( bankrob_mcu_status_write_r )
+READ8_MEMBER(blitz68k_state::bankrob_mcu_status_write_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static WRITE8_HANDLER( bankrob_mcu1_w )
+WRITE8_MEMBER(blitz68k_state::bankrob_mcu1_w)
{
- logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
}
-static WRITE8_HANDLER( bankrob_mcu2_w )
+WRITE8_MEMBER(blitz68k_state::bankrob_mcu2_w)
{
- logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
}
static ADDRESS_MAP_START( bankrob_map, AS_PROGRAM, 16, blitz68k_state )
@@ -582,45 +656,45 @@ static ADDRESS_MAP_START( bankrob_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x220000, 0x220001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0xff00 )
- AM_RANGE(0x240000, 0x240001) AM_WRITE8_LEGACY(blit_addr0_w, 0xff00)
- AM_RANGE(0x240002, 0x240003) AM_WRITE8_LEGACY(blit_addr1_w, 0xff00)
- AM_RANGE(0x240004, 0x240005) AM_WRITE8_LEGACY(blit_addr2_w, 0xff00)
+ AM_RANGE(0x240000, 0x240001) AM_WRITE8(blit_addr0_w, 0xff00)
+ AM_RANGE(0x240002, 0x240003) AM_WRITE8(blit_addr1_w, 0xff00)
+ AM_RANGE(0x240004, 0x240005) AM_WRITE8(blit_addr2_w, 0xff00)
- AM_RANGE(0x240006, 0x240007) AM_WRITE8_LEGACY(blit_x_w, 0xff00)
- AM_RANGE(0x240008, 0x240009) AM_WRITE8_LEGACY(blit_y_w, 0xff00)
+ AM_RANGE(0x240006, 0x240007) AM_WRITE8(blit_x_w, 0xff00)
+ AM_RANGE(0x240008, 0x240009) AM_WRITE8(blit_y_w, 0xff00)
- AM_RANGE(0x24000a, 0x24000b) AM_WRITE8_LEGACY(blit_w_w, 0xff00)
- AM_RANGE(0x24000c, 0x24000d) AM_WRITE8_LEGACY(blit_h_w, 0xff00)
+ AM_RANGE(0x24000a, 0x24000b) AM_WRITE8(blit_w_w, 0xff00)
+ AM_RANGE(0x24000c, 0x24000d) AM_WRITE8(blit_h_w, 0xff00)
- AM_RANGE(0x24000e, 0x24000f) AM_WRITE8_LEGACY(blit_draw_w, 0xff00)
+ AM_RANGE(0x24000e, 0x24000f) AM_WRITE8(blit_draw_w, 0xff00)
- AM_RANGE(0x260000, 0x260001) AM_WRITE8_LEGACY(blit_pen0_w, 0xff00)
- AM_RANGE(0x260002, 0x260003) AM_WRITE8_LEGACY(blit_pen1_w, 0xff00)
- AM_RANGE(0x260004, 0x260005) AM_WRITE8_LEGACY(blit_pen2_w, 0xff00)
- AM_RANGE(0x260006, 0x260007) AM_WRITE8_LEGACY(blit_pen3_w, 0xff00)
+ AM_RANGE(0x260000, 0x260001) AM_WRITE8(blit_pen0_w, 0xff00)
+ AM_RANGE(0x260002, 0x260003) AM_WRITE8(blit_pen1_w, 0xff00)
+ AM_RANGE(0x260004, 0x260005) AM_WRITE8(blit_pen2_w, 0xff00)
+ AM_RANGE(0x260006, 0x260007) AM_WRITE8(blit_pen3_w, 0xff00)
- AM_RANGE(0x280000, 0x280001) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0x280000, 0x280001) AM_READ(blitter_status_r)
AM_RANGE(0x2c0000, 0x2c0001) AM_WRITENOP // 1->0
- AM_RANGE(0x2e0000, 0x2e0001) AM_WRITE8_LEGACY(blit_flag0_w, 0xff00)
- AM_RANGE(0x2e0002, 0x2e0003) AM_WRITE8_LEGACY(blit_flag1_w, 0xff00)
- AM_RANGE(0x2e0004, 0x2e0005) AM_WRITE8_LEGACY(blit_flipx_w, 0xff00)
- AM_RANGE(0x2e0006, 0x2e0007) AM_WRITE8_LEGACY(blit_flipy_w, 0xff00)
- AM_RANGE(0x2e0008, 0x2e0009) AM_WRITE8_LEGACY(blit_solid_w, 0xff00)
- AM_RANGE(0x2e000a, 0x2e000b) AM_WRITE8_LEGACY(blit_trans_w, 0xff00)
- AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8_LEGACY(blit_flag6_w, 0xff00)
- AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8_LEGACY(blit_flag7_w, 0xff00)
+ AM_RANGE(0x2e0000, 0x2e0001) AM_WRITE8(blit_flag0_w, 0xff00)
+ AM_RANGE(0x2e0002, 0x2e0003) AM_WRITE8(blit_flag1_w, 0xff00)
+ AM_RANGE(0x2e0004, 0x2e0005) AM_WRITE8(blit_flipx_w, 0xff00)
+ AM_RANGE(0x2e0006, 0x2e0007) AM_WRITE8(blit_flipy_w, 0xff00)
+ AM_RANGE(0x2e0008, 0x2e0009) AM_WRITE8(blit_solid_w, 0xff00)
+ AM_RANGE(0x2e000a, 0x2e000b) AM_WRITE8(blit_trans_w, 0xff00)
+ AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8(blit_flag6_w, 0xff00)
+ AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8(blit_flag7_w, 0xff00)
AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
- AM_RANGE(0x400000, 0x400001) AM_READ8_LEGACY(bankrob_mcu_status_write_r, 0x00ff)
- AM_RANGE(0x400002, 0x400003) AM_READ8_LEGACY(bankrob_mcu_status_read_r, 0x00ff)
+ AM_RANGE(0x400000, 0x400001) AM_READ8(bankrob_mcu_status_write_r, 0x00ff)
+ AM_RANGE(0x400002, 0x400003) AM_READ8(bankrob_mcu_status_read_r, 0x00ff)
- AM_RANGE(0x400004, 0x400005) AM_READWRITE8_LEGACY(bankrob_mcu1_r, bankrob_mcu1_w, 0x00ff)
- AM_RANGE(0x400006, 0x400007) AM_READWRITE8_LEGACY(bankrob_mcu2_r, bankrob_mcu2_w, 0xff00)
+ AM_RANGE(0x400004, 0x400005) AM_READWRITE8(bankrob_mcu1_r, bankrob_mcu1_w, 0x00ff)
+ AM_RANGE(0x400006, 0x400007) AM_READWRITE8(bankrob_mcu2_r, bankrob_mcu2_w, 0xff00)
AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r, address_w, 0xff00) // triggered by MCU?
AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
@@ -629,46 +703,46 @@ ADDRESS_MAP_END
// bankroba:
// MCU simulation (to be done)
-static READ8_HANDLER( bankroba_mcu1_r )
+READ8_MEMBER(blitz68k_state::bankroba_mcu1_r)
{
- UINT8 ret = space->machine().rand(); // space->machine().rand() gives "interesting" results
- logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = machine().rand(); // machine().rand() gives "interesting" results
+ logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( bankroba_mcu2_r )
+READ8_MEMBER(blitz68k_state::bankroba_mcu2_r)
{
- UINT8 ret = space->machine().rand(); // space->machine().rand() gives "interesting" results
- logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = machine().rand(); // machine().rand() gives "interesting" results
+ logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( bankroba_mcu1_status_write_r )
+READ8_MEMBER(blitz68k_state::bankroba_mcu1_status_write_r)
{
return 0x00; // bit 0 = MCU1. Active low.
}
-static READ8_HANDLER( bankroba_mcu2_status_write_r )
+READ8_MEMBER(blitz68k_state::bankroba_mcu2_status_write_r)
{
return 0x01; // bit 0 = MCU2. Active high.
}
-static WRITE8_HANDLER( bankroba_mcu1_w )
+WRITE8_MEMBER(blitz68k_state::bankroba_mcu1_w)
{
- logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
}
-static WRITE8_HANDLER( bankroba_mcu2_w )
+WRITE8_MEMBER(blitz68k_state::bankroba_mcu2_w)
{
- logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
}
static ADDRESS_MAP_START( bankroba_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x000000, 0x03ffff) AM_ROM
AM_RANGE(0x200000, 0x20ffff) AM_RAM
- AM_RANGE(0x800000, 0x800001) AM_WRITE8_LEGACY(bankroba_mcu1_r, 0x00ff) // lev 4
- AM_RANGE(0x840000, 0x840001) AM_WRITE8_LEGACY(bankroba_mcu1_w, 0x00ff)
+ AM_RANGE(0x800000, 0x800001) AM_READ8(bankroba_mcu1_r, 0x00ff) // lev 4
+ AM_RANGE(0x840000, 0x840001) AM_WRITE8(bankroba_mcu1_w, 0x00ff)
- AM_RANGE(0x880000, 0x880001) AM_WRITE8_LEGACY(bankroba_mcu2_r, 0x00ff) // lev 3
- AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE8_LEGACY(bankroba_mcu2_w, 0x00ff)
+ AM_RANGE(0x880000, 0x880001) AM_READ8(bankroba_mcu2_r, 0x00ff) // lev 3
+ AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE8(bankroba_mcu2_w, 0x00ff)
AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
@@ -676,39 +750,39 @@ static ADDRESS_MAP_START( bankroba_map, AS_PROGRAM, 16, blitz68k_state )
// AM_RANGE(0x940000, 0x940001) AM_WRITE // lev 6
- AM_RANGE(0x980000, 0x980001) AM_WRITE8_LEGACY(blit_flag0_w, 0xff00)
- AM_RANGE(0x980002, 0x980003) AM_WRITE8_LEGACY(blit_flag1_w, 0xff00)
- AM_RANGE(0x980004, 0x980005) AM_WRITE8_LEGACY(blit_flipx_w, 0xff00)
- AM_RANGE(0x980006, 0x980007) AM_WRITE8_LEGACY(blit_flipy_w, 0xff00)
- AM_RANGE(0x980008, 0x980009) AM_WRITE8_LEGACY(blit_solid_w, 0xff00)
- AM_RANGE(0x98000a, 0x98000b) AM_WRITE8_LEGACY(blit_trans_w, 0xff00)
- AM_RANGE(0x98000c, 0x98000d) AM_WRITE8_LEGACY(blit_flag6_w, 0xff00)
- AM_RANGE(0x98000e, 0x98000f) AM_WRITE8_LEGACY(blit_flag7_w, 0xff00)
+ AM_RANGE(0x980000, 0x980001) AM_WRITE8(blit_flag0_w, 0xff00)
+ AM_RANGE(0x980002, 0x980003) AM_WRITE8(blit_flag1_w, 0xff00)
+ AM_RANGE(0x980004, 0x980005) AM_WRITE8(blit_flipx_w, 0xff00)
+ AM_RANGE(0x980006, 0x980007) AM_WRITE8(blit_flipy_w, 0xff00)
+ AM_RANGE(0x980008, 0x980009) AM_WRITE8(blit_solid_w, 0xff00)
+ AM_RANGE(0x98000a, 0x98000b) AM_WRITE8(blit_trans_w, 0xff00)
+ AM_RANGE(0x98000c, 0x98000d) AM_WRITE8(blit_flag6_w, 0xff00)
+ AM_RANGE(0x98000e, 0x98000f) AM_WRITE8(blit_flag7_w, 0xff00)
- AM_RANGE(0x990000, 0x990001) AM_WRITE8_LEGACY(blit_pen0_w, 0xff00)
- AM_RANGE(0x990002, 0x990003) AM_WRITE8_LEGACY(blit_pen1_w, 0xff00)
- AM_RANGE(0x990004, 0x990005) AM_WRITE8_LEGACY(blit_pen2_w, 0xff00)
- AM_RANGE(0x990006, 0x990007) AM_WRITE8_LEGACY(blit_pen3_w, 0xff00)
+ AM_RANGE(0x990000, 0x990001) AM_WRITE8(blit_pen0_w, 0xff00)
+ AM_RANGE(0x990002, 0x990003) AM_WRITE8(blit_pen1_w, 0xff00)
+ AM_RANGE(0x990004, 0x990005) AM_WRITE8(blit_pen2_w, 0xff00)
+ AM_RANGE(0x990006, 0x990007) AM_WRITE8(blit_pen3_w, 0xff00)
- AM_RANGE(0x998000, 0x998001) AM_WRITE8_LEGACY(blit_addr01_w, 0xffff)
- AM_RANGE(0x9a0000, 0x9a0001) AM_WRITE8_LEGACY(blit_addr2_w, 0xff00)
+ AM_RANGE(0x998000, 0x998001) AM_WRITE8(blit_addr01_w, 0xffff)
+ AM_RANGE(0x9a0000, 0x9a0001) AM_WRITE8(blit_addr2_w, 0xff00)
- AM_RANGE(0x9a8000, 0x9a8001) AM_WRITE8_LEGACY(blit_xy_w, 0xffff)
+ AM_RANGE(0x9a8000, 0x9a8001) AM_WRITE8(blit_xy_w, 0xffff)
- AM_RANGE(0x9b0000, 0x9b0001) AM_WRITE8_LEGACY(blit_wh_w, 0xffff)
+ AM_RANGE(0x9b0000, 0x9b0001) AM_WRITE8(blit_wh_w, 0xffff)
- AM_RANGE(0x9b8000, 0x9b8001) AM_WRITE8_LEGACY(blit_draw_w, 0x00ff)
+ AM_RANGE(0x9b8000, 0x9b8001) AM_WRITE8(blit_draw_w, 0x00ff)
AM_RANGE(0x9c0000, 0x9c0001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
AM_RANGE(0x9c0002, 0x9c0003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0xff00 )
- AM_RANGE(0x9d0000, 0x9d0001) AM_READ8_LEGACY(bankroba_mcu1_status_write_r, 0xff00)
+ AM_RANGE(0x9d0000, 0x9d0001) AM_READ8(bankroba_mcu1_status_write_r, 0xff00)
- AM_RANGE(0x9e0000, 0x9e0001) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0x9e0000, 0x9e0001) AM_READ(blitter_status_r)
AM_RANGE(0x9f0000, 0x9f0001) AM_WRITENOP // 1
- AM_RANGE(0xbd0000, 0xbd0001) AM_READ8_LEGACY(bankroba_mcu2_status_write_r, 0xff00)
+ AM_RANGE(0xbd0000, 0xbd0001) AM_READ8(bankroba_mcu2_status_write_r, 0xff00)
// CRTC connected to MCU?
ADDRESS_MAP_END
@@ -717,71 +791,68 @@ ADDRESS_MAP_END
Funny Fruit
*************************************************************************************************************/
-static WRITE16_HANDLER( cjffruit_leds1_w )
+WRITE16_MEMBER(blitz68k_state::cjffruit_leds1_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[0]);
+ data = COMBINE_DATA(m_leds[0]);
if (ACCESSING_BITS_8_15)
{
- coin_counter_w(space->machine(), 0, data & 0x0100); // coin in
- set_led_status(space->machine(), 0, data & 0x0200); // win???
+ coin_counter_w(machine(), 0, data & 0x0100); // coin in
+ set_led_status(machine(), 0, data & 0x0200); // win???
// 1 data & 0x0400 // win???
- set_led_status(space->machine(), 2, data & 0x0800); // small
- set_led_status(space->machine(), 3, data & 0x1000); // big
- set_led_status(space->machine(), 4, data & 0x2000); // take
- set_led_status(space->machine(), 5, data & 0x4000); // double up
- set_led_status(space->machine(), 6, data & 0x8000); // cancel
- show_leds123(state);
+ set_led_status(machine(), 2, data & 0x0800); // small
+ set_led_status(machine(), 3, data & 0x1000); // big
+ set_led_status(machine(), 4, data & 0x2000); // take
+ set_led_status(machine(), 5, data & 0x4000); // double up
+ set_led_status(machine(), 6, data & 0x8000); // cancel
+ show_leds123();
}
}
-static WRITE16_HANDLER( cjffruit_leds2_w )
+WRITE16_MEMBER(blitz68k_state::cjffruit_leds2_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[1]);
+ data = COMBINE_DATA(m_leds[1]);
if (ACCESSING_BITS_8_15)
{
- set_led_status(space->machine(), 7, data & 0x0100); // start
- set_led_status(space->machine(), 8, data & 0x0200); // bet
- set_led_status(space->machine(), 9, data & 0x0400); // hold 5
- set_led_status(space->machine(), 10, data & 0x0800); // hold 4
- set_led_status(space->machine(), 11, data & 0x1000); // hold 3
- set_led_status(space->machine(), 12, data & 0x2000); // hold 2
- set_led_status(space->machine(), 13, data & 0x4000); // collect
- set_led_status(space->machine(), 14, data & 0x8000); // call attendant
- show_leds123(state);
+ set_led_status(machine(), 7, data & 0x0100); // start
+ set_led_status(machine(), 8, data & 0x0200); // bet
+ set_led_status(machine(), 9, data & 0x0400); // hold 5
+ set_led_status(machine(), 10, data & 0x0800); // hold 4
+ set_led_status(machine(), 11, data & 0x1000); // hold 3
+ set_led_status(machine(), 12, data & 0x2000); // hold 2
+ set_led_status(machine(), 13, data & 0x4000); // collect
+ set_led_status(machine(), 14, data & 0x8000); // call attendant
+ show_leds123();
}
}
-static WRITE16_HANDLER( cjffruit_leds3_w )
+WRITE16_MEMBER(blitz68k_state::cjffruit_leds3_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[2]);
+ data = COMBINE_DATA(m_leds[2]);
if (ACCESSING_BITS_8_15)
{
- set_led_status(space->machine(), 15, data & 0x0100); // hopper coins?
- set_led_status(space->machine(), 16, data & 0x0400); // coin out?
- show_leds123(state);
+ set_led_status(machine(), 15, data & 0x0100); // hopper coins?
+ set_led_status(machine(), 16, data & 0x0400); // coin out?
+ show_leds123();
}
}
// CRTC
-static READ8_HANDLER( crtc_r )
+READ8_MEMBER(blitz68k_state::crtc_r)
{
- mc6845_device *mc6845 = space->machine().device<mc6845_device>("crtc");
+ mc6845_device *mc6845 = machine().device<mc6845_device>("crtc");
if (offset)
- return mc6845->register_r(*space, 0);
+ return mc6845->register_r(*&space, 0);
else
- return mc6845->status_r(*space, 0);
+ return mc6845->status_r(*&space, 0);
}
-static WRITE8_HANDLER( crtc_w )
+WRITE8_MEMBER(blitz68k_state::crtc_w)
{
- mc6845_device *mc6845 = space->machine().device<mc6845_device>("crtc");
+ mc6845_device *mc6845 = machine().device<mc6845_device>("crtc");
if (offset)
- mc6845->register_w(*space, 0, data);
+ mc6845->register_w(*&space, 0, data);
else
- mc6845->address_w(*space, 0, data);
+ mc6845->address_w(*&space, 0, data);
}
static WRITE16_DEVICE_HANDLER( crtc_lpen_w )
@@ -793,16 +864,16 @@ static WRITE16_DEVICE_HANDLER( crtc_lpen_w )
}
// MCU simulation (to be done)
-static READ16_HANDLER( cjffruit_mcu_r )
+READ16_MEMBER(blitz68k_state::cjffruit_mcu_r)
{
- UINT8 ret = 0x00; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0x00; // machine().rand() gives "interesting" results
+ logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
return ret << 8;
}
-static WRITE16_HANDLER( cjffruit_mcu_w )
+WRITE16_MEMBER(blitz68k_state::cjffruit_mcu_w)
{
- logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
+ logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
}
static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16, blitz68k_state )
@@ -810,9 +881,9 @@ static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x400000, 0x41ffff) AM_RAM AM_SHARE("nvram")
AM_RANGE(0x480000, 0x4807ff) AM_RAM
- AM_RANGE(0x820000, 0x820007) AM_WRITE8_LEGACY(blit_hwyxa_draw_w, 0xffff)
+ AM_RANGE(0x820000, 0x820007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
- AM_RANGE(0x850000, 0x850001) AM_READ_LEGACY(cjffruit_mcu_r )
+ AM_RANGE(0x850000, 0x850001) AM_READ(cjffruit_mcu_r )
AM_RANGE(0x870000, 0x870001) AM_READ_PORT("IN0")
AM_RANGE(0x872000, 0x872001) AM_READ_PORT("IN1")
@@ -825,21 +896,21 @@ static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x880000, 0x880001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
AM_RANGE(0x880000, 0x880001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
- AM_RANGE(0x8a0000, 0x8a0007) AM_WRITE8_LEGACY(blit_hwyxa_draw_w, 0xffff)
+ AM_RANGE(0x8a0000, 0x8a0007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
- AM_RANGE(0x8b0000, 0x8b0003) AM_WRITE8_LEGACY(blit_pens_w, 0xffff)
+ AM_RANGE(0x8b0000, 0x8b0003) AM_WRITE8(blit_pens_w, 0xffff)
- AM_RANGE(0x8e0000, 0x8e0001) AM_WRITE_LEGACY(cjffruit_mcu_w )
+ AM_RANGE(0x8e0000, 0x8e0001) AM_WRITE(cjffruit_mcu_w )
- AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE_LEGACY(cjffruit_leds1_w) AM_BASE(m_leds[0])
- AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE_LEGACY(cjffruit_leds2_w) AM_BASE(m_leds[1])
- AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE_LEGACY(cjffruit_leds3_w) AM_BASE(m_leds[2])
+ AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE(cjffruit_leds1_w) AM_BASE(m_leds[0])
+ AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE(cjffruit_leds2_w) AM_BASE(m_leds[1])
+ AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE(cjffruit_leds3_w) AM_BASE(m_leds[2])
- AM_RANGE(0x8fe000, 0x8fe003) AM_WRITE8_LEGACY(blit_flags_w, 0xffff) // flipx,y,solid,trans
+ AM_RANGE(0x8fe000, 0x8fe003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
AM_RANGE(0x8fe004, 0x8fe005) AM_WRITEONLY
AM_RANGE(0x8fe006, 0x8fe007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w) // 0x8fe006: 0->1, 0x8fe007: 1->0
- AM_RANGE(0xc40000, 0xc40001) AM_READWRITE8_LEGACY(crtc_r, crtc_w, 0xffff)
+ AM_RANGE(0xc40000, 0xc40001) AM_READWRITE8(crtc_r, crtc_w, 0xffff)
ADDRESS_MAP_END
/*************************************************************************************************************
@@ -847,63 +918,60 @@ ADDRESS_MAP_END
*************************************************************************************************************/
// MCU simulation (to be done)
-static READ16_HANDLER( deucesw2_mcu_r )
+READ16_MEMBER(blitz68k_state::deucesw2_mcu_r)
{
- UINT8 ret = 0x00; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0x00; // machine().rand() gives "interesting" results
+ logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
return ret << 8;
}
-static WRITE16_HANDLER( deucesw2_mcu_w )
+WRITE16_MEMBER(blitz68k_state::deucesw2_mcu_w)
{
- logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
+ logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
}
-static WRITE16_HANDLER( deucesw2_leds1_w )
+WRITE16_MEMBER(blitz68k_state::deucesw2_leds1_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[0]);
+ data = COMBINE_DATA(m_leds[0]);
if (ACCESSING_BITS_8_15)
{
- coin_counter_w(space->machine(), 0, data & 0x0100); // coin in
- set_led_status(space->machine(), 0, data & 0x0200); // win???
+ coin_counter_w(machine(), 0, data & 0x0100); // coin in
+ set_led_status(machine(), 0, data & 0x0200); // win???
// 1 data & 0x0400 // win???
- set_led_status(space->machine(), 2, data & 0x0800); // small
- set_led_status(space->machine(), 3, data & 0x1000); // big
- set_led_status(space->machine(), 4, data & 0x2000); // take
- set_led_status(space->machine(), 5, data & 0x4000); // double up
- set_led_status(space->machine(), 6, data & 0x8000); // cancel
- show_leds123(state);
+ set_led_status(machine(), 2, data & 0x0800); // small
+ set_led_status(machine(), 3, data & 0x1000); // big
+ set_led_status(machine(), 4, data & 0x2000); // take
+ set_led_status(machine(), 5, data & 0x4000); // double up
+ set_led_status(machine(), 6, data & 0x8000); // cancel
+ show_leds123();
}
}
-static WRITE16_HANDLER( deucesw2_leds2_w )
+WRITE16_MEMBER(blitz68k_state::deucesw2_leds2_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[1]);
+ data = COMBINE_DATA(m_leds[1]);
if (ACCESSING_BITS_8_15)
{
- set_led_status(space->machine(), 7, data & 0x0100); // start
- set_led_status(space->machine(), 8, data & 0x0200); // bet
- set_led_status(space->machine(), 9, data & 0x0400); // hold 5
- set_led_status(space->machine(), 10, data & 0x0800); // hold 4
- set_led_status(space->machine(), 11, data & 0x1000); // hold 3
- set_led_status(space->machine(), 12, data & 0x2000); // hold 2
- set_led_status(space->machine(), 13, data & 0x4000); // hold 1
- set_led_status(space->machine(), 14, data & 0x8000); // call attendant
- show_leds123(state);
+ set_led_status(machine(), 7, data & 0x0100); // start
+ set_led_status(machine(), 8, data & 0x0200); // bet
+ set_led_status(machine(), 9, data & 0x0400); // hold 5
+ set_led_status(machine(), 10, data & 0x0800); // hold 4
+ set_led_status(machine(), 11, data & 0x1000); // hold 3
+ set_led_status(machine(), 12, data & 0x2000); // hold 2
+ set_led_status(machine(), 13, data & 0x4000); // hold 1
+ set_led_status(machine(), 14, data & 0x8000); // call attendant
+ show_leds123();
}
}
-static WRITE16_HANDLER( deucesw2_leds3_w )
+WRITE16_MEMBER(blitz68k_state::deucesw2_leds3_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[2]);
+ data = COMBINE_DATA(m_leds[2]);
if (ACCESSING_BITS_8_15)
{
- set_led_status(space->machine(), 15, data & 0x0100); // hopper coins?
- set_led_status(space->machine(), 16, data & 0x0400); // coin out?
- show_leds123(state);
+ set_led_status(machine(), 15, data & 0x0100); // hopper coins?
+ set_led_status(machine(), 16, data & 0x0400); // coin out?
+ show_leds123();
}
}
@@ -911,37 +979,37 @@ static ADDRESS_MAP_START( deucesw2_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x000000, 0x03ffff) AM_ROM
AM_RANGE(0x400000, 0x41ffff) AM_RAM
- AM_RANGE(0x800000, 0x800007) AM_WRITE8_LEGACY(blit_hwyxa_draw_w, 0xffff)
+ AM_RANGE(0x800000, 0x800007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
AM_RANGE(0x812000, 0x812001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
AM_RANGE(0x812000, 0x812001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
- AM_RANGE(0x830000, 0x830001) AM_READ_LEGACY(deucesw2_mcu_r )
+ AM_RANGE(0x830000, 0x830001) AM_READ(deucesw2_mcu_r )
AM_RANGE(0x840000, 0x840001) AM_READ_PORT("IN0")
AM_RANGE(0x850000, 0x850001) AM_READ_PORT("IN1")
AM_RANGE(0x860000, 0x860001) AM_READ_PORT("IN2")
AM_RANGE(0x870000, 0x870001) AM_READ_PORT("DSW")
- AM_RANGE(0x880000, 0x880007) AM_WRITE8_LEGACY(blit_hwyxa_draw_w, 0xffff)
+ AM_RANGE(0x880000, 0x880007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0x00ff )
AM_RANGE(0x890002, 0x890003) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
- AM_RANGE(0x894000, 0x894003) AM_WRITE8_LEGACY(blit_pens_w, 0xffff)
+ AM_RANGE(0x894000, 0x894003) AM_WRITE8(blit_pens_w, 0xffff)
- AM_RANGE(0x896000, 0x896001) AM_WRITE_LEGACY(deucesw2_mcu_w )
+ AM_RANGE(0x896000, 0x896001) AM_WRITE(deucesw2_mcu_w )
- AM_RANGE(0x898000, 0x898001) AM_WRITE_LEGACY(deucesw2_leds1_w) AM_BASE(m_leds[0])
- AM_RANGE(0x89a000, 0x89a001) AM_WRITE_LEGACY(deucesw2_leds2_w) AM_BASE(m_leds[1])
- AM_RANGE(0x89c000, 0x89c001) AM_WRITE_LEGACY(deucesw2_leds3_w) AM_BASE(m_leds[2])
+ AM_RANGE(0x898000, 0x898001) AM_WRITE(deucesw2_leds1_w) AM_BASE(m_leds[0])
+ AM_RANGE(0x89a000, 0x89a001) AM_WRITE(deucesw2_leds2_w) AM_BASE(m_leds[1])
+ AM_RANGE(0x89c000, 0x89c001) AM_WRITE(deucesw2_leds3_w) AM_BASE(m_leds[2])
- AM_RANGE(0x89e000, 0x89e003) AM_WRITE8_LEGACY(blit_flags_w, 0xffff) // flipx,y,solid,trans
+ AM_RANGE(0x89e000, 0x89e003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
AM_RANGE(0x89e004, 0x89e005) AM_WRITEONLY
AM_RANGE(0x89e006, 0x89e007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w) // 0x89e006: 0->1, 0x89e007: 1->0
- AM_RANGE(0xc00000, 0xc00001) AM_READWRITE8_LEGACY(crtc_r, crtc_w, 0xffff)
+ AM_RANGE(0xc00000, 0xc00001) AM_READWRITE8(crtc_r, crtc_w, 0xffff)
ADDRESS_MAP_END
/*************************************************************************************************************
@@ -949,36 +1017,36 @@ ADDRESS_MAP_END
*************************************************************************************************************/
// MCU simulation (to be done)
-static READ8_HANDLER( dualgame_mcu1_r )
+READ8_MEMBER(blitz68k_state::dualgame_mcu1_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( dualgame_mcu2_r )
+READ8_MEMBER(blitz68k_state::dualgame_mcu2_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( dualgame_mcu_status_read_r )
+READ8_MEMBER(blitz68k_state::dualgame_mcu_status_read_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static READ8_HANDLER( dualgame_mcu_status_write_r )
+READ8_MEMBER(blitz68k_state::dualgame_mcu_status_write_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static WRITE8_HANDLER( dualgame_mcu1_w )
+WRITE8_MEMBER(blitz68k_state::dualgame_mcu1_w)
{
- logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
}
-static WRITE8_HANDLER( dualgame_mcu2_w )
+WRITE8_MEMBER(blitz68k_state::dualgame_mcu2_w)
{
- logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
}
static ADDRESS_MAP_START( dualgame_map, AS_PROGRAM, 16, blitz68k_state )
@@ -988,48 +1056,48 @@ static ADDRESS_MAP_START( dualgame_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
- AM_RANGE(0x240000, 0x240001) AM_WRITE8_LEGACY(blit_addr0_w, 0xff00)
- AM_RANGE(0x240002, 0x240003) AM_WRITE8_LEGACY(blit_addr1_w, 0xff00)
- AM_RANGE(0x240004, 0x240005) AM_WRITE8_LEGACY(blit_addr2_w, 0xff00)
+ AM_RANGE(0x240000, 0x240001) AM_WRITE8(blit_addr0_w, 0xff00)
+ AM_RANGE(0x240002, 0x240003) AM_WRITE8(blit_addr1_w, 0xff00)
+ AM_RANGE(0x240004, 0x240005) AM_WRITE8(blit_addr2_w, 0xff00)
- AM_RANGE(0x240006, 0x240007) AM_WRITE8_LEGACY(blit_x_w, 0xff00)
- AM_RANGE(0x240008, 0x240009) AM_WRITE8_LEGACY(blit_y_w, 0xff00)
+ AM_RANGE(0x240006, 0x240007) AM_WRITE8(blit_x_w, 0xff00)
+ AM_RANGE(0x240008, 0x240009) AM_WRITE8(blit_y_w, 0xff00)
- AM_RANGE(0x24000a, 0x24000b) AM_WRITE8_LEGACY(blit_w_w, 0xff00)
- AM_RANGE(0x24000c, 0x24000d) AM_WRITE8_LEGACY(blit_h_w, 0xff00)
+ AM_RANGE(0x24000a, 0x24000b) AM_WRITE8(blit_w_w, 0xff00)
+ AM_RANGE(0x24000c, 0x24000d) AM_WRITE8(blit_h_w, 0xff00)
- AM_RANGE(0x24000e, 0x24000f) AM_WRITE8_LEGACY(blit_draw_w, 0xff00)
+ AM_RANGE(0x24000e, 0x24000f) AM_WRITE8(blit_draw_w, 0xff00)
- AM_RANGE(0x260000, 0x260001) AM_WRITE8_LEGACY(blit_pen0_w, 0xff00)
- AM_RANGE(0x260002, 0x260003) AM_WRITE8_LEGACY(blit_pen1_w, 0xff00)
- AM_RANGE(0x260004, 0x260005) AM_WRITE8_LEGACY(blit_pen2_w, 0xff00)
- AM_RANGE(0x260006, 0x260007) AM_WRITE8_LEGACY(blit_pen3_w, 0xff00)
+ AM_RANGE(0x260000, 0x260001) AM_WRITE8(blit_pen0_w, 0xff00)
+ AM_RANGE(0x260002, 0x260003) AM_WRITE8(blit_pen1_w, 0xff00)
+ AM_RANGE(0x260004, 0x260005) AM_WRITE8(blit_pen2_w, 0xff00)
+ AM_RANGE(0x260006, 0x260007) AM_WRITE8(blit_pen3_w, 0xff00)
- AM_RANGE(0x280000, 0x280001) AM_READ8_LEGACY(blit_status_r, 0xff00)
+ AM_RANGE(0x280000, 0x280001) AM_READ8(blit_status_r, 0xff00)
AM_RANGE(0x2a0000, 0x2a0001) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w)
AM_RANGE(0x2a0000, 0x2a0001) AM_READNOP
AM_RANGE(0x2c0000, 0x2c0001) AM_WRITENOP // 1->0 (MCU related?)
- AM_RANGE(0x2e0000, 0x2e0001) AM_WRITE8_LEGACY(blit_flag0_w, 0xff00)
- AM_RANGE(0x2e0002, 0x2e0003) AM_WRITE8_LEGACY(blit_flag1_w, 0xff00)
- AM_RANGE(0x2e0004, 0x2e0005) AM_WRITE8_LEGACY(blit_flipx_w, 0xff00) // flipx
- AM_RANGE(0x2e0006, 0x2e0007) AM_WRITE8_LEGACY(blit_flipy_w, 0xff00) // flipy
- AM_RANGE(0x2e0008, 0x2e0009) AM_WRITE8_LEGACY(blit_solid_w, 0xff00) // solid
- AM_RANGE(0x2e000a, 0x2e000b) AM_WRITE8_LEGACY(blit_trans_w, 0xff00) // transparency
- AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8_LEGACY(blit_flag6_w, 0xff00)
- AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8_LEGACY(blit_flag7_w, 0xff00)
+ AM_RANGE(0x2e0000, 0x2e0001) AM_WRITE8(blit_flag0_w, 0xff00)
+ AM_RANGE(0x2e0002, 0x2e0003) AM_WRITE8(blit_flag1_w, 0xff00)
+ AM_RANGE(0x2e0004, 0x2e0005) AM_WRITE8(blit_flipx_w, 0xff00) // flipx
+ AM_RANGE(0x2e0006, 0x2e0007) AM_WRITE8(blit_flipy_w, 0xff00) // flipy
+ AM_RANGE(0x2e0008, 0x2e0009) AM_WRITE8(blit_solid_w, 0xff00) // solid
+ AM_RANGE(0x2e000a, 0x2e000b) AM_WRITE8(blit_trans_w, 0xff00) // transparency
+ AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8(blit_flag6_w, 0xff00)
+ AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8(blit_flag7_w, 0xff00)
AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
- AM_RANGE(0x400000, 0x400001) AM_READ8_LEGACY(dualgame_mcu_status_write_r, 0x00ff)
- AM_RANGE(0x400002, 0x400003) AM_READ8_LEGACY(dualgame_mcu_status_read_r, 0x00ff)
+ AM_RANGE(0x400000, 0x400001) AM_READ8(dualgame_mcu_status_write_r, 0x00ff)
+ AM_RANGE(0x400002, 0x400003) AM_READ8(dualgame_mcu_status_read_r, 0x00ff)
- AM_RANGE(0x400004, 0x400005) AM_READWRITE8_LEGACY(dualgame_mcu1_r, dualgame_mcu1_w, 0x00ff)
- AM_RANGE(0x400006, 0x400007) AM_READWRITE8_LEGACY(dualgame_mcu2_r, dualgame_mcu2_w, 0xff00)
+ AM_RANGE(0x400004, 0x400005) AM_READWRITE8(dualgame_mcu1_r, dualgame_mcu1_w, 0x00ff)
+ AM_RANGE(0x400006, 0x400007) AM_READWRITE8(dualgame_mcu2_r, dualgame_mcu2_w, 0xff00)
AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r, address_w, 0xff00)
AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
@@ -1040,49 +1108,47 @@ ADDRESS_MAP_END
*************************************************************************************************************/
// MCU simulation (to be done)
-static READ16_HANDLER( hermit_mcu_r )
+READ16_MEMBER(blitz68k_state::hermit_mcu_r)
{
- UINT8 ret = 0x00; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0x00; // machine().rand() gives "interesting" results
+ logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
return ret << 8;
}
-static WRITE16_HANDLER( hermit_mcu_w )
+WRITE16_MEMBER(blitz68k_state::hermit_mcu_w)
{
- logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
+ logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
}
-static WRITE16_HANDLER( hermit_leds1_w )
+WRITE16_MEMBER(blitz68k_state::hermit_leds1_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[0]);
+ data = COMBINE_DATA(m_leds[0]);
if (ACCESSING_BITS_8_15)
{
- coin_counter_w(space->machine(), 0, data & 0x0100); // coin in
- show_leds12(state);
+ coin_counter_w(machine(), 0, data & 0x0100); // coin in
+ show_leds12();
}
}
-static WRITE16_HANDLER( hermit_leds2_w )
+WRITE16_MEMBER(blitz68k_state::hermit_leds2_w)
{
- blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
- data = COMBINE_DATA(state->m_leds[1]);
+ data = COMBINE_DATA(m_leds[1]);
if (ACCESSING_BITS_8_15)
{
- set_led_status(space->machine(), 7, data & 0x0100); // button
- show_leds12(state);
+ set_led_status(machine(), 7, data & 0x0100); // button
+ show_leds12();
}
}
-static READ16_HANDLER( hermit_track_r )
+READ16_MEMBER(blitz68k_state::hermit_track_r)
{
#ifdef MAME_DEBUG
-// popmessage("track %02x %02x", input_port_read(space->machine(), "TRACK_X"), input_port_read(space->machine(), "TRACK_Y"));
+// popmessage("track %02x %02x", input_port_read(machine(), "TRACK_X"), input_port_read(machine(), "TRACK_Y"));
#endif
return
- ((0xf - ((input_port_read(space->machine(), "TRACK_Y") + 0x7) & 0xf)) << 12) |
- ((0xf - ((input_port_read(space->machine(), "TRACK_X") + 0x7) & 0xf)) << 8) ;
+ ((0xf - ((input_port_read(machine(), "TRACK_Y") + 0x7) & 0xf)) << 12) |
+ ((0xf - ((input_port_read(machine(), "TRACK_X") + 0x7) & 0xf)) << 8) ;
}
static ADDRESS_MAP_START( hermit_map, AS_PROGRAM, 16, blitz68k_state )
@@ -1100,26 +1166,26 @@ static ADDRESS_MAP_START( hermit_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x840000, 0x840001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
- AM_RANGE(0x8c0000, 0x8c0003) AM_WRITE8_LEGACY(blit_pens_w, 0xffff )
+ AM_RANGE(0x8c0000, 0x8c0003) AM_WRITE8(blit_pens_w, 0xffff )
- AM_RANGE(0x940000, 0x940001) AM_READ_LEGACY(hermit_mcu_r )
- AM_RANGE(0x980000, 0x980001) AM_WRITE_LEGACY(hermit_mcu_w )
+ AM_RANGE(0x940000, 0x940001) AM_READ(hermit_mcu_r )
+ AM_RANGE(0x980000, 0x980001) AM_WRITE(hermit_mcu_w )
AM_RANGE(0x9c0000, 0x9c0001) AM_READ_PORT("IN0")
- AM_RANGE(0x9c8000, 0x9c8001) AM_READ_LEGACY(hermit_track_r )
+ AM_RANGE(0x9c8000, 0x9c8001) AM_READ(hermit_track_r )
AM_RANGE(0x9d0000, 0x9d0001) AM_READ_PORT("IN2")
AM_RANGE(0x9d8000, 0x9d8001) AM_READ_PORT("DSW")
- AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE_LEGACY(hermit_leds1_w) AM_BASE(m_leds[0])
- AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE_LEGACY(hermit_leds2_w) AM_BASE(m_leds[1])
+ AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE(hermit_leds1_w) AM_BASE(m_leds[0])
+ AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE(hermit_leds2_w) AM_BASE(m_leds[1])
- AM_RANGE(0x9f0000, 0x9f0003) AM_WRITE8_LEGACY(blit_flags_w, 0xffff) // flipx,y,solid,trans
+ AM_RANGE(0x9f0000, 0x9f0003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
AM_RANGE(0x9f0004, 0x9f0005) AM_WRITEONLY
AM_RANGE(0x9f0006, 0x9f0007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w) // 0x9f0006: 0->1, 0x9f0007: 1->0
- AM_RANGE(0xb00000, 0xb00001) AM_READWRITE8_LEGACY(crtc_r, crtc_w, 0xffff) // triggered by MCU?
+ AM_RANGE(0xb00000, 0xb00001) AM_READWRITE8(crtc_r, crtc_w, 0xffff) // triggered by MCU?
- AM_RANGE(0xc80000, 0xc80007) AM_WRITE8_LEGACY(blit_hwyxa_draw_w, 0xffff)
+ AM_RANGE(0xc80000, 0xc80007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
ADDRESS_MAP_END
/*************************************************************************************************************
@@ -1127,36 +1193,36 @@ ADDRESS_MAP_END
*************************************************************************************************************/
// MCU simulation (to be done)
-static READ8_HANDLER( maxidbl_mcu1_r )
+READ8_MEMBER(blitz68k_state::maxidbl_mcu1_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( maxidbl_mcu2_r )
+READ8_MEMBER(blitz68k_state::maxidbl_mcu2_r)
{
- UINT8 ret = 0; // space->machine().rand() gives "interesting" results
- logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
+ UINT8 ret = 0; // machine().rand() gives "interesting" results
+ logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
return ret;
}
-static READ8_HANDLER( maxidbl_mcu_status_read_r )
+READ8_MEMBER(blitz68k_state::maxidbl_mcu_status_read_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static READ8_HANDLER( maxidbl_mcu_status_write_r )
+READ8_MEMBER(blitz68k_state::maxidbl_mcu_status_write_r)
{
return 0x03; // bit 0 = MCU1, bit 1 = MCU2. Active high.
}
-static WRITE8_HANDLER( maxidbl_mcu1_w )
+WRITE8_MEMBER(blitz68k_state::maxidbl_mcu1_w)
{
- logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
}
-static WRITE8_HANDLER( maxidbl_mcu2_w )
+WRITE8_MEMBER(blitz68k_state::maxidbl_mcu2_w)
{
- logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
+ logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
}
static ADDRESS_MAP_START( maxidbl_map, AS_PROGRAM, 16, blitz68k_state )
@@ -1168,11 +1234,11 @@ static ADDRESS_MAP_START( maxidbl_map, AS_PROGRAM, 16, blitz68k_state )
AM_RANGE(0x30000c, 0x30000d) AM_WRITENOP // 0->1 (IRQ3 ack.?)
AM_RANGE(0x30000e, 0x30000f) AM_WRITENOP // 1->0 (MCU related?)
- AM_RANGE(0x500000, 0x500001) AM_READ8_LEGACY(maxidbl_mcu_status_write_r, 0x00ff)
- AM_RANGE(0x500002, 0x500003) AM_READ8_LEGACY(maxidbl_mcu_status_read_r, 0x00ff)
+ AM_RANGE(0x500000, 0x500001) AM_READ8(maxidbl_mcu_status_write_r, 0x00ff)
+ AM_RANGE(0x500002, 0x500003) AM_READ8(maxidbl_mcu_status_read_r, 0x00ff)
- AM_RANGE(0x500004, 0x500005) AM_READWRITE8_LEGACY(maxidbl_mcu1_r, maxidbl_mcu1_w, 0x00ff)
- AM_RANGE(0x500006, 0x500007) AM_READWRITE8_LEGACY(maxidbl_mcu2_r, maxidbl_mcu2_w, 0xff00)
+ AM_RANGE(0x500004, 0x500005) AM_READWRITE8(maxidbl_mcu1_r, maxidbl_mcu1_w, 0x00ff)
+ AM_RANGE(0x500006, 0x500007) AM_READWRITE8(maxidbl_mcu2_r, maxidbl_mcu2_w, 0xff00)
AM_RANGE(0x600000, 0x600001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r, address_w, 0xff00) // triggered by MCU?
AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
diff --git a/src/mame/drivers/cabaret.c b/src/mame/drivers/cabaret.c
index bb7d26bdc25..dc656915c03 100644
--- a/src/mame/drivers/cabaret.c
+++ b/src/mame/drivers/cabaret.c
@@ -40,6 +40,12 @@ public:
tilemap_t *m_fg_tilemap;
int m_nmi_enable;
UINT8 m_out[3];
+ DECLARE_WRITE8_MEMBER(bg_scroll_w);
+ DECLARE_WRITE8_MEMBER(bg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_color_w);
+ DECLARE_WRITE8_MEMBER(cabaret_nmi_and_coins_w);
+ void show_out();
};
@@ -51,18 +57,16 @@ public:
-static WRITE8_HANDLER( bg_scroll_w )
+WRITE8_MEMBER(cabaret_state::bg_scroll_w)
{
- cabaret_state *state = space->machine().driver_data<cabaret_state>();
- state->m_bg_scroll[offset] = data;
- state->m_bg_tilemap->set_scrolly(offset,data);
+ m_bg_scroll[offset] = data;
+ m_bg_tilemap->set_scrolly(offset,data);
}
-static WRITE8_HANDLER( bg_tile_w )
+WRITE8_MEMBER(cabaret_state::bg_tile_w)
{
- cabaret_state *state = space->machine().driver_data<cabaret_state>();
- state->m_bg_tile_ram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_bg_tile_ram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_bg_tile_info )
@@ -80,18 +84,16 @@ static TILE_GET_INFO( get_fg_tile_info )
SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
}
-static WRITE8_HANDLER( fg_tile_w )
+WRITE8_MEMBER(cabaret_state::fg_tile_w)
{
- cabaret_state *state = space->machine().driver_data<cabaret_state>();
- state->m_fg_tile_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_tile_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( fg_color_w )
+WRITE8_MEMBER(cabaret_state::fg_color_w)
{
- cabaret_state *state = space->machine().driver_data<cabaret_state>();
- state->m_fg_color_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_color_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(cabaret)
@@ -122,33 +124,32 @@ static SCREEN_UPDATE_IND16(cabaret)
-static void show_out(cabaret_state *state)
+void cabaret_state::show_out()
{
#ifdef MAME_DEBUG
- popmessage("%02x %02x %02x", state->m_out[0], state->m_out[1], state->m_out[2]);
+ popmessage("%02x %02x %02x",m_out[0], m_out[1], m_out[2]);
#endif
}
-static WRITE8_HANDLER( cabaret_nmi_and_coins_w )
+WRITE8_MEMBER(cabaret_state::cabaret_nmi_and_coins_w)
{
- cabaret_state *state = space->machine().driver_data<cabaret_state>();
- if ((state->m_nmi_enable ^ data) & (~0xdd))
+ if ((m_nmi_enable ^ data) & (~0xdd))
{
- logerror("PC %06X: nmi_and_coins = %02x\n",cpu_get_pc(&space->device()),data);
+ logerror("PC %06X: nmi_and_coins = %02x\n",cpu_get_pc(&space.device()),data);
// popmessage("%02x",data);
}
- coin_counter_w(space->machine(), 0, data & 0x01); // coin_a
- coin_counter_w(space->machine(), 1, data & 0x04); // coin_c
- coin_counter_w(space->machine(), 2, data & 0x08); // key in
- coin_counter_w(space->machine(), 3, data & 0x10); // coin state->m_out mech
+ coin_counter_w(machine(), 0, data & 0x01); // coin_a
+ coin_counter_w(machine(), 1, data & 0x04); // coin_c
+ coin_counter_w(machine(), 2, data & 0x08); // key in
+ coin_counter_w(machine(), 3, data & 0x10); // coin m_out mech
- set_led_status(space->machine(), 6, data & 0x40); // led for coin state->m_out / hopper active
+ set_led_status(machine(), 6, data & 0x40); // led for coin m_out / hopper active
- state->m_nmi_enable = data; // data & 0x80 // nmi enable?
+ m_nmi_enable = data; // data & 0x80 // nmi enable?
- state->m_out[0] = data;
- show_out(state);
+ m_out[0] = data;
+ show_out();
}
@@ -165,7 +166,7 @@ static ADDRESS_MAP_START( cabaret_portmap, AS_IO, 8, cabaret_state )
AM_RANGE( 0x0081, 0x0081 ) AM_READ_PORT( "SERVICE" )
AM_RANGE( 0x0082, 0x0082 ) AM_READ_PORT( "COINS" )
AM_RANGE( 0x0090, 0x0090 ) AM_READ_PORT( "BUTTONS1" )
- AM_RANGE( 0x00a0, 0x00a0 ) AM_WRITE_LEGACY(cabaret_nmi_and_coins_w )
+ AM_RANGE( 0x00a0, 0x00a0 ) AM_WRITE(cabaret_nmi_and_coins_w )
AM_RANGE( 0x00a1, 0x00a1 ) AM_READ_PORT("DSW1") /* DSW1 */
AM_RANGE( 0x00a2, 0x00a2 ) AM_READ_PORT("DSW2") /* DSW2 */
@@ -173,15 +174,15 @@ static ADDRESS_MAP_START( cabaret_portmap, AS_IO, 8, cabaret_state )
AM_RANGE( 0x00e0, 0x00e1 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w )
- AM_RANGE( 0x2000, 0x27ff ) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE( 0x2800, 0x2fff ) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE( 0x2000, 0x27ff ) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE( 0x2800, 0x2fff ) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
AM_RANGE( 0x3000, 0x37ff ) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split1_w ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x3800, 0x3fff ) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split2_w ) AM_BASE_GENERIC( paletteram2 )
- AM_RANGE( 0x1000, 0x103f ) AM_RAM_WRITE_LEGACY(bg_scroll_w ) AM_BASE(m_bg_scroll )
+ AM_RANGE( 0x1000, 0x103f ) AM_RAM_WRITE(bg_scroll_w ) AM_BASE(m_bg_scroll )
- AM_RANGE( 0x1800, 0x19ff ) AM_RAM_WRITE_LEGACY(bg_tile_w ) AM_BASE(m_bg_tile_ram )
+ AM_RANGE( 0x1800, 0x19ff ) AM_RAM_WRITE(bg_tile_w ) AM_BASE(m_bg_tile_ram )
AM_RANGE( 0x8000, 0xffff ) AM_ROM AM_REGION("gfx3", 0)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/cham24.c b/src/mame/drivers/cham24.c
index 5ddaeebd452..db5e6979b19 100644
--- a/src/mame/drivers/cham24.c
+++ b/src/mame/drivers/cham24.c
@@ -73,6 +73,13 @@ public:
UINT32 m_in_1;
UINT32 m_in_0_shift;
UINT32 m_in_1_shift;
+ DECLARE_WRITE8_MEMBER(nt_w);
+ DECLARE_READ8_MEMBER(nt_r);
+ DECLARE_WRITE8_MEMBER(sprite_dma_w);
+ DECLARE_READ8_MEMBER(cham24_IN0_r);
+ DECLARE_WRITE8_MEMBER(cham24_IN0_w);
+ DECLARE_READ8_MEMBER(cham24_IN1_r);
+ DECLARE_WRITE8_MEMBER(cham24_mapper_w);
};
@@ -110,26 +117,24 @@ static void cham24_set_mirroring( running_machine &machine, int mirroring )
}
}
-static WRITE8_HANDLER( nt_w )
+WRITE8_MEMBER(cham24_state::nt_w)
{
- cham24_state *state = space->machine().driver_data<cham24_state>();
int page = ((offset & 0xc00) >> 10);
- state->m_nt_page[page][offset & 0x3ff] = data;
+ m_nt_page[page][offset & 0x3ff] = data;
}
-static READ8_HANDLER( nt_r )
+READ8_MEMBER(cham24_state::nt_r)
{
- cham24_state *state = space->machine().driver_data<cham24_state>();
int page = ((offset & 0xc00) >> 10);
- return state->m_nt_page[page][offset & 0x3ff];
+ return m_nt_page[page][offset & 0x3ff];
}
-static WRITE8_HANDLER( sprite_dma_w )
+WRITE8_MEMBER(cham24_state::sprite_dma_w)
{
int source = (data & 7);
- ppu2c0x_device *ppu = space->machine().device<ppu2c0x_device>("ppu");
- ppu->spriteram_dma(space, source);
+ ppu2c0x_device *ppu = machine().device<ppu2c0x_device>("ppu");
+ ppu->spriteram_dma(&space, source);
}
static READ8_DEVICE_HANDLER( psg_4015_r )
@@ -148,15 +153,13 @@ static WRITE8_DEVICE_HANDLER( psg_4017_w )
}
-static READ8_HANDLER( cham24_IN0_r )
+READ8_MEMBER(cham24_state::cham24_IN0_r)
{
- cham24_state *state = space->machine().driver_data<cham24_state>();
- return ((state->m_in_0 >> state->m_in_0_shift++) & 0x01) | 0x40;
+ return ((m_in_0 >> m_in_0_shift++) & 0x01) | 0x40;
}
-static WRITE8_HANDLER( cham24_IN0_w )
+WRITE8_MEMBER(cham24_state::cham24_IN0_w)
{
- cham24_state *state = space->machine().driver_data<cham24_state>();
if (data & 0xfe)
{
//logerror("Unhandled cham24_IN0_w write: data = %02X\n", data);
@@ -167,21 +170,20 @@ static WRITE8_HANDLER( cham24_IN0_w )
return;
}
- state->m_in_0_shift = 0;
- state->m_in_1_shift = 0;
+ m_in_0_shift = 0;
+ m_in_1_shift = 0;
- state->m_in_0 = input_port_read(space->machine(), "P1");
- state->m_in_1 = input_port_read(space->machine(), "P2");
+ m_in_0 = input_port_read(machine(), "P1");
+ m_in_1 = input_port_read(machine(), "P2");
}
-static READ8_HANDLER( cham24_IN1_r )
+READ8_MEMBER(cham24_state::cham24_IN1_r)
{
- cham24_state *state = space->machine().driver_data<cham24_state>();
- return ((state->m_in_1 >> state->m_in_1_shift++) & 0x01) | 0x40;
+ return ((m_in_1 >> m_in_1_shift++) & 0x01) | 0x40;
}
-static WRITE8_HANDLER( cham24_mapper_w )
+WRITE8_MEMBER(cham24_state::cham24_mapper_w)
{
UINT32 gfx_bank = offset & 0x3f;
UINT32 prg_16k_bank_page = (offset >> 6) & 0x01;
@@ -189,14 +191,14 @@ static WRITE8_HANDLER( cham24_mapper_w )
UINT32 prg_bank_page_size = (offset >> 12) & 0x01;
UINT32 gfx_mirroring = (offset >> 13) & 0x01;
- UINT8* dst = space->machine().region("maincpu")->base();
- UINT8* src = space->machine().region("user1")->base();
+ UINT8* dst = machine().region("maincpu")->base();
+ UINT8* src = machine().region("user1")->base();
// switch PPU VROM bank
- memory_set_bankptr(space->machine(), "bank1", space->machine().region("gfx1")->base() + (0x2000 * gfx_bank));
+ memory_set_bankptr(machine(), "bank1", machine().region("gfx1")->base() + (0x2000 * gfx_bank));
// set gfx mirroring
- cham24_set_mirroring(space->machine(), gfx_mirroring != 0 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
+ cham24_set_mirroring(machine(), gfx_mirroring != 0 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
// switch PRG bank
if (prg_bank_page_size == 0)
@@ -225,11 +227,11 @@ static ADDRESS_MAP_START( cham24_map, AS_PROGRAM, 8, cham24_state )
AM_RANGE(0x0000, 0x07ff) AM_RAM /* NES RAM */
AM_RANGE(0x2000, 0x3fff) AM_DEVREADWRITE("ppu", ppu2c0x_device, read, write)
AM_RANGE(0x4000, 0x4013) AM_DEVREADWRITE_LEGACY("nes", nes_psg_r, nes_psg_w) /* PSG primary registers */
- AM_RANGE(0x4014, 0x4014) AM_WRITE_LEGACY(sprite_dma_w)
+ AM_RANGE(0x4014, 0x4014) AM_WRITE(sprite_dma_w)
AM_RANGE(0x4015, 0x4015) AM_DEVREADWRITE_LEGACY("nes", psg_4015_r, psg_4015_w) /* PSG status / first control register */
- AM_RANGE(0x4016, 0x4016) AM_READWRITE_LEGACY(cham24_IN0_r, cham24_IN0_w) /* IN0 - input port 1 */
- AM_RANGE(0x4017, 0x4017) AM_READ_LEGACY(cham24_IN1_r) AM_DEVWRITE_LEGACY("nes", psg_4017_w) /* IN1 - input port 2 / PSG second control register */
- AM_RANGE(0x8000, 0xffff) AM_ROM AM_WRITE_LEGACY(cham24_mapper_w)
+ AM_RANGE(0x4016, 0x4016) AM_READWRITE(cham24_IN0_r, cham24_IN0_w) /* IN0 - input port 1 */
+ AM_RANGE(0x4017, 0x4017) AM_READ(cham24_IN1_r) AM_DEVWRITE_LEGACY("nes", psg_4017_w) /* IN1 - input port 2 / PSG second control register */
+ AM_RANGE(0x8000, 0xffff) AM_ROM AM_WRITE(cham24_mapper_w)
ADDRESS_MAP_END
static INPUT_PORTS_START( cham24 )
@@ -320,7 +322,7 @@ static MACHINE_START( cham24 )
state->m_nt_page[3] = state->m_nt_ram + 0xc00;
/* and read/write handlers */
- machine.device("ppu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x2000, 0x3eff, FUNC(nt_r), FUNC(nt_w));
+ machine.device("ppu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0x2000, 0x3eff,read8_delegate(FUNC(cham24_state::nt_r), state), write8_delegate(FUNC(cham24_state::nt_w), state));
}
static DRIVER_INIT( cham24 )
diff --git a/src/mame/drivers/coolridr.c b/src/mame/drivers/coolridr.c
index 363db1e2e67..191d57db53f 100644
--- a/src/mame/drivers/coolridr.c
+++ b/src/mame/drivers/coolridr.c
@@ -297,6 +297,16 @@ public:
required_device<cpu_device> m_maincpu;
required_device<cpu_device> m_subcpu;
required_device<cpu_device> m_soundcpu;
+ DECLARE_READ32_MEMBER(sysh1_unk_r);
+ DECLARE_WRITE32_MEMBER(sysh1_unk_w);
+ DECLARE_READ32_MEMBER(sysh1_ioga_r);
+ DECLARE_WRITE32_MEMBER(sysh1_ioga_w);
+ DECLARE_WRITE32_MEMBER(sysh1_txt_blit_w);
+ DECLARE_WRITE32_MEMBER(sysh1_pal_w);
+ DECLARE_WRITE32_MEMBER(sysh1_dma_w);
+ DECLARE_WRITE32_MEMBER(sysh1_char_w);
+ DECLARE_READ32_MEMBER(coolridr_hack1_r);
+ DECLARE_READ32_MEMBER(coolridr_hack2_r);
};
@@ -376,41 +386,39 @@ static SCREEN_UPDATE_RGB32(coolridr)
/* end video */
/* unknown purpose */
-static READ32_HANDLER(sysh1_unk_r)
+READ32_MEMBER(coolridr_state::sysh1_unk_r)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
switch(offset)
{
case 0x08/4:
{
- state->m_vblank^=1;
+ m_vblank^=1;
- return (state->m_h1_unk[offset] & 0xfdffffff) | (state->m_vblank<<25);
+ return (m_h1_unk[offset] & 0xfdffffff) | (m_vblank<<25);
}
case 0x14/4:
- return state->m_h1_unk[offset];
+ return m_h1_unk[offset];
//case 0x20/4:
}
- return 0xffffffff;//state->m_h1_unk[offset];
+ return 0xffffffff;//m_h1_unk[offset];
}
-static WRITE32_HANDLER(sysh1_unk_w)
+WRITE32_MEMBER(coolridr_state::sysh1_unk_w)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- COMBINE_DATA(&state->m_h1_unk[offset]);
+ COMBINE_DATA(&m_h1_unk[offset]);
}
/* According to Guru, this is actually the same I/O chip of Sega Model 2 HW */
#if 0
-static READ32_HANDLER(sysh1_ioga_r)
+READ32_MEMBER(coolridr_state::sysh1_ioga_r)
{
- //return space->machine().rand();//h1_ioga[offset];
+ //return machine().rand();//h1_ioga[offset];
return h1_ioga[offset];
}
-static WRITE32_HANDLER(sysh1_ioga_w)
+WRITE32_MEMBER(coolridr_state::sysh1_ioga_w)
{
COMBINE_DATA(&h1_ioga[offset]);
}
@@ -418,41 +426,40 @@ static WRITE32_HANDLER(sysh1_ioga_w)
/* This is a RLE-based sprite blitter (US Patent #6,141,122), very unusual from Sega... */
-static WRITE32_HANDLER( sysh1_txt_blit_w )
+WRITE32_MEMBER(coolridr_state::sysh1_txt_blit_w)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- COMBINE_DATA(&state->m_sysh1_txt_blit[offset]);
+ COMBINE_DATA(&m_sysh1_txt_blit[offset]);
switch(offset)
{
// The mode register
case 0x04:
{
- state->m_blitterMode = (data & 0x00ff0000) >> 16;
+ m_blitterMode = (data & 0x00ff0000) >> 16;
- if (state->m_blitterMode == 0xf4)
+ if (m_blitterMode == 0xf4)
{
// Some sort of addressing state.
// In the case of text, simply writes 4 characters per 32-bit word.
// These values may be loaded into RAM somewhere as they are written.
// The number of characters is determined by the upper-most 8 bits.
- state->m_textBytesToWrite = (data & 0xff000000) >> 24;
- state->m_textOffset = (data & 0x0000ffff);
- state->m_blitterSerialCount = 0;
+ m_textBytesToWrite = (data & 0xff000000) >> 24;
+ m_textOffset = (data & 0x0000ffff);
+ m_blitterSerialCount = 0;
}
- else if (state->m_blitterMode == 0x30 || state->m_blitterMode == 0x90)
+ else if (m_blitterMode == 0x30 || m_blitterMode == 0x90)
{
// The blitter function(s).
// After this is set a fixed count of 11 32-bit words are sent to the data register.
// The lower word always seems to be 0x0001 and the upper byte always 0xac.
- state->m_blitterSerialCount = 0;
+ m_blitterSerialCount = 0;
}
- else if (state->m_blitterMode == 0x10)
+ else if (m_blitterMode == 0x10)
{
// Could be a full clear of VRAM?
for(UINT32 vramAddr = 0x3f40000; vramAddr < 0x3f4ffff; vramAddr+=4)
- space->write_dword(vramAddr, 0x00000000);
+ space.write_dword(vramAddr, 0x00000000);
}
break;
}
@@ -460,22 +467,22 @@ static WRITE32_HANDLER( sysh1_txt_blit_w )
// The data register
case 0x05:
{
- if (state->m_blitterMode == 0xf4)
+ if (m_blitterMode == 0xf4)
{
// Uploads a series of bytes that index into the encoded sprite table
- const size_t memOffset = 0x03f40000 + state->m_textOffset + state->m_blitterSerialCount;
- space->write_dword(memOffset, data);
- state->m_blitterSerialCount += 0x04;
+ const size_t memOffset = 0x03f40000 + m_textOffset + m_blitterSerialCount;
+ space.write_dword(memOffset, data);
+ m_blitterSerialCount += 0x04;
// DEBUG: Uncomment to see the ASCII strings as they are being blitted
- //if (state->m_blitterSerialCount >= state->m_textBytesToWrite)
+ //if (m_blitterSerialCount >= m_textBytesToWrite)
//{
- // for (int i = 0; i < state->m_textBytesToWrite+1; i++)
- // printf("%c", space->read_byte(0x03f40000 + state->m_textOffset + i));
+ // for (int i = 0; i < m_textBytesToWrite+1; i++)
+ // printf("%c", read_byte(0x03f40000 + m_textOffset + i));
// printf("\n");
//}
}
- else if (state->m_blitterMode == 0x30 || state->m_blitterMode == 0x90)
+ else if (m_blitterMode == 0x30 || m_blitterMode == 0x90)
{
// Serialized 32-bit words in order of appearance:
// 0: 00000000 - totally unknown : always seems to be zero
@@ -495,37 +502,37 @@ static WRITE32_HANDLER( sysh1_txt_blit_w )
// (See ifdef'ed out code below for a closer examination)
// Serialized counts
- if (state->m_blitterSerialCount == 1)
+ if (m_blitterSerialCount == 1)
{
- state->m_colorNumber = (data & 0x000000ff); // Probably more bits
+ m_colorNumber = (data & 0x000000ff); // Probably more bits
}
- else if (state->m_blitterSerialCount == 6)
+ else if (m_blitterSerialCount == 6)
{
- state->m_vCellCount = (data & 0xffff0000) >> 16;
- state->m_hCellCount = (data & 0x0000ffff);
+ m_vCellCount = (data & 0xffff0000) >> 16;
+ m_hCellCount = (data & 0x0000ffff);
}
- else if (state->m_blitterSerialCount == 9)
+ else if (m_blitterSerialCount == 9)
{
- state->m_vPosition = (data & 0xffff0000) >> 16;
- state->m_hPosition = (data & 0x0000ffff);
+ m_vPosition = (data & 0xffff0000) >> 16;
+ m_hPosition = (data & 0x0000ffff);
}
- else if (state->m_blitterSerialCount == 11)
+ else if (m_blitterSerialCount == 11)
{
const UINT32 memOffset = data;
// Splat some sprites
- for (int h = 0; h < state->m_hCellCount; h++)
+ for (int h = 0; h < m_hCellCount; h++)
{
- for (int v = 0; v < state->m_vCellCount; v++)
+ for (int v = 0; v < m_vCellCount; v++)
{
- const int pixelOffsetX = state->m_hPosition + (h*16);
- const int pixelOffsetY = state->m_vPosition + (v*16);
+ const int pixelOffsetX = m_hPosition + (h*16);
+ const int pixelOffsetY = m_vPosition + (v*16);
// It's unknown if it's row-major or column-major
// TODO: Study the CRT test and "Cool Riders" logo for clues.
- UINT8 spriteNumber = space->read_byte(memOffset + h + (v*h));
+ UINT8 spriteNumber = space.read_byte(memOffset + h + (v*h));
- // DEBUG: For demo purposes, skip spaces and NULL characters
+ // DEBUG: For demo purposes, skip &spaces and NULL characters
if (spriteNumber == 0x20 || spriteNumber == 0x00)
continue;
@@ -535,22 +542,22 @@ static WRITE32_HANDLER( sysh1_txt_blit_w )
for (int y = 1; y < 15; y++)
{
UINT32 color;
- if (state->m_colorNumber == 0x5b)
+ if (m_colorNumber == 0x5b)
color = 0xffff0000;
- else if (state->m_colorNumber == 0x5d)
+ else if (m_colorNumber == 0x5d)
color = 0xff00ff00;
- else if (state->m_colorNumber == 0x5e)
+ else if (m_colorNumber == 0x5e)
color = 0xff0000ff;
else
color = 0xff00ffff;
- state->m_temp_bitmap_sprites.pix32(pixelOffsetY+y, pixelOffsetX+x) = color;
+ m_temp_bitmap_sprites.pix32(pixelOffsetY+y, pixelOffsetX+x) = color;
}
}
}
}
}
- state->m_blitterSerialCount++;
+ m_blitterSerialCount++;
}
break;
}
@@ -558,19 +565,19 @@ static WRITE32_HANDLER( sysh1_txt_blit_w )
}
-static WRITE32_HANDLER( sysh1_pal_w )
+WRITE32_MEMBER(coolridr_state::sysh1_pal_w)
{
int r,g,b;
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
-
- r = ((space->machine().generic.paletteram.u32[offset] & 0x00007c00) >> 10);
- g = ((space->machine().generic.paletteram.u32[offset] & 0x000003e0) >> 5);
- b = ((space->machine().generic.paletteram.u32[offset] & 0x0000001f) >> 0);
- palette_set_color_rgb(space->machine(),(offset*2)+1,pal5bit(r),pal5bit(g),pal5bit(b));
- r = ((space->machine().generic.paletteram.u32[offset] & 0x7c000000) >> 26);
- g = ((space->machine().generic.paletteram.u32[offset] & 0x03e00000) >> 21);
- b = ((space->machine().generic.paletteram.u32[offset] & 0x001f0000) >> 16);
- palette_set_color_rgb(space->machine(),offset*2,pal5bit(r),pal5bit(g),pal5bit(b));
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
+
+ r = ((machine().generic.paletteram.u32[offset] & 0x00007c00) >> 10);
+ g = ((machine().generic.paletteram.u32[offset] & 0x000003e0) >> 5);
+ b = ((machine().generic.paletteram.u32[offset] & 0x0000001f) >> 0);
+ palette_set_color_rgb(machine(),(offset*2)+1,pal5bit(r),pal5bit(g),pal5bit(b));
+ r = ((machine().generic.paletteram.u32[offset] & 0x7c000000) >> 26);
+ g = ((machine().generic.paletteram.u32[offset] & 0x03e00000) >> 21);
+ b = ((machine().generic.paletteram.u32[offset] & 0x001f0000) >> 16);
+ palette_set_color_rgb(machine(),offset*2,pal5bit(r),pal5bit(g),pal5bit(b));
}
@@ -651,32 +658,30 @@ static void sysh1_dma_transfer( address_space *space, UINT16 dma_index )
}while(!end_dma_mark );
}
-static WRITE32_HANDLER( sysh1_dma_w )
+WRITE32_MEMBER(coolridr_state::sysh1_dma_w)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- COMBINE_DATA(&state->m_framebuffer_vram[offset]);
+ COMBINE_DATA(&m_framebuffer_vram[offset]);
if(offset*4 == 0x000)
{
- if((state->m_framebuffer_vram[offset] & 0xff00000) == 0xfe00000)
- sysh1_dma_transfer(space, state->m_framebuffer_vram[offset] & 0xffff);
+ if((m_framebuffer_vram[offset] & 0xff00000) == 0xfe00000)
+ sysh1_dma_transfer(&space, m_framebuffer_vram[offset] & 0xffff);
}
}
-static WRITE32_HANDLER( sysh1_char_w )
+WRITE32_MEMBER(coolridr_state::sysh1_char_w)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- COMBINE_DATA(&state->m_h1_charram[offset]);
+ COMBINE_DATA(&m_h1_charram[offset]);
{
- UINT8 *gfx = space->machine().region("ram_gfx")->base();
+ UINT8 *gfx = machine().region("ram_gfx")->base();
- gfx[offset*4+0] = (state->m_h1_charram[offset] & 0xff000000) >> 24;
- gfx[offset*4+1] = (state->m_h1_charram[offset] & 0x00ff0000) >> 16;
- gfx[offset*4+2] = (state->m_h1_charram[offset] & 0x0000ff00) >> 8;
- gfx[offset*4+3] = (state->m_h1_charram[offset] & 0x000000ff) >> 0;
+ gfx[offset*4+0] = (m_h1_charram[offset] & 0xff000000) >> 24;
+ gfx[offset*4+1] = (m_h1_charram[offset] & 0x00ff0000) >> 16;
+ gfx[offset*4+2] = (m_h1_charram[offset] & 0x0000ff00) >> 8;
+ gfx[offset*4+3] = (m_h1_charram[offset] & 0x000000ff) >> 0;
- gfx_element_mark_dirty(space->machine().gfx[2], offset/64); //*4/256
+ gfx_element_mark_dirty(machine().gfx[2], offset/64); //*4/256
}
}
@@ -685,13 +690,13 @@ static ADDRESS_MAP_START( system_h1_map, AS_PROGRAM, 32, coolridr_state )
AM_RANGE(0x01000000, 0x01ffffff) AM_ROM AM_REGION("gfx_data",0x0000000)
AM_RANGE(0x03000000, 0x030fffff) AM_RAM AM_BASE(m_h1_vram)//bg vram
- AM_RANGE(0x03c00000, 0x03c0ffff) AM_RAM_WRITE_LEGACY(sysh1_pal_w) AM_BASE_GENERIC(paletteram)
- AM_RANGE(0x03d00000, 0x03dfffff) AM_RAM_WRITE_LEGACY(sysh1_char_w) AM_BASE(m_h1_charram) //FIXME: half size
- AM_RANGE(0x03e00000, 0x03efffff) AM_RAM_WRITE_LEGACY(sysh1_dma_w) AM_BASE(m_framebuffer_vram) //FIXME: not all of it
+ AM_RANGE(0x03c00000, 0x03c0ffff) AM_RAM_WRITE(sysh1_pal_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x03d00000, 0x03dfffff) AM_RAM_WRITE(sysh1_char_w) AM_BASE(m_h1_charram) //FIXME: half size
+ AM_RANGE(0x03e00000, 0x03efffff) AM_RAM_WRITE(sysh1_dma_w) AM_BASE(m_framebuffer_vram) //FIXME: not all of it
AM_RANGE(0x03f00000, 0x03f0ffff) AM_RAM AM_SHARE("share3") /*Communication area RAM*/
AM_RANGE(0x03f40000, 0x03f4ffff) AM_RAM AM_BASE(m_txt_vram)//text tilemap + "lineram"
- AM_RANGE(0x04000000, 0x0400003f) AM_RAM_WRITE_LEGACY(sysh1_txt_blit_w) AM_BASE(m_sysh1_txt_blit)
+ AM_RANGE(0x04000000, 0x0400003f) AM_RAM_WRITE(sysh1_txt_blit_w) AM_BASE(m_sysh1_txt_blit)
AM_RANGE(0x06000000, 0x060fffff) AM_RAM AM_BASE(m_sysh1_workram_h)
AM_RANGE(0x20000000, 0x201fffff) AM_ROM AM_SHARE("share1")
@@ -710,7 +715,7 @@ static ADDRESS_MAP_START( coolridr_submap, AS_PROGRAM, 32, coolridr_state )
AM_RANGE(0x03208900, 0x03208903) AM_RAM /*???*/
AM_RANGE(0x03300400, 0x03300403) AM_RAM /*irq enable?*/
- AM_RANGE(0x04000000, 0x0400003f) AM_READWRITE_LEGACY(sysh1_unk_r,sysh1_unk_w) AM_BASE(m_h1_unk)
+ AM_RANGE(0x04000000, 0x0400003f) AM_READWRITE(sysh1_unk_r,sysh1_unk_w) AM_BASE(m_h1_unk)
AM_RANGE(0x04200000, 0x0420003f) AM_RAM /*???*/
AM_RANGE(0x05000000, 0x05000fff) AM_RAM
@@ -1215,32 +1220,31 @@ ROM_START( coolridr )
ROM_END
#if 0
-static READ32_HANDLER( coolridr_hack1_r )
+READ32_MEMBER(coolridr_state::coolridr_hack1_r)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- offs_t pc = downcast<cpu_device *>(&space->device())->pc();
+ offs_t pc = downcast<cpu_device *>(&space.device())->pc();
if(pc == 0x6012374 || pc == 0x6012392)
return 0;
- return state->m_sysh1_workram_h[0xd88a4/4];
+ return m_sysh1_workram_h[0xd88a4/4];
}
#endif
/*TODO: there must be an irq line with custom vector located somewhere that writes to here...*/
-static READ32_HANDLER( coolridr_hack2_r )
+READ32_MEMBER(coolridr_state::coolridr_hack2_r)
{
- coolridr_state *state = space->machine().driver_data<coolridr_state>();
- offs_t pc = downcast<cpu_device *>(&space->device())->pc();
+ offs_t pc = downcast<cpu_device *>(&space.device())->pc();
if(pc == 0x6002cba || pc == 0x6002d42)
return 0;
- return state->m_sysh1_workram_h[0xd8894/4];
+ return m_sysh1_workram_h[0xd8894/4];
}
static DRIVER_INIT( coolridr )
{
+ coolridr_state *state = machine.driver_data<coolridr_state>();
// machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d88a4, 0x060d88a7, FUNC(coolridr_hack1_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d8894, 0x060d8897, FUNC(coolridr_hack2_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x60d8894, 0x060d8897, read32_delegate(FUNC(coolridr_state::coolridr_hack2_r), state));
}
GAME( 1995, coolridr, 0, coolridr, coolridr, coolridr, ROT0, "Sega", "Cool Riders (US)",GAME_NOT_WORKING|GAME_NO_SOUND )
diff --git a/src/mame/drivers/corona.c b/src/mame/drivers/corona.c
index a028e873945..e3b5e9005f2 100644
--- a/src/mame/drivers/corona.c
+++ b/src/mame/drivers/corona.c
@@ -331,6 +331,19 @@ public:
UINT8 m_lamp;
UINT8 m_lamp_old;
int m_input_selector;
+ DECLARE_WRITE8_MEMBER(blitter_y_w);
+ DECLARE_WRITE8_MEMBER(blitter_unk_w);
+ DECLARE_WRITE8_MEMBER(blitter_x_w);
+ DECLARE_WRITE8_MEMBER(blitter_aux_w);
+ DECLARE_READ8_MEMBER(blitter_status_r);
+ DECLARE_WRITE8_MEMBER(blitter_trig_wdht_w);
+ DECLARE_WRITE8_MEMBER(sound_latch_w);
+ DECLARE_READ8_MEMBER(sound_latch_r);
+ DECLARE_WRITE8_MEMBER(ball_w);
+ DECLARE_READ8_MEMBER(mux_port_r);
+ DECLARE_WRITE8_MEMBER(mux_port_w);
+ DECLARE_WRITE8_MEMBER(wc_meters_w);
+ void blitter_execute(int x, int y, int color, int width, int flag);
};
@@ -365,43 +378,39 @@ static PALETTE_INIT( winner )
}
}
-static WRITE8_HANDLER( blitter_y_w )
+WRITE8_MEMBER(corona_state::blitter_y_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- state->m_blitter_y_reg = data;
+ m_blitter_y_reg = data;
}
-static WRITE8_HANDLER( blitter_unk_w )
+WRITE8_MEMBER(corona_state::blitter_unk_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- state->m_blitter_unk_reg = data;
+ m_blitter_unk_reg = data;
}
-static WRITE8_HANDLER( blitter_x_w )
+WRITE8_MEMBER(corona_state::blitter_x_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- state->m_blitter_x_reg = data;
+ m_blitter_x_reg = data;
}
-static WRITE8_HANDLER( blitter_aux_w )
+WRITE8_MEMBER(corona_state::blitter_aux_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- state->m_blitter_aux_reg = data;
+ m_blitter_aux_reg = data;
}
-static READ8_HANDLER( blitter_status_r )
+READ8_MEMBER(corona_state::blitter_status_r)
{
/* code checks bit 6 and/or bit 7 */
- //return space->machine().rand() & 0xc0;
+ //return machine().rand() & 0xc0;
/*
x--- ---- blitter busy
-x-- ---- vblank
*/
- return 0x80 | ((space->machine().primary_screen->vblank() & 1) << 6);
+ return 0x80 | ((machine().primary_screen->vblank() & 1) << 6);
}
-static void blitter_execute(corona_state *state, int x, int y, int color, int width, int flag)
+void corona_state::blitter_execute(int x, int y, int color, int width, int flag)
{
int i;
int xdir = (flag & 0x10) ? -1 : 1;
@@ -419,7 +428,7 @@ static void blitter_execute(corona_state *state, int x, int y, int color, int wi
for(yp = 0; yp < 0x100; yp++)
for(xp = 0; xp < 0x100; xp++)
- state->m_videobuf[(yp & 0x1ff) * 512 + (xp & 0x1ff)] = color;
+ m_videobuf[(yp & 0x1ff) * 512 + (xp & 0x1ff)] = color;
}
else /* line shape */
{
@@ -427,7 +436,7 @@ static void blitter_execute(corona_state *state, int x, int y, int color, int wi
for(i = 0; i < width; i++)
{
- state->m_videobuf[(y & 0x1ff) * 512 + (x & 0x1ff)] = color;
+ m_videobuf[(y & 0x1ff) * 512 + (x & 0x1ff)] = color;
if(flag & 0x40) { x+=xdir; }
if(flag & 0x80) { y+=ydir; }
@@ -435,10 +444,9 @@ static void blitter_execute(corona_state *state, int x, int y, int color, int wi
}
}
-static WRITE8_HANDLER( blitter_trig_wdht_w)
+WRITE8_MEMBER(corona_state::blitter_trig_wdht_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- blitter_execute(state, state->m_blitter_x_reg, 0x100 - state->m_blitter_y_reg, state->m_blitter_aux_reg & 0xf, data, state->m_blitter_aux_reg & 0xf0);
+ blitter_execute(m_blitter_x_reg, 0x100 - m_blitter_y_reg, m_blitter_aux_reg & 0xf, data, m_blitter_aux_reg & 0xf0);
}
static VIDEO_START(winner)
@@ -476,52 +484,49 @@ static SCREEN_UPDATE_IND16(luckyrlt)
* Read & Write Handlers *
*******************************************/
-static WRITE8_HANDLER( sound_latch_w )
+WRITE8_MEMBER(corona_state::sound_latch_w)
{
soundlatch_w(space, 0, data & 0xff);
- cputag_set_input_line(space->machine(), "soundcpu", 0, ASSERT_LINE);
+ cputag_set_input_line(machine(), "soundcpu", 0, ASSERT_LINE);
}
-static READ8_HANDLER( sound_latch_r )
+READ8_MEMBER(corona_state::sound_latch_r)
{
- cputag_set_input_line(space->machine(), "soundcpu", 0, CLEAR_LINE);
+ cputag_set_input_line(machine(), "soundcpu", 0, CLEAR_LINE);
return soundlatch_r(space, 0);
}
-static WRITE8_HANDLER( ball_w )
+WRITE8_MEMBER(corona_state::ball_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- state->m_lamp = data;
+ m_lamp = data;
output_set_lamp_value(data, 1);
- output_set_lamp_value(state->m_lamp_old, 0);
- state->m_lamp_old = state->m_lamp;
+ output_set_lamp_value(m_lamp_old, 0);
+ m_lamp_old = m_lamp;
}
/******** Multiplexed Inputs ********/
-static READ8_HANDLER( mux_port_r )
+READ8_MEMBER(corona_state::mux_port_r)
{
- corona_state *state = space->machine().driver_data<corona_state>();
- switch( state->m_input_selector )
+ switch( m_input_selector )
{
- case 0x01: return input_port_read(space->machine(), "IN0-1");
- case 0x02: return input_port_read(space->machine(), "IN0-2");
- case 0x04: return input_port_read(space->machine(), "IN0-3");
- case 0x08: return input_port_read(space->machine(), "IN0-4");
- case 0x10: return input_port_read(space->machine(), "IN0-5");
- case 0x20: return input_port_read(space->machine(), "IN0-6");
+ case 0x01: return input_port_read(machine(), "IN0-1");
+ case 0x02: return input_port_read(machine(), "IN0-2");
+ case 0x04: return input_port_read(machine(), "IN0-3");
+ case 0x08: return input_port_read(machine(), "IN0-4");
+ case 0x10: return input_port_read(machine(), "IN0-5");
+ case 0x20: return input_port_read(machine(), "IN0-6");
}
return 0xff;
}
-static WRITE8_HANDLER( mux_port_w )
+WRITE8_MEMBER(corona_state::mux_port_w)
{
- corona_state *state = space->machine().driver_data<corona_state>();
/* - bits -
7654 3210
--xx xxxx Input selector.
@@ -531,15 +536,15 @@ static WRITE8_HANDLER( mux_port_w )
Data is written inverted.
*/
- state->m_input_selector = (data ^ 0xff) & 0x3f; /* Input Selector, */
+ m_input_selector = (data ^ 0xff) & 0x3f; /* Input Selector, */
- coin_counter_w(space->machine(), 0, (data ^ 0xff) & 0x40); /* Credits In (mechanical meters) */
- coin_counter_w(space->machine(), 1, (data ^ 0xff) & 0x80); /* Credits Out (mechanical meters) */
+ coin_counter_w(machine(), 0, (data ^ 0xff) & 0x40); /* Credits In (mechanical meters) */
+ coin_counter_w(machine(), 1, (data ^ 0xff) & 0x80); /* Credits Out (mechanical meters) */
-// logerror("muxsel: %02x \n", state->m_input_selector);
+// logerror("muxsel: %02x \n", m_input_selector);
}
-static WRITE8_HANDLER( wc_meters_w )
+WRITE8_MEMBER(corona_state::wc_meters_w)
{
/* - bits -
7654 3210
@@ -552,9 +557,9 @@ static WRITE8_HANDLER( wc_meters_w )
Data is written inverted.
*/
- coin_counter_w(space->machine(), 0, (data ^ 0xff) & 0x01); /* Credits In */
- coin_counter_w(space->machine(), 1, (data ^ 0xff) & 0x02); /* Credits In (through Coin 3) */
- coin_counter_w(space->machine(), 2, (data ^ 0xff) & 0x04); /* Credits Out */
+ coin_counter_w(machine(), 0, (data ^ 0xff) & 0x01); /* Credits In */
+ coin_counter_w(machine(), 1, (data ^ 0xff) & 0x02); /* Credits In (through Coin 3) */
+ coin_counter_w(machine(), 2, (data ^ 0xff) & 0x04); /* Credits Out */
// popmessage("meters: %02x", (data ^ 0xff));
}
@@ -605,15 +610,15 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( winner81_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x70, 0x70) AM_WRITE_LEGACY(blitter_x_w)
- AM_RANGE(0x71, 0x71) AM_WRITE_LEGACY(blitter_unk_w)
- AM_RANGE(0x72, 0x72) AM_WRITE_LEGACY(blitter_trig_wdht_w)
- AM_RANGE(0x74, 0x74) AM_WRITE_LEGACY(blitter_y_w)
- AM_RANGE(0x75, 0x75) AM_READ_LEGACY(blitter_status_r)
- AM_RANGE(0x76, 0x76) AM_WRITE_LEGACY(blitter_aux_w)
+ AM_RANGE(0x70, 0x70) AM_WRITE(blitter_x_w)
+ AM_RANGE(0x71, 0x71) AM_WRITE(blitter_unk_w)
+ AM_RANGE(0x72, 0x72) AM_WRITE(blitter_trig_wdht_w)
+ AM_RANGE(0x74, 0x74) AM_WRITE(blitter_y_w)
+ AM_RANGE(0x75, 0x75) AM_READ(blitter_status_r)
+ AM_RANGE(0x76, 0x76) AM_WRITE(blitter_aux_w)
AM_RANGE(0xd8, 0xd8) AM_WRITENOP /* dunno, but is writing 0's very often */
- AM_RANGE(0xdf, 0xdf) AM_WRITE_LEGACY(sound_latch_w)
+ AM_RANGE(0xdf, 0xdf) AM_WRITE(sound_latch_w)
AM_RANGE(0xe8, 0xe8) AM_READ_PORT("IN0") /* credits for players A, B, C, D */
AM_RANGE(0xe9, 0xe9) AM_READ_PORT("IN3")
@@ -622,7 +627,7 @@ static ADDRESS_MAP_START( winner81_cpu_io_map, AS_IO, 8, corona_state )
AM_RANGE(0xec, 0xec) AM_READ_PORT("IN4")
AM_RANGE(0xed, 0xed) AM_READ_PORT("DSW1") /* DIP switches bank 1 */
AM_RANGE(0xee, 0xee) AM_READ_PORT("DSW2")
- AM_RANGE(0xef, 0xef) AM_WRITE_LEGACY(wc_meters_w) /* meters: coin1 = bit0, coin2 = bit1, coinout = bit2 */
+ AM_RANGE(0xef, 0xef) AM_WRITE(wc_meters_w) /* meters: coin1 = bit0, coin2 = bit1, coinout = bit2 */
ADDRESS_MAP_END
static ADDRESS_MAP_START( winner81_sound_map, AS_PROGRAM, 8, corona_state )
@@ -632,7 +637,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( winner81_sound_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00, 0x00) AM_READ_LEGACY(sound_latch_r)
+ AM_RANGE(0x00, 0x00) AM_READ(sound_latch_r)
AM_RANGE(0x00, 0x01) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
ADDRESS_MAP_END
@@ -662,20 +667,20 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( winner82_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0xf0, 0xf0) AM_WRITE_LEGACY(blitter_x_w)
- AM_RANGE(0xf1, 0xf1) AM_WRITE_LEGACY(blitter_y_w)
- AM_RANGE(0xf2, 0xf2) AM_WRITE_LEGACY(blitter_trig_wdht_w)
- AM_RANGE(0xf3, 0xf3) AM_WRITE_LEGACY(blitter_aux_w)
- AM_RANGE(0xf4, 0xf4) AM_WRITE_LEGACY(blitter_unk_w)
- AM_RANGE(0xf5, 0xf5) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0xf0, 0xf0) AM_WRITE(blitter_x_w)
+ AM_RANGE(0xf1, 0xf1) AM_WRITE(blitter_y_w)
+ AM_RANGE(0xf2, 0xf2) AM_WRITE(blitter_trig_wdht_w)
+ AM_RANGE(0xf3, 0xf3) AM_WRITE(blitter_aux_w)
+ AM_RANGE(0xf4, 0xf4) AM_WRITE(blitter_unk_w)
+ AM_RANGE(0xf5, 0xf5) AM_READ(blitter_status_r)
AM_RANGE(0xf8, 0xf8) AM_READ_PORT("DSW1") /* coinage DIP SW */
AM_RANGE(0xf9, 0xf9) AM_READ_PORT("IN0") /* controls for players A & B */
AM_RANGE(0xfa, 0xfa) AM_READ_PORT("IN1") /* credits for players A, B, C, D */
AM_RANGE(0xfb, 0xfb) AM_READ_PORT("IN3") /* single credits for players A, B, C, D, + fix bits 3, 4, 5, 6 in meters */
- AM_RANGE(0xfc, 0xfc) AM_WRITE_LEGACY(wc_meters_w)
+ AM_RANGE(0xfc, 0xfc) AM_WRITE(wc_meters_w)
AM_RANGE(0xfd, 0xfd) AM_READ_PORT("IN2") /* controls for players C & D */
- AM_RANGE(0xfe, 0xfe) AM_WRITE_LEGACY(sound_latch_w)
+ AM_RANGE(0xfe, 0xfe) AM_WRITE(sound_latch_w)
AM_RANGE(0xff, 0xff) AM_READ_PORT("DSW2") /* no idea */
ADDRESS_MAP_END
@@ -686,7 +691,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( winner82_sound_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00, 0x00) AM_READ_LEGACY(sound_latch_r)
+ AM_RANGE(0x00, 0x00) AM_READ(sound_latch_r)
AM_RANGE(0x00, 0x01) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
AM_RANGE(0x02, 0x03) AM_WRITENOP /* socket for another ay, inited but never played */
ADDRESS_MAP_END
@@ -726,18 +731,18 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( re800_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0xf0, 0xf0) AM_WRITE_LEGACY(blitter_x_w)
- AM_RANGE(0xf1, 0xf1) AM_WRITE_LEGACY(blitter_y_w)
- AM_RANGE(0xf2, 0xf2) AM_WRITE_LEGACY(blitter_trig_wdht_w)
- AM_RANGE(0xf3, 0xf3) AM_WRITE_LEGACY(blitter_aux_w)
- AM_RANGE(0xf4, 0xf4) AM_WRITE_LEGACY(blitter_unk_w)
- AM_RANGE(0xf5, 0xf5) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0xf0, 0xf0) AM_WRITE(blitter_x_w)
+ AM_RANGE(0xf1, 0xf1) AM_WRITE(blitter_y_w)
+ AM_RANGE(0xf2, 0xf2) AM_WRITE(blitter_trig_wdht_w)
+ AM_RANGE(0xf3, 0xf3) AM_WRITE(blitter_aux_w)
+ AM_RANGE(0xf4, 0xf4) AM_WRITE(blitter_unk_w)
+ AM_RANGE(0xf5, 0xf5) AM_READ(blitter_status_r)
AM_RANGE(0xf8, 0xf8) AM_READ_PORT("IN1")
AM_RANGE(0xf9, 0xf9) AM_READ_PORT("DSW1")
- AM_RANGE(0xfc, 0xfc) AM_WRITE_LEGACY(mux_port_w)
- AM_RANGE(0xfd, 0xfd) AM_READ_LEGACY(mux_port_r)
- AM_RANGE(0xfe, 0xfe) AM_WRITE_LEGACY(sound_latch_w)
- AM_RANGE(0xff, 0xff) AM_WRITE_LEGACY(ball_w)
+ AM_RANGE(0xfc, 0xfc) AM_WRITE(mux_port_w)
+ AM_RANGE(0xfd, 0xfd) AM_READ(mux_port_r)
+ AM_RANGE(0xfe, 0xfe) AM_WRITE(sound_latch_w)
+ AM_RANGE(0xff, 0xff) AM_WRITE(ball_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( re800_sound_map, AS_PROGRAM, 8, corona_state )
@@ -747,7 +752,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( re800_sound_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00, 0x00) AM_READ_LEGACY(sound_latch_r)
+ AM_RANGE(0x00, 0x00) AM_READ(sound_latch_r)
AM_RANGE(0x00, 0x01) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
ADDRESS_MAP_END
@@ -785,19 +790,19 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( luckyrlt_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0xf0, 0xf0) AM_WRITE_LEGACY(blitter_x_w)
- AM_RANGE(0xf1, 0xf1) AM_WRITE_LEGACY(blitter_y_w)
- AM_RANGE(0xf2, 0xf2) AM_WRITE_LEGACY(blitter_trig_wdht_w)
- AM_RANGE(0xf3, 0xf3) AM_WRITE_LEGACY(blitter_aux_w)
- AM_RANGE(0xf4, 0xf4) AM_WRITE_LEGACY(blitter_unk_w)
- AM_RANGE(0xf5, 0xf5) AM_READ_LEGACY(blitter_status_r)
+ AM_RANGE(0xf0, 0xf0) AM_WRITE(blitter_x_w)
+ AM_RANGE(0xf1, 0xf1) AM_WRITE(blitter_y_w)
+ AM_RANGE(0xf2, 0xf2) AM_WRITE(blitter_trig_wdht_w)
+ AM_RANGE(0xf3, 0xf3) AM_WRITE(blitter_aux_w)
+ AM_RANGE(0xf4, 0xf4) AM_WRITE(blitter_unk_w)
+ AM_RANGE(0xf5, 0xf5) AM_READ(blitter_status_r)
AM_RANGE(0xf8, 0xf8) AM_READ_PORT("DSW2")
- AM_RANGE(0xf9, 0xf9) AM_WRITE_LEGACY(ball_w)
+ AM_RANGE(0xf9, 0xf9) AM_WRITE(ball_w)
AM_RANGE(0xfa, 0xfa) AM_READ_PORT("DSW1")
- AM_RANGE(0xfc, 0xfc) AM_WRITE_LEGACY(mux_port_w)
- AM_RANGE(0xfd, 0xfd) AM_READ_LEGACY(mux_port_r)
- AM_RANGE(0xfe, 0xfe) AM_WRITE_LEGACY(sound_latch_w)
+ AM_RANGE(0xfc, 0xfc) AM_WRITE(mux_port_w)
+ AM_RANGE(0xfd, 0xfd) AM_READ(mux_port_r)
+ AM_RANGE(0xfe, 0xfe) AM_WRITE(sound_latch_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( luckyrlt_sound_map, AS_PROGRAM, 8, corona_state )
@@ -807,7 +812,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( luckyrlt_sound_cpu_io_map, AS_IO, 8, corona_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00, 0x00) AM_READ_LEGACY(sound_latch_r)
+ AM_RANGE(0x00, 0x00) AM_READ(sound_latch_r)
AM_RANGE(0x00, 0x01) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/crystal.c b/src/mame/drivers/crystal.c
index 1c47b39bebb..ef0ca93e323 100644
--- a/src/mame/drivers/crystal.c
+++ b/src/mame/drivers/crystal.c
@@ -157,6 +157,27 @@ public:
device_t *m_maincpu;
device_t *m_ds1302;
device_t *m_vr0video;
+ DECLARE_READ32_MEMBER(FlipCount_r);
+ DECLARE_WRITE32_MEMBER(FlipCount_w);
+ DECLARE_READ32_MEMBER(Input_r);
+ DECLARE_WRITE32_MEMBER(IntAck_w);
+ DECLARE_WRITE32_MEMBER(Banksw_w);
+ DECLARE_WRITE32_MEMBER(Timer0_w);
+ DECLARE_READ32_MEMBER(Timer0_r);
+ DECLARE_WRITE32_MEMBER(Timer1_w);
+ DECLARE_READ32_MEMBER(Timer1_r);
+ DECLARE_WRITE32_MEMBER(Timer2_w);
+ DECLARE_READ32_MEMBER(Timer2_r);
+ DECLARE_WRITE32_MEMBER(Timer3_w);
+ DECLARE_READ32_MEMBER(Timer3_r);
+ DECLARE_READ32_MEMBER(FlashCmd_r);
+ DECLARE_WRITE32_MEMBER(FlashCmd_w);
+ DECLARE_READ32_MEMBER(PIO_r);
+ DECLARE_WRITE32_MEMBER(PIO_w);
+ DECLARE_READ32_MEMBER(DMA0_r);
+ DECLARE_WRITE32_MEMBER(DMA0_w);
+ DECLARE_READ32_MEMBER(DMA1_r);
+ DECLARE_WRITE32_MEMBER(DMA1_w);
};
static void IntReq( running_machine &machine, int num )
@@ -177,68 +198,64 @@ static void IntReq( running_machine &machine, int num )
#endif
}
-static READ32_HANDLER( FlipCount_r )
+READ32_MEMBER(crystal_state::FlipCount_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
#ifdef IDLE_LOOP_SPEEDUP
- UINT32 IntPend = space->read_dword(0x01800c0c);
- state->m_FlipCntRead++;
- if (state->m_FlipCntRead >= 16 && !IntPend && state->m_FlipCount != 0)
- device_suspend(state->m_maincpu, SUSPEND_REASON_SPIN, 1);
+ UINT32 IntPend = space.read_dword(0x01800c0c);
+ m_FlipCntRead++;
+ if (m_FlipCntRead >= 16 && !IntPend && m_FlipCount != 0)
+ device_suspend(m_maincpu, SUSPEND_REASON_SPIN, 1);
#endif
- return ((UINT32) state->m_FlipCount) << 16;
+ return ((UINT32) m_FlipCount) << 16;
}
-static WRITE32_HANDLER( FlipCount_w )
+WRITE32_MEMBER(crystal_state::FlipCount_w)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
if (mem_mask & 0x00ff0000)
{
int fc = (data >> 16) & 0xff;
if (fc == 1)
- state->m_FlipCount++;
+ m_FlipCount++;
else if (fc == 0)
- state->m_FlipCount = 0;
+ m_FlipCount = 0;
}
}
-static READ32_HANDLER( Input_r )
+READ32_MEMBER(crystal_state::Input_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
if (offset == 0)
- return input_port_read(space->machine(), "P1_P2");
+ return input_port_read(machine(), "P1_P2");
else if (offset == 1)
- return input_port_read(space->machine(), "P3_P4");
+ return input_port_read(machine(), "P3_P4");
else if( offset == 2)
{
- UINT8 Port4 = input_port_read(space->machine(), "SYSTEM");
- if (!(Port4 & 0x10) && ((state->m_OldPort4 ^ Port4) & 0x10)) //coin buttons trigger IRQs
- IntReq(space->machine(), 12);
- if (!(Port4 & 0x20) && ((state->m_OldPort4 ^ Port4) & 0x20))
- IntReq(space->machine(), 19);
- state->m_OldPort4 = Port4;
- return /*dips*/input_port_read(space->machine(), "DSW") | (Port4 << 16);
+ UINT8 Port4 = input_port_read(machine(), "SYSTEM");
+ if (!(Port4 & 0x10) && ((m_OldPort4 ^ Port4) & 0x10)) //coin buttons trigger IRQs
+ IntReq(machine(), 12);
+ if (!(Port4 & 0x20) && ((m_OldPort4 ^ Port4) & 0x20))
+ IntReq(machine(), 19);
+ m_OldPort4 = Port4;
+ return /*dips*/input_port_read(machine(), "DSW") | (Port4 << 16);
}
return 0;
}
-static WRITE32_HANDLER( IntAck_w )
+WRITE32_MEMBER(crystal_state::IntAck_w)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- UINT32 IntPend = space->read_dword(0x01800c0c);
+ UINT32 IntPend = space.read_dword(0x01800c0c);
if (mem_mask & 0xff)
{
IntPend &= ~(1 << (data & 0x1f));
- space->write_dword(0x01800c0c, IntPend);
+ space.write_dword(0x01800c0c, IntPend);
if (!IntPend)
- device_set_input_line(state->m_maincpu, SE3208_INT, CLEAR_LINE);
+ device_set_input_line(m_maincpu, SE3208_INT, CLEAR_LINE);
}
if (mem_mask & 0xff00)
- state->m_IntHigh = (data >> 8) & 7;
+ m_IntHigh = (data >> 8) & 7;
}
static IRQ_CALLBACK( icallback )
@@ -258,15 +275,14 @@ static IRQ_CALLBACK( icallback )
return 0; //This should never happen
}
-static WRITE32_HANDLER( Banksw_w )
+WRITE32_MEMBER(crystal_state::Banksw_w)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- state->m_Bank = (data >> 1) & 7;
- if (state->m_Bank <= 2)
- memory_set_bankptr(space->machine(), "bank1", space->machine().region("user1")->base() + state->m_Bank * 0x1000000);
+ m_Bank = (data >> 1) & 7;
+ if (m_Bank <= 2)
+ memory_set_bankptr(machine(), "bank1", machine().region("user1")->base() + m_Bank * 0x1000000);
else
- memory_set_bankptr(space->machine(), "bank1", space->machine().region("user2")->base());
+ memory_set_bankptr(machine(), "bank1", machine().region("user2")->base());
}
static TIMER_CALLBACK( Timercb )
@@ -299,67 +315,62 @@ INLINE void Timer_w( address_space *space, int which, UINT32 data, UINT32 mem_ma
COMBINE_DATA(&state->m_Timerctrl[which]);
}
-static WRITE32_HANDLER( Timer0_w )
+WRITE32_MEMBER(crystal_state::Timer0_w)
{
- Timer_w(space, 0, data, mem_mask);
+ Timer_w(&space, 0, data, mem_mask);
}
-static READ32_HANDLER( Timer0_r )
+READ32_MEMBER(crystal_state::Timer0_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_Timerctrl[0];
+ return m_Timerctrl[0];
}
-static WRITE32_HANDLER( Timer1_w )
+WRITE32_MEMBER(crystal_state::Timer1_w)
{
- Timer_w(space, 1, data, mem_mask);
+ Timer_w(&space, 1, data, mem_mask);
}
-static READ32_HANDLER( Timer1_r )
+READ32_MEMBER(crystal_state::Timer1_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_Timerctrl[1];
+ return m_Timerctrl[1];
}
-static WRITE32_HANDLER( Timer2_w )
+WRITE32_MEMBER(crystal_state::Timer2_w)
{
- Timer_w(space, 2, data, mem_mask);
+ Timer_w(&space, 2, data, mem_mask);
}
-static READ32_HANDLER( Timer2_r )
+READ32_MEMBER(crystal_state::Timer2_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_Timerctrl[2];
+ return m_Timerctrl[2];
}
-static WRITE32_HANDLER( Timer3_w )
+WRITE32_MEMBER(crystal_state::Timer3_w)
{
- Timer_w(space, 3, data, mem_mask);
+ Timer_w(&space, 3, data, mem_mask);
}
-static READ32_HANDLER( Timer3_r )
+READ32_MEMBER(crystal_state::Timer3_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_Timerctrl[3];
+ return m_Timerctrl[3];
}
-static READ32_HANDLER( FlashCmd_r )
+READ32_MEMBER(crystal_state::FlashCmd_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- if ((state->m_FlashCmd & 0xff) == 0xff)
+ if ((m_FlashCmd & 0xff) == 0xff)
{
- if (state->m_Bank <= 2)
+ if (m_Bank <= 2)
{
- UINT32 *ptr = (UINT32*)(space->machine().region("user1")->base() + state->m_Bank * 0x1000000);
+ UINT32 *ptr = (UINT32*)(machine().region("user1")->base() + m_Bank * 0x1000000);
return ptr[0];
}
else
return 0xffffffff;
}
- if ((state->m_FlashCmd & 0xff) == 0x90)
+ if ((m_FlashCmd & 0xff) == 0x90)
{
- if (state->m_Bank <= 2)
+ if (m_Bank <= 2)
return 0x00180089; //Intel 128MBit
else
return 0xffffffff;
@@ -367,37 +378,34 @@ static READ32_HANDLER( FlashCmd_r )
return 0;
}
-static WRITE32_HANDLER( FlashCmd_w )
+WRITE32_MEMBER(crystal_state::FlashCmd_w)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- state->m_FlashCmd = data;
+ m_FlashCmd = data;
}
-static READ32_HANDLER( PIO_r )
+READ32_MEMBER(crystal_state::PIO_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_PIO;
+ return m_PIO;
}
-static WRITE32_HANDLER( PIO_w )
+WRITE32_MEMBER(crystal_state::PIO_w)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
UINT32 RST = data & 0x01000000;
UINT32 CLK = data & 0x02000000;
UINT32 DAT = data & 0x10000000;
if (!RST)
- state->m_ds1302->reset();
+ m_ds1302->reset();
- ds1302_dat_w(state->m_ds1302, 0, DAT ? 1 : 0);
- ds1302_clk_w(state->m_ds1302, 0, CLK ? 1 : 0);
+ ds1302_dat_w(m_ds1302, 0, DAT ? 1 : 0);
+ ds1302_clk_w(m_ds1302, 0, CLK ? 1 : 0);
- if (ds1302_read(state->m_ds1302, 0))
- space->write_dword(0x01802008, space->read_dword(0x01802008) | 0x10000000);
+ if (ds1302_read(m_ds1302, 0))
+ space.write_dword(0x01802008, space.read_dword(0x01802008) | 0x10000000);
else
- space->write_dword(0x01802008, space->read_dword(0x01802008) & (~0x10000000));
+ space.write_dword(0x01802008, space.read_dword(0x01802008) & (~0x10000000));
- COMBINE_DATA(&state->m_PIO);
+ COMBINE_DATA(&m_PIO);
}
INLINE void DMA_w( address_space *space, int which, UINT32 data, UINT32 mem_mask )
@@ -443,57 +451,55 @@ INLINE void DMA_w( address_space *space, int which, UINT32 data, UINT32 mem_mask
COMBINE_DATA(&state->m_DMActrl[which]);
}
-static READ32_HANDLER( DMA0_r )
+READ32_MEMBER(crystal_state::DMA0_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_DMActrl[0];
+ return m_DMActrl[0];
}
-static WRITE32_HANDLER( DMA0_w )
+WRITE32_MEMBER(crystal_state::DMA0_w)
{
- DMA_w(space, 0, data, mem_mask);
+ DMA_w(&space, 0, data, mem_mask);
}
-static READ32_HANDLER( DMA1_r )
+READ32_MEMBER(crystal_state::DMA1_r)
{
- crystal_state *state = space->machine().driver_data<crystal_state>();
- return state->m_DMActrl[1];
+ return m_DMActrl[1];
}
-static WRITE32_HANDLER( DMA1_w )
+WRITE32_MEMBER(crystal_state::DMA1_w)
{
- DMA_w(space, 1, data, mem_mask);
+ DMA_w(&space, 1, data, mem_mask);
}
static ADDRESS_MAP_START( crystal_mem, AS_PROGRAM, 32, crystal_state )
AM_RANGE(0x00000000, 0x0001ffff) AM_ROM AM_WRITENOP
- AM_RANGE(0x01200000, 0x0120000f) AM_READ_LEGACY(Input_r)
- AM_RANGE(0x01280000, 0x01280003) AM_WRITE_LEGACY(Banksw_w)
+ AM_RANGE(0x01200000, 0x0120000f) AM_READ(Input_r)
+ AM_RANGE(0x01280000, 0x01280003) AM_WRITE(Banksw_w)
AM_RANGE(0x01400000, 0x0140ffff) AM_RAM AM_SHARE("nvram")
- AM_RANGE(0x01801400, 0x01801403) AM_READWRITE_LEGACY(Timer0_r, Timer0_w)
- AM_RANGE(0x01801408, 0x0180140b) AM_READWRITE_LEGACY(Timer1_r, Timer1_w)
- AM_RANGE(0x01801410, 0x01801413) AM_READWRITE_LEGACY(Timer2_r, Timer2_w)
- AM_RANGE(0x01801418, 0x0180141b) AM_READWRITE_LEGACY(Timer3_r, Timer3_w)
- AM_RANGE(0x01802004, 0x01802007) AM_READWRITE_LEGACY(PIO_r, PIO_w)
+ AM_RANGE(0x01801400, 0x01801403) AM_READWRITE(Timer0_r, Timer0_w)
+ AM_RANGE(0x01801408, 0x0180140b) AM_READWRITE(Timer1_r, Timer1_w)
+ AM_RANGE(0x01801410, 0x01801413) AM_READWRITE(Timer2_r, Timer2_w)
+ AM_RANGE(0x01801418, 0x0180141b) AM_READWRITE(Timer3_r, Timer3_w)
+ AM_RANGE(0x01802004, 0x01802007) AM_READWRITE(PIO_r, PIO_w)
- AM_RANGE(0x01800800, 0x01800803) AM_READWRITE_LEGACY(DMA0_r, DMA0_w)
- AM_RANGE(0x01800810, 0x01800813) AM_READWRITE_LEGACY(DMA1_r, DMA1_w)
+ AM_RANGE(0x01800800, 0x01800803) AM_READWRITE(DMA0_r, DMA0_w)
+ AM_RANGE(0x01800810, 0x01800813) AM_READWRITE(DMA1_r, DMA1_w)
- AM_RANGE(0x01800c04, 0x01800c07) AM_WRITE_LEGACY(IntAck_w)
+ AM_RANGE(0x01800c04, 0x01800c07) AM_WRITE(IntAck_w)
AM_RANGE(0x01800000, 0x0180ffff) AM_RAM AM_BASE(m_sysregs)
AM_RANGE(0x02000000, 0x027fffff) AM_RAM AM_BASE(m_workram)
- AM_RANGE(0x030000a4, 0x030000a7) AM_READWRITE_LEGACY(FlipCount_r, FlipCount_w)
+ AM_RANGE(0x030000a4, 0x030000a7) AM_READWRITE(FlipCount_r, FlipCount_w)
AM_RANGE(0x03000000, 0x0300ffff) AM_RAM AM_BASE(m_vidregs)
AM_RANGE(0x03800000, 0x03ffffff) AM_RAM AM_BASE(m_textureram)
AM_RANGE(0x04000000, 0x047fffff) AM_RAM AM_BASE(m_frameram)
AM_RANGE(0x04800000, 0x04800fff) AM_DEVREADWRITE_LEGACY("vrender", vr0_snd_read, vr0_snd_write)
- AM_RANGE(0x05000000, 0x05000003) AM_READWRITE_LEGACY(FlashCmd_r, FlashCmd_w)
+ AM_RANGE(0x05000000, 0x05000003) AM_READWRITE(FlashCmd_r, FlashCmd_w)
AM_RANGE(0x05000000, 0x05ffffff) AM_ROMBANK("bank1")
AM_RANGE(0x44414F4C, 0x44414F7F) AM_RAM AM_BASE(m_ResetPatch)
diff --git a/src/mame/drivers/csplayh5.c b/src/mame/drivers/csplayh5.c
index 6a5552f93a2..97eead7cea3 100644
--- a/src/mame/drivers/csplayh5.c
+++ b/src/mame/drivers/csplayh5.c
@@ -40,6 +40,34 @@ public:
required_device<cpu_device> m_maincpu;
required_device<v9958_device> m_v9958;
+ DECLARE_READ16_MEMBER(csplayh5_mux_r);
+ DECLARE_WRITE16_MEMBER(csplayh5_mux_w);
+ DECLARE_WRITE16_MEMBER(csplayh5_sound_w);
+ DECLARE_READ16_MEMBER(test_r);
+ DECLARE_READ8_MEMBER(csplayh5_sound_r);
+ DECLARE_WRITE8_MEMBER(csplayh5_soundclr_w);
+ DECLARE_READ8_MEMBER(tmpz84c011_pio_r);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_pio_w);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_pa_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_pb_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_pc_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_pd_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_pe_r);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_pa_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_pb_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_pc_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_pd_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_pe_w);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_dir_pa_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_dir_pb_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_dir_pc_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_dir_pd_r);
+ DECLARE_READ8_MEMBER(tmpz84c011_0_dir_pe_r);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_dir_pa_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_dir_pb_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_dir_pc_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_dir_pd_w);
+ DECLARE_WRITE8_MEMBER(tmpz84c011_0_dir_pe_w);
};
@@ -60,28 +88,26 @@ static void csplayh5_vdp0_interrupt(device_t *, v99x8_device &device, int i)
interrupts seem to be fired quite randomly */
}
-static READ16_HANDLER( csplayh5_mux_r )
+READ16_MEMBER(csplayh5_state::csplayh5_mux_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- switch(state->m_mux_data)
+ switch(m_mux_data)
{
- case 0x01: return input_port_read(space->machine(), "KEY0");
- case 0x02: return input_port_read(space->machine(), "KEY1");
- case 0x04: return input_port_read(space->machine(), "KEY2");
- case 0x08: return input_port_read(space->machine(), "KEY3");
- case 0x10: return input_port_read(space->machine(), "KEY4");
+ case 0x01: return input_port_read(machine(), "KEY0");
+ case 0x02: return input_port_read(machine(), "KEY1");
+ case 0x04: return input_port_read(machine(), "KEY2");
+ case 0x08: return input_port_read(machine(), "KEY3");
+ case 0x10: return input_port_read(machine(), "KEY4");
}
return 0xffff;
}
-static WRITE16_HANDLER( csplayh5_mux_w )
+WRITE16_MEMBER(csplayh5_state::csplayh5_mux_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_mux_data = (~data & 0x1f);
+ m_mux_data = (~data & 0x1f);
}
-static WRITE16_HANDLER( csplayh5_sound_w )
+WRITE16_MEMBER(csplayh5_state::csplayh5_sound_w)
{
soundlatch_w(space, 0, ((data >> 8) & 0xff));
}
@@ -90,8 +116,8 @@ static WRITE16_HANDLER( csplayh5_sound_w )
static ADDRESS_MAP_START( csplayh5_map, AS_PROGRAM, 16, csplayh5_state )
AM_RANGE(0x000000, 0x03ffff) AM_ROM
- AM_RANGE(0x200000, 0x200001) AM_READ_PORT("DSW") AM_WRITE_LEGACY(csplayh5_sound_w)
- AM_RANGE(0x200200, 0x200201) AM_READWRITE_LEGACY(csplayh5_mux_r,csplayh5_mux_w)
+ AM_RANGE(0x200000, 0x200001) AM_READ_PORT("DSW") AM_WRITE(csplayh5_sound_w)
+ AM_RANGE(0x200200, 0x200201) AM_READWRITE(csplayh5_mux_r,csplayh5_mux_w)
AM_RANGE(0x200400, 0x200401) AM_READ_PORT("SYSTEM")
AM_RANGE(0x200600, 0x200607) AM_DEVREADWRITE8("v9958", v9958_device, read, write, 0x00ff)
@@ -104,16 +130,16 @@ static ADDRESS_MAP_START( csplayh5_map, AS_PROGRAM, 16, csplayh5_state )
ADDRESS_MAP_END
#if USE_H8
-static READ16_HANDLER( test_r )
+READ16_MEMBER(csplayh5_state::test_r)
{
- return space->machine().rand();
+ return machine().rand();
}
static ADDRESS_MAP_START( csplayh5_sub_map, AS_PROGRAM, 16, csplayh5_state )
AM_RANGE(0x000000, 0x01ffff) AM_ROM
- AM_RANGE(0x04002a, 0x04002b) AM_READ_LEGACY(test_r)
- AM_RANGE(0x040036, 0x040037) AM_READ_LEGACY(test_r)
+ AM_RANGE(0x04002a, 0x04002b) AM_READ(test_r)
+ AM_RANGE(0x040036, 0x040037) AM_READ(test_r)
AM_RANGE(0x078000, 0x07ffff) AM_RAM AM_SHARE("nvram")
AM_RANGE(0x080000, 0x0fffff) AM_RAM
@@ -146,17 +172,17 @@ static void csplayh5_soundbank_w(running_machine &machine, int data)
memory_set_bankptr(machine, "bank1", &SNDROM[0x08000 + (0x8000 * (data & 0x03))]);
}
-static READ8_HANDLER( csplayh5_sound_r )
+READ8_MEMBER(csplayh5_state::csplayh5_sound_r)
{
return soundlatch_r(space, 0);
}
-static WRITE8_HANDLER( csplayh5_soundclr_w )
+WRITE8_MEMBER(csplayh5_state::csplayh5_soundclr_w)
{
soundlatch_clear_w(space, 0, 0);
}
-static READ8_HANDLER( tmpz84c011_pio_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_pio_r)
{
int portdata;
@@ -179,7 +205,7 @@ static READ8_HANDLER( tmpz84c011_pio_r )
break;
default:
- logerror("%s: TMPZ84C011_PIO Unknown Port Read %02X\n", space->machine().describe_context(), offset);
+ logerror("%s: TMPZ84C011_PIO Unknown Port Read %02X\n", machine().describe_context(), offset);
portdata = 0xff;
break;
}
@@ -187,18 +213,18 @@ static READ8_HANDLER( tmpz84c011_pio_r )
return portdata;
}
-static WRITE8_HANDLER( tmpz84c011_pio_w)
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_pio_w)
{
switch (offset)
{
case 0: /* PA_0 */
- csplayh5_soundbank_w(space->machine(), data & 0x03);
+ csplayh5_soundbank_w(machine(), data & 0x03);
break;
case 1: /* PB_0 */
- DAC_WRITE(space->machine().device("dac2"), 0, data);
+ DAC_WRITE(machine().device("dac2"), 0, data);
break;
case 2: /* PC_0 */
- DAC_WRITE(space->machine().device("dac1"), 0, data);
+ DAC_WRITE(machine().device("dac1"), 0, data);
break;
case 3: /* PD_0 */
break;
@@ -207,138 +233,118 @@ static WRITE8_HANDLER( tmpz84c011_pio_w)
break;
default:
- logerror("%s: TMPZ84C011_PIO Unknown Port Write %02X, %02X\n", space->machine().describe_context(), offset, data);
+ logerror("%s: TMPZ84C011_PIO Unknown Port Write %02X, %02X\n", machine().describe_context(), offset, data);
break;
}
}
/* CPU interface */
-static READ8_HANDLER( tmpz84c011_0_pa_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_pa_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return (tmpz84c011_pio_r(space,0) & ~state->m_pio_dir[0]) | (state->m_pio_latch[0] & state->m_pio_dir[0]);
+ return (tmpz84c011_pio_r(space,0) & ~m_pio_dir[0]) | (m_pio_latch[0] & m_pio_dir[0]);
}
-static READ8_HANDLER( tmpz84c011_0_pb_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_pb_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return (tmpz84c011_pio_r(space,1) & ~state->m_pio_dir[1]) | (state->m_pio_latch[1] & state->m_pio_dir[1]);
+ return (tmpz84c011_pio_r(space,1) & ~m_pio_dir[1]) | (m_pio_latch[1] & m_pio_dir[1]);
}
-static READ8_HANDLER( tmpz84c011_0_pc_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_pc_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return (tmpz84c011_pio_r(space,2) & ~state->m_pio_dir[2]) | (state->m_pio_latch[2] & state->m_pio_dir[2]);
+ return (tmpz84c011_pio_r(space,2) & ~m_pio_dir[2]) | (m_pio_latch[2] & m_pio_dir[2]);
}
-static READ8_HANDLER( tmpz84c011_0_pd_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_pd_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return (tmpz84c011_pio_r(space,3) & ~state->m_pio_dir[3]) | (state->m_pio_latch[3] & state->m_pio_dir[3]);
+ return (tmpz84c011_pio_r(space,3) & ~m_pio_dir[3]) | (m_pio_latch[3] & m_pio_dir[3]);
}
-static READ8_HANDLER( tmpz84c011_0_pe_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_pe_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return (tmpz84c011_pio_r(space,4) & ~state->m_pio_dir[4]) | (state->m_pio_latch[4] & state->m_pio_dir[4]);
+ return (tmpz84c011_pio_r(space,4) & ~m_pio_dir[4]) | (m_pio_latch[4] & m_pio_dir[4]);
}
-static WRITE8_HANDLER( tmpz84c011_0_pa_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_pa_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_latch[0] = data;
+ m_pio_latch[0] = data;
tmpz84c011_pio_w(space, 0, data);
}
-static WRITE8_HANDLER( tmpz84c011_0_pb_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_pb_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_latch[1] = data;
+ m_pio_latch[1] = data;
tmpz84c011_pio_w(space, 1, data);
}
-static WRITE8_HANDLER( tmpz84c011_0_pc_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_pc_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_latch[2] = data;
+ m_pio_latch[2] = data;
tmpz84c011_pio_w(space, 2, data);
}
-static WRITE8_HANDLER( tmpz84c011_0_pd_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_pd_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_latch[3] = data;
+ m_pio_latch[3] = data;
tmpz84c011_pio_w(space, 3, data);
}
-static WRITE8_HANDLER( tmpz84c011_0_pe_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_pe_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_latch[4] = data;
+ m_pio_latch[4] = data;
tmpz84c011_pio_w(space, 4, data);
}
-static READ8_HANDLER( tmpz84c011_0_dir_pa_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pa_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return state->m_pio_dir[0];
+ return m_pio_dir[0];
}
-static READ8_HANDLER( tmpz84c011_0_dir_pb_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pb_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return state->m_pio_dir[1];
+ return m_pio_dir[1];
}
-static READ8_HANDLER( tmpz84c011_0_dir_pc_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pc_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return state->m_pio_dir[2];
+ return m_pio_dir[2];
}
-static READ8_HANDLER( tmpz84c011_0_dir_pd_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pd_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return state->m_pio_dir[3];
+ return m_pio_dir[3];
}
-static READ8_HANDLER( tmpz84c011_0_dir_pe_r )
+READ8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pe_r)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- return state->m_pio_dir[4];
+ return m_pio_dir[4];
}
-static WRITE8_HANDLER( tmpz84c011_0_dir_pa_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pa_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_dir[0] = data;
+ m_pio_dir[0] = data;
}
-static WRITE8_HANDLER( tmpz84c011_0_dir_pb_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pb_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_dir[1] = data;
+ m_pio_dir[1] = data;
}
-static WRITE8_HANDLER( tmpz84c011_0_dir_pc_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pc_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_dir[2] = data;
+ m_pio_dir[2] = data;
}
-static WRITE8_HANDLER( tmpz84c011_0_dir_pd_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pd_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_dir[3] = data;
+ m_pio_dir[3] = data;
}
-static WRITE8_HANDLER( tmpz84c011_0_dir_pe_w )
+WRITE8_MEMBER(csplayh5_state::tmpz84c011_0_dir_pe_w)
{
- csplayh5_state *state = space->machine().driver_data<csplayh5_state>();
- state->m_pio_dir[4] = data;
+ m_pio_dir[4] = data;
}
@@ -351,16 +357,16 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( csplayh5_sound_io_map, AS_IO, 8, csplayh5_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x10, 0x13) AM_DEVREADWRITE_LEGACY("ctc", z80ctc_r, z80ctc_w)
- AM_RANGE(0x50, 0x50) AM_READWRITE_LEGACY(tmpz84c011_0_pa_r, tmpz84c011_0_pa_w)
- AM_RANGE(0x51, 0x51) AM_READWRITE_LEGACY(tmpz84c011_0_pb_r, tmpz84c011_0_pb_w)
- AM_RANGE(0x52, 0x52) AM_READWRITE_LEGACY(tmpz84c011_0_pc_r, tmpz84c011_0_pc_w)
- AM_RANGE(0x30, 0x30) AM_READWRITE_LEGACY(tmpz84c011_0_pd_r, tmpz84c011_0_pd_w)
- AM_RANGE(0x40, 0x40) AM_READWRITE_LEGACY(tmpz84c011_0_pe_r, tmpz84c011_0_pe_w)
- AM_RANGE(0x54, 0x54) AM_READWRITE_LEGACY(tmpz84c011_0_dir_pa_r, tmpz84c011_0_dir_pa_w)
- AM_RANGE(0x55, 0x55) AM_READWRITE_LEGACY(tmpz84c011_0_dir_pb_r, tmpz84c011_0_dir_pb_w)
- AM_RANGE(0x56, 0x56) AM_READWRITE_LEGACY(tmpz84c011_0_dir_pc_r, tmpz84c011_0_dir_pc_w)
- AM_RANGE(0x34, 0x34) AM_READWRITE_LEGACY(tmpz84c011_0_dir_pd_r, tmpz84c011_0_dir_pd_w)
- AM_RANGE(0x44, 0x44) AM_READWRITE_LEGACY(tmpz84c011_0_dir_pe_r, tmpz84c011_0_dir_pe_w)
+ AM_RANGE(0x50, 0x50) AM_READWRITE(tmpz84c011_0_pa_r, tmpz84c011_0_pa_w)
+ AM_RANGE(0x51, 0x51) AM_READWRITE(tmpz84c011_0_pb_r, tmpz84c011_0_pb_w)
+ AM_RANGE(0x52, 0x52) AM_READWRITE(tmpz84c011_0_pc_r, tmpz84c011_0_pc_w)
+ AM_RANGE(0x30, 0x30) AM_READWRITE(tmpz84c011_0_pd_r, tmpz84c011_0_pd_w)
+ AM_RANGE(0x40, 0x40) AM_READWRITE(tmpz84c011_0_pe_r, tmpz84c011_0_pe_w)
+ AM_RANGE(0x54, 0x54) AM_READWRITE(tmpz84c011_0_dir_pa_r, tmpz84c011_0_dir_pa_w)
+ AM_RANGE(0x55, 0x55) AM_READWRITE(tmpz84c011_0_dir_pb_r, tmpz84c011_0_dir_pb_w)
+ AM_RANGE(0x56, 0x56) AM_READWRITE(tmpz84c011_0_dir_pc_r, tmpz84c011_0_dir_pc_w)
+ AM_RANGE(0x34, 0x34) AM_READWRITE(tmpz84c011_0_dir_pd_r, tmpz84c011_0_dir_pd_w)
+ AM_RANGE(0x44, 0x44) AM_READWRITE(tmpz84c011_0_dir_pe_r, tmpz84c011_0_dir_pe_w)
AM_RANGE(0x80, 0x81) AM_DEVWRITE_LEGACY("ymsnd", ym3812_w)
ADDRESS_MAP_END
@@ -576,7 +582,7 @@ static MACHINE_RESET( csplayh5 )
for (i = 0; i < 5; i++)
{
state->m_pio_dir[i] = state->m_pio_latch[i] = 0;
- tmpz84c011_pio_w(space, i, 0);
+ state->tmpz84c011_pio_w(*space, i, 0);
}
}
diff --git a/src/mame/drivers/cyclemb.c b/src/mame/drivers/cyclemb.c
index d3466cac4c8..dfd7cea1ee2 100644
--- a/src/mame/drivers/cyclemb.c
+++ b/src/mame/drivers/cyclemb.c
@@ -86,6 +86,10 @@ public:
UINT8 *m_obj1_ram;
UINT8 *m_obj2_ram;
UINT8 *m_obj3_ram;
+ DECLARE_WRITE8_MEMBER(cyclemb_bankswitch_w);
+ DECLARE_READ8_MEMBER(mcu_status_r);
+ DECLARE_WRITE8_MEMBER(sound_cmd_w);
+ DECLARE_WRITE8_MEMBER(cyclemb_flip_w);
};
@@ -215,36 +219,36 @@ static SCREEN_UPDATE_IND16( cyclemb )
return 0;
}
-static WRITE8_HANDLER( cyclemb_bankswitch_w )
+WRITE8_MEMBER(cyclemb_state::cyclemb_bankswitch_w)
{
- memory_set_bank(space->machine(), "bank1", data & 3);
+ memory_set_bank(machine(), "bank1", data & 3);
}
#if 0
-static WRITE8_HANDLER( sound_cmd_w )
+WRITE8_MEMBER(cyclemb_state::sound_cmd_w)
{
soundlatch_w(space, 0, data & 0xff);
- cputag_set_input_line(space->machine(), "audiocpu", 0, HOLD_LINE);
+ cputag_set_input_line(machine(), "audiocpu", 0, HOLD_LINE);
}
#endif
#if 0
-static READ8_HANDLER( mcu_status_r )
+READ8_MEMBER(cyclemb_state::mcu_status_r)
{
return 1;
}
-static WRITE8_HANDLER( sound_cmd_w ) //actually ciom
+WRITE8_MEMBER(cyclemb_state::sound_cmd_w)//actually ciom
{
soundlatch_w(space, 0, data & 0xff);
- cputag_set_input_line(space->machine(), "audiocpu", 0, HOLD_LINE);
+ cputag_set_input_line(machine(), "audiocpu", 0, HOLD_LINE);
}
#endif
-static WRITE8_HANDLER( cyclemb_flip_w )
+WRITE8_MEMBER(cyclemb_state::cyclemb_flip_w)
{
- flip_screen_set(space->machine(), data & 1);
+ flip_screen_set(machine(), data & 1);
// a bunch of other things are setted here
}
@@ -262,9 +266,9 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( cyclemb_io, AS_IO, 8, cyclemb_state )
// ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0xc000, 0xc000) AM_WRITE_LEGACY(cyclemb_bankswitch_w)
+ AM_RANGE(0xc000, 0xc000) AM_WRITE(cyclemb_bankswitch_w)
AM_RANGE(0xc09e, 0xc09f) AM_READWRITE_LEGACY(cyclemb_8741_0_r, cyclemb_8741_0_w)
- AM_RANGE(0xc0bf, 0xc0bf) AM_WRITE_LEGACY(cyclemb_flip_w) //flip screen
+ AM_RANGE(0xc0bf, 0xc0bf) AM_WRITE(cyclemb_flip_w) //flip screen
ADDRESS_MAP_END
static ADDRESS_MAP_START( cyclemb_sound_map, AS_PROGRAM, 8, cyclemb_state )
diff --git a/src/mame/drivers/dai3wksi.c b/src/mame/drivers/dai3wksi.c
index b7257a86b84..fb22a2e27b3 100644
--- a/src/mame/drivers/dai3wksi.c
+++ b/src/mame/drivers/dai3wksi.c
@@ -62,6 +62,9 @@ public:
UINT8 m_port_last2;
int m_enabled_sound;
int m_sound3_counter;
+ DECLARE_WRITE8_MEMBER(dai3wksi_audio_1_w);
+ DECLARE_WRITE8_MEMBER(dai3wksi_audio_2_w);
+ DECLARE_WRITE8_MEMBER(dai3wksi_audio_3_w);
};
@@ -194,62 +197,59 @@ static SCREEN_UPDATE_RGB32( dai3wksi )
#if (USE_SAMPLES)
-static WRITE8_HANDLER( dai3wksi_audio_1_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_1_w)
{
- dai3wksi_state *state = space->machine().driver_data<dai3wksi_state>();
- samples_device *samples = space->machine().device<samples_device>("samples");
- UINT8 rising_bits = data & ~state->m_port_last1;
+ samples_device *samples = machine().device<samples_device>("samples");
+ UINT8 rising_bits = data & ~m_port_last1;
- state->m_enabled_sound = data & 0x80;
+ m_enabled_sound = data & 0x80;
- if ((rising_bits & 0x20) && state->m_enabled_sound)
+ if ((rising_bits & 0x20) && m_enabled_sound)
{
if (data & 0x04)
samples->start(CHANNEL_SOUND5, SAMPLE_SOUND5);
else
samples->start(CHANNEL_SOUND5, SAMPLE_SOUND5, true);
}
- if (!(data & 0x20) && (state->m_port_last1 & 0x20))
+ if (!(data & 0x20) && (m_port_last1 & 0x20))
samples->stop(CHANNEL_SOUND5);
- state->m_port_last1 = data;
+ m_port_last1 = data;
}
-static WRITE8_HANDLER( dai3wksi_audio_2_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_2_w)
{
- dai3wksi_state *state = space->machine().driver_data<dai3wksi_state>();
- samples_device *samples = space->machine().device<samples_device>("samples");
- UINT8 rising_bits = data & ~state->m_port_last2;
+ samples_device *samples = machine().device<samples_device>("samples");
+ UINT8 rising_bits = data & ~m_port_last2;
- state->m_dai3wksi_flipscreen = data & 0x10;
- state->m_dai3wksi_redscreen = ~data & 0x20;
- state->m_dai3wksi_redterop = data & 0x40;
+ m_dai3wksi_flipscreen = data & 0x10;
+ m_dai3wksi_redscreen = ~data & 0x20;
+ m_dai3wksi_redterop = data & 0x40;
- if (state->m_enabled_sound)
+ if (m_enabled_sound)
{
if (rising_bits & 0x01) samples->start(CHANNEL_SOUND1, SAMPLE_SOUND1);
if (rising_bits & 0x02) samples->start(CHANNEL_SOUND2, SAMPLE_SOUND2);
if (rising_bits & 0x08) samples->start(CHANNEL_SOUND4, SAMPLE_SOUND4);
if (rising_bits & 0x04)
{
- if (!state->m_sound3_counter)
+ if (!m_sound3_counter)
samples->start(CHANNEL_SOUND3, SAMPLE_SOUND3_1);
else
samples->start(CHANNEL_SOUND3, SAMPLE_SOUND3_2);
- state->m_sound3_counter ^= 1;
+ m_sound3_counter ^= 1;
}
}
- state->m_port_last2 = data;
+ m_port_last2 = data;
}
-static WRITE8_HANDLER( dai3wksi_audio_3_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_3_w)
{
- dai3wksi_state *state = space->machine().driver_data<dai3wksi_state>();
- samples_device *samples = space->machine().device<samples_device>("samples");
+ samples_device *samples = machine().device<samples_device>("samples");
- if (state->m_enabled_sound)
+ if (m_enabled_sound)
{
if (data & 0x40)
samples->start(CHANNEL_SOUND6, SAMPLE_SOUND6_1);
@@ -282,27 +282,26 @@ static const samples_interface dai3wksi_samples_interface =
#else
-static WRITE8_HANDLER( dai3wksi_audio_1_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_1_w)
{
- device_t *ic79 = space->machine().device("ic79");
+ device_t *ic79 = machine().device("ic79");
- space->machine().sound().system_enable(data & 0x80);
+ machine().sound().system_enable(data & 0x80);
sn76477_enable_w(ic79, (~data >> 5) & 0x01); /* invader movement enable */
sn76477_envelope_1_w(ic79, (~data >> 2) & 0x01); /* invader movement envelope control*/
}
-static WRITE8_HANDLER( dai3wksi_audio_2_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_2_w)
{
- dai3wksi_state *state = space->machine().driver_data<dai3wksi_state>();
- device_t *ic77 = space->machine().device("ic77");
- device_t *ic78 = space->machine().device("ic78");
- device_t *ic80 = space->machine().device("ic80");
+ device_t *ic77 = machine().device("ic77");
+ device_t *ic78 = machine().device("ic78");
+ device_t *ic80 = machine().device("ic80");
- state->m_dai3wksi_flipscreen = data & 0x10;
- state->m_dai3wksi_redscreen = ~data & 0x20;
- state->m_dai3wksi_redterop = data & 0x40;
+ m_dai3wksi_flipscreen = data & 0x10;
+ m_dai3wksi_redscreen = ~data & 0x20;
+ m_dai3wksi_redterop = data & 0x40;
sn76477_enable_w(ic77, (~data >> 0) & 0x01); /* ship movement */
sn76477_enable_w(ic78, (~data >> 1) & 0x01); /* danger text */
@@ -310,9 +309,9 @@ static WRITE8_HANDLER( dai3wksi_audio_2_w )
sn76477_enable_w(ic80, (~data >> 3) & 0x01); /* planet explosion */
}
-static WRITE8_HANDLER( dai3wksi_audio_3_w )
+WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_3_w)
{
- device_t *ic81 = space->machine().device("ic81");
+ device_t *ic81 = machine().device("ic81");
sn76477_enable_w(ic81, (~data >> 2) & 0x01); /* player shoot enable */
sn76477_vco_w(ic81, (~data >> 3) & 0x01); /* player shoot vco control */
@@ -507,9 +506,9 @@ static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, dai3wksi_state )
AM_RANGE(0x2000, 0x23ff) AM_RAM
AM_RANGE(0x2400, 0x24ff) AM_MIRROR(0x100) AM_READ_PORT("IN0")
AM_RANGE(0x2800, 0x28ff) AM_MIRROR(0x100) AM_READ_PORT("IN1")
- AM_RANGE(0x3000, 0x3000) AM_WRITE_LEGACY(dai3wksi_audio_1_w)
- AM_RANGE(0x3400, 0x3400) AM_WRITE_LEGACY(dai3wksi_audio_2_w)
- AM_RANGE(0x3800, 0x3800) AM_WRITE_LEGACY(dai3wksi_audio_3_w)
+ AM_RANGE(0x3000, 0x3000) AM_WRITE(dai3wksi_audio_1_w)
+ AM_RANGE(0x3400, 0x3400) AM_WRITE(dai3wksi_audio_2_w)
+ AM_RANGE(0x3800, 0x3800) AM_WRITE(dai3wksi_audio_3_w)
AM_RANGE(0x8000, 0xbfff) AM_RAM AM_BASE_SIZE(m_dai3wksi_videoram, m_dai3wksi_videoram_size)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/ddayjlc.c b/src/mame/drivers/ddayjlc.c
index b68adc2c0f0..1d9cec94451 100644
--- a/src/mame/drivers/ddayjlc.c
+++ b/src/mame/drivers/ddayjlc.c
@@ -82,6 +82,18 @@ public:
/* devices */
device_t *m_audiocpu;
+ DECLARE_WRITE8_MEMBER(prot_w);
+ DECLARE_WRITE8_MEMBER(char_bank_w);
+ DECLARE_WRITE8_MEMBER(ddayjlc_bgram_w);
+ DECLARE_WRITE8_MEMBER(ddayjlc_videoram_w);
+ DECLARE_WRITE8_MEMBER(sound_nmi_w);
+ DECLARE_WRITE8_MEMBER(main_nmi_w);
+ DECLARE_WRITE8_MEMBER(bg0_w);
+ DECLARE_WRITE8_MEMBER(bg1_w);
+ DECLARE_WRITE8_MEMBER(bg2_w);
+ DECLARE_WRITE8_MEMBER(sound_w);
+ DECLARE_WRITE8_MEMBER(i8257_CH0_w);
+ DECLARE_WRITE8_MEMBER(i8257_LMSR_w);
};
@@ -134,109 +146,97 @@ static CUSTOM_INPUT( prot_r )
return prot_data[state->m_prot_addr];
}
-static WRITE8_HANDLER( prot_w )
+WRITE8_MEMBER(ddayjlc_state::prot_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_prot_addr = (state->m_prot_addr & (~(1 << offset))) | ((data & 1) << offset);
+ m_prot_addr = (m_prot_addr & (~(1 << offset))) | ((data & 1) << offset);
}
-static WRITE8_HANDLER( char_bank_w )
+WRITE8_MEMBER(ddayjlc_state::char_bank_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_char_bank = data;
+ m_char_bank = data;
}
-static WRITE8_HANDLER( ddayjlc_bgram_w )
+WRITE8_MEMBER(ddayjlc_state::ddayjlc_bgram_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
if (!offset)
- state->m_bg_tilemap->set_scrollx(0, data + 8);
+ m_bg_tilemap->set_scrollx(0, data + 8);
- state->m_bgram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset & 0x3ff);
+ m_bgram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset & 0x3ff);
}
-static WRITE8_HANDLER( ddayjlc_videoram_w )
+WRITE8_MEMBER(ddayjlc_state::ddayjlc_videoram_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_videoram[offset] = data;
+ m_videoram[offset] = data;
}
-static WRITE8_HANDLER(sound_nmi_w)
+WRITE8_MEMBER(ddayjlc_state::sound_nmi_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_sound_nmi_enable = data;
+ m_sound_nmi_enable = data;
}
-static WRITE8_HANDLER(main_nmi_w)
+WRITE8_MEMBER(ddayjlc_state::main_nmi_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_main_nmi_enable = data;
+ m_main_nmi_enable = data;
}
-static WRITE8_HANDLER( bg0_w )
+WRITE8_MEMBER(ddayjlc_state::bg0_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_bgadr = (state->m_bgadr & 0xfe) | (data & 1);
+ m_bgadr = (m_bgadr & 0xfe) | (data & 1);
}
-static WRITE8_HANDLER( bg1_w )
+WRITE8_MEMBER(ddayjlc_state::bg1_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_bgadr = (state->m_bgadr & 0xfd) | ((data & 1) << 1);
+ m_bgadr = (m_bgadr & 0xfd) | ((data & 1) << 1);
}
-static WRITE8_HANDLER( bg2_w )
+WRITE8_MEMBER(ddayjlc_state::bg2_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_bgadr = (state->m_bgadr & 0xfb) | ((data & 1) << 2);
- if (state->m_bgadr > 2)
- state->m_bgadr = 0;
+ m_bgadr = (m_bgadr & 0xfb) | ((data & 1) << 2);
+ if (m_bgadr > 2)
+ m_bgadr = 0;
- memory_set_bank(space->machine(), "bank1", state->m_bgadr);
+ memory_set_bank(machine(), "bank1", m_bgadr);
}
-static WRITE8_HANDLER( sound_w )
+WRITE8_MEMBER(ddayjlc_state::sound_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
soundlatch_w(space, offset, data);
- device_set_input_line_and_vector(state->m_audiocpu, 0, HOLD_LINE, 0xff);
+ device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
}
-static WRITE8_HANDLER( i8257_CH0_w )
+WRITE8_MEMBER(ddayjlc_state::i8257_CH0_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
- state->m_e00x_d[offset][state->m_e00x_l[offset]] = data;
- state->m_e00x_l[offset] ^= 1;
+ m_e00x_d[offset][m_e00x_l[offset]] = data;
+ m_e00x_l[offset] ^= 1;
}
-static WRITE8_HANDLER( i8257_LMSR_w )
+WRITE8_MEMBER(ddayjlc_state::i8257_LMSR_w)
{
- ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
if (!data)
{
- INT32 src = state->m_e00x_d[0][1] * 256 + state->m_e00x_d[0][0];
- INT32 dst = state->m_e00x_d[2][1] * 256 + state->m_e00x_d[2][0];
- INT32 size = (state->m_e00x_d[1][1] * 256 + state->m_e00x_d[1][0]) & 0x3ff;
+ INT32 src = m_e00x_d[0][1] * 256 + m_e00x_d[0][0];
+ INT32 dst = m_e00x_d[2][1] * 256 + m_e00x_d[2][0];
+ INT32 size = (m_e00x_d[1][1] * 256 + m_e00x_d[1][0]) & 0x3ff;
INT32 i;
size++; //??
for(i = 0; i < size; i++)
{
- space->write_byte(dst++, space->read_byte(src++));
+ space.write_byte(dst++, space.read_byte(src++));
}
- state->m_e00x_l[0] = 0;
- state->m_e00x_l[1] = 0;
- state->m_e00x_l[2] = 0;
- state->m_e00x_l[3] = 0;
+ m_e00x_l[0] = 0;
+ m_e00x_l[1] = 0;
+ m_e00x_l[2] = 0;
+ m_e00x_l[3] = 0;
}
}
@@ -244,21 +244,21 @@ static ADDRESS_MAP_START( main_cpu, AS_PROGRAM, 8, ddayjlc_state )
AM_RANGE(0x0000, 0x7fff) AM_ROM
AM_RANGE(0x8000, 0x8fff) AM_RAM AM_BASE(m_mainram)
AM_RANGE(0x9000, 0x93ff) AM_RAM AM_BASE(m_spriteram)
- AM_RANGE(0x9400, 0x97ff) AM_RAM_WRITE_LEGACY(ddayjlc_videoram_w) AM_BASE(m_videoram)
- AM_RANGE(0x9800, 0x9fff) AM_RAM_WRITE_LEGACY(ddayjlc_bgram_w) AM_BASE(m_bgram) /* 9800-981f - videoregs */
+ AM_RANGE(0x9400, 0x97ff) AM_RAM_WRITE(ddayjlc_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0x9800, 0x9fff) AM_RAM_WRITE(ddayjlc_bgram_w) AM_BASE(m_bgram) /* 9800-981f - videoregs */
AM_RANGE(0xa000, 0xdfff) AM_ROMBANK("bank1") AM_WRITENOP
- AM_RANGE(0xe000, 0xe003) AM_WRITE_LEGACY(i8257_CH0_w)
+ AM_RANGE(0xe000, 0xe003) AM_WRITE(i8257_CH0_w)
AM_RANGE(0xe008, 0xe008) AM_WRITENOP
- AM_RANGE(0xf000, 0xf000) AM_WRITE_LEGACY(sound_w)
+ AM_RANGE(0xf000, 0xf000) AM_WRITE(sound_w)
AM_RANGE(0xf100, 0xf100) AM_WRITENOP
- AM_RANGE(0xf080, 0xf080) AM_WRITE_LEGACY(char_bank_w)
+ AM_RANGE(0xf080, 0xf080) AM_WRITE(char_bank_w)
AM_RANGE(0xf081, 0xf081) AM_WRITENOP
- AM_RANGE(0xf083, 0xf083) AM_WRITE_LEGACY(i8257_LMSR_w)
- AM_RANGE(0xf084, 0xf084) AM_WRITE_LEGACY(bg0_w)
- AM_RANGE(0xf085, 0xf085) AM_WRITE_LEGACY(bg1_w)
- AM_RANGE(0xf086, 0xf086) AM_WRITE_LEGACY(bg2_w)
- AM_RANGE(0xf101, 0xf101) AM_WRITE_LEGACY(main_nmi_w)
- AM_RANGE(0xf102, 0xf105) AM_WRITE_LEGACY(prot_w)
+ AM_RANGE(0xf083, 0xf083) AM_WRITE(i8257_LMSR_w)
+ AM_RANGE(0xf084, 0xf084) AM_WRITE(bg0_w)
+ AM_RANGE(0xf085, 0xf085) AM_WRITE(bg1_w)
+ AM_RANGE(0xf086, 0xf086) AM_WRITE(bg2_w)
+ AM_RANGE(0xf101, 0xf101) AM_WRITE(main_nmi_w)
+ AM_RANGE(0xf102, 0xf105) AM_WRITE(prot_w)
AM_RANGE(0xf000, 0xf000) AM_READ_PORT("INPUTS")
AM_RANGE(0xf100, 0xf100) AM_READ_PORT("SYSTEM")
AM_RANGE(0xf180, 0xf180) AM_READ_PORT("DSW1")
@@ -273,7 +273,7 @@ static ADDRESS_MAP_START( sound_cpu, AS_PROGRAM, 8, ddayjlc_state )
AM_RANGE(0x4000, 0x4000) AM_DEVWRITE_LEGACY("ay1", ay8910_address_w)
AM_RANGE(0x5000, 0x5000) AM_DEVREADWRITE_LEGACY("ay2", ay8910_r, ay8910_data_w)
AM_RANGE(0x6000, 0x6000) AM_DEVWRITE_LEGACY("ay2", ay8910_address_w)
- AM_RANGE(0x7000, 0x7000) AM_WRITE_LEGACY(sound_nmi_w)
+ AM_RANGE(0x7000, 0x7000) AM_WRITE(sound_nmi_w)
ADDRESS_MAP_END
static INPUT_PORTS_START( ddayjlc )
diff --git a/src/mame/drivers/ddealer.c b/src/mame/drivers/ddealer.c
index 006792793a8..97849d4d908 100644
--- a/src/mame/drivers/ddealer.c
+++ b/src/mame/drivers/ddealer.c
@@ -138,14 +138,18 @@ public:
/* misc */
UINT8 m_input_pressed;
UINT16 m_coin_input;
+ DECLARE_WRITE16_MEMBER(ddealer_flipscreen_w);
+ DECLARE_WRITE16_MEMBER(back_vram_w);
+ DECLARE_WRITE16_MEMBER(ddealer_vregs_w);
+ DECLARE_WRITE16_MEMBER(ddealer_mcu_shared_w);
+ DECLARE_READ16_MEMBER(ddealer_mcu_r);
};
-static WRITE16_HANDLER( ddealer_flipscreen_w )
+WRITE16_MEMBER(ddealer_state::ddealer_flipscreen_w)
{
- ddealer_state *state = space->machine().driver_data<ddealer_state>();
- state->m_flipscreen = data & 0x01;
+ m_flipscreen = data & 0x01;
}
static TILE_GET_INFO( get_back_tile_info )
@@ -358,18 +362,16 @@ static TIMER_DEVICE_CALLBACK( ddealer_mcu_sim )
-static WRITE16_HANDLER( back_vram_w )
+WRITE16_MEMBER(ddealer_state::back_vram_w)
{
- ddealer_state *state = space->machine().driver_data<ddealer_state>();
- COMBINE_DATA(&state->m_back_vram[offset]);
- state->m_back_tilemap->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_back_vram[offset]);
+ m_back_tilemap->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( ddealer_vregs_w )
+WRITE16_MEMBER(ddealer_state::ddealer_vregs_w)
{
- ddealer_state *state = space->machine().driver_data<ddealer_state>();
- COMBINE_DATA(&state->m_vregs[offset]);
+ COMBINE_DATA(&m_vregs[offset]);
}
/******************************************************************************************************
@@ -379,25 +381,24 @@ Protection handling,identical to Hacha Mecha Fighter / Thunder Dragon with diffe
******************************************************************************************************/
#define PROT_JSR(_offs_,_protvalue_,_pc_) \
- if(state->m_mcu_shared_ram[(_offs_)/2] == _protvalue_) \
+ if(m_mcu_shared_ram[(_offs_)/2] == _protvalue_) \
{ \
- state->m_mcu_shared_ram[(_offs_)/2] = 0xffff; /*(MCU job done)*/ \
- state->m_mcu_shared_ram[(_offs_+2-0x10)/2] = 0x4ef9;/*JMP*/\
- state->m_mcu_shared_ram[(_offs_+4-0x10)/2] = 0x0000;/*HI-DWORD*/\
- state->m_mcu_shared_ram[(_offs_+6-0x10)/2] = _pc_; /*LO-DWORD*/\
+ m_mcu_shared_ram[(_offs_)/2] = 0xffff; /*(MCU job done)*/ \
+ m_mcu_shared_ram[(_offs_+2-0x10)/2] = 0x4ef9;/*JMP*/\
+ m_mcu_shared_ram[(_offs_+4-0x10)/2] = 0x0000;/*HI-DWORD*/\
+ m_mcu_shared_ram[(_offs_+6-0x10)/2] = _pc_; /*LO-DWORD*/\
} \
#define PROT_INPUT(_offs_,_protvalue_,_protinput_,_input_) \
- if(state->m_mcu_shared_ram[_offs_] == _protvalue_) \
+ if(m_mcu_shared_ram[_offs_] == _protvalue_) \
{\
- state->m_mcu_shared_ram[_protinput_] = ((_input_ & 0xffff0000)>>16);\
- state->m_mcu_shared_ram[_protinput_+1] = (_input_ & 0x0000ffff);\
+ m_mcu_shared_ram[_protinput_] = ((_input_ & 0xffff0000)>>16);\
+ m_mcu_shared_ram[_protinput_+1] = (_input_ & 0x0000ffff);\
}
-static WRITE16_HANDLER( ddealer_mcu_shared_w )
+WRITE16_MEMBER(ddealer_state::ddealer_mcu_shared_w)
{
- ddealer_state *state = space->machine().driver_data<ddealer_state>();
- COMBINE_DATA(&state->m_mcu_shared_ram[offset]);
+ COMBINE_DATA(&m_mcu_shared_ram[offset]);
switch(offset)
{
@@ -429,25 +430,25 @@ static WRITE16_HANDLER( ddealer_mcu_shared_w )
case 0x4fe/2: PROT_JSR(0x4fe,0x8018,0x9818); break;
/*Start-up vector,I think that only the first ram address can be written by the main CPU,or it is a whole sequence.*/
case 0x000/2:
- if (state->m_mcu_shared_ram[0x000 / 2] == 0x60fe)
+ if (m_mcu_shared_ram[0x000 / 2] == 0x60fe)
{
- state->m_mcu_shared_ram[0x000 / 2] = 0x0000;//coin counter
- state->m_mcu_shared_ram[0x002 / 2] = 0x0000;//coin counter "decimal point"
- state->m_mcu_shared_ram[0x004 / 2] = 0x4ef9;
+ m_mcu_shared_ram[0x000 / 2] = 0x0000;//coin counter
+ m_mcu_shared_ram[0x002 / 2] = 0x0000;//coin counter "decimal point"
+ m_mcu_shared_ram[0x004 / 2] = 0x4ef9;
}
break;
case 0x002/2:
case 0x004/2:
- if (state->m_mcu_shared_ram[0x002 / 2] == 0x0000 && state->m_mcu_shared_ram[0x004 / 2] == 0x0214)
- state->m_mcu_shared_ram[0x004 / 2] = 0x4ef9;
+ if (m_mcu_shared_ram[0x002 / 2] == 0x0000 && m_mcu_shared_ram[0x004 / 2] == 0x0214)
+ m_mcu_shared_ram[0x004 / 2] = 0x4ef9;
break;
case 0x008/2:
- if (state->m_mcu_shared_ram[0x008 / 2] == 0x000f)
- state->m_mcu_shared_ram[0x008 / 2] = 0x0604;
+ if (m_mcu_shared_ram[0x008 / 2] == 0x000f)
+ m_mcu_shared_ram[0x008 / 2] = 0x0604;
break;
case 0x00c/2:
- if (state->m_mcu_shared_ram[0x00c / 2] == 0x000f)
- state->m_mcu_shared_ram[0x00c / 2] = 0x0000;
+ if (m_mcu_shared_ram[0x00c / 2] == 0x000f)
+ m_mcu_shared_ram[0x00c / 2] = 0x0000;
break;
}
}
@@ -460,7 +461,7 @@ static ADDRESS_MAP_START( ddealer, AS_PROGRAM, 16, ddealer_state )
AM_RANGE(0x08000a, 0x08000b) AM_READ_PORT("UNK")
AM_RANGE(0x084000, 0x084003) AM_DEVWRITE8_LEGACY("ymsnd", ym2203_w, 0x00ff) // ym ?
AM_RANGE(0x088000, 0x0887ff) AM_RAM_WRITE_LEGACY(paletteram16_RRRRGGGGBBBBRGBx_word_w) AM_BASE_GENERIC(paletteram) // palette ram
- AM_RANGE(0x08c000, 0x08cfff) AM_RAM_WRITE_LEGACY(ddealer_vregs_w) AM_BASE(m_vregs) // palette ram
+ AM_RANGE(0x08c000, 0x08cfff) AM_RAM_WRITE(ddealer_vregs_w) AM_BASE(m_vregs) // palette ram
/* this might actually be 1 tilemap with some funky rowscroll / columnscroll enabled, I'm not sure */
AM_RANGE(0x090000, 0x090fff) AM_RAM AM_BASE(m_left_fg_vram_top)
@@ -468,10 +469,10 @@ static ADDRESS_MAP_START( ddealer, AS_PROGRAM, 16, ddealer_state )
AM_RANGE(0x092000, 0x092fff) AM_RAM AM_BASE(m_left_fg_vram_bottom)
AM_RANGE(0x093000, 0x093fff) AM_RAM AM_BASE(m_right_fg_vram_bottom)
//AM_RANGE(0x094000, 0x094001) AM_NOP // always 0?
- AM_RANGE(0x098000, 0x098001) AM_WRITE_LEGACY(ddealer_flipscreen_w)
- AM_RANGE(0x09c000, 0x09cfff) AM_RAM_WRITE_LEGACY(back_vram_w) AM_BASE(m_back_vram) // bg tilemap
+ AM_RANGE(0x098000, 0x098001) AM_WRITE(ddealer_flipscreen_w)
+ AM_RANGE(0x09c000, 0x09cfff) AM_RAM_WRITE(back_vram_w) AM_BASE(m_back_vram) // bg tilemap
AM_RANGE(0x0f0000, 0x0fdfff) AM_RAM AM_BASE(m_work_ram)
- AM_RANGE(0x0fe000, 0x0fefff) AM_RAM_WRITE_LEGACY(ddealer_mcu_shared_w) AM_BASE(m_mcu_shared_ram)
+ AM_RANGE(0x0fe000, 0x0fefff) AM_RAM_WRITE(ddealer_mcu_shared_w) AM_BASE(m_mcu_shared_ram)
AM_RANGE(0x0ff000, 0x0fffff) AM_RAM
ADDRESS_MAP_END
@@ -647,9 +648,8 @@ MACHINE_CONFIG_END
-static READ16_HANDLER( ddealer_mcu_r )
+READ16_MEMBER(ddealer_state::ddealer_mcu_r)
{
- ddealer_state *state = space->machine().driver_data<ddealer_state>();
static const int resp[] =
{
0x93, 0xc7, 0x00, 0x8000,
@@ -661,16 +661,17 @@ static READ16_HANDLER( ddealer_mcu_r )
int res;
- res = resp[state->m_respcount++];
- if (resp[state->m_respcount] < 0)
- state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (resp[m_respcount] < 0)
+ m_respcount = 0;
return res;
}
static DRIVER_INIT( ddealer )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfe01c, 0xfe01d, FUNC(ddealer_mcu_r) );
+ ddealer_state *state = machine.driver_data<ddealer_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xfe01c, 0xfe01d, read16_delegate(FUNC(ddealer_state::ddealer_mcu_r), state));
}
ROM_START( ddealer )
diff --git a/src/mame/drivers/deco156.c b/src/mame/drivers/deco156.c
index c8813b75dfa..3697fff9ed5 100644
--- a/src/mame/drivers/deco156.c
+++ b/src/mame/drivers/deco156.c
@@ -41,6 +41,15 @@ public:
UINT16 m_pf1_rowscroll[0x800/2];
UINT16 m_pf2_rowscroll[0x800/2];
UINT16* m_spriteram;
+ DECLARE_WRITE32_MEMBER(hvysmsh_eeprom_w);
+ DECLARE_WRITE32_MEMBER(wcvol95_nonbuffered_palette_w);
+ DECLARE_WRITE32_MEMBER(deco156_nonbuffered_palette_w);
+ DECLARE_READ32_MEMBER(wcvol95_pf1_rowscroll_r);
+ DECLARE_READ32_MEMBER(wcvol95_pf2_rowscroll_r);
+ DECLARE_READ32_MEMBER(wcvol95_spriteram_r);
+ DECLARE_WRITE32_MEMBER(wcvol95_pf1_rowscroll_w);
+ DECLARE_WRITE32_MEMBER(wcvol95_pf2_rowscroll_w);
+ DECLARE_WRITE32_MEMBER(wcvol95_spriteram_w);
};
@@ -76,13 +85,12 @@ static SCREEN_UPDATE_RGB32( wcvol95 )
/***************************************************************************/
-static WRITE32_HANDLER(hvysmsh_eeprom_w)
+WRITE32_MEMBER(deco156_state::hvysmsh_eeprom_w)
{
- deco156_state *state = space->machine().driver_data<deco156_state>();
if (ACCESSING_BITS_0_7)
{
- state->m_oki2->set_bank_base(0x40000 * (data & 0x7));
- input_port_write(space->machine(), "EEPROMOUT", data, 0xff);
+ m_oki2->set_bank_base(0x40000 * (data & 0x7));
+ input_port_write(machine(), "EEPROMOUT", data, 0xff);
}
}
@@ -92,32 +100,32 @@ static WRITE32_DEVICE_HANDLER( hvysmsh_oki_0_bank_w )
oki->set_bank_base((data & 1) * 0x40000);
}
-static WRITE32_HANDLER(wcvol95_nonbuffered_palette_w)
+WRITE32_MEMBER(deco156_state::wcvol95_nonbuffered_palette_w)
{
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
- palette_set_color_rgb(space->machine(),offset,pal5bit(space->machine().generic.paletteram.u32[offset] >> 0),pal5bit(space->machine().generic.paletteram.u32[offset] >> 5),pal5bit(space->machine().generic.paletteram.u32[offset] >> 10));
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
+ palette_set_color_rgb(machine(),offset,pal5bit(machine().generic.paletteram.u32[offset] >> 0),pal5bit(machine().generic.paletteram.u32[offset] >> 5),pal5bit(machine().generic.paletteram.u32[offset] >> 10));
}
/* This is the same as deco32_nonbuffered_palette_w in video/deco32.c */
-static WRITE32_HANDLER( deco156_nonbuffered_palette_w )
+WRITE32_MEMBER(deco156_state::deco156_nonbuffered_palette_w)
{
int r,g,b;
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
- b = (space->machine().generic.paletteram.u32[offset] >>16) & 0xff;
- g = (space->machine().generic.paletteram.u32[offset] >> 8) & 0xff;
- r = (space->machine().generic.paletteram.u32[offset] >> 0) & 0xff;
+ b = (machine().generic.paletteram.u32[offset] >>16) & 0xff;
+ g = (machine().generic.paletteram.u32[offset] >> 8) & 0xff;
+ r = (machine().generic.paletteram.u32[offset] >> 0) & 0xff;
- palette_set_color(space->machine(),offset,MAKE_RGB(r,g,b));
+ palette_set_color(machine(),offset,MAKE_RGB(r,g,b));
}
-static READ32_HANDLER( wcvol95_pf1_rowscroll_r ) { deco156_state *state = space->machine().driver_data<deco156_state>(); return state->m_pf1_rowscroll[offset] ^ 0xffff0000; }
-static READ32_HANDLER( wcvol95_pf2_rowscroll_r ) { deco156_state *state = space->machine().driver_data<deco156_state>(); return state->m_pf2_rowscroll[offset] ^ 0xffff0000; }
-static READ32_HANDLER( wcvol95_spriteram_r ) { deco156_state *state = space->machine().driver_data<deco156_state>(); return state->m_spriteram[offset] ^ 0xffff0000; }
-static WRITE32_HANDLER( wcvol95_pf1_rowscroll_w ) { deco156_state *state = space->machine().driver_data<deco156_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf1_rowscroll[offset]); }
-static WRITE32_HANDLER( wcvol95_pf2_rowscroll_w ) { deco156_state *state = space->machine().driver_data<deco156_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_pf2_rowscroll[offset]); }
-static WRITE32_HANDLER( wcvol95_spriteram_w ) { deco156_state *state = space->machine().driver_data<deco156_state>(); data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&state->m_spriteram[offset]); }
+READ32_MEMBER(deco156_state::wcvol95_pf1_rowscroll_r){ return m_pf1_rowscroll[offset] ^ 0xffff0000; }
+READ32_MEMBER(deco156_state::wcvol95_pf2_rowscroll_r){ return m_pf2_rowscroll[offset] ^ 0xffff0000; }
+READ32_MEMBER(deco156_state::wcvol95_spriteram_r){ return m_spriteram[offset] ^ 0xffff0000; }
+WRITE32_MEMBER(deco156_state::wcvol95_pf1_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf1_rowscroll[offset]); }
+WRITE32_MEMBER(deco156_state::wcvol95_pf2_rowscroll_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_pf2_rowscroll[offset]); }
+WRITE32_MEMBER(deco156_state::wcvol95_spriteram_w){ data &= 0x0000ffff; mem_mask &= 0x0000ffff; COMBINE_DATA(&m_spriteram[offset]); }
static ADDRESS_MAP_START( hvysmsh_map, AS_PROGRAM, 32, deco156_state )
@@ -125,7 +133,7 @@ static ADDRESS_MAP_START( hvysmsh_map, AS_PROGRAM, 32, deco156_state )
AM_RANGE(0x100000, 0x107fff) AM_RAM
AM_RANGE(0x120000, 0x120003) AM_READ_PORT("INPUTS")
AM_RANGE(0x120000, 0x120003) AM_WRITENOP // Volume control in low byte
- AM_RANGE(0x120004, 0x120007) AM_WRITE_LEGACY(hvysmsh_eeprom_w)
+ AM_RANGE(0x120004, 0x120007) AM_WRITE(hvysmsh_eeprom_w)
AM_RANGE(0x120008, 0x12000b) AM_WRITENOP // IRQ ack?
AM_RANGE(0x12000c, 0x12000f) AM_DEVWRITE_LEGACY("oki1", hvysmsh_oki_0_bank_w)
AM_RANGE(0x140000, 0x140003) AM_DEVREADWRITE8("oki1", okim6295_device, read, write, 0x000000ff)
@@ -133,11 +141,11 @@ static ADDRESS_MAP_START( hvysmsh_map, AS_PROGRAM, 32, deco156_state )
AM_RANGE(0x180000, 0x18001f) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf_control_dword_r, deco16ic_pf_control_dword_w)
AM_RANGE(0x190000, 0x191fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf1_data_dword_r, deco16ic_pf1_data_dword_w)
AM_RANGE(0x194000, 0x195fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf2_data_dword_r, deco16ic_pf2_data_dword_w)
- AM_RANGE(0x1a0000, 0x1a0fff) AM_READWRITE_LEGACY(wcvol95_pf1_rowscroll_r, wcvol95_pf1_rowscroll_w)
- AM_RANGE(0x1a4000, 0x1a4fff) AM_READWRITE_LEGACY(wcvol95_pf2_rowscroll_r, wcvol95_pf2_rowscroll_w)
- AM_RANGE(0x1c0000, 0x1c0fff) AM_RAM_WRITE_LEGACY(deco156_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x1a0000, 0x1a0fff) AM_READWRITE(wcvol95_pf1_rowscroll_r, wcvol95_pf1_rowscroll_w)
+ AM_RANGE(0x1a4000, 0x1a4fff) AM_READWRITE(wcvol95_pf2_rowscroll_r, wcvol95_pf2_rowscroll_w)
+ AM_RANGE(0x1c0000, 0x1c0fff) AM_RAM_WRITE(deco156_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x1d0010, 0x1d002f) AM_READNOP // Check for DMA complete?
- AM_RANGE(0x1e0000, 0x1e1fff) AM_READWRITE_LEGACY(wcvol95_spriteram_r, wcvol95_spriteram_w)
+ AM_RANGE(0x1e0000, 0x1e1fff) AM_READWRITE(wcvol95_spriteram_r, wcvol95_spriteram_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( wcvol95_map, AS_PROGRAM, 32, deco156_state )
@@ -145,14 +153,14 @@ static ADDRESS_MAP_START( wcvol95_map, AS_PROGRAM, 32, deco156_state )
AM_RANGE(0x100000, 0x10001f) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf_control_dword_r, deco16ic_pf_control_dword_w)
AM_RANGE(0x110000, 0x111fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf1_data_dword_r, deco16ic_pf1_data_dword_w)
AM_RANGE(0x114000, 0x115fff) AM_DEVREADWRITE_LEGACY("tilegen1", deco16ic_pf2_data_dword_r, deco16ic_pf2_data_dword_w)
- AM_RANGE(0x120000, 0x120fff) AM_READWRITE_LEGACY(wcvol95_pf1_rowscroll_r, wcvol95_pf1_rowscroll_w)
- AM_RANGE(0x124000, 0x124fff) AM_READWRITE_LEGACY(wcvol95_pf2_rowscroll_r, wcvol95_pf2_rowscroll_w)
+ AM_RANGE(0x120000, 0x120fff) AM_READWRITE(wcvol95_pf1_rowscroll_r, wcvol95_pf1_rowscroll_w)
+ AM_RANGE(0x124000, 0x124fff) AM_READWRITE(wcvol95_pf2_rowscroll_r, wcvol95_pf2_rowscroll_w)
AM_RANGE(0x130000, 0x137fff) AM_RAM
AM_RANGE(0x140000, 0x140003) AM_READ_PORT("INPUTS")
AM_RANGE(0x150000, 0x150003) AM_WRITE_PORT("EEPROMOUT")
- AM_RANGE(0x160000, 0x161fff) AM_READWRITE_LEGACY(wcvol95_spriteram_r, wcvol95_spriteram_w)
+ AM_RANGE(0x160000, 0x161fff) AM_READWRITE(wcvol95_spriteram_r, wcvol95_spriteram_w)
AM_RANGE(0x170000, 0x170003) AM_NOP // Irq ack?
- AM_RANGE(0x180000, 0x180fff) AM_RAM_WRITE_LEGACY(wcvol95_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x180000, 0x180fff) AM_RAM_WRITE(wcvol95_nonbuffered_palette_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x1a0000, 0x1a0007) AM_DEVREADWRITE8_LEGACY("ymz", ymz280b_r, ymz280b_w, 0x000000ff)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/deshoros.c b/src/mame/drivers/deshoros.c
index fde226b15c6..99d9a9a978b 100644
--- a/src/mame/drivers/deshoros.c
+++ b/src/mame/drivers/deshoros.c
@@ -25,6 +25,9 @@ public:
UINT8 *m_io_ram;
char m_led_array[21];
UINT8 m_bank;
+ DECLARE_READ8_MEMBER(io_r);
+ DECLARE_WRITE8_MEMBER(io_w);
+ void update_led_array(UINT8 new_data);
};
@@ -47,14 +50,14 @@ static SCREEN_UPDATE_IND16( deshoros )
}
/*I don't know it this is 100% correct,might be different...*/
-static void update_led_array(deshoros_state *state, UINT8 new_data)
+void deshoros_state::update_led_array(UINT8 new_data)
{
UINT8 i;
/*scroll the data*/
for(i=0;i<19;i++)
- state->m_led_array[i] = state->m_led_array[i+1];
+ m_led_array[i] = m_led_array[i+1];
/*update the data*/
- state->m_led_array[19] = new_data;
+ m_led_array[19] = new_data;
}
@@ -72,44 +75,42 @@ static void answer_bankswitch(running_machine &machine,UINT8 new_bank)
}
}
-static READ8_HANDLER( io_r )
+READ8_MEMBER(deshoros_state::io_r)
{
- deshoros_state *state = space->machine().driver_data<deshoros_state>();
switch(offset)
{
case 0x00: return 0xff; //printer read
- case 0x03: return input_port_read(space->machine(), "KEY0" );
- case 0x04: return input_port_read(space->machine(), "KEY1" );
- case 0x05: return input_port_read(space->machine(), "SYSTEM" );
- case 0x0a: return state->m_io_ram[offset]; //"buzzer" 0 read
- case 0x0b: return state->m_io_ram[offset]; //"buzzer" 1 read
+ case 0x03: return input_port_read(machine(), "KEY0" );
+ case 0x04: return input_port_read(machine(), "KEY1" );
+ case 0x05: return input_port_read(machine(), "SYSTEM" );
+ case 0x0a: return m_io_ram[offset]; //"buzzer" 0 read
+ case 0x0b: return m_io_ram[offset]; //"buzzer" 1 read
}
// printf("R -> [%02x]\n",offset);
- return state->m_io_ram[offset];
+ return m_io_ram[offset];
}
-static WRITE8_HANDLER( io_w )
+WRITE8_MEMBER(deshoros_state::io_w)
{
- deshoros_state *state = space->machine().driver_data<deshoros_state>();
switch(offset)
{
case 0x00: /*Printer data*/ return;
- case 0x02: update_led_array(state, data); return;
- case 0x05: coin_lockout_w(space->machine(), 0,state->m_io_ram[offset] & 1);return;
+ case 0x02: update_led_array(data); return;
+ case 0x05: coin_lockout_w(machine(), 0,m_io_ram[offset] & 1);return;
case 0x06: /*Printer IRQ enable*/ return;
// case 0x0a: "buzzer" 0 write
// case 0x0b: "buzzer" 1 write
- case 0x0c: answer_bankswitch(space->machine(),data&0x03); return; //data & 0x10 enabled too,dunno if it is worth to shift the data...
+ case 0x0c: answer_bankswitch(machine(),data&0x03); return; //data & 0x10 enabled too,dunno if it is worth to shift the data...
}
- state->m_io_ram[offset] = data;
+ m_io_ram[offset] = data;
// printf("%02x -> [%02x]\n",data,offset);
}
static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, deshoros_state )
AM_RANGE(0x0000, 0x5fff) AM_ROMBANK("bank1")
AM_RANGE(0x8000, 0x87ff) AM_RAM
- AM_RANGE(0x9000, 0x900f) AM_READWRITE_LEGACY(io_r,io_w) AM_BASE(m_io_ram) //i/o area
+ AM_RANGE(0x9000, 0x900f) AM_READWRITE(io_r,io_w) AM_BASE(m_io_ram) //i/o area
AM_RANGE(0xc000, 0xffff) AM_ROM
ADDRESS_MAP_END
diff --git a/src/mame/drivers/dunhuang.c b/src/mame/drivers/dunhuang.c
index 82e552c562f..8e55b9a35fa 100644
--- a/src/mame/drivers/dunhuang.c
+++ b/src/mame/drivers/dunhuang.c
@@ -93,6 +93,29 @@ public:
UINT8 m_colorram[0x40 * 0x20];
UINT8 m_colorram2[0x40 * 0x8];
UINT8 m_paldata[3 * 256];
+ DECLARE_WRITE8_MEMBER(dunhuang_pos_x_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_pos_y_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_tile_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_tile2_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_clear_y_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_horiz_clear_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_vert_clear_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_dest_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_x_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_y_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_w_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_c_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_addr_lo_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_addr_hi_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_block_h_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_paloffs_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_paldata_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_layers_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_input_w);
+ DECLARE_READ8_MEMBER(dunhuang_service_r);
+ DECLARE_READ8_MEMBER(dunhuang_input_r);
+ DECLARE_WRITE8_MEMBER(dunhuang_rombank_w);
+ DECLARE_WRITE8_MEMBER(dunhuang_82_w);
};
@@ -170,112 +193,105 @@ if (screen.machine().input().code_pressed(KEYCODE_Z))
// Tilemaps access
-static WRITE8_HANDLER( dunhuang_pos_x_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_pos_x_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_pos_x = data & 0x3f;
- state->m_written = 0;
- state->m_written2 = 0;
+ m_pos_x = data & 0x3f;
+ m_written = 0;
+ m_written2 = 0;
}
-static WRITE8_HANDLER( dunhuang_pos_y_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_pos_y_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_pos_y = data;
- state->m_written = 0;
- state->m_written2 = 0;
+ m_pos_y = data;
+ m_written = 0;
+ m_written2 = 0;
}
-static WRITE8_HANDLER( dunhuang_tile_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_tile_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
int addr;
- if (state->m_written & (1 << offset))
+ if (m_written & (1 << offset))
{
- state->m_written = 0;
- state->m_pos_x++;
- if (state->m_pos_x == 0x40)
+ m_written = 0;
+ m_pos_x++;
+ if (m_pos_x == 0x40)
{
- state->m_pos_x = 0;
- state->m_pos_y++;
+ m_pos_x = 0;
+ m_pos_y++;
}
}
- state->m_written |= 1 << offset;
+ m_written |= 1 << offset;
- addr = (state->m_pos_x & 0x3f) + (state->m_pos_y & 0x1f) * 0x40;
+ addr = (m_pos_x & 0x3f) + (m_pos_y & 0x1f) * 0x40;
switch (offset)
{
- case 0: state->m_videoram[addr] = (state->m_videoram[addr] & 0xff00) | data; break;
- case 1: state->m_videoram[addr] = (state->m_videoram[addr] & 0x00ff) | (data<<8); break;
- case 2: state->m_colorram[addr] = data; break;
+ case 0: m_videoram[addr] = (m_videoram[addr] & 0xff00) | data; break;
+ case 1: m_videoram[addr] = (m_videoram[addr] & 0x00ff) | (data<<8); break;
+ case 2: m_colorram[addr] = data; break;
}
- state->m_tmap->mark_tile_dirty(addr);
+ m_tmap->mark_tile_dirty(addr);
}
-static WRITE8_HANDLER( dunhuang_tile2_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_tile2_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
int addr;
- if (state->m_written2 & (1 << offset))
+ if (m_written2 & (1 << offset))
{
- state->m_written2 = 0;
- state->m_pos_x++;
- if (state->m_pos_x == 0x40)
+ m_written2 = 0;
+ m_pos_x++;
+ if (m_pos_x == 0x40)
{
- state->m_pos_x = 0;
- state->m_pos_y++;
+ m_pos_x = 0;
+ m_pos_y++;
}
}
- state->m_written2 |= 1 << offset;
+ m_written2 |= 1 << offset;
- addr = (state->m_pos_x & 0x3f) + (state->m_pos_y & 0x07) * 0x40;
+ addr = (m_pos_x & 0x3f) + (m_pos_y & 0x07) * 0x40;
switch (offset)
{
- case 0: state->m_videoram2[addr] = (state->m_videoram2[addr] & 0xff00) | data; break;
- case 1: state->m_videoram2[addr] = (state->m_videoram2[addr] & 0x00ff) | (data<<8); break;
- case 2: state->m_colorram2[addr] = data; break;
+ case 0: m_videoram2[addr] = (m_videoram2[addr] & 0xff00) | data; break;
+ case 1: m_videoram2[addr] = (m_videoram2[addr] & 0x00ff) | (data<<8); break;
+ case 2: m_colorram2[addr] = data; break;
}
- state->m_tmap2->mark_tile_dirty(addr);
+ m_tmap2->mark_tile_dirty(addr);
}
// Clear a row of tiles (videoram)
-static WRITE8_HANDLER( dunhuang_clear_y_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_clear_y_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_clear_y = data;
+ m_clear_y = data;
}
-static WRITE8_HANDLER( dunhuang_horiz_clear_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_horiz_clear_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
int i;
-// logerror("%06x: horiz clear, y = %02x, data = %02d\n", cpu_get_pc(&space->device()), state->m_clear_y,data);
+// logerror("%06x: horiz clear, y = %02x, data = %02d\n", cpu_get_pc(&space.device()), m_clear_y,data);
for (i = 0; i < 0x40; i++)
{
- int addr = state->m_clear_y * 0x40 + i;
+ int addr = m_clear_y * 0x40 + i;
- state->m_videoram[addr] = 0;
- state->m_colorram[addr] = 0;
- state->m_tmap->mark_tile_dirty(addr);
+ m_videoram[addr] = 0;
+ m_colorram[addr] = 0;
+ m_tmap->mark_tile_dirty(addr);
}
}
// Clear a column of tiles (videoram2)
-static WRITE8_HANDLER( dunhuang_vert_clear_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_vert_clear_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
int i;
-// logerror("%06x: vert clear, x = %02x, y = %02x, data = %02x\n", cpu_get_pc(&space->device()), state->m_pos_x,state->m_pos_y,data);
+// logerror("%06x: vert clear, x = %02x, y = %02x, data = %02x\n", cpu_get_pc(&space.device()), m_pos_x,m_pos_y,data);
for (i = 0; i < 0x08; i++)
{
- int addr = (state->m_pos_x & 0x3f) + (i & 0x07) * 0x40;
+ int addr = (m_pos_x & 0x3f) + (i & 0x07) * 0x40;
- state->m_videoram2[addr] = 1;
- state->m_colorram2[addr] = 0;
- state->m_tmap2->mark_tile_dirty(addr);
+ m_videoram2[addr] = 1;
+ m_colorram2[addr] = 0;
+ m_tmap2->mark_tile_dirty(addr);
}
}
@@ -285,127 +301,116 @@ static WRITE8_HANDLER( dunhuang_vert_clear_w )
// The tiles codes are read from the graphics roms too!
//
-static WRITE8_HANDLER( dunhuang_block_dest_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_dest_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_dest = data;
+ m_block_dest = data;
}
-static WRITE8_HANDLER( dunhuang_block_x_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_x_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_x = data;
+ m_block_x = data;
}
-static WRITE8_HANDLER( dunhuang_block_y_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_y_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_y = data;
+ m_block_y = data;
}
-static WRITE8_HANDLER( dunhuang_block_w_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_w_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_w = data;
+ m_block_w = data;
}
-static WRITE8_HANDLER( dunhuang_block_c_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_c_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_c = data;
+ m_block_c = data;
}
-static WRITE8_HANDLER( dunhuang_block_addr_lo_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_addr_lo_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_addr_lo = data;
+ m_block_addr_lo = data;
}
-static WRITE8_HANDLER( dunhuang_block_addr_hi_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_addr_hi_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_block_addr_hi = data;
+ m_block_addr_hi = data;
}
-static WRITE8_HANDLER( dunhuang_block_h_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_block_h_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
int i,j, addr;
UINT8 *tile_addr;
-// logerror("%06x: block dst %x, src %x, xy %x %x, wh %x %x, clr %x\n", cpu_get_pc(&space->device()), state->m_block_dest, (state->m_block_addr_hi << 8) + state->m_block_addr_lo, state->m_block_x,state->m_block_y,state->m_block_w+1,state->m_block_h+1,state->m_block_c);
+// logerror("%06x: block dst %x, src %x, xy %x %x, wh %x %x, clr %x\n", cpu_get_pc(&space.device()), m_block_dest, (m_block_addr_hi << 8) + m_block_addr_lo, m_block_x,m_block_y,m_block_w+1,m_block_h+1,m_block_c);
- state->m_block_h = data;
+ m_block_h = data;
- tile_addr = space->machine().region("gfx2")->base() + ((state->m_block_addr_hi << 8) + state->m_block_addr_lo) * 4;
+ tile_addr = machine().region("gfx2")->base() + ((m_block_addr_hi << 8) + m_block_addr_lo) * 4;
- switch (state->m_block_dest)
+ switch (m_block_dest)
{
case 0x04: // write to videoram
- for (j = 0; j <= state->m_block_h; j++)
+ for (j = 0; j <= m_block_h; j++)
{
- for (i = 0; i <= state->m_block_w; i++)
+ for (i = 0; i <= m_block_w; i++)
{
- addr = ((state->m_block_x + i)& 0x3f) + ((state->m_block_y + j) & 0x1f) * 0x40;
+ addr = ((m_block_x + i)& 0x3f) + ((m_block_y + j) & 0x1f) * 0x40;
- state->m_videoram[addr] = (tile_addr[1] << 8) | tile_addr[0];
- state->m_colorram[addr] = state->m_block_c;
- state->m_tmap->mark_tile_dirty(addr);
+ m_videoram[addr] = (tile_addr[1] << 8) | tile_addr[0];
+ m_colorram[addr] = m_block_c;
+ m_tmap->mark_tile_dirty(addr);
tile_addr += 4;
}
}
break;
case 0x08: // write to videoram2
- for (j = 0; j <= state->m_block_h; j++)
+ for (j = 0; j <= m_block_h; j++)
{
- for (i = 0; i <= state->m_block_w; i++)
+ for (i = 0; i <= m_block_w; i++)
{
- addr = ((state->m_block_x + i)& 0x3f) + ((state->m_block_y + j) & 0x7) * 0x40;
+ addr = ((m_block_x + i)& 0x3f) + ((m_block_y + j) & 0x7) * 0x40;
- state->m_videoram2[addr] = (tile_addr[1] << 8) | tile_addr[0];
- state->m_colorram2[addr] = state->m_block_c;
- state->m_tmap2->mark_tile_dirty(addr);
+ m_videoram2[addr] = (tile_addr[1] << 8) | tile_addr[0];
+ m_colorram2[addr] = m_block_c;
+ m_tmap2->mark_tile_dirty(addr);
tile_addr += 4;
}
}
break;
default:
- popmessage("%06x: block dst=%x", cpu_get_pc(&space->device()), state->m_block_dest);
+ popmessage("%06x: block dst=%x", cpu_get_pc(&space.device()), m_block_dest);
}
}
// Palette: HMC HM86171 VGA 256 colour RAMDAC
-static WRITE8_HANDLER( dunhuang_paloffs_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_paloffs_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_paloffs = data * 3;
+ m_paloffs = data * 3;
}
-static WRITE8_HANDLER( dunhuang_paldata_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_paldata_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_paldata[state->m_paloffs] = data;
+ m_paldata[m_paloffs] = data;
- palette_set_color_rgb( space->machine(), state->m_paloffs/3,
- pal6bit(state->m_paldata[(state->m_paloffs/3)*3+0]),
- pal6bit(state->m_paldata[(state->m_paloffs/3)*3+1]),
- pal6bit(state->m_paldata[(state->m_paloffs/3)*3+2])
+ palette_set_color_rgb( machine(), m_paloffs/3,
+ pal6bit(m_paldata[(m_paloffs/3)*3+0]),
+ pal6bit(m_paldata[(m_paloffs/3)*3+1]),
+ pal6bit(m_paldata[(m_paloffs/3)*3+2])
);
- state->m_paloffs = (state->m_paloffs + 1) % (3*256);
+ m_paloffs = (m_paloffs + 1) % (3*256);
}
// Layers control (not understood)
-static WRITE8_HANDLER( dunhuang_layers_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_layers_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
// popmessage("layers %02x",data);
- state->m_layers = data;
+ m_layers = data;
}
/***************************************************************************
@@ -420,17 +425,15 @@ ADDRESS_MAP_END
// Inputs
-static WRITE8_HANDLER( dunhuang_input_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_input_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- state->m_input = data;
+ m_input = data;
}
-static READ8_HANDLER( dunhuang_service_r )
+READ8_MEMBER(dunhuang_state::dunhuang_service_r)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- return input_port_read(space->machine(), "SERVICE")
- | ((state->m_hopper && !(space->machine().primary_screen->frame_number() % 10)) ? 0x00 : 0x08) // bit 3: hopper sensor
+ return input_port_read(machine(), "SERVICE")
+ | ((m_hopper && !(machine().primary_screen->frame_number() % 10)) ? 0x00 : 0x08) // bit 3: hopper sensor
| 0x80 // bit 7 low -> tiles block transferrer busy
;
}
@@ -446,77 +449,75 @@ static READ8_DEVICE_HANDLER( dunhuang_dsw_r )
logerror("%s: warning, unknown dsw bits read, input = %02x\n", device->machine().describe_context(), state->m_input);
return 0xff;
}
-static READ8_HANDLER( dunhuang_input_r )
-{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
- if (!(state->m_input & 0x01)) return input_port_read(space->machine(), "IN0");
- if (!(state->m_input & 0x02)) return input_port_read(space->machine(), "IN1");
- if (!(state->m_input & 0x04)) return input_port_read(space->machine(), "IN2");
- if (!(state->m_input & 0x08)) return input_port_read(space->machine(), "IN3");
- if (!(state->m_input & 0x10)) return input_port_read(space->machine(), "IN4");
- logerror("%s: warning, unknown input bits read, input = %02x\n", space->machine().describe_context(), state->m_input);
+READ8_MEMBER(dunhuang_state::dunhuang_input_r)
+{
+ if (!(m_input & 0x01)) return input_port_read(machine(), "IN0");
+ if (!(m_input & 0x02)) return input_port_read(machine(), "IN1");
+ if (!(m_input & 0x04)) return input_port_read(machine(), "IN2");
+ if (!(m_input & 0x08)) return input_port_read(machine(), "IN3");
+ if (!(m_input & 0x10)) return input_port_read(machine(), "IN4");
+ logerror("%s: warning, unknown input bits read, input = %02x\n", machine().describe_context(), m_input);
return 0xff;
}
-static WRITE8_HANDLER( dunhuang_rombank_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_rombank_w)
{
- dunhuang_state *state = space->machine().driver_data<dunhuang_state>();
// ? data & 0x01
// ? data & 0x02
- memory_set_bank(space->machine(), "bank1", ((data >> 2) & 0x7));
+ memory_set_bank(machine(), "bank1", ((data >> 2) & 0x7));
// COIN OUT: data & 0x20
- coin_counter_w(space->machine(), 0, data & 0x40);
- state->m_hopper = data & 0x80;
+ coin_counter_w(machine(), 0, data & 0x40);
+ m_hopper = data & 0x80;
}
#ifdef UNUSED_FUNCTION
-static WRITE8_HANDLER( dunhuang_82_w )
+WRITE8_MEMBER(dunhuang_state::dunhuang_82_w)
{
// popmessage("82 = %02x",dunhuang_82);
}
#endif
static ADDRESS_MAP_START( dunhuang_io_map, AS_IO, 8, dunhuang_state )
- AM_RANGE( 0x0000, 0x0000 ) AM_WRITE_LEGACY(dunhuang_pos_x_w )
- AM_RANGE( 0x0001, 0x0001 ) AM_WRITE_LEGACY(dunhuang_pos_y_w )
- AM_RANGE( 0x0002, 0x0004 ) AM_WRITE_LEGACY(dunhuang_tile_w )
- AM_RANGE( 0x0005, 0x0007 ) AM_WRITE_LEGACY(dunhuang_tile2_w )
+ AM_RANGE( 0x0000, 0x0000 ) AM_WRITE(dunhuang_pos_x_w )
+ AM_RANGE( 0x0001, 0x0001 ) AM_WRITE(dunhuang_pos_y_w )
+ AM_RANGE( 0x0002, 0x0004 ) AM_WRITE(dunhuang_tile_w )
+ AM_RANGE( 0x0005, 0x0007 ) AM_WRITE(dunhuang_tile2_w )
- AM_RANGE( 0x0008, 0x0008 ) AM_WRITE_LEGACY(dunhuang_vert_clear_w )
+ AM_RANGE( 0x0008, 0x0008 ) AM_WRITE(dunhuang_vert_clear_w )
AM_RANGE( 0x000c, 0x000c ) AM_READ_LEGACY(watchdog_reset_r )
- AM_RANGE( 0x000f, 0x000f ) AM_WRITE_LEGACY(dunhuang_block_addr_lo_w )
- AM_RANGE( 0x0010, 0x0010 ) AM_WRITE_LEGACY(dunhuang_block_addr_hi_w )
+ AM_RANGE( 0x000f, 0x000f ) AM_WRITE(dunhuang_block_addr_lo_w )
+ AM_RANGE( 0x0010, 0x0010 ) AM_WRITE(dunhuang_block_addr_hi_w )
// AM_RANGE( 0x0011, 0x0011 ) ?
- AM_RANGE( 0x0012, 0x0012 ) AM_WRITE_LEGACY(dunhuang_block_c_w )
- AM_RANGE( 0x0015, 0x0015 ) AM_WRITE_LEGACY(dunhuang_block_x_w )
- AM_RANGE( 0x0016, 0x0016 ) AM_WRITE_LEGACY(dunhuang_block_y_w )
- AM_RANGE( 0x0017, 0x0017 ) AM_WRITE_LEGACY(dunhuang_block_w_w )
- AM_RANGE( 0x0018, 0x0018 ) AM_WRITE_LEGACY(dunhuang_block_h_w )
+ AM_RANGE( 0x0012, 0x0012 ) AM_WRITE(dunhuang_block_c_w )
+ AM_RANGE( 0x0015, 0x0015 ) AM_WRITE(dunhuang_block_x_w )
+ AM_RANGE( 0x0016, 0x0016 ) AM_WRITE(dunhuang_block_y_w )
+ AM_RANGE( 0x0017, 0x0017 ) AM_WRITE(dunhuang_block_w_w )
+ AM_RANGE( 0x0018, 0x0018 ) AM_WRITE(dunhuang_block_h_w )
- AM_RANGE( 0x0019, 0x0019 ) AM_WRITE_LEGACY(dunhuang_clear_y_w )
- AM_RANGE( 0x001a, 0x001a ) AM_WRITE_LEGACY(dunhuang_horiz_clear_w )
+ AM_RANGE( 0x0019, 0x0019 ) AM_WRITE(dunhuang_clear_y_w )
+ AM_RANGE( 0x001a, 0x001a ) AM_WRITE(dunhuang_horiz_clear_w )
- AM_RANGE( 0x001b, 0x001b ) AM_WRITE_LEGACY(dunhuang_block_dest_w )
+ AM_RANGE( 0x001b, 0x001b ) AM_WRITE(dunhuang_block_dest_w )
AM_RANGE( 0x0081, 0x0081 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_register_port_w )
AM_RANGE( 0x0089, 0x0089 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_data_port_w )
-// AM_RANGE( 0x0082, 0x0082 ) AM_WRITE_LEGACY(dunhuang_82_w )
+// AM_RANGE( 0x0082, 0x0082 ) AM_WRITE(dunhuang_82_w )
- AM_RANGE( 0x0083, 0x0083 ) AM_WRITE_LEGACY(dunhuang_paloffs_w )
- AM_RANGE( 0x008b, 0x008b ) AM_WRITE_LEGACY(dunhuang_paldata_w )
+ AM_RANGE( 0x0083, 0x0083 ) AM_WRITE(dunhuang_paloffs_w )
+ AM_RANGE( 0x008b, 0x008b ) AM_WRITE(dunhuang_paldata_w )
- AM_RANGE( 0x0084, 0x0084 ) AM_READ_LEGACY(dunhuang_service_r )
- AM_RANGE( 0x0085, 0x0085 ) AM_READ_LEGACY(dunhuang_input_r )
+ AM_RANGE( 0x0084, 0x0084 ) AM_READ(dunhuang_service_r )
+ AM_RANGE( 0x0085, 0x0085 ) AM_READ(dunhuang_input_r )
- AM_RANGE( 0x0086, 0x0086 ) AM_WRITE_LEGACY(dunhuang_rombank_w )
- AM_RANGE( 0x0087, 0x0087 ) AM_WRITE_LEGACY(dunhuang_layers_w )
+ AM_RANGE( 0x0086, 0x0086 ) AM_WRITE(dunhuang_rombank_w )
+ AM_RANGE( 0x0087, 0x0087 ) AM_WRITE(dunhuang_layers_w )
AM_RANGE( 0x0088, 0x0088 ) AM_DEVREAD_LEGACY("ay8910", ay8910_r )
AM_RANGE( 0x0090, 0x0090 ) AM_DEVWRITE_LEGACY("ay8910", ay8910_data_w )
@@ -757,7 +758,7 @@ static const ay8910_interface dunhuang_ay8910_interface =
AY8910_DEFAULT_LOADS,
// A B
DEVCB_NULL, DEVCB_HANDLER(dunhuang_dsw_r), // R
- DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, dunhuang_input_w), DEVCB_NULL // W
+ DEVCB_DRIVER_MEMBER(dunhuang_state, dunhuang_input_w), DEVCB_NULL // W
};
diff --git a/src/mame/drivers/famibox.c b/src/mame/drivers/famibox.c
index f019123ea4a..6cf98e76079 100644
--- a/src/mame/drivers/famibox.c
+++ b/src/mame/drivers/famibox.c
@@ -91,6 +91,14 @@ public:
emu_timer* m_gameplay_timer;
UINT8 m_money_reg;
+ DECLARE_WRITE8_MEMBER(famibox_nt_w);
+ DECLARE_READ8_MEMBER(famibox_nt_r);
+ DECLARE_WRITE8_MEMBER(sprite_dma_w);
+ DECLARE_READ8_MEMBER(famibox_IN0_r);
+ DECLARE_WRITE8_MEMBER(famibox_IN0_w);
+ DECLARE_READ8_MEMBER(famibox_IN1_r);
+ DECLARE_READ8_MEMBER(famibox_system_r);
+ DECLARE_WRITE8_MEMBER(famibox_system_w);
};
/******************************************************
@@ -133,19 +141,17 @@ static void set_mirroring(famibox_state *state, int mirroring)
}
#endif
-static WRITE8_HANDLER (famibox_nt_w)
+WRITE8_MEMBER(famibox_state::famibox_nt_w)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
int page = ((offset & 0xc00) >> 10);
- state->m_nt_page[page][offset & 0x3ff] = data;
+ m_nt_page[page][offset & 0x3ff] = data;
}
-static READ8_HANDLER (famibox_nt_r)
+READ8_MEMBER(famibox_state::famibox_nt_r)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
int page = ((offset & 0xc00) >> 10);
- return state->m_nt_page[page][offset & 0x3ff];
+ return m_nt_page[page][offset & 0x3ff];
}
/******************************************************
@@ -154,11 +160,11 @@ static READ8_HANDLER (famibox_nt_r)
*******************************************************/
-static WRITE8_HANDLER( sprite_dma_w )
+WRITE8_MEMBER(famibox_state::sprite_dma_w)
{
- ppu2c0x_device *ppu = space->machine().device<ppu2c0x_device>("ppu");
+ ppu2c0x_device *ppu = machine().device<ppu2c0x_device>("ppu");
int source = (data & 7);
- ppu->spriteram_dma(space, source);
+ ppu->spriteram_dma(&space, source);
}
static READ8_DEVICE_HANDLER( psg_4015_r )
@@ -183,31 +189,28 @@ static WRITE8_DEVICE_HANDLER( psg_4017_w )
*******************************************************/
-static READ8_HANDLER( famibox_IN0_r )
+READ8_MEMBER(famibox_state::famibox_IN0_r)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
- return ((state->m_in_0 >> state->m_in_0_shift++) & 0x01) | 0x40;
+ return ((m_in_0 >> m_in_0_shift++) & 0x01) | 0x40;
}
-static WRITE8_HANDLER( famibox_IN0_w )
+WRITE8_MEMBER(famibox_state::famibox_IN0_w)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
if (data & 0x01)
{
return;
}
- state->m_in_0_shift = 0;
- state->m_in_1_shift = 0;
+ m_in_0_shift = 0;
+ m_in_1_shift = 0;
- state->m_in_0 = input_port_read(space->machine(), "P1");
- state->m_in_1 = input_port_read(space->machine(), "P2");
+ m_in_0 = input_port_read(machine(), "P1");
+ m_in_1 = input_port_read(machine(), "P2");
}
-static READ8_HANDLER( famibox_IN1_r )
+READ8_MEMBER(famibox_state::famibox_IN1_r)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
- return ((state->m_in_1 >> state->m_in_1_shift++) & 0x01) | 0x40;
+ return ((m_in_1 >> m_in_1_shift++) & 0x01) | 0x40;
}
/******************************************************
@@ -295,36 +298,34 @@ static TIMER_CALLBACK(famicombox_gameplay_timer_callback)
}
}
-static READ8_HANDLER( famibox_system_r )
+READ8_MEMBER(famibox_state::famibox_system_r)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
switch( offset & 0x07 )
{
case 0: /* device which caused exception */
{
- UINT8 ret = state->m_exception_cause;
- state->m_exception_cause = 0xff;
+ UINT8 ret = m_exception_cause;
+ m_exception_cause = 0xff;
return ret;
}
case 2:
- return input_port_read(space->machine(), "DSW");
+ return input_port_read(machine(), "DSW");
case 3:
- return input_port_read(space->machine(), "KEYSWITCH");
+ return input_port_read(machine(), "KEYSWITCH");
case 7:
return 0x02;
default:
- logerror("%s: Unhandled famibox_system_r(%x)\n", space->machine().describe_context(), offset );
+ logerror("%s: Unhandled famibox_system_r(%x)\n", machine().describe_context(), offset );
return 0;
}
}
-static WRITE8_HANDLER( famibox_system_w )
+WRITE8_MEMBER(famibox_state::famibox_system_w)
{
- famibox_state *state = space->machine().driver_data<famibox_state>();
switch( offset & 0x07 )
{
case 0:
- logerror("%s: Interrupt enable\n", space->machine().describe_context());
+ logerror("%s: Interrupt enable\n", machine().describe_context());
logerror("6.82Hz interrupt source (0 = enable): %d\n", BIT(data,0));
logerror("8 bit timer expiration @ 5003W (1 = enable): %d\n", BIT(data,1));
logerror("controller reads (1 = enable): %d\n", BIT(data,2));
@@ -332,36 +333,36 @@ static WRITE8_HANDLER( famibox_system_w )
logerror("money insertion (1 = enable): %d\n", BIT(data,4));
logerror("reset button (1 = enable): %d\n", BIT(data,5));
logerror("\"CATV connector\" pin 4 detection (1 = enable): %d\n", BIT(data,7));
- state->m_exception_mask = data;
- if ( BIT(state->m_exception_mask,1) && ( state->m_attract_timer_period != 0 ) )
+ m_exception_mask = data;
+ if ( BIT(m_exception_mask,1) && ( m_attract_timer_period != 0 ) )
{
- if (state->m_attract_timer->start() != attotime::never)
+ if (m_attract_timer->start() != attotime::never)
{
- state->m_attract_timer->adjust(attotime::from_seconds((INT32)((double)1.0/6.8274*state->m_attract_timer_period)), 0, attotime::never);
+ m_attract_timer->adjust(attotime::from_seconds((INT32)((double)1.0/6.8274*m_attract_timer_period)), 0, attotime::never);
}
}
break;
case 1:
- state->m_money_reg = data;
- logerror("%s: Money handling register: %02x\n", space->machine().describe_context(), data);
+ m_money_reg = data;
+ logerror("%s: Money handling register: %02x\n", machine().describe_context(), data);
break;
case 2:
- logerror("%s: LED & memory protect register: %02x\n", space->machine().describe_context(), data);
+ logerror("%s: LED & memory protect register: %02x\n", machine().describe_context(), data);
break;
case 3:
- logerror("%s: 8 bit down counter, for attract mode timing: %02x\n", space->machine().describe_context(), data);
- state->m_attract_timer_period = data;
- if ( BIT(state->m_exception_mask,1) && ( data != 0 ) )
+ logerror("%s: 8 bit down counter, for attract mode timing: %02x\n", machine().describe_context(), data);
+ m_attract_timer_period = data;
+ if ( BIT(m_exception_mask,1) && ( data != 0 ) )
{
- state->m_attract_timer->adjust(attotime::from_hz(6.8274/state->m_attract_timer_period), 0, attotime::never);
+ m_attract_timer->adjust(attotime::from_hz(6.8274/m_attract_timer_period), 0, attotime::never);
}
break;
case 4:
- logerror("%s: bankswitch %x\n", space->machine().describe_context(), data );
- famicombox_bankswitch(space->machine(), data & 0x3f);
+ logerror("%s: bankswitch %x\n", machine().describe_context(), data );
+ famicombox_bankswitch(machine(), data & 0x3f);
break;
default:
- logerror("%s: Unhandled famibox_system_w(%x,%02x)\n", space->machine().describe_context(), offset, data );
+ logerror("%s: Unhandled famibox_system_w(%x,%02x)\n", machine().describe_context(), offset, data );
}
}
@@ -376,11 +377,11 @@ static ADDRESS_MAP_START( famibox_map, AS_PROGRAM, 8, famibox_state )
AM_RANGE(0x0000, 0x1fff) AM_RAM
AM_RANGE(0x2000, 0x3fff) AM_DEVREADWRITE("ppu", ppu2c0x_device, read, write)
AM_RANGE(0x4000, 0x4013) AM_DEVREADWRITE_LEGACY("nes", nes_psg_r, nes_psg_w) /* PSG primary registers */
- AM_RANGE(0x4014, 0x4014) AM_WRITE_LEGACY(sprite_dma_w)
+ AM_RANGE(0x4014, 0x4014) AM_WRITE(sprite_dma_w)
AM_RANGE(0x4015, 0x4015) AM_DEVREADWRITE_LEGACY("nes", psg_4015_r, psg_4015_w) /* PSG status / first control register */
- AM_RANGE(0x4016, 0x4016) AM_READWRITE_LEGACY(famibox_IN0_r, famibox_IN0_w) /* IN0 - input port 1 */
- AM_RANGE(0x4017, 0x4017) AM_READ_LEGACY(famibox_IN1_r) AM_DEVWRITE_LEGACY("nes", psg_4017_w) /* IN1 - input port 2 / PSG second control register */
- AM_RANGE(0x5000, 0x5fff) AM_READWRITE_LEGACY(famibox_system_r, famibox_system_w)
+ AM_RANGE(0x4016, 0x4016) AM_READWRITE(famibox_IN0_r, famibox_IN0_w) /* IN0 - input port 1 */
+ AM_RANGE(0x4017, 0x4017) AM_READ(famibox_IN1_r) AM_DEVWRITE_LEGACY("nes", psg_4017_w) /* IN1 - input port 2 / PSG second control register */
+ AM_RANGE(0x5000, 0x5fff) AM_READWRITE(famibox_system_r, famibox_system_w)
AM_RANGE(0x6000, 0x7fff) AM_RAM
AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("cpubank1")
AM_RANGE(0xc000, 0xffff) AM_ROMBANK("cpubank2")
@@ -553,7 +554,7 @@ static MACHINE_START( famibox )
state->m_nt_page[2] = state->m_nt_ram + 0x800;
state->m_nt_page[3] = state->m_nt_ram + 0xc00;
- machine.device("ppu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x2000, 0x3eff, FUNC(famibox_nt_r), FUNC(famibox_nt_w));
+ machine.device("ppu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0x2000, 0x3eff, read8_delegate(FUNC(famibox_state::famibox_nt_r), state), write8_delegate(FUNC(famibox_state::famibox_nt_w), state));
machine.device("ppu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x1fff, "ppubank1");
famicombox_bankswitch(machine, 0);
diff --git a/src/mame/drivers/firefox.c b/src/mame/drivers/firefox.c
index ea66b914554..4ca9747c308 100644
--- a/src/mame/drivers/firefox.c
+++ b/src/mame/drivers/firefox.c
@@ -57,6 +57,35 @@ public:
UINT8 m_main_to_sound_flag;
int m_sprite_bank;
UINT8 *m_spriteram;
+ DECLARE_READ8_MEMBER(firefox_disc_status_r);
+ DECLARE_READ8_MEMBER(firefox_disc_data_r);
+ DECLARE_WRITE8_MEMBER(firefox_disc_read_w);
+ DECLARE_WRITE8_MEMBER(firefox_disc_lock_w);
+ DECLARE_WRITE8_MEMBER(audio_enable_w);
+ DECLARE_WRITE8_MEMBER(firefox_disc_reset_w);
+ DECLARE_WRITE8_MEMBER(firefox_disc_write_w);
+ DECLARE_WRITE8_MEMBER(firefox_disc_data_w);
+ DECLARE_WRITE8_MEMBER(tileram_w);
+ DECLARE_WRITE8_MEMBER(tile_palette_w);
+ DECLARE_WRITE8_MEMBER(sprite_palette_w);
+ DECLARE_WRITE8_MEMBER(firefox_objram_bank_w);
+ DECLARE_READ8_MEMBER(sound_to_main_r);
+ DECLARE_WRITE8_MEMBER(main_to_sound_w);
+ DECLARE_WRITE8_MEMBER(sound_reset_w);
+ DECLARE_READ8_MEMBER(main_to_sound_r);
+ DECLARE_WRITE8_MEMBER(sound_to_main_w);
+ DECLARE_READ8_MEMBER(adc_r);
+ DECLARE_WRITE8_MEMBER(adc_select_w);
+ DECLARE_WRITE8_MEMBER(nvram_w);
+ DECLARE_READ8_MEMBER(nvram_r);
+ DECLARE_WRITE8_MEMBER(novram_recall_w);
+ DECLARE_WRITE8_MEMBER(novram_store_w);
+ DECLARE_WRITE8_MEMBER(rom_bank_w);
+ DECLARE_WRITE8_MEMBER(main_irq_clear_w);
+ DECLARE_WRITE8_MEMBER(main_firq_clear_w);
+ DECLARE_WRITE8_MEMBER(self_reset_w);
+ DECLARE_WRITE8_MEMBER(led_w);
+ DECLARE_WRITE8_MEMBER(firefox_coin_counter_w);
};
@@ -88,15 +117,14 @@ fffe=reset e7cc
40 = DISKFULL - Active low
80 = DISKDAV - Active low data available
*/
-static READ8_HANDLER( firefox_disc_status_r )
+READ8_MEMBER(firefox_state::firefox_disc_status_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
UINT8 result = 0xff;
result ^= 0x20;
- if (!state->m_laserdisc->ready_r())
+ if (!m_laserdisc->ready_r())
result ^= 0x40;
- if (state->m_laserdisc->data_available_r())
+ if (m_laserdisc->data_available_r())
result ^= 0x80;
return result;
@@ -104,51 +132,44 @@ static READ8_HANDLER( firefox_disc_status_r )
/* 4105 - DREAD */
/* this reset RDDSK (&DSKRD) */
-static READ8_HANDLER( firefox_disc_data_r )
+READ8_MEMBER(firefox_state::firefox_disc_data_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- return state->m_n_disc_read_data;
+ return m_n_disc_read_data;
}
/* DISK READ ENABLE */
/* 4218 - DSKREAD, set RDDSK */
-static WRITE8_HANDLER( firefox_disc_read_w )
+WRITE8_MEMBER(firefox_state::firefox_disc_read_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_n_disc_read_data = state->m_laserdisc->data_r();
+ m_n_disc_read_data = m_laserdisc->data_r();
}
-static WRITE8_HANDLER( firefox_disc_lock_w )
+WRITE8_MEMBER(firefox_state::firefox_disc_lock_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_n_disc_lock = data & 0x80;
+ m_n_disc_lock = data & 0x80;
}
-static WRITE8_HANDLER( audio_enable_w )
+WRITE8_MEMBER(firefox_state::audio_enable_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_laserdisc->set_output_gain(~offset & 1, (data & 0x80) ? 1.0 : 0.0);
+ m_laserdisc->set_output_gain(~offset & 1, (data & 0x80) ? 1.0 : 0.0);
}
-static WRITE8_HANDLER( firefox_disc_reset_w )
+WRITE8_MEMBER(firefox_state::firefox_disc_reset_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_laserdisc->reset_w((data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
+ m_laserdisc->reset_w((data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
}
/* active low on dbb7 */
-static WRITE8_HANDLER( firefox_disc_write_w )
+WRITE8_MEMBER(firefox_state::firefox_disc_write_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
if ( ( data & 0x80 ) == 0 )
- state->m_laserdisc->data_w(state->m_n_disc_data);
+ m_laserdisc->data_w(m_n_disc_data);
}
/* latch the data */
-static WRITE8_HANDLER( firefox_disc_data_w )
+WRITE8_MEMBER(firefox_state::firefox_disc_data_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_n_disc_data = data;
+ m_n_disc_data = data;
}
@@ -167,11 +188,10 @@ static TILE_GET_INFO( bgtile_get_info )
}
-static WRITE8_HANDLER( tileram_w )
+WRITE8_MEMBER(firefox_state::tileram_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_tileram[offset] = data;
- state->m_bgtiles->mark_tile_dirty(offset);
+ m_tileram[offset] = data;
+ m_bgtiles->mark_tile_dirty(offset);
}
@@ -237,24 +257,21 @@ static void set_rgba( running_machine &machine, int start, int index, unsigned c
palette_set_color( machine, start + index, MAKE_ARGB( a, r, g, b ) );
}
-static WRITE8_HANDLER( tile_palette_w )
+WRITE8_MEMBER(firefox_state::tile_palette_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_tile_palette[ offset ] = data;
- set_rgba( space->machine(), 0, offset & 0xff, state->m_tile_palette );
+ m_tile_palette[ offset ] = data;
+ set_rgba( machine(), 0, offset & 0xff, m_tile_palette );
}
-static WRITE8_HANDLER( sprite_palette_w )
+WRITE8_MEMBER(firefox_state::sprite_palette_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_sprite_palette[ offset ] = data;
- set_rgba( space->machine(), 256, offset & 0xff, state->m_sprite_palette );
+ m_sprite_palette[ offset ] = data;
+ set_rgba( machine(), 256, offset & 0xff, m_sprite_palette );
}
-static WRITE8_HANDLER( firefox_objram_bank_w )
+WRITE8_MEMBER(firefox_state::firefox_objram_bank_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_sprite_bank = data & 0x03;
+ m_sprite_bank = data & 0x03;
}
@@ -277,40 +294,35 @@ static CUSTOM_INPUT( soundflag_r )
return state->m_sound_to_main_flag;
}
-static READ8_HANDLER( sound_to_main_r )
+READ8_MEMBER(firefox_state::sound_to_main_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_sound_to_main_flag = 0;
+ m_sound_to_main_flag = 0;
return soundlatch2_r(space, 0);
}
-static WRITE8_HANDLER( main_to_sound_w )
+WRITE8_MEMBER(firefox_state::main_to_sound_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_main_to_sound_flag = 1;
+ m_main_to_sound_flag = 1;
soundlatch_w(space, 0, data);
- cputag_set_input_line(space->machine(), "audiocpu", INPUT_LINE_NMI, PULSE_LINE);
+ cputag_set_input_line(machine(), "audiocpu", INPUT_LINE_NMI, PULSE_LINE);
}
-static WRITE8_HANDLER( sound_reset_w )
+WRITE8_MEMBER(firefox_state::sound_reset_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- cputag_set_input_line(space->machine(), "audiocpu", INPUT_LINE_RESET, (data & 0x80) ? ASSERT_LINE : CLEAR_LINE);
+ cputag_set_input_line(machine(), "audiocpu", INPUT_LINE_RESET, (data & 0x80) ? ASSERT_LINE : CLEAR_LINE);
if ((data & 0x80) != 0)
- state->m_sound_to_main_flag = state->m_main_to_sound_flag = 0;
+ m_sound_to_main_flag = m_main_to_sound_flag = 0;
}
-static READ8_HANDLER( main_to_sound_r )
+READ8_MEMBER(firefox_state::main_to_sound_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_main_to_sound_flag = 0;
+ m_main_to_sound_flag = 0;
return soundlatch_r(space, 0);
}
-static WRITE8_HANDLER( sound_to_main_w )
+WRITE8_MEMBER(firefox_state::sound_to_main_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_sound_to_main_flag = 1;
+ m_sound_to_main_flag = 1;
soundlatch2_w(space, 0, data);
}
@@ -361,21 +373,19 @@ static WRITE_LINE_DEVICE_HANDLER( riot_irq )
*
*************************************/
-static READ8_HANDLER( adc_r )
+READ8_MEMBER(firefox_state::adc_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- if( state->m_control_num == 0 )
+ if( m_control_num == 0 )
{
- return input_port_read( space->machine(), "PITCH" );
+ return input_port_read( machine(), "PITCH" );
}
- return input_port_read( space->machine(), "YAW" );
+ return input_port_read( machine(), "YAW" );
}
-static WRITE8_HANDLER( adc_select_w )
+WRITE8_MEMBER(firefox_state::adc_select_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_control_num = offset;
+ m_control_num = offset;
}
@@ -386,31 +396,27 @@ static WRITE8_HANDLER( adc_select_w )
*
*************************************/
-static WRITE8_HANDLER( nvram_w )
+WRITE8_MEMBER(firefox_state::nvram_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_nvram_1c->write(*space, offset, data >> 4);
- state->m_nvram_1d->write(*space, offset, data & 0xf);
+ m_nvram_1c->write(*&space, offset, data >> 4);
+ m_nvram_1d->write(*&space, offset, data & 0xf);
}
-static READ8_HANDLER( nvram_r )
+READ8_MEMBER(firefox_state::nvram_r)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- return (state->m_nvram_1c->read(*space, offset) << 4) | (state->m_nvram_1d->read(*space, offset) & 0x0f);
+ return (m_nvram_1c->read(*&space, offset) << 4) | (m_nvram_1d->read(*&space, offset) & 0x0f);
}
-static WRITE8_HANDLER( novram_recall_w )
+WRITE8_MEMBER(firefox_state::novram_recall_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_nvram_1c->recall(data & 0x80);
- state->m_nvram_1d->recall(data & 0x80);
+ m_nvram_1c->recall(data & 0x80);
+ m_nvram_1d->recall(data & 0x80);
}
-static WRITE8_HANDLER( novram_store_w )
+WRITE8_MEMBER(firefox_state::novram_store_w)
{
- firefox_state *state = space->machine().driver_data<firefox_state>();
- state->m_nvram_1c->store(data & 0x80);
- state->m_nvram_1d->store(data & 0x80);
+ m_nvram_1c->store(data & 0x80);
+ m_nvram_1d->store(data & 0x80);
}
@@ -421,24 +427,24 @@ static WRITE8_HANDLER( novram_store_w )
*
*************************************/
-static WRITE8_HANDLER( rom_bank_w )
+WRITE8_MEMBER(firefox_state::rom_bank_w)
{
- memory_set_bank(space->machine(), "bank1", data & 0x1f);
+ memory_set_bank(machine(), "bank1", data & 0x1f);
}
-static WRITE8_HANDLER( main_irq_clear_w )
+WRITE8_MEMBER(firefox_state::main_irq_clear_w)
{
- cputag_set_input_line( space->machine(), "maincpu", M6809_IRQ_LINE, CLEAR_LINE );
+ cputag_set_input_line( machine(), "maincpu", M6809_IRQ_LINE, CLEAR_LINE );
}
-static WRITE8_HANDLER( main_firq_clear_w )
+WRITE8_MEMBER(firefox_state::main_firq_clear_w)
{
- cputag_set_input_line( space->machine(), "maincpu", M6809_FIRQ_LINE, CLEAR_LINE );
+ cputag_set_input_line( machine(), "maincpu", M6809_FIRQ_LINE, CLEAR_LINE );
}
-static WRITE8_HANDLER( self_reset_w )
+WRITE8_MEMBER(firefox_state::self_reset_w)
{
- cputag_set_input_line( space->machine(), "maincpu", INPUT_LINE_RESET, PULSE_LINE );
+ cputag_set_input_line( machine(), "maincpu", INPUT_LINE_RESET, PULSE_LINE );
}
@@ -449,14 +455,14 @@ static WRITE8_HANDLER( self_reset_w )
*
*************************************/
-static WRITE8_HANDLER( led_w )
+WRITE8_MEMBER(firefox_state::led_w)
{
- set_led_status( space->machine(), offset, ( data & 0x80 ) == 0 );
+ set_led_status( machine(), offset, ( data & 0x80 ) == 0 );
}
-static WRITE8_HANDLER( firefox_coin_counter_w )
+WRITE8_MEMBER(firefox_state::firefox_coin_counter_w)
{
- coin_counter_w( space->machine(), offset, data & 0x80 );
+ coin_counter_w( machine(), offset, data & 0x80 );
}
@@ -490,39 +496,39 @@ static MACHINE_START( firefox )
static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, firefox_state )
AM_RANGE(0x0000, 0x0fff) AM_RAM
- AM_RANGE(0x1000, 0x1fff) AM_RAM_WRITE_LEGACY(tileram_w) AM_BASE(m_tileram)
+ AM_RANGE(0x1000, 0x1fff) AM_RAM_WRITE(tileram_w) AM_BASE(m_tileram)
AM_RANGE(0x2000, 0x27ff) AM_RAM AM_BASE(m_spriteram)
- AM_RANGE(0x2800, 0x2aff) AM_RAM_WRITE_LEGACY(sprite_palette_w) AM_BASE(m_sprite_palette)
- AM_RANGE(0x2b00, 0x2b00) AM_MIRROR(0x04ff) AM_WRITE_LEGACY(firefox_objram_bank_w)
- AM_RANGE(0x2c00, 0x2eff) AM_RAM_WRITE_LEGACY(tile_palette_w) AM_BASE(m_tile_palette)
+ AM_RANGE(0x2800, 0x2aff) AM_RAM_WRITE(sprite_palette_w) AM_BASE(m_sprite_palette)
+ AM_RANGE(0x2b00, 0x2b00) AM_MIRROR(0x04ff) AM_WRITE(firefox_objram_bank_w)
+ AM_RANGE(0x2c00, 0x2eff) AM_RAM_WRITE(tile_palette_w) AM_BASE(m_tile_palette)
AM_RANGE(0x3000, 0x3fff) AM_ROMBANK("bank1")
- AM_RANGE(0x4000, 0x40ff) AM_READWRITE_LEGACY(nvram_r, nvram_w) /* NOVRAM */
+ AM_RANGE(0x4000, 0x40ff) AM_READWRITE(nvram_r, nvram_w) /* NOVRAM */
AM_RANGE(0x4100, 0x4100) AM_MIRROR(0x00f8) AM_READ_PORT("rdin0") /* RDIN0 */
AM_RANGE(0x4101, 0x4101) AM_MIRROR(0x00f8) AM_READ_PORT("rdin1") /* RDIN1 */
- AM_RANGE(0x4102, 0x4102) AM_MIRROR(0x00f8) AM_READ_LEGACY(firefox_disc_status_r) /* RDIN2 */
+ AM_RANGE(0x4102, 0x4102) AM_MIRROR(0x00f8) AM_READ(firefox_disc_status_r) /* RDIN2 */
AM_RANGE(0x4103, 0x4103) AM_MIRROR(0x00f8) AM_READ_PORT("opt0") /* OPT0 */
AM_RANGE(0x4104, 0x4104) AM_MIRROR(0x00f8) AM_READ_PORT("opt1") /* OPT1 */
- AM_RANGE(0x4105, 0x4105) AM_MIRROR(0x00f8) AM_READ_LEGACY(firefox_disc_data_r) /* DREAD */
- AM_RANGE(0x4106, 0x4106) AM_MIRROR(0x00f8) AM_READ_LEGACY(sound_to_main_r) /* RDSOUND */
- AM_RANGE(0x4107, 0x4107) AM_MIRROR(0x00f8) AM_READ_LEGACY(adc_r) /* ADC */
- AM_RANGE(0x4200, 0x4200) AM_MIRROR(0x0047) AM_WRITE_LEGACY(main_irq_clear_w) /* RSTIRQ */
- AM_RANGE(0x4208, 0x4208) AM_MIRROR(0x0047) AM_WRITE_LEGACY(main_firq_clear_w) /* RSTFIRQ */
+ AM_RANGE(0x4105, 0x4105) AM_MIRROR(0x00f8) AM_READ(firefox_disc_data_r) /* DREAD */
+ AM_RANGE(0x4106, 0x4106) AM_MIRROR(0x00f8) AM_READ(sound_to_main_r) /* RDSOUND */
+ AM_RANGE(0x4107, 0x4107) AM_MIRROR(0x00f8) AM_READ(adc_r) /* ADC */
+ AM_RANGE(0x4200, 0x4200) AM_MIRROR(0x0047) AM_WRITE(main_irq_clear_w) /* RSTIRQ */
+ AM_RANGE(0x4208, 0x4208) AM_MIRROR(0x0047) AM_WRITE(main_firq_clear_w) /* RSTFIRQ */
AM_RANGE(0x4210, 0x4210) AM_MIRROR(0x0047) AM_WRITE_LEGACY(watchdog_reset_w) /* WDCLK */
- AM_RANGE(0x4218, 0x4218) AM_MIRROR(0x0047) AM_WRITE_LEGACY(firefox_disc_read_w) /* DSKREAD */
- AM_RANGE(0x4220, 0x4223) AM_MIRROR(0x0044) AM_WRITE_LEGACY(adc_select_w) /* ADCSTART */
- AM_RANGE(0x4230, 0x4230) AM_MIRROR(0x0047) AM_WRITE_LEGACY(self_reset_w) /* AMUCK */
- AM_RANGE(0x4280, 0x4280) AM_MIRROR(0x0040) AM_WRITE_LEGACY(novram_recall_w) /* LATCH0 -> NVRECALL */
- AM_RANGE(0x4281, 0x4281) AM_MIRROR(0x0040) AM_WRITE_LEGACY(sound_reset_w) /* LATCH0 -> RSTSOUND */
- AM_RANGE(0x4282, 0x4282) AM_MIRROR(0x0040) AM_WRITE_LEGACY(novram_store_w) /* LATCH0 -> NVRSTORE */
- AM_RANGE(0x4283, 0x4283) AM_MIRROR(0x0040) AM_WRITE_LEGACY(firefox_disc_lock_w) /* LATCH0 -> LOCK */
- AM_RANGE(0x4284, 0x4285) AM_MIRROR(0x0040) AM_WRITE_LEGACY(audio_enable_w) /* LATCH0 -> SWDSKR, SWDSKL */
- AM_RANGE(0x4286, 0x4286) AM_MIRROR(0x0040) AM_WRITE_LEGACY(firefox_disc_reset_w) /* LATCH0 -> RSTDSK */
- AM_RANGE(0x4287, 0x4287) AM_MIRROR(0x0040) AM_WRITE_LEGACY(firefox_disc_write_w) /* LATCH0 -> WRDSK */
- AM_RANGE(0x4288, 0x4289) AM_MIRROR(0x0040) AM_WRITE_LEGACY(firefox_coin_counter_w) /* LATCH1 -> COIN COUNTERR, COUNTERL */
- AM_RANGE(0x428c, 0x428f) AM_MIRROR(0x0040) AM_WRITE_LEGACY(led_w) /* LATCH1 -> LEDs */
- AM_RANGE(0x4290, 0x4290) AM_MIRROR(0x0047) AM_WRITE_LEGACY(rom_bank_w) /* WRTREG */
- AM_RANGE(0x4298, 0x4298) AM_MIRROR(0x0047) AM_WRITE_LEGACY(main_to_sound_w) /* WRSOUND */
- AM_RANGE(0x42a0, 0x42a0) AM_MIRROR(0x0047) AM_WRITE_LEGACY(firefox_disc_data_w) /* DSKLATCH */
+ AM_RANGE(0x4218, 0x4218) AM_MIRROR(0x0047) AM_WRITE(firefox_disc_read_w) /* DSKREAD */
+ AM_RANGE(0x4220, 0x4223) AM_MIRROR(0x0044) AM_WRITE(adc_select_w) /* ADCSTART */
+ AM_RANGE(0x4230, 0x4230) AM_MIRROR(0x0047) AM_WRITE(self_reset_w) /* AMUCK */
+ AM_RANGE(0x4280, 0x4280) AM_MIRROR(0x0040) AM_WRITE(novram_recall_w) /* LATCH0 -> NVRECALL */
+ AM_RANGE(0x4281, 0x4281) AM_MIRROR(0x0040) AM_WRITE(sound_reset_w) /* LATCH0 -> RSTSOUND */
+ AM_RANGE(0x4282, 0x4282) AM_MIRROR(0x0040) AM_WRITE(novram_store_w) /* LATCH0 -> NVRSTORE */
+ AM_RANGE(0x4283, 0x4283) AM_MIRROR(0x0040) AM_WRITE(firefox_disc_lock_w) /* LATCH0 -> LOCK */
+ AM_RANGE(0x4284, 0x4285) AM_MIRROR(0x0040) AM_WRITE(audio_enable_w) /* LATCH0 -> SWDSKR, SWDSKL */
+ AM_RANGE(0x4286, 0x4286) AM_MIRROR(0x0040) AM_WRITE(firefox_disc_reset_w) /* LATCH0 -> RSTDSK */
+ AM_RANGE(0x4287, 0x4287) AM_MIRROR(0x0040) AM_WRITE(firefox_disc_write_w) /* LATCH0 -> WRDSK */
+ AM_RANGE(0x4288, 0x4289) AM_MIRROR(0x0040) AM_WRITE(firefox_coin_counter_w) /* LATCH1 -> COIN COUNTERR, COUNTERL */
+ AM_RANGE(0x428c, 0x428f) AM_MIRROR(0x0040) AM_WRITE(led_w) /* LATCH1 -> LEDs */
+ AM_RANGE(0x4290, 0x4290) AM_MIRROR(0x0047) AM_WRITE(rom_bank_w) /* WRTREG */
+ AM_RANGE(0x4298, 0x4298) AM_MIRROR(0x0047) AM_WRITE(main_to_sound_w) /* WRSOUND */
+ AM_RANGE(0x42a0, 0x42a0) AM_MIRROR(0x0047) AM_WRITE(firefox_disc_data_w) /* DSKLATCH */
AM_RANGE(0x4400, 0xffff) AM_ROM
ADDRESS_MAP_END
@@ -538,8 +544,8 @@ static ADDRESS_MAP_START( audio_map, AS_PROGRAM, 8, firefox_state )
AM_RANGE(0x0000, 0x07ff) AM_RAM
AM_RANGE(0x0800, 0x087f) AM_MIRROR(0x0700) AM_RAM /* RIOT ram */
AM_RANGE(0x0880, 0x089f) AM_MIRROR(0x07e0) AM_DEVREADWRITE_LEGACY("riot",riot6532_r, riot6532_w)
- AM_RANGE(0x1000, 0x1000) AM_READ_LEGACY(main_to_sound_r)
- AM_RANGE(0x1800, 0x1800) AM_WRITE_LEGACY(sound_to_main_w)
+ AM_RANGE(0x1000, 0x1000) AM_READ(main_to_sound_r)
+ AM_RANGE(0x1800, 0x1800) AM_WRITE(sound_to_main_w)
AM_RANGE(0x2000, 0x200f) AM_DEVREADWRITE_LEGACY("pokey1", pokey_r, pokey_w)
AM_RANGE(0x2800, 0x280f) AM_DEVREADWRITE_LEGACY("pokey2", pokey_r, pokey_w)
AM_RANGE(0x3000, 0x300f) AM_DEVREADWRITE_LEGACY("pokey3", pokey_r, pokey_w)
diff --git a/src/mame/drivers/ghosteo.c b/src/mame/drivers/ghosteo.c
index b718bb7d45d..e8d9e18cb62 100644
--- a/src/mame/drivers/ghosteo.c
+++ b/src/mame/drivers/ghosteo.c
@@ -84,6 +84,8 @@ public:
int m_security_count;
UINT32 m_bballoon_port[20];
struct nand_t m_nand;
+ DECLARE_WRITE32_MEMBER(sound_w);
+ DECLARE_READ32_MEMBER(bballoon_speedup_r);
};
@@ -329,7 +331,7 @@ static WRITE_LINE_DEVICE_HANDLER( s3c2410_i2c_sda_w )
i2cmem_sda_write( i2cmem, state);
}
-static WRITE32_HANDLER( sound_w )
+WRITE32_MEMBER(ghosteo_state::sound_w)
{
if ((data >= 0x20) && (data <= 0x7F))
{
@@ -349,7 +351,7 @@ static ADDRESS_MAP_START( bballoon_map, AS_PROGRAM, 32, ghosteo_state )
AM_RANGE(0x10000000, 0x10000003) AM_READ_PORT("10000000")
AM_RANGE(0x10100000, 0x10100003) AM_READ_PORT("10100000")
AM_RANGE(0x10200000, 0x10200003) AM_READ_PORT("10200000")
- AM_RANGE(0x10300000, 0x10300003) AM_WRITE_LEGACY(sound_w)
+ AM_RANGE(0x10300000, 0x10300003) AM_WRITE(sound_w)
AM_RANGE(0x30000000, 0x31ffffff) AM_RAM AM_BASE(m_system_memory) AM_MIRROR(0x02000000)
ADDRESS_MAP_END
@@ -435,23 +437,23 @@ static const i2cmem_interface i2cmem_interface =
device_t* s3c2410;
-static READ32_HANDLER( bballoon_speedup_r )
+READ32_MEMBER(ghosteo_state::bballoon_speedup_r)
{
UINT32 ret = s3c2410_lcd_r(s3c2410, offset+0x10/4, mem_mask);
- int pc = cpu_get_pc(&space->device());
+ int pc = cpu_get_pc(&space.device());
// these are vblank waits
if (pc == 0x3001c0e4 || pc == 0x3001c0d8)
{
// BnB Arcade
- device_spin_until_time(&space->device(), attotime::from_usec(20));
+ device_spin_until_time(&space.device(), attotime::from_usec(20));
}
else if (pc == 0x3002b580 || pc == 0x3002b550)
{
// Happy Tour
- device_spin_until_time(&space->device(), attotime::from_usec(20));
+ device_spin_until_time(&space.device(), attotime::from_usec(20));
}
//else
// printf("speedup %08x %08x\n", pc, ret);
@@ -461,7 +463,8 @@ static READ32_HANDLER( bballoon_speedup_r )
static MACHINE_RESET( bballoon )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4d000010, 0x4d000013, FUNC(bballoon_speedup_r));
+ ghosteo_state *state = machine.driver_data<ghosteo_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x4d000010, 0x4d000013,read32_delegate(FUNC(ghosteo_state::bballoon_speedup_r), state));
s3c2410 = machine.device("s3c2410");
}
diff --git a/src/mame/drivers/gstream.c b/src/mame/drivers/gstream.c
index b2e19f8974b..de1a7cf2f9a 100644
--- a/src/mame/drivers/gstream.c
+++ b/src/mame/drivers/gstream.c
@@ -159,6 +159,17 @@ public:
required_device<e132xt_device> m_maincpu;
required_device<okim6295_device> m_oki_1;
required_device<okim6295_device> m_oki_2;
+ DECLARE_WRITE32_MEMBER(gstream_palette_w);
+ DECLARE_WRITE32_MEMBER(gstream_vram_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap1_scrollx_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap1_scrolly_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap2_scrollx_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap2_scrolly_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap3_scrollx_w);
+ DECLARE_WRITE32_MEMBER(gstream_tilemap3_scrolly_w);
+ DECLARE_WRITE32_MEMBER(gstream_oki_banking_w);
+ DECLARE_WRITE32_MEMBER(gstream_oki_4040_w);
+ DECLARE_READ32_MEMBER(gstream_speedup_r);
};
@@ -192,96 +203,88 @@ static CUSTOM_INPUT( gstream_mirror_r )
}
-static WRITE32_HANDLER( gstream_palette_w )
+WRITE32_MEMBER(gstream_state::gstream_palette_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- COMBINE_DATA(&state->m_paletteram[offset]);
+ COMBINE_DATA(&m_paletteram[offset]);
- palette_set_color_rgb(space->machine(), offset * 2, pal5bit(state->m_paletteram[offset] >> (0 + 16)),
- pal5bit(state->m_paletteram[offset] >> (6 + 16)),
- pal5bit(state->m_paletteram[offset] >> (11 + 16)));
+ palette_set_color_rgb(machine(), offset * 2, pal5bit(m_paletteram[offset] >> (0 + 16)),
+ pal5bit(m_paletteram[offset] >> (6 + 16)),
+ pal5bit(m_paletteram[offset] >> (11 + 16)));
- palette_set_color_rgb(space->machine(),offset * 2 + 1,pal5bit(state->m_paletteram[offset] >> (0)),
- pal5bit(state->m_paletteram[offset] >> (6)),
- pal5bit(state->m_paletteram[offset] >> (11)));
+ palette_set_color_rgb(machine(),offset * 2 + 1,pal5bit(m_paletteram[offset] >> (0)),
+ pal5bit(m_paletteram[offset] >> (6)),
+ pal5bit(m_paletteram[offset] >> (11)));
}
-static WRITE32_HANDLER( gstream_vram_w )
+WRITE32_MEMBER(gstream_state::gstream_vram_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- COMBINE_DATA(&state->m_vram[offset]);
+ COMBINE_DATA(&m_vram[offset]);
if (ACCESSING_BITS_24_31)
{
if (offset >= 0x000 / 4 && offset < 0x400 / 4)
{
- state->m_tilemap1->mark_tile_dirty(offset - (0x000 / 4));
+ m_tilemap1->mark_tile_dirty(offset - (0x000 / 4));
}
else if (offset >= 0x400 / 4 && offset < 0x800 / 4)
{
- state->m_tilemap2->mark_tile_dirty(offset - (0x400 / 4));
+ m_tilemap2->mark_tile_dirty(offset - (0x400 / 4));
}
else if (offset >= 0x800 / 4 && offset < 0xc00 / 4)
{
- state->m_tilemap3->mark_tile_dirty(offset - (0x800 / 4));
+ m_tilemap3->mark_tile_dirty(offset - (0x800 / 4));
}
}
}
-static WRITE32_HANDLER( gstream_tilemap1_scrollx_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap1_scrollx_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap1_scrollx = data;
+ m_tmap1_scrollx = data;
}
-static WRITE32_HANDLER( gstream_tilemap1_scrolly_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap1_scrolly_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap1_scrolly = data;
+ m_tmap1_scrolly = data;
}
-static WRITE32_HANDLER( gstream_tilemap2_scrollx_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap2_scrollx_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap2_scrollx = data;
+ m_tmap2_scrollx = data;
}
-static WRITE32_HANDLER( gstream_tilemap2_scrolly_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap2_scrolly_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap2_scrolly = data;
+ m_tmap2_scrolly = data;
}
-static WRITE32_HANDLER( gstream_tilemap3_scrollx_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap3_scrollx_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap3_scrollx = data;
+ m_tmap3_scrollx = data;
}
-static WRITE32_HANDLER( gstream_tilemap3_scrolly_w )
+WRITE32_MEMBER(gstream_state::gstream_tilemap3_scrolly_w)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- state->m_tmap3_scrolly = data;
+ m_tmap3_scrolly = data;
}
static ADDRESS_MAP_START( gstream_32bit_map, AS_PROGRAM, 32, gstream_state )
AM_RANGE(0x00000000, 0x003FFFFF) AM_RAM AM_BASE(m_workram) // work ram
// AM_RANGE(0x40000000, 0x40FFFFFF) AM_RAM // ?? lots of data gets copied here if present, but game runs without it??
- AM_RANGE(0x80000000, 0x80003FFF) AM_RAM_WRITE_LEGACY(gstream_vram_w) AM_BASE(m_vram) // video ram
+ AM_RANGE(0x80000000, 0x80003FFF) AM_RAM_WRITE(gstream_vram_w) AM_BASE(m_vram) // video ram
AM_RANGE(0x4E000000, 0x4E1FFFFF) AM_ROM AM_REGION("user2",0) // main game rom
- AM_RANGE(0x4F000000, 0x4F000003) AM_WRITE_LEGACY(gstream_tilemap3_scrollx_w)
- AM_RANGE(0x4F200000, 0x4F200003) AM_WRITE_LEGACY(gstream_tilemap3_scrolly_w)
- AM_RANGE(0x4F400000, 0x4F406FFF) AM_RAM_WRITE_LEGACY(gstream_palette_w) AM_BASE(m_paletteram)
- AM_RANGE(0x4F800000, 0x4F800003) AM_WRITE_LEGACY(gstream_tilemap1_scrollx_w)
- AM_RANGE(0x4FA00000, 0x4FA00003) AM_WRITE_LEGACY(gstream_tilemap1_scrolly_w)
- AM_RANGE(0x4FC00000, 0x4FC00003) AM_WRITE_LEGACY(gstream_tilemap2_scrollx_w)
- AM_RANGE(0x4FE00000, 0x4FE00003) AM_WRITE_LEGACY(gstream_tilemap2_scrolly_w)
+ AM_RANGE(0x4F000000, 0x4F000003) AM_WRITE(gstream_tilemap3_scrollx_w)
+ AM_RANGE(0x4F200000, 0x4F200003) AM_WRITE(gstream_tilemap3_scrolly_w)
+ AM_RANGE(0x4F400000, 0x4F406FFF) AM_RAM_WRITE(gstream_palette_w) AM_BASE(m_paletteram)
+ AM_RANGE(0x4F800000, 0x4F800003) AM_WRITE(gstream_tilemap1_scrollx_w)
+ AM_RANGE(0x4FA00000, 0x4FA00003) AM_WRITE(gstream_tilemap1_scrolly_w)
+ AM_RANGE(0x4FC00000, 0x4FC00003) AM_WRITE(gstream_tilemap2_scrollx_w)
+ AM_RANGE(0x4FE00000, 0x4FE00003) AM_WRITE(gstream_tilemap2_scrolly_w)
AM_RANGE(0xFFC00000, 0xFFC01FFF) AM_RAM AM_SHARE("nvram") // Backup RAM
AM_RANGE(0xFFF80000, 0xFFFFFFFF) AM_ROM AM_REGION("user1",0) // boot rom
ADDRESS_MAP_END
-static WRITE32_HANDLER( gstream_oki_banking_w )
+WRITE32_MEMBER(gstream_state::gstream_oki_banking_w)
{
/* OKI BANKING (still far from perfect, based on game behaviour)
@@ -314,39 +317,38 @@ static WRITE32_HANDLER( gstream_oki_banking_w )
Musics order is completely guessed but close to what the original PCB game should be */
- gstream_state *state = space->machine().driver_data<gstream_state>();
static const int bank_table_0[16] = { -1, -1, -1, -1, -1, -1, 0, 0, -1, 6, 0, 5, -1, 0, 0, 0 };
static const int bank_table_1[16] = { -1, -1, -1, -1, -1, -1, 2, 2, -1, 0, 0, 4, -1, 1, 1, 1 };
//popmessage("oki_0 banking value = %X\noki_1 banking value = %X\n",data & 0xf,(data >> 4) & 0xf);
- state->m_oki_bank_0 = bank_table_0[data & 0xf];
- state->m_oki_bank_1 = bank_table_1[data & 0xf]; // (data >> 4) & 0xf ??
+ m_oki_bank_0 = bank_table_0[data & 0xf];
+ m_oki_bank_1 = bank_table_1[data & 0xf]; // (data >> 4) & 0xf ??
/* some values are already used in the table, so we force them manually */
if ((data == 0x6f) || (data == 0x6e))
{
- state->m_oki_bank_0 = 0; // level 3b-5a samples
- state->m_oki_bank_1 = 6; // level 3b-5a music
+ m_oki_bank_0 = 0; // level 3b-5a samples
+ m_oki_bank_1 = 6; // level 3b-5a music
}
if (data == 0x9b)
{
- state->m_oki_bank_0 = 7; // level 7 music
- state->m_oki_bank_1 = 0; // level 7 samples
+ m_oki_bank_0 = 7; // level 7 music
+ m_oki_bank_1 = 0; // level 7 samples
}
if (data == 0x9f)
{
- state->m_oki_bank_0 = 0; // end sequence samples
- state->m_oki_bank_1 = 3; // end sequence music
+ m_oki_bank_0 = 0; // end sequence samples
+ m_oki_bank_1 = 3; // end sequence music
}
- state->m_oki_1->set_bank_base(state->m_oki_bank_0 * 0x40000);
- state->m_oki_2->set_bank_base(state->m_oki_bank_1 * 0x40000);
+ m_oki_1->set_bank_base(m_oki_bank_0 * 0x40000);
+ m_oki_2->set_bank_base(m_oki_bank_1 * 0x40000);
}
-static WRITE32_HANDLER( gstream_oki_4040_w )
+WRITE32_MEMBER(gstream_state::gstream_oki_4040_w)
{
// data == 0 or data == 0x81
}
@@ -355,8 +357,8 @@ static ADDRESS_MAP_START( gstream_io, AS_IO, 32, gstream_state )
AM_RANGE(0x4000, 0x4003) AM_READ_PORT("IN0")
AM_RANGE(0x4010, 0x4013) AM_READ_PORT("IN1")
AM_RANGE(0x4020, 0x4023) AM_READ_PORT("IN2") // extra coin switches etc
- AM_RANGE(0x4030, 0x4033) AM_WRITE_LEGACY(gstream_oki_banking_w) // oki banking
- AM_RANGE(0x4040, 0x4043) AM_WRITE_LEGACY(gstream_oki_4040_w) // ??
+ AM_RANGE(0x4030, 0x4033) AM_WRITE(gstream_oki_banking_w) // oki banking
+ AM_RANGE(0x4040, 0x4043) AM_WRITE(gstream_oki_4040_w) // ??
AM_RANGE(0x4050, 0x4053) AM_DEVREADWRITE8("oki2", okim6295_device, read, write, 0x000000ff) // music and samples
AM_RANGE(0x4060, 0x4063) AM_DEVREADWRITE8("oki1", okim6295_device, read, write, 0x000000ff) // music and samples
ADDRESS_MAP_END
@@ -627,20 +629,20 @@ ROM_START( gstream )
ROM_LOAD( "gstream.nv", 0x000000, 0x2000, CRC(895d724b) SHA1(97941102f94923220d9beb270939f0ad9a40fe0e) )
ROM_END
-static READ32_HANDLER( gstream_speedup_r )
+READ32_MEMBER(gstream_state::gstream_speedup_r)
{
- gstream_state *state = space->machine().driver_data<gstream_state>();
- if (state->m_maincpu->state(STATE_GENPC) == 0xc0001592)
+ if (m_maincpu->state(STATE_GENPC) == 0xc0001592)
{
- state->m_maincpu->eat_cycles(50);
+ m_maincpu->eat_cycles(50);
}
- return state->m_workram[0xd1ee0 / 4];
+ return m_workram[0xd1ee0 / 4];
}
static DRIVER_INIT( gstream )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd1ee0, 0xd1ee3, FUNC(gstream_speedup_r) );
+ gstream_state *state = machine.driver_data<gstream_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xd1ee0, 0xd1ee3, read32_delegate(FUNC(gstream_state::gstream_speedup_r), state));
}
diff --git a/src/mame/drivers/halleys.c b/src/mame/drivers/halleys.c
index 94ab9da2552..a1fef47b226 100644
--- a/src/mame/drivers/halleys.c
+++ b/src/mame/drivers/halleys.c
@@ -243,6 +243,20 @@ public:
emu_timer *m_blitter_reset_timer;
offs_t m_collision_detection;
int m_latch_delay;
+ DECLARE_WRITE8_MEMBER(bgtile_w);
+ DECLARE_READ8_MEMBER(blitter_status_r);
+ DECLARE_READ8_MEMBER(blitter_r);
+ DECLARE_WRITE8_MEMBER(blitter_w);
+ DECLARE_READ8_MEMBER(collision_id_r);
+ DECLARE_WRITE8_MEMBER(halleys_paletteram_IIRRGGBB_w);
+ DECLARE_READ8_MEMBER(zero_r);
+ DECLARE_READ8_MEMBER(debug_r);
+ DECLARE_READ8_MEMBER(vector_r);
+ DECLARE_WRITE8_MEMBER(firq_ack_w);
+ DECLARE_WRITE8_MEMBER(soundcommand_w);
+ DECLARE_READ8_MEMBER(coin_lockout_r);
+ DECLARE_READ8_MEMBER(io_mirror_r);
+ void blit(int offset);
};
@@ -250,7 +264,7 @@ public:
//**************************************************************************
// MB1551x Blitter Functions
-static void blit(halleys_state *state, int offset)
+void halleys_state::blit(int offset)
{
/*
The render layers can be converted to standard MAME bitmaps but
@@ -334,7 +348,7 @@ static void blit(halleys_state *state, int offset)
UINT16 ax; UINT8 al, ah; // partial regs
- param = state->m_blitter_ram + offset;
+ param = m_blitter_ram + offset;
#if HALLEYS_DEBUG
@@ -356,11 +370,11 @@ if (0) {
// update sprite status
layer = (code>>3 & 2) | (code>>7 & 1);
offset >>= 4;
- status = (stptr) ? state->m_cpu1_base[stptr] : ACTIVE;
+ status = (stptr) ? m_cpu1_base[stptr] : ACTIVE;
flags = mode;
group = mode & GROUP;
command = code & COMMAND;
- if (state->m_game_id == GAME_HALLEYS)
+ if (m_game_id == GAME_HALLEYS)
{
if (!layer) flags |= PPCD_ON;
if (offset >= HALLEYS_SPLIT) flags |= AD_HIGH; else
@@ -388,7 +402,7 @@ if (0) {
src1 &= 0x3fff;
src2 &= 0x3fff;
bank = ((code & BANKBIT0) | (color & BANKBIT1)) << 8;
- pal_ptr = state->m_internal_palette;
+ pal_ptr = m_internal_palette;
// the crossroad of fate
@@ -435,8 +449,8 @@ if (0) {
// calculate entry points and loop constants
- src1_ptr = state->m_gfx_plane02 + ((bank + src1)<<3) + eax;
- src2_ptr = state->m_gfx_plane13 + ((bank + src2)<<3) + eax;
+ src1_ptr = m_gfx_plane02 + ((bank + src1)<<3) + eax;
+ src2_ptr = m_gfx_plane13 + ((bank + src2)<<3) + eax;
if (!(flags & (S1_IDLE | S2_IDLE)))
{
@@ -446,7 +460,7 @@ if (0) {
}
else src_dy = src_dx = 0;
- dst_ptr = state->m_render_layer[layer] + dst_skip;
+ dst_ptr = m_render_layer[layer] + dst_skip;
// look up pen values and set rendering flags
@@ -556,11 +570,11 @@ if (0) {
// update collision list if object collided with the other group
if (status & ACTIVE && ax & SP_COLLD)
{
- state->m_collision_list[state->m_collision_count & (MAX_SPRITES-1)] = offset;
- state->m_collision_count++;
+ m_collision_list[m_collision_count & (MAX_SPRITES-1)] = offset;
+ m_collision_count++;
#if HALLEYS_DEBUG
- popmessage("ID:%02x CC:%3d", offset, state->m_collision_count);
+ popmessage("ID:%02x CC:%3d", offset, m_collision_count);
#endif
}
@@ -705,10 +719,10 @@ COMMAND_MODE:
if (flags & S1_IDLE) src_dx = 0; else src_dx = 1;
if (flags & S1_REV ) src_dx = -src_dx;
- src_base = state->m_gfx1_base + bank;
+ src_base = m_gfx1_base + bank;
if (command == STARPASS1 || command == STARPASS2) layer = (layer & 1) + 4;
- dst_base = state->m_render_layer[layer];
+ dst_base = m_render_layer[layer];
//--------------------------------------------------------------------------
@@ -732,17 +746,17 @@ COMMAND_MODE:
if (!command && y == 0xff && h == 1)
{
y = 0; h = SCREEN_HEIGHT;
- dst_base = state->m_render_layer[(layer&1)+4];
+ dst_base = m_render_layer[(layer&1)+4];
WARP_WIPE_COMMON
- state->m_stars_enabled = ~layer & 1;
+ m_stars_enabled = ~layer & 1;
}
// wipe background and chain-wipe corresponding sprite layer when the command is zero
else
{
WARP_WIPE_COMMON
- if (!command) { dst_base = state->m_render_layer[layer&1]; WARP_WIPE_COMMON }
+ if (!command) { dst_base = m_render_layer[layer&1]; WARP_WIPE_COMMON }
}
} else
@@ -794,7 +808,7 @@ COMMAND_MODE:
}
}
- state->m_stars_enabled = layer & 1;
+ m_stars_enabled = layer & 1;
#undef RORB
#undef C2S
@@ -862,7 +876,7 @@ COMMAND_MODE:
if (flags & IGNORE_0) { w=8; h=8; WARP_WIPE_COMMON }
src1_ptr = src_base + src1;
- dst_ptr = state->m_render_layer[2] + (y << SCREEN_WIDTH_L2);
+ dst_ptr = m_render_layer[2] + (y << SCREEN_WIDTH_L2);
src1_ptr += 8;
edx = -8;
@@ -974,14 +988,13 @@ COMMAND_MODE:
// draws Ben Bero Beh's color backdrop(verification required)
-static WRITE8_HANDLER( bgtile_w )
+WRITE8_MEMBER(halleys_state::bgtile_w)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
int yskip, xskip, ecx;
UINT16 *edi;
UINT16 ax;
- state->m_cpu1_base[0x1f00+offset] = data;
+ m_cpu1_base[0x1f00+offset] = data;
offset -= 0x18;
if (offset >= 191) return;
@@ -992,7 +1005,7 @@ static WRITE8_HANDLER( bgtile_w )
yskip = yskip * 48 + 24;
xskip = xskip * 5 + 2;
- edi = state->m_render_layer[2] + (yskip<<SCREEN_WIDTH_L2) + xskip + (48<<SCREEN_WIDTH_L2);
+ edi = m_render_layer[2] + (yskip<<SCREEN_WIDTH_L2) + xskip + (48<<SCREEN_WIDTH_L2);
ecx = -(48<<SCREEN_WIDTH_L2);
ax = (UINT16)data | BG_RGB;
@@ -1000,23 +1013,21 @@ static WRITE8_HANDLER( bgtile_w )
}
-static READ8_HANDLER( blitter_status_r )
+READ8_MEMBER(halleys_state::blitter_status_r)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
- if (state->m_game_id==GAME_HALLEYS && cpu_get_pc(&space->device())==0x8017) return(0x55); // HACK: trick SRAM test on startup
+ if (m_game_id==GAME_HALLEYS && cpu_get_pc(&space.device())==0x8017) return(0x55); // HACK: trick SRAM test on startup
return(0);
}
-static READ8_HANDLER( blitter_r )
+READ8_MEMBER(halleys_state::blitter_r)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
int i = offset & 0xf;
if (i==0 || i==4) return(1);
- return(state->m_blitter_ram[offset]);
+ return(m_blitter_ram[offset]);
}
@@ -1027,34 +1038,32 @@ static TIMER_CALLBACK( blitter_reset )
}
-static WRITE8_HANDLER( blitter_w )
+WRITE8_MEMBER(halleys_state::blitter_w)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
int i = offset & 0xf;
- state->m_blitter_ram[offset] = data;
+ m_blitter_ram[offset] = data;
- if (i==0) blit(state, offset);
+ if (i==0) blit(offset);
- if (state->m_game_id == GAME_BENBEROB)
+ if (m_game_id == GAME_BENBEROB)
{
if (i==0 || (i==4 && !data))
{
- state->m_blitter_busy = 0;
- if (state->m_firq_level) cputag_set_input_line(space->machine(), "maincpu", M6809_FIRQ_LINE, ASSERT_LINE); // make up delayed FIRQ's
+ m_blitter_busy = 0;
+ if (m_firq_level) cputag_set_input_line(machine(), "maincpu", M6809_FIRQ_LINE, ASSERT_LINE); // make up delayed FIRQ's
}
else
{
- state->m_blitter_busy = 1;
- state->m_blitter_reset_timer->adjust(downcast<cpu_device *>(&space->device())->cycles_to_attotime(100)); // free blitter if no updates in 100 cycles
+ m_blitter_busy = 1;
+ m_blitter_reset_timer->adjust(downcast<cpu_device *>(&space.device())->cycles_to_attotime(100)); // free blitter if no updates in 100 cycles
}
}
}
-static READ8_HANDLER( collision_id_r )
+READ8_MEMBER(halleys_state::collision_id_r)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
/*
Collision detection abstract:
@@ -1077,14 +1086,14 @@ static READ8_HANDLER( collision_id_r )
UPDATE: re-implemented pixel collision to accompany the hack method.
*/
- if (state->m_game_id==GAME_HALLEYS && cpu_get_pc(&space->device())==state->m_collision_detection) // HACK: collision detection bypass
+ if (m_game_id==GAME_HALLEYS && cpu_get_pc(&space.device())==m_collision_detection) // HACK: collision detection bypass
{
- if (state->m_collision_count) { state->m_collision_count--; return(state->m_collision_list[state->m_collision_count]); }
+ if (m_collision_count) { m_collision_count--; return(m_collision_list[m_collision_count]); }
return(0);
}
- return(state->m_io_ram[0x66]);
+ return(m_io_ram[0x66]);
}
@@ -1185,13 +1194,12 @@ static void halleys_decode_rgb(running_machine &machine, UINT32 *r, UINT32 *g, U
*b = prom_6330[0x40 + (bit0|bit1|bit2|bit3|bit4)];
}
-static WRITE8_HANDLER( halleys_paletteram_IIRRGGBB_w )
+WRITE8_MEMBER(halleys_state::halleys_paletteram_IIRRGGBB_w)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
UINT32 d, r, g, b, i, j;
- UINT32 *pal_ptr = state->m_internal_palette;
+ UINT32 *pal_ptr = m_internal_palette;
- space->machine().generic.paletteram.u8[offset] = data;
+ machine().generic.paletteram.u8[offset] = data;
d = (UINT32)data;
j = d | BG_RGB;
pal_ptr[offset] = j;
@@ -1205,13 +1213,13 @@ static WRITE8_HANDLER( halleys_paletteram_IIRRGGBB_w )
g = d & 0x0c; g |= i; g = g<<4 | g;
b = d<<2 & 0x0c; b |= i; b = b<<4 | b;
- palette_set_color(space->machine(), offset, MAKE_RGB(r, g, b));
- palette_set_color(space->machine(), offset+SP_2BACK, MAKE_RGB(r, g, b));
- palette_set_color(space->machine(), offset+SP_ALPHA, MAKE_RGB(r, g, b));
- palette_set_color(space->machine(), offset+SP_COLLD, MAKE_RGB(r, g, b));
+ palette_set_color(machine(), offset, MAKE_RGB(r, g, b));
+ palette_set_color(machine(), offset+SP_2BACK, MAKE_RGB(r, g, b));
+ palette_set_color(machine(), offset+SP_ALPHA, MAKE_RGB(r, g, b));
+ palette_set_color(machine(), offset+SP_COLLD, MAKE_RGB(r, g, b));
- halleys_decode_rgb(space->machine(), &r, &g, &b, offset, 0);
- palette_set_color(space->machine(), offset+0x20, MAKE_RGB(r, g, b));
+ halleys_decode_rgb(machine(), &r, &g, &b, offset, 0);
+ palette_set_color(machine(), offset+0x20, MAKE_RGB(r, g, b));
}
@@ -1513,12 +1521,11 @@ static SCREEN_UPDATE_IND16( benberob )
#if HALLEYS_DEBUG
-static READ8_HANDLER( zero_r ) { return(0); }
+READ8_MEMBER(halleys_state::zero_r){ return(0); }
-static READ8_HANDLER( debug_r )
+READ8_MEMBER(halleys_state::debug_r)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
- return(state->m_io_ram[offset]);
+ return(m_io_ram[offset]);
}
#endif
@@ -1582,20 +1589,18 @@ static TIMER_DEVICE_CALLBACK( benberob_scanline )
}
-static READ8_HANDLER( vector_r )
+READ8_MEMBER(halleys_state::vector_r)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
- return(state->m_cpu1_base[0xffe0 + (offset^(state->m_mVectorType<<4))]);
+ return(m_cpu1_base[0xffe0 + (offset^(m_mVectorType<<4))]);
}
-static WRITE8_HANDLER( firq_ack_w )
+WRITE8_MEMBER(halleys_state::firq_ack_w)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
- state->m_io_ram[0x9c] = data;
+ m_io_ram[0x9c] = data;
- if (state->m_firq_level) state->m_firq_level--;
- cputag_set_input_line(space->machine(), "maincpu", M6809_FIRQ_LINE, CLEAR_LINE);
+ if (m_firq_level) m_firq_level--;
+ cputag_set_input_line(machine(), "maincpu", M6809_FIRQ_LINE, CLEAR_LINE);
}
@@ -1606,25 +1611,24 @@ static WRITE8_DEVICE_HANDLER( sndnmi_msk_w )
}
-static WRITE8_HANDLER( soundcommand_w )
+WRITE8_MEMBER(halleys_state::soundcommand_w)
{
- halleys_state *state = space->machine().driver_data<halleys_state>();
- state->m_io_ram[0x8a] = data;
+ m_io_ram[0x8a] = data;
soundlatch_w(space,offset,data);
- cputag_set_input_line(space->machine(), "audiocpu", INPUT_LINE_NMI, PULSE_LINE);
+ cputag_set_input_line(machine(), "audiocpu", INPUT_LINE_NMI, PULSE_LINE);
}
-static READ8_HANDLER( coin_lockout_r )
+READ8_MEMBER(halleys_state::coin_lockout_r)
{
// This is a hack, but it lets you coin up when COIN1 or COIN2 are signaled.
// See NMI for the twisted logic that is involved in handling coin input :
// 0x8599 : 'benberob'
// 0x83e2 : 'halleys', 'halleysc', 'halleycj'
// 0x83df : 'halley87'
- int inp = input_port_read(space->machine(), "IN0");
- int result = ((input_port_read(space->machine(), "DSW4")) & 0x20) >> 5;
+ int inp = input_port_read(machine(), "IN0");
+ int result = ((input_port_read(machine(), "DSW4")) & 0x20) >> 5;
if (inp & 0x80) result |= 0x02;
if (inp & 0x40) result |= 0x04;
@@ -1633,11 +1637,11 @@ static READ8_HANDLER( coin_lockout_r )
}
-static READ8_HANDLER( io_mirror_r )
+READ8_MEMBER(halleys_state::io_mirror_r)
{
static const char *const portnames[] = { "IN0", "IN1", "IN2", "IN3" };
- return input_port_read(space->machine(), portnames[offset]);
+ return input_port_read(machine(), portnames[offset]);
}
@@ -1645,28 +1649,28 @@ static READ8_HANDLER( io_mirror_r )
// Memory Maps
static ADDRESS_MAP_START( halleys_map, AS_PROGRAM, 8, halleys_state )
- AM_RANGE(0x0000, 0x0fff) AM_READWRITE_LEGACY(blitter_r, blitter_w) AM_BASE(m_blitter_ram) AM_SIZE(m_blitter_ramsize)
- AM_RANGE(0x1f00, 0x1fff) AM_WRITE_LEGACY(bgtile_w) // background tiles?(Ben Bero Beh only)
+ AM_RANGE(0x0000, 0x0fff) AM_READWRITE(blitter_r, blitter_w) AM_BASE(m_blitter_ram) AM_SIZE(m_blitter_ramsize)
+ AM_RANGE(0x1f00, 0x1fff) AM_WRITE(bgtile_w) // background tiles?(Ben Bero Beh only)
AM_RANGE(0x1000, 0xefff) AM_ROM
AM_RANGE(0xf000, 0xfeff) AM_RAM // work ram
- AM_RANGE(0xff66, 0xff66) AM_READ_LEGACY(collision_id_r) // HACK: collision detection bypass(Halley's Comet only)
- AM_RANGE(0xff71, 0xff71) AM_READ_LEGACY(blitter_status_r)
- AM_RANGE(0xff80, 0xff83) AM_READ_LEGACY(io_mirror_r)
- AM_RANGE(0xff8a, 0xff8a) AM_WRITE_LEGACY(soundcommand_w)
+ AM_RANGE(0xff66, 0xff66) AM_READ(collision_id_r) // HACK: collision detection bypass(Halley's Comet only)
+ AM_RANGE(0xff71, 0xff71) AM_READ(blitter_status_r)
+ AM_RANGE(0xff80, 0xff83) AM_READ(io_mirror_r)
+ AM_RANGE(0xff8a, 0xff8a) AM_WRITE(soundcommand_w)
AM_RANGE(0xff90, 0xff90) AM_READ_PORT("IN0") // coin/start
AM_RANGE(0xff91, 0xff91) AM_READ_PORT("IN1") // player 1
AM_RANGE(0xff92, 0xff92) AM_READ_PORT("IN2") // player 2
AM_RANGE(0xff93, 0xff93) AM_READ_PORT("IN3") // unused?
- AM_RANGE(0xff94, 0xff94) AM_READ_LEGACY(coin_lockout_r)
+ AM_RANGE(0xff94, 0xff94) AM_READ(coin_lockout_r)
AM_RANGE(0xff95, 0xff95) AM_READ_PORT("DSW1") // dipswitch 4
AM_RANGE(0xff96, 0xff96) AM_READ_PORT("DSW2") // dipswitch 3
AM_RANGE(0xff97, 0xff97) AM_READ_PORT("DSW3") // dipswitch 2
- AM_RANGE(0xff9c, 0xff9c) AM_WRITE_LEGACY(firq_ack_w)
+ AM_RANGE(0xff9c, 0xff9c) AM_WRITE(firq_ack_w)
AM_RANGE(0xff00, 0xffbf) AM_RAM AM_BASE(m_io_ram) AM_SIZE(m_io_ramsize) // I/O write fall-through
- AM_RANGE(0xffc0, 0xffdf) AM_RAM_WRITE_LEGACY(halleys_paletteram_IIRRGGBB_w) AM_BASE_GENERIC(paletteram)
- AM_RANGE(0xffe0, 0xffff) AM_READ_LEGACY(vector_r)
+ AM_RANGE(0xffc0, 0xffdf) AM_RAM_WRITE(halleys_paletteram_IIRRGGBB_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0xffe0, 0xffff) AM_READ(vector_r)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/highvdeo.c b/src/mame/drivers/highvdeo.c
index d4e8f6e887e..74bb43d132b 100644
--- a/src/mame/drivers/highvdeo.c
+++ b/src/mame/drivers/highvdeo.c
@@ -100,6 +100,23 @@ public:
UINT16 m_vblank_bit;
UINT16 m_brasil_prot_latch;
struct { int r,g,b,offs,offs_internal; } m_pal;
+ DECLARE_READ16_MEMBER(read1_r);
+ DECLARE_READ16_MEMBER(read2_r);
+ DECLARE_READ16_MEMBER(read3_r);
+ DECLARE_WRITE16_MEMBER(tv_vcf_paletteram_w);
+ DECLARE_WRITE16_MEMBER(tv_vcf_bankselect_w);
+ DECLARE_WRITE16_MEMBER(write1_w);
+ DECLARE_READ16_MEMBER(tv_ncf_read2_r);
+ DECLARE_WRITE16_MEMBER(tv_tcf_paletteram_w);
+ DECLARE_WRITE16_MEMBER(tv_tcf_bankselect_w);
+ DECLARE_READ16_MEMBER(newmcard_status_r);
+ DECLARE_READ16_MEMBER(newmcard_vblank_r);
+ DECLARE_WRITE16_MEMBER(newmcard_vblank_w);
+ DECLARE_WRITE16_MEMBER(write2_w);
+ DECLARE_READ16_MEMBER(brasil_status_r);
+ DECLARE_WRITE16_MEMBER(brasil_status_w);
+ DECLARE_READ16_MEMBER(ciclone_status_r);
+ DECLARE_WRITE16_MEMBER(fashion_output_w);
};
@@ -174,48 +191,47 @@ static SCREEN_UPDATE_RGB32(brasil)
-static READ16_HANDLER( read1_r )
+READ16_MEMBER(highvdeo_state::read1_r)
{
- return input_port_read(space->machine(), "IN0");
+ return input_port_read(machine(), "IN0");
}
-static READ16_HANDLER( read2_r )
+READ16_MEMBER(highvdeo_state::read2_r)
{
- return input_port_read(space->machine(), "IN1");
+ return input_port_read(machine(), "IN1");
}
-static READ16_HANDLER( read3_r )
+READ16_MEMBER(highvdeo_state::read3_r)
{
- return input_port_read(space->machine(), "IN2");
+ return input_port_read(machine(), "IN2");
}
-static WRITE16_HANDLER( tv_vcf_paletteram_w )
+WRITE16_MEMBER(highvdeo_state::tv_vcf_paletteram_w)
{
- highvdeo_state *state = space->machine().driver_data<highvdeo_state>();
switch(offset*2)
{
case 0:
- state->m_pal.offs = data;
+ m_pal.offs = data;
break;
case 2:
- state->m_pal.offs_internal = 0;
+ m_pal.offs_internal = 0;
break;
case 4:
- switch(state->m_pal.offs_internal)
+ switch(m_pal.offs_internal)
{
case 0:
- state->m_pal.r = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
- state->m_pal.offs_internal++;
+ m_pal.r = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
+ m_pal.offs_internal++;
break;
case 1:
- state->m_pal.g = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
- state->m_pal.offs_internal++;
+ m_pal.g = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
+ m_pal.offs_internal++;
break;
case 2:
- state->m_pal.b = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
- palette_set_color(space->machine(), state->m_pal.offs, MAKE_RGB(state->m_pal.r, state->m_pal.g, state->m_pal.b));
- state->m_pal.offs_internal = 0;
- state->m_pal.offs++;
+ m_pal.b = ((data & 0x3f) << 2) | ((data & 0x30) >> 4);
+ palette_set_color(machine(), m_pal.offs, MAKE_RGB(m_pal.r, m_pal.g, m_pal.b));
+ m_pal.offs_internal = 0;
+ m_pal.offs++;
break;
}
@@ -223,15 +239,15 @@ static WRITE16_HANDLER( tv_vcf_paletteram_w )
}
}
-static WRITE16_HANDLER( tv_vcf_bankselect_w )
+WRITE16_MEMBER(highvdeo_state::tv_vcf_bankselect_w)
{
UINT32 bankaddress;
- UINT8 *ROM = space->machine().region("user1")->base();
+ UINT8 *ROM = machine().region("user1")->base();
/* bits 0, 1 select the ROM bank */
bankaddress = (data & 0x03) * 0x40000;
- memory_set_bankptr(space->machine(), "bank1", &ROM[bankaddress]);
+ memory_set_bankptr(machine(), "bank1", &ROM[bankaddress]);
}
@@ -255,7 +271,7 @@ static READ16_DEVICE_HANDLER( tv_oki6376_r )
return 0xff;
}
-static WRITE16_HANDLER( write1_w )
+WRITE16_MEMBER(highvdeo_state::write1_w)
{
/*
- Lbits -
@@ -287,17 +303,17 @@ static ADDRESS_MAP_START( tv_vcf_map, AS_PROGRAM, 16, highvdeo_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( tv_vcf_io, AS_IO, 16, highvdeo_state )
- AM_RANGE(0x0000, 0x0001) AM_WRITE_LEGACY(write1_w ) // lamps
+ AM_RANGE(0x0000, 0x0001) AM_WRITE(write1_w ) // lamps
AM_RANGE(0x0006, 0x0007) AM_DEVWRITE_LEGACY("oki", tv_oki6376_w )
- AM_RANGE(0x0008, 0x0009) AM_READ_LEGACY(read1_r )
- AM_RANGE(0x000a, 0x000b) AM_READ_LEGACY(read2_r )
- AM_RANGE(0x000c, 0x000d) AM_READ_LEGACY(read3_r )
- AM_RANGE(0x0010, 0x0015) AM_WRITE_LEGACY(tv_vcf_paletteram_w )
- AM_RANGE(0x0030, 0x0031) AM_WRITE_LEGACY(tv_vcf_bankselect_w ) AM_DEVREAD_LEGACY("oki", tv_oki6376_r )
+ AM_RANGE(0x0008, 0x0009) AM_READ(read1_r )
+ AM_RANGE(0x000a, 0x000b) AM_READ(read2_r )
+ AM_RANGE(0x000c, 0x000d) AM_READ(read3_r )
+ AM_RANGE(0x0010, 0x0015) AM_WRITE(tv_vcf_paletteram_w )
+ AM_RANGE(0x0030, 0x0031) AM_WRITE(tv_vcf_bankselect_w ) AM_DEVREAD_LEGACY("oki", tv_oki6376_r )
ADDRESS_MAP_END
-static READ16_HANDLER( tv_ncf_read2_r )
+READ16_MEMBER(highvdeo_state::tv_ncf_read2_r)
{
static int resetpulse = 0;
@@ -305,7 +321,7 @@ static READ16_HANDLER( tv_ncf_read2_r )
// machine resets itself.
resetpulse ^= 0x40;
- return (input_port_read(space->machine(), "IN1") & 0xbf) | resetpulse;
+ return (input_port_read(machine(), "IN1") & 0xbf) | resetpulse;
}
static WRITE16_DEVICE_HANDLER( tv_ncf_oki6376_w )
@@ -334,56 +350,56 @@ static ADDRESS_MAP_START( tv_ncf_map, AS_PROGRAM, 16, highvdeo_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( tv_ncf_io, AS_IO, 16, highvdeo_state )
- AM_RANGE(0x0000, 0x0001) AM_WRITE_LEGACY(write1_w ) // lamps
+ AM_RANGE(0x0000, 0x0001) AM_WRITE(write1_w ) // lamps
AM_RANGE(0x0008, 0x0009) AM_DEVWRITE_LEGACY("oki", tv_ncf_oki6376_w )
AM_RANGE(0x000a, 0x000b) AM_DEVWRITE_LEGACY("oki", tv_ncf_oki6376_st_w )
- AM_RANGE(0x000c, 0x000d) AM_READ_LEGACY(read1_r )
- AM_RANGE(0x0010, 0x0011) AM_READ_LEGACY(tv_ncf_read2_r )
- AM_RANGE(0x0012, 0x0013) AM_READ_LEGACY(read3_r )
- AM_RANGE(0x0030, 0x0035) AM_WRITE_LEGACY(tv_vcf_paletteram_w )
+ AM_RANGE(0x000c, 0x000d) AM_READ(read1_r )
+ AM_RANGE(0x0010, 0x0011) AM_READ(tv_ncf_read2_r )
+ AM_RANGE(0x0012, 0x0013) AM_READ(read3_r )
+ AM_RANGE(0x0030, 0x0035) AM_WRITE(tv_vcf_paletteram_w )
ADDRESS_MAP_END
-static WRITE16_HANDLER( tv_tcf_paletteram_w )
+WRITE16_MEMBER(highvdeo_state::tv_tcf_paletteram_w)
{
int r, g, b, color;
- COMBINE_DATA(&space->machine().generic.paletteram.u16[offset]);
+ COMBINE_DATA(&machine().generic.paletteram.u16[offset]);
- color = space->machine().generic.paletteram.u16[offset];
+ color = machine().generic.paletteram.u16[offset];
r = (color >> 8) & 0xf8;
g = (color >> 3) & 0xf8;
b = (color << 3) & 0xf8;
- palette_set_color_rgb(space->machine(), offset, r, g, b);
+ palette_set_color_rgb(machine(), offset, r, g, b);
}
-static WRITE16_HANDLER( tv_tcf_bankselect_w )
+WRITE16_MEMBER(highvdeo_state::tv_tcf_bankselect_w)
{
UINT32 bankaddress;
- UINT8 *ROM = space->machine().region("user1")->base();
+ UINT8 *ROM = machine().region("user1")->base();
/* bits 0, 1, 2 select the ROM bank */
bankaddress = (data & 0x07) * 0x40000;
- memory_set_bankptr(space->machine(), "bank1", &ROM[bankaddress]);
+ memory_set_bankptr(machine(), "bank1", &ROM[bankaddress]);
}
static ADDRESS_MAP_START( tv_tcf_map, AS_PROGRAM, 16, highvdeo_state )
AM_RANGE(0x00000, 0x003ff) AM_RAM /*irq vector area*/
AM_RANGE(0x00400, 0x03fff) AM_RAM AM_SHARE("nvram")
AM_RANGE(0x40000, 0x5d4bf) AM_RAM AM_BASE(m_blit_ram) /*blitter ram*/
- AM_RANGE(0x7fe00, 0x7ffff) AM_RAM_WRITE_LEGACY(tv_tcf_paletteram_w ) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x7fe00, 0x7ffff) AM_RAM_WRITE(tv_tcf_paletteram_w ) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x80000, 0xbffff) AM_ROMBANK("bank1")
AM_RANGE(0xc0000, 0xfffff) AM_ROM AM_REGION("boot_prg",0)
ADDRESS_MAP_END
static ADDRESS_MAP_START( tv_tcf_io, AS_IO, 16, highvdeo_state )
- AM_RANGE(0x0000, 0x0001) AM_WRITE_LEGACY(write1_w ) // lamps
+ AM_RANGE(0x0000, 0x0001) AM_WRITE(write1_w ) // lamps
AM_RANGE(0x0006, 0x0007) AM_DEVWRITE_LEGACY("oki", tv_oki6376_w )
- AM_RANGE(0x0008, 0x0009) AM_READ_LEGACY(read1_r )
- AM_RANGE(0x000a, 0x000b) AM_READ_LEGACY(read2_r )
- AM_RANGE(0x0030, 0x0031) AM_READ_LEGACY(read3_r ) AM_WRITE_LEGACY(tv_tcf_bankselect_w )
+ AM_RANGE(0x0008, 0x0009) AM_READ(read1_r )
+ AM_RANGE(0x000a, 0x000b) AM_READ(read2_r )
+ AM_RANGE(0x0030, 0x0031) AM_READ(read3_r ) AM_WRITE(tv_tcf_bankselect_w )
ADDRESS_MAP_END
/****************************
@@ -392,7 +408,7 @@ ADDRESS_MAP_END
*
****************************/
-static READ16_HANDLER( newmcard_status_r )
+READ16_MEMBER(highvdeo_state::newmcard_status_r)
{
switch(offset*2)
{
@@ -403,19 +419,17 @@ static READ16_HANDLER( newmcard_status_r )
}
-static READ16_HANDLER( newmcard_vblank_r )
+READ16_MEMBER(highvdeo_state::newmcard_vblank_r)
{
- highvdeo_state *state = space->machine().driver_data<highvdeo_state>();
- return state->m_vblank_bit; //0x80
+ return m_vblank_bit; //0x80
}
-static WRITE16_HANDLER( newmcard_vblank_w )
+WRITE16_MEMBER(highvdeo_state::newmcard_vblank_w)
{
- highvdeo_state *state = space->machine().driver_data<highvdeo_state>();
- state->m_vblank_bit = data;
+ m_vblank_bit = data;
}
-static WRITE16_HANDLER( write2_w )
+WRITE16_MEMBER(highvdeo_state::write2_w)
{
int i;
@@ -423,8 +437,8 @@ static WRITE16_HANDLER( write2_w )
for(i=0;i<4;i++)
{
- coin_counter_w(space->machine(), i,data & 0x20);
- coin_lockout_w(space->machine(), i,~data & 0x08);
+ coin_counter_w(machine(), i,data & 0x20);
+ coin_lockout_w(machine(), i,~data & 0x08);
}
}
@@ -437,17 +451,17 @@ static ADDRESS_MAP_START( newmcard_map, AS_PROGRAM, 16, highvdeo_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( newmcard_io, AS_IO, 16, highvdeo_state )
- AM_RANGE(0x0030, 0x0033) AM_READ_LEGACY(newmcard_status_r )
- AM_RANGE(0x0030, 0x0031) AM_WRITE_LEGACY(tv_tcf_bankselect_w )
- AM_RANGE(0x0000, 0x0001) AM_WRITE_LEGACY(write1_w ) // lamps
- AM_RANGE(0x0002, 0x0003) AM_WRITE_LEGACY(write2_w ) // coin counter & coin lockout
- AM_RANGE(0x0004, 0x0005) AM_WRITE_LEGACY(newmcard_vblank_w )
+ AM_RANGE(0x0030, 0x0033) AM_READ(newmcard_status_r )
+ AM_RANGE(0x0030, 0x0031) AM_WRITE(tv_tcf_bankselect_w )
+ AM_RANGE(0x0000, 0x0001) AM_WRITE(write1_w ) // lamps
+ AM_RANGE(0x0002, 0x0003) AM_WRITE(write2_w ) // coin counter & coin lockout
+ AM_RANGE(0x0004, 0x0005) AM_WRITE(newmcard_vblank_w )
AM_RANGE(0x0006, 0x0007) AM_DEVWRITE_LEGACY("oki", tv_oki6376_w )
- AM_RANGE(0x0008, 0x0009) AM_READ_LEGACY(read1_r )
- AM_RANGE(0x000a, 0x000b) AM_READ_LEGACY(read2_r )
- AM_RANGE(0x000c, 0x000d) AM_READ_LEGACY(newmcard_vblank_r )
- AM_RANGE(0x000e, 0x000f) AM_READ_LEGACY(read3_r )
- AM_RANGE(0x0010, 0x0015) AM_WRITE_LEGACY(tv_vcf_paletteram_w )
+ AM_RANGE(0x0008, 0x0009) AM_READ(read1_r )
+ AM_RANGE(0x000a, 0x000b) AM_READ(read2_r )
+ AM_RANGE(0x000c, 0x000d) AM_READ(newmcard_vblank_r )
+ AM_RANGE(0x000e, 0x000f) AM_READ(read3_r )
+ AM_RANGE(0x0010, 0x0015) AM_WRITE(tv_vcf_paletteram_w )
ADDRESS_MAP_END
/****************************
@@ -457,9 +471,8 @@ ADDRESS_MAP_END
****************************/
-static READ16_HANDLER( brasil_status_r )
+READ16_MEMBER(highvdeo_state::brasil_status_r)
{
- highvdeo_state *state = space->machine().driver_data<highvdeo_state>();
static UINT16 resetpulse;
switch(offset*2)
@@ -468,7 +481,7 @@ static READ16_HANDLER( brasil_status_r )
resetpulse^=0x10;
return 3 | resetpulse;
- case 2: return (state->m_brasil_prot_latch & 3); //and 0x3f
+ case 2: return (m_brasil_prot_latch & 3); //and 0x3f
}
return 0;
@@ -477,22 +490,21 @@ static READ16_HANDLER( brasil_status_r )
/*bankaddress might be incorrect.*/
-static WRITE16_HANDLER( brasil_status_w )
+WRITE16_MEMBER(highvdeo_state::brasil_status_w)
{
- highvdeo_state *state = space->machine().driver_data<highvdeo_state>();
UINT32 bankaddress;
- UINT8 *ROM = space->machine().region("user1")->base();
+ UINT8 *ROM = machine().region("user1")->base();
switch(data & 3) //data & 7?
{
- case 0: state->m_brasil_prot_latch = 1; break;
- case 1: state->m_brasil_prot_latch = 0; break;
- case 2: state->m_brasil_prot_latch = 2; break;
+ case 0: m_brasil_prot_latch = 1; break;
+ case 1: m_brasil_prot_latch = 0; break;
+ case 2: m_brasil_prot_latch = 2; break;
}
bankaddress = (data & 0x07) * 0x40000;
- memory_set_bankptr(space->machine(), "bank1", &ROM[bankaddress]);
+ memory_set_bankptr(machine(), "bank1", &ROM[bankaddress]);
// popmessage("%04x",data);
}
@@ -506,14 +518,14 @@ static ADDRESS_MAP_START( brasil_map, AS_PROGRAM, 16, highvdeo_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( brasil_io, AS_IO, 16, highvdeo_state )
- AM_RANGE(0x0030, 0x0033) AM_READ_LEGACY(brasil_status_r )
- AM_RANGE(0x0030, 0x0031) AM_WRITE_LEGACY(brasil_status_w )
- AM_RANGE(0x0000, 0x0001) AM_WRITE_LEGACY(write1_w ) // lamps
- AM_RANGE(0x0002, 0x0003) AM_WRITE_LEGACY(write2_w ) // coin counter & coin lockout
+ AM_RANGE(0x0030, 0x0033) AM_READ(brasil_status_r )
+ AM_RANGE(0x0030, 0x0031) AM_WRITE(brasil_status_w )
+ AM_RANGE(0x0000, 0x0001) AM_WRITE(write1_w ) // lamps
+ AM_RANGE(0x0002, 0x0003) AM_WRITE(write2_w ) // coin counter & coin lockout
AM_RANGE(0x0006, 0x0007) AM_DEVWRITE_LEGACY("oki", tv_oki6376_w )
- AM_RANGE(0x0008, 0x0009) AM_READ_LEGACY(read1_r )
- AM_RANGE(0x000a, 0x000b) AM_READ_LEGACY(read2_r )
- AM_RANGE(0x000e, 0x000f) AM_READ_LEGACY(read3_r )
+ AM_RANGE(0x0008, 0x0009) AM_READ(read1_r )
+ AM_RANGE(0x000a, 0x000b) AM_READ(read2_r )
+ AM_RANGE(0x000e, 0x000f) AM_READ(read3_r )
// AM_RANGE(0x000e, 0x000f) AM_WRITE
// AM_RANGE(0xffa2, 0xffa3) AM_WRITE
ADDRESS_MAP_END
@@ -1160,7 +1172,7 @@ ROM_START( ciclone )
ROM_END
/*Ciclone*/
-static READ16_HANDLER( ciclone_status_r )
+READ16_MEMBER(highvdeo_state::ciclone_status_r)
{
static UINT16 resetpulse;
switch(offset*2)
@@ -1176,7 +1188,8 @@ static READ16_HANDLER( ciclone_status_r )
static DRIVER_INIT( ciclone )
{
- machine.device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0030, 0x0033, FUNC(ciclone_status_r) );
+ highvdeo_state *state = machine.driver_data<highvdeo_state>();
+ machine.device("maincpu")->memory().space(AS_IO)->install_read_handler(0x0030, 0x0033, read16_delegate(FUNC(highvdeo_state::ciclone_status_r), state));
}
/*
@@ -1231,7 +1244,7 @@ ROM_START( fashion )
ROM_LOAD( "sound-fashion-v-1-memory4m.u16", 0x00000, 0x80000, CRC(2927c799) SHA1(f11cad096a23fee10bfdff5bf944c96e30f4a8b8) )
ROM_END
-static WRITE16_HANDLER( fashion_output_w )
+WRITE16_MEMBER(highvdeo_state::fashion_output_w)
{
int i;
@@ -1239,14 +1252,15 @@ static WRITE16_HANDLER( fashion_output_w )
for(i=0;i<4;i++)
{
- coin_counter_w(space->machine(), i,data & 0x20);
- coin_lockout_w(space->machine(), i,~data & 0x01);
+ coin_counter_w(machine(), i,data & 0x20);
+ coin_lockout_w(machine(), i,~data & 0x01);
}
}
static DRIVER_INIT( fashion )
{
- machine.device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x0002, 0x0003, FUNC(fashion_output_w) );
+ highvdeo_state *state = machine.driver_data<highvdeo_state>();
+ machine.device("maincpu")->memory().space(AS_IO)->install_write_handler(0x0002, 0x0003, write16_delegate(FUNC(highvdeo_state::fashion_output_w), state));
}
GAMEL( 2000, tour4000, 0, tv_vcf, tv_vcf, 0, ROT0, "High Video", "Tour 4000", 0, layout_fashion )
diff --git a/src/mame/drivers/igs009.c b/src/mame/drivers/igs009.c
index e4e7d850702..589074b0e16 100644
--- a/src/mame/drivers/igs009.c
+++ b/src/mame/drivers/igs009.c
@@ -47,6 +47,19 @@ public:
int m_hopper;
UINT8 m_out[3];
UINT8 m_igs_magic[2];
+ DECLARE_WRITE8_MEMBER(gp98_reel1_ram_w);
+ DECLARE_WRITE8_MEMBER(gp98_reel2_ram_w);
+ DECLARE_WRITE8_MEMBER(gp98_reel3_ram_w);
+ DECLARE_WRITE8_MEMBER(gp98_reel4_ram_w);
+ DECLARE_WRITE8_MEMBER(bg_scroll_w);
+ DECLARE_WRITE8_MEMBER(fg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_color_w);
+ DECLARE_WRITE8_MEMBER(jingbell_nmi_and_coins_w);
+ DECLARE_WRITE8_MEMBER(jingbell_video_and_leds_w);
+ DECLARE_WRITE8_MEMBER(jingbell_leds_w);
+ DECLARE_WRITE8_MEMBER(jingbell_magic_w);
+ DECLARE_READ8_MEMBER(jingbell_magic_r);
+ void show_out();
};
@@ -56,11 +69,10 @@ public:
-static WRITE8_HANDLER( gp98_reel1_ram_w )
+WRITE8_MEMBER(igs009_state::gp98_reel1_ram_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_gp98_reel1_ram[offset] = data;
- state->m_gp98_reel1_tilemap->mark_tile_dirty(offset);
+ m_gp98_reel1_ram[offset] = data;
+ m_gp98_reel1_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel1_tile_info )
@@ -89,11 +101,10 @@ static TILE_GET_INFO( get_gp98_reel1_tile_info )
}
-static WRITE8_HANDLER( gp98_reel2_ram_w )
+WRITE8_MEMBER(igs009_state::gp98_reel2_ram_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_gp98_reel2_ram[offset] = data;
- state->m_gp98_reel2_tilemap->mark_tile_dirty(offset);
+ m_gp98_reel2_ram[offset] = data;
+ m_gp98_reel2_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel2_tile_info )
@@ -122,11 +133,10 @@ static TILE_GET_INFO( get_gp98_reel2_tile_info )
-static WRITE8_HANDLER( gp98_reel3_ram_w )
+WRITE8_MEMBER(igs009_state::gp98_reel3_ram_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_gp98_reel3_ram[offset] = data;
- state->m_gp98_reel3_tilemap->mark_tile_dirty(offset);
+ m_gp98_reel3_ram[offset] = data;
+ m_gp98_reel3_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel3_tile_info )
@@ -155,11 +165,10 @@ static TILE_GET_INFO( get_gp98_reel3_tile_info )
-static WRITE8_HANDLER( gp98_reel4_ram_w )
+WRITE8_MEMBER(igs009_state::gp98_reel4_ram_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_gp98_reel4_ram[offset] = data;
- state->m_gp98_reel4_tilemap->mark_tile_dirty(offset);
+ m_gp98_reel4_ram[offset] = data;
+ m_gp98_reel4_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel4_tile_info )
@@ -192,10 +201,9 @@ static TILE_GET_INFO( get_gp98_reel4_tile_info )
-static WRITE8_HANDLER( bg_scroll_w )
+WRITE8_MEMBER(igs009_state::bg_scroll_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_bg_scroll[offset] = data;
+ m_bg_scroll[offset] = data;
// bg_tilemap->set_scrolly(offset,data);
}
@@ -207,18 +215,16 @@ static TILE_GET_INFO( get_fg_tile_info )
SET_TILE_INFO(1, code, (4*(code >> 14)+3), 0);
}
-static WRITE8_HANDLER( fg_tile_w )
+WRITE8_MEMBER(igs009_state::fg_tile_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_fg_tile_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_tile_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( fg_color_w )
+WRITE8_MEMBER(igs009_state::fg_color_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_fg_color_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_color_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(jingbell)
@@ -344,97 +350,92 @@ static CUSTOM_INPUT( hopper_r )
}
-static void show_out(igs009_state *state)
+void igs009_state::show_out()
{
#ifdef MAME_DEBUG
- popmessage("%02x %02x %02x", state->m_out[0], state->m_out[1], state->m_out[2]);
+ popmessage("%02x %02x %02x", m_out[0], m_out[1], m_out[2]);
#endif
}
-static WRITE8_HANDLER( jingbell_nmi_and_coins_w )
+WRITE8_MEMBER(igs009_state::jingbell_nmi_and_coins_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- if ((state->m_nmi_enable ^ data) & (~0xdd))
+ if ((m_nmi_enable ^ data) & (~0xdd))
{
- logerror("PC %06X: nmi_and_coins = %02x\n",cpu_get_pc(&space->device()),data);
+ logerror("PC %06X: nmi_and_coins = %02x\n",cpu_get_pc(&space.device()),data);
// popmessage("%02x",data);
}
- coin_counter_w(space->machine(), 0, data & 0x01); // coin_a
- coin_counter_w(space->machine(), 1, data & 0x04); // coin_c
- coin_counter_w(space->machine(), 2, data & 0x08); // key in
- coin_counter_w(space->machine(), 3, data & 0x10); // coin state->m_out mech
+ coin_counter_w(machine(), 0, data & 0x01); // coin_a
+ coin_counter_w(machine(), 1, data & 0x04); // coin_c
+ coin_counter_w(machine(), 2, data & 0x08); // key in
+ coin_counter_w(machine(), 3, data & 0x10); // coin m_out mech
- set_led_status(space->machine(), 6, data & 0x40); // led for coin state->m_out / state->m_hopper active
+ set_led_status(machine(), 6, data & 0x40); // led for coin m_out / m_hopper active
- state->m_nmi_enable = data; // data & 0x80 // nmi enable?
+ m_nmi_enable = data; // data & 0x80 // nmi enable?
- state->m_out[0] = data;
- show_out(state);
+ m_out[0] = data;
+ show_out();
}
-static WRITE8_HANDLER( jingbell_video_and_leds_w )
+WRITE8_MEMBER(igs009_state::jingbell_video_and_leds_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- set_led_status(space->machine(), 4, data & 0x01); // start?
- set_led_status(space->machine(), 5, data & 0x04); // l_bet?
+ set_led_status(machine(), 4, data & 0x01); // start?
+ set_led_status(machine(), 5, data & 0x04); // l_bet?
- state->m_video_enable = data & 0x40;
- state->m_hopper = (~data)& 0x80;
+ m_video_enable = data & 0x40;
+ m_hopper = (~data)& 0x80;
- state->m_out[1] = data;
- show_out(state);
+ m_out[1] = data;
+ show_out();
}
-static WRITE8_HANDLER( jingbell_leds_w )
+WRITE8_MEMBER(igs009_state::jingbell_leds_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- set_led_status(space->machine(), 0, data & 0x01); // stop_1
- set_led_status(space->machine(), 1, data & 0x02); // stop_2
- set_led_status(space->machine(), 2, data & 0x04); // stop_3
- set_led_status(space->machine(), 3, data & 0x08); // stop
+ set_led_status(machine(), 0, data & 0x01); // stop_1
+ set_led_status(machine(), 1, data & 0x02); // stop_2
+ set_led_status(machine(), 2, data & 0x04); // stop_3
+ set_led_status(machine(), 3, data & 0x08); // stop
// data & 0x10?
- state->m_out[2] = data;
- show_out(state);
+ m_out[2] = data;
+ show_out();
}
-static WRITE8_HANDLER( jingbell_magic_w )
+WRITE8_MEMBER(igs009_state::jingbell_magic_w)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- state->m_igs_magic[offset] = data;
+ m_igs_magic[offset] = data;
if (offset == 0)
return;
- switch(state->m_igs_magic[0])
+ switch(m_igs_magic[0])
{
case 0x01:
break;
default:
-// popmessage("magic %x <- %04x",state->m_igs_magic[0],data);
- logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0], data);
+// popmessage("magic %x <- %04x",m_igs_magic[0],data);
+ logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space.device()), m_igs_magic[0], data);
}
}
-static READ8_HANDLER( jingbell_magic_r )
+READ8_MEMBER(igs009_state::jingbell_magic_r)
{
- igs009_state *state = space->machine().driver_data<igs009_state>();
- switch(state->m_igs_magic[0])
+ switch(m_igs_magic[0])
{
case 0x00:
- if ( !(state->m_igs_magic[1] & 0x01) ) return input_port_read(space->machine(), "DSW1");
- if ( !(state->m_igs_magic[1] & 0x02) ) return input_port_read(space->machine(), "DSW2");
- if ( !(state->m_igs_magic[1] & 0x04) ) return input_port_read(space->machine(), "DSW3");
- if ( !(state->m_igs_magic[1] & 0x08) ) return input_port_read(space->machine(), "DSW4");
- if ( !(state->m_igs_magic[1] & 0x10) ) return input_port_read(space->machine(), "DSW5");
- logerror("%06x: warning, reading dsw with igs_magic[1] = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[1]);
+ if ( !(m_igs_magic[1] & 0x01) ) return input_port_read(machine(), "DSW1");
+ if ( !(m_igs_magic[1] & 0x02) ) return input_port_read(machine(), "DSW2");
+ if ( !(m_igs_magic[1] & 0x04) ) return input_port_read(machine(), "DSW3");
+ if ( !(m_igs_magic[1] & 0x08) ) return input_port_read(machine(), "DSW4");
+ if ( !(m_igs_magic[1] & 0x10) ) return input_port_read(machine(), "DSW5");
+ logerror("%06x: warning, reading dsw with igs_magic[1] = %02x\n", cpu_get_pc(&space.device()), m_igs_magic[1]);
break;
default:
- logerror("%06x: warning, reading with igs_magic = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0]);
+ logerror("%06x: warning, reading with igs_magic = %02x\n", cpu_get_pc(&space.device()), m_igs_magic[0]);
}
return 0;
@@ -451,36 +452,36 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( jingbell_portmap, AS_IO, 8, igs009_state )
AM_RANGE( 0x0000, 0x003f ) AM_RAM // Z180 internal regs
- AM_RANGE( 0x1000, 0x11ff ) AM_RAM_WRITE_LEGACY(bg_scroll_w ) AM_BASE(m_bg_scroll )
+ AM_RANGE( 0x1000, 0x11ff ) AM_RAM_WRITE(bg_scroll_w ) AM_BASE(m_bg_scroll )
AM_RANGE( 0x2000, 0x23ff ) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split1_w ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x2400, 0x27ff ) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split2_w ) AM_BASE_GENERIC( paletteram2 )
- AM_RANGE( 0x3000, 0x33ff ) AM_RAM_WRITE_LEGACY(gp98_reel1_ram_w ) AM_BASE(m_gp98_reel1_ram )
- AM_RANGE( 0x3400, 0x37ff ) AM_RAM_WRITE_LEGACY(gp98_reel2_ram_w ) AM_BASE(m_gp98_reel2_ram )
- AM_RANGE( 0x3800, 0x3bff ) AM_RAM_WRITE_LEGACY(gp98_reel3_ram_w ) AM_BASE(m_gp98_reel3_ram )
- AM_RANGE( 0x3c00, 0x3fff ) AM_RAM_WRITE_LEGACY(gp98_reel4_ram_w ) AM_BASE(m_gp98_reel4_ram )
+ AM_RANGE( 0x3000, 0x33ff ) AM_RAM_WRITE(gp98_reel1_ram_w ) AM_BASE(m_gp98_reel1_ram )
+ AM_RANGE( 0x3400, 0x37ff ) AM_RAM_WRITE(gp98_reel2_ram_w ) AM_BASE(m_gp98_reel2_ram )
+ AM_RANGE( 0x3800, 0x3bff ) AM_RAM_WRITE(gp98_reel3_ram_w ) AM_BASE(m_gp98_reel3_ram )
+ AM_RANGE( 0x3c00, 0x3fff ) AM_RAM_WRITE(gp98_reel4_ram_w ) AM_BASE(m_gp98_reel4_ram )
AM_RANGE( 0x4000, 0x407f ) AM_RAM AM_BASE(m_bg_scroll2 )
- AM_RANGE( 0x5000, 0x5fff ) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE( 0x5000, 0x5fff ) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE( 0x6480, 0x6480 ) AM_WRITE_LEGACY(jingbell_nmi_and_coins_w )
+ AM_RANGE( 0x6480, 0x6480 ) AM_WRITE(jingbell_nmi_and_coins_w )
AM_RANGE( 0x6481, 0x6481 ) AM_READ_PORT( "SERVICE" )
AM_RANGE( 0x6482, 0x6482 ) AM_READ_PORT( "COINS" )
AM_RANGE( 0x6490, 0x6490 ) AM_READ_PORT( "BUTTONS1" )
- AM_RANGE( 0x6491, 0x6491 ) AM_WRITE_LEGACY(jingbell_video_and_leds_w )
- AM_RANGE( 0x6492, 0x6492 ) AM_WRITE_LEGACY(jingbell_leds_w )
+ AM_RANGE( 0x6491, 0x6491 ) AM_WRITE(jingbell_video_and_leds_w )
+ AM_RANGE( 0x6492, 0x6492 ) AM_WRITE(jingbell_leds_w )
AM_RANGE( 0x64a0, 0x64a0 ) AM_READ_PORT( "BUTTONS2" )
AM_RANGE( 0x64b0, 0x64b1 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w )
AM_RANGE( 0x64c0, 0x64c0 ) AM_DEVREADWRITE("oki", okim6295_device, read, write)
- AM_RANGE( 0x64d0, 0x64d1 ) AM_READWRITE_LEGACY(jingbell_magic_r, jingbell_magic_w ) // DSW1-5
+ AM_RANGE( 0x64d0, 0x64d1 ) AM_READWRITE(jingbell_magic_r, jingbell_magic_w ) // DSW1-5
- AM_RANGE( 0x7000, 0x7fff ) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE( 0x7000, 0x7fff ) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
AM_RANGE( 0x8000, 0xffff ) AM_ROM AM_REGION("data", 0)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/igs011.c b/src/mame/drivers/igs011.c
index bd72dfce831..e3e05940024 100644
--- a/src/mame/drivers/igs011.c
+++ b/src/mame/drivers/igs011.c
@@ -108,6 +108,71 @@ public:
blitter_t m_blitter;
required_device<cpu_device> m_maincpu;
+ DECLARE_WRITE16_MEMBER(igs011_priority_w);
+ DECLARE_READ16_MEMBER(igs011_layers_r);
+ DECLARE_WRITE16_MEMBER(igs011_layers_w);
+ DECLARE_WRITE16_MEMBER(igs011_palette);
+ DECLARE_WRITE16_MEMBER(igs011_blit_x_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_y_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_gfx_lo_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_gfx_hi_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_w_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_h_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_depth_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_pen_w);
+ DECLARE_WRITE16_MEMBER(igs011_blit_flags_w);
+ DECLARE_WRITE16_MEMBER(igs_dips_w);
+ DECLARE_READ16_MEMBER(igs_3_dips_r);
+ DECLARE_READ16_MEMBER(igs_4_dips_r);
+ DECLARE_READ16_MEMBER(igs_5_dips_r);
+ DECLARE_WRITE16_MEMBER(igs011_prot1_w);
+ DECLARE_READ16_MEMBER(igs011_prot1_r);
+ DECLARE_WRITE16_MEMBER(igs011_prot_addr_w);
+ DECLARE_READ16_MEMBER(igs011_prot_fake_r);
+ DECLARE_WRITE16_MEMBER(igs011_prot2_reset_w);
+ DECLARE_READ16_MEMBER(igs011_prot2_reset_r);
+ DECLARE_WRITE16_MEMBER(igs011_prot2_inc_w);
+ DECLARE_WRITE16_MEMBER(igs011_prot2_dec_w);
+ DECLARE_WRITE16_MEMBER(drgnwrld_igs011_prot2_swap_w);
+ DECLARE_WRITE16_MEMBER(lhb_igs011_prot2_swap_w);
+ DECLARE_WRITE16_MEMBER(wlcc_igs011_prot2_swap_w);
+ DECLARE_WRITE16_MEMBER(vbowl_igs011_prot2_swap_w);
+ DECLARE_READ16_MEMBER(drgnwrldv21_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(drgnwrldv20j_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(lhb_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(dbc_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(ryukobou_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(lhb2_igs011_prot2_r);
+ DECLARE_READ16_MEMBER(vbowl_igs011_prot2_r);
+ DECLARE_WRITE16_MEMBER(igs012_prot_reset_w);
+ DECLARE_READ16_MEMBER(igs012_prot_fake_r);
+ DECLARE_WRITE16_MEMBER(igs012_prot_mode_w);
+ DECLARE_WRITE16_MEMBER(igs012_prot_inc_w);
+ DECLARE_WRITE16_MEMBER(igs012_prot_dec_inc_w);
+ DECLARE_WRITE16_MEMBER(igs012_prot_dec_copy_w);
+ DECLARE_WRITE16_MEMBER(igs012_prot_copy_w);
+ DECLARE_WRITE16_MEMBER(igs012_prot_swap_w);
+ DECLARE_READ16_MEMBER(igs012_prot_r);
+ DECLARE_WRITE16_MEMBER(drgnwrld_igs003_w);
+ DECLARE_READ16_MEMBER(drgnwrld_igs003_r);
+ DECLARE_WRITE16_MEMBER(lhb_inputs_w);
+ DECLARE_READ16_MEMBER(lhb_inputs_r);
+ DECLARE_WRITE16_MEMBER(lhb2_igs003_w);
+ DECLARE_READ16_MEMBER(lhb2_igs003_r);
+ DECLARE_WRITE16_MEMBER(wlcc_igs003_w);
+ DECLARE_READ16_MEMBER(wlcc_igs003_r);
+ DECLARE_WRITE16_MEMBER(xymg_igs003_w);
+ DECLARE_READ16_MEMBER(xymg_igs003_r);
+ DECLARE_WRITE16_MEMBER(vbowl_igs003_w);
+ DECLARE_READ16_MEMBER(vbowl_igs003_r);
+ DECLARE_WRITE16_MEMBER(lhb_irq_enable_w);
+ DECLARE_READ16_MEMBER(vbowl_unk_r);
+ DECLARE_WRITE16_MEMBER(vbowl_pen_hi_w);
+ DECLARE_WRITE16_MEMBER(vbowl_link_0_w);
+ DECLARE_WRITE16_MEMBER(vbowl_link_1_w);
+ DECLARE_WRITE16_MEMBER(vbowl_link_2_w);
+ DECLARE_WRITE16_MEMBER(vbowl_link_3_w);
+ UINT16 igs_dips_r(int NUM);
};
@@ -132,15 +197,14 @@ public:
-static WRITE16_HANDLER( igs011_priority_w )
+WRITE16_MEMBER(igs011_state::igs011_priority_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_priority);
+ COMBINE_DATA(&m_priority);
-// logerror("%06x: priority = %02x\n", cpu_get_pc(&space->device()), state->m_priority);
+// logerror("%06x: priority = %02x\n", cpu_get_pc(&space.device()), m_priority);
if (data & ~0x7)
- logerror("%06x: warning, unknown bits written to priority = %02x\n", cpu_get_pc(&space->device()), state->m_priority);
+ logerror("%06x: warning, unknown bits written to priority = %02x\n", cpu_get_pc(&space.device()), m_priority);
}
@@ -234,13 +298,12 @@ static SCREEN_UPDATE_IND16( igs011 )
***************************************************************************/
-static READ16_HANDLER( igs011_layers_r )
+READ16_MEMBER(igs011_state::igs011_layers_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
int layer0 = ((offset & (0x80000/2)) ? 4 : 0) + ((offset & 1) ? 0 : 2);
- UINT8 *l0 = state->m_layer[layer0];
- UINT8 *l1 = state->m_layer[layer0+1];
+ UINT8 *l0 = m_layer[layer0];
+ UINT8 *l1 = m_layer[layer0+1];
offset >>= 1;
offset &= 0x1ffff;
@@ -248,15 +311,14 @@ static READ16_HANDLER( igs011_layers_r )
return (l0[offset] << 8) | l1[offset];
}
-static WRITE16_HANDLER( igs011_layers_w )
+WRITE16_MEMBER(igs011_state::igs011_layers_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
UINT16 word;
int layer0 = ((offset & (0x80000/2)) ? 4 : 0) + ((offset & 1) ? 0 : 2);
- UINT8 *l0 = state->m_layer[layer0];
- UINT8 *l1 = state->m_layer[layer0+1];
+ UINT8 *l0 = m_layer[layer0];
+ UINT8 *l1 = m_layer[layer0+1];
offset >>= 1;
offset &= 0x1ffff;
@@ -276,14 +338,14 @@ static WRITE16_HANDLER( igs011_layers_w )
***************************************************************************/
-static WRITE16_HANDLER( igs011_palette )
+WRITE16_MEMBER(igs011_state::igs011_palette)
{
int rgb;
- COMBINE_DATA(&space->machine().generic.paletteram.u16[offset]);
+ COMBINE_DATA(&machine().generic.paletteram.u16[offset]);
- rgb = (space->machine().generic.paletteram.u16[offset & 0x7ff] & 0xff) | ((space->machine().generic.paletteram.u16[offset | 0x800] & 0xff) << 8);
- palette_set_color_rgb(space->machine(),offset & 0x7ff,pal5bit(rgb >> 0),pal5bit(rgb >> 5),pal5bit(rgb >> 10));
+ rgb = (machine().generic.paletteram.u16[offset & 0x7ff] & 0xff) | ((machine().generic.paletteram.u16[offset | 0x800] & 0xff) << 8);
+ palette_set_color_rgb(machine(),offset & 0x7ff,pal5bit(rgb >> 0),pal5bit(rgb >> 5),pal5bit(rgb >> 10));
}
/***************************************************************************
@@ -293,95 +355,86 @@ static WRITE16_HANDLER( igs011_palette )
***************************************************************************/
-static WRITE16_HANDLER( igs011_blit_x_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_x_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.x);
}
-static WRITE16_HANDLER( igs011_blit_y_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_y_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.y);
}
-static WRITE16_HANDLER( igs011_blit_gfx_lo_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_gfx_lo_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.gfx_lo);
}
-static WRITE16_HANDLER( igs011_blit_gfx_hi_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_gfx_hi_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.gfx_hi);
}
-static WRITE16_HANDLER( igs011_blit_w_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_w_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.w);
}
-static WRITE16_HANDLER( igs011_blit_h_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_h_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.h);
}
-static WRITE16_HANDLER( igs011_blit_depth_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_depth_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.depth);
}
-static WRITE16_HANDLER( igs011_blit_pen_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_pen_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
COMBINE_DATA(&blitter.pen);
}
-static WRITE16_HANDLER( igs011_blit_flags_w )
+WRITE16_MEMBER(igs011_state::igs011_blit_flags_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- struct blitter_t &blitter = state->m_blitter;
+ struct blitter_t &blitter = m_blitter;
int x, xstart, xend, xinc, flipx;
int y, ystart, yend, yinc, flipy;
int depth4, clear, opaque, z;
UINT8 trans_pen, clear_pen, pen_hi, *dest;
UINT8 pen = 0;
- UINT8 *gfx = space->machine().region("blitter")->base();
- UINT8 *gfx2 = space->machine().region("blitter_hi")->base();
- int gfx_size = space->machine().region("blitter")->bytes();
- int gfx2_size = space->machine().region("blitter_hi")->bytes();
+ UINT8 *gfx = machine().region("blitter")->base();
+ UINT8 *gfx2 = machine().region("blitter_hi")->base();
+ int gfx_size = machine().region("blitter")->bytes();
+ int gfx2_size = machine().region("blitter_hi")->bytes();
- const rectangle &clip = space->machine().primary_screen->visible_area();
+ const rectangle &clip = machine().primary_screen->visible_area();
COMBINE_DATA(&blitter.flags);
#if LOG_BLITTER
- logerror("%06x: blit x %03x, y %03x, w %03x, h %03x, gfx %03x%04x, depth %02x, pen %02x, flags %03x\n", cpu_get_pc(&space->device()),
+ logerror("%06x: blit x %03x, y %03x, w %03x, h %03x, gfx %03x%04x, depth %02x, pen %02x, flags %03x\n", cpu_get_pc(&space.device()),
blitter.x,blitter.y,blitter.w,blitter.h,blitter.gfx_hi,blitter.gfx_lo,blitter.depth,blitter.pen,blitter.flags);
#endif
- dest = state->m_layer[ blitter.flags & 0x0007 ];
+ dest = m_layer[ blitter.flags & 0x0007 ];
opaque = !(blitter.flags & 0x0008);
clear = blitter.flags & 0x0010;
flipx = blitter.flags & 0x0020;
flipy = blitter.flags & 0x0040;
if (!(blitter.flags & 0x0400)) return;
- pen_hi = (state->m_lhb2_pen_hi & 0x07) << 5;
+ pen_hi = (m_lhb2_pen_hi & 0x07) << 5;
// pixel address
z = blitter.gfx_lo + (blitter.gfx_hi << 16);
@@ -449,7 +502,7 @@ static WRITE16_HANDLER( igs011_blit_flags_w )
#ifdef MAME_DEBUG
#if 1
- if (space->machine().input().code_pressed(KEYCODE_Z))
+ if (machine().input().code_pressed(KEYCODE_Z))
{ char buf[20];
sprintf(buf, "%02X%02X",blitter.depth,blitter.flags&0xff);
// ui_draw_text(buf, blitter.x, blitter.y); // crashes mame!
@@ -473,30 +526,28 @@ static CUSTOM_INPUT( igs_hopper_r )
return (state->m_igs_hopper && ((field.machine().primary_screen->frame_number()/5)&1)) ? 0x0000 : 0x0001;
}
-static WRITE16_HANDLER( igs_dips_w )
+WRITE16_MEMBER(igs011_state::igs_dips_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs_dips_sel);
+ COMBINE_DATA(&m_igs_dips_sel);
}
-INLINE UINT16 igs_dips_r(address_space *space, int NUM)
+UINT16 igs011_state::igs_dips_r(int NUM)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
int i;
UINT16 ret=0;
static const char *const dipnames[] = { "DSW1", "DSW2", "DSW3", "DSW4", "DSW5" };
for (i = 0; i < NUM; i++)
- if ((~state->m_igs_dips_sel) & (1 << i) )
- ret = input_port_read(space->machine(), dipnames[i]);
+ if ((~m_igs_dips_sel) & (1 << i) )
+ ret = input_port_read(machine(), dipnames[i]);
/* 0x0100 is blitter busy */
return (ret & 0xff) | 0x0000;
}
// Games have 3 to 5 dips
-static READ16_HANDLER( igs_3_dips_r ) { return igs_dips_r(space, 3); }
-static READ16_HANDLER( igs_4_dips_r ) { return igs_dips_r(space, 4); }
-static READ16_HANDLER( igs_5_dips_r ) { return igs_dips_r(space, 5); }
+READ16_MEMBER(igs011_state::igs_3_dips_r){ return igs_dips_r(3); }
+READ16_MEMBER(igs011_state::igs_4_dips_r){ return igs_dips_r(4); }
+READ16_MEMBER(igs011_state::igs_5_dips_r){ return igs_dips_r(5); }
/***************************************************************************
@@ -903,9 +954,8 @@ static void drgnwrld_gfx_decrypt(running_machine &machine)
-static WRITE16_HANDLER( igs011_prot1_w )
+WRITE16_MEMBER(igs011_state::igs011_prot1_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
offset *= 2;
switch (offset)
@@ -913,7 +963,7 @@ static WRITE16_HANDLER( igs011_prot1_w )
case 0: // COPY
if (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300)
{
- state->m_prot1 = state->m_prot1_swap;
+ m_prot1 = m_prot1_swap;
return;
}
break;
@@ -921,7 +971,7 @@ static WRITE16_HANDLER( igs011_prot1_w )
case 2: // INC
if (ACCESSING_BITS_8_15 && (data & 0xff00) == 0xff00)
{
- state->m_prot1++;
+ m_prot1++;
return;
}
break;
@@ -929,7 +979,7 @@ static WRITE16_HANDLER( igs011_prot1_w )
case 4: // DEC
if (ACCESSING_BITS_8_15 && (data & 0xff00) == 0xaa00)
{
- state->m_prot1--;
+ m_prot1--;
return;
}
break;
@@ -938,53 +988,50 @@ static WRITE16_HANDLER( igs011_prot1_w )
if (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x5500)
{
// b1 . (b2|b3) . b2 . (b0&b3)
- UINT8 x = state->m_prot1;
- state->m_prot1_swap = (BIT(x,1)<<3) | ((BIT(x,2)|BIT(x,3))<<2) | (BIT(x,2)<<1) | (BIT(x,0)&BIT(x,3));
+ UINT8 x = m_prot1;
+ m_prot1_swap = (BIT(x,1)<<3) | ((BIT(x,2)|BIT(x,3))<<2) | (BIT(x,2)<<1) | (BIT(x,0)&BIT(x,3));
return;
}
break;
}
- logerror("%s: warning, unknown igs011_prot1_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+ logerror("%s: warning, unknown igs011_prot1_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
-static READ16_HANDLER( igs011_prot1_r )
+READ16_MEMBER(igs011_state::igs011_prot1_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// !(b1&b2) . 0 . 0 . (b0^b3) . 0 . 0
- UINT8 x = state->m_prot1;
+ UINT8 x = m_prot1;
return (((BIT(x,1)&BIT(x,2))^1)<<5) | ((BIT(x,0)^BIT(x,3))<<2);
}
-static WRITE16_HANDLER( igs011_prot_addr_w )
+WRITE16_MEMBER(igs011_state::igs011_prot_addr_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- state->m_prot1 = 0x00;
- state->m_prot1_swap = 0x00;
+ m_prot1 = 0x00;
+ m_prot1_swap = 0x00;
-// state->m_prot2 = 0x00;
+// m_prot2 = 0x00;
- address_space *sp = space->machine().device("maincpu")->memory().space(AS_PROGRAM);
- UINT8 *rom = space->machine().region("maincpu")->base();
+ address_space *sp = machine().device("maincpu")->memory().space(AS_PROGRAM);
+ UINT8 *rom = machine().region("maincpu")->base();
// Plug previous address range with ROM access
- sp->install_rom(state->m_prot1_addr + 0, state->m_prot1_addr + 9, rom + state->m_prot1_addr);
+ sp->install_rom(m_prot1_addr + 0, m_prot1_addr + 9, rom + m_prot1_addr);
- state->m_prot1_addr = (data << 4) ^ 0x8340;
+ m_prot1_addr = (data << 4) ^ 0x8340;
// Add protection memory range
- sp->install_legacy_write_handler(state->m_prot1_addr + 0, state->m_prot1_addr + 7, FUNC(igs011_prot1_w));
- sp->install_legacy_read_handler (state->m_prot1_addr + 8, state->m_prot1_addr + 9, FUNC(igs011_prot1_r));
+ sp->install_write_handler(m_prot1_addr + 0, m_prot1_addr + 7, write16_delegate(FUNC(igs011_state::igs011_prot1_w), this));
+ sp->install_read_handler (m_prot1_addr + 8, m_prot1_addr + 9, read16_delegate(FUNC(igs011_state::igs011_prot1_r), this));
}
/*
-static READ16_HANDLER( igs011_prot_fake_r )
+READ16_MEMBER(igs011_state::igs011_prot_fake_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
switch (offset)
{
- case 0: return state->m_prot1;
- case 1: return state->m_prot1_swap;
- case 2: return state->m_prot2;
+ case 0: return m_prot1;
+ case 1: return m_prot1_swap;
+ case 2: return m_prot2;
}
return 0;
}
@@ -998,176 +1045,161 @@ static READ16_HANDLER( igs011_prot_fake_r )
// Prot2
// drgnwrld (33)
-static WRITE16_HANDLER( igs011_prot2_reset_w )
+WRITE16_MEMBER(igs011_state::igs011_prot2_reset_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- state->m_prot2 = 0x00;
+ m_prot2 = 0x00;
}
// wlcc
-static READ16_HANDLER( igs011_prot2_reset_r )
+READ16_MEMBER(igs011_state::igs011_prot2_reset_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- state->m_prot2 = 0x00;
+ m_prot2 = 0x00;
return 0;
}
// lhb2 (55), lhb/dbc/ryukobou (33)
-static WRITE16_HANDLER( igs011_prot2_inc_w )
+WRITE16_MEMBER(igs011_state::igs011_prot2_inc_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x5500) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0055)) )
{
- state->m_prot2++;
+ m_prot2++;
}
// else
-// logerror("%s: warning, unknown igs011_prot2_inc_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_inc_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
// vbowl (33)
-static WRITE16_HANDLER( igs011_prot2_dec_w )
+WRITE16_MEMBER(igs011_state::igs011_prot2_dec_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0033)) )
{
- state->m_prot2--;
+ m_prot2--;
}
// else
-// logerror("%s: warning, unknown igs011_prot2_dec_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_dec_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
-static WRITE16_HANDLER( drgnwrld_igs011_prot2_swap_w )
+WRITE16_MEMBER(igs011_state::drgnwrld_igs011_prot2_swap_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
offset *= 2;
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0033)) )
{
// (b3&b0) . b2 . (b0|b1) . (b2^!b4) . (!b1^b3)
- UINT8 x = state->m_prot2;
- state->m_prot2 = ((BIT(x,3)&BIT(x,0))<<4) | (BIT(x,2)<<3) | ((BIT(x,0)|BIT(x,1))<<2) | ((BIT(x,2)^BIT(x,4)^1)<<1) | (BIT(x,1)^1^BIT(x,3));
+ UINT8 x = m_prot2;
+ m_prot2 = ((BIT(x,3)&BIT(x,0))<<4) | (BIT(x,2)<<3) | ((BIT(x,0)|BIT(x,1))<<2) | ((BIT(x,2)^BIT(x,4)^1)<<1) | (BIT(x,1)^1^BIT(x,3));
}
// else
-// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
// lhb, xymg, lhb2
-static WRITE16_HANDLER( lhb_igs011_prot2_swap_w )
+WRITE16_MEMBER(igs011_state::lhb_igs011_prot2_swap_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
offset *= 2;
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0033)) )
{
// (!b0|b1) . b2 . (b0&b1)
- UINT8 x = state->m_prot2;
- state->m_prot2 = (((BIT(x,0)^1)|BIT(x,1))<<2) | (BIT(x,2)<<1) | (BIT(x,0)&BIT(x,1));
+ UINT8 x = m_prot2;
+ m_prot2 = (((BIT(x,0)^1)|BIT(x,1))<<2) | (BIT(x,2)<<1) | (BIT(x,0)&BIT(x,1));
}
// else
-// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
// wlcc
-static WRITE16_HANDLER( wlcc_igs011_prot2_swap_w )
+WRITE16_MEMBER(igs011_state::wlcc_igs011_prot2_swap_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
offset *= 2;
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0033)) )
{
// (b3 ^ b2) . (b2 ^ b1) . (b1 ^ b0) . !(b4 ^ b0) . !(b4 ^ b3)
- UINT8 x = state->m_prot2;
- state->m_prot2 = ((BIT(x,3)^BIT(x,2))<<4) | ((BIT(x,2)^BIT(x,1))<<3) | ((BIT(x,1)^BIT(x,0))<<2) | ((BIT(x,4)^BIT(x,0)^1)<<1) | (BIT(x,4)^BIT(x,3)^1);
+ UINT8 x = m_prot2;
+ m_prot2 = ((BIT(x,3)^BIT(x,2))<<4) | ((BIT(x,2)^BIT(x,1))<<3) | ((BIT(x,1)^BIT(x,0))<<2) | ((BIT(x,4)^BIT(x,0)^1)<<1) | (BIT(x,4)^BIT(x,3)^1);
}
// else
-// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
// vbowl
-static WRITE16_HANDLER( vbowl_igs011_prot2_swap_w )
+WRITE16_MEMBER(igs011_state::vbowl_igs011_prot2_swap_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
offset *= 2;
// if ( (ACCESSING_BITS_8_15 && (data & 0xff00) == 0x3300) || ((ACCESSING_BITS_0_7 && (data & 0x00ff) == 0x0033)) )
{
// (b3 ^ b2) . (b2 ^ b1) . (b1 ^ b0) . (b4 ^ b0) . (b4 ^ b3)
- UINT8 x = state->m_prot2;
- state->m_prot2 = ((BIT(x,3)^BIT(x,2))<<4) | ((BIT(x,2)^BIT(x,1))<<3) | ((BIT(x,1)^BIT(x,0))<<2) | ((BIT(x,4)^BIT(x,0))<<1) | (BIT(x,4)^BIT(x,3));
+ UINT8 x = m_prot2;
+ m_prot2 = ((BIT(x,3)^BIT(x,2))<<4) | ((BIT(x,2)^BIT(x,1))<<3) | ((BIT(x,1)^BIT(x,0))<<2) | ((BIT(x,4)^BIT(x,0))<<1) | (BIT(x,4)^BIT(x,3));
}
// else
-// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", space->machine().describe_context(), offset, data);
+// logerror("%s: warning, unknown igs011_prot2_swap_w( %04x, %04x )\n", machine().describe_context(), offset, data);
}
// drgnwrld
-static READ16_HANDLER( drgnwrldv21_igs011_prot2_r )
+READ16_MEMBER(igs011_state::drgnwrldv21_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b9 = (!b4) | (!b0 & b2) | (!(b3 ^ b1) & !(!(b4 & b0) | b2))
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = (BIT(x,4)^1) | ((BIT(x,0)^1) & BIT(x,2)) | ( (BIT(x,3)^BIT(x,1)^1) & ((((BIT(x,4)^1) & BIT(x,0)) | BIT(x,2))^1) );
return (b9 << 9);
}
-static READ16_HANDLER( drgnwrldv20j_igs011_prot2_r )
+READ16_MEMBER(igs011_state::drgnwrldv20j_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b9 = (!b4 | !b0) | !(b3 | b1) | !(b2 & b0)
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = ((BIT(x,4)^1) | (BIT(x,0)^1)) | ((BIT(x,3) | BIT(x,1))^1) | ((BIT(x,2) & BIT(x,0))^1);
return (b9 << 9);
}
// lhb, xymg
-static READ16_HANDLER( lhb_igs011_prot2_r )
+READ16_MEMBER(igs011_state::lhb_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b9 = !b2 | (b1 & b0)
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = (BIT(x,2)^1) | (BIT(x,1) & BIT(x,0));
return (b9 << 9);
}
// dbc
-static READ16_HANDLER( dbc_igs011_prot2_r )
+READ16_MEMBER(igs011_state::dbc_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b9 = !b1 | (!b0 & b2)
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = (BIT(x,1)^1) | ((BIT(x,0)^1) & BIT(x,2));
return (b9 << 9);
}
// ryukobou
-static READ16_HANDLER( ryukobou_igs011_prot2_r )
+READ16_MEMBER(igs011_state::ryukobou_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b9 = (!b1 | b2) & b0
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = ((BIT(x,1)^1) | BIT(x,2)) & BIT(x,0);
return (b9 << 9);
}
// lhb2
-static READ16_HANDLER( lhb2_igs011_prot2_r )
+READ16_MEMBER(igs011_state::lhb2_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// b3 = !b2 | !b1 | b0
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b3 = (BIT(x,2)^1) | (BIT(x,1)^1) | BIT(x,0);
return (b3 << 3);
}
// vbowl
-static READ16_HANDLER( vbowl_igs011_prot2_r )
+READ16_MEMBER(igs011_state::vbowl_igs011_prot2_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- UINT8 x = state->m_prot2;
+ UINT8 x = m_prot2;
UINT8 b9 = ((BIT(x,4)^1) & (BIT(x,3)^1)) | ((BIT(x,2) & BIT(x,1))^1) | ((BIT(x,4) | BIT(x,0))^1);
return (b9 << 9);
}
@@ -1194,112 +1226,103 @@ static READ16_HANDLER( vbowl_igs011_prot2_r )
***************************************************************************/
-static WRITE16_HANDLER( igs012_prot_reset_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_reset_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- state->m_igs012_prot = 0x00;
- state->m_igs012_prot_swap = 0x00;
+ m_igs012_prot = 0x00;
+ m_igs012_prot_swap = 0x00;
- state->m_igs012_prot_mode = 0;
+ m_igs012_prot_mode = 0;
}
/*
-static READ16_HANDLER( igs012_prot_fake_r )
+READ16_MEMBER(igs011_state::igs012_prot_fake_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
switch (offset)
{
- case 0: return state->m_igs012_prot;
- case 1: return state->m_igs012_prot_swap;
- case 2: return state->m_igs012_prot_mode;
+ case 0: return m_igs012_prot;
+ case 1: return m_igs012_prot_swap;
+ case 2: return m_igs012_prot_mode;
}
return 0;
}
*/
// Macro that checks whether the current mode and data byte written match the arguments
-#define MODE_AND_DATA(_MODE,_DATA) (state->m_igs012_prot_mode == (_MODE) && ( (ACCESSING_BITS_8_15 && (data & 0xff00) == ((_DATA)<<8)) || (ACCESSING_BITS_0_7 && ((data & 0x00ff) == (_DATA))) ) )
+#define MODE_AND_DATA(_MODE,_DATA) (m_igs012_prot_mode == (_MODE) && ( (ACCESSING_BITS_8_15 && (data & 0xff00) == ((_DATA)<<8)) || (ACCESSING_BITS_0_7 && ((data & 0x00ff) == (_DATA))) ) )
-static WRITE16_HANDLER( igs012_prot_mode_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_mode_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(0, 0xcc) || MODE_AND_DATA(1, 0xdd) )
{
- state->m_igs012_prot_mode = state->m_igs012_prot_mode ^ 1;
+ m_igs012_prot_mode = m_igs012_prot_mode ^ 1;
}
else
- logerror("%s: warning, unknown igs012_prot_mode_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_mode_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static WRITE16_HANDLER( igs012_prot_inc_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_inc_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(0, 0xff) )
{
- state->m_igs012_prot = (state->m_igs012_prot + 1) & 0x1f;
+ m_igs012_prot = (m_igs012_prot + 1) & 0x1f;
}
else
- logerror("%s: warning, unknown igs012_prot_inc_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_inc_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static WRITE16_HANDLER( igs012_prot_dec_inc_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_dec_inc_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(0, 0xaa) )
{
- state->m_igs012_prot = (state->m_igs012_prot - 1) & 0x1f;
+ m_igs012_prot = (m_igs012_prot - 1) & 0x1f;
}
else if ( MODE_AND_DATA(1, 0xfa) )
{
- state->m_igs012_prot = (state->m_igs012_prot + 1) & 0x1f;
+ m_igs012_prot = (m_igs012_prot + 1) & 0x1f;
}
else
- logerror("%s: warning, unknown igs012_prot_dec_inc_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_dec_inc_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static WRITE16_HANDLER( igs012_prot_dec_copy_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_dec_copy_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(0, 0x33) )
{
- state->m_igs012_prot = state->m_igs012_prot_swap;
+ m_igs012_prot = m_igs012_prot_swap;
}
else if ( MODE_AND_DATA(1, 0x5a) )
{
- state->m_igs012_prot = (state->m_igs012_prot - 1) & 0x1f;
+ m_igs012_prot = (m_igs012_prot - 1) & 0x1f;
}
else
- logerror("%s: warning, unknown igs012_prot_dec_copy_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_dec_copy_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static WRITE16_HANDLER( igs012_prot_copy_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_copy_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(1, 0x22) )
{
- state->m_igs012_prot = state->m_igs012_prot_swap;
+ m_igs012_prot = m_igs012_prot_swap;
}
else
- logerror("%s: warning, unknown igs012_prot_copy_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_copy_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static WRITE16_HANDLER( igs012_prot_swap_w )
+WRITE16_MEMBER(igs011_state::igs012_prot_swap_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if ( MODE_AND_DATA(0, 0x55) || MODE_AND_DATA(1, 0xa5) )
{
// !(3 | 1)..(2 & 1)..(3 ^ 0)..(!2)
- UINT8 x = state->m_igs012_prot;
- state->m_igs012_prot_swap = (((BIT(x,3)|BIT(x,1))^1)<<3) | ((BIT(x,2)&BIT(x,1))<<2) | ((BIT(x,3)^BIT(x,0))<<1) | (BIT(x,2)^1);
+ UINT8 x = m_igs012_prot;
+ m_igs012_prot_swap = (((BIT(x,3)|BIT(x,1))^1)<<3) | ((BIT(x,2)&BIT(x,1))<<2) | ((BIT(x,3)^BIT(x,0))<<1) | (BIT(x,2)^1);
}
else
- logerror("%s: warning, unknown igs012_prot_swap_w( %04x, %04x ), mode %x\n", space->machine().describe_context(), offset, data, state->m_igs012_prot_mode);
+ logerror("%s: warning, unknown igs012_prot_swap_w( %04x, %04x ), mode %x\n", machine().describe_context(), offset, data, m_igs012_prot_mode);
}
-static READ16_HANDLER( igs012_prot_r )
+READ16_MEMBER(igs011_state::igs012_prot_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
// FIXME: mode 0 and mode 1 are mapped to different memory ranges
- UINT8 x = state->m_igs012_prot;
+ UINT8 x = m_igs012_prot;
UINT8 b1 = (BIT(x,3) | BIT(x,1))^1;
UINT8 b0 = BIT(x,3) ^ BIT(x,0);
@@ -1314,23 +1337,22 @@ static READ16_HANDLER( igs012_prot_r )
***************************************************************************/
-static WRITE16_HANDLER( drgnwrld_igs003_w )
+WRITE16_MEMBER(igs011_state::drgnwrld_igs003_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs003_reg[offset]);
+ COMBINE_DATA(&m_igs003_reg[offset]);
if (offset == 0)
return;
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x00:
if (ACCESSING_BITS_0_7)
- coin_counter_w(space->machine(), 0,data & 2);
+ coin_counter_w(machine(), 0,data & 2);
if (data & ~0x2)
- logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space->device()), data);
+ logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space.device()), data);
break;
@@ -1342,18 +1364,17 @@ static WRITE16_HANDLER( drgnwrld_igs003_w )
// case 0x05:
default:
-// popmessage("igs003 %x <- %04x",state->m_igs003_reg[0],data);
- logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0], data);
+// popmessage("igs003 %x <- %04x",m_igs003_reg[0],data);
+ logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0], data);
}
}
-static READ16_HANDLER( drgnwrld_igs003_r )
+READ16_MEMBER(igs011_state::drgnwrld_igs003_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
- case 0x00: return input_port_read(space->machine(), "IN0");
- case 0x01: return input_port_read(space->machine(), "IN1");
- case 0x02: return input_port_read(space->machine(), "IN2");
+ case 0x00: return input_port_read(machine(), "IN0");
+ case 0x01: return input_port_read(machine(), "IN1");
+ case 0x02: return input_port_read(machine(), "IN2");
case 0x20: return 0x49;
case 0x21: return 0x47;
@@ -1378,7 +1399,7 @@ static READ16_HANDLER( drgnwrld_igs003_r )
case 0x34: return 0x32;
default:
- logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0]);
+ logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0]);
}
return 0;
@@ -1386,38 +1407,36 @@ static READ16_HANDLER( drgnwrld_igs003_r )
-static WRITE16_HANDLER( lhb_inputs_w )
+WRITE16_MEMBER(igs011_state::lhb_inputs_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs_input_sel);
+ COMBINE_DATA(&m_igs_input_sel);
if (ACCESSING_BITS_0_7)
{
- coin_counter_w(space->machine(), 0, data & 0x20 );
+ coin_counter_w(machine(), 0, data & 0x20 );
// coin out data & 0x40
- state->m_igs_hopper = data & 0x80;
+ m_igs_hopper = data & 0x80;
}
- if ( state->m_igs_input_sel & (~0xff) )
- logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space->device()), state->m_igs_input_sel);
+ if ( m_igs_input_sel & (~0xff) )
+ logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space.device()), m_igs_input_sel);
-// popmessage("sel2 %02x",state->m_igs_input_sel&~0x1f);
+// popmessage("sel2 %02x",m_igs_input_sel&~0x1f);
}
-static READ16_HANDLER( lhb_inputs_r )
+READ16_MEMBER(igs011_state::lhb_inputs_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
switch(offset)
{
- case 0: return state->m_igs_input_sel;
+ case 0: return m_igs_input_sel;
case 1:
- if (~state->m_igs_input_sel & 0x01) return input_port_read(space->machine(), "KEY0");
- if (~state->m_igs_input_sel & 0x02) return input_port_read(space->machine(), "KEY1");
- if (~state->m_igs_input_sel & 0x04) return input_port_read(space->machine(), "KEY2");
- if (~state->m_igs_input_sel & 0x08) return input_port_read(space->machine(), "KEY3");
- if (~state->m_igs_input_sel & 0x10) return input_port_read(space->machine(), "KEY4");
+ if (~m_igs_input_sel & 0x01) return input_port_read(machine(), "KEY0");
+ if (~m_igs_input_sel & 0x02) return input_port_read(machine(), "KEY1");
+ if (~m_igs_input_sel & 0x04) return input_port_read(machine(), "KEY2");
+ if (~m_igs_input_sel & 0x08) return input_port_read(machine(), "KEY3");
+ if (~m_igs_input_sel & 0x10) return input_port_read(machine(), "KEY4");
- logerror("%06x: warning, reading with igs_input_sel = %02x\n", cpu_get_pc(&space->device()), state->m_igs_input_sel);
+ logerror("%06x: warning, reading with igs_input_sel = %02x\n", cpu_get_pc(&space.device()), m_igs_input_sel);
break;
}
return 0;
@@ -1425,65 +1444,63 @@ static READ16_HANDLER( lhb_inputs_r )
-static WRITE16_HANDLER( lhb2_igs003_w )
+WRITE16_MEMBER(igs011_state::lhb2_igs003_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs003_reg[offset]);
+ COMBINE_DATA(&m_igs003_reg[offset]);
if (offset == 0)
return;
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x00:
- COMBINE_DATA(&state->m_igs_input_sel);
+ COMBINE_DATA(&m_igs_input_sel);
if (ACCESSING_BITS_0_7)
{
- coin_counter_w(space->machine(), 0, data & 0x20);
+ coin_counter_w(machine(), 0, data & 0x20);
// coin out data & 0x40
- state->m_igs_hopper = data & 0x80;
+ m_igs_hopper = data & 0x80;
}
- if ( state->m_igs_input_sel & ~0x7f )
- logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space->device()), state->m_igs_input_sel);
+ if ( m_igs_input_sel & ~0x7f )
+ logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space.device()), m_igs_input_sel);
-// popmessage("sel2 %02x",state->m_igs_input_sel&~0x1f);
+// popmessage("sel2 %02x",m_igs_input_sel&~0x1f);
break;
case 0x02:
if (ACCESSING_BITS_0_7)
{
- state->m_lhb2_pen_hi = data & 0x07;
+ m_lhb2_pen_hi = data & 0x07;
- okim6295_device *oki = space->machine().device<okim6295_device>("oki");
+ okim6295_device *oki = machine().device<okim6295_device>("oki");
oki->set_bank_base((data & 0x08) ? 0x40000 : 0);
}
- if ( state->m_lhb2_pen_hi & ~0xf )
- logerror("%06x: warning, unknown bits written in lhb2_pen_hi = %02x\n", cpu_get_pc(&space->device()), state->m_lhb2_pen_hi);
+ if ( m_lhb2_pen_hi & ~0xf )
+ logerror("%06x: warning, unknown bits written in lhb2_pen_hi = %02x\n", cpu_get_pc(&space.device()), m_lhb2_pen_hi);
-// popmessage("oki %02x",state->m_lhb2_pen_hi & 0x08);
+// popmessage("oki %02x",m_lhb2_pen_hi & 0x08);
break;
default:
- logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0], data);
+ logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0], data);
}
}
-static READ16_HANDLER( lhb2_igs003_r )
+READ16_MEMBER(igs011_state::lhb2_igs003_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x01:
- if (~state->m_igs_input_sel & 0x01) return input_port_read(space->machine(), "KEY0");
- if (~state->m_igs_input_sel & 0x02) return input_port_read(space->machine(), "KEY1");
- if (~state->m_igs_input_sel & 0x04) return input_port_read(space->machine(), "KEY2");
- if (~state->m_igs_input_sel & 0x08) return input_port_read(space->machine(), "KEY3");
- if (~state->m_igs_input_sel & 0x10) return input_port_read(space->machine(), "KEY4");
+ if (~m_igs_input_sel & 0x01) return input_port_read(machine(), "KEY0");
+ if (~m_igs_input_sel & 0x02) return input_port_read(machine(), "KEY1");
+ if (~m_igs_input_sel & 0x04) return input_port_read(machine(), "KEY2");
+ if (~m_igs_input_sel & 0x08) return input_port_read(machine(), "KEY3");
+ if (~m_igs_input_sel & 0x10) return input_port_read(machine(), "KEY4");
/* fall through */
default:
- logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0]);
+ logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0]);
break;
// case 0x03:
@@ -1521,43 +1538,41 @@ static READ16_HANDLER( lhb2_igs003_r )
-static WRITE16_HANDLER( wlcc_igs003_w )
+WRITE16_MEMBER(igs011_state::wlcc_igs003_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs003_reg[offset]);
+ COMBINE_DATA(&m_igs003_reg[offset]);
if (offset == 0)
return;
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x02:
if (ACCESSING_BITS_0_7)
{
- coin_counter_w(space->machine(), 0, data & 0x01);
+ coin_counter_w(machine(), 0, data & 0x01);
// coin out data & 0x02
- okim6295_device *oki = space->machine().device<okim6295_device>("oki");
+ okim6295_device *oki = machine().device<okim6295_device>("oki");
oki->set_bank_base((data & 0x10) ? 0x40000 : 0);
- state->m_igs_hopper = data & 0x20;
+ m_igs_hopper = data & 0x20;
}
if (data & ~0x33)
- logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space->device()), data);
+ logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space.device()), data);
// popmessage("coin %02x",data);
break;
default:
- logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0], data);
+ logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0], data);
}
}
-static READ16_HANDLER( wlcc_igs003_r )
+READ16_MEMBER(igs011_state::wlcc_igs003_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
- case 0x00: return input_port_read(space->machine(), "IN0");
+ case 0x00: return input_port_read(machine(), "IN0");
case 0x20: return 0x49;
case 0x21: return 0x47;
@@ -1582,7 +1597,7 @@ static READ16_HANDLER( wlcc_igs003_r )
case 0x34: return 0x32;
default:
- logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0]);
+ logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0]);
}
return 0;
@@ -1590,49 +1605,47 @@ static READ16_HANDLER( wlcc_igs003_r )
-static WRITE16_HANDLER( xymg_igs003_w )
+WRITE16_MEMBER(igs011_state::xymg_igs003_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs003_reg[offset]);
+ COMBINE_DATA(&m_igs003_reg[offset]);
if (offset == 0)
return;
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x01:
- COMBINE_DATA(&state->m_igs_input_sel);
+ COMBINE_DATA(&m_igs_input_sel);
if (ACCESSING_BITS_0_7)
{
- coin_counter_w(space->machine(), 0, data & 0x20);
+ coin_counter_w(machine(), 0, data & 0x20);
// coin out data & 0x40
- state->m_igs_hopper = data & 0x80;
+ m_igs_hopper = data & 0x80;
}
- if ( state->m_igs_input_sel & 0x40 )
- logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space->device()), state->m_igs_input_sel);
+ if ( m_igs_input_sel & 0x40 )
+ logerror("%06x: warning, unknown bits written in igs_input_sel = %02x\n", cpu_get_pc(&space.device()), m_igs_input_sel);
-// popmessage("sel2 %02x",state->m_igs_input_sel&~0x1f);
+// popmessage("sel2 %02x",m_igs_input_sel&~0x1f);
break;
default:
- logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0], data);
+ logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0], data);
}
}
-static READ16_HANDLER( xymg_igs003_r )
+READ16_MEMBER(igs011_state::xymg_igs003_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
- case 0x00: return input_port_read(space->machine(), "COIN");
+ case 0x00: return input_port_read(machine(), "COIN");
case 0x02:
- if (~state->m_igs_input_sel & 0x01) return input_port_read(space->machine(), "KEY0");
- if (~state->m_igs_input_sel & 0x02) return input_port_read(space->machine(), "KEY1");
- if (~state->m_igs_input_sel & 0x04) return input_port_read(space->machine(), "KEY2");
- if (~state->m_igs_input_sel & 0x08) return input_port_read(space->machine(), "KEY3");
- if (~state->m_igs_input_sel & 0x10) return input_port_read(space->machine(), "KEY4");
+ if (~m_igs_input_sel & 0x01) return input_port_read(machine(), "KEY0");
+ if (~m_igs_input_sel & 0x02) return input_port_read(machine(), "KEY1");
+ if (~m_igs_input_sel & 0x04) return input_port_read(machine(), "KEY2");
+ if (~m_igs_input_sel & 0x08) return input_port_read(machine(), "KEY3");
+ if (~m_igs_input_sel & 0x10) return input_port_read(machine(), "KEY4");
/* fall through */
case 0x20: return 0x49;
@@ -1658,7 +1671,7 @@ static READ16_HANDLER( xymg_igs003_r )
case 0x34: return 0x32;
default:
- logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0]);
+ logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0]);
break;
}
@@ -1667,40 +1680,38 @@ static READ16_HANDLER( xymg_igs003_r )
-static WRITE16_HANDLER( vbowl_igs003_w )
+WRITE16_MEMBER(igs011_state::vbowl_igs003_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA(&state->m_igs003_reg[offset]);
+ COMBINE_DATA(&m_igs003_reg[offset]);
if (offset == 0)
return;
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
case 0x02:
if (ACCESSING_BITS_0_7)
{
- coin_counter_w(space->machine(), 0, data & 1);
- coin_counter_w(space->machine(), 1, data & 2);
+ coin_counter_w(machine(), 0, data & 1);
+ coin_counter_w(machine(), 1, data & 2);
}
if (data & ~0x3)
- logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space->device()), data);
+ logerror("%06x: warning, unknown bits written in coin counter = %02x\n", cpu_get_pc(&space.device()), data);
break;
default:
-// popmessage("igs003 %x <- %04x",state->m_igs003_reg[0],data);
- logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0], data);
+// popmessage("igs003 %x <- %04x",m_igs003_reg[0],data);
+ logerror("%06x: warning, writing to igs003_reg %02x = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0], data);
}
}
-static READ16_HANDLER( vbowl_igs003_r )
+READ16_MEMBER(igs011_state::vbowl_igs003_r)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- switch(state->m_igs003_reg[0])
+ switch(m_igs003_reg[0])
{
- case 0x00: return input_port_read(space->machine(), "IN0");
- case 0x01: return input_port_read(space->machine(), "IN1");
+ case 0x00: return input_port_read(machine(), "IN0");
+ case 0x01: return input_port_read(machine(), "IN1");
// case 0x03:
// return 0xff; // parametric bitswaps?
@@ -1728,7 +1739,7 @@ static READ16_HANDLER( vbowl_igs003_r )
case 0x34: return 0x32;
default:
- logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space->device()), state->m_igs003_reg[0]);
+ logerror("%06x: warning, reading with igs003_reg = %02x\n", cpu_get_pc(&space.device()), m_igs003_reg[0]);
}
return 0;
@@ -1800,8 +1811,8 @@ static DRIVER_INIT( drgnwrldv21 )
drgnwrld_type2_decrypt(machine);
drgnwrld_gfx_decrypt(machine);
-
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd4c0, 0xd4ff, FUNC(drgnwrldv21_igs011_prot2_r));
+ igs011_state *state = machine.driver_data<igs011_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xd4c0, 0xd4ff, read16_delegate(FUNC(igs011_state::drgnwrldv21_igs011_prot2_r), state));
/*
// PROTECTION CHECKS
// bp 32ee; bp 11ca8; bp 23d5e; bp 23fd0; bp 24170; bp 24348; bp 2454e; bp 246cc; bp 24922; bp 24b66; bp 24de2; bp 2502a; bp 25556; bp 269de; bp 2766a; bp 2a830
@@ -1941,7 +1952,8 @@ static DRIVER_INIT( dbc )
dbc_decrypt(machine);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(dbc_igs011_prot2_r));
+ igs011_state *state = machine.driver_data<igs011_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x10600, 0x107ff, read16_delegate(FUNC(igs011_state::dbc_igs011_prot2_r), state));
/*
// PROTECTION CHECKS
rom[0x04c42/2] = 0x602e; // 004C42: 6604 bne 4c48 (rom test error otherwise)
@@ -1970,7 +1982,8 @@ static DRIVER_INIT( ryukobou )
ryukobou_decrypt(machine);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(ryukobou_igs011_prot2_r));
+ igs011_state *state = machine.driver_data<igs011_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x10600, 0x107ff, read16_delegate(FUNC(igs011_state::ryukobou_igs011_prot2_r), state));
// PROTECTION CHECKS
// rom[0x2df68/2] = 0x4e75; // 02DF68: 4E56 FE00 link A6, #-$200 (fills palette with pink otherwise)
@@ -2120,56 +2133,56 @@ static DRIVER_INIT( nkishusp )
static ADDRESS_MAP_START( drgnwrld, AS_PROGRAM, 16, igs011_state )
// drgnwrld: IGS011 protection dynamically mapped at 1dd7x
-// AM_RANGE( 0x01dd70, 0x01dd77 ) AM_WRITE_LEGACY(igs011_prot1_w )
+// AM_RANGE( 0x01dd70, 0x01dd77 ) AM_WRITE(igs011_prot1_w )
// AM_RANGE( 0x01dd78, 0x01dd79 ) AM_READ ( igs011_prot1_r )
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM AM_SHARE("nvram")
AM_RANGE( 0x200000, 0x200fff ) AM_RAM AM_BASE(m_priority_ram )
- AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x500000, 0x500001 ) AM_READ_PORT( "COIN" )
AM_RANGE( 0x600000, 0x600001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
AM_RANGE( 0x700000, 0x700003 ) AM_DEVWRITE8_LEGACY("ymsnd", ym3812_w, 0x00ff )
- AM_RANGE( 0x800000, 0x800003 ) AM_WRITE_LEGACY(drgnwrld_igs003_w )
- AM_RANGE( 0x800002, 0x800003 ) AM_READ_LEGACY(drgnwrld_igs003_r )
-
- AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
- AM_RANGE( 0xa88000, 0xa88001 ) AM_READ_LEGACY(igs_3_dips_r )
+ AM_RANGE( 0x800000, 0x800003 ) AM_WRITE(drgnwrld_igs003_w )
+ AM_RANGE( 0x800002, 0x800003 ) AM_READ(drgnwrld_igs003_r )
+
+ AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ(igs011_prot_fake_r )
+
+ AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE(igs011_blit_depth_w )
+ AM_RANGE( 0xa88000, 0xa88001 ) AM_READ(igs_3_dips_r )
ADDRESS_MAP_END
static ADDRESS_MAP_START( drgnwrld_igs012, AS_PROGRAM, 16, igs011_state )
// IGS012
- AM_RANGE( 0x001600, 0x00160f ) AM_WRITE_LEGACY(igs012_prot_swap_w ) AM_MIRROR(0x01c000) // swap (a5 / 55)
- AM_RANGE( 0x001610, 0x00161f ) AM_READ_LEGACY(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 0)
- AM_RANGE( 0x001620, 0x00162f ) AM_WRITE_LEGACY(igs012_prot_dec_inc_w ) AM_MIRROR(0x01c000) // dec (aa), inc (fa)
- AM_RANGE( 0x001630, 0x00163f ) AM_WRITE_LEGACY(igs012_prot_inc_w ) AM_MIRROR(0x01c000) // inc (ff)
- AM_RANGE( 0x001640, 0x00164f ) AM_WRITE_LEGACY(igs012_prot_copy_w ) AM_MIRROR(0x01c000) // copy (22)
- AM_RANGE( 0x001650, 0x00165f ) AM_WRITE_LEGACY(igs012_prot_dec_copy_w ) AM_MIRROR(0x01c000) // dec (5a), copy (33)
- AM_RANGE( 0x001660, 0x00166f ) AM_READ_LEGACY(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 1)
- AM_RANGE( 0x001670, 0x00167f ) AM_WRITE_LEGACY(igs012_prot_mode_w ) AM_MIRROR(0x01c000) // mode (cc / dd)
-
- AM_RANGE( 0x00d400, 0x00d43f ) AM_WRITE_LEGACY(igs011_prot2_dec_w ) // dec (33)
- AM_RANGE( 0x00d440, 0x00d47f ) AM_WRITE_LEGACY(drgnwrld_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x00d480, 0x00d4bf ) AM_WRITE_LEGACY(igs011_prot2_reset_w ) // reset (33)
- AM_RANGE( 0x00d4c0, 0x00d4ff ) AM_READ_LEGACY(drgnwrldv20j_igs011_prot2_r ) // read
-
- AM_RANGE( 0x902000, 0x902fff ) AM_WRITE_LEGACY(igs012_prot_reset_w ) // reset?
-// AM_RANGE( 0x902000, 0x902005 ) AM_WRITE_LEGACY(igs012_prot_fake_r )
+ AM_RANGE( 0x001600, 0x00160f ) AM_WRITE(igs012_prot_swap_w ) AM_MIRROR(0x01c000) // swap (a5 / 55)
+ AM_RANGE( 0x001610, 0x00161f ) AM_READ(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 0)
+ AM_RANGE( 0x001620, 0x00162f ) AM_WRITE(igs012_prot_dec_inc_w ) AM_MIRROR(0x01c000) // dec (aa), inc (fa)
+ AM_RANGE( 0x001630, 0x00163f ) AM_WRITE(igs012_prot_inc_w ) AM_MIRROR(0x01c000) // inc (ff)
+ AM_RANGE( 0x001640, 0x00164f ) AM_WRITE(igs012_prot_copy_w ) AM_MIRROR(0x01c000) // copy (22)
+ AM_RANGE( 0x001650, 0x00165f ) AM_WRITE(igs012_prot_dec_copy_w ) AM_MIRROR(0x01c000) // dec (5a), copy (33)
+ AM_RANGE( 0x001660, 0x00166f ) AM_READ(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 1)
+ AM_RANGE( 0x001670, 0x00167f ) AM_WRITE(igs012_prot_mode_w ) AM_MIRROR(0x01c000) // mode (cc / dd)
+
+ AM_RANGE( 0x00d400, 0x00d43f ) AM_WRITE(igs011_prot2_dec_w ) // dec (33)
+ AM_RANGE( 0x00d440, 0x00d47f ) AM_WRITE(drgnwrld_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x00d480, 0x00d4bf ) AM_WRITE(igs011_prot2_reset_w ) // reset (33)
+ AM_RANGE( 0x00d4c0, 0x00d4ff ) AM_READ(drgnwrldv20j_igs011_prot2_r ) // read
+
+ AM_RANGE( 0x902000, 0x902fff ) AM_WRITE(igs012_prot_reset_w ) // reset?
+// AM_RANGE( 0x902000, 0x902005 ) AM_WRITE(igs012_prot_fake_r )
AM_IMPORT_FROM(drgnwrld)
ADDRESS_MAP_END
@@ -2177,10 +2190,9 @@ ADDRESS_MAP_END
// Only values 0 and 7 are written (1 bit per irq source?)
-static WRITE16_HANDLER( lhb_irq_enable_w )
+WRITE16_MEMBER(igs011_state::lhb_irq_enable_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
- COMBINE_DATA( &state->m_lhb_irq_enable );
+ COMBINE_DATA( &m_lhb_irq_enable );
}
static WRITE16_DEVICE_HANDLER( lhb_okibank_w )
@@ -2199,158 +2211,158 @@ static WRITE16_DEVICE_HANDLER( lhb_okibank_w )
static ADDRESS_MAP_START( lhb, AS_PROGRAM, 16, igs011_state )
// lhb: IGS011 protection dynamically mapped at 834x
-// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE_LEGACY(igs011_prot1_w )
+// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE(igs011_prot1_w )
// AM_RANGE( 0x008348, 0x008349 ) AM_READ ( igs011_prot1_r )
AM_RANGE( 0x010000, 0x010001 ) AM_DEVWRITE_LEGACY("oki", lhb_okibank_w )
- AM_RANGE( 0x010200, 0x0103ff ) AM_WRITE_LEGACY(igs011_prot2_inc_w )
- AM_RANGE( 0x010400, 0x0105ff ) AM_WRITE_LEGACY(lhb_igs011_prot2_swap_w )
- AM_RANGE( 0x010600, 0x0107ff ) AM_READ_LEGACY(lhb_igs011_prot2_r )
+ AM_RANGE( 0x010200, 0x0103ff ) AM_WRITE(igs011_prot2_inc_w )
+ AM_RANGE( 0x010400, 0x0105ff ) AM_WRITE(lhb_igs011_prot2_swap_w )
+ AM_RANGE( 0x010600, 0x0107ff ) AM_READ(lhb_igs011_prot2_r )
// no reset
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM AM_SHARE("nvram")
AM_RANGE( 0x200000, 0x200fff ) AM_RAM AM_BASE(m_priority_ram )
- AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE_LEGACY(igs011_layers_r, igs011_layers_w )
- AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE(igs011_layers_r, igs011_layers_w )
+ AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x600000, 0x600001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
AM_RANGE( 0x700000, 0x700001 ) AM_READ_PORT( "COIN" )
- AM_RANGE( 0x700002, 0x700005 ) AM_READ_LEGACY(lhb_inputs_r )
- AM_RANGE( 0x700002, 0x700003 ) AM_WRITE_LEGACY(lhb_inputs_w )
- AM_RANGE( 0x820000, 0x820001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0x838000, 0x838001 ) AM_WRITE_LEGACY(lhb_irq_enable_w )
- AM_RANGE( 0x840000, 0x840001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0x850000, 0x850001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0x850000, 0x850005 ) AM_WRITE_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0x858000, 0x858001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0x858800, 0x858801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0x859000, 0x859001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0x859800, 0x859801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0x85a000, 0x85a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0x85a800, 0x85a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0x85b000, 0x85b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0x85b800, 0x85b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0x85c000, 0x85c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
- AM_RANGE( 0x888000, 0x888001 ) AM_READ_LEGACY(igs_5_dips_r )
+ AM_RANGE( 0x700002, 0x700005 ) AM_READ(lhb_inputs_r )
+ AM_RANGE( 0x700002, 0x700003 ) AM_WRITE(lhb_inputs_w )
+ AM_RANGE( 0x820000, 0x820001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0x838000, 0x838001 ) AM_WRITE(lhb_irq_enable_w )
+ AM_RANGE( 0x840000, 0x840001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0x850000, 0x850001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0x850000, 0x850005 ) AM_WRITE(igs011_prot_fake_r )
+
+ AM_RANGE( 0x858000, 0x858001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0x858800, 0x858801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0x859000, 0x859001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0x859800, 0x859801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0x85a000, 0x85a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0x85a800, 0x85a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0x85b000, 0x85b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0x85b800, 0x85b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0x85c000, 0x85c001 ) AM_WRITE(igs011_blit_depth_w )
+ AM_RANGE( 0x888000, 0x888001 ) AM_READ(igs_5_dips_r )
ADDRESS_MAP_END
static ADDRESS_MAP_START( xymg, AS_PROGRAM, 16, igs011_state )
// xymg: IGS011 protection dynamically mapped at 834x
-// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE_LEGACY(igs011_prot1_w )
+// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE(igs011_prot1_w )
// AM_RANGE( 0x008348, 0x008349 ) AM_READ ( igs011_prot1_r )
AM_RANGE( 0x010000, 0x010001 ) AM_DEVWRITE_LEGACY("oki", lhb_okibank_w )
- AM_RANGE( 0x010200, 0x0103ff ) AM_WRITE_LEGACY(igs011_prot2_inc_w ) // inc (33)
- AM_RANGE( 0x010400, 0x0105ff ) AM_WRITE_LEGACY(lhb_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x010600, 0x0107ff ) AM_READ_LEGACY(lhb_igs011_prot2_r ) // read
+ AM_RANGE( 0x010200, 0x0103ff ) AM_WRITE(igs011_prot2_inc_w ) // inc (33)
+ AM_RANGE( 0x010400, 0x0105ff ) AM_WRITE(lhb_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x010600, 0x0107ff ) AM_READ(lhb_igs011_prot2_r ) // read
// no reset
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM
AM_RANGE( 0x1f0000, 0x1f3fff ) AM_RAM AM_SHARE("nvram") // extra ram
AM_RANGE( 0x200000, 0x200fff ) AM_RAM AM_BASE(m_priority_ram )
- AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE_LEGACY(igs011_layers_r, igs011_layers_w )
- AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE(igs011_layers_r, igs011_layers_w )
+ AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x600000, 0x600001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
- AM_RANGE( 0x700000, 0x700003 ) AM_WRITE_LEGACY(xymg_igs003_w )
- AM_RANGE( 0x700002, 0x700003 ) AM_READ_LEGACY(xymg_igs003_r )
- AM_RANGE( 0x820000, 0x820001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0x840000, 0x840001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0x850000, 0x850001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0x850000, 0x850005 ) AM_WRITE_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0x858000, 0x858001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0x858800, 0x858801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0x859000, 0x859001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0x859800, 0x859801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0x85a000, 0x85a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0x85a800, 0x85a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0x85b000, 0x85b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0x85b800, 0x85b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0x85c000, 0x85c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
- AM_RANGE( 0x888000, 0x888001 ) AM_READ_LEGACY(igs_3_dips_r )
+ AM_RANGE( 0x700000, 0x700003 ) AM_WRITE(xymg_igs003_w )
+ AM_RANGE( 0x700002, 0x700003 ) AM_READ(xymg_igs003_r )
+ AM_RANGE( 0x820000, 0x820001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0x840000, 0x840001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0x850000, 0x850001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0x850000, 0x850005 ) AM_WRITE(igs011_prot_fake_r )
+
+ AM_RANGE( 0x858000, 0x858001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0x858800, 0x858801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0x859000, 0x859001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0x859800, 0x859801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0x85a000, 0x85a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0x85a800, 0x85a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0x85b000, 0x85b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0x85b800, 0x85b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0x85c000, 0x85c001 ) AM_WRITE(igs011_blit_depth_w )
+ AM_RANGE( 0x888000, 0x888001 ) AM_READ(igs_3_dips_r )
ADDRESS_MAP_END
static ADDRESS_MAP_START( wlcc, AS_PROGRAM, 16, igs011_state )
// wlcc: IGS011 protection dynamically mapped at 834x
-// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE_LEGACY(igs011_prot1_w )
-// AM_RANGE( 0x008348, 0x008349 ) AM_READ_LEGACY(igs011_prot1_r )
+// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE(igs011_prot1_w )
+// AM_RANGE( 0x008348, 0x008349 ) AM_READ(igs011_prot1_r )
- AM_RANGE( 0x518000, 0x5181ff ) AM_WRITE_LEGACY(igs011_prot2_inc_w ) // inc (33)
- AM_RANGE( 0x518200, 0x5183ff ) AM_WRITE_LEGACY(wlcc_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x518800, 0x5189ff ) AM_READ_LEGACY(igs011_prot2_reset_r ) // reset
- AM_RANGE( 0x519000, 0x5195ff ) AM_READ_LEGACY(lhb_igs011_prot2_r ) // read
+ AM_RANGE( 0x518000, 0x5181ff ) AM_WRITE(igs011_prot2_inc_w ) // inc (33)
+ AM_RANGE( 0x518200, 0x5183ff ) AM_WRITE(wlcc_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x518800, 0x5189ff ) AM_READ(igs011_prot2_reset_r ) // reset
+ AM_RANGE( 0x519000, 0x5195ff ) AM_READ(lhb_igs011_prot2_r ) // read
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM AM_SHARE("nvram")
AM_RANGE( 0x200000, 0x200fff ) AM_RAM AM_BASE(m_priority_ram )
- AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE_LEGACY(igs011_layers_r, igs011_layers_w )
- AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE(igs011_layers_r, igs011_layers_w )
+ AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x520000, 0x520001 ) AM_READ_PORT( "COIN" )
AM_RANGE( 0x600000, 0x600001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
- AM_RANGE( 0x800000, 0x800003 ) AM_WRITE_LEGACY(wlcc_igs003_w )
- AM_RANGE( 0x800002, 0x800003 ) AM_READ_LEGACY(wlcc_igs003_r )
- AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
- AM_RANGE( 0xa88000, 0xa88001 ) AM_READ_LEGACY(igs_4_dips_r )
+ AM_RANGE( 0x800000, 0x800003 ) AM_WRITE(wlcc_igs003_w )
+ AM_RANGE( 0x800002, 0x800003 ) AM_READ(wlcc_igs003_r )
+ AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ(igs011_prot_fake_r )
+
+ AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE(igs011_blit_depth_w )
+ AM_RANGE( 0xa88000, 0xa88001 ) AM_READ(igs_4_dips_r )
ADDRESS_MAP_END
static ADDRESS_MAP_START( lhb2, AS_PROGRAM, 16, igs011_state )
// lhb2: IGS011 protection dynamically mapped at 1ff8x
-// AM_RANGE( 0x01ff80, 0x01ff87 ) AM_WRITE_LEGACY(igs011_prot1_w )
+// AM_RANGE( 0x01ff80, 0x01ff87 ) AM_WRITE(igs011_prot1_w )
// AM_RANGE( 0x01ff88, 0x01ff89 ) AM_READ ( igs011_prot1_r )
- AM_RANGE( 0x020000, 0x0201ff ) AM_WRITE_LEGACY(igs011_prot2_inc_w ) // inc (55)
- AM_RANGE( 0x020200, 0x0203ff ) AM_WRITE_LEGACY(lhb_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x020400, 0x0205ff ) AM_READ_LEGACY(lhb2_igs011_prot2_r ) // read
- AM_RANGE( 0x020600, 0x0207ff ) AM_WRITE_LEGACY(igs011_prot2_reset_w ) // reset (55)
+ AM_RANGE( 0x020000, 0x0201ff ) AM_WRITE(igs011_prot2_inc_w ) // inc (55)
+ AM_RANGE( 0x020200, 0x0203ff ) AM_WRITE(lhb_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x020400, 0x0205ff ) AM_READ(lhb2_igs011_prot2_r ) // read
+ AM_RANGE( 0x020600, 0x0207ff ) AM_WRITE(igs011_prot2_reset_w ) // reset (55)
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM AM_SHARE("nvram")
AM_RANGE( 0x200000, 0x200001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
AM_RANGE( 0x204000, 0x204003 ) AM_DEVWRITE8_LEGACY("ymsnd", ym2413_w, 0x00ff )
- AM_RANGE( 0x208000, 0x208003 ) AM_WRITE_LEGACY(lhb2_igs003_w )
- AM_RANGE( 0x208002, 0x208003 ) AM_READ_LEGACY(lhb2_igs003_r )
+ AM_RANGE( 0x208000, 0x208003 ) AM_WRITE(lhb2_igs003_w )
+ AM_RANGE( 0x208002, 0x208003 ) AM_READ(lhb2_igs003_r )
AM_RANGE( 0x20c000, 0x20cfff ) AM_RAM AM_BASE(m_priority_ram)
- AM_RANGE( 0x210000, 0x211fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x210000, 0x211fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x214000, 0x214001 ) AM_READ_PORT( "COIN" )
- AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE_LEGACY(igs011_layers_r, igs011_layers_w )
- AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
- AM_RANGE( 0xa88000, 0xa88001 ) AM_READ_LEGACY(igs_3_dips_r )
+ AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE(igs011_layers_r, igs011_layers_w )
+ AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0xa50000, 0xa50001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0xa50000, 0xa50005 ) AM_READ(igs011_prot_fake_r )
+
+ AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE(igs011_blit_depth_w )
+ AM_RANGE( 0xa88000, 0xa88001 ) AM_READ(igs_3_dips_r )
ADDRESS_MAP_END
/* trap15's note:
@@ -2383,7 +2395,7 @@ static WRITE16_DEVICE_HANDLER( ics2115_word_w )
}
}
-static READ16_HANDLER( vbowl_unk_r )
+READ16_MEMBER(igs011_state::vbowl_unk_r)
{
return 0xffff;
}
@@ -2399,88 +2411,87 @@ static SCREEN_VBLANK( vbowl )
}
}
-static WRITE16_HANDLER( vbowl_pen_hi_w )
+WRITE16_MEMBER(igs011_state::vbowl_pen_hi_w)
{
- igs011_state *state = space->machine().driver_data<igs011_state>();
if (ACCESSING_BITS_0_7)
{
- state->m_lhb2_pen_hi = data & 0x07;
+ m_lhb2_pen_hi = data & 0x07;
}
if (data & ~0x7)
- logerror("%06x: warning, unknown bits written to pen_hi = %04x\n", cpu_get_pc(&space->device()), state->m_priority);
+ logerror("%06x: warning, unknown bits written to pen_hi = %04x\n", cpu_get_pc(&space.device()), m_priority);
}
-static WRITE16_HANDLER( vbowl_link_0_w ) { }
-static WRITE16_HANDLER( vbowl_link_1_w ) { }
-static WRITE16_HANDLER( vbowl_link_2_w ) { }
-static WRITE16_HANDLER( vbowl_link_3_w ) { }
+WRITE16_MEMBER(igs011_state::vbowl_link_0_w){ }
+WRITE16_MEMBER(igs011_state::vbowl_link_1_w){ }
+WRITE16_MEMBER(igs011_state::vbowl_link_2_w){ }
+WRITE16_MEMBER(igs011_state::vbowl_link_3_w){ }
static ADDRESS_MAP_START( vbowl, AS_PROGRAM, 16, igs011_state )
// vbowl: IGS011 protection dynamically mapped at 834x
-// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE_LEGACY(igs011_prot1_w )
-// AM_RANGE( 0x008348, 0x008349 ) AM_READ_LEGACY(igs011_prot1_r )
+// AM_RANGE( 0x008340, 0x008347 ) AM_WRITE(igs011_prot1_w )
+// AM_RANGE( 0x008348, 0x008349 ) AM_READ(igs011_prot1_r )
// IGS012
- AM_RANGE( 0x001600, 0x00160f ) AM_WRITE_LEGACY(igs012_prot_swap_w ) AM_MIRROR(0x01c000) // swap (a5 / 55)
- AM_RANGE( 0x001610, 0x00161f ) AM_READ_LEGACY(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 0)
- AM_RANGE( 0x001620, 0x00162f ) AM_WRITE_LEGACY(igs012_prot_dec_inc_w ) AM_MIRROR(0x01c000) // dec (aa), inc (fa)
- AM_RANGE( 0x001630, 0x00163f ) AM_WRITE_LEGACY(igs012_prot_inc_w ) AM_MIRROR(0x01c000) // inc (ff)
- AM_RANGE( 0x001640, 0x00164f ) AM_WRITE_LEGACY(igs012_prot_copy_w ) AM_MIRROR(0x01c000) // copy (22)
- AM_RANGE( 0x001650, 0x00165f ) AM_WRITE_LEGACY(igs012_prot_dec_copy_w ) AM_MIRROR(0x01c000) // dec (5a), copy (33)
- AM_RANGE( 0x001660, 0x00166f ) AM_READ_LEGACY(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 1)
- AM_RANGE( 0x001670, 0x00167f ) AM_WRITE_LEGACY(igs012_prot_mode_w ) AM_MIRROR(0x01c000) // mode (cc / dd)
-
- AM_RANGE( 0x00d400, 0x00d43f ) AM_WRITE_LEGACY(igs011_prot2_dec_w ) // dec (33)
- AM_RANGE( 0x00d440, 0x00d47f ) AM_WRITE_LEGACY(drgnwrld_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x00d480, 0x00d4bf ) AM_WRITE_LEGACY(igs011_prot2_reset_w ) // reset (33)
- AM_RANGE( 0x00d4c0, 0x00d4ff ) AM_READ_LEGACY(drgnwrldv20j_igs011_prot2_r ) // read
-
- AM_RANGE( 0x50f000, 0x50f1ff ) AM_WRITE_LEGACY(igs011_prot2_dec_w ) // dec (33)
- AM_RANGE( 0x50f200, 0x50f3ff ) AM_WRITE_LEGACY(vbowl_igs011_prot2_swap_w ) // swap (33)
- AM_RANGE( 0x50f400, 0x50f5ff ) AM_WRITE_LEGACY(igs011_prot2_reset_w ) // reset (33)
- AM_RANGE( 0x50f600, 0x50f7ff ) AM_READ_LEGACY(vbowl_igs011_prot2_r ) // read
-
- AM_RANGE( 0x902000, 0x902fff ) AM_WRITE_LEGACY(igs012_prot_reset_w ) // reset?
-// AM_RANGE( 0x902000, 0x902005 ) AM_WRITE_LEGACY(igs012_prot_fake_r )
+ AM_RANGE( 0x001600, 0x00160f ) AM_WRITE(igs012_prot_swap_w ) AM_MIRROR(0x01c000) // swap (a5 / 55)
+ AM_RANGE( 0x001610, 0x00161f ) AM_READ(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 0)
+ AM_RANGE( 0x001620, 0x00162f ) AM_WRITE(igs012_prot_dec_inc_w ) AM_MIRROR(0x01c000) // dec (aa), inc (fa)
+ AM_RANGE( 0x001630, 0x00163f ) AM_WRITE(igs012_prot_inc_w ) AM_MIRROR(0x01c000) // inc (ff)
+ AM_RANGE( 0x001640, 0x00164f ) AM_WRITE(igs012_prot_copy_w ) AM_MIRROR(0x01c000) // copy (22)
+ AM_RANGE( 0x001650, 0x00165f ) AM_WRITE(igs012_prot_dec_copy_w ) AM_MIRROR(0x01c000) // dec (5a), copy (33)
+ AM_RANGE( 0x001660, 0x00166f ) AM_READ(igs012_prot_r ) AM_MIRROR(0x01c000) // read (mode 1)
+ AM_RANGE( 0x001670, 0x00167f ) AM_WRITE(igs012_prot_mode_w ) AM_MIRROR(0x01c000) // mode (cc / dd)
+
+ AM_RANGE( 0x00d400, 0x00d43f ) AM_WRITE(igs011_prot2_dec_w ) // dec (33)
+ AM_RANGE( 0x00d440, 0x00d47f ) AM_WRITE(drgnwrld_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x00d480, 0x00d4bf ) AM_WRITE(igs011_prot2_reset_w ) // reset (33)
+ AM_RANGE( 0x00d4c0, 0x00d4ff ) AM_READ(drgnwrldv20j_igs011_prot2_r ) // read
+
+ AM_RANGE( 0x50f000, 0x50f1ff ) AM_WRITE(igs011_prot2_dec_w ) // dec (33)
+ AM_RANGE( 0x50f200, 0x50f3ff ) AM_WRITE(vbowl_igs011_prot2_swap_w ) // swap (33)
+ AM_RANGE( 0x50f400, 0x50f5ff ) AM_WRITE(igs011_prot2_reset_w ) // reset (33)
+ AM_RANGE( 0x50f600, 0x50f7ff ) AM_READ(vbowl_igs011_prot2_r ) // read
+
+ AM_RANGE( 0x902000, 0x902fff ) AM_WRITE(igs012_prot_reset_w ) // reset?
+// AM_RANGE( 0x902000, 0x902005 ) AM_WRITE(igs012_prot_fake_r )
AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
AM_RANGE( 0x100000, 0x103fff ) AM_RAM AM_SHARE("nvram")
AM_RANGE( 0x200000, 0x200fff ) AM_RAM AM_BASE(m_priority_ram )
- AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE_LEGACY(igs011_layers_r, igs011_layers_w )
- AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE_LEGACY(igs011_palette ) AM_BASE_GENERIC( paletteram )
+ AM_RANGE( 0x300000, 0x3fffff ) AM_READWRITE(igs011_layers_r, igs011_layers_w )
+ AM_RANGE( 0x400000, 0x401fff ) AM_RAM_WRITE(igs011_palette ) AM_BASE_GENERIC( paletteram )
AM_RANGE( 0x520000, 0x520001 ) AM_READ_PORT( "COIN" )
AM_RANGE( 0x600000, 0x600007 ) AM_DEVREADWRITE_LEGACY("ics", ics2115_word_r, ics2115_word_w )
AM_RANGE( 0x700000, 0x700003 ) AM_RAM AM_BASE(m_vbowl_trackball )
- AM_RANGE( 0x700004, 0x700005 ) AM_WRITE_LEGACY(vbowl_pen_hi_w )
- AM_RANGE( 0x800000, 0x800003 ) AM_WRITE_LEGACY(vbowl_igs003_w )
- AM_RANGE( 0x800002, 0x800003 ) AM_READ_LEGACY(vbowl_igs003_r )
-
- AM_RANGE( 0xa00000, 0xa00001 ) AM_WRITE_LEGACY(vbowl_link_0_w )
- AM_RANGE( 0xa08000, 0xa08001 ) AM_WRITE_LEGACY(vbowl_link_1_w )
- AM_RANGE( 0xa10000, 0xa10001 ) AM_WRITE_LEGACY(vbowl_link_2_w )
- AM_RANGE( 0xa18000, 0xa18001 ) AM_WRITE_LEGACY(vbowl_link_3_w )
-
- AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE_LEGACY(igs011_priority_w )
- AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE_LEGACY(igs_dips_w )
-
- AM_RANGE( 0xa48000, 0xa48001 ) AM_WRITE_LEGACY(igs011_prot_addr_w )
-// AM_RANGE( 0xa48000, 0xa48005 ) AM_WRITE_LEGACY(igs011_prot_fake_r )
-
- AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE_LEGACY(igs011_blit_x_w )
- AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE_LEGACY(igs011_blit_y_w )
- AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE_LEGACY(igs011_blit_w_w )
- AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE_LEGACY(igs011_blit_h_w )
- AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE_LEGACY(igs011_blit_gfx_lo_w )
- AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE_LEGACY(igs011_blit_gfx_hi_w )
- AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE_LEGACY(igs011_blit_flags_w )
- AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE_LEGACY(igs011_blit_pen_w )
- AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE_LEGACY(igs011_blit_depth_w )
-
- AM_RANGE( 0xa80000, 0xa80001 ) AM_READ_LEGACY(vbowl_unk_r )
- AM_RANGE( 0xa88000, 0xa88001 ) AM_READ_LEGACY(igs_4_dips_r )
- AM_RANGE( 0xa90000, 0xa90001 ) AM_READ_LEGACY(vbowl_unk_r )
- AM_RANGE( 0xa98000, 0xa98001 ) AM_READ_LEGACY(vbowl_unk_r )
+ AM_RANGE( 0x700004, 0x700005 ) AM_WRITE(vbowl_pen_hi_w )
+ AM_RANGE( 0x800000, 0x800003 ) AM_WRITE(vbowl_igs003_w )
+ AM_RANGE( 0x800002, 0x800003 ) AM_READ(vbowl_igs003_r )
+
+ AM_RANGE( 0xa00000, 0xa00001 ) AM_WRITE(vbowl_link_0_w )
+ AM_RANGE( 0xa08000, 0xa08001 ) AM_WRITE(vbowl_link_1_w )
+ AM_RANGE( 0xa10000, 0xa10001 ) AM_WRITE(vbowl_link_2_w )
+ AM_RANGE( 0xa18000, 0xa18001 ) AM_WRITE(vbowl_link_3_w )
+
+ AM_RANGE( 0xa20000, 0xa20001 ) AM_WRITE(igs011_priority_w )
+ AM_RANGE( 0xa40000, 0xa40001 ) AM_WRITE(igs_dips_w )
+
+ AM_RANGE( 0xa48000, 0xa48001 ) AM_WRITE(igs011_prot_addr_w )
+// AM_RANGE( 0xa48000, 0xa48005 ) AM_WRITE(igs011_prot_fake_r )
+
+ AM_RANGE( 0xa58000, 0xa58001 ) AM_WRITE(igs011_blit_x_w )
+ AM_RANGE( 0xa58800, 0xa58801 ) AM_WRITE(igs011_blit_y_w )
+ AM_RANGE( 0xa59000, 0xa59001 ) AM_WRITE(igs011_blit_w_w )
+ AM_RANGE( 0xa59800, 0xa59801 ) AM_WRITE(igs011_blit_h_w )
+ AM_RANGE( 0xa5a000, 0xa5a001 ) AM_WRITE(igs011_blit_gfx_lo_w )
+ AM_RANGE( 0xa5a800, 0xa5a801 ) AM_WRITE(igs011_blit_gfx_hi_w )
+ AM_RANGE( 0xa5b000, 0xa5b001 ) AM_WRITE(igs011_blit_flags_w )
+ AM_RANGE( 0xa5b800, 0xa5b801 ) AM_WRITE(igs011_blit_pen_w )
+ AM_RANGE( 0xa5c000, 0xa5c001 ) AM_WRITE(igs011_blit_depth_w )
+
+ AM_RANGE( 0xa80000, 0xa80001 ) AM_READ(vbowl_unk_r )
+ AM_RANGE( 0xa88000, 0xa88001 ) AM_READ(igs_4_dips_r )
+ AM_RANGE( 0xa90000, 0xa90001 ) AM_READ(vbowl_unk_r )
+ AM_RANGE( 0xa98000, 0xa98001 ) AM_READ(vbowl_unk_r )
ADDRESS_MAP_END
diff --git a/src/mame/drivers/igspoker.c b/src/mame/drivers/igspoker.c
index 0b43e439629..b00a986e96b 100644
--- a/src/mame/drivers/igspoker.c
+++ b/src/mame/drivers/igspoker.c
@@ -91,6 +91,17 @@ public:
size_t m_protection_res;
required_device<cpu_device> m_maincpu;
+ DECLARE_READ8_MEMBER(igs_irqack_r);
+ DECLARE_WRITE8_MEMBER(igs_irqack_w);
+ DECLARE_WRITE8_MEMBER(bg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_color_w);
+ DECLARE_WRITE8_MEMBER(igs_nmi_and_coins_w);
+ DECLARE_WRITE8_MEMBER(igs_lamps_w);
+ DECLARE_READ8_MEMBER(custom_io_r);
+ DECLARE_WRITE8_MEMBER(custom_io_w);
+ DECLARE_READ8_MEMBER(exp_rom_r);
+ void show_out();
};
@@ -119,16 +130,15 @@ static TIMER_DEVICE_CALLBACK( igs_interrupt )
}
-static READ8_HANDLER( igs_irqack_r )
+READ8_MEMBER(igspoker_state::igs_irqack_r)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
- device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
+ device_set_input_line(m_maincpu, 0, CLEAR_LINE);
return 0;
}
-static WRITE8_HANDLER( igs_irqack_w )
+WRITE8_MEMBER(igspoker_state::igs_irqack_w)
{
-// cputag_set_input_line(space->machine(), "maincpu", 0, CLEAR_LINE);
+// cputag_set_input_line(machine(), "maincpu", 0, CLEAR_LINE);
}
@@ -147,25 +157,22 @@ static TILE_GET_INFO( get_fg_tile_info )
SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
}
-static WRITE8_HANDLER( bg_tile_w )
+WRITE8_MEMBER(igspoker_state::bg_tile_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
- state->m_bg_tile_ram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_bg_tile_ram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( fg_tile_w )
+WRITE8_MEMBER(igspoker_state::fg_tile_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
- state->m_fg_tile_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_tile_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( fg_color_w )
+WRITE8_MEMBER(igspoker_state::fg_color_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
- state->m_fg_color_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_color_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(igs_video)
@@ -205,35 +212,33 @@ static SCREEN_UPDATE_IND16(cpokerpk)
}
-static void show_out(igspoker_state *state)
+void igspoker_state::show_out()
{
#ifdef MAME_DEBUG
- popmessage("%02x %02x", state->m_out[0], state->m_out[1]);
+ popmessage("%02x %02x", m_out[0], m_out[1]);
#endif
}
-static WRITE8_HANDLER( igs_nmi_and_coins_w )
+WRITE8_MEMBER(igspoker_state::igs_nmi_and_coins_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
- coin_counter_w(space->machine(), 0, data & 0x01); // coin_a
- coin_counter_w(space->machine(), 1, data & 0x04); // coin_c
- coin_counter_w(space->machine(), 2, data & 0x08); // key in
- coin_counter_w(space->machine(), 3, data & 0x10); // coin state->m_out mech
+ coin_counter_w(machine(), 0, data & 0x01); // coin_a
+ coin_counter_w(machine(), 1, data & 0x04); // coin_c
+ coin_counter_w(machine(), 2, data & 0x08); // key in
+ coin_counter_w(machine(), 3, data & 0x10); // coin m_out mech
- set_led_status(space->machine(), 6, data & 0x20); // led for coin state->m_out / state->m_hopper active
+ set_led_status(machine(), 6, data & 0x20); // led for coin m_out / m_hopper active
- state->m_nmi_enable = data & 0x80; // nmi enable?
+ m_nmi_enable = data & 0x80; // nmi enable?
#ifdef VERBOSE
- logerror("PC %06X: NMI change %02x\n",cpu_get_pc(&space->device()),state->m_nmi_enable);
+ logerror("PC %06X: NMI change %02x\n",cpu_get_pc(&space.device()),m_nmi_enable);
#endif
- state->m_out[0] = data;
- show_out(state);
+ m_out[0] = data;
+ show_out();
}
-static WRITE8_HANDLER( igs_lamps_w )
+WRITE8_MEMBER(igspoker_state::igs_lamps_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
/*
- Lbits -
7654 3210
@@ -266,66 +271,64 @@ static WRITE8_HANDLER( igs_lamps_w )
output_set_lamp_value(5, (data >> 2) & 1); /* Lamp 5 - HOLD 5 */
output_set_lamp_value(6, (data & 1)); /* Lamp 6 - START */
- state->m_hopper = (~data)& 0x80;
+ m_hopper = (~data)& 0x80;
- state->m_out[1] = data;
- show_out(state);
+ m_out[1] = data;
+ show_out();
}
-static READ8_HANDLER( custom_io_r )
+READ8_MEMBER(igspoker_state::custom_io_r)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
#ifdef VERBOSE
- logerror("PC %06X: Protection read %02x\n",cpu_get_pc(&space->device()), (int) state->m_protection_res);
+ logerror("PC %06X: Protection read %02x\n",cpu_get_pc(&space.device()), (int) m_protection_res);
#endif
- return state->m_protection_res;
+ return m_protection_res;
}
-static WRITE8_HANDLER( custom_io_w )
+WRITE8_MEMBER(igspoker_state::custom_io_w)
{
- igspoker_state *state = space->machine().driver_data<igspoker_state>();
#ifdef VERBOSE
- logerror("PC %06X: Protection write %02x\n",cpu_get_pc(&space->device()),data);
+ logerror("PC %06X: Protection write %02x\n",cpu_get_pc(&space.device()),data);
#endif
switch (data)
{
- case 0x00: state->m_protection_res = input_port_read(space->machine(), "BUTTONS1"); break;
+ case 0x00: m_protection_res = input_port_read(machine(), "BUTTONS1"); break;
// CSK227
- case 0x20: state->m_protection_res = 0x49; break;
- case 0x21: state->m_protection_res = 0x47; break;
- case 0x22: state->m_protection_res = 0x53; break;
- case 0x24: state->m_protection_res = 0x41; break;
- case 0x25: state->m_protection_res = 0x41; break;
- case 0x26: state->m_protection_res = 0x7f; break;
- case 0x27: state->m_protection_res = 0x41; break;
- case 0x28: state->m_protection_res = 0x41; break;
- case 0x2a: state->m_protection_res = 0x3e; break;
- case 0x2b: state->m_protection_res = 0x41; break;
+ case 0x20: m_protection_res = 0x49; break;
+ case 0x21: m_protection_res = 0x47; break;
+ case 0x22: m_protection_res = 0x53; break;
+ case 0x24: m_protection_res = 0x41; break;
+ case 0x25: m_protection_res = 0x41; break;
+ case 0x26: m_protection_res = 0x7f; break;
+ case 0x27: m_protection_res = 0x41; break;
+ case 0x28: m_protection_res = 0x41; break;
+ case 0x2a: m_protection_res = 0x3e; break;
+ case 0x2b: m_protection_res = 0x41; break;
// CSK227 and NUMBER10
- case 0x2c: state->m_protection_res = 0x49; break;
- case 0x2d: state->m_protection_res = 0xf9; break;
- case 0x2e: state->m_protection_res = 0x0a; break;
- case 0x30: state->m_protection_res = 0x26; break;
- case 0x31: state->m_protection_res = 0x49; break;
- case 0x32: state->m_protection_res = 0x49; break;
- case 0x33: state->m_protection_res = 0x49; break;
- case 0x34: state->m_protection_res = 0x32; break;
+ case 0x2c: m_protection_res = 0x49; break;
+ case 0x2d: m_protection_res = 0xf9; break;
+ case 0x2e: m_protection_res = 0x0a; break;
+ case 0x30: m_protection_res = 0x26; break;
+ case 0x31: m_protection_res = 0x49; break;
+ case 0x32: m_protection_res = 0x49; break;
+ case 0x33: m_protection_res = 0x49; break;
+ case 0x34: m_protection_res = 0x32; break;
// NUMBER10
- case 0x60: state->m_protection_res = 0x30; break;
- case 0x61: state->m_protection_res = 0x31; break;
- case 0x62: state->m_protection_res = 0x3e; break;
- case 0x64: state->m_protection_res = 0x3c; break;
- case 0x65: state->m_protection_res = 0x31; break;
- case 0x66: state->m_protection_res = 0x39; break;
- case 0x67: state->m_protection_res = 0x33; break;
- case 0x68: state->m_protection_res = 0x35; break;
- case 0x6a: state->m_protection_res = 0x40; break;
- case 0x6b: state->m_protection_res = 0x43; break;
+ case 0x60: m_protection_res = 0x30; break;
+ case 0x61: m_protection_res = 0x31; break;
+ case 0x62: m_protection_res = 0x3e; break;
+ case 0x64: m_protection_res = 0x3c; break;
+ case 0x65: m_protection_res = 0x31; break;
+ case 0x66: m_protection_res = 0x39; break;
+ case 0x67: m_protection_res = 0x33; break;
+ case 0x68: m_protection_res = 0x35; break;
+ case 0x6a: m_protection_res = 0x40; break;
+ case 0x6b: m_protection_res = 0x43; break;
default:
- state->m_protection_res = data;
+ m_protection_res = data;
}
}
@@ -336,9 +339,9 @@ static CUSTOM_INPUT( hopper_r )
return field.machine().input().code_pressed(KEYCODE_H);
}
-static READ8_HANDLER( exp_rom_r )
+READ8_MEMBER(igspoker_state::exp_rom_r)
{
- UINT8 *rom = space->machine().region("maincpu")->base();
+ UINT8 *rom = machine().region("maincpu")->base();
return rom[offset+0x10000];
}
@@ -355,18 +358,18 @@ static ADDRESS_MAP_START( igspoker_io_map, AS_IO, 8, igspoker_state )
AM_RANGE(0x4002, 0x4002) AM_READ_PORT("DSW3") /* DSW3 */
AM_RANGE(0x4003, 0x4003) AM_READ_PORT("DSW4") /* DSW4 */
AM_RANGE(0x4004, 0x4004) AM_READ_PORT("DSW5") /* DSW5 */
- AM_RANGE(0x5080, 0x5080) AM_WRITE_LEGACY(igs_nmi_and_coins_w)
+ AM_RANGE(0x5080, 0x5080) AM_WRITE(igs_nmi_and_coins_w)
AM_RANGE(0x5081, 0x5081) AM_READ_PORT("SERVICE") /* Services */
AM_RANGE(0x5082, 0x5082) AM_READ_PORT("COINS") /* Coing & Kbd */
- AM_RANGE(0x5090, 0x5090) AM_WRITE_LEGACY(custom_io_w)
- AM_RANGE(0x5091, 0x5091) AM_READ_LEGACY(custom_io_r) AM_WRITE_LEGACY(igs_lamps_w ) /* Keyboard */
+ AM_RANGE(0x5090, 0x5090) AM_WRITE(custom_io_w)
+ AM_RANGE(0x5091, 0x5091) AM_READ(custom_io_r) AM_WRITE(igs_lamps_w ) /* Keyboard */
AM_RANGE(0x50a0, 0x50a0) AM_READ_PORT("BUTTONS2") /* Not connected */
AM_RANGE(0x50b0, 0x50b1) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w)
- AM_RANGE(0x50c0, 0x50c0) AM_READ_LEGACY(igs_irqack_r) AM_WRITE_LEGACY(igs_irqack_w)
- AM_RANGE(0x6800, 0x6fff) AM_RAM_WRITE_LEGACY(bg_tile_w ) AM_BASE(m_bg_tile_ram )
- AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
- AM_RANGE(0x0000, 0xffff) AM_READ_LEGACY(exp_rom_r )
+ AM_RANGE(0x50c0, 0x50c0) AM_READ(igs_irqack_r) AM_WRITE(igs_irqack_w)
+ AM_RANGE(0x6800, 0x6fff) AM_RAM_WRITE(bg_tile_w ) AM_BASE(m_bg_tile_ram )
+ AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE(0x0000, 0xffff) AM_READ(exp_rom_r )
ADDRESS_MAP_END
@@ -1111,17 +1114,17 @@ static ADDRESS_MAP_START( number10_io_map, AS_IO, 8, igspoker_state )
AM_RANGE(0x4004, 0x4004) AM_READ_PORT("DSW5") /* DSW5 */
AM_RANGE(0x4006, 0x4006) AM_READ_PORT("DSW6")
AM_RANGE(0x4007, 0x4007) AM_READ_PORT("DSW7")
- AM_RANGE(0x50f0, 0x50f0) AM_WRITE_LEGACY(igs_nmi_and_coins_w)
+ AM_RANGE(0x50f0, 0x50f0) AM_WRITE(igs_nmi_and_coins_w)
AM_RANGE(0x5080, 0x5080) AM_READ_PORT("SERVICE") /* Services */
- AM_RANGE(0x5090, 0x5090) AM_WRITE_LEGACY(custom_io_w)
- AM_RANGE(0x5091, 0x5091) AM_READ_LEGACY(custom_io_r) AM_WRITE_LEGACY(igs_lamps_w ) /* Keyboard */
+ AM_RANGE(0x5090, 0x5090) AM_WRITE(custom_io_w)
+ AM_RANGE(0x5091, 0x5091) AM_READ(custom_io_r) AM_WRITE(igs_lamps_w ) /* Keyboard */
AM_RANGE(0x50a0, 0x50a0) AM_READ_PORT("BUTTONS2")
/* Sound synthesys has been patched out, replaced by ADPCM samples */
AM_RANGE(0x50b0, 0x50b0) AM_DEVREADWRITE("oki", okim6295_device, read, write)
- AM_RANGE(0x50c0, 0x50c0) AM_READ_LEGACY(igs_irqack_r) AM_WRITE_LEGACY(igs_irqack_w)
- AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
- AM_RANGE(0x0000, 0xffff) AM_READ_LEGACY(exp_rom_r )
+ AM_RANGE(0x50c0, 0x50c0) AM_READ(igs_irqack_r) AM_WRITE(igs_irqack_w)
+ AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE(0x0000, 0xffff) AM_READ(exp_rom_r )
ADDRESS_MAP_END
static ADDRESS_MAP_START( cpokerpk_io_map, AS_IO, 8, igspoker_state )
@@ -1132,18 +1135,18 @@ static ADDRESS_MAP_START( cpokerpk_io_map, AS_IO, 8, igspoker_state )
AM_RANGE(0x4002, 0x4002) AM_READ_PORT("DSW3") /* DSW3 */
AM_RANGE(0x4003, 0x4003) AM_READ_PORT("DSW4") /* DSW4 */
AM_RANGE(0x4004, 0x4004) AM_READ_PORT("DSW5") /* DSW5 */
- AM_RANGE(0x50f0, 0x50f0) AM_WRITE_LEGACY(igs_nmi_and_coins_w)
+ AM_RANGE(0x50f0, 0x50f0) AM_WRITE(igs_nmi_and_coins_w)
AM_RANGE(0x5081, 0x5081) AM_READ_PORT("SERVICE") /* Services */
AM_RANGE(0x5082, 0x5082) AM_READ_PORT("COINS") /* Coing & Kbd */
- AM_RANGE(0x5090, 0x5090) AM_WRITE_LEGACY(custom_io_w)
- AM_RANGE(0x5091, 0x5091) AM_READ_LEGACY(custom_io_r) AM_WRITE_LEGACY(igs_lamps_w ) /* Keyboard */
+ AM_RANGE(0x5090, 0x5090) AM_WRITE(custom_io_w)
+ AM_RANGE(0x5091, 0x5091) AM_READ(custom_io_r) AM_WRITE(igs_lamps_w ) /* Keyboard */
AM_RANGE(0x50a0, 0x50a0) AM_READ_PORT("BUTTONS2")
/* Sound synthesys has been patched out, replaced by ADPCM samples */
AM_RANGE(0x50b0, 0x50b0) AM_DEVREADWRITE("oki", okim6295_device, read, write)
- AM_RANGE(0x50c0, 0x50c0) AM_READ_LEGACY(igs_irqack_r) AM_WRITE_LEGACY(igs_irqack_w)
- AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
- AM_RANGE(0x0000, 0xffff) AM_READ_LEGACY(exp_rom_r )
+ AM_RANGE(0x50c0, 0x50c0) AM_READ(igs_irqack_r) AM_WRITE(igs_irqack_w)
+ AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE(0x0000, 0xffff) AM_READ(exp_rom_r )
ADDRESS_MAP_END
static INPUT_PORTS_START( number10 )
diff --git a/src/mame/drivers/jackie.c b/src/mame/drivers/jackie.c
index 7ed06fb522d..885e4c92c62 100644
--- a/src/mame/drivers/jackie.c
+++ b/src/mame/drivers/jackie.c
@@ -76,6 +76,26 @@ public:
UINT16 m_unk_reg[3][5];
required_device<cpu_device> m_maincpu;
+ DECLARE_WRITE8_MEMBER(fg_tile_w);
+ DECLARE_WRITE8_MEMBER(fg_color_w);
+ DECLARE_WRITE8_MEMBER(bg_scroll_w);
+ DECLARE_WRITE8_MEMBER(jackie_reel1_ram_w);
+ DECLARE_WRITE8_MEMBER(jackie_reel2_ram_w);
+ DECLARE_WRITE8_MEMBER(jackie_reel3_ram_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg1_lo_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg2_lo_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg3_lo_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg1_hi_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg2_hi_w);
+ DECLARE_WRITE8_MEMBER(jackie_unk_reg3_hi_w);
+ DECLARE_WRITE8_MEMBER(jackie_nmi_and_coins_w);
+ DECLARE_WRITE8_MEMBER(jackie_lamps_w);
+ DECLARE_READ8_MEMBER(igs_irqack_r);
+ DECLARE_WRITE8_MEMBER(igs_irqack_w);
+ DECLARE_READ8_MEMBER(expram_r);
+ void jackie_unk_reg_lo_w( int offset, UINT8 data, int reg );
+ void jackie_unk_reg_hi_w( int offset, UINT8 data, int reg );
+ void show_out();
};
@@ -89,35 +109,31 @@ static TILE_GET_INFO( get_fg_tile_info )
SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
}
-static WRITE8_HANDLER( fg_tile_w )
+WRITE8_MEMBER(jackie_state::fg_tile_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_fg_tile_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_tile_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( fg_color_w )
+WRITE8_MEMBER(jackie_state::fg_color_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_fg_color_ram[offset] = data;
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ m_fg_color_ram[offset] = data;
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( bg_scroll_w )
+WRITE8_MEMBER(jackie_state::bg_scroll_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_bg_scroll[offset] = data;
+ m_bg_scroll[offset] = data;
}
-static WRITE8_HANDLER( jackie_reel1_ram_w )
+WRITE8_MEMBER(jackie_state::jackie_reel1_ram_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_reel1_ram[offset] = data;
- state->m_reel1_tilemap->mark_tile_dirty(offset);
+ m_reel1_ram[offset] = data;
+ m_reel1_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel1_tile_info )
@@ -129,11 +145,10 @@ static TILE_GET_INFO( get_jackie_reel1_tile_info )
-static WRITE8_HANDLER( jackie_reel2_ram_w )
+WRITE8_MEMBER(jackie_state::jackie_reel2_ram_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_reel2_ram[offset] = data;
- state->m_reel2_tilemap->mark_tile_dirty(offset);
+ m_reel2_ram[offset] = data;
+ m_reel2_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel2_tile_info )
@@ -144,11 +159,10 @@ static TILE_GET_INFO( get_jackie_reel2_tile_info )
}
-static WRITE8_HANDLER( jackie_reel3_ram_w )
+WRITE8_MEMBER(jackie_state::jackie_reel3_ram_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_reel3_ram[offset] = data;
- state->m_reel3_tilemap->mark_tile_dirty(offset);
+ m_reel3_ram[offset] = data;
+ m_reel3_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel3_tile_info )
@@ -234,62 +248,58 @@ static MACHINE_RESET( jackie )
}
-static void show_out(jackie_state *state)
+void jackie_state::show_out()
{
#ifdef MAME_DEBUG
// popmessage("%02x %02x %02x", state->m_out[0], state->m_out[1], state->m_out[2]);
popmessage("520: %04x %04x %04x %04x %04x\n560: %04x %04x %04x %04x %04x\n5A0: %04x %04x %04x %04x %04x",
- state->m_unk_reg[0][0],state->m_unk_reg[0][1],state->m_unk_reg[0][2],state->m_unk_reg[0][3],state->m_unk_reg[0][4],
- state->m_unk_reg[1][0],state->m_unk_reg[1][1],state->m_unk_reg[1][2],state->m_unk_reg[1][3],state->m_unk_reg[1][4],
- state->m_unk_reg[2][0],state->m_unk_reg[2][1],state->m_unk_reg[2][2],state->m_unk_reg[2][3],state->m_unk_reg[2][4]
+ m_unk_reg[0][0],m_unk_reg[0][1],m_unk_reg[0][2],m_unk_reg[0][3],m_unk_reg[0][4],
+ m_unk_reg[1][0],m_unk_reg[1][1],m_unk_reg[1][2],m_unk_reg[1][3],m_unk_reg[1][4],
+ m_unk_reg[2][0],m_unk_reg[2][1],m_unk_reg[2][2],m_unk_reg[2][3],m_unk_reg[2][4]
);
#endif
}
-static void jackie_unk_reg_lo_w( address_space *space, int offset, UINT8 data, int reg )
+void jackie_state::jackie_unk_reg_lo_w( int offset, UINT8 data, int reg )
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_unk_reg[reg][offset] &= 0xff00;
- state->m_unk_reg[reg][offset] |= data;
- show_out(state);
+ m_unk_reg[reg][offset] &= 0xff00;
+ m_unk_reg[reg][offset] |= data;
+ show_out();
}
-static WRITE8_HANDLER( jackie_unk_reg1_lo_w ) { jackie_unk_reg_lo_w( space, offset, data, 0 ); }
-static WRITE8_HANDLER( jackie_unk_reg2_lo_w ) { jackie_unk_reg_lo_w( space, offset, data, 1 ); }
-static WRITE8_HANDLER( jackie_unk_reg3_lo_w ) { jackie_unk_reg_lo_w( space, offset, data, 2 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg1_lo_w){ jackie_unk_reg_lo_w( offset, data, 0 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg2_lo_w){ jackie_unk_reg_lo_w( offset, data, 1 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg3_lo_w){ jackie_unk_reg_lo_w( offset, data, 2 ); }
-static void jackie_unk_reg_hi_w( address_space *space, int offset, UINT8 data, int reg )
+void jackie_state::jackie_unk_reg_hi_w( int offset, UINT8 data, int reg )
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_unk_reg[reg][offset] &= 0xff;
- state->m_unk_reg[reg][offset] |= data << 8;
- show_out(state);
+ m_unk_reg[reg][offset] &= 0xff;
+ m_unk_reg[reg][offset] |= data << 8;
+ show_out();
}
-static WRITE8_HANDLER( jackie_unk_reg1_hi_w ) { jackie_unk_reg_hi_w( space, offset, data, 0 ); }
-static WRITE8_HANDLER( jackie_unk_reg2_hi_w ) { jackie_unk_reg_hi_w( space, offset, data, 1 ); }
-static WRITE8_HANDLER( jackie_unk_reg3_hi_w ) { jackie_unk_reg_hi_w( space, offset, data, 2 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg1_hi_w){ jackie_unk_reg_hi_w( offset, data, 0 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg2_hi_w){ jackie_unk_reg_hi_w( offset, data, 1 ); }
+WRITE8_MEMBER(jackie_state::jackie_unk_reg3_hi_w){ jackie_unk_reg_hi_w( offset, data, 2 ); }
-static WRITE8_HANDLER( jackie_nmi_and_coins_w )
+WRITE8_MEMBER(jackie_state::jackie_nmi_and_coins_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- coin_counter_w(space->machine(), 0, data & 0x01); // coin_a
- coin_counter_w(space->machine(), 1, data & 0x04); // coin_c
- coin_counter_w(space->machine(), 2, data & 0x08); // key in
- coin_counter_w(space->machine(), 3, data & 0x10); // coin state->m_out mech
+ coin_counter_w(machine(), 0, data & 0x01); // coin_a
+ coin_counter_w(machine(), 1, data & 0x04); // coin_c
+ coin_counter_w(machine(), 2, data & 0x08); // key in
+ coin_counter_w(machine(), 3, data & 0x10); // coin m_out mech
- set_led_status(space->machine(), 6, data & 0x20); // led for coin state->m_out / state->m_hopper active
+ set_led_status(machine(), 6, data & 0x20); // led for coin m_out / m_hopper active
- state->m_exp_bank = (data & 0x02) ? 1 : 0; // expram bank number
- state->m_nmi_enable = data & 0x80; // nmi enable?
+ m_exp_bank = (data & 0x02) ? 1 : 0; // expram bank number
+ m_nmi_enable = data & 0x80; // nmi enable?
- state->m_out[0] = data;
- show_out(state);
+ m_out[0] = data;
+ show_out();
}
-static WRITE8_HANDLER( jackie_lamps_w )
+WRITE8_MEMBER(jackie_state::jackie_lamps_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
/*
- Lbits -
7654 3210
@@ -308,34 +318,31 @@ static WRITE8_HANDLER( jackie_lamps_w )
output_set_lamp_value(5, (data >> 2) & 1); /* Lamp 5 - HOLD 5 */
output_set_lamp_value(6, (data & 1)); /* Lamp 6 - START */
- state->m_hopper = (~data)& 0x80;
+ m_hopper = (~data)& 0x80;
- state->m_out[1] = data;
- show_out(state);
+ m_out[1] = data;
+ show_out();
}
-static READ8_HANDLER( igs_irqack_r )
+READ8_MEMBER(jackie_state::igs_irqack_r)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- state->m_irq_enable = 1;
+ m_irq_enable = 1;
return 0;
}
-static WRITE8_HANDLER( igs_irqack_w )
+WRITE8_MEMBER(jackie_state::igs_irqack_w)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
-// cputag_set_input_line(space->machine(), "maincpu", 0, CLEAR_LINE);
- state->m_out[2] = data;
- show_out(state);
+// cputag_set_input_line(machine(), "maincpu", 0, CLEAR_LINE);
+ m_out[2] = data;
+ show_out();
}
-static READ8_HANDLER( expram_r )
+READ8_MEMBER(jackie_state::expram_r)
{
- jackie_state *state = space->machine().driver_data<jackie_state>();
- UINT8 *rom = space->machine().region("gfx3")->base();
+ UINT8 *rom = machine().region("gfx3")->base();
- offset += state->m_exp_bank * 0x8000;
-// logerror("PC %06X: %04x = %02x\n",cpu_get_pc(&space->device()),offset,rom[offset]);
+ offset += m_exp_bank * 0x8000;
+// logerror("PC %06X: %04x = %02x\n",cpu_get_pc(&space.device()),offset,rom[offset]);
return rom[offset];
}
@@ -346,12 +353,12 @@ static ADDRESS_MAP_START( jackie_prg_map, AS_PROGRAM, 8, jackie_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( jackie_io_map, AS_IO, 8, jackie_state )
- AM_RANGE(0x0520, 0x0524) AM_WRITE_LEGACY(jackie_unk_reg1_lo_w)
- AM_RANGE(0x0d20, 0x0d24) AM_WRITE_LEGACY(jackie_unk_reg1_hi_w)
- AM_RANGE(0x0560, 0x0564) AM_WRITE_LEGACY(jackie_unk_reg2_lo_w)
- AM_RANGE(0x0d60, 0x0d64) AM_WRITE_LEGACY(jackie_unk_reg2_hi_w)
- AM_RANGE(0x05a0, 0x05a4) AM_WRITE_LEGACY(jackie_unk_reg3_lo_w)
- AM_RANGE(0x0da0, 0x0da4) AM_WRITE_LEGACY(jackie_unk_reg3_hi_w)
+ AM_RANGE(0x0520, 0x0524) AM_WRITE(jackie_unk_reg1_lo_w)
+ AM_RANGE(0x0d20, 0x0d24) AM_WRITE(jackie_unk_reg1_hi_w)
+ AM_RANGE(0x0560, 0x0564) AM_WRITE(jackie_unk_reg2_lo_w)
+ AM_RANGE(0x0d60, 0x0d64) AM_WRITE(jackie_unk_reg2_hi_w)
+ AM_RANGE(0x05a0, 0x05a4) AM_WRITE(jackie_unk_reg3_lo_w)
+ AM_RANGE(0x0da0, 0x0da4) AM_WRITE(jackie_unk_reg3_hi_w)
AM_RANGE(0x1000, 0x1107) AM_RAM AM_BASE(m_bg_scroll2 )
AM_RANGE(0x2000, 0x27ff) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split1_w ) AM_BASE_GENERIC( paletteram )
AM_RANGE(0x2800, 0x2fff) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split2_w ) AM_BASE_GENERIC( paletteram2 )
@@ -360,21 +367,21 @@ static ADDRESS_MAP_START( jackie_io_map, AS_IO, 8, jackie_state )
AM_RANGE(0x4002, 0x4002) AM_READ_PORT("DSW3") /* DSW3 */
AM_RANGE(0x4003, 0x4003) AM_READ_PORT("DSW4") /* DSW4 */
AM_RANGE(0x4004, 0x4004) AM_READ_PORT("DSW5") /* DSW5 */
- AM_RANGE(0x5080, 0x5080) AM_WRITE_LEGACY(jackie_nmi_and_coins_w)
+ AM_RANGE(0x5080, 0x5080) AM_WRITE(jackie_nmi_and_coins_w)
AM_RANGE(0x5081, 0x5081) AM_READ_PORT("SERVICE")
AM_RANGE(0x5082, 0x5082) AM_READ_PORT("COINS")
AM_RANGE(0x5090, 0x5090) AM_READ_PORT("BUTTONS1")
- AM_RANGE(0x5091, 0x5091) AM_WRITE_LEGACY(jackie_lamps_w )
+ AM_RANGE(0x5091, 0x5091) AM_WRITE(jackie_lamps_w )
AM_RANGE(0x50a0, 0x50a0) AM_READ_PORT("BUTTONS2")
AM_RANGE(0x50b0, 0x50b1) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w)
- AM_RANGE(0x50c0, 0x50c0) AM_READ_LEGACY(igs_irqack_r) AM_WRITE_LEGACY(igs_irqack_w)
- AM_RANGE(0x6000, 0x60ff) AM_RAM_WRITE_LEGACY(bg_scroll_w ) AM_BASE(m_bg_scroll )
- AM_RANGE(0x6800, 0x69ff) AM_RAM_WRITE_LEGACY(jackie_reel1_ram_w ) AM_BASE(m_reel1_ram )
- AM_RANGE(0x6a00, 0x6bff) AM_RAM_WRITE_LEGACY(jackie_reel2_ram_w ) AM_BASE(m_reel2_ram )
- AM_RANGE(0x6c00, 0x6dff) AM_RAM_WRITE_LEGACY(jackie_reel3_ram_w ) AM_BASE(m_reel3_ram )
- AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE_LEGACY(fg_tile_w ) AM_BASE(m_fg_tile_ram )
- AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE_LEGACY(fg_color_w ) AM_BASE(m_fg_color_ram )
- AM_RANGE(0x8000, 0xffff) AM_READ_LEGACY(expram_r)
+ AM_RANGE(0x50c0, 0x50c0) AM_READ(igs_irqack_r) AM_WRITE(igs_irqack_w)
+ AM_RANGE(0x6000, 0x60ff) AM_RAM_WRITE(bg_scroll_w ) AM_BASE(m_bg_scroll )
+ AM_RANGE(0x6800, 0x69ff) AM_RAM_WRITE(jackie_reel1_ram_w ) AM_BASE(m_reel1_ram )
+ AM_RANGE(0x6a00, 0x6bff) AM_RAM_WRITE(jackie_reel2_ram_w ) AM_BASE(m_reel2_ram )
+ AM_RANGE(0x6c00, 0x6dff) AM_RAM_WRITE(jackie_reel3_ram_w ) AM_BASE(m_reel3_ram )
+ AM_RANGE(0x7000, 0x77ff) AM_RAM_WRITE(fg_tile_w ) AM_BASE(m_fg_tile_ram )
+ AM_RANGE(0x7800, 0x7fff) AM_RAM_WRITE(fg_color_w ) AM_BASE(m_fg_color_ram )
+ AM_RANGE(0x8000, 0xffff) AM_READ(expram_r)
ADDRESS_MAP_END
static CUSTOM_INPUT( hopper_r )
diff --git a/src/mame/drivers/jalmah.c b/src/mame/drivers/jalmah.c
index becd0b3f03f..8192fdbefc0 100644
--- a/src/mame/drivers/jalmah.c
+++ b/src/mame/drivers/jalmah.c
@@ -157,6 +157,28 @@ public:
UINT8 m_oki_rom;
UINT8 m_oki_bank;
UINT8 m_oki_za;
+ DECLARE_WRITE16_MEMBER(sc0_vram_w);
+ DECLARE_WRITE16_MEMBER(sc3_vram_w);
+ DECLARE_WRITE16_MEMBER(sc1_vram_w);
+ DECLARE_WRITE16_MEMBER(sc2_vram_w);
+ DECLARE_WRITE16_MEMBER(jalmah_tilebank_w);
+ DECLARE_WRITE16_MEMBER(jalmah_scroll_w);
+ DECLARE_WRITE16_MEMBER(urashima_bank_w);
+ DECLARE_WRITE16_MEMBER(urashima_sc0_vram_w);
+ DECLARE_WRITE16_MEMBER(urashima_sc3_vram_w);
+ DECLARE_WRITE16_MEMBER(urashima_vregs_w);
+ DECLARE_WRITE16_MEMBER(urashima_dma_w);
+ DECLARE_WRITE16_MEMBER(jalmah_okirom_w);
+ DECLARE_WRITE16_MEMBER(jalmah_okibank_w);
+ DECLARE_WRITE16_MEMBER(jalmah_flip_screen_w);
+ DECLARE_READ16_MEMBER(urashima_mcu_r);
+ DECLARE_WRITE16_MEMBER(urashima_mcu_w);
+ DECLARE_READ16_MEMBER(daireika_mcu_r);
+ DECLARE_WRITE16_MEMBER(daireika_mcu_w);
+ DECLARE_READ16_MEMBER(mjzoomin_mcu_r);
+ DECLARE_WRITE16_MEMBER(mjzoomin_mcu_w);
+ DECLARE_READ16_MEMBER(kakumei_mcu_r);
+ DECLARE_READ16_MEMBER(suchipi_mcu_r);
};
@@ -472,63 +494,58 @@ static SCREEN_UPDATE_IND16( urashima )
return 0;
}
-static WRITE16_HANDLER( sc0_vram_w )
+WRITE16_MEMBER(jalmah_state::sc0_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc0_vram[offset]);
+ COMBINE_DATA(&m_sc0_vram[offset]);
/*2048x256 tilemap*/
- state->m_sc0_tilemap_0->mark_tile_dirty(offset);
+ m_sc0_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
- state->m_sc0_tilemap_1->mark_tile_dirty(offset);
+ m_sc0_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
- state->m_sc0_tilemap_2->mark_tile_dirty(offset);
+ m_sc0_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
- state->m_sc0_tilemap_3->mark_tile_dirty(offset);
+ m_sc0_tilemap_3->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( sc3_vram_w )
+WRITE16_MEMBER(jalmah_state::sc3_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc3_vram[offset]);
+ COMBINE_DATA(&m_sc3_vram[offset]);
/*2048x256 tilemap*/
- state->m_sc3_tilemap_0->mark_tile_dirty(offset);
+ m_sc3_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
- state->m_sc3_tilemap_2->mark_tile_dirty(offset);
+ m_sc3_tilemap_2->mark_tile_dirty(offset);
/*512x1024 tilemap*/
- state->m_sc3_tilemap_3->mark_tile_dirty(offset);
+ m_sc3_tilemap_3->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( sc1_vram_w )
+WRITE16_MEMBER(jalmah_state::sc1_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc1_vram[offset]);
+ COMBINE_DATA(&m_sc1_vram[offset]);
/*2048x256 tilemap*/
- state->m_sc1_tilemap_0->mark_tile_dirty(offset);
+ m_sc1_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
- state->m_sc1_tilemap_1->mark_tile_dirty(offset);
+ m_sc1_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
- state->m_sc1_tilemap_2->mark_tile_dirty(offset);
+ m_sc1_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
- state->m_sc1_tilemap_3->mark_tile_dirty(offset);
+ m_sc1_tilemap_3->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( sc2_vram_w )
+WRITE16_MEMBER(jalmah_state::sc2_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc2_vram[offset]);
+ COMBINE_DATA(&m_sc2_vram[offset]);
/*2048x256 tilemap*/
- state->m_sc2_tilemap_0->mark_tile_dirty(offset);
+ m_sc2_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
- state->m_sc2_tilemap_1->mark_tile_dirty(offset);
+ m_sc2_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
- state->m_sc2_tilemap_2->mark_tile_dirty(offset);
+ m_sc2_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
- state->m_sc2_tilemap_3->mark_tile_dirty(offset);
+ m_sc2_tilemap_3->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( jalmah_tilebank_w )
+WRITE16_MEMBER(jalmah_state::jalmah_tilebank_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
/*
xxxx ---- fg bank (used by suchipi)
---- xxxx Priority number (trusted,see mjzoomin)
@@ -536,24 +553,23 @@ static WRITE16_HANDLER( jalmah_tilebank_w )
//popmessage("Write to tilebank %02x",data);
if (ACCESSING_BITS_0_7)
{
- if (state->m_sc0bank != ((data & 0xf0) >> 4))
+ if (m_sc0bank != ((data & 0xf0) >> 4))
{
- state->m_sc0bank = (data & 0xf0) >> 4;
- state->m_sc0_tilemap_0->mark_all_dirty();
- state->m_sc0_tilemap_1->mark_all_dirty();
- state->m_sc0_tilemap_2->mark_all_dirty();
- state->m_sc0_tilemap_3->mark_all_dirty();
+ m_sc0bank = (data & 0xf0) >> 4;
+ m_sc0_tilemap_0->mark_all_dirty();
+ m_sc0_tilemap_1->mark_all_dirty();
+ m_sc0_tilemap_2->mark_all_dirty();
+ m_sc0_tilemap_3->mark_all_dirty();
}
- if (state->m_pri != (data & 0x0f))
- state->m_pri = data & 0x0f;
+ if (m_pri != (data & 0x0f))
+ m_pri = data & 0x0f;
}
}
-static WRITE16_HANDLER( jalmah_scroll_w )
+WRITE16_MEMBER(jalmah_state::jalmah_scroll_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- UINT16 *jm_scrollram = state->m_jm_scrollram;
- UINT16 *jm_vregs = state->m_jm_vregs;
+ UINT16 *jm_scrollram = m_jm_scrollram;
+ UINT16 *jm_vregs = m_jm_vregs;
//logerror("[%04x]<-%04x\n",(offset+0x10)*2,data);
switch(offset+(0x10))
{
@@ -579,41 +595,37 @@ static WRITE16_HANDLER( jalmah_scroll_w )
}
}
-static WRITE16_HANDLER( urashima_bank_w )
+WRITE16_MEMBER(jalmah_state::urashima_bank_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
if (ACCESSING_BITS_0_7)
{
- if (state->m_sc0bank != (data & 0x0f))
+ if (m_sc0bank != (data & 0x0f))
{
- state->m_sc0bank = (data & 0x0f);
- state->m_sc0_tilemap_0->mark_all_dirty();
- //state->m_sc0_tilemap_2->mark_all_dirty();
- //state->m_sc0_tilemap_3->mark_all_dirty();
+ m_sc0bank = (data & 0x0f);
+ m_sc0_tilemap_0->mark_all_dirty();
+ //m_sc0_tilemap_2->mark_all_dirty();
+ //m_sc0_tilemap_3->mark_all_dirty();
}
}
}
-static WRITE16_HANDLER( urashima_sc0_vram_w )
+WRITE16_MEMBER(jalmah_state::urashima_sc0_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc0_vram[offset]);
- state->m_sc0_tilemap_0->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_sc0_vram[offset]);
+ m_sc0_tilemap_0->mark_tile_dirty(offset);
}
-static WRITE16_HANDLER( urashima_sc3_vram_w )
+WRITE16_MEMBER(jalmah_state::urashima_sc3_vram_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- COMBINE_DATA(&state->m_sc3_vram[offset]);
- state->m_sc3_tilemap_0->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_sc3_vram[offset]);
+ m_sc3_tilemap_0->mark_tile_dirty(offset);
}
/*Urashima Mahjong uses a bigger (and mostly unused/wasted) video register ram.*/
-static WRITE16_HANDLER( urashima_vregs_w )
+WRITE16_MEMBER(jalmah_state::urashima_vregs_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- UINT16 *jm_scrollram = state->m_jm_scrollram;
- UINT16 *jm_vregs = state->m_jm_vregs;
+ UINT16 *jm_scrollram = m_jm_scrollram;
+ UINT16 *jm_vregs = m_jm_vregs;
//logerror("[%04x]<-%04x\n",(offset)*2,data);
switch(offset)
{
@@ -685,13 +697,13 @@ if((0xffff - input_port_read(machine, tag)) & _bit_) { jm_shared_ram[_offset_] =
/*Funky "DMA" / protection thing*/
/*---- -x-- "DMA" execute.*/
/*---- ---x used too very often,I don't have any clue of what it is,it might just be the source or the destination address.*/
-static WRITE16_HANDLER( urashima_dma_w )
+WRITE16_MEMBER(jalmah_state::urashima_dma_w)
{
if(data & 4)
{
UINT32 i;
for(i = 0; i < 0x200; i += 2)
- space->write_word(0x88200 + i, space->read_word(0x88400 + i));
+ space.write_word(0x88200 + i, space.read_word(0x88400 + i));
}
}
@@ -928,43 +940,41 @@ Basic driver start
******************************************************************************************/
-static WRITE16_HANDLER( jalmah_okirom_w )
+WRITE16_MEMBER(jalmah_state::jalmah_okirom_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
if(ACCESSING_BITS_0_7)
{
- UINT8 *oki = space->machine().region("oki")->base();
+ UINT8 *oki = machine().region("oki")->base();
- state->m_oki_rom = data & 1;
+ m_oki_rom = data & 1;
/* ZA appears to be related to the banking, or maybe kakumei2 uses PAL shuffling and this is for something else? */
- state->m_oki_za = (data & 2) ? 1 : 0;
+ m_oki_za = (data & 2) ? 1 : 0;
- memcpy(&oki[0x20000], &oki[(state->m_oki_rom * 0x80000) + ((state->m_oki_bank+state->m_oki_za) * 0x20000) + 0x40000], 0x20000);
+ memcpy(&oki[0x20000], &oki[(m_oki_rom * 0x80000) + ((m_oki_bank+m_oki_za) * 0x20000) + 0x40000], 0x20000);
}
- //popmessage("PC=%06x %02x %02x %02x %08x",cpu_get_pc(&space->device()),state->m_oki_rom,state->m_oki_za,state->m_oki_bank,(state->m_oki_rom * 0x80000) + ((state->m_oki_bank+state->m_oki_za) * 0x20000) + 0x40000);
+ //popmessage("PC=%06x %02x %02x %02x %08x",cpu_get_pc(&space.device()),m_oki_rom,m_oki_za,m_oki_bank,(m_oki_rom * 0x80000) + ((m_oki_bank+m_oki_za) * 0x20000) + 0x40000);
}
-static WRITE16_HANDLER( jalmah_okibank_w )
+WRITE16_MEMBER(jalmah_state::jalmah_okibank_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
if(ACCESSING_BITS_0_7)
{
- UINT8 *oki = space->machine().region("oki")->base();
+ UINT8 *oki = machine().region("oki")->base();
- state->m_oki_bank = data & 3;
+ m_oki_bank = data & 3;
- memcpy(&oki[0x20000], &oki[(state->m_oki_rom * 0x80000) + ((state->m_oki_bank+state->m_oki_za) * 0x20000) + 0x40000], 0x20000);
+ memcpy(&oki[0x20000], &oki[(m_oki_rom * 0x80000) + ((m_oki_bank+m_oki_za) * 0x20000) + 0x40000], 0x20000);
}
- //popmessage("PC=%06x %02x %02x %02x %08x",cpu_get_pc(&space->device()),state->m_oki_rom,state->m_oki_za,state->m_oki_bank,(state->m_oki_rom * 0x80000) + ((state->m_oki_bank+state->m_oki_za) * 0x20000) + 0x40000);
+ //popmessage("PC=%06x %02x %02x %02x %08x",cpu_get_pc(&space.device()),m_oki_rom,m_oki_za,m_oki_bank,(m_oki_rom * 0x80000) + ((m_oki_bank+m_oki_za) * 0x20000) + 0x40000);
}
-static WRITE16_HANDLER( jalmah_flip_screen_w )
+WRITE16_MEMBER(jalmah_state::jalmah_flip_screen_w)
{
/*---- ----x flip screen*/
- flip_screen_set(space->machine(), data & 1);
+ flip_screen_set(machine(), data & 1);
// popmessage("%04x",data);
}
@@ -974,20 +984,20 @@ static ADDRESS_MAP_START( jalmah, AS_PROGRAM, 16, jalmah_state )
AM_RANGE(0x080000, 0x080001) AM_READ_PORT("SYSTEM")
AM_RANGE(0x080002, 0x080003) AM_READ_PORT("DSW")
// 0x080004, 0x080005 MCU read,different for each game
- AM_RANGE(0x080010, 0x080011) AM_WRITE_LEGACY(jalmah_flip_screen_w)
+ AM_RANGE(0x080010, 0x080011) AM_WRITE(jalmah_flip_screen_w)
// 0x080012, 0x080013 MCU write related,same for each game
// 0x080014, 0x080015 MCU write related,same for each game
-/**/AM_RANGE(0x080016, 0x080017) AM_RAM_WRITE_LEGACY(jalmah_tilebank_w)
- AM_RANGE(0x080018, 0x080019) AM_WRITE_LEGACY(jalmah_okibank_w)
- AM_RANGE(0x08001a, 0x08001b) AM_WRITE_LEGACY(jalmah_okirom_w)
-/**/AM_RANGE(0x080020, 0x08003f) AM_RAM_WRITE_LEGACY(jalmah_scroll_w)
+/**/AM_RANGE(0x080016, 0x080017) AM_RAM_WRITE(jalmah_tilebank_w)
+ AM_RANGE(0x080018, 0x080019) AM_WRITE(jalmah_okibank_w)
+ AM_RANGE(0x08001a, 0x08001b) AM_WRITE(jalmah_okirom_w)
+/**/AM_RANGE(0x080020, 0x08003f) AM_RAM_WRITE(jalmah_scroll_w)
AM_RANGE(0x080040, 0x080041) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff)
// 0x084000, 0x084001 ?
AM_RANGE(0x088000, 0x0887ff) AM_RAM_WRITE_LEGACY(paletteram16_RRRRGGGGBBBBRGBx_word_w) AM_BASE_GENERIC(paletteram) /* Palette RAM */
- AM_RANGE(0x090000, 0x093fff) AM_RAM_WRITE_LEGACY(sc0_vram_w) AM_BASE(m_sc0_vram)
- AM_RANGE(0x094000, 0x097fff) AM_RAM_WRITE_LEGACY(sc1_vram_w) AM_BASE(m_sc1_vram)
- AM_RANGE(0x098000, 0x09bfff) AM_RAM_WRITE_LEGACY(sc2_vram_w) AM_BASE(m_sc2_vram)
- AM_RANGE(0x09c000, 0x09ffff) AM_RAM_WRITE_LEGACY(sc3_vram_w) AM_BASE(m_sc3_vram)
+ AM_RANGE(0x090000, 0x093fff) AM_RAM_WRITE(sc0_vram_w) AM_BASE(m_sc0_vram)
+ AM_RANGE(0x094000, 0x097fff) AM_RAM_WRITE(sc1_vram_w) AM_BASE(m_sc1_vram)
+ AM_RANGE(0x098000, 0x09bfff) AM_RAM_WRITE(sc2_vram_w) AM_BASE(m_sc2_vram)
+ AM_RANGE(0x09c000, 0x09ffff) AM_RAM_WRITE(sc3_vram_w) AM_BASE(m_sc3_vram)
AM_RANGE(0x0f0000, 0x0f0fff) AM_RAM AM_BASE(m_jm_shared_ram)/*shared with MCU*/
AM_RANGE(0x0f1000, 0x0fffff) AM_RAM /*Work Ram*/
AM_RANGE(0x100000, 0x10ffff) AM_RAM AM_BASE(m_jm_mcu_code)/*extra RAM for MCU code prg (NOT ON REAL HW!!!)*/
@@ -998,25 +1008,25 @@ static ADDRESS_MAP_START( urashima, AS_PROGRAM, 16, jalmah_state )
AM_RANGE(0x080000, 0x080001) AM_READ_PORT("SYSTEM")
AM_RANGE(0x080002, 0x080003) AM_READ_PORT("DSW")
// 0x080004, 0x080005 MCU read,different for each game
- AM_RANGE(0x080010, 0x080011) AM_WRITE_LEGACY(jalmah_flip_screen_w)
+ AM_RANGE(0x080010, 0x080011) AM_WRITE(jalmah_flip_screen_w)
// 0x080012, 0x080013 MCU write related,same for each game
// 0x080014, 0x080015 MCU write related,same for each game
-/**/AM_RANGE(0x080016, 0x080017) AM_RAM_WRITE_LEGACY(urashima_dma_w)
- AM_RANGE(0x080018, 0x080019) AM_WRITE_LEGACY(jalmah_okibank_w)
- AM_RANGE(0x08001a, 0x08001b) AM_WRITE_LEGACY(jalmah_okirom_w)
-/**/AM_RANGE(0x08001c, 0x08001d) AM_RAM_WRITE_LEGACY(urashima_bank_w)
+/**/AM_RANGE(0x080016, 0x080017) AM_RAM_WRITE(urashima_dma_w)
+ AM_RANGE(0x080018, 0x080019) AM_WRITE(jalmah_okibank_w)
+ AM_RANGE(0x08001a, 0x08001b) AM_WRITE(jalmah_okirom_w)
+/**/AM_RANGE(0x08001c, 0x08001d) AM_RAM_WRITE(urashima_bank_w)
AM_RANGE(0x080040, 0x080041) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff)
// 0x084000, 0x084001 ?
AM_RANGE(0x088000, 0x0887ff) AM_RAM_WRITE_LEGACY(paletteram16_RRRRGGGGBBBBRGBx_word_w) AM_BASE_GENERIC(paletteram) /* Palette RAM */
- AM_RANGE(0x090000, 0x093fff) AM_RAM_WRITE_LEGACY(urashima_sc0_vram_w) AM_BASE(m_sc0_vram)
- AM_RANGE(0x094000, 0x097fff) AM_RAM_WRITE_LEGACY(urashima_sc0_vram_w)
- AM_RANGE(0x098000, 0x09bfff) AM_RAM_WRITE_LEGACY(urashima_sc0_vram_w)
+ AM_RANGE(0x090000, 0x093fff) AM_RAM_WRITE(urashima_sc0_vram_w) AM_BASE(m_sc0_vram)
+ AM_RANGE(0x094000, 0x097fff) AM_RAM_WRITE(urashima_sc0_vram_w)
+ AM_RANGE(0x098000, 0x09bfff) AM_RAM_WRITE(urashima_sc0_vram_w)
// AM_RANGE(0x094000, 0x097fff) AM_RAM_WRITE_LEGACY(urashima_sc1_vram_w) AM_BASE(m_sc1_vram)/*unused*/
// AM_RANGE(0x098000, 0x09bfff) AM_RAM_WRITE_LEGACY(urashima_sc2_vram_w) AM_BASE(m_sc2_vram)/*unused*/
/*$9c000-$9cfff Video Registers*/
-/**/AM_RANGE(0x09c000, 0x09dfff) AM_WRITE_LEGACY(urashima_vregs_w)
+/**/AM_RANGE(0x09c000, 0x09dfff) AM_WRITE(urashima_vregs_w)
/**///AM_RANGE(0x09c480, 0x09c49f) AM_RAM_WRITE_LEGACY(urashima_sc2vregs_w)
- AM_RANGE(0x09e000, 0x0a1fff) AM_RAM_WRITE_LEGACY(urashima_sc3_vram_w) AM_BASE(m_sc3_vram)
+ AM_RANGE(0x09e000, 0x0a1fff) AM_RAM_WRITE(urashima_sc3_vram_w) AM_BASE(m_sc3_vram)
AM_RANGE(0x0f0000, 0x0f0fff) AM_RAM AM_BASE(m_jm_shared_ram)/*shared with MCU*/
AM_RANGE(0x0f1000, 0x0fffff) AM_RAM /*Work Ram*/
AM_RANGE(0x100000, 0x10ffff) AM_RAM AM_BASE(m_jm_mcu_code)/*extra RAM for MCU code prg (NOT ON REAL HW!!!)*/
@@ -1716,9 +1726,8 @@ MCU code snippets
******************************************************************************************/
-static READ16_HANDLER( urashima_mcu_r )
+READ16_MEMBER(jalmah_state::urashima_mcu_r)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
static const int resp[] = { 0x99, 0xd8, 0x00,
0x2a, 0x6a, 0x00,
0x9c, 0xd8, 0x00,
@@ -1731,10 +1740,10 @@ static READ16_HANDLER( urashima_mcu_r )
0x21, 0x61, 0x00 };
int res;
- res = resp[state->m_respcount++];
- if (state->m_respcount >= sizeof(resp)/sizeof(resp[0])) state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (m_respcount >= sizeof(resp)/sizeof(resp[0])) m_respcount = 0;
-// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space->device()),res);
+// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space.device()),res);
return res;
}
@@ -1742,11 +1751,10 @@ static READ16_HANDLER( urashima_mcu_r )
/*
data value is REQ under mjzoomin video test menu.It is related to the MCU?
*/
-static WRITE16_HANDLER( urashima_mcu_w )
+WRITE16_MEMBER(jalmah_state::urashima_mcu_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- UINT16 *jm_shared_ram = state->m_jm_shared_ram;
- UINT16 *jm_mcu_code = state->m_jm_mcu_code;
+ UINT16 *jm_shared_ram = m_jm_shared_ram;
+ UINT16 *jm_mcu_code = m_jm_mcu_code;
if(ACCESSING_BITS_0_7 && data)
{
/*******************************************************
@@ -1936,9 +1944,8 @@ static WRITE16_HANDLER( urashima_mcu_w )
}
}
-static READ16_HANDLER( daireika_mcu_r )
+READ16_MEMBER(jalmah_state::daireika_mcu_r)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
static const int resp[] = { 0x99, 0xd8, 0x00,
0x2a, 0x6a, 0x00,
0x9c, 0xd8, 0x00,
@@ -1951,10 +1958,10 @@ static READ16_HANDLER( daireika_mcu_r )
0x21, 0x61, 0x00 };
int res;
- res = resp[state->m_respcount++];
- if (state->m_respcount >= sizeof(resp)/sizeof(resp[0])) state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (m_respcount >= sizeof(resp)/sizeof(resp[0])) m_respcount = 0;
-// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space->device()),res);
+// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space.device()),res);
return res;
}
@@ -1965,11 +1972,10 @@ data value is REQ under mjzoomin video test menu.It is related to the MCU?
static const UINT16 dai_mcu_code[0x11] = { 0x33c5, 0x0010, 0x07fe, 0x3a39,0x000f,0x000c,0xda86,0x0245,
0x003f, 0x33c5, 0x000f, 0x000c,0x3a39,0x0010,0x07fe,0x4e75 };
-static WRITE16_HANDLER( daireika_mcu_w )
+WRITE16_MEMBER(jalmah_state::daireika_mcu_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- UINT16 *jm_shared_ram = state->m_jm_shared_ram;
- UINT16 *jm_mcu_code = state->m_jm_mcu_code;
+ UINT16 *jm_shared_ram = m_jm_shared_ram;
+ UINT16 *jm_mcu_code = m_jm_mcu_code;
UINT16 i;
if(ACCESSING_BITS_0_7 && data)
@@ -2113,11 +2119,11 @@ static WRITE16_HANDLER( daireika_mcu_w )
jm_shared_ram[0x0128/2] = 0x0010;
jm_shared_ram[0x012a/2] = 0x8980;
- //state->m_pri $f0590
+ //m_pri $f0590
jm_mcu_code[0x8980/2] = 0x33fc;
jm_mcu_code[0x8982/2] = 0x0006;
jm_mcu_code[0x8984/2] = 0x000f;
- jm_mcu_code[0x8986/2] = 0x0590; //move.w #$6,$f0590 (state->m_pri n)
+ jm_mcu_code[0x8986/2] = 0x0590; //move.w #$6,$f0590 (m_pri n)
jm_mcu_code[0x8988/2] = 0x4df9;
jm_mcu_code[0x898a/2] = 0x0009;
jm_mcu_code[0x898c/2] = 0xc000; //lea.w #9c000,A6
@@ -2218,9 +2224,8 @@ static WRITE16_HANDLER( daireika_mcu_w )
}
}
-static READ16_HANDLER( mjzoomin_mcu_r )
+READ16_MEMBER(jalmah_state::mjzoomin_mcu_r)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
static const int resp[] = { 0x9c, 0xd8, 0x00,
0x2a, 0x6a, 0x00,
0x99, 0xd8, 0x00,
@@ -2232,10 +2237,10 @@ static READ16_HANDLER( mjzoomin_mcu_r )
0x21, 0x61, 0x00 };
int res;
- res = resp[state->m_respcount++];
- if (state->m_respcount >= sizeof(resp)/sizeof(resp[0])) state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (m_respcount >= sizeof(resp)/sizeof(resp[0])) m_respcount = 0;
-// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space->device()),res);
+// logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space.device()),res);
return res;
}
@@ -2243,11 +2248,10 @@ static READ16_HANDLER( mjzoomin_mcu_r )
/*
data value is REQ under mjzoomin video test menu.It is related to the MCU?
*/
-static WRITE16_HANDLER( mjzoomin_mcu_w )
+WRITE16_MEMBER(jalmah_state::mjzoomin_mcu_w)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
- UINT16 *jm_shared_ram = state->m_jm_shared_ram;
- UINT16 *jm_mcu_code = state->m_jm_mcu_code;
+ UINT16 *jm_shared_ram = m_jm_shared_ram;
+ UINT16 *jm_mcu_code = m_jm_mcu_code;
if(ACCESSING_BITS_0_7 && data)
{
/******************************************************
@@ -2357,9 +2361,8 @@ static WRITE16_HANDLER( mjzoomin_mcu_w )
}
}
-static READ16_HANDLER( kakumei_mcu_r )
+READ16_MEMBER(jalmah_state::kakumei_mcu_r)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
static const int resp[] = { 0x8a, 0xd8, 0x00,
0x3c, 0x7c, 0x00,
0x99, 0xd8, 0x00,
@@ -2371,17 +2374,16 @@ static READ16_HANDLER( kakumei_mcu_r )
0x3e, 0x7e, 0x00 };
int res;
- res = resp[state->m_respcount++];
- if (state->m_respcount >= sizeof(resp)/sizeof(resp[0])) state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (m_respcount >= sizeof(resp)/sizeof(resp[0])) m_respcount = 0;
-// popmessage("%04x: mcu_r %02x",cpu_get_pc(&space->device()),res);
+// popmessage("%04x: mcu_r %02x",cpu_get_pc(&space.device()),res);
return res;
}
-static READ16_HANDLER( suchipi_mcu_r )
+READ16_MEMBER(jalmah_state::suchipi_mcu_r)
{
- jalmah_state *state = space->machine().driver_data<jalmah_state>();
static const int resp[] = { 0x8a, 0xd8, 0x00,
0x3c, 0x7c, 0x00,
0x99, 0xd8, 0x00,
@@ -2393,10 +2395,10 @@ static READ16_HANDLER( suchipi_mcu_r )
0x3e, 0x7e, 0x00 };
int res;
- res = resp[state->m_respcount++];
- if (state->m_respcount >= sizeof(resp)/sizeof(resp[0])) state->m_respcount = 0;
+ res = resp[m_respcount++];
+ if (m_respcount >= sizeof(resp)/sizeof(resp[0])) m_respcount = 0;
-// popmessage("%04x: mcu_r %02x",cpu_get_pc(&space->device()),res);
+// popmessage("%04x: mcu_r %02x",cpu_get_pc(&space.device()),res);
return res;
}
@@ -2404,8 +2406,8 @@ static READ16_HANDLER( suchipi_mcu_r )
static DRIVER_INIT( urashima )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(urashima_mcu_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x80012, 0x80013, FUNC(urashima_mcu_w) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::urashima_mcu_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x80012, 0x80013, write16_delegate(FUNC(jalmah_state::urashima_mcu_w), state));
state->m_mcu_prg = 0x12;
}
@@ -2413,8 +2415,8 @@ static DRIVER_INIT( urashima )
static DRIVER_INIT( daireika )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(daireika_mcu_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x80012, 0x80013, FUNC(daireika_mcu_w) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::daireika_mcu_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x80012, 0x80013, write16_delegate(FUNC(jalmah_state::daireika_mcu_w), state));
state->m_mcu_prg = 0x11;
}
@@ -2422,8 +2424,8 @@ static DRIVER_INIT( daireika )
static DRIVER_INIT( mjzoomin )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(mjzoomin_mcu_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x80012, 0x80013, FUNC(mjzoomin_mcu_w) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::mjzoomin_mcu_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x80012, 0x80013, write16_delegate(FUNC(jalmah_state::mjzoomin_mcu_w), state));
state->m_mcu_prg = 0x13;
}
@@ -2431,15 +2433,14 @@ static DRIVER_INIT( mjzoomin )
static DRIVER_INIT( kakumei )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(kakumei_mcu_r) );
-
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::kakumei_mcu_r), state));
state->m_mcu_prg = 0x21;
}
static DRIVER_INIT( kakumei2 )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(kakumei_mcu_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::kakumei_mcu_r), state));
state->m_mcu_prg = 0x22;
}
@@ -2447,7 +2448,7 @@ static DRIVER_INIT( kakumei2 )
static DRIVER_INIT( suchipi )
{
jalmah_state *state = machine.driver_data<jalmah_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80004, 0x80005, FUNC(suchipi_mcu_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x80004, 0x80005, read16_delegate(FUNC(jalmah_state::suchipi_mcu_r), state));
state->m_mcu_prg = 0x23;
}
diff --git a/src/mame/drivers/jangou.c b/src/mame/drivers/jangou.c
index b3e97d2f5c8..9a5128e6a1a 100644
--- a/src/mame/drivers/jangou.c
+++ b/src/mame/drivers/jangou.c
@@ -64,6 +64,19 @@ public:
UINT8 m_pen_data[0x10];
UINT8 m_blit_data[6];
UINT8 m_blit_buffer[256 * 256];
+ DECLARE_WRITE8_MEMBER(blitter_process_w);
+ DECLARE_WRITE8_MEMBER(blit_vregs_w);
+ DECLARE_WRITE8_MEMBER(mux_w);
+ DECLARE_WRITE8_MEMBER(output_w);
+ DECLARE_WRITE8_MEMBER(sound_latch_w);
+ DECLARE_READ8_MEMBER(sound_latch_r);
+ DECLARE_WRITE8_MEMBER(cvsd_w);
+ DECLARE_WRITE8_MEMBER(adpcm_w);
+ DECLARE_READ8_MEMBER(master_com_r);
+ DECLARE_WRITE8_MEMBER(master_com_w);
+ DECLARE_READ8_MEMBER(slave_com_r);
+ DECLARE_WRITE8_MEMBER(slave_com_w);
+ DECLARE_READ8_MEMBER(jngolady_rng_r);
};
@@ -176,27 +189,26 @@ static void plot_jangou_gfx_pixel( running_machine &machine, UINT8 pix, int x, i
state->m_blit_buffer[(y * 256) + (x >> 1)] = (state->m_blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f);
}
-static WRITE8_HANDLER( blitter_process_w )
+WRITE8_MEMBER(jangou_state::blitter_process_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
int src, x, y, h, w, flipx;
- state->m_blit_data[offset] = data;
+ m_blit_data[offset] = data;
if (offset == 5)
{
int count = 0;
int xcount, ycount;
- /* printf("%02x %02x %02x %02x %02x %02x\n", state->m_blit_data[0], state->m_blit_data[1], state->m_blit_data[2],
- state->m_blit_data[3], state->m_blit_data[4], state->m_blit_data[5]); */
- w = (state->m_blit_data[4] & 0xff) + 1;
- h = (state->m_blit_data[5] & 0xff) + 1;
- src = ((state->m_blit_data[1] << 8)|(state->m_blit_data[0] << 0));
- x = (state->m_blit_data[2] & 0xff);
- y = (state->m_blit_data[3] & 0xff);
+ /* printf("%02x %02x %02x %02x %02x %02x\n", m_blit_data[0], m_blit_data[1], m_blit_data[2],
+ m_blit_data[3], m_blit_data[4], m_blit_data[5]); */
+ w = (m_blit_data[4] & 0xff) + 1;
+ h = (m_blit_data[5] & 0xff) + 1;
+ src = ((m_blit_data[1] << 8)|(m_blit_data[0] << 0));
+ x = (m_blit_data[2] & 0xff);
+ y = (m_blit_data[3] & 0xff);
// lowest bit of src controls flipping / draw direction?
- flipx = (state->m_blit_data[0] & 1);
+ flipx = (m_blit_data[0] & 1);
if (!flipx)
src += (w * h) - 1;
@@ -209,14 +221,14 @@ static WRITE8_HANDLER( blitter_process_w )
{
int drawx = (x + xcount) & 0xff;
int drawy = (y + ycount) & 0xff;
- UINT8 dat = jangou_gfx_nibble(space->machine(), src + count);
- UINT8 cur_pen_hi = state->m_pen_data[(dat & 0xf0) >> 4];
- UINT8 cur_pen_lo = state->m_pen_data[(dat & 0x0f) >> 0];
+ UINT8 dat = jangou_gfx_nibble(machine(), src + count);
+ UINT8 cur_pen_hi = m_pen_data[(dat & 0xf0) >> 4];
+ UINT8 cur_pen_lo = m_pen_data[(dat & 0x0f) >> 0];
dat = cur_pen_lo | (cur_pen_hi << 4);
if ((dat & 0xff) != 0)
- plot_jangou_gfx_pixel(space->machine(), dat, drawx, drawy);
+ plot_jangou_gfx_pixel(machine(), dat, drawx, drawy);
if (!flipx)
count--;
@@ -228,12 +240,11 @@ static WRITE8_HANDLER( blitter_process_w )
}
/* What is the bit 5 (0x20) for?*/
-static WRITE8_HANDLER( blit_vregs_w )
+WRITE8_MEMBER(jangou_state::blit_vregs_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
// printf("%02x %02x\n", offset, data);
- state->m_pen_data[offset] = data & 0xf;
+ m_pen_data[offset] = data & 0xf;
}
/*************************************
@@ -242,13 +253,12 @@ static WRITE8_HANDLER( blit_vregs_w )
*
*************************************/
-static WRITE8_HANDLER( mux_w )
+WRITE8_MEMBER(jangou_state::mux_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- state->m_mux_data = ~data;
+ m_mux_data = ~data;
}
-static WRITE8_HANDLER( output_w )
+WRITE8_MEMBER(jangou_state::output_w)
{
/*
--x- ---- ? (polls between high and low in irq routine,probably signals the vblank routine)
@@ -256,9 +266,9 @@ static WRITE8_HANDLER( output_w )
---- ---x coin counter
*/
// printf("%02x\n", data);
- coin_counter_w(space->machine(), 0, data & 0x01);
+ coin_counter_w(machine(), 0, data & 0x01);
// flip_screen_set(data & 0x04);
-// coin_lockout_w(space->machine(), 0, ~data & 0x20);
+// coin_lockout_w(machine(), 0, ~data & 0x20);
}
static READ8_DEVICE_HANDLER( input_mux_r )
@@ -289,25 +299,22 @@ static READ8_DEVICE_HANDLER( input_system_r )
*
*************************************/
-static WRITE8_HANDLER( sound_latch_w )
+WRITE8_MEMBER(jangou_state::sound_latch_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
soundlatch_w(space, 0, data & 0xff);
- device_set_input_line(state->m_cpu_1, INPUT_LINE_NMI, ASSERT_LINE);
+ device_set_input_line(m_cpu_1, INPUT_LINE_NMI, ASSERT_LINE);
}
-static READ8_HANDLER( sound_latch_r )
+READ8_MEMBER(jangou_state::sound_latch_r)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- device_set_input_line(state->m_cpu_1, INPUT_LINE_NMI, CLEAR_LINE);
+ device_set_input_line(m_cpu_1, INPUT_LINE_NMI, CLEAR_LINE);
return soundlatch_r(space, 0);
}
/* Jangou HC-55516 CVSD */
-static WRITE8_HANDLER( cvsd_w )
+WRITE8_MEMBER(jangou_state::cvsd_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- state->m_cvsd_shiftreg = data;
+ m_cvsd_shiftreg = data;
}
static TIMER_CALLBACK( cvsd_bit_timer_callback )
@@ -325,10 +332,9 @@ static TIMER_CALLBACK( cvsd_bit_timer_callback )
/* Jangou Lady MSM5218 (MSM5205-compatible) ADPCM */
-static WRITE8_HANDLER( adpcm_w )
+WRITE8_MEMBER(jangou_state::adpcm_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- state->m_adpcm_byte = data;
+ m_adpcm_byte = data;
}
static void jngolady_vclk_cb( device_t *device )
@@ -353,30 +359,26 @@ static void jngolady_vclk_cb( device_t *device )
*
*************************************/
-static READ8_HANDLER( master_com_r )
+READ8_MEMBER(jangou_state::master_com_r)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- return state->m_z80_latch;
+ return m_z80_latch;
}
-static WRITE8_HANDLER( master_com_w )
+WRITE8_MEMBER(jangou_state::master_com_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- device_set_input_line(state->m_nsc, 0, HOLD_LINE);
- state->m_nsc_latch = data;
+ device_set_input_line(m_nsc, 0, HOLD_LINE);
+ m_nsc_latch = data;
}
-static READ8_HANDLER( slave_com_r )
+READ8_MEMBER(jangou_state::slave_com_r)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- return state->m_nsc_latch;
+ return m_nsc_latch;
}
-static WRITE8_HANDLER( slave_com_w )
+WRITE8_MEMBER(jangou_state::slave_com_w)
{
- jangou_state *state = space->machine().driver_data<jangou_state>();
- state->m_z80_latch = data;
+ m_z80_latch = data;
}
/*************************************
@@ -395,12 +397,12 @@ static ADDRESS_MAP_START( cpu0_io, AS_IO, 8, jangou_state )
AM_RANGE(0x01,0x01) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x02,0x03) AM_DEVWRITE_LEGACY("aysnd", ay8910_data_address_w)
AM_RANGE(0x10,0x10) AM_READ_PORT("DSW") //dsw + blitter busy flag
- AM_RANGE(0x10,0x10) AM_WRITE_LEGACY(output_w)
- AM_RANGE(0x11,0x11) AM_WRITE_LEGACY(mux_w)
- AM_RANGE(0x12,0x17) AM_WRITE_LEGACY(blitter_process_w)
- AM_RANGE(0x20,0x2f) AM_WRITE_LEGACY(blit_vregs_w)
+ AM_RANGE(0x10,0x10) AM_WRITE(output_w)
+ AM_RANGE(0x11,0x11) AM_WRITE(mux_w)
+ AM_RANGE(0x12,0x17) AM_WRITE(blitter_process_w)
+ AM_RANGE(0x20,0x2f) AM_WRITE(blit_vregs_w)
AM_RANGE(0x30,0x30) AM_WRITENOP //? polls 0x03 continuously
- AM_RANGE(0x31,0x31) AM_WRITE_LEGACY(sound_latch_w)
+ AM_RANGE(0x31,0x31) AM_WRITE(sound_latch_w)
ADDRESS_MAP_END
@@ -410,8 +412,8 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( cpu1_io, AS_IO, 8, jangou_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00,0x00) AM_READ_LEGACY(sound_latch_r)
- AM_RANGE(0x01,0x01) AM_WRITE_LEGACY(cvsd_w)
+ AM_RANGE(0x00,0x00) AM_READ(sound_latch_r)
+ AM_RANGE(0x01,0x01) AM_WRITE(cvsd_w)
AM_RANGE(0x02,0x02) AM_WRITENOP // Echoes sound command - acknowledge?
ADDRESS_MAP_END
@@ -425,7 +427,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( jngolady_cpu0_map, AS_PROGRAM, 8, jangou_state )
AM_RANGE(0x0000, 0x9fff) AM_ROM
AM_RANGE(0xc000, 0xc7ff) AM_RAM AM_SHARE("share1")
- AM_RANGE(0xe000, 0xe000) AM_READWRITE_LEGACY(master_com_r,master_com_w)
+ AM_RANGE(0xe000, 0xe000) AM_READWRITE(master_com_r,master_com_w)
ADDRESS_MAP_END
@@ -435,8 +437,8 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( jngolady_cpu1_io, AS_IO, 8, jangou_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00,0x00) AM_READ_LEGACY(sound_latch_r)
- AM_RANGE(0x01,0x01) AM_WRITE_LEGACY(adpcm_w)
+ AM_RANGE(0x00,0x00) AM_READ(sound_latch_r)
+ AM_RANGE(0x01,0x01) AM_WRITE(adpcm_w)
AM_RANGE(0x02,0x02) AM_WRITENOP
ADDRESS_MAP_END
@@ -444,7 +446,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( nsc_map, AS_PROGRAM, 8, jangou_state )
AM_RANGE(0x0000, 0x007f) AM_RAM //internal ram for irq etc.
AM_RANGE(0x8000, 0x8000) AM_WRITENOP //write-only,irq related?
- AM_RANGE(0x9000, 0x9000) AM_READWRITE_LEGACY(slave_com_r,slave_com_w)
+ AM_RANGE(0x9000, 0x9000) AM_READWRITE(slave_com_r,slave_com_w)
AM_RANGE(0xc000, 0xc7ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0xf000, 0xffff) AM_ROM
ADDRESS_MAP_END
@@ -466,12 +468,12 @@ static ADDRESS_MAP_START( cntrygrl_cpu0_io, AS_IO, 8, jangou_state )
AM_RANGE(0x01,0x01) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x02,0x03) AM_DEVWRITE_LEGACY("aysnd", ay8910_data_address_w)
AM_RANGE(0x10,0x10) AM_READ_PORT("DSW") //dsw + blitter busy flag
- AM_RANGE(0x10,0x10) AM_WRITE_LEGACY(output_w)
- AM_RANGE(0x11,0x11) AM_WRITE_LEGACY(mux_w)
- AM_RANGE(0x12,0x17) AM_WRITE_LEGACY(blitter_process_w)
- AM_RANGE(0x20,0x2f) AM_WRITE_LEGACY(blit_vregs_w )
+ AM_RANGE(0x10,0x10) AM_WRITE(output_w)
+ AM_RANGE(0x11,0x11) AM_WRITE(mux_w)
+ AM_RANGE(0x12,0x17) AM_WRITE(blitter_process_w)
+ AM_RANGE(0x20,0x2f) AM_WRITE(blit_vregs_w )
AM_RANGE(0x30,0x30) AM_WRITENOP //? polls 0x03 continuously
-// AM_RANGE(0x31,0x31) AM_WRITE_LEGACY(sound_latch_w)
+// AM_RANGE(0x31,0x31) AM_WRITE(sound_latch_w)
ADDRESS_MAP_END
/*************************************
@@ -491,10 +493,10 @@ static ADDRESS_MAP_START( roylcrdn_cpu0_io, AS_IO, 8, jangou_state )
AM_RANGE(0x02,0x03) AM_DEVWRITE_LEGACY("aysnd", ay8910_data_address_w)
AM_RANGE(0x10,0x10) AM_READ_PORT("DSW") /* DSW + blitter busy flag */
AM_RANGE(0x10,0x10) AM_WRITENOP /* Writes continuosly 0's in attract mode, and 1's in game */
- AM_RANGE(0x11,0x11) AM_WRITE_LEGACY(mux_w)
+ AM_RANGE(0x11,0x11) AM_WRITE(mux_w)
AM_RANGE(0x13,0x13) AM_READNOP /* Often reads bit7 with unknown purposes */
- AM_RANGE(0x12,0x17) AM_WRITE_LEGACY(blitter_process_w)
- AM_RANGE(0x20,0x2f) AM_WRITE_LEGACY(blit_vregs_w)
+ AM_RANGE(0x12,0x17) AM_WRITE(blitter_process_w)
+ AM_RANGE(0x20,0x2f) AM_WRITE(blit_vregs_w)
AM_RANGE(0x30,0x30) AM_WRITENOP /* Seems to write 0x10 on each sound event */
ADDRESS_MAP_END
@@ -1353,14 +1355,15 @@ ROM_END
*************************************/
/*Temporary kludge for make the RNG work*/
-static READ8_HANDLER( jngolady_rng_r )
+READ8_MEMBER(jangou_state::jngolady_rng_r)
{
- return space->machine().rand();
+ return machine().rand();
}
static DRIVER_INIT( jngolady )
{
- machine.device("nsc")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x08, 0x08, FUNC(jngolady_rng_r) );
+ jangou_state *state = machine.driver_data<jangou_state>();
+ machine.device("nsc")->memory().space(AS_PROGRAM)->install_read_handler(0x08, 0x08, read8_delegate(FUNC(jangou_state::jngolady_rng_r),state) );
}
static DRIVER_INIT (luckygrl)
diff --git a/src/mame/drivers/limenko.c b/src/mame/drivers/limenko.c
index 82d76407444..2e1412b3a5f 100644
--- a/src/mame/drivers/limenko.c
+++ b/src/mame/drivers/limenko.c
@@ -52,6 +52,20 @@ public:
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(limenko_paletteram_w);
+ DECLARE_WRITE32_MEMBER(bg_videoram_w);
+ DECLARE_WRITE32_MEMBER(md_videoram_w);
+ DECLARE_WRITE32_MEMBER(fg_videoram_w);
+ DECLARE_WRITE32_MEMBER(spotty_soundlatch_w);
+ DECLARE_WRITE32_MEMBER(spriteram_buffer_w);
+ DECLARE_WRITE8_MEMBER(spotty_sound_cmd_w);
+ DECLARE_READ8_MEMBER(spotty_sound_cmd_r);
+ DECLARE_READ8_MEMBER(spotty_sound_r);
+ DECLARE_READ32_MEMBER(dynabomb_speedup_r);
+ DECLARE_READ32_MEMBER(legendoh_speedup_r);
+ DECLARE_READ32_MEMBER(sb2003_speedup_r);
+ DECLARE_READ32_MEMBER(spotty_speedup_r);
};
@@ -61,51 +75,48 @@ static void draw_sprites(running_machine &machine, UINT32 *sprites, const rectan
MISC FUNCTIONS
*****************************************************************************************************/
-static WRITE32_HANDLER( limenko_coincounter_w )
+WRITE32_MEMBER(limenko_state::limenko_coincounter_w)
{
- coin_counter_w(space->machine(),0,data & 0x10000);
+ coin_counter_w(machine(),0,data & 0x10000);
}
-static WRITE32_HANDLER( limenko_paletteram_w )
+WRITE32_MEMBER(limenko_state::limenko_paletteram_w)
{
UINT16 paldata;
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
if(ACCESSING_BITS_0_15)
{
- paldata = space->machine().generic.paletteram.u32[offset] & 0x7fff;
- palette_set_color_rgb(space->machine(), offset * 2 + 1, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
+ paldata = machine().generic.paletteram.u32[offset] & 0x7fff;
+ palette_set_color_rgb(machine(), offset * 2 + 1, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
}
if(ACCESSING_BITS_16_31)
{
- paldata = (space->machine().generic.paletteram.u32[offset] >> 16) & 0x7fff;
- palette_set_color_rgb(space->machine(), offset * 2 + 0, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
+ paldata = (machine().generic.paletteram.u32[offset] >> 16) & 0x7fff;
+ palette_set_color_rgb(machine(), offset * 2 + 0, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
}
}
-static WRITE32_HANDLER( bg_videoram_w )
+WRITE32_MEMBER(limenko_state::bg_videoram_w)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- COMBINE_DATA(&state->m_bg_videoram[offset]);
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_bg_videoram[offset]);
+ m_bg_tilemap->mark_tile_dirty(offset);
}
-static WRITE32_HANDLER( md_videoram_w )
+WRITE32_MEMBER(limenko_state::md_videoram_w)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- COMBINE_DATA(&state->m_md_videoram[offset]);
- state->m_md_tilemap->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_md_videoram[offset]);
+ m_md_tilemap->mark_tile_dirty(offset);
}
-static WRITE32_HANDLER( fg_videoram_w )
+WRITE32_MEMBER(limenko_state::fg_videoram_w)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- COMBINE_DATA(&state->m_fg_videoram[offset]);
- state->m_fg_tilemap->mark_tile_dirty(offset);
+ COMBINE_DATA(&m_fg_videoram[offset]);
+ m_fg_tilemap->mark_tile_dirty(offset);
}
-static WRITE32_HANDLER( spotty_soundlatch_w )
+WRITE32_MEMBER(limenko_state::spotty_soundlatch_w)
{
soundlatch_w(space, 0, (data >> 16) & 0xff);
}
@@ -116,30 +127,29 @@ static CUSTOM_INPUT( spriteram_bit_r )
return state->m_spriteram_bit;
}
-static WRITE32_HANDLER( spriteram_buffer_w )
+WRITE32_MEMBER(limenko_state::spriteram_buffer_w)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
rectangle clip(0, 383, 0, 239);
- state->m_sprites_bitmap_pri.fill(0, clip);
- state->m_sprites_bitmap.fill(0, clip);
+ m_sprites_bitmap_pri.fill(0, clip);
+ m_sprites_bitmap.fill(0, clip);
// toggle spriterams location in the memory map
- state->m_spriteram_bit ^= 1;
+ m_spriteram_bit ^= 1;
- if(state->m_spriteram_bit)
+ if(m_spriteram_bit)
{
// draw the sprites to the frame buffer
- draw_sprites(space->machine(),state->m_spriteram2,clip,state->m_prev_sprites_count);
+ draw_sprites(machine(),m_spriteram2,clip,m_prev_sprites_count);
}
else
{
// draw the sprites to the frame buffer
- draw_sprites(space->machine(),state->m_spriteram,clip,state->m_prev_sprites_count);
+ draw_sprites(machine(),m_spriteram,clip,m_prev_sprites_count);
}
// buffer the next number of sprites to draw
- state->m_prev_sprites_count = (state->m_videoreg[0] & 0x1ff0000) >> 16;
+ m_prev_sprites_count = (m_videoreg[0] & 0x1ff0000) >> 16;
}
/*****************************************************************************************************
@@ -149,15 +159,15 @@ static WRITE32_HANDLER( spriteram_buffer_w )
static ADDRESS_MAP_START( limenko_map, AS_PROGRAM, 32, limenko_state )
AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE(m_mainram)
AM_RANGE(0x40000000, 0x403fffff) AM_ROM AM_REGION("user2",0)
- AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE_LEGACY(fg_videoram_w) AM_BASE(m_fg_videoram)
- AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE_LEGACY(md_videoram_w) AM_BASE(m_md_videoram)
- AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE_LEGACY(bg_videoram_w) AM_BASE(m_bg_videoram)
+ AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_BASE(m_fg_videoram)
+ AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_BASE(m_md_videoram)
+ AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_BASE(m_bg_videoram)
AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_BASE_SIZE(m_spriteram, m_spriteram_size)
AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_BASE(m_spriteram2)
- AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE_LEGACY(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x8001e000, 0x8001ebff) AM_RAM // ? not used
AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_BASE(m_videoreg)
- AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE_LEGACY(spriteram_buffer_w)
+ AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE(spriteram_buffer_w)
AM_RANGE(0xffe00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
ADDRESS_MAP_END
@@ -165,7 +175,7 @@ static ADDRESS_MAP_START( limenko_io_map, AS_IO, 32, limenko_state )
AM_RANGE(0x0000, 0x0003) AM_READ_PORT("IN0")
AM_RANGE(0x0800, 0x0803) AM_READ_PORT("IN1")
AM_RANGE(0x1000, 0x1003) AM_READ_PORT("IN2")
- AM_RANGE(0x4000, 0x4003) AM_WRITE_LEGACY(limenko_coincounter_w)
+ AM_RANGE(0x4000, 0x4003) AM_WRITE(limenko_coincounter_w)
AM_RANGE(0x4800, 0x4803) AM_WRITE_PORT("EEPROMOUT")
AM_RANGE(0x5000, 0x5003) AM_WRITENOP // sound latch
ADDRESS_MAP_END
@@ -176,15 +186,15 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( spotty_map, AS_PROGRAM, 32, limenko_state )
AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE(m_mainram)
AM_RANGE(0x40002000, 0x400024d3) AM_RAM //?
- AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE_LEGACY(fg_videoram_w) AM_BASE(m_fg_videoram)
- AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE_LEGACY(md_videoram_w) AM_BASE(m_md_videoram)
- AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE_LEGACY(bg_videoram_w) AM_BASE(m_bg_videoram)
+ AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_BASE(m_fg_videoram)
+ AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_BASE(m_md_videoram)
+ AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_BASE(m_bg_videoram)
AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_BASE_SIZE(m_spriteram, m_spriteram_size)
AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_BASE(m_spriteram2)
- AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE_LEGACY(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x8001e000, 0x8001ebff) AM_RAM // ? not used
AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_BASE(m_videoreg)
- AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE_LEGACY(spriteram_buffer_w)
+ AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE(spriteram_buffer_w)
AM_RANGE(0xfff00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
ADDRESS_MAP_END
@@ -194,34 +204,32 @@ static ADDRESS_MAP_START( spotty_io_map, AS_IO, 32, limenko_state )
AM_RANGE(0x0800, 0x0803) AM_WRITENOP // hopper related
AM_RANGE(0x1000, 0x1003) AM_READ_PORT("IN2")
AM_RANGE(0x4800, 0x4803) AM_WRITE_PORT("EEPROMOUT")
- AM_RANGE(0x5000, 0x5003) AM_WRITE_LEGACY(spotty_soundlatch_w)
+ AM_RANGE(0x5000, 0x5003) AM_WRITE(spotty_soundlatch_w)
ADDRESS_MAP_END
-static WRITE8_HANDLER( spotty_sound_cmd_w )
+WRITE8_MEMBER(limenko_state::spotty_sound_cmd_w)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- state->m_spotty_sound_cmd = data;
+ m_spotty_sound_cmd = data;
}
-static READ8_HANDLER( spotty_sound_cmd_r )
+READ8_MEMBER(limenko_state::spotty_sound_cmd_r)
{
return 0; //??? some status bit? if set it executes a jump in the code
}
-static READ8_HANDLER( spotty_sound_r )
+READ8_MEMBER(limenko_state::spotty_sound_r)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- // check state->m_spotty_sound_cmd bits...
+ // check m_spotty_sound_cmd bits...
- if(state->m_spotty_sound_cmd == 0xf7)
+ if(m_spotty_sound_cmd == 0xf7)
return soundlatch_r(space,0);
else
- return space->machine().device<okim6295_device>("oki")->read(*space,0);
+ return machine().device<okim6295_device>("oki")->read(*&space,0);
}
static ADDRESS_MAP_START( spotty_sound_io_map, AS_IO, 8, limenko_state )
- AM_RANGE(MCS51_PORT_P1, MCS51_PORT_P1) AM_READ_LEGACY(spotty_sound_r) AM_DEVWRITE("oki", okim6295_device, write) //? sound latch and ?
- AM_RANGE(MCS51_PORT_P3, MCS51_PORT_P3) AM_READWRITE_LEGACY(spotty_sound_cmd_r, spotty_sound_cmd_w) //not sure about anything...
+ AM_RANGE(MCS51_PORT_P1, MCS51_PORT_P1) AM_READ(spotty_sound_r) AM_DEVWRITE("oki", okim6295_device, write) //? sound latch and ?
+ AM_RANGE(MCS51_PORT_P3, MCS51_PORT_P3) AM_READWRITE(spotty_sound_cmd_r, spotty_sound_cmd_w) //not sure about anything...
ADDRESS_MAP_END
/*****************************************************************************************************
@@ -985,54 +993,50 @@ ROM_END
-static READ32_HANDLER( dynabomb_speedup_r )
+READ32_MEMBER(limenko_state::dynabomb_speedup_r)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- if(space->machine().firstcpu->pc() == 0xc25b8)
+ if(machine().firstcpu->pc() == 0xc25b8)
{
- space->machine().firstcpu->eat_cycles(50);
+ machine().firstcpu->eat_cycles(50);
}
- return state->m_mainram[0xe2784/4];
+ return m_mainram[0xe2784/4];
}
-static READ32_HANDLER( legendoh_speedup_r )
+READ32_MEMBER(limenko_state::legendoh_speedup_r)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- if(space->machine().firstcpu->pc() == 0x23e32)
+ if(machine().firstcpu->pc() == 0x23e32)
{
- space->machine().firstcpu->eat_cycles(50);
+ machine().firstcpu->eat_cycles(50);
}
- return state->m_mainram[0x32ab0/4];
+ return m_mainram[0x32ab0/4];
}
-static READ32_HANDLER( sb2003_speedup_r )
+READ32_MEMBER(limenko_state::sb2003_speedup_r)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- if(space->machine().firstcpu->pc() == 0x26da4)
+ if(machine().firstcpu->pc() == 0x26da4)
{
- space->machine().firstcpu->eat_cycles(50);
+ machine().firstcpu->eat_cycles(50);
}
- return state->m_mainram[0x135800/4];
+ return m_mainram[0x135800/4];
}
-static READ32_HANDLER( spotty_speedup_r )
+READ32_MEMBER(limenko_state::spotty_speedup_r)
{
- limenko_state *state = space->machine().driver_data<limenko_state>();
- if(space->machine().firstcpu->pc() == 0x8560)
+ if(machine().firstcpu->pc() == 0x8560)
{
- space->machine().firstcpu->eat_cycles(50);
+ machine().firstcpu->eat_cycles(50);
}
- return state->m_mainram[0x6626c/4];
+ return m_mainram[0x6626c/4];
}
static DRIVER_INIT( dynabomb )
{
limenko_state *state = machine.driver_data<limenko_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xe2784, 0xe2787, FUNC(dynabomb_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xe2784, 0xe2787, read32_delegate(FUNC(limenko_state::dynabomb_speedup_r), state));
state->m_spriteram_bit = 1;
}
@@ -1040,7 +1044,7 @@ static DRIVER_INIT( dynabomb )
static DRIVER_INIT( legendoh )
{
limenko_state *state = machine.driver_data<limenko_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x32ab0, 0x32ab3, FUNC(legendoh_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x32ab0, 0x32ab3, read32_delegate(FUNC(limenko_state::legendoh_speedup_r), state));
state->m_spriteram_bit = 1;
}
@@ -1048,7 +1052,7 @@ static DRIVER_INIT( legendoh )
static DRIVER_INIT( sb2003 )
{
limenko_state *state = machine.driver_data<limenko_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x135800, 0x135803, FUNC(sb2003_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x135800, 0x135803, read32_delegate(FUNC(limenko_state::sb2003_speedup_r), state));
state->m_spriteram_bit = 1;
}
@@ -1069,7 +1073,7 @@ static DRIVER_INIT( spotty )
dst[x+2] = (src[x+1]&0x0f) >> 0;
}
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x6626c, 0x6626f, FUNC(spotty_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x6626c, 0x6626f, read32_delegate(FUNC(limenko_state::spotty_speedup_r), state));
state->m_spriteram_bit = 1;
}
diff --git a/src/mame/drivers/looping.c b/src/mame/drivers/looping.c
index 41e5b94e7f1..964e2f22f41 100644
--- a/src/mame/drivers/looping.c
+++ b/src/mame/drivers/looping.c
@@ -113,6 +113,23 @@ public:
UINT8 m_sound[8];
int m_last;
+ DECLARE_WRITE8_MEMBER(flip_screen_x_w);
+ DECLARE_WRITE8_MEMBER(flip_screen_y_w);
+ DECLARE_WRITE8_MEMBER(looping_videoram_w);
+ DECLARE_WRITE8_MEMBER(looping_colorram_w);
+ DECLARE_WRITE8_MEMBER(level2_irq_set);
+ DECLARE_WRITE8_MEMBER(main_irq_ack_w);
+ DECLARE_WRITE8_MEMBER(looping_souint_clr);
+ DECLARE_WRITE8_MEMBER(looping_soundlatch_w);
+ DECLARE_WRITE8_MEMBER(ballon_enable_w);
+ DECLARE_WRITE8_MEMBER(out_0_w);
+ DECLARE_WRITE8_MEMBER(out_2_w);
+ DECLARE_READ8_MEMBER(adc_r);
+ DECLARE_WRITE8_MEMBER(adc_w);
+ DECLARE_WRITE8_MEMBER(plr2_w);
+ DECLARE_READ8_MEMBER(cop_io_r);
+ DECLARE_WRITE8_MEMBER(cop_io_w);
+ DECLARE_READ8_MEMBER(protection_r);
};
@@ -195,36 +212,32 @@ static VIDEO_START( looping )
*
*************************************/
-static WRITE8_HANDLER( flip_screen_x_w )
+WRITE8_MEMBER(looping_state::flip_screen_x_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
- flip_screen_x_set(space->machine(), ~data & 0x01);
- state->m_bg_tilemap->set_scrollx(0, flip_screen_get(space->machine()) ? 128 : 0);
+ flip_screen_x_set(machine(), ~data & 0x01);
+ m_bg_tilemap->set_scrollx(0, flip_screen_get(machine()) ? 128 : 0);
}
-static WRITE8_HANDLER( flip_screen_y_w )
+WRITE8_MEMBER(looping_state::flip_screen_y_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
- flip_screen_y_set(space->machine(), ~data & 0x01);
- state->m_bg_tilemap->set_scrollx(0, flip_screen_get(space->machine()) ? 128 : 0);
+ flip_screen_y_set(machine(), ~data & 0x01);
+ m_bg_tilemap->set_scrollx(0, flip_screen_get(machine()) ? 128 : 0);
}
-static WRITE8_HANDLER( looping_videoram_w )
+WRITE8_MEMBER(looping_state::looping_videoram_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
- state->m_videoram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_videoram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( looping_colorram_w )
+WRITE8_MEMBER(looping_state::looping_colorram_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
int i;
- state->m_colorram[offset] = data;
+ m_colorram[offset] = data;
/* odd bytes are column color attribute */
if (offset & 1)
@@ -232,12 +245,12 @@ static WRITE8_HANDLER( looping_colorram_w )
/* mark the whole column dirty */
offs_t offs = (offset/2);
for (i = 0; i < 0x20; i++)
- state->m_bg_tilemap->mark_tile_dirty(i * 0x20 + offs);
+ m_bg_tilemap->mark_tile_dirty(i * 0x20 + offs);
}
/* even bytes are column scroll */
else
- state->m_bg_tilemap->set_scrolly(offset/2, data);
+ m_bg_tilemap->set_scrolly(offset/2, data);
}
@@ -316,24 +329,24 @@ static INTERRUPT_GEN( looping_interrupt )
}
-static WRITE8_HANDLER( level2_irq_set )
+WRITE8_MEMBER(looping_state::level2_irq_set)
{
if (!(data & 1))
- cputag_set_input_line_and_vector(space->machine(), "maincpu", 0, ASSERT_LINE, 4);
+ cputag_set_input_line_and_vector(machine(), "maincpu", 0, ASSERT_LINE, 4);
}
-static WRITE8_HANDLER( main_irq_ack_w )
+WRITE8_MEMBER(looping_state::main_irq_ack_w)
{
if (data == 0)
- cputag_set_input_line(space->machine(), "maincpu", 0, CLEAR_LINE);
+ cputag_set_input_line(machine(), "maincpu", 0, CLEAR_LINE);
}
-static WRITE8_HANDLER( looping_souint_clr )
+WRITE8_MEMBER(looping_state::looping_souint_clr)
{
if (data == 0)
- cputag_set_input_line(space->machine(), "audiocpu", 0, CLEAR_LINE);
+ cputag_set_input_line(machine(), "audiocpu", 0, CLEAR_LINE);
}
@@ -343,10 +356,10 @@ static WRITE_LINE_DEVICE_HANDLER( looping_spcint )
}
-static WRITE8_HANDLER( looping_soundlatch_w )
+WRITE8_MEMBER(looping_state::looping_soundlatch_w)
{
soundlatch_w(space, offset, data);
- cputag_set_input_line_and_vector(space->machine(), "audiocpu", 0, ASSERT_LINE, 4);
+ cputag_set_input_line_and_vector(machine(), "audiocpu", 0, ASSERT_LINE, 4);
}
@@ -402,12 +415,11 @@ static WRITE8_DEVICE_HANDLER( speech_enable_w )
}
-static WRITE8_HANDLER( ballon_enable_w )
+WRITE8_MEMBER(looping_state::ballon_enable_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
- if (state->m_last != data)
+ if (m_last != data)
mame_printf_debug("ballon_enable_w = %d\n", data);
- state->m_last = data;
+ m_last = data;
}
@@ -418,13 +430,13 @@ static WRITE8_HANDLER( ballon_enable_w )
*
*************************************/
-static WRITE8_HANDLER( out_0_w ) { mame_printf_debug("out0 = %02X\n", data); }
-static WRITE8_HANDLER( out_2_w ) { mame_printf_debug("out2 = %02X\n", data); }
+WRITE8_MEMBER(looping_state::out_0_w){ mame_printf_debug("out0 = %02X\n", data); }
+WRITE8_MEMBER(looping_state::out_2_w){ mame_printf_debug("out2 = %02X\n", data); }
-static READ8_HANDLER( adc_r ) { mame_printf_debug("%04X:ADC read\n", cpu_get_pc(&space->device())); return 0xff; }
-static WRITE8_HANDLER( adc_w ) { mame_printf_debug("%04X:ADC write = %02X\n", cpu_get_pc(&space->device()), data); }
+READ8_MEMBER(looping_state::adc_r){ mame_printf_debug("%04X:ADC read\n", cpu_get_pc(&space.device())); return 0xff; }
+WRITE8_MEMBER(looping_state::adc_w){ mame_printf_debug("%04X:ADC write = %02X\n", cpu_get_pc(&space.device()), data); }
-static WRITE8_HANDLER( plr2_w )
+WRITE8_MEMBER(looping_state::plr2_w)
{
/* set to 1 after IDLE, cleared to 0 during processing */
/* is this an LED on the PCB? */
@@ -438,23 +450,20 @@ static WRITE8_HANDLER( plr2_w )
*
*************************************/
-static READ8_HANDLER( cop_io_r )
+READ8_MEMBER(looping_state::cop_io_r)
{
- //looping_state *state = space->machine().driver_data<looping_state>();
- // if (offset == 1) return space->machine().rand() & 0x01;
- return 1; // state->m_cop_io[offset];
+ // if (offset == 1) return machine().rand() & 0x01;
+ return 1; // m_cop_io[offset];
}
-static WRITE8_HANDLER( cop_io_w )
+WRITE8_MEMBER(looping_state::cop_io_w)
{
- looping_state *state = space->machine().driver_data<looping_state>();
- state->m_cop_io[offset] = data;
+ m_cop_io[offset] = data;
if (offset == 0) logerror("%02x ",data);
}
-static READ8_HANDLER( protection_r )
+READ8_MEMBER(looping_state::protection_r)
{
- looping_state *state = space->machine().driver_data<looping_state>();
// The code reads ($7002) ($7004) alternately
// The result must change at least once every 10 reads
// A read from ($34b0 + result) must == $01
@@ -473,7 +482,7 @@ static READ8_HANDLER( protection_r )
// cop write randomly fc (unfortunatly) but 61,67,b7,bf,db,e1,f3,fd,ff too and only these values
// missing something
- if(state->m_cop_io[0] != 0xfc) return state->m_cop_io[0];
+ if(m_cop_io[0] != 0xfc) return m_cop_io[0];
return 0xff;
}
@@ -487,31 +496,31 @@ static READ8_HANDLER( protection_r )
static ADDRESS_MAP_START( looping_map, AS_PROGRAM, 8, looping_state )
AM_RANGE(0x0000, 0x7fff) AM_ROM
- AM_RANGE(0x9000, 0x93ff) AM_RAM_WRITE_LEGACY(looping_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0x9000, 0x93ff) AM_RAM_WRITE(looping_videoram_w) AM_BASE(m_videoram)
- AM_RANGE(0x9800, 0x983f) AM_MIRROR(0x0700) AM_RAM_WRITE_LEGACY(looping_colorram_w) AM_BASE(m_colorram)
+ AM_RANGE(0x9800, 0x983f) AM_MIRROR(0x0700) AM_RAM_WRITE(looping_colorram_w) AM_BASE(m_colorram)
AM_RANGE(0x9840, 0x987f) AM_MIRROR(0x0700) AM_RAM AM_BASE(m_spriteram)
AM_RANGE(0x9880, 0x98ff) AM_MIRROR(0x0700) AM_RAM
- AM_RANGE(0xb001, 0xb001) AM_MIRROR(0x07f8) AM_WRITE_LEGACY(level2_irq_set)
- AM_RANGE(0xb006, 0xb006) AM_MIRROR(0x07f8) AM_WRITE_LEGACY(flip_screen_x_w)
- AM_RANGE(0xb007, 0xb007) AM_MIRROR(0x07f8) AM_WRITE_LEGACY(flip_screen_y_w)
+ AM_RANGE(0xb001, 0xb001) AM_MIRROR(0x07f8) AM_WRITE(level2_irq_set)
+ AM_RANGE(0xb006, 0xb006) AM_MIRROR(0x07f8) AM_WRITE(flip_screen_x_w)
+ AM_RANGE(0xb007, 0xb007) AM_MIRROR(0x07f8) AM_WRITE(flip_screen_y_w)
AM_RANGE(0xe000, 0xefff) AM_RAM
- AM_RANGE(0xf800, 0xf800) AM_MIRROR(0x03fc) AM_READ_PORT("P1") AM_WRITE_LEGACY(out_0_w) /* /OUT0 */
- AM_RANGE(0xf801, 0xf801) AM_MIRROR(0x03fc) AM_READ_PORT("P2") AM_WRITE_LEGACY(looping_soundlatch_w) /* /OUT1 */
- AM_RANGE(0xf802, 0xf802) AM_MIRROR(0x03fc) AM_READ_PORT("DSW") AM_WRITE_LEGACY(out_2_w) /* /OUT2 */
- AM_RANGE(0xf803, 0xf803) AM_MIRROR(0x03fc) AM_READWRITE_LEGACY(adc_r, adc_w)
+ AM_RANGE(0xf800, 0xf800) AM_MIRROR(0x03fc) AM_READ_PORT("P1") AM_WRITE(out_0_w) /* /OUT0 */
+ AM_RANGE(0xf801, 0xf801) AM_MIRROR(0x03fc) AM_READ_PORT("P2") AM_WRITE(looping_soundlatch_w) /* /OUT1 */
+ AM_RANGE(0xf802, 0xf802) AM_MIRROR(0x03fc) AM_READ_PORT("DSW") AM_WRITE(out_2_w) /* /OUT2 */
+ AM_RANGE(0xf803, 0xf803) AM_MIRROR(0x03fc) AM_READWRITE(adc_r, adc_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( looping_io_map, AS_IO, 8, looping_state )
/* 400 = A16 */
/* 401 = A17 */
/* 402 = COLOR 9 */
- AM_RANGE(0x403, 0x403) AM_WRITE_LEGACY(plr2_w)
+ AM_RANGE(0x403, 0x403) AM_WRITE(plr2_w)
/* 404 = C0 */
/* 405 = C1 */
- AM_RANGE(0x406, 0x406) AM_WRITE_LEGACY(main_irq_ack_w)
+ AM_RANGE(0x406, 0x406) AM_WRITE(main_irq_ack_w)
AM_RANGE(0x407, 0x407) AM_WRITE_LEGACY(watchdog_reset_w)
AM_RANGE(0x10000, 0x10000) AM_NOP /* external IDLE signal -- we can ignore it */
@@ -532,11 +541,11 @@ static ADDRESS_MAP_START( looping_sound_map, AS_PROGRAM, 8, looping_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( looping_sound_io_map, AS_IO, 8, looping_state )
- AM_RANGE(0x000, 0x000) AM_WRITE_LEGACY(looping_souint_clr)
+ AM_RANGE(0x000, 0x000) AM_WRITE(looping_souint_clr)
AM_RANGE(0x001, 0x007) AM_DEVWRITE_LEGACY("dac", looping_sound_sw)
AM_RANGE(0x008, 0x008) AM_DEVWRITE_LEGACY("aysnd", ay_enable_w)
AM_RANGE(0x009, 0x009) AM_DEVWRITE_LEGACY("tms", speech_enable_w)
- AM_RANGE(0x00a, 0x00a) AM_WRITE_LEGACY(ballon_enable_w)
+ AM_RANGE(0x00a, 0x00a) AM_WRITE(ballon_enable_w)
AM_RANGE(0x00b, 0x00f) AM_NOP
ADDRESS_MAP_END
@@ -551,7 +560,7 @@ static ADDRESS_MAP_START( looping_cop_data_map, AS_DATA, 8, looping_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( looping_cop_io_map, AS_IO, 8, looping_state )
- AM_RANGE(0x0100, 0x0107) AM_READWRITE_LEGACY(cop_io_r, cop_io_w)
+ AM_RANGE(0x0100, 0x0107) AM_READWRITE(cop_io_r, cop_io_w)
ADDRESS_MAP_END
@@ -898,7 +907,7 @@ static DRIVER_INIT( looping )
rom[i] = BITSWAP8(rom[i], 0,1,2,3,4,5,6,7);
/* install protection handlers */
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7000, 0x7007, FUNC(protection_r));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x7000, 0x7007, read8_delegate(FUNC(looping_state::protection_r), state));
}
diff --git a/src/mame/drivers/marinedt.c b/src/mame/drivers/marinedt.c
index b99f165ffbe..5a7b7dac589 100644
--- a/src/mame/drivers/marinedt.c
+++ b/src/mame/drivers/marinedt.c
@@ -130,28 +130,42 @@ public:
UINT8 m_cxh;
UINT8 m_cyrh;
UINT8 m_cyqh;
+ DECLARE_WRITE8_MEMBER(tx_tileram_w);
+ DECLARE_READ8_MEMBER(marinedt_port1_r);
+ DECLARE_READ8_MEMBER(marinedt_coll_r);
+ DECLARE_READ8_MEMBER(marinedt_obj1_x_r);
+ DECLARE_READ8_MEMBER(marinedt_obj1_yr_r);
+ DECLARE_READ8_MEMBER(marinedt_obj1_yq_r);
+ DECLARE_WRITE8_MEMBER(marinedt_obj1_a_w);
+ DECLARE_WRITE8_MEMBER(marinedt_obj1_x_w);
+ DECLARE_WRITE8_MEMBER(marinedt_obj1_y_w);
+ DECLARE_WRITE8_MEMBER(marinedt_obj2_a_w);
+ DECLARE_WRITE8_MEMBER(marinedt_obj2_x_w);
+ DECLARE_WRITE8_MEMBER(marinedt_obj2_y_w);
+ DECLARE_WRITE8_MEMBER(marinedt_music_w);
+ DECLARE_WRITE8_MEMBER(marinedt_sound_w);
+ DECLARE_WRITE8_MEMBER(marinedt_pd_w);
+ DECLARE_WRITE8_MEMBER(marinedt_pf_w);
};
-static WRITE8_HANDLER( tx_tileram_w )
+WRITE8_MEMBER(marinedt_state::tx_tileram_w)
{
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- state->m_tx_tileram[offset] = data;
- state->m_tx_tilemap->mark_tile_dirty(offset);
+ m_tx_tileram[offset] = data;
+ m_tx_tilemap->mark_tile_dirty(offset);
}
-static READ8_HANDLER( marinedt_port1_r )
+READ8_MEMBER(marinedt_state::marinedt_port1_r)
{
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
//might need to be reversed for cocktail stuff
/* x/y multiplexed */
- return input_port_read(space->machine(), ((state->m_pf & 0x08) >> 3) ? "TRACKY" : "TRACKX");
+ return input_port_read(machine(), ((m_pf & 0x08) >> 3) ? "TRACKY" : "TRACKX");
}
-static READ8_HANDLER( marinedt_coll_r )
+READ8_MEMBER(marinedt_state::marinedt_coll_r)
{
//76543210
//x------- obj1 to obj2 collision
@@ -159,48 +173,45 @@ static READ8_HANDLER( marinedt_coll_r )
//----x--- obj1 to playfield collision
//-----xxx unused
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- return state->m_coll | state->m_collh;
+ return m_coll | m_collh;
}
//are these returning only during a collision?
//id imagine they are returning the pf char where the collission took place?
//what about where there is lots of colls?
//maybe the first on a scanline basis
-static READ8_HANDLER( marinedt_obj1_x_r )
+READ8_MEMBER(marinedt_state::marinedt_obj1_x_r)
{
//76543210
//xxxx---- unknown
//----xxxx x pos in tile ram
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- UINT8 *RAM = space->machine().region("maincpu")->base();
+ UINT8 *RAM = machine().region("maincpu")->base();
if (RAM[0x430e])
- --state->m_cx;
+ --m_cx;
else
- ++state->m_cx;
+ ++m_cx;
//figure out why inc/dec based on 430e?
- return state->m_cx | (state->m_cxh << 4);
+ return m_cx | (m_cxh << 4);
}
-static READ8_HANDLER( marinedt_obj1_yr_r )
+READ8_MEMBER(marinedt_state::marinedt_obj1_yr_r)
{
//76543210
//xxxx---- unknown
//----xxxx row in current screen quarter
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
//has to be +1 if cx went over?
- if (state->m_cx == 0x10)
- state->m_cyr++;
+ if (m_cx == 0x10)
+ m_cyr++;
- return state->m_cyr | (state->m_cyrh << 4);
+ return m_cyr | (m_cyrh << 4);
}
-static READ8_HANDLER( marinedt_obj1_yq_r )
+READ8_MEMBER(marinedt_state::marinedt_obj1_yq_r)
{
//76543210
//xx------ unknown
@@ -208,20 +219,19 @@ static READ8_HANDLER( marinedt_obj1_yq_r )
//----xx-- unknown
//------xx screen quarter
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- return state->m_cyq | (state->m_cyqh << 4);
+ return m_cyq | (m_cyqh << 4);
}
-static WRITE8_HANDLER( marinedt_obj1_a_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj1_a = data; }
-static WRITE8_HANDLER( marinedt_obj1_x_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj1_x = data; }
-static WRITE8_HANDLER( marinedt_obj1_y_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj1_y = data; }
-static WRITE8_HANDLER( marinedt_obj2_a_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj2_a = data; }
-static WRITE8_HANDLER( marinedt_obj2_x_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj2_x = data; }
-static WRITE8_HANDLER( marinedt_obj2_y_w ) { marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_obj2_y = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj1_a_w){ m_obj1_a = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj1_x_w){ m_obj1_x = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj1_y_w){ m_obj1_y = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj2_a_w){ m_obj2_a = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj2_x_w){ m_obj2_x = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_obj2_y_w){ m_obj2_y = data; }
-static WRITE8_HANDLER( marinedt_music_w ){ marinedt_state *state = space->machine().driver_data<marinedt_state>(); state->m_music = data; }
+WRITE8_MEMBER(marinedt_state::marinedt_music_w){ m_music = data; }
-static WRITE8_HANDLER( marinedt_sound_w )
+WRITE8_MEMBER(marinedt_state::marinedt_sound_w)
{
//76543210
//xx------ ??
@@ -232,11 +242,10 @@ static WRITE8_HANDLER( marinedt_sound_w )
//------x- dots hit
//-------x ??
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- state->m_sound = data;
+ m_sound = data;
}
-static WRITE8_HANDLER( marinedt_pd_w )
+WRITE8_MEMBER(marinedt_state::marinedt_pd_w)
{
//76543210
//xxx----- ?? unused
@@ -246,8 +255,7 @@ static WRITE8_HANDLER( marinedt_pd_w )
//------x- obj2 enable
//-------x obj1 enable
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- state->m_pd = data;
+ m_pd = data;
}
/*
@@ -265,7 +273,7 @@ marinedt_pf_w: 05 // flip sprite?
marinedt_pf_w: 07 // cocktail
marinedt_pf_w: 03 // non-flip sprite?
*/
-static WRITE8_HANDLER( marinedt_pf_w )
+WRITE8_MEMBER(marinedt_state::marinedt_pf_w)
{
//76543210
//xxxx---- ?? unused (will need to understand table of written values)
@@ -274,12 +282,11 @@ static WRITE8_HANDLER( marinedt_pf_w )
//------x- ?? upright/cocktail
//-------x ?? service mode (coin lockout??)
- marinedt_state *state = space->machine().driver_data<marinedt_state>();
- //if ((state->m_pf & 0x07) != (data & 0x07))
+ //if ((m_pf & 0x07) != (data & 0x07))
// mame_printf_debug("marinedt_pf_w: %02x\n", data & 0x07);
- if ((state->m_pf & 0x02) != (data & 0x02))
+ if ((m_pf & 0x02) != (data & 0x02))
{
if (data & 0x02)
mame_printf_debug("tile flip\n");
@@ -287,16 +294,16 @@ static WRITE8_HANDLER( marinedt_pf_w )
mame_printf_debug("tile non-flip\n");
if (data & 0x02)
- state->m_tx_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
+ m_tx_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
else
- state->m_tx_tilemap->set_flip(0);
+ m_tx_tilemap->set_flip(0);
}
- state->m_pf = data;
+ m_pf = data;
//if (data & 0xf0)
- // logerror("pf:%02x %d\n", state->m_pf);
- //logerror("pd:%02x %d\n", state->m_pd, space->machine().primary_screen->frame_number());
+ // logerror("pf:%02x %d\n", m_pf);
+ //logerror("pd:%02x %d\n", m_pd, machine().primary_screen->frame_number());
}
@@ -304,25 +311,25 @@ static ADDRESS_MAP_START( marinedt_map, AS_PROGRAM, 8, marinedt_state )
AM_RANGE(0x0000, 0x37ff) AM_ROM
AM_RANGE(0x4000, 0x43ff) AM_RAM
AM_RANGE(0x4400, 0x47ff) AM_RAM //unused, vram mirror?
- AM_RANGE(0x4800, 0x4bff) AM_RAM_WRITE_LEGACY(tx_tileram_w) AM_BASE(m_tx_tileram)
+ AM_RANGE(0x4800, 0x4bff) AM_RAM_WRITE(tx_tileram_w) AM_BASE(m_tx_tileram)
AM_RANGE(0x4c00, 0x4c00) AM_WRITENOP //?? maybe off by one error
ADDRESS_MAP_END
static ADDRESS_MAP_START( marinedt_io_map, AS_IO, 8, marinedt_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x00, 0x00) AM_READ_PORT("DSW0") //dips coinage
- AM_RANGE(0x01, 0x01) AM_READ_LEGACY(marinedt_port1_r) //trackball xy muxed
- AM_RANGE(0x02, 0x02) AM_READWRITE_LEGACY(marinedt_obj1_x_r, marinedt_obj1_a_w)
- AM_RANGE(0x03, 0x03) AM_READ_PORT("IN0") AM_WRITE_LEGACY(marinedt_obj1_x_w)
- AM_RANGE(0x04, 0x04) AM_READ_PORT("DSW1") AM_WRITE_LEGACY(marinedt_obj1_y_w)
- AM_RANGE(0x05, 0x05) AM_WRITE_LEGACY(marinedt_music_w)
- AM_RANGE(0x06, 0x06) AM_READWRITE_LEGACY(marinedt_obj1_yr_r, marinedt_sound_w)
- AM_RANGE(0x08, 0x08) AM_WRITE_LEGACY(marinedt_obj2_a_w)
- AM_RANGE(0x09, 0x09) AM_WRITE_LEGACY(marinedt_obj2_x_w)
- AM_RANGE(0x0a, 0x0a) AM_READWRITE_LEGACY(marinedt_obj1_yq_r, marinedt_obj2_y_w)
- AM_RANGE(0x0d, 0x0d) AM_WRITE_LEGACY(marinedt_pd_w)
- AM_RANGE(0x0e, 0x0e) AM_READWRITE_LEGACY(marinedt_coll_r, watchdog_reset_w)
- AM_RANGE(0x0f, 0x0f) AM_WRITE_LEGACY(marinedt_pf_w)
+ AM_RANGE(0x01, 0x01) AM_READ(marinedt_port1_r) //trackball xy muxed
+ AM_RANGE(0x02, 0x02) AM_READWRITE(marinedt_obj1_x_r, marinedt_obj1_a_w)
+ AM_RANGE(0x03, 0x03) AM_READ_PORT("IN0") AM_WRITE(marinedt_obj1_x_w)
+ AM_RANGE(0x04, 0x04) AM_READ_PORT("DSW1") AM_WRITE(marinedt_obj1_y_w)
+ AM_RANGE(0x05, 0x05) AM_WRITE(marinedt_music_w)
+ AM_RANGE(0x06, 0x06) AM_READWRITE(marinedt_obj1_yr_r, marinedt_sound_w)
+ AM_RANGE(0x08, 0x08) AM_WRITE(marinedt_obj2_a_w)
+ AM_RANGE(0x09, 0x09) AM_WRITE(marinedt_obj2_x_w)
+ AM_RANGE(0x0a, 0x0a) AM_READWRITE(marinedt_obj1_yq_r, marinedt_obj2_y_w)
+ AM_RANGE(0x0d, 0x0d) AM_WRITE(marinedt_pd_w)
+ AM_RANGE(0x0e, 0x0e) AM_READWRITE(marinedt_coll_r, watchdog_reset_w)
+ AM_RANGE(0x0f, 0x0f) AM_WRITE(marinedt_pf_w)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/maygay1b.c b/src/mame/drivers/maygay1b.c
index 56818b5cd3b..de6ab52ed1c 100644
--- a/src/mame/drivers/maygay1b.c
+++ b/src/mame/drivers/maygay1b.c
@@ -125,22 +125,35 @@ public:
int m_optic_pattern;
device_t *m_duart68681;
i8279_state m_i8279[2];
+ DECLARE_READ8_MEMBER(m1_8279_r);
+ DECLARE_WRITE8_MEMBER(m1_8279_w);
+ DECLARE_READ8_MEMBER(m1_8279_2_r);
+ DECLARE_WRITE8_MEMBER(m1_8279_2_w);
+ DECLARE_WRITE8_MEMBER(reel12_w);
+ DECLARE_WRITE8_MEMBER(reel34_w);
+ DECLARE_WRITE8_MEMBER(reel56_w);
+ DECLARE_WRITE8_MEMBER(m1_latch_w);
+ DECLARE_WRITE8_MEMBER(latch_ch2_w);
+ DECLARE_READ8_MEMBER(latch_st_hi);
+ DECLARE_READ8_MEMBER(latch_st_lo);
+ DECLARE_WRITE8_MEMBER(m1ab_no_oki_w);
+ void m1_draw_lamps(int data,int strobe, int col);
};
-static void m1_draw_lamps(maygay1b_state *state, int data,int strobe, int col)
+void maygay1b_state::m1_draw_lamps(int data,int strobe, int col)
{
int i;
int scramble[8] = { 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08 };
- state->m_lamppos = strobe + col * 8;
+ m_lamppos = strobe + col * 8;
for ( i = 0; i < 8; i++ )
{
- state->m_Lamps[state->m_lamppos] = ( data & scramble[i] );
- output_set_lamp_value(state->m_lamppos, state->m_Lamps[state->m_lamppos]);
+ m_Lamps[m_lamppos] = ( data & scramble[i] );
+ output_set_lamp_value(m_lamppos, m_Lamps[m_lamppos]);
}
- state->m_lamppos++;
+ m_lamppos++;
}
@@ -174,10 +187,9 @@ static void update_outputs(i8279_state *chip, UINT16 which)
}
}
-static READ8_HANDLER( m1_8279_r )
+READ8_MEMBER(maygay1b_state::m1_8279_r)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
- i8279_state *chip = state->m_i8279 + 0;
+ i8279_state *chip = m_i8279 + 0;
static const char *const portnames[] = { "SW1","STROBE5","STROBE7","STROBE3","SW2","STROBE4","STROBE6","STROBE2" };
UINT8 result = 0xff;
UINT8 addr;
@@ -190,7 +202,7 @@ static READ8_HANDLER( m1_8279_r )
/* read sensor RAM */
case 0x40:
addr = chip->command & 0x07;
- result = input_port_read(space->machine(),"SW1");
+ result = input_port_read(machine(),"SW1");
/* handle autoincrement */
if (chip->command & 0x10)
chip->command = (chip->command & 0xf0) | ((addr + 1) & 0x0f);
@@ -217,7 +229,7 @@ static READ8_HANDLER( m1_8279_r )
{
if ( chip->read_sensor )
{
- result = input_port_read(space->machine(),portnames[chip->sense_address]);
+ result = input_port_read(machine(),portnames[chip->sense_address]);
// break
}
if ( chip->sense_auto_inc )
@@ -234,10 +246,9 @@ static READ8_HANDLER( m1_8279_r )
return result;
}
-static WRITE8_HANDLER( m1_8279_w )
+WRITE8_MEMBER(maygay1b_state::m1_8279_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
- i8279_state *chip = state->m_i8279 + 0;
+ i8279_state *chip = m_i8279 + 0;
UINT8 addr;
/* write data */
@@ -345,7 +356,7 @@ static WRITE8_HANDLER( m1_8279_w )
{ // Data
if ( chip->ram[chip->disp_address] != data )
{
- m1_draw_lamps(state,chip->ram[chip->disp_address],chip->disp_address, 0);
+ m1_draw_lamps(chip->ram[chip->disp_address],chip->disp_address, 0);
}
chip->ram[chip->disp_address] = data;
if ( chip->disp_auto_inc )
@@ -353,10 +364,9 @@ static WRITE8_HANDLER( m1_8279_w )
}
}
-static READ8_HANDLER( m1_8279_2_r )
+READ8_MEMBER(maygay1b_state::m1_8279_2_r)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
- i8279_state *chip = state->m_i8279 + 1;
+ i8279_state *chip = m_i8279 + 1;
UINT8 result = 0xff;
UINT8 addr;
@@ -394,10 +404,9 @@ static READ8_HANDLER( m1_8279_2_r )
}
-static WRITE8_HANDLER( m1_8279_2_w )
+WRITE8_MEMBER(maygay1b_state::m1_8279_2_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
- i8279_state *chip = state->m_i8279 + 1;
+ i8279_state *chip = m_i8279 + 1;
UINT8 addr;
/* write data */
@@ -497,7 +506,7 @@ static WRITE8_HANDLER( m1_8279_2_w )
{ // Data
if ( chip->ram[chip->disp_address] != data )
{
- m1_draw_lamps(state,chip->ram[chip->disp_address],chip->disp_address, 128);
+ m1_draw_lamps(chip->ram[chip->disp_address],chip->disp_address, 128);
}
chip->ram[chip->disp_address] = data;
if ( chip->disp_auto_inc )
@@ -727,46 +736,43 @@ static MACHINE_START( m1 )
// setup the standard oki MSC1937 display ///////////////////////////////
ROC10937_init(0, MSC1937,0);
}
-static WRITE8_HANDLER( reel12_w )
+WRITE8_MEMBER(maygay1b_state::reel12_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
stepper_update(0, data & 0x0F );
stepper_update(1, (data>>4) & 0x0F );
- if ( stepper_optic_state(0) ) state->m_optic_pattern |= 0x01;
- else state->m_optic_pattern &= ~0x01;
- if ( stepper_optic_state(1) ) state->m_optic_pattern |= 0x02;
- else state->m_optic_pattern &= ~0x02;
+ if ( stepper_optic_state(0) ) m_optic_pattern |= 0x01;
+ else m_optic_pattern &= ~0x01;
+ if ( stepper_optic_state(1) ) m_optic_pattern |= 0x02;
+ else m_optic_pattern &= ~0x02;
awp_draw_reel(0);
awp_draw_reel(1);
}
-static WRITE8_HANDLER( reel34_w )
+WRITE8_MEMBER(maygay1b_state::reel34_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
stepper_update(2, data & 0x0F );
stepper_update(3, (data>>4) & 0x0F );
- if ( stepper_optic_state(2) ) state->m_optic_pattern |= 0x04;
- else state->m_optic_pattern &= ~0x04;
- if ( stepper_optic_state(3) ) state->m_optic_pattern |= 0x08;
- else state->m_optic_pattern &= ~0x08;
+ if ( stepper_optic_state(2) ) m_optic_pattern |= 0x04;
+ else m_optic_pattern &= ~0x04;
+ if ( stepper_optic_state(3) ) m_optic_pattern |= 0x08;
+ else m_optic_pattern &= ~0x08;
awp_draw_reel(2);
awp_draw_reel(3);
}
-static WRITE8_HANDLER( reel56_w )
+WRITE8_MEMBER(maygay1b_state::reel56_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
stepper_update(4, data & 0x0F );
stepper_update(5, (data>>4) & 0x0F );
- if ( stepper_optic_state(4) ) state->m_optic_pattern |= 0x10;
- else state->m_optic_pattern &= ~0x10;
- if ( stepper_optic_state(5) ) state->m_optic_pattern |= 0x20;
- else state->m_optic_pattern &= ~0x20;
+ if ( stepper_optic_state(4) ) m_optic_pattern |= 0x10;
+ else m_optic_pattern &= ~0x10;
+ if ( stepper_optic_state(5) ) m_optic_pattern |= 0x20;
+ else m_optic_pattern &= ~0x20;
awp_draw_reel(4);
awp_draw_reel(5);
@@ -786,20 +792,19 @@ static WRITE8_DEVICE_HANDLER( m1_meter_w )
if ( data & (1 << i) ) MechMtr_update(i, data & (1 << i) );
}
-static WRITE8_HANDLER( m1_latch_w )
+WRITE8_MEMBER(maygay1b_state::m1_latch_w)
{
- maygay1b_state *state = space->machine().driver_data<maygay1b_state>();
switch ( offset )
{
- case 0: // state->m_RAMEN
- state->m_RAMEN = (data & 1);
+ case 0: // m_RAMEN
+ m_RAMEN = (data & 1);
break;
case 1: // AlarmEn
- state->m_ALARMEN = (data & 1);
+ m_ALARMEN = (data & 1);
break;
case 2: // Enable
- cpu0_nmi(space->machine(),1);
- cpu0_nmi(space->machine(),0);
+ cpu0_nmi(machine(),1);
+ cpu0_nmi(machine(),0);
// if ( m1_enable == 0 && ( data & 1 ) && Vmm )
// {
@@ -812,35 +817,35 @@ static WRITE8_HANDLER( m1_latch_w )
}
break;
case 4: // PSURelay
- state->m_PSUrelay = (data & 1);
+ m_PSUrelay = (data & 1);
break;
case 5: // WDog
- state->m_WDOG = (data & 1);
+ m_WDOG = (data & 1);
break;
case 6: // Srsel
- state->m_SRSEL = (data & 1);
+ m_SRSEL = (data & 1);
break;
}
}
-static WRITE8_HANDLER( latch_ch2_w )
+WRITE8_MEMBER(maygay1b_state::latch_ch2_w)
{
- device_t *msm6376 = space->machine().device("msm6376");
+ device_t *msm6376 = machine().device("msm6376");
okim6376_w(msm6376, 0, data&0x7f);
okim6376_ch2_w(msm6376,data&0x80);
}
//A strange setup this, the address lines are used to move st to the right level
-static READ8_HANDLER( latch_st_hi )
+READ8_MEMBER(maygay1b_state::latch_st_hi)
{
- device_t *msm6376 = space->machine().device("msm6376");
+ device_t *msm6376 = machine().device("msm6376");
okim6376_st_w(msm6376,1);
return 0;
}
-static READ8_HANDLER( latch_st_lo )
+READ8_MEMBER(maygay1b_state::latch_st_lo)
{
- device_t *msm6376 = space->machine().device("msm6376");
+ device_t *msm6376 = machine().device("msm6376");
okim6376_st_w(msm6376,0);
return 0;
}
@@ -848,12 +853,12 @@ static READ8_HANDLER( latch_st_lo )
static ADDRESS_MAP_START( m1_memmap, AS_PROGRAM, 8, maygay1b_state )
AM_RANGE(0x0000, 0x1fff) AM_RAM AM_SHARE("nvram")
- AM_RANGE(0x2000, 0x2000) AM_WRITE_LEGACY(reel12_w)
- AM_RANGE(0x2010, 0x2010) AM_WRITE_LEGACY(reel34_w)
- AM_RANGE(0x2020, 0x2020) AM_WRITE_LEGACY(reel56_w)
+ AM_RANGE(0x2000, 0x2000) AM_WRITE(reel12_w)
+ AM_RANGE(0x2010, 0x2010) AM_WRITE(reel34_w)
+ AM_RANGE(0x2020, 0x2020) AM_WRITE(reel56_w)
- AM_RANGE(0x2030, 0x2031) AM_READWRITE_LEGACY(m1_8279_r,m1_8279_w)
- AM_RANGE(0x2040, 0x2041) AM_READWRITE_LEGACY(m1_8279_2_r,m1_8279_2_w)
+ AM_RANGE(0x2030, 0x2031) AM_READWRITE(m1_8279_r,m1_8279_w)
+ AM_RANGE(0x2040, 0x2041) AM_READWRITE(m1_8279_2_r,m1_8279_2_w)
AM_RANGE(0x2050, 0x2050)// SCAN on M1B
AM_RANGE(0x2070, 0x207f) AM_DEVREADWRITE_LEGACY("duart68681", duart68681_r, duart68681_w )
@@ -864,13 +869,13 @@ static ADDRESS_MAP_START( m1_memmap, AS_PROGRAM, 8, maygay1b_state )
AM_RANGE(0x20A0, 0x20A3) AM_DEVWRITE("pia", pia6821_device, write)
AM_RANGE(0x20A0, 0x20A3) AM_DEVREAD("pia", pia6821_device, read)
- AM_RANGE(0x20C0, 0x20C7) AM_WRITE_LEGACY(m1_latch_w)
+ AM_RANGE(0x20C0, 0x20C7) AM_WRITE(m1_latch_w)
AM_RANGE(0x2400, 0x2401) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w )
- AM_RANGE(0x2404, 0x2405) AM_READ_LEGACY(latch_st_lo)
- AM_RANGE(0x2406, 0x2407) AM_READ_LEGACY(latch_st_hi)
+ AM_RANGE(0x2404, 0x2405) AM_READ(latch_st_lo)
+ AM_RANGE(0x2406, 0x2407) AM_READ(latch_st_hi)
- AM_RANGE(0x2420, 0x2421) AM_WRITE_LEGACY(latch_ch2_w ) // oki
+ AM_RANGE(0x2420, 0x2421) AM_WRITE(latch_ch2_w ) // oki
AM_RANGE(0x2800, 0xffff) AM_ROM
ADDRESS_MAP_END
@@ -4404,7 +4409,7 @@ ROM_START( m1atunk )
ROM_REGION( 0x100000, "msm6376", ROMREGION_ERASE00 )
ROM_END
-static WRITE8_HANDLER( m1ab_no_oki_w )
+WRITE8_MEMBER(maygay1b_state::m1ab_no_oki_w)
{
popmessage("write to OKI, but no OKI rom");
}
@@ -4412,14 +4417,15 @@ static WRITE8_HANDLER( m1ab_no_oki_w )
static DRIVER_INIT( m1 )
{
- //AM_RANGE(0x2420, 0x2421) AM_WRITE_LEGACY(latch_ch2_w ) // oki
+ //AM_RANGE(0x2420, 0x2421) AM_WRITE(latch_ch2_w ) // oki
// if there is no OKI region disable writes here, the rom might be missing, so alert user
UINT8 *okirom = machine.region( "oki" )->base();
- if (!okirom)
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x2420, 0x2421, FUNC(m1ab_no_oki_w));
-
+ if (!okirom) {
+ maygay1b_state *state = machine.driver_data<maygay1b_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x2420, 0x2421, write8_delegate(FUNC(maygay1b_state::m1ab_no_oki_w), state));
+ }
// print out the rom id / header info to give us some hints
// note this isn't always correct, alley cat has 'Calpsyo' still in the ident string?
{
diff --git a/src/mame/drivers/meritm.c b/src/mame/drivers/meritm.c
index cbff1f93c36..5eea6f1e60c 100644
--- a/src/mame/drivers/meritm.c
+++ b/src/mame/drivers/meritm.c
@@ -147,6 +147,14 @@ public:
required_device<v9938_device> m_v9938_0;
required_device<v9938_device> m_v9938_1;
required_device<microtouch_device> m_microtouch;
+ DECLARE_WRITE8_MEMBER(meritm_crt250_bank_w);
+ DECLARE_WRITE8_MEMBER(meritm_psd_a15_w);
+ DECLARE_WRITE8_MEMBER(meritm_bank_w);
+ DECLARE_WRITE8_MEMBER(meritm_crt250_questions_lo_w);
+ DECLARE_WRITE8_MEMBER(meritm_crt250_questions_hi_w);
+ DECLARE_WRITE8_MEMBER(meritm_crt250_questions_bank_w);
+ DECLARE_WRITE8_MEMBER(meritm_ds1644_w);
+ DECLARE_READ8_MEMBER(meritm_ds1644_r);
};
@@ -414,9 +422,9 @@ static void meritm_crt250_switch_banks( running_machine &machine )
memory_set_bank(machine, "bank1", rombank );
};
-static WRITE8_HANDLER(meritm_crt250_bank_w)
+WRITE8_MEMBER(meritm_state::meritm_crt250_bank_w)
{
- meritm_crt250_switch_banks(space->machine());
+ meritm_crt250_switch_banks(machine());
};
static void meritm_switch_banks( running_machine &machine )
@@ -434,17 +442,16 @@ static void meritm_switch_banks( running_machine &machine )
memory_set_bank(machine, "bank3", rambank);
};
-static WRITE8_HANDLER(meritm_psd_a15_w)
+WRITE8_MEMBER(meritm_state::meritm_psd_a15_w)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
- state->m_psd_a15 = data;
- //logerror( "Writing PSD_A15 with %02x at PC=%04X\n", data, cpu_get_pc(&space->device()) );
- meritm_switch_banks(space->machine());
+ m_psd_a15 = data;
+ //logerror( "Writing PSD_A15 with %02x at PC=%04X\n", data, cpu_get_pc(&space.device()) );
+ meritm_switch_banks(machine());
};
-static WRITE8_HANDLER(meritm_bank_w)
+WRITE8_MEMBER(meritm_state::meritm_bank_w)
{
- meritm_switch_banks(space->machine());
+ meritm_switch_banks(machine());
};
/*************************************
@@ -454,33 +461,30 @@ static WRITE8_HANDLER(meritm_bank_w)
*************************************/
-static WRITE8_HANDLER(meritm_crt250_questions_lo_w)
+WRITE8_MEMBER(meritm_state::meritm_crt250_questions_lo_w)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
- state->m_questions_loword_address &= 0xff00;
- state->m_questions_loword_address |= data;
+ m_questions_loword_address &= 0xff00;
+ m_questions_loword_address |= data;
};
-static WRITE8_HANDLER(meritm_crt250_questions_hi_w)
+WRITE8_MEMBER(meritm_state::meritm_crt250_questions_hi_w)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
- state->m_questions_loword_address &= 0x00ff;
- state->m_questions_loword_address |= (data << 8);
+ m_questions_loword_address &= 0x00ff;
+ m_questions_loword_address |= (data << 8);
};
-static WRITE8_HANDLER(meritm_crt250_questions_bank_w)
+WRITE8_MEMBER(meritm_state::meritm_crt250_questions_bank_w)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
UINT32 questions_address;
UINT8 *dst;
- if ((state->m_bank & 0x07) != 0)
+ if ((m_bank & 0x07) != 0)
{
- logerror("meritm_crt250_questions_bank_w: bank is %d\n", state->m_bank);
+ logerror("meritm_crt250_questions_bank_w: bank is %d\n", m_bank);
return;
}
- dst = space->machine().region("maincpu")->base() + 0x70000 + 2;
+ dst = machine().region("maincpu")->base() + 0x70000 + 2;
if (data == 0)
{
@@ -508,8 +512,8 @@ static WRITE8_HANDLER(meritm_crt250_questions_bank_w)
case 0x3f: questions_address = 0xb0000; break;
default: logerror( "meritm_crt250_questions_bank_w: unknown data = %02x\n", data ); return;
}
- logerror( "Reading question byte at %06X\n", questions_address | state->m_questions_loword_address);
- *dst = space->machine().region("extra")->base()[questions_address | state->m_questions_loword_address];
+ logerror( "Reading question byte at %06X\n", questions_address | m_questions_loword_address);
+ *dst = machine().region("extra")->base()[questions_address | m_questions_loword_address];
}
};
@@ -520,19 +524,18 @@ static WRITE8_HANDLER(meritm_crt250_questions_bank_w)
*
*************************************/
-static WRITE8_HANDLER(meritm_ds1644_w)
+WRITE8_MEMBER(meritm_state::meritm_ds1644_w)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
- int rambank = (state->m_psd_a15 >> 2) & 0x3;
+ int rambank = (m_psd_a15 >> 2) & 0x3;
if (rambank < 3)
{
- state->m_ram[rambank*0x2000 + 0x1ff8 + offset] = data;
+ m_ram[rambank*0x2000 + 0x1ff8 + offset] = data;
}
else
{
if (offset == 0)
{
- state->m_ram[0x7ff8] = data;
+ m_ram[0x7ff8] = data;
}
//logerror( "Writing RTC, reg = %d, data = %x\n", offset, data);
}
@@ -545,25 +548,24 @@ static UINT8 binary_to_BCD(UINT8 data)
return ((data / 10) << 4) | (data %10);
}
-static READ8_HANDLER(meritm_ds1644_r)
+READ8_MEMBER(meritm_state::meritm_ds1644_r)
{
- meritm_state *state = space->machine().driver_data<meritm_state>();
system_time systime;
- int rambank = (state->m_psd_a15 >> 2) & 0x3;
+ int rambank = (m_psd_a15 >> 2) & 0x3;
if (rambank == 3)
{
//logerror( "Reading RTC, reg = %x\n", offset);
- space->machine().current_datetime(systime);
- state->m_ram[0x7ff9] = binary_to_BCD(systime.local_time.second);
- state->m_ram[0x7ffa] = binary_to_BCD(systime.local_time.minute);
- state->m_ram[0x7ffb] = binary_to_BCD(systime.local_time.hour);
- state->m_ram[0x7ffc] = binary_to_BCD(systime.local_time.weekday+1);
- state->m_ram[0x7ffd] = binary_to_BCD(systime.local_time.mday);
- state->m_ram[0x7ffe] = binary_to_BCD(systime.local_time.month+1);
- state->m_ram[0x7fff] = binary_to_BCD(systime.local_time.year % 100);
+ machine().current_datetime(systime);
+ m_ram[0x7ff9] = binary_to_BCD(systime.local_time.second);
+ m_ram[0x7ffa] = binary_to_BCD(systime.local_time.minute);
+ m_ram[0x7ffb] = binary_to_BCD(systime.local_time.hour);
+ m_ram[0x7ffc] = binary_to_BCD(systime.local_time.weekday+1);
+ m_ram[0x7ffd] = binary_to_BCD(systime.local_time.mday);
+ m_ram[0x7ffe] = binary_to_BCD(systime.local_time.month+1);
+ m_ram[0x7fff] = binary_to_BCD(systime.local_time.year % 100);
}
- return state->m_ram[rambank*0x2000 + 0x1ff8 + offset];
+ return m_ram[rambank*0x2000 + 0x1ff8 + offset];
};
/*************************************
@@ -579,9 +581,9 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( meritm_crt250_questions_map, AS_PROGRAM, 8, meritm_state )
AM_RANGE(0x0000, 0xdfff) AM_ROMBANK("bank1")
- AM_RANGE(0x0000, 0x0000) AM_WRITE_LEGACY(meritm_crt250_questions_lo_w)
- AM_RANGE(0x0001, 0x0001) AM_WRITE_LEGACY(meritm_crt250_questions_hi_w)
- AM_RANGE(0x0002, 0x0002) AM_WRITE_LEGACY(meritm_crt250_questions_bank_w)
+ AM_RANGE(0x0000, 0x0000) AM_WRITE(meritm_crt250_questions_lo_w)
+ AM_RANGE(0x0001, 0x0001) AM_WRITE(meritm_crt250_questions_hi_w)
+ AM_RANGE(0x0002, 0x0002) AM_WRITE(meritm_crt250_questions_bank_w)
AM_RANGE(0xe000, 0xffff) AM_RAM AM_SHARE("nvram")
ADDRESS_MAP_END
@@ -594,7 +596,7 @@ static ADDRESS_MAP_START( meritm_crt250_io_map, AS_IO, 8, meritm_state )
AM_RANGE(0x50, 0x53) AM_DEVREADWRITE_LEGACY("z80pio_1", z80pio_cd_ba_r, z80pio_cd_ba_w)
AM_RANGE(0x80, 0x80) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x80, 0x81) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
- AM_RANGE(0xff, 0xff) AM_WRITE_LEGACY(meritm_crt250_bank_w)
+ AM_RANGE(0xff, 0xff) AM_WRITE(meritm_crt250_bank_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( meritm_crt250_crt258_io_map, AS_IO, 8, meritm_state )
@@ -607,7 +609,7 @@ static ADDRESS_MAP_START( meritm_crt250_crt258_io_map, AS_IO, 8, meritm_state )
AM_RANGE(0x60, 0x67) AM_READWRITE_LEGACY(pc16552d_0_r,pc16552d_0_w)
AM_RANGE(0x80, 0x80) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x80, 0x81) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
- AM_RANGE(0xff, 0xff) AM_WRITE_LEGACY(meritm_crt250_bank_w)
+ AM_RANGE(0xff, 0xff) AM_WRITE(meritm_crt250_bank_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( meritm_map, AS_PROGRAM, 8, meritm_state )
@@ -618,7 +620,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( meritm_io_map, AS_IO, 8, meritm_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x00, 0x00) AM_WRITE_LEGACY(meritm_psd_a15_w)
+ AM_RANGE(0x00, 0x00) AM_WRITE(meritm_psd_a15_w)
AM_RANGE(0x01, 0x01) AM_WRITE_LEGACY(watchdog_reset_w)
AM_RANGE(0x10, 0x13) AM_DEVREADWRITE("v9938_0", v9938_device, read, write)
AM_RANGE(0x20, 0x23) AM_DEVREADWRITE("v9938_1", v9938_device, read, write)
@@ -628,7 +630,7 @@ static ADDRESS_MAP_START( meritm_io_map, AS_IO, 8, meritm_state )
AM_RANGE(0x60, 0x67) AM_READWRITE_LEGACY(pc16552d_0_r,pc16552d_0_w)
AM_RANGE(0x80, 0x80) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x80, 0x81) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
- AM_RANGE(0xff, 0xff) AM_WRITE_LEGACY(meritm_bank_w)
+ AM_RANGE(0xff, 0xff) AM_WRITE(meritm_bank_w)
ADDRESS_MAP_END
/*************************************
@@ -1876,8 +1878,9 @@ static DRIVER_INIT(megat3te)
{ 0x99, 0x53, 0xfc, 0x29, 0x3a, 0x95, 0x8b, 0x58, 0xca, 0xca, 0x00, 0xc2, 0x30, 0x62, 0x0b, 0x96 };
ds1204_init(machine, megat3_ds1204_key, megat3_ds1204_nvram);
-
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xfff8, 0xffff, FUNC(meritm_ds1644_r), FUNC(meritm_ds1644_w) );
+
+ meritm_state *state = machine.driver_data<meritm_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), state), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), state));
};
@@ -1907,7 +1910,8 @@ static DRIVER_INIT(megat4te)
ds1204_init(machine, 0, megat4te_ds1204_nvram);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xfff8, 0xffff, FUNC(meritm_ds1644_r), FUNC(meritm_ds1644_w) );
+ meritm_state *state = machine.driver_data<meritm_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), state), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), state));
};
@@ -1918,7 +1922,8 @@ static DRIVER_INIT(megat4st)
ds1204_init(machine, 0, megat4te_ds1204_nvram);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xfff8, 0xffff, FUNC(meritm_ds1644_r), FUNC(meritm_ds1644_w) );
+ meritm_state *state = machine.driver_data<meritm_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), state), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), state));
};
@@ -1938,7 +1943,8 @@ static DRIVER_INIT(megat5t)
ds1204_init(machine, 0, megat5_ds1204_nvram);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xfff8, 0xffff, FUNC(meritm_ds1644_r), FUNC(meritm_ds1644_w) );
+ meritm_state *state = machine.driver_data<meritm_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), state), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), state));
}
diff --git a/src/mame/drivers/mpu3.c b/src/mame/drivers/mpu3.c
index e4aa941d2a3..2b8e96d1d63 100644
--- a/src/mame/drivers/mpu3.c
+++ b/src/mame/drivers/mpu3.c
@@ -152,6 +152,10 @@ int m_prot_col;
int m_optic_pattern;
emu_timer *m_ic21_timer;
+ DECLARE_WRITE8_MEMBER(characteriser_w);
+ DECLARE_READ8_MEMBER(characteriser_r);
+ DECLARE_WRITE8_MEMBER(mpu3ptm_w);
+ DECLARE_READ8_MEMBER(mpu3ptm_r);
};
#define DISPLAY_PORT 0
@@ -790,28 +794,27 @@ The MPU3 characteriser is surprisingly simple to simulate, as it operates a call
address of the PAL in memory varies between games. Once found, the memory location of the data table is easily found from the X register of the CPU.
*/
-static WRITE8_HANDLER( characteriser_w )
+WRITE8_MEMBER(mpu3_state::characteriser_w)
{
- mpu3_state *state = space->machine().driver_data<mpu3_state>();
int x;
int call=data;
- if (!state->m_current_chr_table)
- fatalerror("No Characteriser Table @ %04x\n", cpu_get_previouspc(&space->device()));
+ if (!m_current_chr_table)
+ fatalerror("No Characteriser Table @ %04x\n", cpu_get_previouspc(&space.device()));
if (offset == 0)
{
{
if (call == 0)
{
- state->m_prot_col = 0;
+ m_prot_col = 0;
}
else
{
- for (x = state->m_prot_col; x < 64; x++)
+ for (x = m_prot_col; x < 64; x++)
{
- if (state->m_current_chr_table[(x)].call == call)
+ if (m_current_chr_table[(x)].call == call)
{
- state->m_prot_col = x;
+ m_prot_col = x;
break;
}
}
@@ -821,15 +824,14 @@ static WRITE8_HANDLER( characteriser_w )
}
-static READ8_HANDLER( characteriser_r )
+READ8_MEMBER(mpu3_state::characteriser_r)
{
- mpu3_state *state = space->machine().driver_data<mpu3_state>();
- if (!state->m_current_chr_table)
- fatalerror("No Characteriser Table @ %04x\n", cpu_get_previouspc(&space->device()));
+ if (!m_current_chr_table)
+ fatalerror("No Characteriser Table @ %04x\n", cpu_get_previouspc(&space.device()));
if (offset == 0)
{
- return state->m_current_chr_table[state->m_prot_col].response;
+ return m_current_chr_table[m_prot_col].response;
}
return 0;
}
@@ -857,23 +859,23 @@ static TIMER_DEVICE_CALLBACK( ic10_callback )
timer.machine().device<pia6821_device>("pia_ic4")->ca1_w(state->m_ic10_output);
}
-static WRITE8_HANDLER( mpu3ptm_w )
+WRITE8_MEMBER(mpu3_state::mpu3ptm_w)
{
- ptm6840_device *ptm2 = space->machine().device<ptm6840_device>("ptm_ic2");
+ ptm6840_device *ptm2 = machine().device<ptm6840_device>("ptm_ic2");
ptm2->write(offset >>2,data);//((offset & 0x1f) >>2),data);
}
-static READ8_HANDLER( mpu3ptm_r )
+READ8_MEMBER(mpu3_state::mpu3ptm_r)
{
- ptm6840_device *ptm2 = space->machine().device<ptm6840_device>("ptm_ic2");
+ ptm6840_device *ptm2 = machine().device<ptm6840_device>("ptm_ic2");
return ptm2->read(offset >>2);
}
static ADDRESS_MAP_START( mpu3_basemap, AS_PROGRAM, 8, mpu3_state )
AM_RANGE(0x0000, 0x07ff) AM_RAM AM_SHARE("nvram")
- AM_RANGE(0x8800, 0x881f) AM_READWRITE_LEGACY(mpu3ptm_r, mpu3ptm_w)/* PTM6840 IC2 */
+ AM_RANGE(0x8800, 0x881f) AM_READWRITE(mpu3ptm_r, mpu3ptm_w)/* PTM6840 IC2 */
AM_RANGE(0x9000, 0x9003) AM_DEVREADWRITE("pia_ic3", pia6821_device, read, write) /* PIA6821 IC3 */
AM_RANGE(0x9800, 0x9803) AM_DEVREADWRITE("pia_ic4", pia6821_device, read, write) /* PIA6821 IC4 */
AM_RANGE(0xa000, 0xa003) AM_DEVREADWRITE("pia_ic5", pia6821_device, read, write) /* PIA6821 IC5 */
@@ -923,7 +925,7 @@ static DRIVER_INIT (m3hprvpr)
state->m_disp_func=METER_PORT;
state->m_current_chr_table = hprvpr_data;
- space->install_legacy_readwrite_handler(0xc000, 0xc000 , FUNC(characteriser_r),FUNC(characteriser_w));
+ space->install_readwrite_handler(0xc000, 0xc000 , read8_delegate(FUNC(mpu3_state::characteriser_r), state),write8_delegate(FUNC(mpu3_state::characteriser_w), state));
}
diff --git a/src/mame/drivers/nexus3d.c b/src/mame/drivers/nexus3d.c
index 0372b0198b0..bbd1fb3ba12 100644
--- a/src/mame/drivers/nexus3d.c
+++ b/src/mame/drivers/nexus3d.c
@@ -38,6 +38,11 @@ public:
UINT8* m_flash_region;
+ DECLARE_READ32_MEMBER(nexus3d_unk_r);
+// DECLARE_READ32_MEMBER(nexus3d_unk2_r);
+// DECLARE_READ32_MEMBER(nexus3d_unk3_r);
+// DECLARE_WRITE32_MEMBER(nexus3d_unk2_w);
+// DECLARE_WRITE32_MEMBER(nexus3d_unk3_w);
};
@@ -120,27 +125,27 @@ WRITE8_HANDLER( n3d_flash_addr_w )
}
-static READ32_HANDLER( nexus3d_unk_r )
+READ32_MEMBER(nexus3d_state::nexus3d_unk_r)
{
- return space->machine().rand() ^ (space->machine().rand() << 16);
+ return machine().rand() ^ (machine().rand() << 16);
}
-//static READ32_HANDLER( nexus3d_unk2_r )
+//READ32_MEMBER(nexus3d_state::nexus3d_unk2_r)
//{
-// return 0x00000000;//space->machine().rand() ^ (space->machine().rand() << 16);
+// return 0x00000000;//machine().rand() ^ (machine().rand() << 16);
//}
//
-//static READ32_HANDLER( nexus3d_unk3_r )
+//READ32_MEMBER(nexus3d_state::nexus3d_unk3_r)
//{
-// return 0x00000000;//space->machine().rand() ^ (space->machine().rand() << 16);
+// return 0x00000000;//machine().rand() ^ (machine().rand() << 16);
//}
//
-//static WRITE32_HANDLER( nexus3d_unk2_w )
+//WRITE32_MEMBER(nexus3d_state::nexus3d_unk2_w)
//{
//
//}
//
-//static WRITE32_HANDLER( nexus3d_unk3_w )
+//WRITE32_MEMBER(nexus3d_state::nexus3d_unk3_w)
//{
//
//}
@@ -156,10 +161,10 @@ static ADDRESS_MAP_START( nexus3d_map, AS_PROGRAM, 32, nexus3d_state )
AM_RANGE(0x9C000018, 0x9C00001b) AM_WRITE8_LEGACY(n3d_flash_addr_w, 0xffffffff)
// lots of accesses in this range
-// AM_RANGE(0xC0000F44, 0xC0000F47) AM_READWRITE_LEGACY(nexus3d_unk2_r, nexus3d_unk2_w ) // often
-// AM_RANGE(0xC0000F4C, 0xC0000F4f) AM_READWRITE_LEGACY(nexus3d_unk3_r, nexus3d_unk3_w ) // often
+// AM_RANGE(0xC0000F44, 0xC0000F47) AM_READWRITE(nexus3d_unk2_r, nexus3d_unk2_w ) // often
+// AM_RANGE(0xC0000F4C, 0xC0000F4f) AM_READWRITE(nexus3d_unk3_r, nexus3d_unk3_w ) // often
- AM_RANGE(0xE0000014, 0xE0000017) AM_READ_LEGACY(nexus3d_unk_r ) // sits waiting for this
+ AM_RANGE(0xE0000014, 0xE0000017) AM_READ(nexus3d_unk_r ) // sits waiting for this
ADDRESS_MAP_END
diff --git a/src/mame/drivers/nyny.c b/src/mame/drivers/nyny.c
index 3e967582b09..ce0e79ebf33 100644
--- a/src/mame/drivers/nyny.c
+++ b/src/mame/drivers/nyny.c
@@ -111,6 +111,11 @@ public:
pia6821_device *m_pia1;
pia6821_device *m_pia2;
pen_t m_pens[NUM_PENS];
+ DECLARE_WRITE8_MEMBER(audio_1_command_w);
+ DECLARE_WRITE8_MEMBER(audio_1_answer_w);
+ DECLARE_WRITE8_MEMBER(audio_2_command_w);
+ DECLARE_READ8_MEMBER(nyny_pia_1_2_r);
+ DECLARE_WRITE8_MEMBER(nyny_pia_1_2_w);
};
@@ -121,7 +126,7 @@ public:
*************************************/
static WRITE_LINE_DEVICE_HANDLER( flipscreen_w );
-static WRITE8_HANDLER( audio_2_command_w );
+
/*************************************
@@ -214,7 +219,7 @@ static WRITE8_DEVICE_HANDLER( pia_2_port_b_w )
state->m_star_enable = data & 0x10;
/* bits 5-7 go to the music board connector */
- audio_2_command_w(state->m_maincpu->memory().space(AS_PROGRAM), 0, data & 0xe0);
+ state->audio_2_command_w(*state->m_maincpu->memory().space(AS_PROGRAM), 0, data & 0xe0);
}
@@ -434,21 +439,19 @@ static const mc6845_interface mc6845_intf =
*
*************************************/
-static WRITE8_HANDLER( audio_1_command_w )
+WRITE8_MEMBER(nyny_state::audio_1_command_w)
{
- nyny_state *state = space->machine().driver_data<nyny_state>();
soundlatch_w(space, 0, data);
- device_set_input_line(state->m_audiocpu, M6800_IRQ_LINE, HOLD_LINE);
+ device_set_input_line(m_audiocpu, M6800_IRQ_LINE, HOLD_LINE);
}
-static WRITE8_HANDLER( audio_1_answer_w )
+WRITE8_MEMBER(nyny_state::audio_1_answer_w)
{
- nyny_state *state = space->machine().driver_data<nyny_state>();
soundlatch3_w(space, 0, data);
- device_set_input_line(state->m_maincpu, M6809_IRQ_LINE, HOLD_LINE);
+ device_set_input_line(m_maincpu, M6809_IRQ_LINE, HOLD_LINE);
}
@@ -489,12 +492,11 @@ static const ay8910_interface ay8910_64_interface =
*
*************************************/
-static WRITE8_HANDLER( audio_2_command_w )
+WRITE8_MEMBER(nyny_state::audio_2_command_w)
{
- nyny_state *state = space->machine().driver_data<nyny_state>();
soundlatch2_w(space, 0, (data & 0x60) >> 5);
- device_set_input_line(state->m_audiocpu2, M6800_IRQ_LINE, BIT(data, 7) ? CLEAR_LINE : ASSERT_LINE);
+ device_set_input_line(m_audiocpu2, M6800_IRQ_LINE, BIT(data, 7) ? CLEAR_LINE : ASSERT_LINE);
}
@@ -505,26 +507,24 @@ static WRITE8_HANDLER( audio_2_command_w )
*
*************************************/
-static READ8_HANDLER( nyny_pia_1_2_r )
+READ8_MEMBER(nyny_state::nyny_pia_1_2_r)
{
- nyny_state *state = space->machine().driver_data<nyny_state>();
UINT8 ret = 0;
/* the address bits are directly connected to the chip selects */
- if (BIT(offset, 2)) ret = state->m_pia1->read(*memory_nonspecific_space(space->machine()), offset & 0x03);
- if (BIT(offset, 3)) ret = state->m_pia2->read_alt(*memory_nonspecific_space(space->machine()), offset & 0x03);
+ if (BIT(offset, 2)) ret = m_pia1->read(space, offset & 0x03);
+ if (BIT(offset, 3)) ret = m_pia2->read_alt(space, offset & 0x03);
return ret;
}
-static WRITE8_HANDLER( nyny_pia_1_2_w )
+WRITE8_MEMBER(nyny_state::nyny_pia_1_2_w)
{
- nyny_state *state = space->machine().driver_data<nyny_state>();
/* the address bits are directly connected to the chip selects */
- if (BIT(offset, 2)) state->m_pia1->write(*memory_nonspecific_space(space->machine()), offset & 0x03, data);
- if (BIT(offset, 3)) state->m_pia2->write_alt(*memory_nonspecific_space(space->machine()), offset & 0x03, data);
+ if (BIT(offset, 2)) m_pia1->write(space, offset & 0x03, data);
+ if (BIT(offset, 3)) m_pia2->write_alt(space, offset & 0x03, data);
}
@@ -537,8 +537,8 @@ static ADDRESS_MAP_START( nyny_main_map, AS_PROGRAM, 8, nyny_state )
AM_RANGE(0xa000, 0xa0ff) AM_RAM AM_SHARE("nvram") /* SRAM (coin counter, shown when holding F2) */
AM_RANGE(0xa100, 0xa100) AM_MIRROR(0x00fe) AM_DEVWRITE("crtc", mc6845_device, address_w)
AM_RANGE(0xa101, 0xa101) AM_MIRROR(0x00fe) AM_DEVWRITE("crtc", mc6845_device, register_w)
- AM_RANGE(0xa200, 0xa20f) AM_MIRROR(0x00f0) AM_READWRITE_LEGACY(nyny_pia_1_2_r, nyny_pia_1_2_w)
- AM_RANGE(0xa300, 0xa300) AM_MIRROR(0x00ff) AM_READWRITE_LEGACY(soundlatch3_r, audio_1_command_w)
+ AM_RANGE(0xa200, 0xa20f) AM_MIRROR(0x00f0) AM_READWRITE(nyny_pia_1_2_r, nyny_pia_1_2_w)
+ AM_RANGE(0xa300, 0xa300) AM_MIRROR(0x00ff) AM_READ_LEGACY(soundlatch3_r) AM_WRITE(audio_1_command_w)
AM_RANGE(0xa400, 0xa7ff) AM_NOP
AM_RANGE(0xa800, 0xbfff) AM_ROM
AM_RANGE(0xc000, 0xdfff) AM_RAM
@@ -550,7 +550,7 @@ static ADDRESS_MAP_START( nyny_audio_1_map, AS_PROGRAM, 8, nyny_state )
ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x0000, 0x007f) AM_RAM /* internal RAM */
AM_RANGE(0x0080, 0x0fff) AM_NOP
- AM_RANGE(0x1000, 0x1000) AM_MIRROR(0x0fff) AM_READWRITE_LEGACY(soundlatch_r, audio_1_answer_w)
+ AM_RANGE(0x1000, 0x1000) AM_MIRROR(0x0fff) AM_READ_LEGACY(soundlatch_r) AM_WRITE(audio_1_answer_w)
AM_RANGE(0x2000, 0x2000) AM_MIRROR(0x0fff) AM_READ_PORT("SW3")
AM_RANGE(0x3000, 0x3000) AM_MIRROR(0x0ffc) AM_DEVREAD_LEGACY("ay1", ay8910_r)
AM_RANGE(0x3000, 0x3001) AM_MIRROR(0x0ffc) AM_DEVWRITE_LEGACY("ay1", ay8910_data_address_w)
diff --git a/src/mame/drivers/omegrace.c b/src/mame/drivers/omegrace.c
index 8895707b1fc..1e5728960c6 100644
--- a/src/mame/drivers/omegrace.c
+++ b/src/mame/drivers/omegrace.c
@@ -229,6 +229,10 @@ public:
omegrace_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) { }
+ DECLARE_READ8_MEMBER(omegrace_vg_go_r);
+ DECLARE_READ8_MEMBER(omegrace_spinner1_r);
+ DECLARE_WRITE8_MEMBER(omegrace_leds_w);
+ DECLARE_WRITE8_MEMBER(omegrace_soundlatch_w);
};
@@ -253,9 +257,9 @@ static MACHINE_RESET( omegrace )
*
*************************************/
-static READ8_HANDLER( omegrace_vg_go_r )
+READ8_MEMBER(omegrace_state::omegrace_vg_go_r)
{
- avgdvg_go_w(space,0,0);
+ avgdvg_go_w(&space,0,0);
return 0;
}
@@ -291,9 +295,9 @@ static const UINT8 spinnerTable[64] =
};
-static READ8_HANDLER( omegrace_spinner1_r )
+READ8_MEMBER(omegrace_state::omegrace_spinner1_r)
{
- return (spinnerTable[input_port_read(space->machine(), "SPIN0") & 0x3f]);
+ return (spinnerTable[input_port_read(machine(), "SPIN0") & 0x3f]);
}
@@ -304,26 +308,26 @@ static READ8_HANDLER( omegrace_spinner1_r )
*
*************************************/
-static WRITE8_HANDLER( omegrace_leds_w )
+WRITE8_MEMBER(omegrace_state::omegrace_leds_w)
{
/* bits 0 and 1 are coin counters */
- coin_counter_w(space->machine(), 0,data & 0x01);
- coin_counter_w(space->machine(), 1,data & 0x02);
+ coin_counter_w(machine(), 0,data & 0x01);
+ coin_counter_w(machine(), 1,data & 0x02);
/* bits 2 to 5 are the start leds (4 and 5 cocktail only) */
- set_led_status(space->machine(), 0,~data & 0x04);
- set_led_status(space->machine(), 1,~data & 0x08);
- set_led_status(space->machine(), 2,~data & 0x10);
- set_led_status(space->machine(), 3,~data & 0x20);
+ set_led_status(machine(), 0,~data & 0x04);
+ set_led_status(machine(), 1,~data & 0x08);
+ set_led_status(machine(), 2,~data & 0x10);
+ set_led_status(machine(), 3,~data & 0x20);
/* bit 6 flips screen (not supported) */
}
-static WRITE8_HANDLER( omegrace_soundlatch_w )
+WRITE8_MEMBER(omegrace_state::omegrace_soundlatch_w)
{
soundlatch_w (space, offset, data);
- cputag_set_input_line(space->machine(), "audiocpu", 0, HOLD_LINE);
+ cputag_set_input_line(machine(), "audiocpu", 0, HOLD_LINE);
}
@@ -345,7 +349,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( port_map, AS_IO, 8, omegrace_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE(0x08, 0x08) AM_READ_LEGACY(omegrace_vg_go_r)
+ AM_RANGE(0x08, 0x08) AM_READ(omegrace_vg_go_r)
AM_RANGE(0x09, 0x09) AM_READ_LEGACY(watchdog_reset_r)
AM_RANGE(0x0a, 0x0a) AM_WRITE_LEGACY(avgdvg_reset_w)
AM_RANGE(0x0b, 0x0b) AM_READ_PORT("AVGDVG") /* vg_halt */
@@ -353,9 +357,9 @@ static ADDRESS_MAP_START( port_map, AS_IO, 8, omegrace_state )
AM_RANGE(0x17, 0x17) AM_READ_PORT("DSW2") /* DIP SW C6 */
AM_RANGE(0x11, 0x11) AM_READ_PORT("IN0") /* Player 1 input */
AM_RANGE(0x12, 0x12) AM_READ_PORT("IN1") /* Player 2 input */
- AM_RANGE(0x13, 0x13) AM_WRITE_LEGACY(omegrace_leds_w) /* coin counters, leds, flip screen */
- AM_RANGE(0x14, 0x14) AM_WRITE_LEGACY(omegrace_soundlatch_w) /* Sound command */
- AM_RANGE(0x15, 0x15) AM_READ_LEGACY(omegrace_spinner1_r) /* 1st controller */
+ AM_RANGE(0x13, 0x13) AM_WRITE(omegrace_leds_w) /* coin counters, leds, flip screen */
+ AM_RANGE(0x14, 0x14) AM_WRITE(omegrace_soundlatch_w) /* Sound command */
+ AM_RANGE(0x15, 0x15) AM_READ(omegrace_spinner1_r) /* 1st controller */
AM_RANGE(0x16, 0x16) AM_READ_PORT("SPIN1") /* 2nd controller (cocktail) */
ADDRESS_MAP_END
diff --git a/src/mame/drivers/pasha2.c b/src/mame/drivers/pasha2.c
index d361ccc356c..fec1c91070b 100644
--- a/src/mame/drivers/pasha2.c
+++ b/src/mame/drivers/pasha2.c
@@ -93,12 +93,19 @@ public:
/* memory */
UINT16 m_bitmap0[0x40000/2];
UINT16 m_bitmap1[0x40000/2];
+ DECLARE_WRITE16_MEMBER(pasha2_misc_w);
+ DECLARE_WRITE16_MEMBER(pasha2_palette_w);
+ DECLARE_WRITE16_MEMBER(vbuffer_set_w);
+ DECLARE_WRITE16_MEMBER(vbuffer_clear_w);
+ DECLARE_WRITE16_MEMBER(bitmap_0_w);
+ DECLARE_WRITE16_MEMBER(bitmap_1_w);
+ DECLARE_WRITE16_MEMBER(pasha2_lamps_w);
+ DECLARE_READ16_MEMBER(pasha2_speedup_r);
};
-static WRITE16_HANDLER( pasha2_misc_w )
+WRITE16_MEMBER(pasha2_state::pasha2_misc_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
if (offset)
{
@@ -106,9 +113,9 @@ static WRITE16_HANDLER( pasha2_misc_w )
{
int bank = data & 0xf000;
- if (bank != state->m_old_bank)
+ if (bank != m_old_bank)
{
- state->m_old_bank = bank;
+ m_old_bank = bank;
switch (bank)
{
@@ -118,50 +125,45 @@ static WRITE16_HANDLER( pasha2_misc_w )
case 0xb000:
case 0xc000:
case 0xd000:
- memory_set_bankptr(space->machine(), "bank1", space->machine().region("user2")->base() + 0x400 * (bank - 0x8000)); break;
+ memory_set_bankptr(machine(), "bank1", machine().region("user2")->base() + 0x400 * (bank - 0x8000)); break;
}
}
}
}
}
-static WRITE16_HANDLER( pasha2_palette_w )
+WRITE16_MEMBER(pasha2_state::pasha2_palette_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
int color;
- COMBINE_DATA(&state->m_paletteram[offset]);
+ COMBINE_DATA(&m_paletteram[offset]);
offset &= 0xff;
- color = (state->m_paletteram[offset] >> 8) | (state->m_paletteram[offset + 0x100] & 0xff00);
- palette_set_color_rgb(space->machine(), offset * 2 + 0, pal5bit(color), pal5bit(color >> 5), pal5bit(color >> 10));
+ color = (m_paletteram[offset] >> 8) | (m_paletteram[offset + 0x100] & 0xff00);
+ palette_set_color_rgb(machine(), offset * 2 + 0, pal5bit(color), pal5bit(color >> 5), pal5bit(color >> 10));
- color = (state->m_paletteram[offset] & 0xff) | ((state->m_paletteram[offset + 0x100] & 0xff) << 8);
- palette_set_color_rgb(space->machine(), offset * 2 + 1, pal5bit(color), pal5bit(color >> 5), pal5bit(color >> 10));
+ color = (m_paletteram[offset] & 0xff) | ((m_paletteram[offset + 0x100] & 0xff) << 8);
+ palette_set_color_rgb(machine(), offset * 2 + 1, pal5bit(color), pal5bit(color >> 5), pal5bit(color >> 10));
}
-static WRITE16_HANDLER( vbuffer_set_w )
+WRITE16_MEMBER(pasha2_state::vbuffer_set_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
- state->m_vbuffer = 1;
+ m_vbuffer = 1;
}
-static WRITE16_HANDLER( vbuffer_clear_w )
+WRITE16_MEMBER(pasha2_state::vbuffer_clear_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
- state->m_vbuffer = 0;
+ m_vbuffer = 0;
}
-static WRITE16_HANDLER( bitmap_0_w )
+WRITE16_MEMBER(pasha2_state::bitmap_0_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
- COMBINE_DATA(&state->m_bitmap0[offset + state->m_vbuffer * 0x20000 / 2]);
+ COMBINE_DATA(&m_bitmap0[offset + m_vbuffer * 0x20000 / 2]);
}
-static WRITE16_HANDLER( bitmap_1_w )
+WRITE16_MEMBER(pasha2_state::bitmap_1_w)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
// handle overlapping pixels without writing them
switch (mem_mask)
@@ -182,7 +184,7 @@ static WRITE16_HANDLER( bitmap_1_w )
break;
}
- COMBINE_DATA(&state->m_bitmap1[offset + state->m_vbuffer * 0x20000 / 2]);
+ COMBINE_DATA(&m_bitmap1[offset + m_vbuffer * 0x20000 / 2]);
}
static WRITE16_DEVICE_HANDLER( oki_bank_w )
@@ -191,7 +193,7 @@ static WRITE16_DEVICE_HANDLER( oki_bank_w )
downcast<okim6295_device *>(device)->set_bank_base((data & 1) * 0x40000);
}
-static WRITE16_HANDLER( pasha2_lamps_w )
+WRITE16_MEMBER(pasha2_state::pasha2_lamps_w)
{
if (data)
popmessage("1P: %c%c%c 2P: %c%c%c 3P: %c%c%c",
@@ -208,29 +210,29 @@ static WRITE16_HANDLER( pasha2_lamps_w )
static ADDRESS_MAP_START( pasha2_map, AS_PROGRAM, 16, pasha2_state )
AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE(m_wram)
- AM_RANGE(0x40000000, 0x4001ffff) AM_RAM_WRITE_LEGACY(bitmap_0_w)
- AM_RANGE(0x40020000, 0x4003ffff) AM_RAM_WRITE_LEGACY(bitmap_1_w)
+ AM_RANGE(0x40000000, 0x4001ffff) AM_RAM_WRITE(bitmap_0_w)
+ AM_RANGE(0x40020000, 0x4003ffff) AM_RAM_WRITE(bitmap_1_w)
AM_RANGE(0x40060000, 0x40060001) AM_WRITENOP
AM_RANGE(0x40064000, 0x40064001) AM_WRITENOP
AM_RANGE(0x40068000, 0x40068001) AM_WRITENOP
AM_RANGE(0x4006c000, 0x4006c001) AM_WRITENOP
- AM_RANGE(0x40070000, 0x40070001) AM_WRITE_LEGACY(vbuffer_clear_w)
- AM_RANGE(0x40074000, 0x40074001) AM_WRITE_LEGACY(vbuffer_set_w)
+ AM_RANGE(0x40070000, 0x40070001) AM_WRITE(vbuffer_clear_w)
+ AM_RANGE(0x40074000, 0x40074001) AM_WRITE(vbuffer_set_w)
AM_RANGE(0x40078000, 0x40078001) AM_WRITENOP //once at startup -> to disable the eeprom?
AM_RANGE(0x80000000, 0x803fffff) AM_ROMBANK("bank1")
- AM_RANGE(0xe0000000, 0xe00003ff) AM_RAM_WRITE_LEGACY(pasha2_palette_w) AM_BASE(m_paletteram) //tilemap? palette?
+ AM_RANGE(0xe0000000, 0xe00003ff) AM_RAM_WRITE(pasha2_palette_w) AM_BASE(m_paletteram) //tilemap? palette?
AM_RANGE(0xfff80000, 0xffffffff) AM_ROM AM_REGION("user1",0)
ADDRESS_MAP_END
static ADDRESS_MAP_START( pasha2_io, AS_IO, 16, pasha2_state )
AM_RANGE(0x08, 0x0b) AM_READNOP //sound status?
AM_RANGE(0x18, 0x1b) AM_READNOP //sound status?
- AM_RANGE(0x20, 0x23) AM_WRITE_LEGACY(pasha2_lamps_w)
+ AM_RANGE(0x20, 0x23) AM_WRITE(pasha2_lamps_w)
AM_RANGE(0x40, 0x43) AM_READ_PORT("COINS")
AM_RANGE(0x60, 0x63) AM_READ_PORT("DSW")
AM_RANGE(0x80, 0x83) AM_READ_PORT("INPUTS")
AM_RANGE(0xa0, 0xa3) AM_WRITENOP //soundlatch?
- AM_RANGE(0xc0, 0xc3) AM_WRITE_LEGACY(pasha2_misc_w)
+ AM_RANGE(0xc0, 0xc3) AM_WRITE(pasha2_misc_w)
AM_RANGE(0xe2, 0xe3) AM_DEVREADWRITE8("oki1", okim6295_device, read, write, 0x00ff)
AM_RANGE(0xe6, 0xe7) AM_DEVREADWRITE8("oki2", okim6295_device, read, write, 0x00ff)
AM_RANGE(0xe8, 0xeb) AM_DEVWRITE_LEGACY("oki1", oki_bank_w)
@@ -458,19 +460,19 @@ ROM_START( pasha2 )
ROM_LOAD( "pp2.um53", 0x00000, 0x80000, CRC(8a29ad03) SHA1(3e9b0c86d8e3bb0b7691f68ad45431f6f9e8edbd) )
ROM_END
-static READ16_HANDLER( pasha2_speedup_r )
+READ16_MEMBER(pasha2_state::pasha2_speedup_r)
{
- pasha2_state *state = space->machine().driver_data<pasha2_state>();
- if(cpu_get_pc(&space->device()) == 0x8302)
- device_spin_until_interrupt(&space->device());
+ if(cpu_get_pc(&space.device()) == 0x8302)
+ device_spin_until_interrupt(&space.device());
- return state->m_wram[(0x95744 / 2) + offset];
+ return m_wram[(0x95744 / 2) + offset];
}
static DRIVER_INIT( pasha2 )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x95744, 0x95747, FUNC(pasha2_speedup_r) );
+ pasha2_state *state = machine.driver_data<pasha2_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x95744, 0x95747, read16_delegate(FUNC(pasha2_state::pasha2_speedup_r), state));
memory_set_bankptr(machine, "bank1", machine.region("user2")->base());
}
diff --git a/src/mame/drivers/pinkiri8.c b/src/mame/drivers/pinkiri8.c
index 7411201cac0..01893754928 100644
--- a/src/mame/drivers/pinkiri8.c
+++ b/src/mame/drivers/pinkiri8.c
@@ -54,6 +54,15 @@ public:
UINT8 m_prot_read_index;
UINT8 m_prot_char[6];
UINT8 m_prot_index;
+ DECLARE_WRITE8_MEMBER(output_regs_w);
+ DECLARE_WRITE8_MEMBER(pinkiri8_vram_w);
+ DECLARE_WRITE8_MEMBER(mux_w);
+ DECLARE_READ8_MEMBER(mux_p2_r);
+ DECLARE_READ8_MEMBER(mux_p1_r);
+ DECLARE_READ8_MEMBER(ronjan_prot_r);
+ DECLARE_WRITE8_MEMBER(ronjan_prot_w);
+ DECLARE_READ8_MEMBER(ronjan_prot_status_r);
+ DECLARE_READ8_MEMBER(ronjan_patched_prot_r);
};
@@ -381,82 +390,78 @@ static ADDRESS_MAP_START( pinkiri8_map, AS_PROGRAM, 8, pinkiri8_state )
AM_RANGE(0x10000, 0x1ffff) AM_ROM
ADDRESS_MAP_END
-static WRITE8_HANDLER( output_regs_w )
+WRITE8_MEMBER(pinkiri8_state::output_regs_w)
{
if(data & 0x40)
- cputag_set_input_line(space->machine(), "maincpu", INPUT_LINE_NMI, CLEAR_LINE);
+ cputag_set_input_line(machine(), "maincpu", INPUT_LINE_NMI, CLEAR_LINE);
//data & 0x80 is probably NMI mask
}
#define LOG_VRAM 0
-static WRITE8_HANDLER( pinkiri8_vram_w )
+WRITE8_MEMBER(pinkiri8_state::pinkiri8_vram_w)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
switch(offset)
{
case 0:
- state->m_vram_addr = (data << 0) | (state->m_vram_addr&0xffff00);
- if (LOG_VRAM) printf("\n prev writes was %04x\n\naddress set to %04x -\n", state->m_prev_writes, state->m_vram_addr );
- state->m_prev_writes = 0;
+ m_vram_addr = (data << 0) | (m_vram_addr&0xffff00);
+ if (LOG_VRAM) printf("\n prev writes was %04x\n\naddress set to %04x -\n", m_prev_writes, m_vram_addr );
+ m_prev_writes = 0;
break;
case 1:
- state->m_vram_addr = (data << 8) | (state->m_vram_addr & 0xff00ff);
- if (LOG_VRAM)printf("\naddress set to %04x\n", state->m_vram_addr);
+ m_vram_addr = (data << 8) | (m_vram_addr & 0xff00ff);
+ if (LOG_VRAM)printf("\naddress set to %04x\n", m_vram_addr);
break;
case 2:
- state->m_vram_addr = (data << 16) | (state->m_vram_addr & 0x00ffff);
- if (LOG_VRAM)printf("\naddress set to %04x\n", state->m_vram_addr);
+ m_vram_addr = (data << 16) | (m_vram_addr & 0x00ffff);
+ if (LOG_VRAM)printf("\naddress set to %04x\n", m_vram_addr);
break;
case 3:
- address_space *vdp_space = space->machine().device<janshi_vdp_device>("janshivdp")->space();
+ address_space *vdp_space = machine().device<janshi_vdp_device>("janshivdp")->space();
if (LOG_VRAM) printf("%02x ", data);
- state->m_prev_writes++;
- state->m_vram_addr++;
+ m_prev_writes++;
+ m_vram_addr++;
- vdp_space->write_byte(state->m_vram_addr, data);
+ vdp_space->write_byte(m_vram_addr, data);
break;
}
}
-static WRITE8_HANDLER( mux_w )
+WRITE8_MEMBER(pinkiri8_state::mux_w)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
- state->m_mux_data = data;
+ m_mux_data = data;
}
-static READ8_HANDLER( mux_p2_r )
+READ8_MEMBER(pinkiri8_state::mux_p2_r)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
- switch(state->m_mux_data)
+ switch(m_mux_data)
{
- case 0x01: return input_port_read(space->machine(), "PL2_01");
- case 0x02: return input_port_read(space->machine(), "PL2_02");
- case 0x04: return input_port_read(space->machine(), "PL2_03");
- case 0x08: return input_port_read(space->machine(), "PL2_04");
- case 0x10: return input_port_read(space->machine(), "PL2_05");
+ case 0x01: return input_port_read(machine(), "PL2_01");
+ case 0x02: return input_port_read(machine(), "PL2_02");
+ case 0x04: return input_port_read(machine(), "PL2_03");
+ case 0x08: return input_port_read(machine(), "PL2_04");
+ case 0x10: return input_port_read(machine(), "PL2_05");
}
return 0xff;
}
-static READ8_HANDLER( mux_p1_r )
+READ8_MEMBER(pinkiri8_state::mux_p1_r)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
- switch(state->m_mux_data)
+ switch(m_mux_data)
{
- case 0x01: return input_port_read(space->machine(), "PL1_01");
- case 0x02: return input_port_read(space->machine(), "PL1_02");
- case 0x04: return input_port_read(space->machine(), "PL1_03");
- case 0x08: return input_port_read(space->machine(), "PL1_04");
- case 0x10: return input_port_read(space->machine(), "PL1_05");
+ case 0x01: return input_port_read(machine(), "PL1_01");
+ case 0x02: return input_port_read(machine(), "PL1_02");
+ case 0x04: return input_port_read(machine(), "PL1_03");
+ case 0x08: return input_port_read(machine(), "PL1_04");
+ case 0x10: return input_port_read(machine(), "PL1_05");
}
return 0xff;
@@ -465,13 +470,13 @@ static READ8_HANDLER( mux_p1_r )
static ADDRESS_MAP_START( pinkiri8_io, AS_IO, 8, pinkiri8_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x00, 0x3f) AM_RAM //Z180 internal I/O
- AM_RANGE(0x60, 0x60) AM_WRITE_LEGACY(output_regs_w)
- AM_RANGE(0x80, 0x83) AM_WRITE_LEGACY(pinkiri8_vram_w)
+ AM_RANGE(0x60, 0x60) AM_WRITE(output_regs_w)
+ AM_RANGE(0x80, 0x83) AM_WRITE(pinkiri8_vram_w)
AM_RANGE(0xa0, 0xa0) AM_DEVREADWRITE("oki", okim6295_device, read, write) //correct?
- AM_RANGE(0xb0, 0xb0) AM_WRITE_LEGACY(mux_w) //mux
- AM_RANGE(0xb0, 0xb0) AM_READ_LEGACY(mux_p2_r) // mux inputs
- AM_RANGE(0xb1, 0xb1) AM_READ_LEGACY(mux_p1_r) // mux inputs
+ AM_RANGE(0xb0, 0xb0) AM_WRITE(mux_w) //mux
+ AM_RANGE(0xb0, 0xb0) AM_READ(mux_p2_r) // mux inputs
+ AM_RANGE(0xb1, 0xb1) AM_READ(mux_p1_r) // mux inputs
AM_RANGE(0xb2, 0xb2) AM_READ_PORT("SYSTEM")
AM_RANGE(0xf8, 0xf8) AM_READ_PORT("DSW1")
AM_RANGE(0xf9, 0xf9) AM_READ_PORT("DSW2")
@@ -1173,52 +1178,51 @@ ROM_START( ronjan )
ROM_END
-static READ8_HANDLER( ronjan_prot_r )
+READ8_MEMBER(pinkiri8_state::ronjan_prot_r)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
static const char wing_str[6] = { 'W', 'I', 'N', 'G', '8', '9' };
- state->m_prot_read_index++;
+ m_prot_read_index++;
- if(state->m_prot_read_index & 1)
+ if(m_prot_read_index & 1)
return 0xff; //value is discarded
- return wing_str[(state->m_prot_read_index >> 1)-1];
+ return wing_str[(m_prot_read_index >> 1)-1];
}
-static WRITE8_HANDLER( ronjan_prot_w )
+WRITE8_MEMBER(pinkiri8_state::ronjan_prot_w)
{
- pinkiri8_state *state = space->machine().driver_data<pinkiri8_state>();
if(data == 0)
{
- state->m_prot_index = 0;
+ m_prot_index = 0;
}
else
{
- state->m_prot_char[state->m_prot_index] = data;
- state->m_prot_index++;
+ m_prot_char[m_prot_index] = data;
+ m_prot_index++;
- if(state->m_prot_char[0] == 'E' && state->m_prot_char[1] == 'R' && state->m_prot_char[2] == 'R' && state->m_prot_char[3] == 'O' && state->m_prot_char[4] == 'R')
- state->m_prot_read_index = 0;
+ if(m_prot_char[0] == 'E' && m_prot_char[1] == 'R' && m_prot_char[2] == 'R' && m_prot_char[3] == 'O' && m_prot_char[4] == 'R')
+ m_prot_read_index = 0;
}
}
-static READ8_HANDLER( ronjan_prot_status_r )
+READ8_MEMBER(pinkiri8_state::ronjan_prot_status_r)
{
return 0; //bit 0 seems a protection status bit
}
-static READ8_HANDLER( ronjan_patched_prot_r )
+READ8_MEMBER(pinkiri8_state::ronjan_patched_prot_r)
{
return 0; //value is read then discarded
}
static DRIVER_INIT( ronjan )
{
- machine.device("maincpu")->memory().space(AS_IO)->install_legacy_readwrite_handler(0x90, 0x90, FUNC(ronjan_prot_r), FUNC(ronjan_prot_w));
- machine.device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x66, 0x66, FUNC(ronjan_prot_status_r));
- machine.device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x9f, 0x9f, FUNC(ronjan_patched_prot_r));
+ pinkiri8_state *state = machine.driver_data<pinkiri8_state>();
+ machine.device("maincpu")->memory().space(AS_IO)->install_readwrite_handler(0x90, 0x90, read8_delegate(FUNC(pinkiri8_state::ronjan_prot_r), state), write8_delegate(FUNC(pinkiri8_state::ronjan_prot_w), state));
+ machine.device("maincpu")->memory().space(AS_IO)->install_read_handler(0x66, 0x66, read8_delegate(FUNC(pinkiri8_state::ronjan_prot_status_r), state));
+ machine.device("maincpu")->memory().space(AS_IO)->install_read_handler(0x9f, 0x9f, read8_delegate(FUNC(pinkiri8_state::ronjan_patched_prot_r), state));
}
GAME( 1992, janshi, 0, pinkiri8, janshi, 0, ROT0, "Eagle", "Janshi", GAME_IMPERFECT_SOUND | GAME_IMPERFECT_GRAPHICS | GAME_NOT_WORKING )
diff --git a/src/mame/drivers/poo.c b/src/mame/drivers/poo.c
index e6356210e44..ae95074ebf4 100644
--- a/src/mame/drivers/poo.c
+++ b/src/mame/drivers/poo.c
@@ -56,6 +56,13 @@ public:
UINT8 *m_scrolly;
UINT8 *m_sprites;
UINT8 m_vram_colbank;
+ DECLARE_READ8_MEMBER(unk_inp_r);
+ DECLARE_READ8_MEMBER(unk_inp2_r);
+ DECLARE_READ8_MEMBER(unk_inp3_r);
+ DECLARE_WRITE8_MEMBER(unk_w);
+ DECLARE_WRITE8_MEMBER(sound_cmd_w);
+ DECLARE_WRITE8_MEMBER(poo_vregs_w);
+ DECLARE_READ8_MEMBER(timer_r);
};
@@ -106,56 +113,55 @@ static SCREEN_UPDATE_IND16(unclepoo)
return 0;
}
-static READ8_HANDLER( unk_inp_r )
+READ8_MEMBER(poo_state::unk_inp_r)
{
- return 0x00;//space->machine().rand();
+ return 0x00;//machine().rand();
}
#if 0
-static READ8_HANDLER( unk_inp2_r )
+READ8_MEMBER(poo_state::unk_inp2_r)
{
return 0xff;
}
-static READ8_HANDLER( unk_inp3_r )
+READ8_MEMBER(poo_state::unk_inp3_r)
{
- return space->machine().rand();
+ return machine().rand();
}
#endif
#if 0
-static WRITE8_HANDLER( unk_w )
+WRITE8_MEMBER(poo_state::unk_w)
{
printf("%02x %02x\n",data,offset);
}
#endif
/* soundlatch write */
-static WRITE8_HANDLER( sound_cmd_w )
+WRITE8_MEMBER(poo_state::sound_cmd_w)
{
soundlatch_w(space, 0, (data & 0xff));
- cputag_set_input_line(space->machine(), "subcpu", 0, HOLD_LINE);
+ cputag_set_input_line(machine(), "subcpu", 0, HOLD_LINE);
}
-static WRITE8_HANDLER( poo_vregs_w )
+WRITE8_MEMBER(poo_state::poo_vregs_w)
{
- poo_state *state = space->machine().driver_data<poo_state>();
// bit 2 used, unknown purpose
- state->m_vram_colbank = data & 0x18;
+ m_vram_colbank = data & 0x18;
}
static ADDRESS_MAP_START( unclepoo_main_map, AS_PROGRAM, 8, poo_state )
AM_RANGE(0x0000, 0x7fff) AM_ROM AM_WRITENOP
AM_RANGE(0x8000, 0x8fff) AM_RAM
AM_RANGE(0x9000, 0x97ff) AM_RAM
- AM_RANGE(0x9800, 0x9801) AM_READ_LEGACY(unk_inp_r) //AM_WRITE_LEGACY(unk_w )
+ AM_RANGE(0x9800, 0x9801) AM_READ(unk_inp_r) //AM_WRITE(unk_w )
AM_RANGE(0xb000, 0xb07f) AM_RAM AM_BASE(m_sprites)
AM_RANGE(0xb080, 0xb0ff) AM_RAM AM_BASE(m_scrolly)
- AM_RANGE(0xb400, 0xb400) AM_WRITE_LEGACY(sound_cmd_w)
+ AM_RANGE(0xb400, 0xb400) AM_WRITE(sound_cmd_w)
AM_RANGE(0xb500, 0xb500) AM_READ_PORT("DSW1")
AM_RANGE(0xb501, 0xb501) AM_READ_PORT("DSW2")
@@ -163,7 +169,7 @@ static ADDRESS_MAP_START( unclepoo_main_map, AS_PROGRAM, 8, poo_state )
AM_RANGE(0xb503, 0xb503) AM_READ_PORT("P2")
AM_RANGE(0xb504, 0xb504) AM_READ_PORT("SYSTEM")
- AM_RANGE(0xb700, 0xb700) AM_WRITE_LEGACY(poo_vregs_w)
+ AM_RANGE(0xb700, 0xb700) AM_WRITE(poo_vregs_w)
AM_RANGE(0xb800, 0xbfff) AM_RAM AM_BASE(m_vram)
@@ -306,9 +312,9 @@ static PALETTE_INIT( unclepoo )
}
}
- static READ8_HANDLER( timer_r )
+READ8_MEMBER(poo_state::timer_r)
{
- return downcast<cpu_device *>(&space->device())->total_cycles() / 16;
+ return downcast<cpu_device *>(&space.device())->total_cycles() / 16;
}
@@ -317,7 +323,7 @@ static const ay8910_interface ay8910_config =
AY8910_LEGACY_OUTPUT,
AY8910_DEFAULT_LOADS,
DEVCB_MEMORY_HANDLER("subcpu", PROGRAM, soundlatch_r),
- DEVCB_MEMORY_HANDLER("subcpu", PROGRAM, timer_r),
+ DEVCB_DRIVER_MEMBER(poo_state, timer_r),
DEVCB_NULL,
DEVCB_NULL
};
diff --git a/src/mame/drivers/r2dtank.c b/src/mame/drivers/r2dtank.c
index 1ef0f8fc577..a77eb363c07 100644
--- a/src/mame/drivers/r2dtank.c
+++ b/src/mame/drivers/r2dtank.c
@@ -61,6 +61,10 @@ public:
UINT32 m_ttl74123_output;
UINT8 m_AY8910_selected;
pen_t m_pens[NUM_PENS];
+ DECLARE_READ8_MEMBER(audio_command_r);
+ DECLARE_WRITE8_MEMBER(audio_command_w);
+ DECLARE_READ8_MEMBER(audio_answer_r);
+ DECLARE_WRITE8_MEMBER(audio_answer_w);
};
@@ -99,44 +103,44 @@ static WRITE_LINE_DEVICE_HANDLER( main_cpu_irq )
*
*************************************/
-static READ8_HANDLER( audio_command_r )
+READ8_MEMBER(r2dtank_state::audio_command_r)
{
UINT8 ret = soundlatch_r(space, 0);
-if (LOG_AUDIO_COMM) logerror("%08X CPU#1 Audio Command Read: %x\n", cpu_get_pc(&space->device()), ret);
+if (LOG_AUDIO_COMM) logerror("%08X CPU#1 Audio Command Read: %x\n", cpu_get_pc(&space.device()), ret);
return ret;
}
-static WRITE8_HANDLER( audio_command_w )
+WRITE8_MEMBER(r2dtank_state::audio_command_w)
{
soundlatch_w(space, 0, ~data);
- cputag_set_input_line(space->machine(), "audiocpu", M6800_IRQ_LINE, HOLD_LINE);
+ cputag_set_input_line(machine(), "audiocpu", M6800_IRQ_LINE, HOLD_LINE);
-if (LOG_AUDIO_COMM) logerror("%08X CPU#0 Audio Command Write: %x\n", cpu_get_pc(&space->device()), data^0xff);
+if (LOG_AUDIO_COMM) logerror("%08X CPU#0 Audio Command Write: %x\n", cpu_get_pc(&space.device()), data^0xff);
}
-static READ8_HANDLER( audio_answer_r )
+READ8_MEMBER(r2dtank_state::audio_answer_r)
{
UINT8 ret = soundlatch2_r(space, 0);
-if (LOG_AUDIO_COMM) logerror("%08X CPU#0 Audio Answer Read: %x\n", cpu_get_pc(&space->device()), ret);
+if (LOG_AUDIO_COMM) logerror("%08X CPU#0 Audio Answer Read: %x\n", cpu_get_pc(&space.device()), ret);
return ret;
}
-static WRITE8_HANDLER( audio_answer_w )
+WRITE8_MEMBER(r2dtank_state::audio_answer_w)
{
/* HACK - prevents lock-up, but causes game to end some in-between sreens prematurely */
- if (cpu_get_pc(&space->device()) == 0xfb12)
+ if (cpu_get_pc(&space.device()) == 0xfb12)
data = 0x00;
soundlatch2_w(space, 0, data);
- cputag_set_input_line(space->machine(), "maincpu", M6809_IRQ_LINE, HOLD_LINE);
+ cputag_set_input_line(machine(), "maincpu", M6809_IRQ_LINE, HOLD_LINE);
-if (LOG_AUDIO_COMM) logerror("%08X CPU#1 Audio Answer Write: %x\n", cpu_get_pc(&space->device()), data);
+if (LOG_AUDIO_COMM) logerror("%08X CPU#1 Audio Answer Write: %x\n", cpu_get_pc(&space.device()), data);
}
@@ -416,7 +420,7 @@ static ADDRESS_MAP_START( r2dtank_main_map, AS_PROGRAM, 8, r2dtank_state )
AM_RANGE(0x4000, 0x5fff) AM_RAM AM_BASE(m_colorram)
AM_RANGE(0x6000, 0x7fff) AM_RAM
AM_RANGE(0x8000, 0x8003) AM_DEVREAD("pia_main", pia6821_device, read) AM_DEVWRITE_LEGACY("pia_main", pia_comp_w)
- AM_RANGE(0x8004, 0x8004) AM_READWRITE_LEGACY(audio_answer_r, audio_command_w)
+ AM_RANGE(0x8004, 0x8004) AM_READWRITE(audio_answer_r, audio_command_w)
AM_RANGE(0xb000, 0xb000) AM_DEVWRITE("crtc", mc6845_device, address_w)
AM_RANGE(0xb001, 0xb001) AM_DEVWRITE("crtc", mc6845_device, register_w)
AM_RANGE(0xc000, 0xc007) AM_RAM AM_SHARE("nvram")
@@ -427,7 +431,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( r2dtank_audio_map, AS_PROGRAM, 8, r2dtank_state )
AM_RANGE(0x0000, 0x007f) AM_RAM /* internal RAM */
AM_RANGE(0xd000, 0xd003) AM_DEVREADWRITE("pia_audio", pia6821_device, read, write)
- AM_RANGE(0xf000, 0xf000) AM_READWRITE_LEGACY(audio_command_r, audio_answer_w)
+ AM_RANGE(0xf000, 0xf000) AM_READWRITE(audio_command_r, audio_answer_w)
AM_RANGE(0xf800, 0xffff) AM_ROM
ADDRESS_MAP_END
diff --git a/src/mame/drivers/rmhaihai.c b/src/mame/drivers/rmhaihai.c
index b6fb68ffe8e..f44b0cec4e7 100644
--- a/src/mame/drivers/rmhaihai.c
+++ b/src/mame/drivers/rmhaihai.c
@@ -45,22 +45,27 @@ public:
UINT8 *m_colorram;
tilemap_t *m_bg_tilemap;
int m_keyboard_cmd;
+ DECLARE_WRITE8_MEMBER(rmhaihai_videoram_w);
+ DECLARE_WRITE8_MEMBER(rmhaihai_colorram_w);
+ DECLARE_READ8_MEMBER(keyboard_r);
+ DECLARE_WRITE8_MEMBER(keyboard_w);
+ DECLARE_READ8_MEMBER(samples_r);
+ DECLARE_WRITE8_MEMBER(ctrl_w);
+ DECLARE_WRITE8_MEMBER(themj_rombank_w);
};
-static WRITE8_HANDLER( rmhaihai_videoram_w )
+WRITE8_MEMBER(rmhaihai_state::rmhaihai_videoram_w)
{
- rmhaihai_state *state = space->machine().driver_data<rmhaihai_state>();
- state->m_videoram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_videoram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( rmhaihai_colorram_w )
+WRITE8_MEMBER(rmhaihai_state::rmhaihai_colorram_w)
{
- rmhaihai_state *state = space->machine().driver_data<rmhaihai_state>();
- state->m_colorram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_colorram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_bg_tile_info )
@@ -90,13 +95,12 @@ static SCREEN_UPDATE_IND16( rmhaihai )
-static READ8_HANDLER( keyboard_r )
+READ8_MEMBER(rmhaihai_state::keyboard_r)
{
- rmhaihai_state *state = space->machine().driver_data<rmhaihai_state>();
static const char *const keynames[] = { "KEY0", "KEY1" };
- logerror("%04x: keyboard_r\n",cpu_get_pc(&space->device()));
- switch(cpu_get_pc(&space->device()))
+ logerror("%04x: keyboard_r\n",cpu_get_pc(&space.device()));
+ switch(cpu_get_pc(&space.device()))
{
/* read keyboard */
case 0x0aba: // rmhaihai, rmhaisei
@@ -108,9 +112,9 @@ static READ8_HANDLER( keyboard_r )
for (i = 0; i < 31; i++)
{
- if (input_port_read(space->machine(), keynames[i/16]) & (1 << (i & 15))) return i+1;
+ if (input_port_read(machine(), keynames[i/16]) & (1 << (i & 15))) return i+1;
}
- if (input_port_read(space->machine(), "KEY1") & 0x8000) return 0x80; // coin
+ if (input_port_read(machine(), "KEY1") & 0x8000) return 0x80; // coin
return 0;
}
case 0x5c7b: // rmhaihai, rmhaisei, rmhaijin
@@ -120,20 +124,20 @@ static READ8_HANDLER( keyboard_r )
case 0x13a: // additional checks done by rmhaijin
- if (state->m_keyboard_cmd == 0x3b) return 0xdd;
- if (state->m_keyboard_cmd == 0x85) return 0xdc;
- if (state->m_keyboard_cmd == 0xf2) return 0xd6;
- if (state->m_keyboard_cmd == 0xc1) return 0x8f;
- if (state->m_keyboard_cmd == 0xd0) return 0x08;
+ if (m_keyboard_cmd == 0x3b) return 0xdd;
+ if (m_keyboard_cmd == 0x85) return 0xdc;
+ if (m_keyboard_cmd == 0xf2) return 0xd6;
+ if (m_keyboard_cmd == 0xc1) return 0x8f;
+ if (m_keyboard_cmd == 0xd0) return 0x08;
return 0;
case 0x140: // additional checks done by rmhaisei
case 0x155: // additional checks done by themj, but they are patched out!
- if (state->m_keyboard_cmd == 0x11) return 0x57;
- if (state->m_keyboard_cmd == 0x3e) return 0xda;
- if (state->m_keyboard_cmd == 0x48) return 0x74;
- if (state->m_keyboard_cmd == 0x5d) return 0x46;
- if (state->m_keyboard_cmd == 0xd0) return 0x08;
+ if (m_keyboard_cmd == 0x11) return 0x57;
+ if (m_keyboard_cmd == 0x3e) return 0xda;
+ if (m_keyboard_cmd == 0x48) return 0x74;
+ if (m_keyboard_cmd == 0x5d) return 0x46;
+ if (m_keyboard_cmd == 0xd0) return 0x08;
return 0;
}
@@ -141,16 +145,15 @@ static READ8_HANDLER( keyboard_r )
return 0;
}
-static WRITE8_HANDLER( keyboard_w )
+WRITE8_MEMBER(rmhaihai_state::keyboard_w)
{
- rmhaihai_state *state = space->machine().driver_data<rmhaihai_state>();
-logerror("%04x: keyboard_w %02x\n",cpu_get_pc(&space->device()),data);
- state->m_keyboard_cmd = data;
+logerror("%04x: keyboard_w %02x\n",cpu_get_pc(&space.device()),data);
+ m_keyboard_cmd = data;
}
-static READ8_HANDLER( samples_r )
+READ8_MEMBER(rmhaihai_state::samples_r)
{
- return space->machine().region("adpcm")->base()[offset];
+ return machine().region("adpcm")->base()[offset];
}
static WRITE8_DEVICE_HANDLER( adpcm_w )
@@ -160,33 +163,33 @@ static WRITE8_DEVICE_HANDLER( adpcm_w )
msm5205_vclk_w (device,(data>>4)&1); /* bit4 */
}
-static WRITE8_HANDLER( ctrl_w )
+WRITE8_MEMBER(rmhaihai_state::ctrl_w)
{
- rmhaihai_state *state = space->machine().driver_data<rmhaihai_state>();
- flip_screen_set(space->machine(), data & 0x01);
+ flip_screen_set(machine(), data & 0x01);
// (data & 0x02) is switched on and off in service mode
- coin_lockout_w(space->machine(), 0, ~data & 0x04);
- coin_counter_w(space->machine(), 0, data & 0x08);
+ coin_lockout_w(machine(), 0, ~data & 0x04);
+ coin_counter_w(machine(), 0, data & 0x08);
// (data & 0x10) is medal in service mode
- state->m_gfxbank = (data & 0x40) >> 6; /* rmhaisei only */
+ m_gfxbank = (data & 0x40) >> 6; /* rmhaisei only */
}
-static WRITE8_HANDLER( themj_rombank_w )
+WRITE8_MEMBER(rmhaihai_state::themj_rombank_w)
{
- UINT8 *rom = space->machine().region("maincpu")->base() + 0x10000;
+ UINT8 *rom = machine().region("maincpu")->base() + 0x10000;
int bank = data & 0x03;
logerror("banksw %d\n",bank);
- memory_set_bankptr(space->machine(), "bank1", rom + bank*0x4000);
- memory_set_bankptr(space->machine(), "bank2", rom + bank*0x4000 + 0x2000);
+ memory_set_bankptr(machine(), "bank1", rom + bank*0x4000);
+ memory_set_bankptr(machine(), "bank2", rom + bank*0x4000 + 0x2000);
}
static MACHINE_RESET( themj )
{
- themj_rombank_w(machine.device("maincpu")->memory().space(AS_IO), 0, 0);
+ rmhaihai_state *state = machine.driver_data<rmhaihai_state>();
+ state->themj_rombank_w(*machine.device("maincpu")->memory().space(AS_IO), 0, 0);
}
@@ -194,8 +197,8 @@ static MACHINE_RESET( themj )
static ADDRESS_MAP_START( rmhaihai_map, AS_PROGRAM, 8, rmhaihai_state )
AM_RANGE(0x0000, 0x9fff) AM_ROM
AM_RANGE(0xa000, 0xa7ff) AM_RAM
- AM_RANGE(0xa800, 0xafff) AM_RAM_WRITE_LEGACY(rmhaihai_colorram_w) AM_BASE(m_colorram)
- AM_RANGE(0xb000, 0xb7ff) AM_RAM_WRITE_LEGACY(rmhaihai_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0xa800, 0xafff) AM_RAM_WRITE(rmhaihai_colorram_w) AM_BASE(m_colorram)
+ AM_RANGE(0xb000, 0xb7ff) AM_RAM_WRITE(rmhaihai_videoram_w) AM_BASE(m_videoram)
AM_RANGE(0xb83c, 0xb83c) AM_WRITENOP // ??
AM_RANGE(0xbc00, 0xbc00) AM_WRITENOP // ??
AM_RANGE(0xc000, 0xdfff) AM_ROM
@@ -203,13 +206,13 @@ static ADDRESS_MAP_START( rmhaihai_map, AS_PROGRAM, 8, rmhaihai_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( rmhaihai_io_map, AS_IO, 8, rmhaihai_state )
- AM_RANGE(0x0000, 0x7fff) AM_READ_LEGACY(samples_r)
- AM_RANGE(0x8000, 0x8000) AM_READ_LEGACY(keyboard_r) AM_WRITENOP // ??
- AM_RANGE(0x8001, 0x8001) AM_READNOP AM_WRITE_LEGACY(keyboard_w) // ??
+ AM_RANGE(0x0000, 0x7fff) AM_READ(samples_r)
+ AM_RANGE(0x8000, 0x8000) AM_READ(keyboard_r) AM_WRITENOP // ??
+ AM_RANGE(0x8001, 0x8001) AM_READNOP AM_WRITE(keyboard_w) // ??
AM_RANGE(0x8020, 0x8020) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x8020, 0x8021) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
AM_RANGE(0x8040, 0x8040) AM_DEVWRITE_LEGACY("msm", adpcm_w)
- AM_RANGE(0x8060, 0x8060) AM_WRITE_LEGACY(ctrl_w)
+ AM_RANGE(0x8060, 0x8060) AM_WRITE(ctrl_w)
AM_RANGE(0x8080, 0x8080) AM_WRITENOP // ??
AM_RANGE(0xbc04, 0xbc04) AM_WRITENOP // ??
AM_RANGE(0xbc0c, 0xbc0c) AM_WRITENOP // ??
@@ -219,22 +222,22 @@ static ADDRESS_MAP_START( themj_map, AS_PROGRAM, 8, rmhaihai_state )
AM_RANGE(0x0000, 0x7fff) AM_ROM
AM_RANGE(0x8000, 0x9fff) AM_ROMBANK("bank1")
AM_RANGE(0xa000, 0xa7ff) AM_RAM
- AM_RANGE(0xa800, 0xafff) AM_RAM_WRITE_LEGACY(rmhaihai_colorram_w) AM_BASE(m_colorram)
- AM_RANGE(0xb000, 0xb7ff) AM_RAM_WRITE_LEGACY(rmhaihai_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0xa800, 0xafff) AM_RAM_WRITE(rmhaihai_colorram_w) AM_BASE(m_colorram)
+ AM_RANGE(0xb000, 0xb7ff) AM_RAM_WRITE(rmhaihai_videoram_w) AM_BASE(m_videoram)
AM_RANGE(0xc000, 0xdfff) AM_ROMBANK("bank2")
AM_RANGE(0xe000, 0xffff) AM_ROM
ADDRESS_MAP_END
static ADDRESS_MAP_START( themj_io_map, AS_IO, 8, rmhaihai_state )
- AM_RANGE(0x0000, 0x7fff) AM_READ_LEGACY(samples_r)
- AM_RANGE(0x8000, 0x8000) AM_READ_LEGACY(keyboard_r) AM_WRITENOP // ??
- AM_RANGE(0x8001, 0x8001) AM_READNOP AM_WRITE_LEGACY(keyboard_w) // ??
+ AM_RANGE(0x0000, 0x7fff) AM_READ(samples_r)
+ AM_RANGE(0x8000, 0x8000) AM_READ(keyboard_r) AM_WRITENOP // ??
+ AM_RANGE(0x8001, 0x8001) AM_READNOP AM_WRITE(keyboard_w) // ??
AM_RANGE(0x8020, 0x8020) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0x8020, 0x8021) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
AM_RANGE(0x8040, 0x8040) AM_DEVWRITE_LEGACY("msm", adpcm_w)
- AM_RANGE(0x8060, 0x8060) AM_WRITE_LEGACY(ctrl_w)
+ AM_RANGE(0x8060, 0x8060) AM_WRITE(ctrl_w)
AM_RANGE(0x8080, 0x8080) AM_WRITENOP // ??
- AM_RANGE(0x80a0, 0x80a0) AM_WRITE_LEGACY(themj_rombank_w)
+ AM_RANGE(0x80a0, 0x80a0) AM_WRITE(themj_rombank_w)
AM_RANGE(0xbc04, 0xbc04) AM_WRITENOP // ??
AM_RANGE(0xbc0c, 0xbc0c) AM_WRITENOP // ??
ADDRESS_MAP_END
diff --git a/src/mame/drivers/safarir.c b/src/mame/drivers/safarir.c
index a9c30f49322..9f8da0ca97a 100644
--- a/src/mame/drivers/safarir.c
+++ b/src/mame/drivers/safarir.c
@@ -67,6 +67,10 @@ public:
UINT8 m_port_last;
UINT8 m_port_last2;
samples_device *m_samples;
+ DECLARE_WRITE8_MEMBER(ram_w);
+ DECLARE_READ8_MEMBER(ram_r);
+ DECLARE_WRITE8_MEMBER(ram_bank_w);
+ DECLARE_WRITE8_MEMBER(safarir_audio_w);
};
@@ -76,34 +80,31 @@ public:
*
*************************************/
-static WRITE8_HANDLER( ram_w )
+WRITE8_MEMBER(safarir_state::ram_w)
{
- safarir_state *state = space->machine().driver_data<safarir_state>();
- if (state->m_ram_bank)
- state->m_ram_2[offset] = data;
+ if (m_ram_bank)
+ m_ram_2[offset] = data;
else
- state->m_ram_1[offset] = data;
+ m_ram_1[offset] = data;
- ((offset & 0x0400) ? state->m_bg_tilemap : state->m_fg_tilemap)->mark_tile_dirty(offset & 0x03ff);
+ ((offset & 0x0400) ? m_bg_tilemap : m_fg_tilemap)->mark_tile_dirty(offset & 0x03ff);
}
-static READ8_HANDLER( ram_r )
+READ8_MEMBER(safarir_state::ram_r)
{
- safarir_state *state = space->machine().driver_data<safarir_state>();
- return state->m_ram_bank ? state->m_ram_2[offset] : state->m_ram_1[offset];
+ return m_ram_bank ? m_ram_2[offset] : m_ram_1[offset];
}
-static WRITE8_HANDLER( ram_bank_w )
+WRITE8_MEMBER(safarir_state::ram_bank_w)
{
- safarir_state *state = space->machine().driver_data<safarir_state>();
- state->m_ram_bank = data & 0x01;
+ m_ram_bank = data & 0x01;
- space->machine().tilemap().mark_all_dirty();
+ machine().tilemap().mark_all_dirty();
}
@@ -147,7 +148,8 @@ static TILE_GET_INFO( get_bg_tile_info )
{
int color;
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
- UINT8 code = ram_r(space,tile_index | 0x400);
+ safarir_state *state = machine.driver_data<safarir_state>();
+ UINT8 code = state->ram_r(*space,tile_index | 0x400);
if (code & 0x80)
color = 6; /* yellow */
@@ -169,8 +171,8 @@ static TILE_GET_INFO( get_fg_tile_info )
{
int color, flags;
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
-
- UINT8 code = ram_r(space,tile_index);
+ safarir_state *state = machine.driver_data<safarir_state>();
+ UINT8 code = state->ram_r(*space,tile_index);
if (code & 0x80)
color = 7; /* white */
@@ -232,11 +234,10 @@ static SCREEN_UPDATE_IND16( safarir )
#define CHANNEL_SOUND6 5
-static WRITE8_HANDLER( safarir_audio_w )
+WRITE8_MEMBER(safarir_state::safarir_audio_w)
{
- safarir_state *state = space->machine().driver_data<safarir_state>();
- samples_device *samples = state->m_samples;
- UINT8 rising_bits = data & ~state->m_port_last;
+ samples_device *samples = m_samples;
+ UINT8 rising_bits = data & ~m_port_last;
if (rising_bits == 0x12) samples->start(CHANNEL_SOUND1, SAMPLE_SOUND1_1);
if (rising_bits == 0x02) samples->start(CHANNEL_SOUND1, SAMPLE_SOUND1_2);
@@ -249,16 +250,16 @@ static WRITE8_HANDLER( safarir_audio_w )
if (data == 0x13)
{
- if ((rising_bits == 0x13 && state->m_port_last != 0x04) || (rising_bits == 0x01 && state->m_port_last == 0x12))
+ if ((rising_bits == 0x13 && m_port_last != 0x04) || (rising_bits == 0x01 && m_port_last == 0x12))
{
samples->start(CHANNEL_SOUND4, SAMPLE_SOUND7);
}
- else if (rising_bits == 0x03 && state->m_port_last2 == 0x15 && !samples->playing(CHANNEL_SOUND4))
+ else if (rising_bits == 0x03 && m_port_last2 == 0x15 && !samples->playing(CHANNEL_SOUND4))
{
samples->start(CHANNEL_SOUND4, SAMPLE_SOUND4_1);
}
}
- if (data == 0x53 && state->m_port_last == 0x55) samples->start(CHANNEL_SOUND4, SAMPLE_SOUND4_2);
+ if (data == 0x53 && m_port_last == 0x55) samples->start(CHANNEL_SOUND4, SAMPLE_SOUND4_2);
if (data == 0x1f && rising_bits == 0x1f) samples->start(CHANNEL_SOUND5, SAMPLE_SOUND5_1);
if (data == 0x14 && (rising_bits == 0x14 || rising_bits == 0x04)) samples->start(CHANNEL_SOUND5, SAMPLE_SOUND5_2);
@@ -266,8 +267,8 @@ static WRITE8_HANDLER( safarir_audio_w )
if (data == 0x07 && rising_bits == 0x07 && !samples->playing(CHANNEL_SOUND6))
samples->start(CHANNEL_SOUND6, SAMPLE_SOUND8);
- state->m_port_last2 = state->m_port_last;
- state->m_port_last = data;
+ m_port_last2 = m_port_last;
+ m_port_last = data;
}
@@ -338,10 +339,10 @@ static MACHINE_START( safarir )
static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, safarir_state )
AM_RANGE(0x0000, 0x17ff) AM_ROM
- AM_RANGE(0x2000, 0x27ff) AM_READWRITE_LEGACY(ram_r, ram_w) AM_SIZE(m_ram_size)
- AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x03ff) AM_READNOP AM_WRITE_LEGACY(ram_bank_w)
+ AM_RANGE(0x2000, 0x27ff) AM_READWRITE(ram_r, ram_w) AM_SIZE(m_ram_size)
+ AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x03ff) AM_READNOP AM_WRITE(ram_bank_w)
AM_RANGE(0x2c00, 0x2cff) AM_MIRROR(0x03ff) AM_READNOP AM_WRITEONLY AM_BASE(m_bg_scroll)
- AM_RANGE(0x3000, 0x30ff) AM_MIRROR(0x03ff) AM_WRITE_LEGACY(safarir_audio_w) /* goes to SN76477 */
+ AM_RANGE(0x3000, 0x30ff) AM_MIRROR(0x03ff) AM_WRITE(safarir_audio_w) /* goes to SN76477 */
AM_RANGE(0x3400, 0x3400) AM_MIRROR(0x03ff) AM_WRITENOP /* cleared at the beginning */
AM_RANGE(0x3800, 0x38ff) AM_MIRROR(0x03ff) AM_READ_PORT("INPUTS") AM_WRITENOP
AM_RANGE(0x3c00, 0x3cff) AM_MIRROR(0x03ff) AM_READ_PORT("DSW") AM_WRITENOP
diff --git a/src/mame/drivers/sigmab98.c b/src/mame/drivers/sigmab98.c
index 0837ccace0b..88624421f3e 100644
--- a/src/mame/drivers/sigmab98.c
+++ b/src/mame/drivers/sigmab98.c
@@ -122,6 +122,48 @@ public:
UINT8 m_vblank_vector;
UINT8 m_timer0_vector;
UINT8 m_timer1_vector;
+ DECLARE_WRITE8_MEMBER(regs_w);
+ DECLARE_READ8_MEMBER(regs_r);
+ DECLARE_WRITE8_MEMBER(regs2_w);
+ DECLARE_READ8_MEMBER(regs2_r);
+ DECLARE_WRITE8_MEMBER(c4_w);
+ DECLARE_WRITE8_MEMBER(c6_w);
+ DECLARE_WRITE8_MEMBER(c8_w);
+ DECLARE_WRITE8_MEMBER(animalc_rombank_w);
+ DECLARE_READ8_MEMBER(animalc_rombank_r);
+ DECLARE_WRITE8_MEMBER(animalc_rambank_w);
+ DECLARE_READ8_MEMBER(animalc_rambank_r);
+ DECLARE_READ8_MEMBER(unk_34_r);
+ DECLARE_READ8_MEMBER(vblank_r);
+ DECLARE_WRITE8_MEMBER(vblank_w);
+ DECLARE_WRITE8_MEMBER(sammymdl_coin_w);
+ DECLARE_WRITE8_MEMBER(sammymdl_leds_w);
+ DECLARE_WRITE8_MEMBER(sammymdl_hopper_w);
+ DECLARE_READ8_MEMBER(sammymdl_coin_hopper_r);
+ DECLARE_WRITE8_MEMBER(haekaka_rombank_w);
+ DECLARE_READ8_MEMBER(haekaka_rombank_r);
+ DECLARE_WRITE8_MEMBER(haekaka_rambank_w);
+ DECLARE_READ8_MEMBER(haekaka_rambank_r);
+ DECLARE_READ8_MEMBER(haekaka_vblank_r);
+ DECLARE_READ8_MEMBER(haekaka_b000_r);
+ DECLARE_WRITE8_MEMBER(haekaka_b000_w);
+ DECLARE_WRITE8_MEMBER(haekaka_leds_w);
+ DECLARE_WRITE8_MEMBER(haekaka_coin_w);
+ DECLARE_WRITE8_MEMBER(itazuram_rombank_w);
+ DECLARE_READ8_MEMBER(itazuram_rombank_r);
+ DECLARE_WRITE8_MEMBER(itazuram_rambank_w);
+ DECLARE_READ8_MEMBER(itazuram_rambank_r);
+ DECLARE_WRITE8_MEMBER(itazuram_nvram_palette_w);
+ DECLARE_WRITE8_MEMBER(itazuram_palette_w);
+ DECLARE_READ8_MEMBER(itazuram_palette_r);
+ DECLARE_WRITE8_MEMBER(tdoboon_rombank_w);
+ DECLARE_READ8_MEMBER(tdoboon_rombank_r);
+ DECLARE_WRITE8_MEMBER(tdoboon_rambank_w);
+ DECLARE_READ8_MEMBER(tdoboon_rambank_r);
+ DECLARE_READ8_MEMBER(tdoboon_c000_r);
+ DECLARE_WRITE8_MEMBER(tdoboon_c000_w);
+ void show_outputs();
+ void show_3_outputs();
};
@@ -289,90 +331,86 @@ static SCREEN_UPDATE_IND16(sigmab98)
***************************************************************************/
// rombank
-static WRITE8_HANDLER( regs_w )
+WRITE8_MEMBER(sigmab98_state::regs_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg = data;
+ m_reg = data;
return;
}
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x1f:
- state->m_rombank = data;
+ m_rombank = data;
if (data >= 0x18)
- logerror("%s: unknown rom bank = %02x\n", space->machine().describe_context(), data);
+ logerror("%s: unknown rom bank = %02x\n", machine().describe_context(), data);
else
- memory_set_bank(space->machine(), "rombank", data);
+ memory_set_bank(machine(), "rombank", data);
break;
default:
- logerror("%s: unknown reg written: %02x = %02x\n", space->machine().describe_context(), state->m_reg, data);
+ logerror("%s: unknown reg written: %02x = %02x\n", machine().describe_context(), m_reg, data);
}
}
-static READ8_HANDLER( regs_r )
+READ8_MEMBER(sigmab98_state::regs_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg;
+ return m_reg;
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x1f:
- return state->m_rombank;
+ return m_rombank;
default:
- logerror("%s: unknown reg read: %02x\n", space->machine().describe_context(), state->m_reg);
+ logerror("%s: unknown reg read: %02x\n", machine().describe_context(), m_reg);
return 0x00;
}
}
// rambank
-static WRITE8_HANDLER( regs2_w )
+WRITE8_MEMBER(sigmab98_state::regs2_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg2 = data;
+ m_reg2 = data;
return;
}
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0xb5:
- state->m_rambank = data;
+ m_rambank = data;
switch (data)
{
case 0x32:
- memory_set_bank(space->machine(), "rambank", 0);
+ memory_set_bank(machine(), "rambank", 0);
break;
case 0x36:
- memory_set_bank(space->machine(), "rambank", 1);
+ memory_set_bank(machine(), "rambank", 1);
break;
default:
- logerror("%s: unknown ram bank = %02x\n", space->machine().describe_context(), data);
+ logerror("%s: unknown ram bank = %02x\n", machine().describe_context(), data);
}
break;
default:
- logerror("%s: unknown reg2 written: %02x = %02x\n", space->machine().describe_context(), state->m_reg2, data);
+ logerror("%s: unknown reg2 written: %02x = %02x\n", machine().describe_context(), m_reg2, data);
}
}
-static READ8_HANDLER( regs2_r )
+READ8_MEMBER(sigmab98_state::regs2_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg2;
+ return m_reg2;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0xb5:
- return state->m_rambank;
+ return m_rambank;
default:
- logerror("%s: unknown reg2 read: %02x\n", space->machine().describe_context(), state->m_reg2);
+ logerror("%s: unknown reg2 read: %02x\n", machine().describe_context(), m_reg2);
return 0x00;
}
}
@@ -380,10 +418,10 @@ static READ8_HANDLER( regs2_r )
// Outputs
-static void show_outputs(sigmab98_state *state)
+void sigmab98_state::show_outputs()
{
#ifdef MAME_DEBUG
-// popmessage("0: %02X 4: %02X 6: %02X 8: %02X",state->m_c0,state->m_c4,state->m_c6,state->m_c8);
+// popmessage("0: %02X 4: %02X 6: %02X 8: %02X",m_c0,m_c4,m_c6,m_c8);
#endif
}
@@ -403,18 +441,17 @@ static WRITE8_DEVICE_HANDLER( eeprom_w )
eeprom->set_clock_line((data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
state->m_c0 = data;
- show_outputs(state);
+ //show_outputs(state);
}
// Port c4
// 10 led?
-static WRITE8_HANDLER( c4_w )
+WRITE8_MEMBER(sigmab98_state::c4_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- set_led_status(space->machine(), 0, (data & 0x10));
+ set_led_status(machine(), 0, (data & 0x10));
- state->m_c4 = data;
- show_outputs(state);
+ m_c4 = data;
+ show_outputs();
}
// Port c6
@@ -423,31 +460,29 @@ static WRITE8_HANDLER( c4_w )
// 08 always blinks
// 10 led?
// 20 blinks after coin up
-static WRITE8_HANDLER( c6_w )
+WRITE8_MEMBER(sigmab98_state::c6_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- coin_lockout_w(space->machine(), 0, (~data) & 0x02);
+ coin_lockout_w(machine(), 0, (~data) & 0x02);
- coin_counter_w(space->machine(), 0, data & 0x04);
+ coin_counter_w(machine(), 0, data & 0x04);
- set_led_status(space->machine(), 1, data & 0x08);
- set_led_status(space->machine(), 2, data & 0x10);
- set_led_status(space->machine(), 3, data & 0x20); //
+ set_led_status(machine(), 1, data & 0x08);
+ set_led_status(machine(), 2, data & 0x10);
+ set_led_status(machine(), 3, data & 0x20); //
- state->m_c6 = data;
- show_outputs(state);
+ m_c6 = data;
+ show_outputs();
}
// Port c8
// 01 hopper enable?
// 02 hopper motor on (active low)?
-static WRITE8_HANDLER( c8_w )
+WRITE8_MEMBER(sigmab98_state::c8_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- ticket_dispenser_w(space->machine().device("hopper"), 0, (!(data & 0x02) && (data & 0x01)) ? 0x00 : 0x80);
+ ticket_dispenser_w(machine().device("hopper"), 0, (!(data & 0x02) && (data & 0x01)) ? 0x00 : 0x80);
- state->m_c8 = data;
- show_outputs(state);
+ m_c8 = data;
+ show_outputs();
}
static ADDRESS_MAP_START( gegege_mem_map, AS_PROGRAM, 8, sigmab98_state )
@@ -473,9 +508,9 @@ static ADDRESS_MAP_START( gegege_io_map, AS_IO, 8, sigmab98_state )
AM_RANGE( 0x00, 0x01 ) AM_DEVWRITE_LEGACY("ymz", ymz280b_w )
- AM_RANGE( 0xa0, 0xa1 ) AM_READWRITE_LEGACY(regs_r, regs_w )
+ AM_RANGE( 0xa0, 0xa1 ) AM_READWRITE(regs_r, regs_w )
// AM_RANGE( 0xa2, 0xa3 )
- AM_RANGE( 0xa4, 0xa5 ) AM_READWRITE_LEGACY(regs2_r, regs2_w )
+ AM_RANGE( 0xa4, 0xa5 ) AM_READWRITE(regs2_r, regs2_w )
AM_RANGE( 0xc0, 0xc0 ) AM_READ_PORT( "EEPROM" )
AM_RANGE( 0xc0, 0xc0 ) AM_DEVWRITE_LEGACY("eeprom", eeprom_w)
@@ -483,11 +518,11 @@ static ADDRESS_MAP_START( gegege_io_map, AS_IO, 8, sigmab98_state )
AM_RANGE( 0xc2, 0xc2 ) AM_READ_PORT( "IN1" )
AM_RANGE( 0xc4, 0xc4 ) AM_READ_PORT( "IN2" )
- AM_RANGE( 0xc4, 0xc4 ) AM_WRITE_LEGACY(c4_w )
+ AM_RANGE( 0xc4, 0xc4 ) AM_WRITE(c4_w )
- AM_RANGE( 0xc6, 0xc6 ) AM_WRITE_LEGACY(c6_w )
+ AM_RANGE( 0xc6, 0xc6 ) AM_WRITE(c6_w )
- AM_RANGE( 0xc8, 0xc8 ) AM_WRITE_LEGACY(c8_w )
+ AM_RANGE( 0xc8, 0xc8 ) AM_WRITE(c8_w )
AM_RANGE( 0xe5, 0xe5 ) AM_READNOP // during irq
ADDRESS_MAP_END
@@ -498,66 +533,63 @@ ADDRESS_MAP_END
***************************************************************************/
// rombank
-static WRITE8_HANDLER( animalc_rombank_w )
+WRITE8_MEMBER(sigmab98_state::animalc_rombank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg = data;
+ m_reg = data;
return;
}
- UINT8 *rom = space->machine().region("maincpu")->base();
- switch ( state->m_reg )
+ UINT8 *rom = machine().region("maincpu")->base();
+ switch ( m_reg )
{
case 0x0f:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
- case 0x10: memory_set_bankptr(space->machine(), "rombank", rom + 0x400 + 0x4000); break;
- case 0x14: memory_set_bankptr(space->machine(), "rombank", rom + 0x400 + 0x8000); break;
- case 0x18: memory_set_bankptr(space->machine(), "rombank", rom + 0x400 + 0xc000); break;
+ case 0x10: memory_set_bankptr(machine(), "rombank", rom + 0x400 + 0x4000); break;
+ case 0x14: memory_set_bankptr(machine(), "rombank", rom + 0x400 + 0x8000); break;
+ case 0x18: memory_set_bankptr(machine(), "rombank", rom + 0x400 + 0xc000); break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
default:
- logerror("%s: unknown reg written: %02x = %02x\n", space->machine().describe_context(), state->m_reg, data);
+ logerror("%s: unknown reg written: %02x = %02x\n", machine().describe_context(), m_reg, data);
}
}
-static READ8_HANDLER( animalc_rombank_r )
+READ8_MEMBER(sigmab98_state::animalc_rombank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg;
+ return m_reg;
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x0f:
- return state->m_rombank;
+ return m_rombank;
default:
- logerror("%s: unknown reg read: %02x\n", space->machine().describe_context(), state->m_reg);
+ logerror("%s: unknown reg read: %02x\n", machine().describe_context(), m_reg);
return 0x00;
}
}
// rambank
-static WRITE8_HANDLER( animalc_rambank_w )
+WRITE8_MEMBER(sigmab98_state::animalc_rambank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg2 = data;
+ m_reg2 = data;
return;
}
int bank = 0;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x1f:
- state->m_rambank = data;
+ m_rambank = data;
switch (data)
{
case 0x58: bank = 0; break;
@@ -566,31 +598,30 @@ static WRITE8_HANDLER( animalc_rambank_w )
case 0x64: bank = 3; break;
case 0x65: bank = 4; break;
default:
- logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", space->machine().describe_context(), data, state->m_reg2);
+ logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", machine().describe_context(), data, m_reg2);
return;
}
- memory_set_bank(space->machine(), "rambank", bank);
+ memory_set_bank(machine(), "rambank", bank);
if ( (bank == 1) || (bank == 2) || (bank == 3) )
- memory_set_bank(space->machine(), "sprbank", bank-1);
+ memory_set_bank(machine(), "sprbank", bank-1);
break;
default:
- logerror("%s: unknown reg2 written: %02x = %02x\n", space->machine().describe_context(), state->m_reg2, data);
+ logerror("%s: unknown reg2 written: %02x = %02x\n", machine().describe_context(), m_reg2, data);
}
}
-static READ8_HANDLER( animalc_rambank_r )
+READ8_MEMBER(sigmab98_state::animalc_rambank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg2;
+ return m_reg2;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x1f:
- return state->m_rambank;
+ return m_rambank;
default:
- logerror("%s: unknown reg2 read: %02x\n", space->machine().describe_context(), state->m_reg2);
+ logerror("%s: unknown reg2 read: %02x\n", machine().describe_context(), m_reg2);
return 0x00;
}
}
@@ -618,24 +649,22 @@ static WRITE8_DEVICE_HANDLER( sammymdl_eeprom_w )
logerror("%s: unknown eeeprom bits written %02x\n", device->machine().describe_context(), data);
}
-static READ8_HANDLER( unk_34_r )
+READ8_MEMBER(sigmab98_state::unk_34_r)
{
// mask 0x01?
return 0x01;
}
-static READ8_HANDLER( vblank_r )
+READ8_MEMBER(sigmab98_state::vblank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
// mask 0x04 must be set before writing sprite list
// mask 0x10 must be set or irq/00 hangs?
- return state->m_vblank | 0x14;
+ return m_vblank | 0x14;
}
-static WRITE8_HANDLER( vblank_w )
+WRITE8_MEMBER(sigmab98_state::vblank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- state->m_vblank = (state->m_vblank & ~0x03) | (data & 0x03);
+ m_vblank = (m_vblank & ~0x03) | (data & 0x03);
}
static SCREEN_VBLANK( sammymdl )
@@ -648,55 +677,52 @@ static SCREEN_VBLANK( sammymdl )
}
}
-static void show_3_outputs(sigmab98_state *state)
+void sigmab98_state::show_3_outputs()
{
#ifdef MAME_DEBUG
-// popmessage("COIN: %02X LED: %02X HOP: %02X", state->m_out[0], state->m_out[1], state->m_out[2]);
+// popmessage("COIN: %02X LED: %02X HOP: %02X", m_out[0], m_out[1], m_out[2]);
#endif
}
// Port 31
-static WRITE8_HANDLER( sammymdl_coin_w )
+WRITE8_MEMBER(sigmab98_state::sammymdl_coin_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- coin_counter_w(space->machine(), 0, data & 0x01 ); // coin1 in
- coin_counter_w(space->machine(), 1, data & 0x02 ); // coin2 in
- coin_counter_w(space->machine(), 2, data & 0x04 ); // medal in
+ coin_counter_w(machine(), 0, data & 0x01 ); // coin1 in
+ coin_counter_w(machine(), 1, data & 0x02 ); // coin2 in
+ coin_counter_w(machine(), 2, data & 0x04 ); // medal in
-// coin_lockout_w(space->machine(), 1, (~data) & 0x08 ); // coin2 lockout?
-// coin_lockout_w(space->machine(), 0, (~data) & 0x10 ); // coin1 lockout
-// coin_lockout_w(space->machine(), 2, (~data) & 0x20 ); // medal lockout?
+// coin_lockout_w(machine(), 1, (~data) & 0x08 ); // coin2 lockout?
+// coin_lockout_w(machine(), 0, (~data) & 0x10 ); // coin1 lockout
+// coin_lockout_w(machine(), 2, (~data) & 0x20 ); // medal lockout?
- state->m_out[0] = data;
- show_3_outputs(state);
+ m_out[0] = data;
+ show_3_outputs();
}
// Port 32
-static WRITE8_HANDLER( sammymdl_leds_w )
+WRITE8_MEMBER(sigmab98_state::sammymdl_leds_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- set_led_status(space->machine(), 0, data & 0x01); // button
+ set_led_status(machine(), 0, data & 0x01); // button
- state->m_out[1] = data;
- show_3_outputs(state);
+ m_out[1] = data;
+ show_3_outputs();
}
// Port b0
// 02 hopper enable?
// 01 hopper motor on (active low)?
-static WRITE8_HANDLER( sammymdl_hopper_w )
+WRITE8_MEMBER(sigmab98_state::sammymdl_hopper_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- ticket_dispenser_w(space->machine().device("hopper"), 0, (!(data & 0x01) && (data & 0x02)) ? 0x00 : 0x80);
+ ticket_dispenser_w(machine().device("hopper"), 0, (!(data & 0x01) && (data & 0x02)) ? 0x00 : 0x80);
- state->m_out[2] = data;
- show_3_outputs(state);
+ m_out[2] = data;
+ show_3_outputs();
}
-static READ8_HANDLER( sammymdl_coin_hopper_r )
+READ8_MEMBER(sigmab98_state::sammymdl_coin_hopper_r)
{
- UINT8 ret = input_port_read(space->machine(), "COIN");
+ UINT8 ret = input_port_read(machine(), "COIN");
-// if ( !ticket_dispenser_r(space->machine().device("hopper"), 0) )
+// if ( !ticket_dispenser_r(machine().device("hopper"), 0) )
// ret &= ~0x01;
return ret;
@@ -715,26 +741,26 @@ static ADDRESS_MAP_START( animalc_map, AS_PROGRAM, 8, sigmab98_state )
AM_RANGE( 0xd800, 0xd87f ) AM_RAM // table?
AM_RANGE( 0xe011, 0xe011 ) AM_WRITENOP // IRQ Enable? Screen disable?
- AM_RANGE( 0xe013, 0xe013 ) AM_READWRITE_LEGACY(vblank_r, vblank_w ) // IRQ Ack?
+ AM_RANGE( 0xe013, 0xe013 ) AM_READWRITE(vblank_r, vblank_w ) // IRQ Ack?
AM_RANGE( 0xfe00, 0xffff ) AM_RAM // High speed internal RAM
ADDRESS_MAP_END
static ADDRESS_MAP_START( animalc_io, AS_IO, 8, sigmab98_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE( 0x02, 0x03 ) AM_READWRITE_LEGACY(animalc_rombank_r, animalc_rombank_w )
- AM_RANGE( 0x04, 0x05 ) AM_READWRITE_LEGACY(animalc_rambank_r, animalc_rambank_w )
+ AM_RANGE( 0x02, 0x03 ) AM_READWRITE(animalc_rombank_r, animalc_rombank_w )
+ AM_RANGE( 0x04, 0x05 ) AM_READWRITE(animalc_rambank_r, animalc_rambank_w )
AM_RANGE( 0x2c, 0x2c ) AM_DEVREADWRITE_LEGACY("eeprom", sammymdl_eeprom_r, sammymdl_eeprom_w )
- AM_RANGE( 0x2e, 0x2e ) AM_READ_LEGACY(sammymdl_coin_hopper_r )
+ AM_RANGE( 0x2e, 0x2e ) AM_READ(sammymdl_coin_hopper_r )
AM_RANGE( 0x30, 0x30 ) AM_READ_PORT( "BUTTON" )
- AM_RANGE( 0x31, 0x31 ) AM_WRITE_LEGACY(sammymdl_coin_w )
- AM_RANGE( 0x32, 0x32 ) AM_WRITE_LEGACY(sammymdl_leds_w )
- AM_RANGE( 0x34, 0x34 ) AM_READ_LEGACY(unk_34_r )
+ AM_RANGE( 0x31, 0x31 ) AM_WRITE(sammymdl_coin_w )
+ AM_RANGE( 0x32, 0x32 ) AM_WRITE(sammymdl_leds_w )
+ AM_RANGE( 0x34, 0x34 ) AM_READ(unk_34_r )
AM_RANGE( 0x90, 0x90 ) AM_DEVWRITE("oki", okim9810_device, write )
AM_RANGE( 0x91, 0x91 ) AM_DEVWRITE("oki", okim9810_device, write_TMP_register )
AM_RANGE( 0x92, 0x92 ) AM_DEVREAD("oki", okim9810_device, read )
- AM_RANGE( 0xb0, 0xb0 ) AM_WRITE_LEGACY(sammymdl_hopper_w )
+ AM_RANGE( 0xb0, 0xb0 ) AM_WRITE(sammymdl_hopper_w )
AM_RANGE( 0xc0, 0xc0 ) AM_WRITE_LEGACY(watchdog_reset_w ) // 1
ADDRESS_MAP_END
@@ -743,19 +769,18 @@ ADDRESS_MAP_END
***************************************************************************/
// rombank
-static WRITE8_HANDLER( haekaka_rombank_w )
+WRITE8_MEMBER(sigmab98_state::haekaka_rombank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg = data;
+ m_reg = data;
return;
}
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x2b:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x10: // ROM
@@ -780,85 +805,81 @@ static WRITE8_HANDLER( haekaka_rombank_w )
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
default:
- logerror("%s: unknown reg written: %02x = %02x\n", space->machine().describe_context(), state->m_reg, data);
+ logerror("%s: unknown reg written: %02x = %02x\n", machine().describe_context(), m_reg, data);
}
}
-static READ8_HANDLER( haekaka_rombank_r )
+READ8_MEMBER(sigmab98_state::haekaka_rombank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg;
+ return m_reg;
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x2b:
- return state->m_rombank;
+ return m_rombank;
default:
- logerror("%s: unknown reg read: %02x\n", space->machine().describe_context(), state->m_reg);
+ logerror("%s: unknown reg read: %02x\n", machine().describe_context(), m_reg);
return 0x00;
}
}
// rambank
-static WRITE8_HANDLER( haekaka_rambank_w )
+WRITE8_MEMBER(sigmab98_state::haekaka_rambank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg2 = data;
+ m_reg2 = data;
return;
}
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x33:
- state->m_rambank = data;
+ m_rambank = data;
switch (data)
{
case 0x53:
break;
default:
- logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", space->machine().describe_context(), data, state->m_reg2);
+ logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", machine().describe_context(), data, m_reg2);
}
break;
default:
- logerror("%s: unknown reg2 written: %02x = %02x\n", space->machine().describe_context(), state->m_reg2, data);
+ logerror("%s: unknown reg2 written: %02x = %02x\n", machine().describe_context(), m_reg2, data);
}
}
-static READ8_HANDLER( haekaka_rambank_r )
+READ8_MEMBER(sigmab98_state::haekaka_rambank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg2;
+ return m_reg2;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x33:
- return state->m_rambank;
+ return m_rambank;
default:
- logerror("%s: unknown reg2 read: %02x\n", space->machine().describe_context(), state->m_reg2);
+ logerror("%s: unknown reg2 read: %02x\n", machine().describe_context(), m_reg2);
return 0x00;
}
}
-static READ8_HANDLER( haekaka_vblank_r )
+READ8_MEMBER(sigmab98_state::haekaka_vblank_r)
{
- return space->machine().primary_screen->vblank() ? 0 : 0x1c;
+ return machine().primary_screen->vblank() ? 0 : 0x1c;
}
-static READ8_HANDLER( haekaka_b000_r )
+READ8_MEMBER(sigmab98_state::haekaka_b000_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- switch (state->m_rombank)
+ switch (m_rombank)
{
case 0x10: // ROM
case 0x11:
@@ -876,33 +897,32 @@ static READ8_HANDLER( haekaka_b000_r )
case 0x1d:
case 0x1e:
case 0x1f:
- return space->machine().region("maincpu")->base()[offset + 0xb400 + 0x1000 * (state->m_rombank-0x10)];
+ return machine().region("maincpu")->base()[offset + 0xb400 + 0x1000 * (m_rombank-0x10)];
case 0x65: // SPRITERAM
if (offset < 0x1000)
- return state->m_spriteram[offset];
+ return m_spriteram[offset];
case 0x67: // PALETTERAM + TABLE? + REGS
if (offset < 0x200)
- return space->machine().generic.paletteram.u8[offset];
+ return machine().generic.paletteram.u8[offset];
else if (offset == (0xc013-0xb000))
return haekaka_vblank_r(space, offset);
break;
}
- logerror("%s: unknown read from %02x with rombank = %02x\n", space->machine().describe_context(), offset+0xb000, state->m_rombank);
+ logerror("%s: unknown read from %02x with rombank = %02x\n", machine().describe_context(), offset+0xb000, m_rombank);
return 0x00;
}
-static WRITE8_HANDLER( haekaka_b000_w )
+WRITE8_MEMBER(sigmab98_state::haekaka_b000_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- switch (state->m_rombank)
+ switch (m_rombank)
{
case 0x65: // SPRITERAM
if (offset < 0x1000)
{
- state->m_spriteram[offset] = data;
+ m_spriteram[offset] = data;
return;
}
break;
@@ -911,7 +931,7 @@ static WRITE8_HANDLER( haekaka_b000_w )
if (offset < 0x200)
{
paletteram_xRRRRRGGGGGBBBBB_be_w(space, offset, data);
-// space->machine().generic.paletteram.u8[offset] = data;
+// machine().generic.paletteram.u8[offset] = data;
return;
}
else if ((offset >= 0x800) && (offset < 0x880))
@@ -922,59 +942,57 @@ static WRITE8_HANDLER( haekaka_b000_w )
break;
}
- logerror("%s: unknown write to %02x = %02x with rombank = %02x\n", space->machine().describe_context(), offset+0xb000, data, state->m_rombank);
+ logerror("%s: unknown write to %02x = %02x with rombank = %02x\n", machine().describe_context(), offset+0xb000, data, m_rombank);
}
-static WRITE8_HANDLER( haekaka_leds_w )
+WRITE8_MEMBER(sigmab98_state::haekaka_leds_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
// All used
- set_led_status(space->machine(), 0, data & 0x01);
- set_led_status(space->machine(), 1, data & 0x02);
- set_led_status(space->machine(), 2, data & 0x04);
- set_led_status(space->machine(), 3, data & 0x08);
- set_led_status(space->machine(), 4, data & 0x10);
- set_led_status(space->machine(), 5, data & 0x20);
- set_led_status(space->machine(), 6, data & 0x40);
- set_led_status(space->machine(), 7, data & 0x80);
-
- state->m_out[1] = data;
- show_3_outputs(state);
+ set_led_status(machine(), 0, data & 0x01);
+ set_led_status(machine(), 1, data & 0x02);
+ set_led_status(machine(), 2, data & 0x04);
+ set_led_status(machine(), 3, data & 0x08);
+ set_led_status(machine(), 4, data & 0x10);
+ set_led_status(machine(), 5, data & 0x20);
+ set_led_status(machine(), 6, data & 0x40);
+ set_led_status(machine(), 7, data & 0x80);
+
+ m_out[1] = data;
+ show_3_outputs();
}
-static WRITE8_HANDLER( haekaka_coin_w )
+WRITE8_MEMBER(sigmab98_state::haekaka_coin_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- coin_counter_w(space->machine(), 0, data & 0x01 ); // medal out
+ coin_counter_w(machine(), 0, data & 0x01 ); // medal out
// data & 0x02 ?
// data & 0x04 ?
// data & 0x10 ?
- state->m_out[0] = data;
- show_3_outputs(state);
+ m_out[0] = data;
+ show_3_outputs();
}
static ADDRESS_MAP_START( haekaka_map, AS_PROGRAM, 8, sigmab98_state )
AM_RANGE( 0x0000, 0x7fff ) AM_ROM
- AM_RANGE( 0xb000, 0xcfff ) AM_READWRITE_LEGACY(haekaka_b000_r, haekaka_b000_w )
+ AM_RANGE( 0xb000, 0xcfff ) AM_READWRITE(haekaka_b000_r, haekaka_b000_w )
AM_RANGE( 0xd000, 0xefff ) AM_RAM AM_SHARE( "nvram" ) AM_BASE(m_nvram )
AM_RANGE( 0xfe00, 0xffff ) AM_RAM // High speed internal RAM
ADDRESS_MAP_END
static ADDRESS_MAP_START( haekaka_io, AS_IO, 8, sigmab98_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE( 0x02, 0x03 ) AM_READWRITE_LEGACY(haekaka_rombank_r, haekaka_rombank_w )
- AM_RANGE( 0x04, 0x05 ) AM_READWRITE_LEGACY(haekaka_rambank_r, haekaka_rambank_w )
+ AM_RANGE( 0x02, 0x03 ) AM_READWRITE(haekaka_rombank_r, haekaka_rombank_w )
+ AM_RANGE( 0x04, 0x05 ) AM_READWRITE(haekaka_rambank_r, haekaka_rambank_w )
AM_RANGE( 0x2c, 0x2c ) AM_DEVREADWRITE_LEGACY("eeprom", sammymdl_eeprom_r, sammymdl_eeprom_w )
- AM_RANGE( 0x2e, 0x2e ) AM_READ_LEGACY(sammymdl_coin_hopper_r )
+ AM_RANGE( 0x2e, 0x2e ) AM_READ(sammymdl_coin_hopper_r )
AM_RANGE( 0x30, 0x30 ) AM_READ_PORT( "BUTTON" )
- AM_RANGE( 0x31, 0x31 ) AM_WRITE_LEGACY(haekaka_coin_w )
- AM_RANGE( 0x32, 0x32 ) AM_WRITE_LEGACY(haekaka_leds_w )
+ AM_RANGE( 0x31, 0x31 ) AM_WRITE(haekaka_coin_w )
+ AM_RANGE( 0x32, 0x32 ) AM_WRITE(haekaka_leds_w )
AM_RANGE( 0x90, 0x90 ) AM_DEVWRITE("oki", okim9810_device, write )
AM_RANGE( 0x91, 0x91 ) AM_DEVWRITE("oki", okim9810_device, write_TMP_register )
AM_RANGE( 0x92, 0x92 ) AM_DEVREAD("oki", okim9810_device, read )
- AM_RANGE( 0xb0, 0xb0 ) AM_WRITE_LEGACY(sammymdl_hopper_w )
+ AM_RANGE( 0xb0, 0xb0 ) AM_WRITE(sammymdl_hopper_w )
AM_RANGE( 0xc0, 0xc0 ) AM_WRITE_LEGACY(watchdog_reset_w ) // 1
ADDRESS_MAP_END
@@ -983,211 +1001,205 @@ ADDRESS_MAP_END
***************************************************************************/
// rombank
-static WRITE8_HANDLER( itazuram_rombank_w )
+WRITE8_MEMBER(sigmab98_state::itazuram_rombank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg = data;
+ m_reg = data;
return;
}
- UINT8 *rom = space->machine().region("maincpu")->base();
- switch ( state->m_reg )
+ UINT8 *rom = machine().region("maincpu")->base();
+ switch ( m_reg )
{
case 0x0d:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x11: // 3800 IS ROM
- memory_set_bankptr(space->machine(), "rombank0", rom + 0x4c00);
- memory_set_bankptr(space->machine(), "rombank1", rom + 0x5c00);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*4); // scratch
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", rom + 0x4c00);
+ memory_set_bankptr(machine(), "rombank1", rom + 0x5c00);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
case 0x4d:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x14: // 3800 IS ROM
- memory_set_bankptr(space->machine(), "rombank0", rom + 0x8000);
- memory_set_bankptr(space->machine(), "rombank1", rom + 0x9000);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*4); // scratch
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", rom + 0x8000);
+ memory_set_bankptr(machine(), "rombank1", rom + 0x9000);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
case 0x8d:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x0f: // 3800 IS ROM
- memory_set_bankptr(space->machine(), "rombank0", rom + 0x3400);
- memory_set_bankptr(space->machine(), "rombank1", rom + 0x4400);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*4); // scratch
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", rom + 0x3400);
+ memory_set_bankptr(machine(), "rombank1", rom + 0x4400);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
case 0x12: // 3800 IS ROM
- memory_set_bankptr(space->machine(), "rombank0", rom + 0x6400);
- memory_set_bankptr(space->machine(), "rombank1", rom + 0x7400);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*4); // scratch
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", rom + 0x6400);
+ memory_set_bankptr(machine(), "rombank1", rom + 0x7400);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
// used in test mode:
-// case 0x5c: memory_set_bankptr(space->machine(), "rombank", rom + 0x400 + 0x0000); break; // 3800 IS RAM! (8000 bytes)
+// case 0x5c: memory_set_bankptr(machine(), "rombank", rom + 0x400 + 0x0000); break; // 3800 IS RAM! (8000 bytes)
case 0x5e: // 3800 IS RAM! (1404 bytes)
- memory_set_bankptr(space->machine(), "rombank0", state->m_spriteram + 0x1000*1);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*1);
- memory_set_bankptr(space->machine(), "rombank1", state->m_spriteram + 0x1000*2);
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*2);
+ memory_set_bankptr(machine(), "rombank0", m_spriteram + 0x1000*1);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*1);
+ memory_set_bankptr(machine(), "rombank1", m_spriteram + 0x1000*2);
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*2);
break;
case 0x6c: // 3800 IS RAM! (1000 bytes) - SPRITERAM
- memory_set_bankptr(space->machine(), "rombank0", state->m_spriteram);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram);
-// memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", m_spriteram);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram);
+// memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
case 0xcd:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x14: // 3800 IS ROM
- memory_set_bankptr(space->machine(), "rombank0", rom + 0x8800);
- memory_set_bankptr(space->machine(), "rombank1", rom + 0x9800);
- memory_set_bankptr(space->machine(), "sprbank0", state->m_spriteram + 0x1000*4); // scratch
- memory_set_bankptr(space->machine(), "sprbank1", state->m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "rombank0", rom + 0x8800);
+ memory_set_bankptr(machine(), "rombank1", rom + 0x9800);
+ memory_set_bankptr(machine(), "sprbank0", m_spriteram + 0x1000*4); // scratch
+ memory_set_bankptr(machine(), "sprbank1", m_spriteram + 0x1000*4); // scratch
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
default:
- logerror("%s: unknown reg written: %02x = %02x\n", space->machine().describe_context(), state->m_reg, data);
+ logerror("%s: unknown reg written: %02x = %02x\n", machine().describe_context(), m_reg, data);
}
}
-static READ8_HANDLER( itazuram_rombank_r )
+READ8_MEMBER(sigmab98_state::itazuram_rombank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg;
+ return m_reg;
- switch ( state->m_reg )
+ switch ( m_reg )
{
// FIXME different registers
case 0x0d:
case 0x4d:
case 0x8d:
case 0xcd:
- return state->m_rombank;
+ return m_rombank;
default:
- logerror("%s: unknown reg read: %02x\n", space->machine().describe_context(), state->m_reg);
+ logerror("%s: unknown reg read: %02x\n", machine().describe_context(), m_reg);
return 0x00;
}
}
// rambank
-static WRITE8_HANDLER( itazuram_rambank_w )
+WRITE8_MEMBER(sigmab98_state::itazuram_rambank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg2 = data;
+ m_reg2 = data;
return;
}
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x76:
- state->m_rambank = data;
+ m_rambank = data;
switch (data)
{
- case 0x52: memory_set_bankptr(space->machine(), "palbank", state->m_nvram); break;
- case 0x64: memory_set_bankptr(space->machine(), "palbank", space->machine().generic.paletteram.u8); break;
+ case 0x52: memory_set_bankptr(machine(), "palbank", m_nvram); break;
+ case 0x64: memory_set_bankptr(machine(), "palbank", machine().generic.paletteram.u8); break;
default:
- logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", space->machine().describe_context(), data, state->m_reg2);
+ logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", machine().describe_context(), data, m_reg2);
return;
}
break;
default:
- logerror("%s: unknown reg2 written: %02x = %02x\n", space->machine().describe_context(), state->m_reg2, data);
+ logerror("%s: unknown reg2 written: %02x = %02x\n", machine().describe_context(), m_reg2, data);
}
}
-static READ8_HANDLER( itazuram_rambank_r )
+READ8_MEMBER(sigmab98_state::itazuram_rambank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg2;
+ return m_reg2;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x76:
- return state->m_rambank;
+ return m_rambank;
default:
- logerror("%s: unknown reg2 read: %02x\n", space->machine().describe_context(), state->m_reg2);
+ logerror("%s: unknown reg2 read: %02x\n", machine().describe_context(), m_reg2);
return 0x00;
}
}
-static WRITE8_HANDLER( itazuram_nvram_palette_w )
+WRITE8_MEMBER(sigmab98_state::itazuram_nvram_palette_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- if (state->m_rambank == 0x64)
+ if (m_rambank == 0x64)
{
paletteram_xRRRRRGGGGGBBBBB_be_w(space, offset, data);
-// space->machine().generic.paletteram.u8[offset] = data;
+// machine().generic.paletteram.u8[offset] = data;
}
- else if (state->m_rambank == 0x52)
+ else if (m_rambank == 0x52)
{
- state->m_nvram[offset] = data;
+ m_nvram[offset] = data;
}
else
{
- logerror("%s: itazuram_nvram_palette_w offset = %03x with unknown bank = %02x\n", space->machine().describe_context(), offset, state->m_rambank);
+ logerror("%s: itazuram_nvram_palette_w offset = %03x with unknown bank = %02x\n", machine().describe_context(), offset, m_rambank);
}
}
-static WRITE8_HANDLER( itazuram_palette_w )
+WRITE8_MEMBER(sigmab98_state::itazuram_palette_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- if (state->m_rombank == 0x6c)
+ if (m_rombank == 0x6c)
{
if (offset < 0x200)
paletteram_xRRRRRGGGGGBBBBB_be_w(space, offset, data);
-// space->machine().generic.paletteram.u8[offset] = data;
+// machine().generic.paletteram.u8[offset] = data;
}
else
{
- logerror("%s: itazuram_palette_w offset = %03x with unknown bank = %02x\n", space->machine().describe_context(), offset, state->m_rombank);
+ logerror("%s: itazuram_palette_w offset = %03x with unknown bank = %02x\n", machine().describe_context(), offset, m_rombank);
}
}
-static READ8_HANDLER( itazuram_palette_r )
+READ8_MEMBER(sigmab98_state::itazuram_palette_r)
{
- return space->machine().generic.paletteram.u8[offset];
+ return machine().generic.paletteram.u8[offset];
}
static ADDRESS_MAP_START( itazuram_map, AS_PROGRAM, 8, sigmab98_state )
@@ -1195,30 +1207,30 @@ static ADDRESS_MAP_START( itazuram_map, AS_PROGRAM, 8, sigmab98_state )
AM_RANGE( 0x3800, 0x47ff ) AM_READ_BANK( "rombank0" ) AM_WRITE_BANK( "sprbank0" )
AM_RANGE( 0x4800, 0x57ff ) AM_READ_BANK( "rombank1" ) AM_WRITE_BANK( "sprbank1" )
- AM_RANGE( 0x5800, 0x59ff ) AM_READWRITE_LEGACY(itazuram_palette_r, itazuram_palette_w )
+ AM_RANGE( 0x5800, 0x59ff ) AM_READWRITE(itazuram_palette_r, itazuram_palette_w )
AM_RANGE( 0x6000, 0x607f ) AM_RAM // table?
AM_RANGE( 0x6811, 0x6811 ) AM_WRITENOP // IRQ Enable? Screen disable?
AM_RANGE( 0x6813, 0x6813 ) AM_WRITENOP // IRQ Ack?
- AM_RANGE( 0xdc00, 0xfdff ) AM_READ_BANK( "palbank" ) AM_WRITE_LEGACY(itazuram_nvram_palette_w ) AM_SHARE( "nvram" ) AM_BASE(m_nvram ) // nvram | paletteram
+ AM_RANGE( 0xdc00, 0xfdff ) AM_READ_BANK( "palbank" ) AM_WRITE(itazuram_nvram_palette_w ) AM_SHARE( "nvram" ) AM_BASE(m_nvram ) // nvram | paletteram
AM_RANGE( 0xfe00, 0xffff ) AM_RAM // High speed internal RAM
ADDRESS_MAP_END
static ADDRESS_MAP_START( itazuram_io, AS_IO, 8, sigmab98_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE( 0x02, 0x03 ) AM_READWRITE_LEGACY(itazuram_rombank_r, itazuram_rombank_w )
- AM_RANGE( 0x04, 0x05 ) AM_READWRITE_LEGACY(itazuram_rambank_r, itazuram_rambank_w )
+ AM_RANGE( 0x02, 0x03 ) AM_READWRITE(itazuram_rombank_r, itazuram_rombank_w )
+ AM_RANGE( 0x04, 0x05 ) AM_READWRITE(itazuram_rambank_r, itazuram_rambank_w )
AM_RANGE( 0x2c, 0x2c ) AM_DEVREADWRITE_LEGACY("eeprom", sammymdl_eeprom_r, sammymdl_eeprom_w )
- AM_RANGE( 0x2e, 0x2e ) AM_READ_LEGACY(sammymdl_coin_hopper_r )
+ AM_RANGE( 0x2e, 0x2e ) AM_READ(sammymdl_coin_hopper_r )
AM_RANGE( 0x30, 0x30 ) AM_READ_PORT( "BUTTON" )
- AM_RANGE( 0x31, 0x31 ) AM_WRITE_LEGACY(sammymdl_coin_w )
- AM_RANGE( 0x32, 0x32 ) AM_WRITE_LEGACY(sammymdl_leds_w )
+ AM_RANGE( 0x31, 0x31 ) AM_WRITE(sammymdl_coin_w )
+ AM_RANGE( 0x32, 0x32 ) AM_WRITE(sammymdl_leds_w )
AM_RANGE( 0x90, 0x90 ) AM_DEVWRITE("oki", okim9810_device, write )
AM_RANGE( 0x91, 0x91 ) AM_DEVWRITE("oki", okim9810_device, write_TMP_register )
AM_RANGE( 0x92, 0x92 ) AM_DEVREAD("oki", okim9810_device, read )
- AM_RANGE( 0xb0, 0xb0 ) AM_WRITE_LEGACY(sammymdl_hopper_w )
+ AM_RANGE( 0xb0, 0xb0 ) AM_WRITE(sammymdl_hopper_w )
AM_RANGE( 0xc0, 0xc0 ) AM_WRITE_LEGACY(watchdog_reset_w ) // 1
ADDRESS_MAP_END
@@ -1227,7 +1239,7 @@ ADDRESS_MAP_END
***************************************************************************/
static ADDRESS_MAP_START( pyenaget_io, AS_IO, 8, sigmab98_state )
- AM_RANGE( 0x31, 0x31 ) AM_WRITE_LEGACY(sammymdl_coin_w )
+ AM_RANGE( 0x31, 0x31 ) AM_WRITE(sammymdl_coin_w )
AM_IMPORT_FROM( haekaka_io )
ADDRESS_MAP_END
@@ -1236,19 +1248,18 @@ ADDRESS_MAP_END
***************************************************************************/
// rombank
-static WRITE8_HANDLER( tdoboon_rombank_w )
+WRITE8_MEMBER(sigmab98_state::tdoboon_rombank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg = data;
+ m_reg = data;
return;
}
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x2f:
- state->m_rombank = data;
+ m_rombank = data;
switch (data)
{
case 0x10: // ROM
@@ -1274,80 +1285,76 @@ static WRITE8_HANDLER( tdoboon_rombank_w )
break;
default:
- logerror("%s: unknown rom bank = %02x, reg = %02x\n", space->machine().describe_context(), data, state->m_reg);
+ logerror("%s: unknown rom bank = %02x, reg = %02x\n", machine().describe_context(), data, m_reg);
}
break;
default:
- logerror("%s: unknown reg written: %02x = %02x\n", space->machine().describe_context(), state->m_reg, data);
+ logerror("%s: unknown reg written: %02x = %02x\n", machine().describe_context(), m_reg, data);
}
}
-static READ8_HANDLER( tdoboon_rombank_r )
+READ8_MEMBER(sigmab98_state::tdoboon_rombank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg;
+ return m_reg;
- switch ( state->m_reg )
+ switch ( m_reg )
{
case 0x2f:
- return state->m_rombank;
+ return m_rombank;
default:
- logerror("%s: unknown reg read: %02x\n", space->machine().describe_context(), state->m_reg);
+ logerror("%s: unknown reg read: %02x\n", machine().describe_context(), m_reg);
return 0x00;
}
}
// rambank
-static WRITE8_HANDLER( tdoboon_rambank_w )
+WRITE8_MEMBER(sigmab98_state::tdoboon_rambank_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
{
- state->m_reg2 = data;
+ m_reg2 = data;
return;
}
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x33:
- state->m_rambank = data;
+ m_rambank = data;
switch (data)
{
case 0x53:
break;
default:
- logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", space->machine().describe_context(), data, state->m_reg2);
+ logerror("%s: unknown ram bank = %02x, reg2 = %02x\n", machine().describe_context(), data, m_reg2);
}
break;
default:
- logerror("%s: unknown reg2 written: %02x = %02x\n", space->machine().describe_context(), state->m_reg2, data);
+ logerror("%s: unknown reg2 written: %02x = %02x\n", machine().describe_context(), m_reg2, data);
}
}
-static READ8_HANDLER( tdoboon_rambank_r )
+READ8_MEMBER(sigmab98_state::tdoboon_rambank_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
if (offset == 0)
- return state->m_reg2;
+ return m_reg2;
- switch ( state->m_reg2 )
+ switch ( m_reg2 )
{
case 0x33:
- return state->m_rambank;
+ return m_rambank;
default:
- logerror("%s: unknown reg2 read: %02x\n", space->machine().describe_context(), state->m_reg2);
+ logerror("%s: unknown reg2 read: %02x\n", machine().describe_context(), m_reg2);
return 0x00;
}
}
-static READ8_HANDLER( tdoboon_c000_r )
+READ8_MEMBER(sigmab98_state::tdoboon_c000_r)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- switch (state->m_rombank)
+ switch (m_rombank)
{
case 0x10: // ROM
case 0x11:
@@ -1365,16 +1372,16 @@ static READ8_HANDLER( tdoboon_c000_r )
case 0x1d:
case 0x1e:
case 0x1f:
- return space->machine().region("maincpu")->base()[offset + 0xc400 + 0x1000 * (state->m_rombank-0x10)];
+ return machine().region("maincpu")->base()[offset + 0xc400 + 0x1000 * (m_rombank-0x10)];
case 0x64: // SPRITERAM
if (offset < 0x1000)
- return state->m_spriteram[offset];
+ return m_spriteram[offset];
break;
case 0x66: // PALETTERAM + TABLE?
if (offset < 0x200)
- return space->machine().generic.paletteram.u8[offset];
+ return machine().generic.paletteram.u8[offset];
break;
case 0x67: // REGS
@@ -1383,19 +1390,18 @@ static READ8_HANDLER( tdoboon_c000_r )
break;
}
- logerror("%s: unknown read from %02x with rombank = %02x\n", space->machine().describe_context(), offset+0xc000, state->m_rombank);
+ logerror("%s: unknown read from %02x with rombank = %02x\n", machine().describe_context(), offset+0xc000, m_rombank);
return 0x00;
}
-static WRITE8_HANDLER( tdoboon_c000_w )
+WRITE8_MEMBER(sigmab98_state::tdoboon_c000_w)
{
- sigmab98_state *state = space->machine().driver_data<sigmab98_state>();
- switch (state->m_rombank)
+ switch (m_rombank)
{
case 0x64: // SPRITERAM
if (offset < 0x1000)
{
- state->m_spriteram[offset] = data;
+ m_spriteram[offset] = data;
return;
}
break;
@@ -1404,7 +1410,7 @@ static WRITE8_HANDLER( tdoboon_c000_w )
if (offset < 0x200)
{
paletteram_xRRRRRGGGGGBBBBB_be_w(space, offset, data);
-// space->machine().generic.paletteram.u8[offset] = data;
+// machine().generic.paletteram.u8[offset] = data;
return;
}
else if ((offset >= 0x800) && (offset < 0x880))
@@ -1415,30 +1421,30 @@ static WRITE8_HANDLER( tdoboon_c000_w )
break;
}
- logerror("%s: unknown write to %02x = %02x with rombank = %02x\n", space->machine().describe_context(), offset+0xc000, data, state->m_rombank);
+ logerror("%s: unknown write to %02x = %02x with rombank = %02x\n", machine().describe_context(), offset+0xc000, data, m_rombank);
}
static ADDRESS_MAP_START( tdoboon_map, AS_PROGRAM, 8, sigmab98_state )
AM_RANGE( 0x0000, 0xbfff ) AM_ROM
- AM_RANGE( 0xc000, 0xcfff ) AM_READWRITE_LEGACY(tdoboon_c000_r, tdoboon_c000_w )
+ AM_RANGE( 0xc000, 0xcfff ) AM_READWRITE(tdoboon_c000_r, tdoboon_c000_w )
AM_RANGE( 0xd000, 0xefff ) AM_RAM AM_SHARE( "nvram" ) AM_BASE(m_nvram )
AM_RANGE( 0xfe00, 0xffff ) AM_RAM // High speed internal RAM
ADDRESS_MAP_END
static ADDRESS_MAP_START( tdoboon_io, AS_IO, 8, sigmab98_state )
ADDRESS_MAP_GLOBAL_MASK(0xff)
- AM_RANGE( 0x02, 0x03 ) AM_READWRITE_LEGACY(tdoboon_rombank_r, tdoboon_rombank_w )
- AM_RANGE( 0x04, 0x05 ) AM_READWRITE_LEGACY(tdoboon_rambank_r, tdoboon_rambank_w )
+ AM_RANGE( 0x02, 0x03 ) AM_READWRITE(tdoboon_rombank_r, tdoboon_rombank_w )
+ AM_RANGE( 0x04, 0x05 ) AM_READWRITE(tdoboon_rambank_r, tdoboon_rambank_w )
AM_RANGE( 0x2c, 0x2c ) AM_DEVREADWRITE_LEGACY("eeprom", sammymdl_eeprom_r, sammymdl_eeprom_w )
- AM_RANGE( 0x2e, 0x2e ) AM_READ_LEGACY(sammymdl_coin_hopper_r )
+ AM_RANGE( 0x2e, 0x2e ) AM_READ(sammymdl_coin_hopper_r )
AM_RANGE( 0x30, 0x30 ) AM_READ_PORT( "BUTTON" )
- AM_RANGE( 0x31, 0x31 ) AM_WRITE_LEGACY(sammymdl_coin_w )
- AM_RANGE( 0x32, 0x32 ) AM_WRITE_LEGACY(sammymdl_leds_w )
+ AM_RANGE( 0x31, 0x31 ) AM_WRITE(sammymdl_coin_w )
+ AM_RANGE( 0x32, 0x32 ) AM_WRITE(sammymdl_leds_w )
AM_RANGE( 0x90, 0x90 ) AM_DEVWRITE("oki", okim9810_device, write )
AM_RANGE( 0x91, 0x91 ) AM_DEVWRITE("oki", okim9810_device, write_TMP_register )
AM_RANGE( 0x92, 0x92 ) AM_DEVREAD("oki", okim9810_device, read )
- AM_RANGE( 0xb0, 0xb0 ) AM_WRITE_LEGACY(sammymdl_hopper_w )
+ AM_RANGE( 0xb0, 0xb0 ) AM_WRITE(sammymdl_hopper_w )
AM_RANGE( 0xc0, 0xc0 ) AM_WRITE_LEGACY(watchdog_reset_w ) // 1
ADDRESS_MAP_END
diff --git a/src/mame/drivers/srmp6.c b/src/mame/drivers/srmp6.c
index 160caf81525..add0432f304 100644
--- a/src/mame/drivers/srmp6.c
+++ b/src/mame/drivers/srmp6.c
@@ -90,6 +90,15 @@ public:
unsigned short m_lastb;
unsigned short m_lastb2;
int m_destl;
+ DECLARE_WRITE16_MEMBER(srmp6_input_select_w);
+ DECLARE_READ16_MEMBER(srmp6_inputs_r);
+ DECLARE_WRITE16_MEMBER(video_regs_w);
+ DECLARE_READ16_MEMBER(video_regs_r);
+ DECLARE_WRITE16_MEMBER(srmp6_dma_w);
+ DECLARE_READ16_MEMBER(tileram_r);
+ DECLARE_WRITE16_MEMBER(tileram_w);
+ DECLARE_WRITE16_MEMBER(paletteram_w);
+ DECLARE_READ16_MEMBER(srmp6_irq_ack_r);
};
#define VERBOSE 0
@@ -288,44 +297,41 @@ static SCREEN_UPDATE_RGB32(srmp6)
Main CPU memory handlers
***************************************************************************/
-static WRITE16_HANDLER( srmp6_input_select_w )
+WRITE16_MEMBER(srmp6_state::srmp6_input_select_w)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
- state->m_input_select = data & 0x0f;
+ m_input_select = data & 0x0f;
}
-static READ16_HANDLER( srmp6_inputs_r )
+READ16_MEMBER(srmp6_state::srmp6_inputs_r)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
if (offset == 0) // DSW
- return input_port_read(space->machine(), "DSW");
+ return input_port_read(machine(), "DSW");
- switch (state->m_input_select) // inputs
+ switch (m_input_select) // inputs
{
- case 1<<0: return input_port_read(space->machine(), "KEY0");
- case 1<<1: return input_port_read(space->machine(), "KEY1");
- case 1<<2: return input_port_read(space->machine(), "KEY2");
- case 1<<3: return input_port_read(space->machine(), "KEY3");
+ case 1<<0: return input_port_read(machine(), "KEY0");
+ case 1<<1: return input_port_read(machine(), "KEY1");
+ case 1<<2: return input_port_read(machine(), "KEY2");
+ case 1<<3: return input_port_read(machine(), "KEY3");
}
return 0;
}
-static WRITE16_HANDLER( video_regs_w )
+WRITE16_MEMBER(srmp6_state::video_regs_w)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
switch(offset)
{
case 0x5e/2: // bank switch, used by ROM check
{
- const UINT8 *rom = space->machine().region("nile")->base();
+ const UINT8 *rom = machine().region("nile")->base();
LOG(("%x\n",data));
- memory_set_bankptr(space->machine(), "bank1",(UINT16 *)(rom + (data & 0x0f)*0x200000));
+ memory_set_bankptr(machine(), "bank1",(UINT16 *)(rom + (data & 0x0f)*0x200000));
break;
}
@@ -333,9 +339,9 @@ static WRITE16_HANDLER( video_regs_w )
case 0x5c/2: // either 0x40 explicitely in many places, or according $2083b0 (IT4)
//Fade in/out (0x40(dark)-0x60(normal)-0x7e?(bright) reset by 0x00?
data = (!data)?0x60:(data == 0x5e)?0x60:data;
- if (state->m_brightness != data) {
- state->m_brightness = data;
- update_palette(space->machine());
+ if (m_brightness != data) {
+ m_brightness = data;
+ update_palette(machine());
}
break;
@@ -350,18 +356,17 @@ static WRITE16_HANDLER( video_regs_w )
case 0x56/2: // written 8,9,8,9 successively
default:
- logerror("video_regs_w (PC=%06X): %04x = %04x & %04x\n", cpu_get_previouspc(&space->device()), offset*2, data, mem_mask);
+ logerror("video_regs_w (PC=%06X): %04x = %04x & %04x\n", cpu_get_previouspc(&space.device()), offset*2, data, mem_mask);
break;
}
- COMBINE_DATA(&state->m_video_regs[offset]);
+ COMBINE_DATA(&m_video_regs[offset]);
}
-static READ16_HANDLER( video_regs_r )
+READ16_MEMBER(srmp6_state::video_regs_r)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
- logerror("video_regs_r (PC=%06X): %04x\n", cpu_get_previouspc(&space->device()), offset*2);
- return state->m_video_regs[offset];
+ logerror("video_regs_r (PC=%06X): %04x\n", cpu_get_previouspc(&space.device()), offset*2);
+ return m_video_regs[offset];
}
@@ -402,15 +407,14 @@ static UINT32 process(running_machine &machine,UINT8 b,UINT32 dst_offset)
}
-static WRITE16_HANDLER(srmp6_dma_w)
+WRITE16_MEMBER(srmp6_state::srmp6_dma_w)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
- UINT16* dmaram = state->m_dmaram;
+ UINT16* dmaram = m_dmaram;
COMBINE_DATA(&dmaram[offset]);
if (offset==13 && dmaram[offset]==0x40)
{
- const UINT8 *rom = space->machine().region("nile")->base();
+ const UINT8 *rom = machine().region("nile")->base();
UINT32 srctab=2*((((UINT32)dmaram[5])<<16)|dmaram[4]);
UINT32 srcdata=2*((((UINT32)dmaram[11])<<16)|dmaram[10]);
UINT32 len=4*(((((UINT32)dmaram[7]&3)<<16)|dmaram[6])+1); //??? WRONG!
@@ -433,10 +437,10 @@ static WRITE16_HANDLER(srmp6_dma_w)
dmaram[0x18/2],
dmaram[0x1a/2]));
- state->m_destl = dmaram[9]*0x40000;
+ m_destl = dmaram[9]*0x40000;
- state->m_lastb = 0xfffe;
- state->m_lastb2 = 0xffff;
+ m_lastb = 0xfffe;
+ m_lastb2 = 0xffff;
while(1)
{
@@ -452,13 +456,13 @@ static WRITE16_HANDLER(srmp6_dma_w)
{
UINT8 real_byte;
real_byte = rom[srctab+p*2];
- tempidx+=process(space->machine(),real_byte,tempidx);
+ tempidx+=process(machine(),real_byte,tempidx);
real_byte = rom[srctab+p*2+1];//px[DMA_XOR((current_table_address+p*2+1))];
- tempidx+=process(space->machine(),real_byte,tempidx);
+ tempidx+=process(machine(),real_byte,tempidx);
}
else
{
- tempidx+=process(space->machine(),p,tempidx);
+ tempidx+=process(machine(),p,tempidx);
}
ctrl<<=1;
@@ -476,19 +480,17 @@ static WRITE16_HANDLER(srmp6_dma_w)
}
/* if tileram is actually bigger than the mapped area, how do we access the rest? */
-static READ16_HANDLER(tileram_r)
+READ16_MEMBER(srmp6_state::tileram_r)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
- return state->m_chrram[offset];
+ return m_chrram[offset];
}
-static WRITE16_HANDLER(tileram_w)
+WRITE16_MEMBER(srmp6_state::tileram_w)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
//UINT16 tmp;
- COMBINE_DATA(&state->m_chrram[offset]);
+ COMBINE_DATA(&m_chrram[offset]);
/* are the DMA registers enabled some other way, or always mapped here, over RAM? */
if (offset >= 0xfff00/2 && offset <= 0xfff1a/2 )
@@ -498,11 +500,10 @@ static WRITE16_HANDLER(tileram_w)
}
}
-static WRITE16_HANDLER(paletteram_w)
+WRITE16_MEMBER(srmp6_state::paletteram_w)
{
- srmp6_state *state = space->machine().driver_data<srmp6_state>();
INT8 r, g, b;
- int brg = state->m_brightness - 0x60;
+ int brg = m_brightness - 0x60;
paletteram16_xBBBBBGGGGGRRRRR_word_w(space, offset, data, mem_mask);
@@ -529,13 +530,13 @@ static WRITE16_HANDLER(paletteram_w)
if(b > 0x1F) b = 0x1F;
}
- palette_set_color(space->machine(), offset, MAKE_RGB(r << 3, g << 3, b << 3));
+ palette_set_color(machine(), offset, MAKE_RGB(r << 3, g << 3, b << 3));
}
}
-static READ16_HANDLER( srmp6_irq_ack_r )
+READ16_MEMBER(srmp6_state::srmp6_irq_ack_r)
{
- cputag_set_input_line(space->machine(), "maincpu", 4, CLEAR_LINE);
+ cputag_set_input_line(machine(), "maincpu", 4, CLEAR_LINE);
return 0; // value read doesn't matter
}
@@ -545,18 +546,18 @@ static ADDRESS_MAP_START( srmp6_map, AS_PROGRAM, 16, srmp6_state )
AM_RANGE(0x600000, 0x7fffff) AM_ROMBANK("bank1") // banked ROM (used by ROM check)
AM_RANGE(0x800000, 0x9fffff) AM_ROM AM_REGION("user1", 0)
- AM_RANGE(0x300000, 0x300005) AM_READWRITE_LEGACY(srmp6_inputs_r, srmp6_input_select_w) // inputs
- AM_RANGE(0x480000, 0x480fff) AM_RAM_WRITE_LEGACY(paletteram_w) AM_BASE_GENERIC(paletteram)
- AM_RANGE(0x4d0000, 0x4d0001) AM_READ_LEGACY(srmp6_irq_ack_r)
+ AM_RANGE(0x300000, 0x300005) AM_READWRITE(srmp6_inputs_r, srmp6_input_select_w) // inputs
+ AM_RANGE(0x480000, 0x480fff) AM_RAM_WRITE(paletteram_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x4d0000, 0x4d0001) AM_READ(srmp6_irq_ack_r)
// OBJ RAM: checked [$400000-$47dfff]
AM_RANGE(0x400000, 0x47ffff) AM_RAM AM_BASE(m_sprram)
// CHR RAM: checked [$500000-$5fffff]
- AM_RANGE(0x500000, 0x5fffff) AM_READWRITE_LEGACY(tileram_r,tileram_w) AM_BASE(m_chrram)
+ AM_RANGE(0x500000, 0x5fffff) AM_READWRITE(tileram_r,tileram_w) AM_BASE(m_chrram)
//AM_RANGE(0x5fff00, 0x5fffff) AM_WRITE_LEGACY(dma_w) AM_BASE(m_dmaram)
- AM_RANGE(0x4c0000, 0x4c006f) AM_READWRITE_LEGACY(video_regs_r, video_regs_w) AM_BASE(m_video_regs) // ? gfx regs ST-0026 NiLe
+ AM_RANGE(0x4c0000, 0x4c006f) AM_READWRITE(video_regs_r, video_regs_w) AM_BASE(m_video_regs) // ? gfx regs ST-0026 NiLe
AM_RANGE(0x4e0000, 0x4e00ff) AM_DEVREADWRITE_LEGACY("nile", nile_snd_r, nile_snd_w)
AM_RANGE(0x4e0100, 0x4e0101) AM_DEVREADWRITE_LEGACY("nile", nile_sndctrl_r, nile_sndctrl_w)
//AM_RANGE(0x4e0110, 0x4e0111) AM_NOP // ? accessed once ($268dc, written $b.w)
diff --git a/src/mame/drivers/statriv2.c b/src/mame/drivers/statriv2.c
index 2e65be8de0e..e7bf7b79686 100644
--- a/src/mame/drivers/statriv2.c
+++ b/src/mame/drivers/statriv2.c
@@ -90,6 +90,10 @@ public:
UINT8 m_question_offset_high;
UINT8 m_latched_coin;
UINT8 m_last_coin;
+ DECLARE_WRITE8_MEMBER(statriv2_videoram_w);
+ DECLARE_READ8_MEMBER(question_data_r);
+ DECLARE_READ8_MEMBER(laserdisc_io_r);
+ DECLARE_WRITE8_MEMBER(laserdisc_io_w);
};
@@ -161,12 +165,11 @@ static VIDEO_START( vertical )
*
*************************************/
-static WRITE8_HANDLER( statriv2_videoram_w )
+WRITE8_MEMBER(statriv2_state::statriv2_videoram_w)
{
- statriv2_state *state = space->machine().driver_data<statriv2_state>();
- UINT8 *videoram = state->m_videoram;
+ UINT8 *videoram = m_videoram;
videoram[offset] = data;
- state->m_tilemap->mark_tile_dirty(offset & 0x3ff);
+ m_tilemap->mark_tile_dirty(offset & 0x3ff);
}
@@ -216,20 +219,19 @@ static INTERRUPT_GEN( statriv2_interrupt )
*
*************************************/
-static READ8_HANDLER( question_data_r )
+READ8_MEMBER(statriv2_state::question_data_r)
{
- statriv2_state *state = space->machine().driver_data<statriv2_state>();
- const UINT8 *qrom = space->machine().region("questions")->base();
- UINT32 qromsize = space->machine().region("questions")->bytes();
+ const UINT8 *qrom = machine().region("questions")->base();
+ UINT32 qromsize = machine().region("questions")->bytes();
UINT32 address;
- if (state->m_question_offset_high == 0xff)
- state->m_question_offset[state->m_question_offset_low]++;
+ if (m_question_offset_high == 0xff)
+ m_question_offset[m_question_offset_low]++;
- address = state->m_question_offset[state->m_question_offset_low];
- address |= state->m_question_offset[state->m_question_offset_mid] << 8;
- if (state->m_question_offset_high != 0xff)
- address |= state->m_question_offset[state->m_question_offset_high] << 16;
+ address = m_question_offset[m_question_offset_low];
+ address |= m_question_offset[m_question_offset_mid] << 8;
+ if (m_question_offset_high != 0xff)
+ address |= m_question_offset[m_question_offset_high] << 16;
return (address < qromsize) ? qrom[address] : 0xff;
}
@@ -292,12 +294,12 @@ static ADDRESS_MAP_START( statriv2_map, AS_PROGRAM, 8, statriv2_state )
AM_RANGE(0x0000, 0x3fff) AM_ROM
AM_RANGE(0x4000, 0x43ff) AM_RAM
AM_RANGE(0x4800, 0x48ff) AM_RAM AM_SHARE("nvram")
- AM_RANGE(0xc800, 0xcfff) AM_RAM_WRITE_LEGACY(statriv2_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0xc800, 0xcfff) AM_RAM_WRITE(statriv2_videoram_w) AM_BASE(m_videoram)
ADDRESS_MAP_END
static ADDRESS_MAP_START( statriv2_io_map, AS_IO, 8, statriv2_state )
AM_RANGE(0x20, 0x23) AM_DEVREADWRITE_LEGACY("ppi", ppi8255_r, ppi8255_w)
- AM_RANGE(0x28, 0x2b) AM_READ_LEGACY(question_data_r) AM_WRITEONLY AM_BASE(m_question_offset)
+ AM_RANGE(0x28, 0x2b) AM_READ(question_data_r) AM_WRITEONLY AM_BASE(m_question_offset)
AM_RANGE(0xb0, 0xb1) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
AM_RANGE(0xb1, 0xb1) AM_DEVREAD_LEGACY("aysnd", ay8910_r)
AM_RANGE(0xc0, 0xcf) AM_DEVREADWRITE_LEGACY("tms", tms9927_r, tms9927_w)
@@ -1109,24 +1111,25 @@ static DRIVER_INIT( addr_lmhe )
}
-static READ8_HANDLER( laserdisc_io_r )
+READ8_MEMBER(statriv2_state::laserdisc_io_r)
{
UINT8 result = 0x00;
if (offset == 1)
result = 0x18;
- mame_printf_debug("%s:ld read ($%02X) = %02X\n", space->machine().describe_context(), 0x28 + offset, result);
+ mame_printf_debug("%s:ld read ($%02X) = %02X\n", machine().describe_context(), 0x28 + offset, result);
return result;
}
-static WRITE8_HANDLER( laserdisc_io_w )
+WRITE8_MEMBER(statriv2_state::laserdisc_io_w)
{
- mame_printf_debug("%s:ld write ($%02X) = %02X\n", space->machine().describe_context(), 0x28 + offset, data);
+ mame_printf_debug("%s:ld write ($%02X) = %02X\n", machine().describe_context(), 0x28 + offset, data);
}
static DRIVER_INIT( laserdisc )
{
address_space *iospace = machine.device("maincpu")->memory().space(AS_IO);
- iospace->install_legacy_readwrite_handler(0x28, 0x2b, FUNC(laserdisc_io_r), FUNC(laserdisc_io_w));
+ statriv2_state *state = machine.driver_data<statriv2_state>();
+ iospace->install_readwrite_handler(0x28, 0x2b, read8_delegate(FUNC(statriv2_state::laserdisc_io_r), state), write8_delegate(FUNC(statriv2_state::laserdisc_io_w), state));
}
diff --git a/src/mame/drivers/subsino2.c b/src/mame/drivers/subsino2.c
index 888f2094ece..196cc951f3d 100644
--- a/src/mame/drivers/subsino2.c
+++ b/src/mame/drivers/subsino2.c
@@ -96,6 +96,57 @@ public:
UINT8 *m_am188em_regs;
UINT16 m_bishjan_sel;
UINT16 m_bishjan_input;
+ DECLARE_WRITE8_MEMBER(ss9601_byte_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_byte_lo2_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_0_hi_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_0_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_0_hi_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_0_hi_lo2_w);
+ DECLARE_READ8_MEMBER(ss9601_videoram_0_hi_r);
+ DECLARE_READ8_MEMBER(ss9601_videoram_0_lo_r);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_1_hi_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_1_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_1_hi_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_videoram_1_hi_lo2_w);
+ DECLARE_READ8_MEMBER(ss9601_videoram_1_hi_r);
+ DECLARE_READ8_MEMBER(ss9601_videoram_1_lo_r);
+ DECLARE_WRITE8_MEMBER(ss9601_reelram_hi_lo_w);
+ DECLARE_READ8_MEMBER(ss9601_reelram_hi_r);
+ DECLARE_READ8_MEMBER(ss9601_reelram_lo_r);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollctrl_w);
+ DECLARE_WRITE8_MEMBER(ss9601_tilesize_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scroll_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_0_hi_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_0_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_0_hi_lo_w);
+ DECLARE_READ8_MEMBER(ss9601_scrollram_0_hi_r);
+ DECLARE_READ8_MEMBER(ss9601_scrollram_0_lo_r);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_1_hi_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_1_lo_w);
+ DECLARE_WRITE8_MEMBER(ss9601_scrollram_1_hi_lo_w);
+ DECLARE_READ8_MEMBER(ss9601_scrollram_1_hi_r);
+ DECLARE_READ8_MEMBER(ss9601_scrollram_1_lo_r);
+ DECLARE_WRITE8_MEMBER(ss9601_disable_w);
+ DECLARE_WRITE8_MEMBER(hm86171_colorram_w);
+ DECLARE_WRITE8_MEMBER(dsw_mask_w);
+ DECLARE_READ8_MEMBER(dsw_r);
+ DECLARE_READ8_MEMBER(vblank_bit2_r);
+ DECLARE_READ8_MEMBER(vblank_bit6_r);
+ DECLARE_READ8_MEMBER(am188em_regs_r);
+ DECLARE_WRITE8_MEMBER(am188em_regs_w);
+ DECLARE_WRITE16_MEMBER(bishjan_sel_w);
+ DECLARE_READ16_MEMBER(bishjan_serial_r);
+ DECLARE_WRITE16_MEMBER(bishjan_input_w);
+ DECLARE_READ16_MEMBER(bishjan_input_r);
+ DECLARE_WRITE16_MEMBER(bishjan_outputs_w);
+ DECLARE_WRITE8_MEMBER(expcard_outputs_w);
+ DECLARE_WRITE8_MEMBER(mtrain_outputs_w);
+ DECLARE_WRITE8_MEMBER(mtrain_videoram_w);
+ DECLARE_WRITE8_MEMBER(mtrain_tilesize_w);
+ DECLARE_READ8_MEMBER(mtrain_prot_r);
+ DECLARE_WRITE8_MEMBER(saklove_outputs_w);
+ DECLARE_WRITE8_MEMBER(xplan_outputs_w);
+ DECLARE_WRITE8_MEMBER(xtrain_outputs_w);
};
@@ -133,15 +184,13 @@ static TILE_GET_INFO( ss9601_get_tile_info_1 )
}
-static WRITE8_HANDLER( ss9601_byte_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_byte_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_byte_lo = data;
+ m_ss9601_byte_lo = data;
}
-static WRITE8_HANDLER( ss9601_byte_lo2_w )
+WRITE8_MEMBER(subsino2_state::ss9601_byte_lo2_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_byte_lo2 = data;
+ m_ss9601_byte_lo2 = data;
}
@@ -172,100 +221,85 @@ INLINE void ss9601_videoram_w(layer_t *l, vram_t vram, address_space *space, off
}
// Layer 0
-static WRITE8_HANDLER( ss9601_videoram_0_hi_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_0_hi_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[0], VRAM_HI, space, offset, data);
+ ss9601_videoram_w(&m_layers[0], VRAM_HI, &space, offset, data);
}
-static WRITE8_HANDLER( ss9601_videoram_0_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_0_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[0], VRAM_LO, space, offset, data);
+ ss9601_videoram_w(&m_layers[0], VRAM_LO, &space, offset, data);
}
-static WRITE8_HANDLER( ss9601_videoram_0_hi_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_0_hi_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[0], VRAM_HI, space, offset, data);
- ss9601_videoram_w(&state->m_layers[0], VRAM_LO, space, offset, state->m_ss9601_byte_lo);
+ ss9601_videoram_w(&m_layers[0], VRAM_HI, &space, offset, data);
+ ss9601_videoram_w(&m_layers[0], VRAM_LO, &space, offset, m_ss9601_byte_lo);
}
-static WRITE8_HANDLER( ss9601_videoram_0_hi_lo2_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_0_hi_lo2_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[0], VRAM_HI, space, offset, data);
- ss9601_videoram_w(&state->m_layers[0], VRAM_LO, space, offset, state->m_ss9601_byte_lo2);
+ ss9601_videoram_w(&m_layers[0], VRAM_HI, &space, offset, data);
+ ss9601_videoram_w(&m_layers[0], VRAM_LO, &space, offset, m_ss9601_byte_lo2);
}
-static READ8_HANDLER( ss9601_videoram_0_hi_r )
+READ8_MEMBER(subsino2_state::ss9601_videoram_0_hi_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[0].videorams[VRAM_HI][offset];
+ return m_layers[0].videorams[VRAM_HI][offset];
}
-static READ8_HANDLER( ss9601_videoram_0_lo_r )
+READ8_MEMBER(subsino2_state::ss9601_videoram_0_lo_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[0].videorams[VRAM_LO][offset];
+ return m_layers[0].videorams[VRAM_LO][offset];
}
// Layer 1
-static WRITE8_HANDLER( ss9601_videoram_1_hi_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_1_hi_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[1], VRAM_HI, space, offset, data);
+ ss9601_videoram_w(&m_layers[1], VRAM_HI, &space, offset, data);
}
-static WRITE8_HANDLER( ss9601_videoram_1_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_1_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[1], VRAM_LO, space, offset, data);
+ ss9601_videoram_w(&m_layers[1], VRAM_LO, &space, offset, data);
}
-static WRITE8_HANDLER( ss9601_videoram_1_hi_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_1_hi_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[1], VRAM_HI, space, offset, data);
- ss9601_videoram_w(&state->m_layers[1], VRAM_LO, space, offset, state->m_ss9601_byte_lo);
+ ss9601_videoram_w(&m_layers[1], VRAM_HI, &space, offset, data);
+ ss9601_videoram_w(&m_layers[1], VRAM_LO, &space, offset, m_ss9601_byte_lo);
}
-static WRITE8_HANDLER( ss9601_videoram_1_hi_lo2_w )
+WRITE8_MEMBER(subsino2_state::ss9601_videoram_1_hi_lo2_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- ss9601_videoram_w(&state->m_layers[1], VRAM_HI, space, offset, data);
- ss9601_videoram_w(&state->m_layers[1], VRAM_LO, space, offset, state->m_ss9601_byte_lo2);
+ ss9601_videoram_w(&m_layers[1], VRAM_HI, &space, offset, data);
+ ss9601_videoram_w(&m_layers[1], VRAM_LO, &space, offset, m_ss9601_byte_lo2);
}
-static READ8_HANDLER( ss9601_videoram_1_hi_r )
+READ8_MEMBER(subsino2_state::ss9601_videoram_1_hi_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[1].videorams[VRAM_HI][offset];
+ return m_layers[1].videorams[VRAM_HI][offset];
}
-static READ8_HANDLER( ss9601_videoram_1_lo_r )
+READ8_MEMBER(subsino2_state::ss9601_videoram_1_lo_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[1].videorams[VRAM_LO][offset];
+ return m_layers[1].videorams[VRAM_LO][offset];
}
// Layer 0 Reels
-static WRITE8_HANDLER( ss9601_reelram_hi_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_reelram_hi_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_reelrams[VRAM_HI][offset] = data;
- state->m_ss9601_reelrams[VRAM_LO][offset] = state->m_ss9601_byte_lo;
+ m_ss9601_reelrams[VRAM_HI][offset] = data;
+ m_ss9601_reelrams[VRAM_LO][offset] = m_ss9601_byte_lo;
}
-static READ8_HANDLER( ss9601_reelram_hi_r )
+READ8_MEMBER(subsino2_state::ss9601_reelram_hi_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_ss9601_reelrams[VRAM_HI][offset];
+ return m_ss9601_reelrams[VRAM_HI][offset];
}
-static READ8_HANDLER( ss9601_reelram_lo_r )
+READ8_MEMBER(subsino2_state::ss9601_reelram_lo_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_ss9601_reelrams[VRAM_LO][offset];
+ return m_ss9601_reelrams[VRAM_LO][offset];
}
@@ -374,16 +408,14 @@ wtrnymph xplan
// These are written in sequence
-static WRITE8_HANDLER( ss9601_scrollctrl_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollctrl_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_scrollctrl = data;
+ m_ss9601_scrollctrl = data;
}
-static WRITE8_HANDLER( ss9601_tilesize_w )
+WRITE8_MEMBER(subsino2_state::ss9601_tilesize_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_tilesize = data;
+ m_ss9601_tilesize = data;
tilesize_t sizes[2];
switch (data)
@@ -407,14 +439,14 @@ static WRITE8_HANDLER( ss9601_tilesize_w )
sizes[0] = TILE_8x8;
sizes[1] = TILE_8x8;
- logerror("%s: warning, unknown tilesize = %02x\n", space->machine().describe_context(), data);
+ logerror("%s: warning, unknown tilesize = %02x\n", machine().describe_context(), data);
popmessage("UNKNOWN TILESIZE %02X", data);
break;
}
for (int i = 0; i < 2; i++)
{
- layer_t *l = &state->m_layers[i];
+ layer_t *l = &m_layers[i];
if (l->tilesize != sizes[i])
{
@@ -428,10 +460,9 @@ static WRITE8_HANDLER( ss9601_tilesize_w )
Tilemaps Scroll
***************************************************************************/
-static WRITE8_HANDLER( ss9601_scroll_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scroll_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- layer_t *layers = state->m_layers;
+ layer_t *layers = m_layers;
switch ( offset )
{
// Layer 0
@@ -449,67 +480,57 @@ static WRITE8_HANDLER( ss9601_scroll_w )
}
// Layer 0
-static WRITE8_HANDLER( ss9601_scrollram_0_hi_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_0_hi_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[0].scrollrams[VRAM_HI][offset] = data;
+ m_layers[0].scrollrams[VRAM_HI][offset] = data;
}
-static WRITE8_HANDLER( ss9601_scrollram_0_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_0_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[0].scrollrams[VRAM_LO][offset] = data;
+ m_layers[0].scrollrams[VRAM_LO][offset] = data;
}
-static WRITE8_HANDLER( ss9601_scrollram_0_hi_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_0_hi_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[0].scrollrams[VRAM_HI][offset] = data;
- state->m_layers[0].scrollrams[VRAM_LO][offset] = state->m_ss9601_byte_lo;
+ m_layers[0].scrollrams[VRAM_HI][offset] = data;
+ m_layers[0].scrollrams[VRAM_LO][offset] = m_ss9601_byte_lo;
}
-static READ8_HANDLER ( ss9601_scrollram_0_hi_r )
+READ8_MEMBER(subsino2_state::ss9601_scrollram_0_hi_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[0].scrollrams[VRAM_HI][offset];
+ return m_layers[0].scrollrams[VRAM_HI][offset];
}
-static READ8_HANDLER ( ss9601_scrollram_0_lo_r )
+READ8_MEMBER(subsino2_state::ss9601_scrollram_0_lo_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[0].scrollrams[VRAM_LO][offset];
+ return m_layers[0].scrollrams[VRAM_LO][offset];
}
// Layer 1
-static WRITE8_HANDLER( ss9601_scrollram_1_hi_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_1_hi_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[1].scrollrams[VRAM_HI][offset] = data;
+ m_layers[1].scrollrams[VRAM_HI][offset] = data;
}
-static WRITE8_HANDLER( ss9601_scrollram_1_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_1_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[1].scrollrams[VRAM_LO][offset] = data;
+ m_layers[1].scrollrams[VRAM_LO][offset] = data;
}
-static WRITE8_HANDLER( ss9601_scrollram_1_hi_lo_w )
+WRITE8_MEMBER(subsino2_state::ss9601_scrollram_1_hi_lo_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_layers[1].scrollrams[VRAM_HI][offset] = data;
- state->m_layers[1].scrollrams[VRAM_LO][offset] = state->m_ss9601_byte_lo;
+ m_layers[1].scrollrams[VRAM_HI][offset] = data;
+ m_layers[1].scrollrams[VRAM_LO][offset] = m_ss9601_byte_lo;
}
-static READ8_HANDLER ( ss9601_scrollram_1_hi_r )
+READ8_MEMBER(subsino2_state::ss9601_scrollram_1_hi_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[1].scrollrams[VRAM_HI][offset];
+ return m_layers[1].scrollrams[VRAM_HI][offset];
}
-static READ8_HANDLER ( ss9601_scrollram_1_lo_r )
+READ8_MEMBER(subsino2_state::ss9601_scrollram_1_lo_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_layers[1].scrollrams[VRAM_LO][offset];
+ return m_layers[1].scrollrams[VRAM_LO][offset];
}
@@ -517,10 +538,9 @@ static READ8_HANDLER ( ss9601_scrollram_1_lo_r )
Tilemaps Disable
***************************************************************************/
-static WRITE8_HANDLER( ss9601_disable_w )
+WRITE8_MEMBER(subsino2_state::ss9601_disable_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_disable = data;
+ m_ss9601_disable = data;
}
@@ -724,23 +744,22 @@ static SCREEN_UPDATE_IND16( subsino2 )
***************************************************************************/
-static WRITE8_HANDLER( hm86171_colorram_w )
+WRITE8_MEMBER(subsino2_state::hm86171_colorram_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
switch (offset)
{
case 0:
- state->m_hm86171_offs = data * 3;
+ m_hm86171_offs = data * 3;
break;
case 1:
- state->m_hm86171_colorram[state->m_hm86171_offs] = data;
- palette_set_color_rgb(space->machine(), state->m_hm86171_offs/3,
- pal6bit(state->m_hm86171_colorram[(state->m_hm86171_offs/3)*3+0]),
- pal6bit(state->m_hm86171_colorram[(state->m_hm86171_offs/3)*3+1]),
- pal6bit(state->m_hm86171_colorram[(state->m_hm86171_offs/3)*3+2])
+ m_hm86171_colorram[m_hm86171_offs] = data;
+ palette_set_color_rgb(machine(), m_hm86171_offs/3,
+ pal6bit(m_hm86171_colorram[(m_hm86171_offs/3)*3+0]),
+ pal6bit(m_hm86171_colorram[(m_hm86171_offs/3)*3+1]),
+ pal6bit(m_hm86171_colorram[(m_hm86171_offs/3)*3+2])
);
- state->m_hm86171_offs = (state->m_hm86171_offs+1) % (256*3);
+ m_hm86171_offs = (m_hm86171_offs+1) % (256*3);
break;
case 2:
@@ -757,29 +776,27 @@ static WRITE8_HANDLER( hm86171_colorram_w )
Input / Output
***************************************************************************/
-static WRITE8_HANDLER( dsw_mask_w )
+WRITE8_MEMBER(subsino2_state::dsw_mask_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_dsw_mask = data;
+ m_dsw_mask = data;
}
-static READ8_HANDLER( dsw_r )
+READ8_MEMBER(subsino2_state::dsw_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return ( (input_port_read(space->machine(), "DSW1") & state->m_dsw_mask) ? 0x01 : 0 ) |
- ( (input_port_read(space->machine(), "DSW2") & state->m_dsw_mask) ? 0x02 : 0 ) |
- ( (input_port_read(space->machine(), "DSW3") & state->m_dsw_mask) ? 0x04 : 0 ) |
- ( (input_port_read(space->machine(), "DSW4") & state->m_dsw_mask) ? 0x08 : 0 ) ;
+ return ( (input_port_read(machine(), "DSW1") & m_dsw_mask) ? 0x01 : 0 ) |
+ ( (input_port_read(machine(), "DSW2") & m_dsw_mask) ? 0x02 : 0 ) |
+ ( (input_port_read(machine(), "DSW3") & m_dsw_mask) ? 0x04 : 0 ) |
+ ( (input_port_read(machine(), "DSW4") & m_dsw_mask) ? 0x08 : 0 ) ;
}
-static READ8_HANDLER( vblank_bit2_r )
+READ8_MEMBER(subsino2_state::vblank_bit2_r)
{
- return space->machine().primary_screen->vblank() ? 0x04 : 0x00;
+ return machine().primary_screen->vblank() ? 0x04 : 0x00;
}
-static READ8_HANDLER( vblank_bit6_r )
+READ8_MEMBER(subsino2_state::vblank_bit6_r)
{
- return space->machine().primary_screen->vblank() ? 0x40 : 0x00;
+ return machine().primary_screen->vblank() ? 0x40 : 0x00;
}
static WRITE8_DEVICE_HANDLER( oki_bank_bit0_w )
@@ -810,16 +827,14 @@ enum
AM188EM_I0CON = 0x38
};
-static READ8_HANDLER( am188em_regs_r )
+READ8_MEMBER(subsino2_state::am188em_regs_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- return state->m_am188em_regs[offset];
+ return m_am188em_regs[offset];
}
-static WRITE8_HANDLER( am188em_regs_w )
+WRITE8_MEMBER(subsino2_state::am188em_regs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_am188em_regs[offset] = data;
+ m_am188em_regs[offset] = data;
}
static MACHINE_RESET( am188em )
@@ -867,52 +882,47 @@ static TIMER_DEVICE_CALLBACK( h8_timer_irq )
***************************************************************************/
-static WRITE16_HANDLER( bishjan_sel_w )
+WRITE16_MEMBER(subsino2_state::bishjan_sel_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
if (ACCESSING_BITS_8_15)
- state->m_bishjan_sel = data >> 8;
+ m_bishjan_sel = data >> 8;
}
-static READ16_HANDLER( bishjan_serial_r )
+READ16_MEMBER(subsino2_state::bishjan_serial_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
return
- (space->machine().rand() & 0x9800) | // bit 7 - serial communication
- (((state->m_bishjan_sel==0x12) ? 0x40:0x00) << 8) |
+ (machine().rand() & 0x9800) | // bit 7 - serial communication
+ (((m_bishjan_sel==0x12) ? 0x40:0x00) << 8) |
// (machine.rand() & 0xff);
-// (((space->machine().primary_screen->frame_number()%60)==0)?0x18:0x00);
+// (((machine().primary_screen->frame_number()%60)==0)?0x18:0x00);
0x18;
}
-static WRITE16_HANDLER( bishjan_input_w )
+WRITE16_MEMBER(subsino2_state::bishjan_input_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
if (ACCESSING_BITS_8_15)
- state->m_bishjan_input = data >> 8;
+ m_bishjan_input = data >> 8;
}
-static READ16_HANDLER( bishjan_input_r )
+READ16_MEMBER(subsino2_state::bishjan_input_r)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
int i;
UINT16 res = 0xff;
static const char *const port[] = { "KEYB_0", "KEYB_1", "KEYB_2", "KEYB_3", "KEYB_4" };
for (i = 0; i < 5; i++)
- if (state->m_bishjan_input & (1 << i))
- res = input_port_read(space->machine(), port[i]);
+ if (m_bishjan_input & (1 << i))
+ res = input_port_read(machine(), port[i]);
return (res << 8) | // high byte
- input_port_read(space->machine(), "SYSTEM") | // low byte
- (ticket_dispenser_r(space->machine().device("hopper"), 0) ? 0x00 : 0x04) // bit 2: hopper sensor
+ input_port_read(machine(), "SYSTEM") | // low byte
+ (ticket_dispenser_r(machine().device("hopper"), 0) ? 0x00 : 0x04) // bit 2: hopper sensor
;
}
-static WRITE16_HANDLER( bishjan_outputs_w )
+WRITE16_MEMBER(subsino2_state::bishjan_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs16[offset] = data;
+ m_outputs16[offset] = data;
switch (offset)
{
@@ -920,13 +930,13 @@ static WRITE16_HANDLER( bishjan_outputs_w )
if (ACCESSING_BITS_0_7)
{
// coin out data & 0x01;
- ticket_dispenser_w(space->machine().device("hopper"), 0, (data & 0x0002) ? 0x80 : 0); // hopper
- coin_counter_w(space->machine(), 0, data & 0x0010 );
+ ticket_dispenser_w(machine().device("hopper"), 0, (data & 0x0002) ? 0x80 : 0); // hopper
+ coin_counter_w(machine(), 0, data & 0x0010 );
}
break;
}
-// popmessage("0: %04x", state->m_outputs16[0]);
+// popmessage("0: %04x", m_outputs16[0]);
}
@@ -939,53 +949,52 @@ static ADDRESS_MAP_START( bishjan_map, AS_PROGRAM, 16, subsino2_state )
AM_RANGE( 0x200000, 0x207fff ) AM_RAM AM_SHARE("nvram") // battery
// read lo (L1) (only half tilemap?)
- AM_RANGE( 0x412000, 0x412fff ) AM_READ8_LEGACY(ss9601_videoram_1_lo_r, 0xffff )
- AM_RANGE( 0x413000, 0x4131ff ) AM_READWRITE8_LEGACY(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w, 0xffff )
+ AM_RANGE( 0x412000, 0x412fff ) AM_READ8(ss9601_videoram_1_lo_r, 0xffff )
+ AM_RANGE( 0x413000, 0x4131ff ) AM_READWRITE8(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w, 0xffff )
// read lo (REEL)
- AM_RANGE( 0x416000, 0x416fff ) AM_READ8_LEGACY(ss9601_reelram_lo_r, 0xffff )
- AM_RANGE( 0x417000, 0x4171ff ) AM_READWRITE8_LEGACY(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w, 0xffff )
+ AM_RANGE( 0x416000, 0x416fff ) AM_READ8(ss9601_reelram_lo_r, 0xffff )
+ AM_RANGE( 0x417000, 0x4171ff ) AM_READWRITE8(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w, 0xffff )
// read hi (L1)
- AM_RANGE( 0x422000, 0x422fff ) AM_READ8_LEGACY(ss9601_videoram_1_hi_r, 0xffff )
- AM_RANGE( 0x423000, 0x4231ff ) AM_READWRITE8_LEGACY(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w, 0xffff )
+ AM_RANGE( 0x422000, 0x422fff ) AM_READ8(ss9601_videoram_1_hi_r, 0xffff )
+ AM_RANGE( 0x423000, 0x4231ff ) AM_READWRITE8(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w, 0xffff )
// read hi (REEL)
- AM_RANGE( 0x426000, 0x426fff ) AM_READ8_LEGACY(ss9601_reelram_hi_r, 0xffff )
- AM_RANGE( 0x427000, 0x4271ff ) AM_READWRITE8_LEGACY(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w, 0xffff )
+ AM_RANGE( 0x426000, 0x426fff ) AM_READ8(ss9601_reelram_hi_r, 0xffff )
+ AM_RANGE( 0x427000, 0x4271ff ) AM_READWRITE8(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w, 0xffff )
// write both (L1)
- AM_RANGE( 0x430000, 0x431fff ) AM_WRITE8_LEGACY(ss9601_videoram_1_hi_lo_w, 0xffff )
- AM_RANGE( 0x432000, 0x432fff ) AM_WRITE8_LEGACY(ss9601_videoram_1_hi_lo_w, 0xffff )
- AM_RANGE( 0x433000, 0x4331ff ) AM_WRITE8_LEGACY(ss9601_scrollram_1_hi_lo_w, 0xffff )
+ AM_RANGE( 0x430000, 0x431fff ) AM_WRITE8(ss9601_videoram_1_hi_lo_w, 0xffff )
+ AM_RANGE( 0x432000, 0x432fff ) AM_WRITE8(ss9601_videoram_1_hi_lo_w, 0xffff )
+ AM_RANGE( 0x433000, 0x4331ff ) AM_WRITE8(ss9601_scrollram_1_hi_lo_w, 0xffff )
// write both (L0 & REEL)
- AM_RANGE( 0x434000, 0x435fff ) AM_WRITE8_LEGACY(ss9601_videoram_0_hi_lo_w, 0xffff )
- AM_RANGE( 0x436000, 0x436fff ) AM_WRITE8_LEGACY(ss9601_reelram_hi_lo_w, 0xffff )
- AM_RANGE( 0x437000, 0x4371ff ) AM_WRITE8_LEGACY(ss9601_scrollram_0_hi_lo_w, 0xffff )
+ AM_RANGE( 0x434000, 0x435fff ) AM_WRITE8(ss9601_videoram_0_hi_lo_w, 0xffff )
+ AM_RANGE( 0x436000, 0x436fff ) AM_WRITE8(ss9601_reelram_hi_lo_w, 0xffff )
+ AM_RANGE( 0x437000, 0x4371ff ) AM_WRITE8(ss9601_scrollram_0_hi_lo_w, 0xffff )
- AM_RANGE( 0x600000, 0x600001 ) AM_READNOP AM_WRITE_LEGACY(bishjan_sel_w )
- AM_RANGE( 0x600040, 0x600041 ) AM_WRITE8_LEGACY(ss9601_scrollctrl_w, 0xff00 )
- AM_RANGE( 0x600060, 0x600063 ) AM_WRITE8_LEGACY(hm86171_colorram_w, 0xffff )
- AM_RANGE( 0x600080, 0x600081 ) AM_WRITE8_LEGACY(ss9601_tilesize_w, 0xff00 )
- AM_RANGE( 0x6000a0, 0x6000a1 ) AM_WRITE8_LEGACY(ss9601_byte_lo_w, 0xff00 )
+ AM_RANGE( 0x600000, 0x600001 ) AM_READNOP AM_WRITE(bishjan_sel_w )
+ AM_RANGE( 0x600040, 0x600041 ) AM_WRITE8(ss9601_scrollctrl_w, 0xff00 )
+ AM_RANGE( 0x600060, 0x600063 ) AM_WRITE8(hm86171_colorram_w, 0xffff )
+ AM_RANGE( 0x600080, 0x600081 ) AM_WRITE8(ss9601_tilesize_w, 0xff00 )
+ AM_RANGE( 0x6000a0, 0x6000a1 ) AM_WRITE8(ss9601_byte_lo_w, 0xff00 )
- AM_RANGE( 0xa0001e, 0xa0001f ) AM_WRITE8_LEGACY(ss9601_disable_w, 0x00ff )
+ AM_RANGE( 0xa0001e, 0xa0001f ) AM_WRITE8(ss9601_disable_w, 0x00ff )
- AM_RANGE( 0xa00020, 0xa00025 ) AM_WRITE8_LEGACY(ss9601_scroll_w, 0xffff )
+ AM_RANGE( 0xa00020, 0xa00025 ) AM_WRITE8(ss9601_scroll_w, 0xffff )
AM_RANGE( 0xc00000, 0xc00001 ) AM_READ_PORT("DSW") // SW1
- AM_RANGE( 0xc00002, 0xc00003 ) AM_READ_PORT("JOY") AM_WRITE_LEGACY(bishjan_input_w ) // IN C
- AM_RANGE( 0xc00004, 0xc00005 ) AM_READ_LEGACY(bishjan_input_r ) // IN A & B
- AM_RANGE( 0xc00006, 0xc00007 ) AM_READ_LEGACY(bishjan_serial_r ) // IN D
- AM_RANGE( 0xc00008, 0xc00009 ) AM_READ_PORT("RESET") AM_WRITE_LEGACY(bishjan_outputs_w ) AM_BASE(m_outputs16 )
+ AM_RANGE( 0xc00002, 0xc00003 ) AM_READ_PORT("JOY") AM_WRITE(bishjan_input_w ) // IN C
+ AM_RANGE( 0xc00004, 0xc00005 ) AM_READ(bishjan_input_r ) // IN A & B
+ AM_RANGE( 0xc00006, 0xc00007 ) AM_READ(bishjan_serial_r ) // IN D
+ AM_RANGE( 0xc00008, 0xc00009 ) AM_READ_PORT("RESET") AM_WRITE(bishjan_outputs_w ) AM_BASE(m_outputs16 )
ADDRESS_MAP_END
/***************************************************************************
Express Card / Top Card
***************************************************************************/
-static WRITE8_HANDLER( expcard_outputs_w )
+WRITE8_MEMBER(subsino2_state::expcard_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs[offset] = data;
+ m_outputs[offset] = data;
switch (offset)
{
@@ -994,51 +1003,50 @@ static WRITE8_HANDLER( expcard_outputs_w )
break;
case 1: // C
- set_led_status(space->machine(), 0, data & 0x02); // raise
+ set_led_status(machine(), 0, data & 0x02); // raise
break;
case 2: // B
- set_led_status(space->machine(), 1, data & 0x04); // hold 4 / small & hold 5 / big ?
- set_led_status(space->machine(), 2, data & 0x08); // hold 1 / bet
- set_led_status(space->machine(), 3, data & 0x10); // hold 2 / take ?
- set_led_status(space->machine(), 4, data & 0x20); // hold 3 / double up ?
+ set_led_status(machine(), 1, data & 0x04); // hold 4 / small & hold 5 / big ?
+ set_led_status(machine(), 2, data & 0x08); // hold 1 / bet
+ set_led_status(machine(), 3, data & 0x10); // hold 2 / take ?
+ set_led_status(machine(), 4, data & 0x20); // hold 3 / double up ?
break;
case 3: // A
- coin_counter_w(space->machine(), 0, data & 0x01 ); // coin in
- coin_counter_w(space->machine(), 1, data & 0x02 ); // key in
+ coin_counter_w(machine(), 0, data & 0x01 ); // coin in
+ coin_counter_w(machine(), 1, data & 0x02 ); // key in
- set_led_status(space->machine(), 5, data & 0x10); // start
+ set_led_status(machine(), 5, data & 0x10); // start
break;
}
-// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", state->m_outputs[0], state->m_outputs[1], state->m_outputs[2], state->m_outputs[3]);
+// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", m_outputs[0], m_outputs[1], m_outputs[2], m_outputs[3]);
}
/***************************************************************************
Magic Train
***************************************************************************/
-static WRITE8_HANDLER( mtrain_outputs_w )
+WRITE8_MEMBER(subsino2_state::mtrain_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs[offset] = data;
+ m_outputs[offset] = data;
switch (offset)
{
case 0:
- coin_counter_w(space->machine(), 0, data & 0x01 ); // key in
- coin_counter_w(space->machine(), 1, data & 0x02 ); // coin in
- coin_counter_w(space->machine(), 2, data & 0x10 ); // pay out
-// coin_counter_w(space->machine(), 3, data & 0x20 ); // hopper motor
+ coin_counter_w(machine(), 0, data & 0x01 ); // key in
+ coin_counter_w(machine(), 1, data & 0x02 ); // coin in
+ coin_counter_w(machine(), 2, data & 0x10 ); // pay out
+// coin_counter_w(machine(), 3, data & 0x20 ); // hopper motor
break;
case 1:
- set_led_status(space->machine(), 0, data & 0x01); // stop reel?
- set_led_status(space->machine(), 1, data & 0x02); // stop reel? (double or take)
- set_led_status(space->machine(), 2, data & 0x04); // start all
- set_led_status(space->machine(), 3, data & 0x08); // bet / stop all
- set_led_status(space->machine(), 4, data & 0x20); // stop reel? (double or take)
+ set_led_status(machine(), 0, data & 0x01); // stop reel?
+ set_led_status(machine(), 1, data & 0x02); // stop reel? (double or take)
+ set_led_status(machine(), 2, data & 0x04); // start all
+ set_led_status(machine(), 3, data & 0x08); // bet / stop all
+ set_led_status(machine(), 4, data & 0x20); // stop reel? (double or take)
break;
case 2:
@@ -1048,29 +1056,27 @@ static WRITE8_HANDLER( mtrain_outputs_w )
break;
}
-// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", state->m_outputs[0], state->m_outputs[1], state->m_outputs[2], state->m_outputs[3]);
+// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", m_outputs[0], m_outputs[1], m_outputs[2], m_outputs[3]);
}
-static WRITE8_HANDLER( mtrain_videoram_w )
+WRITE8_MEMBER(subsino2_state::mtrain_videoram_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- vram_t vram = (state->m_ss9601_byte_lo & 0x08) ? VRAM_HI : VRAM_LO;
- switch (state->m_ss9601_byte_lo & (~0x08))
+ vram_t vram = (m_ss9601_byte_lo & 0x08) ? VRAM_HI : VRAM_LO;
+ switch (m_ss9601_byte_lo & (~0x08))
{
- case 0x00: ss9601_videoram_w(&state->m_layers[1], vram, space, offset, data);
- ss9601_videoram_w(&state->m_layers[1], vram, space, offset+0x1000, data); break;
+ case 0x00: ss9601_videoram_w(&m_layers[1], vram, &space, offset, data);
+ ss9601_videoram_w(&m_layers[1], vram, &space, offset+0x1000, data); break;
- case 0x04: ss9601_videoram_w(&state->m_layers[0], vram, space, offset, data);
- ss9601_videoram_w(&state->m_layers[0], vram, space, offset+0x1000, data); break;
+ case 0x04: ss9601_videoram_w(&m_layers[0], vram, &space, offset, data);
+ ss9601_videoram_w(&m_layers[0], vram, &space, offset+0x1000, data); break;
- case 0x06: state->m_ss9601_reelrams[vram][offset] = data; break;
+ case 0x06: m_ss9601_reelrams[vram][offset] = data; break;
}
}
-static WRITE8_HANDLER( mtrain_tilesize_w )
+WRITE8_MEMBER(subsino2_state::mtrain_tilesize_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_ss9601_tilesize = data;
+ m_ss9601_tilesize = data;
tilesize_t sizes[2];
switch (data)
@@ -1089,14 +1095,14 @@ static WRITE8_HANDLER( mtrain_tilesize_w )
sizes[0] = TILE_8x8;
sizes[1] = TILE_8x8;
- logerror("%s: warning, unknown tilesize = %02x\n", space->machine().describe_context(), data);
+ logerror("%s: warning, unknown tilesize = %02x\n", machine().describe_context(), data);
popmessage("UNKNOWN TILESIZE %02X", data);
break;
}
for (int i = 0; i < 2; i++)
{
- layer_t *l = &state->m_layers[i];
+ layer_t *l = &m_layers[i];
if (l->tilesize != sizes[i])
{
@@ -1106,7 +1112,7 @@ static WRITE8_HANDLER( mtrain_tilesize_w )
}
}
-static READ8_HANDLER( mtrain_prot_r )
+READ8_MEMBER(subsino2_state::mtrain_prot_r)
{
return "SUBSION"[offset];
}
@@ -1116,28 +1122,28 @@ static ADDRESS_MAP_START( mtrain_map, AS_PROGRAM, 8, subsino2_state )
AM_RANGE( 0x07800, 0x07fff ) AM_RAM AM_SHARE("nvram") // battery
- AM_RANGE( 0x08000, 0x08fff ) AM_WRITE_LEGACY(mtrain_videoram_w )
+ AM_RANGE( 0x08000, 0x08fff ) AM_WRITE(mtrain_videoram_w )
- AM_RANGE( 0x0911f, 0x0911f ) AM_WRITE_LEGACY(ss9601_disable_w )
- AM_RANGE( 0x09120, 0x09125 ) AM_WRITE_LEGACY(ss9601_scroll_w )
+ AM_RANGE( 0x0911f, 0x0911f ) AM_WRITE(ss9601_disable_w )
+ AM_RANGE( 0x09120, 0x09125 ) AM_WRITE(ss9601_scroll_w )
- AM_RANGE( 0x0912f, 0x0912f ) AM_WRITE_LEGACY(ss9601_byte_lo_w )
+ AM_RANGE( 0x0912f, 0x0912f ) AM_WRITE(ss9601_byte_lo_w )
- AM_RANGE( 0x09140, 0x09142 ) AM_WRITE_LEGACY(mtrain_outputs_w ) AM_BASE(m_outputs )
+ AM_RANGE( 0x09140, 0x09142 ) AM_WRITE(mtrain_outputs_w ) AM_BASE(m_outputs )
AM_RANGE( 0x09143, 0x09143 ) AM_READ_PORT( "IN D" ) // (not shown in system test) 0x40 serial out, 0x80 serial in
AM_RANGE( 0x09144, 0x09144 ) AM_READ_PORT( "IN A" ) // A
AM_RANGE( 0x09145, 0x09145 ) AM_READ_PORT( "IN B" ) // B
AM_RANGE( 0x09146, 0x09146 ) AM_READ_PORT( "IN C" ) // C
- AM_RANGE( 0x09147, 0x09147 ) AM_READ_LEGACY(dsw_r )
- AM_RANGE( 0x09148, 0x09148 ) AM_WRITE_LEGACY(dsw_mask_w )
+ AM_RANGE( 0x09147, 0x09147 ) AM_READ(dsw_r )
+ AM_RANGE( 0x09148, 0x09148 ) AM_WRITE(dsw_mask_w )
- AM_RANGE( 0x09152, 0x09152 ) AM_WRITE_LEGACY(vblank_bit2_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit0_w )
+ AM_RANGE( 0x09152, 0x09152 ) AM_READ(vblank_bit2_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit0_w )
- AM_RANGE( 0x09158, 0x0915e ) AM_READ_LEGACY(mtrain_prot_r )
+ AM_RANGE( 0x09158, 0x0915e ) AM_READ(mtrain_prot_r )
- AM_RANGE( 0x09160, 0x09163 ) AM_WRITE_LEGACY(hm86171_colorram_w )
+ AM_RANGE( 0x09160, 0x09163 ) AM_WRITE(hm86171_colorram_w )
AM_RANGE( 0x09164, 0x09164 ) AM_DEVREADWRITE("oki", okim6295_device, read, write)
- AM_RANGE( 0x09168, 0x09168 ) AM_WRITE_LEGACY(mtrain_tilesize_w )
+ AM_RANGE( 0x09168, 0x09168 ) AM_WRITE(mtrain_tilesize_w )
AM_RANGE( 0x09800, 0x09fff ) AM_RAM
@@ -1152,16 +1158,15 @@ ADDRESS_MAP_END
Sakura Love - Ying Hua Lian
***************************************************************************/
-static WRITE8_HANDLER( saklove_outputs_w )
+WRITE8_MEMBER(subsino2_state::saklove_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs[offset] = data;
+ m_outputs[offset] = data;
switch (offset)
{
case 0:
- coin_counter_w(space->machine(), 0, data & 0x01 ); // coin in
- coin_counter_w(space->machine(), 1, data & 0x02 ); // key in
+ coin_counter_w(machine(), 0, data & 0x01 ); // coin in
+ coin_counter_w(machine(), 1, data & 0x02 ); // key in
break;
case 1:
@@ -1175,70 +1180,69 @@ static WRITE8_HANDLER( saklove_outputs_w )
break;
}
-// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", state->m_outputs[0], state->m_outputs[1], state->m_outputs[2], state->m_outputs[3]);
+// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", m_outputs[0], m_outputs[1], m_outputs[2], m_outputs[3]);
}
static ADDRESS_MAP_START( saklove_map, AS_PROGRAM, 8, subsino2_state )
AM_RANGE(0x00000, 0x07fff) AM_RAM AM_SHARE("nvram") // battery
// read lo (L1) (only half tilemap?)
- AM_RANGE(0x12000, 0x12fff) AM_READWRITE_LEGACY(ss9601_videoram_1_lo_r, ss9601_videoram_1_lo_w )
- AM_RANGE(0x13000, 0x131ff) AM_READWRITE_LEGACY(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w )
+ AM_RANGE(0x12000, 0x12fff) AM_READWRITE(ss9601_videoram_1_lo_r, ss9601_videoram_1_lo_w )
+ AM_RANGE(0x13000, 0x131ff) AM_READWRITE(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w )
// read lo (L0)
- AM_RANGE(0x16000, 0x16fff) AM_READWRITE_LEGACY(ss9601_videoram_0_lo_r, ss9601_videoram_0_lo_w )
- AM_RANGE(0x17000, 0x171ff) AM_READWRITE_LEGACY(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w )
+ AM_RANGE(0x16000, 0x16fff) AM_READWRITE(ss9601_videoram_0_lo_r, ss9601_videoram_0_lo_w )
+ AM_RANGE(0x17000, 0x171ff) AM_READWRITE(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w )
// read hi (L1)
- AM_RANGE(0x22000, 0x22fff) AM_READWRITE_LEGACY(ss9601_videoram_1_hi_r, ss9601_videoram_1_hi_w )
- AM_RANGE(0x23000, 0x231ff) AM_READWRITE_LEGACY(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w )
+ AM_RANGE(0x22000, 0x22fff) AM_READWRITE(ss9601_videoram_1_hi_r, ss9601_videoram_1_hi_w )
+ AM_RANGE(0x23000, 0x231ff) AM_READWRITE(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w )
// read hi (L0)
- AM_RANGE(0x26000, 0x26fff) AM_READWRITE_LEGACY(ss9601_videoram_0_hi_r, ss9601_videoram_0_hi_w )
- AM_RANGE(0x27000, 0x271ff) AM_READWRITE_LEGACY(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w )
+ AM_RANGE(0x26000, 0x26fff) AM_READWRITE(ss9601_videoram_0_hi_r, ss9601_videoram_0_hi_w )
+ AM_RANGE(0x27000, 0x271ff) AM_READWRITE(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w )
// write both (L1)
- AM_RANGE(0x30000, 0x31fff) AM_READWRITE_LEGACY(ss9601_videoram_1_hi_r, ss9601_videoram_1_hi_lo_w )
+ AM_RANGE(0x30000, 0x31fff) AM_READWRITE(ss9601_videoram_1_hi_r, ss9601_videoram_1_hi_lo_w )
// write both (L0)
- AM_RANGE(0x34000, 0x35fff) AM_READWRITE_LEGACY(ss9601_videoram_0_hi_r, ss9601_videoram_0_hi_lo_w )
+ AM_RANGE(0x34000, 0x35fff) AM_READWRITE(ss9601_videoram_0_hi_r, ss9601_videoram_0_hi_lo_w )
AM_RANGE(0xe0000, 0xfffff) AM_ROM AM_REGION("maincpu",0)
ADDRESS_MAP_END
static ADDRESS_MAP_START( saklove_io, AS_IO, 8, subsino2_state )
- AM_RANGE(0x0000, 0x0000) AM_WRITE_LEGACY(ss9601_scrollctrl_w )
+ AM_RANGE(0x0000, 0x0000) AM_WRITE(ss9601_scrollctrl_w )
AM_RANGE(0x0020, 0x0020) AM_DEVREADWRITE("oki", okim6295_device, read, write)
AM_RANGE(0x0040, 0x0041) AM_DEVWRITE_LEGACY("ymsnd", ym3812_w )
- AM_RANGE(0x0060, 0x0063) AM_WRITE_LEGACY(hm86171_colorram_w )
+ AM_RANGE(0x0060, 0x0063) AM_WRITE(hm86171_colorram_w )
- AM_RANGE(0x0080, 0x0080) AM_WRITE_LEGACY(ss9601_tilesize_w )
- AM_RANGE(0x00a0, 0x00a0) AM_WRITE_LEGACY(ss9601_byte_lo_w )
- AM_RANGE(0x021f, 0x021f) AM_WRITE_LEGACY(ss9601_disable_w )
- AM_RANGE(0x0220, 0x0225) AM_WRITE_LEGACY(ss9601_scroll_w )
+ AM_RANGE(0x0080, 0x0080) AM_WRITE(ss9601_tilesize_w )
+ AM_RANGE(0x00a0, 0x00a0) AM_WRITE(ss9601_byte_lo_w )
+ AM_RANGE(0x021f, 0x021f) AM_WRITE(ss9601_disable_w )
+ AM_RANGE(0x0220, 0x0225) AM_WRITE(ss9601_scroll_w )
- AM_RANGE(0x0300, 0x0303) AM_WRITE_LEGACY(saklove_outputs_w ) AM_BASE(m_outputs )
+ AM_RANGE(0x0300, 0x0303) AM_WRITE(saklove_outputs_w ) AM_BASE(m_outputs )
AM_RANGE(0x0303, 0x0303) AM_READ_PORT( "IN D" ) // 0x40 serial out, 0x80 serial in
AM_RANGE(0x0304, 0x0304) AM_READ_PORT( "IN A" )
AM_RANGE(0x0305, 0x0305) AM_READ_PORT( "IN B" )
AM_RANGE(0x0306, 0x0306) AM_READ_PORT( "IN C" )
- AM_RANGE(0x0307, 0x0307) AM_READ_LEGACY(dsw_r )
- AM_RANGE(0x0308, 0x0308) AM_WRITE_LEGACY(dsw_mask_w )
+ AM_RANGE(0x0307, 0x0307) AM_READ(dsw_r )
+ AM_RANGE(0x0308, 0x0308) AM_WRITE(dsw_mask_w )
- AM_RANGE(0x0312, 0x0312) AM_READ_LEGACY(vblank_bit2_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit0_w )
+ AM_RANGE(0x0312, 0x0312) AM_READ(vblank_bit2_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit0_w )
// Peripheral Control Block
- AM_RANGE(0xff00, 0xffff) AM_READWRITE_LEGACY(am188em_regs_r, am188em_regs_w ) AM_BASE(m_am188em_regs )
+ AM_RANGE(0xff00, 0xffff) AM_READWRITE(am188em_regs_r, am188em_regs_w ) AM_BASE(m_am188em_regs )
ADDRESS_MAP_END
/***************************************************************************
X-Plan
***************************************************************************/
-static WRITE8_HANDLER( xplan_outputs_w )
+WRITE8_MEMBER(subsino2_state::xplan_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs[offset] = data;
+ m_outputs[offset] = data;
switch (offset)
{
@@ -1247,58 +1251,58 @@ static WRITE8_HANDLER( xplan_outputs_w )
break;
case 1:
- set_led_status(space->machine(), 0, data & 0x02); // raise
+ set_led_status(machine(), 0, data & 0x02); // raise
break;
case 2: // B
- set_led_status(space->machine(), 1, data & 0x04); // hold 1 / big ?
- set_led_status(space->machine(), 2, data & 0x08); // hold 5 / bet
- set_led_status(space->machine(), 3, data & 0x10); // hold 4 ?
- set_led_status(space->machine(), 4, data & 0x20); // hold 2 / double up
- set_led_status(space->machine(), 5, data & 0x40); // hold 3 / small ?
+ set_led_status(machine(), 1, data & 0x04); // hold 1 / big ?
+ set_led_status(machine(), 2, data & 0x08); // hold 5 / bet
+ set_led_status(machine(), 3, data & 0x10); // hold 4 ?
+ set_led_status(machine(), 4, data & 0x20); // hold 2 / double up
+ set_led_status(machine(), 5, data & 0x40); // hold 3 / small ?
break;
case 3: // A
- coin_counter_w(space->machine(), 0, data & 0x01 );
- coin_counter_w(space->machine(), 1, data & 0x02 );
+ coin_counter_w(machine(), 0, data & 0x01 );
+ coin_counter_w(machine(), 1, data & 0x02 );
- set_led_status(space->machine(), 6, data & 0x10); // start / take
+ set_led_status(machine(), 6, data & 0x10); // start / take
break;
}
-// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", state->m_outputs[0], state->m_outputs[1], state->m_outputs[2], state->m_outputs[3]);
+// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", m_outputs[0], m_outputs[1], m_outputs[2], m_outputs[3]);
}
static ADDRESS_MAP_START( xplan_map, AS_PROGRAM, 8, subsino2_state )
AM_RANGE(0x00000, 0x07fff) AM_RAM AM_SHARE("nvram") // battery
// write both (L1, byte_lo2)
- AM_RANGE( 0x10000, 0x11fff ) AM_WRITE_LEGACY(ss9601_videoram_1_hi_lo2_w )
+ AM_RANGE( 0x10000, 0x11fff ) AM_WRITE(ss9601_videoram_1_hi_lo2_w )
// read lo (L1) (only half tilemap?)
- AM_RANGE( 0x12000, 0x12fff ) AM_READ_LEGACY(ss9601_videoram_1_lo_r )
- AM_RANGE( 0x13000, 0x131ff ) AM_READWRITE_LEGACY(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w )
+ AM_RANGE( 0x12000, 0x12fff ) AM_READ(ss9601_videoram_1_lo_r )
+ AM_RANGE( 0x13000, 0x131ff ) AM_READWRITE(ss9601_scrollram_1_lo_r, ss9601_scrollram_1_lo_w )
// write both (L0, byte_lo2)
- AM_RANGE( 0x14000, 0x15fff ) AM_WRITE_LEGACY(ss9601_videoram_0_hi_lo2_w )
+ AM_RANGE( 0x14000, 0x15fff ) AM_WRITE(ss9601_videoram_0_hi_lo2_w )
// read lo (REEL)
- AM_RANGE( 0x16000, 0x16fff ) AM_READ_LEGACY(ss9601_reelram_lo_r )
- AM_RANGE( 0x17000, 0x171ff ) AM_READWRITE_LEGACY(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w )
+ AM_RANGE( 0x16000, 0x16fff ) AM_READ(ss9601_reelram_lo_r )
+ AM_RANGE( 0x17000, 0x171ff ) AM_READWRITE(ss9601_scrollram_0_lo_r, ss9601_scrollram_0_lo_w )
// read hi (L1)
- AM_RANGE( 0x22000, 0x22fff ) AM_READ_LEGACY(ss9601_videoram_1_hi_r )
- AM_RANGE( 0x23000, 0x231ff ) AM_READWRITE_LEGACY(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w )
+ AM_RANGE( 0x22000, 0x22fff ) AM_READ(ss9601_videoram_1_hi_r )
+ AM_RANGE( 0x23000, 0x231ff ) AM_READWRITE(ss9601_scrollram_1_hi_r, ss9601_scrollram_1_hi_w )
// read hi (REEL)
- AM_RANGE( 0x26000, 0x26fff ) AM_READ_LEGACY(ss9601_reelram_hi_r )
- AM_RANGE( 0x27000, 0x271ff ) AM_READWRITE_LEGACY(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w )
+ AM_RANGE( 0x26000, 0x26fff ) AM_READ(ss9601_reelram_hi_r )
+ AM_RANGE( 0x27000, 0x271ff ) AM_READWRITE(ss9601_scrollram_0_hi_r, ss9601_scrollram_0_hi_w )
// write both (L1, byte_lo)
- AM_RANGE( 0x30000, 0x31fff ) AM_WRITE_LEGACY(ss9601_videoram_1_hi_lo_w )
- AM_RANGE( 0x32000, 0x32fff ) AM_WRITE_LEGACY(ss9601_videoram_1_hi_lo_w )
- AM_RANGE( 0x33000, 0x331ff ) AM_WRITE_LEGACY(ss9601_scrollram_1_hi_lo_w )
+ AM_RANGE( 0x30000, 0x31fff ) AM_WRITE(ss9601_videoram_1_hi_lo_w )
+ AM_RANGE( 0x32000, 0x32fff ) AM_WRITE(ss9601_videoram_1_hi_lo_w )
+ AM_RANGE( 0x33000, 0x331ff ) AM_WRITE(ss9601_scrollram_1_hi_lo_w )
// write both (L0 & REEL, byte_lo)
- AM_RANGE( 0x34000, 0x35fff ) AM_WRITE_LEGACY(ss9601_videoram_0_hi_lo_w )
- AM_RANGE( 0x36000, 0x36fff ) AM_WRITE_LEGACY(ss9601_reelram_hi_lo_w )
- AM_RANGE( 0x37000, 0x371ff ) AM_WRITE_LEGACY(ss9601_scrollram_0_hi_lo_w )
+ AM_RANGE( 0x34000, 0x35fff ) AM_WRITE(ss9601_videoram_0_hi_lo_w )
+ AM_RANGE( 0x36000, 0x36fff ) AM_WRITE(ss9601_reelram_hi_lo_w )
+ AM_RANGE( 0x37000, 0x371ff ) AM_WRITE(ss9601_scrollram_0_hi_lo_w )
AM_RANGE(0xc0000, 0xfffff) AM_ROM AM_REGION("maincpu",0)
ADDRESS_MAP_END
@@ -1306,42 +1310,41 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( xplan_io, AS_IO, 8, subsino2_state )
AM_RANGE(0x0000, 0x0000) AM_DEVREADWRITE("oki", okim6295_device, read, write)
- AM_RANGE(0x0020, 0x0020) AM_WRITE_LEGACY(ss9601_byte_lo2_w )
+ AM_RANGE(0x0020, 0x0020) AM_WRITE(ss9601_byte_lo2_w )
- AM_RANGE(0x0040, 0x0040) AM_WRITE_LEGACY(ss9601_scrollctrl_w )
+ AM_RANGE(0x0040, 0x0040) AM_WRITE(ss9601_scrollctrl_w )
- AM_RANGE(0x0060, 0x0063) AM_WRITE_LEGACY(hm86171_colorram_w )
- AM_RANGE(0x0080, 0x0080) AM_WRITE_LEGACY(ss9601_tilesize_w )
- AM_RANGE(0x00a0, 0x00a0) AM_WRITE_LEGACY(ss9601_byte_lo_w )
+ AM_RANGE(0x0060, 0x0063) AM_WRITE(hm86171_colorram_w )
+ AM_RANGE(0x0080, 0x0080) AM_WRITE(ss9601_tilesize_w )
+ AM_RANGE(0x00a0, 0x00a0) AM_WRITE(ss9601_byte_lo_w )
- AM_RANGE(0x021f, 0x021f) AM_WRITE_LEGACY(ss9601_disable_w )
- AM_RANGE(0x0220, 0x0225) AM_WRITE_LEGACY(ss9601_scroll_w )
+ AM_RANGE(0x021f, 0x021f) AM_WRITE(ss9601_disable_w )
+ AM_RANGE(0x0220, 0x0225) AM_WRITE(ss9601_scroll_w )
AM_RANGE(0x0235, 0x0235) AM_NOP // INT0 Ack.?
- AM_RANGE(0x0300, 0x0300) AM_READ_LEGACY(vblank_bit6_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit4_w )
- AM_RANGE(0x0301, 0x0301) AM_WRITE_LEGACY(dsw_mask_w )
- AM_RANGE(0x0302, 0x0302) AM_READ_LEGACY(dsw_r )
+ AM_RANGE(0x0300, 0x0300) AM_READ(vblank_bit6_r ) AM_DEVWRITE_LEGACY("oki", oki_bank_bit4_w )
+ AM_RANGE(0x0301, 0x0301) AM_WRITE(dsw_mask_w )
+ AM_RANGE(0x0302, 0x0302) AM_READ(dsw_r )
AM_RANGE(0x0303, 0x0303) AM_READ_PORT( "IN C" )
AM_RANGE(0x0304, 0x0304) AM_READ_PORT( "IN B" )
AM_RANGE(0x0305, 0x0305) AM_READ_PORT( "IN A" )
AM_RANGE(0x0306, 0x0306) AM_READ_PORT( "IN D" ) // 0x40 serial out, 0x80 serial in
// 306 = d, 307 = c, 308 = b, 309 = a
- AM_RANGE(0x0306, 0x0309) AM_WRITE_LEGACY(xplan_outputs_w ) AM_BASE(m_outputs )
+ AM_RANGE(0x0306, 0x0309) AM_WRITE(xplan_outputs_w ) AM_BASE(m_outputs )
// Peripheral Control Block
- AM_RANGE(0xff00, 0xffff) AM_READWRITE_LEGACY(am188em_regs_r, am188em_regs_w ) AM_BASE(m_am188em_regs )
+ AM_RANGE(0xff00, 0xffff) AM_READWRITE(am188em_regs_r, am188em_regs_w ) AM_BASE(m_am188em_regs )
ADDRESS_MAP_END
/***************************************************************************
X-Train
***************************************************************************/
-static WRITE8_HANDLER( xtrain_outputs_w )
+WRITE8_MEMBER(subsino2_state::xtrain_outputs_w)
{
- subsino2_state *state = space->machine().driver_data<subsino2_state>();
- state->m_outputs[offset] = data;
+ m_outputs[offset] = data;
switch (offset)
{
@@ -1350,39 +1353,39 @@ static WRITE8_HANDLER( xtrain_outputs_w )
break;
case 1: // C
- set_led_status(space->machine(), 0, data & 0x02); // re-double
- set_led_status(space->machine(), 1, data & 0x04); // half double
+ set_led_status(machine(), 0, data & 0x02); // re-double
+ set_led_status(machine(), 1, data & 0x04); // half double
break;
case 2: // B
- set_led_status(space->machine(), 2, data & 0x02); // hold 3 / small
- set_led_status(space->machine(), 3, data & 0x04); // hold 2 / big
- set_led_status(space->machine(), 4, data & 0x08); // bet
- set_led_status(space->machine(), 5, data & 0x10); // hold1 / take
- set_led_status(space->machine(), 6, data & 0x20); // double up
+ set_led_status(machine(), 2, data & 0x02); // hold 3 / small
+ set_led_status(machine(), 3, data & 0x04); // hold 2 / big
+ set_led_status(machine(), 4, data & 0x08); // bet
+ set_led_status(machine(), 5, data & 0x10); // hold1 / take
+ set_led_status(machine(), 6, data & 0x20); // double up
break;
case 3: // A
- coin_counter_w(space->machine(), 0, data & 0x01 ); // coin in
- coin_counter_w(space->machine(), 1, data & 0x02 ); // key in
+ coin_counter_w(machine(), 0, data & 0x01 ); // coin in
+ coin_counter_w(machine(), 1, data & 0x02 ); // key in
- set_led_status(space->machine(), 7, data & 0x10); // start
+ set_led_status(machine(), 7, data & 0x10); // start
break;
}
-// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", state->m_outputs[0], state->m_outputs[1], state->m_outputs[2], state->m_outputs[3]);
+// popmessage("0: %02x - 1: %02x - 2: %02x - 3: %02x", m_outputs[0], m_outputs[1], m_outputs[2], m_outputs[3]);
}
static ADDRESS_MAP_START( expcard_io, AS_IO, 8, subsino2_state )
// 306 = d, 307 = c, 308 = b, 309 = a
- AM_RANGE(0x0306, 0x0309) AM_WRITE_LEGACY(expcard_outputs_w ) AM_BASE(m_outputs )
+ AM_RANGE(0x0306, 0x0309) AM_WRITE(expcard_outputs_w ) AM_BASE(m_outputs )
AM_IMPORT_FROM( xplan_io )
ADDRESS_MAP_END
static ADDRESS_MAP_START( xtrain_io, AS_IO, 8, subsino2_state )
// 306 = d, 307 = c, 308 = b, 309 = a
- AM_RANGE(0x0306, 0x0309) AM_WRITE_LEGACY(xtrain_outputs_w ) AM_BASE(m_outputs )
+ AM_RANGE(0x0306, 0x0309) AM_WRITE(xtrain_outputs_w ) AM_BASE(m_outputs )
AM_IMPORT_FROM( xplan_io )
ADDRESS_MAP_END
diff --git a/src/mame/drivers/supertnk.c b/src/mame/drivers/supertnk.c
index 8ebb034e823..06cf53b217f 100644
--- a/src/mame/drivers/supertnk.c
+++ b/src/mame/drivers/supertnk.c
@@ -115,6 +115,13 @@ public:
UINT8 m_rom_bank;
UINT8 m_bitplane_select;
pen_t m_pens[NUM_PENS];
+ DECLARE_WRITE8_MEMBER(supertnk_bankswitch_0_w);
+ DECLARE_WRITE8_MEMBER(supertnk_bankswitch_1_w);
+ DECLARE_WRITE8_MEMBER(supertnk_interrupt_ack_w);
+ DECLARE_WRITE8_MEMBER(supertnk_videoram_w);
+ DECLARE_READ8_MEMBER(supertnk_videoram_r);
+ DECLARE_WRITE8_MEMBER(supertnk_bitplane_select_0_w);
+ DECLARE_WRITE8_MEMBER(supertnk_bitplane_select_1_w);
};
@@ -125,29 +132,27 @@ public:
*
*************************************/
-static WRITE8_HANDLER( supertnk_bankswitch_0_w )
+WRITE8_MEMBER(supertnk_state::supertnk_bankswitch_0_w)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
offs_t bank_address;
- state->m_rom_bank = (state->m_rom_bank & 0x02) | ((data << 0) & 0x01);
+ m_rom_bank = (m_rom_bank & 0x02) | ((data << 0) & 0x01);
- bank_address = 0x10000 + (state->m_rom_bank * 0x1000);
+ bank_address = 0x10000 + (m_rom_bank * 0x1000);
- memory_set_bankptr(space->machine(), "bank1", &space->machine().region("maincpu")->base()[bank_address]);
+ memory_set_bankptr(machine(), "bank1", &machine().region("maincpu")->base()[bank_address]);
}
-static WRITE8_HANDLER( supertnk_bankswitch_1_w )
+WRITE8_MEMBER(supertnk_state::supertnk_bankswitch_1_w)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
offs_t bank_address;
- state->m_rom_bank = (state->m_rom_bank & 0x01) | ((data << 1) & 0x02);
+ m_rom_bank = (m_rom_bank & 0x01) | ((data << 1) & 0x02);
- bank_address = 0x10000 + (state->m_rom_bank * 0x1000);
+ bank_address = 0x10000 + (m_rom_bank * 0x1000);
- memory_set_bankptr(space->machine(), "bank1", &space->machine().region("maincpu")->base()[bank_address]);
+ memory_set_bankptr(machine(), "bank1", &machine().region("maincpu")->base()[bank_address]);
}
@@ -165,9 +170,9 @@ static INTERRUPT_GEN( supertnk_interrupt )
}
-static WRITE8_HANDLER( supertnk_interrupt_ack_w )
+WRITE8_MEMBER(supertnk_state::supertnk_interrupt_ack_w)
{
- cputag_set_input_line(space->machine(), "maincpu", 0, CLEAR_LINE);
+ cputag_set_input_line(machine(), "maincpu", 0, CLEAR_LINE);
}
@@ -197,48 +202,44 @@ static VIDEO_START( supertnk )
}
-static WRITE8_HANDLER( supertnk_videoram_w )
+WRITE8_MEMBER(supertnk_state::supertnk_videoram_w)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
- if (state->m_bitplane_select > 2)
+ if (m_bitplane_select > 2)
{
- state->m_videoram[0][offset] = 0;
- state->m_videoram[1][offset] = 0;
- state->m_videoram[2][offset] = 0;
+ m_videoram[0][offset] = 0;
+ m_videoram[1][offset] = 0;
+ m_videoram[2][offset] = 0;
}
else
{
- state->m_videoram[state->m_bitplane_select][offset] = data;
+ m_videoram[m_bitplane_select][offset] = data;
}
}
-static READ8_HANDLER( supertnk_videoram_r )
+READ8_MEMBER(supertnk_state::supertnk_videoram_r)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
UINT8 ret = 0x00;
- if (state->m_bitplane_select < 3)
- ret = state->m_videoram[state->m_bitplane_select][offset];
+ if (m_bitplane_select < 3)
+ ret = m_videoram[m_bitplane_select][offset];
return ret;
}
-static WRITE8_HANDLER( supertnk_bitplane_select_0_w )
+WRITE8_MEMBER(supertnk_state::supertnk_bitplane_select_0_w)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
- state->m_bitplane_select = (state->m_bitplane_select & 0x02) | ((data << 0) & 0x01);
+ m_bitplane_select = (m_bitplane_select & 0x02) | ((data << 0) & 0x01);
}
-static WRITE8_HANDLER( supertnk_bitplane_select_1_w )
+WRITE8_MEMBER(supertnk_state::supertnk_bitplane_select_1_w)
{
- supertnk_state *state = space->machine().driver_data<supertnk_state>();
- state->m_bitplane_select = (state->m_bitplane_select & 0x01) | ((data << 1) & 0x02);
+ m_bitplane_select = (m_bitplane_select & 0x01) | ((data << 1) & 0x02);
}
@@ -284,12 +285,13 @@ static SCREEN_UPDATE_RGB32( supertnk )
static MACHINE_RESET( supertnk )
{
+ supertnk_state *state = machine.driver_data<supertnk_state>();
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
- supertnk_bankswitch_0_w(space, 0, 0);
- supertnk_bankswitch_1_w(space, 0, 0);
+ state->supertnk_bankswitch_0_w(*space, 0, 0);
+ state->supertnk_bankswitch_1_w(*space, 0, 0);
- supertnk_bitplane_select_0_w(space, 0, 0);
- supertnk_bitplane_select_1_w(space, 0, 0);
+ state->supertnk_bitplane_select_0_w(*space, 0, 0);
+ state->supertnk_bitplane_select_1_w(*space, 0, 0);
}
@@ -309,7 +311,7 @@ static ADDRESS_MAP_START( supertnk_map, AS_PROGRAM, 8, supertnk_state )
AM_RANGE(0x1efe, 0x1eff) AM_DEVWRITE_LEGACY("aysnd", ay8910_address_data_w)
AM_RANGE(0x1efe, 0x1efe) AM_READ_PORT("DSW")
AM_RANGE(0x1eff, 0x1eff) AM_READ_PORT("UNK")
- AM_RANGE(0x2000, 0x3fff) AM_READWRITE_LEGACY(supertnk_videoram_r, supertnk_videoram_w)
+ AM_RANGE(0x2000, 0x3fff) AM_READWRITE(supertnk_videoram_r, supertnk_videoram_w)
ADDRESS_MAP_END
@@ -322,11 +324,11 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( supertnk_io_map, AS_IO, 8, supertnk_state )
AM_RANGE(0x0000, 0x0000) AM_WRITENOP
- AM_RANGE(0x0400, 0x0400) AM_WRITE_LEGACY(supertnk_bitplane_select_0_w)
- AM_RANGE(0x0401, 0x0401) AM_WRITE_LEGACY(supertnk_bitplane_select_1_w)
- AM_RANGE(0x0402, 0x0402) AM_WRITE_LEGACY(supertnk_bankswitch_0_w)
- AM_RANGE(0x0404, 0x0404) AM_WRITE_LEGACY(supertnk_bankswitch_1_w)
- AM_RANGE(0x0406, 0x0406) AM_WRITE_LEGACY(supertnk_interrupt_ack_w)
+ AM_RANGE(0x0400, 0x0400) AM_WRITE(supertnk_bitplane_select_0_w)
+ AM_RANGE(0x0401, 0x0401) AM_WRITE(supertnk_bitplane_select_1_w)
+ AM_RANGE(0x0402, 0x0402) AM_WRITE(supertnk_bankswitch_0_w)
+ AM_RANGE(0x0404, 0x0404) AM_WRITE(supertnk_bankswitch_1_w)
+ AM_RANGE(0x0406, 0x0406) AM_WRITE(supertnk_interrupt_ack_w)
AM_RANGE(0x0407, 0x0407) AM_WRITE_LEGACY(watchdog_reset_w)
ADDRESS_MAP_END
diff --git a/src/mame/drivers/tmspoker.c b/src/mame/drivers/tmspoker.c
index 3286f527e3a..304c21bee12 100644
--- a/src/mame/drivers/tmspoker.c
+++ b/src/mame/drivers/tmspoker.c
@@ -222,6 +222,9 @@ public:
UINT8 *m_videoram;
tilemap_t *m_bg_tilemap;
+ DECLARE_WRITE8_MEMBER(tmspoker_videoram_w);
+ //DECLARE_WRITE8_MEMBER(debug_w);
+ DECLARE_READ8_MEMBER(unk_r);
};
@@ -229,11 +232,10 @@ public:
* Video Hardware *
*************************/
-static WRITE8_HANDLER( tmspoker_videoram_w )
+WRITE8_MEMBER(tmspoker_state::tmspoker_videoram_w)
{
- tmspoker_state *state = space->machine().driver_data<tmspoker_state>();
- state->m_videoram[offset] = data;
- state->m_bg_tilemap->mark_tile_dirty(offset);
+ m_videoram[offset] = data;
+ m_bg_tilemap->mark_tile_dirty(offset);
}
@@ -273,7 +275,7 @@ static PALETTE_INIT( tmspoker )
* Read / Write Handlers *
**************************/
-//static WRITE8_HANDLER( debug_w )
+//WRITE8_MEMBER(tmspoker_state::debug_w)
//{
// popmessage("written : %02X", data);
//}
@@ -314,20 +316,20 @@ static ADDRESS_MAP_START( tmspoker_map, AS_PROGRAM, 8, tmspoker_state )
AM_RANGE(0x0000, 0x0fff) AM_ROMBANK("bank1")
AM_RANGE(0x2800, 0x2800) AM_DEVWRITE("crtc", mc6845_device, address_w)
AM_RANGE(0x2801, 0x2801) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
- AM_RANGE(0x3000, 0x33ff) AM_WRITE_LEGACY(tmspoker_videoram_w) AM_BASE(m_videoram)
+ AM_RANGE(0x3000, 0x33ff) AM_WRITE(tmspoker_videoram_w) AM_BASE(m_videoram)
AM_RANGE(0x3800, 0x3fff) AM_RAM //NVRAM?
AM_RANGE(0x2000, 0x20ff) AM_RAM //color RAM?
ADDRESS_MAP_END
-static READ8_HANDLER(unk_r)
+READ8_MEMBER(tmspoker_state::unk_r)
{
printf("%x\n",offset);
- return 0;//0xff;//mame_rand(space->machine);
+ return 0;//0xff;//mame_rand(machine);
}
static ADDRESS_MAP_START( tmspoker_cru_map, AS_IO, 8, tmspoker_state )
- AM_RANGE(0x0000, 0xffff) AM_READ_LEGACY(unk_r)
+ AM_RANGE(0x0000, 0xffff) AM_READ(unk_r)
ADDRESS_MAP_END
/* I/O byte R/W
diff --git a/src/mame/drivers/umipoker.c b/src/mame/drivers/umipoker.c
index 5173613a8b9..f9bead3cf54 100644
--- a/src/mame/drivers/umipoker.c
+++ b/src/mame/drivers/umipoker.c
@@ -38,6 +38,21 @@ public:
tilemap_t *m_tilemap_3;
UINT8 *m_z80_wram;
int m_umipoker_scrolly[4];
+ DECLARE_READ8_MEMBER(z80_rom_readback_r);
+ DECLARE_READ8_MEMBER(z80_shared_ram_r);
+ DECLARE_WRITE8_MEMBER(z80_shared_ram_w);
+ DECLARE_WRITE16_MEMBER(umipoker_irq_ack_w);
+ DECLARE_WRITE16_MEMBER(umipoker_scrolly_0_w);
+ DECLARE_WRITE16_MEMBER(umipoker_scrolly_1_w);
+ DECLARE_WRITE16_MEMBER(umipoker_scrolly_2_w);
+ DECLARE_WRITE16_MEMBER(umipoker_scrolly_3_w);
+ DECLARE_WRITE16_MEMBER(umipoker_vram_0_w);
+ DECLARE_WRITE16_MEMBER(umipoker_vram_1_w);
+ DECLARE_WRITE16_MEMBER(umipoker_vram_2_w);
+ DECLARE_WRITE16_MEMBER(umipoker_vram_3_w);
+ DECLARE_WRITE16_MEMBER(lamps_w);
+ DECLARE_WRITE16_MEMBER(umi_counters_w);
+ DECLARE_WRITE16_MEMBER(saiyu_counters_w);
};
static TILE_GET_INFO( get_tile_info_0 )
@@ -127,79 +142,73 @@ static SCREEN_UPDATE_IND16( umipoker )
return 0;
}
-static READ8_HANDLER( z80_rom_readback_r )
+READ8_MEMBER(umipoker_state::z80_rom_readback_r)
{
- UINT8 *ROM = space->machine().region("audiocpu")->base();
+ UINT8 *ROM = machine().region("audiocpu")->base();
return ROM[offset];
}
-static READ8_HANDLER( z80_shared_ram_r )
+READ8_MEMBER(umipoker_state::z80_shared_ram_r)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- space->machine().scheduler().synchronize(); // force resync
+ machine().scheduler().synchronize(); // force resync
- return state->m_z80_wram[offset];
+ return m_z80_wram[offset];
}
-static WRITE8_HANDLER( z80_shared_ram_w )
+WRITE8_MEMBER(umipoker_state::z80_shared_ram_w)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- space->machine().scheduler().synchronize(); // force resync
+ machine().scheduler().synchronize(); // force resync
- state->m_z80_wram[offset] = data;
+ m_z80_wram[offset] = data;
}
-static WRITE16_HANDLER( umipoker_irq_ack_w )
+WRITE16_MEMBER(umipoker_state::umipoker_irq_ack_w)
{
- cputag_set_input_line(space->machine(), "maincpu", 6, CLEAR_LINE);
+ cputag_set_input_line(machine(), "maincpu", 6, CLEAR_LINE);
/* shouldn't happen */
if(data)
popmessage("%04x IRQ ACK, contact MAMEdev",data);
}
-static WRITE16_HANDLER( umipoker_scrolly_0_w ) { umipoker_state *state = space->machine().driver_data<umipoker_state>(); COMBINE_DATA(&state->m_umipoker_scrolly[0]); }
-static WRITE16_HANDLER( umipoker_scrolly_1_w ) { umipoker_state *state = space->machine().driver_data<umipoker_state>(); COMBINE_DATA(&state->m_umipoker_scrolly[1]); }
-static WRITE16_HANDLER( umipoker_scrolly_2_w ) { umipoker_state *state = space->machine().driver_data<umipoker_state>(); COMBINE_DATA(&state->m_umipoker_scrolly[2]); }
-static WRITE16_HANDLER( umipoker_scrolly_3_w ) { umipoker_state *state = space->machine().driver_data<umipoker_state>(); COMBINE_DATA(&state->m_umipoker_scrolly[3]); }
+WRITE16_MEMBER(umipoker_state::umipoker_scrolly_0_w){ COMBINE_DATA(&m_umipoker_scrolly[0]); }
+WRITE16_MEMBER(umipoker_state::umipoker_scrolly_1_w){ COMBINE_DATA(&m_umipoker_scrolly[1]); }
+WRITE16_MEMBER(umipoker_state::umipoker_scrolly_2_w){ COMBINE_DATA(&m_umipoker_scrolly[2]); }
+WRITE16_MEMBER(umipoker_state::umipoker_scrolly_3_w){ COMBINE_DATA(&m_umipoker_scrolly[3]); }
-static WRITE16_HANDLER( umipoker_vram_0_w )
+WRITE16_MEMBER(umipoker_state::umipoker_vram_0_w)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- COMBINE_DATA(&state->m_vram_0[offset]);
- state->m_tilemap_0->mark_tile_dirty(offset >> 1);
+ COMBINE_DATA(&m_vram_0[offset]);
+ m_tilemap_0->mark_tile_dirty(offset >> 1);
}
-static WRITE16_HANDLER( umipoker_vram_1_w )
+WRITE16_MEMBER(umipoker_state::umipoker_vram_1_w)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- COMBINE_DATA(&state->m_vram_1[offset]);
- state->m_tilemap_1->mark_tile_dirty(offset >> 1);
+ COMBINE_DATA(&m_vram_1[offset]);
+ m_tilemap_1->mark_tile_dirty(offset >> 1);
}
-static WRITE16_HANDLER( umipoker_vram_2_w )
+WRITE16_MEMBER(umipoker_state::umipoker_vram_2_w)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- COMBINE_DATA(&state->m_vram_2[offset]);
- state->m_tilemap_2->mark_tile_dirty(offset >> 1);
+ COMBINE_DATA(&m_vram_2[offset]);
+ m_tilemap_2->mark_tile_dirty(offset >> 1);
}
-static WRITE16_HANDLER( umipoker_vram_3_w )
+WRITE16_MEMBER(umipoker_state::umipoker_vram_3_w)
{
- umipoker_state *state = space->machine().driver_data<umipoker_state>();
- COMBINE_DATA(&state->m_vram_3[offset]);
- state->m_tilemap_3->mark_tile_dirty(offset >> 1);
+ COMBINE_DATA(&m_vram_3[offset]);
+ m_tilemap_3->mark_tile_dirty(offset >> 1);
}
-static WRITE16_HANDLER( lamps_w )
+WRITE16_MEMBER(umipoker_state::lamps_w)
{
/*
Umipoker buttons layout:
@@ -248,7 +257,7 @@ static WRITE16_HANDLER( lamps_w )
output_set_lamp_value(5, (data >> 13) & 1); /* Lamp 5 - START */
}
-static WRITE16_HANDLER( umi_counters_w )
+WRITE16_MEMBER(umipoker_state::umi_counters_w)
{/*
0x0000 - Normal State (lamps off).
0x0001 - Payout pulse.
@@ -264,12 +273,12 @@ static WRITE16_HANDLER( umi_counters_w )
xxxx xxxx x--x xxx- Unknown / Not used.
*/
- coin_counter_w(space->machine(), 0, data & 0x20); /* COIN 1 */
- coin_counter_w(space->machine(), 1, data & 0x40); /* COIN 2 */
- coin_counter_w(space->machine(), 2, data & 0x01); /* PAYOUT */
+ coin_counter_w(machine(), 0, data & 0x20); /* COIN 1 */
+ coin_counter_w(machine(), 1, data & 0x40); /* COIN 2 */
+ coin_counter_w(machine(), 2, data & 0x01); /* PAYOUT */
}
-static WRITE16_HANDLER( saiyu_counters_w )
+WRITE16_MEMBER(umipoker_state::saiyu_counters_w)
{
/*
0x0000 - Normal State (lamps off).
@@ -286,9 +295,9 @@ static WRITE16_HANDLER( saiyu_counters_w )
x--x xxx- xxxx xxxx Unknown / Not used.
*/
- coin_counter_w(space->machine(), 0, data & 0x2000); /* COIN 1 */
- coin_counter_w(space->machine(), 1, data & 0x4000); /* COIN 2 */
- coin_counter_w(space->machine(), 2, data & 0x0100); /* PAYOUT */
+ coin_counter_w(machine(), 0, data & 0x2000); /* COIN 1 */
+ coin_counter_w(machine(), 1, data & 0x4000); /* COIN 2 */
+ coin_counter_w(machine(), 2, data & 0x0100); /* PAYOUT */
}
@@ -297,30 +306,30 @@ static ADDRESS_MAP_START( umipoker_map, AS_PROGRAM, 16, umipoker_state )
AM_RANGE(0x000000, 0x03ffff) AM_ROM
AM_RANGE(0x400000, 0x403fff) AM_RAM AM_SHARE("nvram")
AM_RANGE(0x600000, 0x6007ff) AM_RAM_WRITE_LEGACY(paletteram16_xRRRRRGGGGGBBBBB_word_w) AM_BASE_GENERIC(paletteram) // Palette
- AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE_LEGACY(umipoker_vram_0_w) AM_BASE(m_vram_0)
- AM_RANGE(0x802000, 0x803fff) AM_RAM_WRITE_LEGACY(umipoker_vram_1_w) AM_BASE(m_vram_1)
- AM_RANGE(0x804000, 0x805fff) AM_RAM_WRITE_LEGACY(umipoker_vram_2_w) AM_BASE(m_vram_2)
- AM_RANGE(0x806000, 0x807fff) AM_RAM_WRITE_LEGACY(umipoker_vram_3_w) AM_BASE(m_vram_3)
- AM_RANGE(0xc00000, 0xc0ffff) AM_READ8_LEGACY(z80_rom_readback_r,0x00ff)
- AM_RANGE(0xc1f000, 0xc1ffff) AM_READWRITE8_LEGACY(z80_shared_ram_r,z80_shared_ram_w,0x00ff)
+ AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(umipoker_vram_0_w) AM_BASE(m_vram_0)
+ AM_RANGE(0x802000, 0x803fff) AM_RAM_WRITE(umipoker_vram_1_w) AM_BASE(m_vram_1)
+ AM_RANGE(0x804000, 0x805fff) AM_RAM_WRITE(umipoker_vram_2_w) AM_BASE(m_vram_2)
+ AM_RANGE(0x806000, 0x807fff) AM_RAM_WRITE(umipoker_vram_3_w) AM_BASE(m_vram_3)
+ AM_RANGE(0xc00000, 0xc0ffff) AM_READ8(z80_rom_readback_r,0x00ff)
+ AM_RANGE(0xc1f000, 0xc1ffff) AM_READWRITE8(z80_shared_ram_r,z80_shared_ram_w,0x00ff)
AM_RANGE(0xe00000, 0xe00001) AM_READ_PORT("IN0")
AM_RANGE(0xe00004, 0xe00005) AM_READ_PORT("IN1") // unused?
AM_RANGE(0xe00008, 0xe00009) AM_READ_PORT("IN2")
-// AM_RANGE(0xe0000c, 0xe0000d) AM_WRITE_LEGACY(lamps_w) -----> lamps only for saiyukip.
+// AM_RANGE(0xe0000c, 0xe0000d) AM_WRITE(lamps_w) -----> lamps only for saiyukip.
// AM_RANGE(0xe00010, 0xe00011) AM_WRITE_LEGACY(counters_w) --> coin counters for both games.
AM_RANGE(0xe00014, 0xe00015) AM_READ_PORT("DSW1-2")
AM_RANGE(0xe00018, 0xe00019) AM_READ_PORT("DSW3-4")
- AM_RANGE(0xe00020, 0xe00021) AM_WRITE_LEGACY(umipoker_scrolly_0_w)
- AM_RANGE(0xe00022, 0xe00023) AM_WRITE_LEGACY(umipoker_irq_ack_w)
- AM_RANGE(0xe00026, 0xe00027) AM_WRITE_LEGACY(umipoker_scrolly_2_w)
- AM_RANGE(0xe0002a, 0xe0002b) AM_WRITE_LEGACY(umipoker_scrolly_1_w)
+ AM_RANGE(0xe00020, 0xe00021) AM_WRITE(umipoker_scrolly_0_w)
+ AM_RANGE(0xe00022, 0xe00023) AM_WRITE(umipoker_irq_ack_w)
+ AM_RANGE(0xe00026, 0xe00027) AM_WRITE(umipoker_scrolly_2_w)
+ AM_RANGE(0xe0002a, 0xe0002b) AM_WRITE(umipoker_scrolly_1_w)
AM_RANGE(0xe0002c, 0xe0002d) AM_WRITENOP // unknown meaning, bit 0 goes from 0 -> 1 on IRQ service routine
- AM_RANGE(0xe0002e, 0xe0002f) AM_WRITE_LEGACY(umipoker_scrolly_3_w)
+ AM_RANGE(0xe0002e, 0xe0002f) AM_WRITE(umipoker_scrolly_3_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( umipoker_audio_map, AS_PROGRAM, 8, umipoker_state )
AM_RANGE(0x0000, 0x7fff) AM_ROM
- AM_RANGE(0xf800, 0xffff) AM_READWRITE_LEGACY(z80_shared_ram_r,z80_shared_ram_w) AM_BASE(m_z80_wram)
+ AM_RANGE(0xf800, 0xffff) AM_READWRITE(z80_shared_ram_r,z80_shared_ram_w) AM_BASE(m_z80_wram)
ADDRESS_MAP_END
static ADDRESS_MAP_START( umipoker_audio_io_map, AS_IO, 8, umipoker_state )
@@ -734,13 +743,15 @@ ROM_END
static DRIVER_INIT( umipoker )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe00010, 0xe00011, FUNC(umi_counters_w) );
+ umipoker_state *state = machine.driver_data<umipoker_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0xe00010, 0xe00011, write16_delegate(FUNC(umipoker_state::umi_counters_w), state));
}
static DRIVER_INIT( saiyukip )
{
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe00010, 0xe00011, FUNC(saiyu_counters_w) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe0000c, 0xe0000d, FUNC(lamps_w) );
+ umipoker_state *state = machine.driver_data<umipoker_state>();
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0xe00010, 0xe00011, write16_delegate(FUNC(umipoker_state::saiyu_counters_w), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0xe0000c, 0xe0000d, write16_delegate(FUNC(umipoker_state::lamps_w), state));
}
diff --git a/src/mame/drivers/vamphalf.c b/src/mame/drivers/vamphalf.c
index 9fde6131b27..99f0abf9cc5 100644
--- a/src/mame/drivers/vamphalf.c
+++ b/src/mame/drivers/vamphalf.c
@@ -83,6 +83,39 @@ public:
UINT16 m_finalgdr_backupram_bank;
UINT8 *m_finalgdr_backupram;
int m_has_extra_gfx;
+ DECLARE_WRITE16_MEMBER(flipscreen_w);
+ DECLARE_WRITE32_MEMBER(flipscreen32_w);
+ DECLARE_WRITE16_MEMBER(jmpbreak_flipscreen_w);
+ DECLARE_WRITE32_MEMBER(paletteram32_w);
+ DECLARE_READ32_MEMBER(wyvernwg_prot_r);
+ DECLARE_WRITE32_MEMBER(wyvernwg_prot_w);
+ DECLARE_READ32_MEMBER(finalgdr_prot_r);
+ DECLARE_WRITE32_MEMBER(finalgdr_prot_w);
+ DECLARE_WRITE32_MEMBER(finalgdr_backupram_bank_w);
+ DECLARE_READ32_MEMBER(finalgdr_backupram_r);
+ DECLARE_WRITE32_MEMBER(finalgdr_backupram_w);
+ DECLARE_WRITE32_MEMBER(finalgdr_prize_w);
+ DECLARE_WRITE16_MEMBER(boonggab_prize_w);
+ DECLARE_WRITE16_MEMBER(boonggab_lamps_w);
+ DECLARE_READ16_MEMBER(vamphalf_speedup_r);
+ DECLARE_READ16_MEMBER(vamphafk_speedup_r);
+ DECLARE_READ16_MEMBER(misncrft_speedup_r);
+ DECLARE_READ16_MEMBER(coolmini_speedup_r);
+ DECLARE_READ16_MEMBER(suplup_speedup_r);
+ DECLARE_READ16_MEMBER(luplup_speedup_r);
+ DECLARE_READ16_MEMBER(luplup29_speedup_r);
+ DECLARE_READ16_MEMBER(puzlbang_speedup_r);
+ DECLARE_READ32_MEMBER(wyvernwg_speedup_r);
+ DECLARE_READ32_MEMBER(wyvernwga_speedup_r);
+ DECLARE_READ32_MEMBER(finalgdr_speedup_r);
+ DECLARE_READ32_MEMBER(mrkicker_speedup_r);
+ DECLARE_READ16_MEMBER(dquizgo2_speedup_r);
+ DECLARE_READ32_MEMBER(aoh_speedup_r);
+ DECLARE_READ16_MEMBER(jmpbreak_speedup_r);
+ DECLARE_READ16_MEMBER(mrdig_speedup_r);
+ DECLARE_READ16_MEMBER(dtfamily_speedup_r);
+ DECLARE_READ16_MEMBER(toyland_speedup_r);
+ DECLARE_READ16_MEMBER(boonggab_speedup_r);
};
static READ16_DEVICE_HANDLER( eeprom_r )
@@ -131,65 +164,58 @@ static WRITE32_DEVICE_HANDLER( finalgdr_eeprom_w )
eeprom->set_clock_line((data & 0x2000) ? ASSERT_LINE : CLEAR_LINE );
}
-static WRITE16_HANDLER( flipscreen_w )
+WRITE16_MEMBER(vamphalf_state::flipscreen_w)
{
if(offset)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_flipscreen = data & state->m_flip_bit;
+ m_flipscreen = data & m_flip_bit;
}
}
-static WRITE32_HANDLER( flipscreen32_w )
+WRITE32_MEMBER(vamphalf_state::flipscreen32_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_flipscreen = data & state->m_flip_bit;
+ m_flipscreen = data & m_flip_bit;
}
-static WRITE16_HANDLER( jmpbreak_flipscreen_w )
+WRITE16_MEMBER(vamphalf_state::jmpbreak_flipscreen_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_flipscreen = data & 0x8000;
+ m_flipscreen = data & 0x8000;
}
-static WRITE32_HANDLER( paletteram32_w )
+WRITE32_MEMBER(vamphalf_state::paletteram32_w)
{
UINT16 paldata;
- COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
+ COMBINE_DATA(&machine().generic.paletteram.u32[offset]);
- paldata = space->machine().generic.paletteram.u32[offset] & 0xffff;
- palette_set_color_rgb(space->machine(), offset*2 + 1, pal5bit(paldata >> 10), pal5bit(paldata >> 5), pal5bit(paldata >> 0));
+ paldata = machine().generic.paletteram.u32[offset] & 0xffff;
+ palette_set_color_rgb(machine(), offset*2 + 1, pal5bit(paldata >> 10), pal5bit(paldata >> 5), pal5bit(paldata >> 0));
- paldata = (space->machine().generic.paletteram.u32[offset] >> 16) & 0xffff;
- palette_set_color_rgb(space->machine(), offset*2 + 0, pal5bit(paldata >> 10), pal5bit(paldata >> 5), pal5bit(paldata >> 0));
+ paldata = (machine().generic.paletteram.u32[offset] >> 16) & 0xffff;
+ palette_set_color_rgb(machine(), offset*2 + 0, pal5bit(paldata >> 10), pal5bit(paldata >> 5), pal5bit(paldata >> 0));
}
-static READ32_HANDLER( wyvernwg_prot_r )
+READ32_MEMBER(vamphalf_state::wyvernwg_prot_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_semicom_prot_idx--;
- return (state->m_semicom_prot_data[state->m_semicom_prot_which] & (1 << state->m_semicom_prot_idx)) >> state->m_semicom_prot_idx;
+ m_semicom_prot_idx--;
+ return (m_semicom_prot_data[m_semicom_prot_which] & (1 << m_semicom_prot_idx)) >> m_semicom_prot_idx;
}
-static WRITE32_HANDLER( wyvernwg_prot_w )
+WRITE32_MEMBER(vamphalf_state::wyvernwg_prot_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_semicom_prot_which = data & 1;
- state->m_semicom_prot_idx = 8;
+ m_semicom_prot_which = data & 1;
+ m_semicom_prot_idx = 8;
}
-static READ32_HANDLER( finalgdr_prot_r )
+READ32_MEMBER(vamphalf_state::finalgdr_prot_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_semicom_prot_idx--;
- return (state->m_semicom_prot_data[state->m_semicom_prot_which] & (1 << state->m_semicom_prot_idx)) ? 0x8000 : 0;
+ m_semicom_prot_idx--;
+ return (m_semicom_prot_data[m_semicom_prot_which] & (1 << m_semicom_prot_idx)) ? 0x8000 : 0;
}
-static WRITE32_HANDLER( finalgdr_prot_w )
+WRITE32_MEMBER(vamphalf_state::finalgdr_prot_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
/*
41C6
967E
@@ -197,11 +223,11 @@ static WRITE32_HANDLER( finalgdr_prot_w )
F94B
*/
if(data == 0x41c6 || data == 0x446b)
- state->m_semicom_prot_which = 0;
+ m_semicom_prot_which = 0;
else
- state->m_semicom_prot_which = 1;
+ m_semicom_prot_which = 1;
- state->m_semicom_prot_idx = 8;
+ m_semicom_prot_idx = 8;
}
static WRITE32_DEVICE_HANDLER( finalgdr_oki_bank_w )
@@ -209,25 +235,22 @@ static WRITE32_DEVICE_HANDLER( finalgdr_oki_bank_w )
downcast<okim6295_device *>(device)->set_bank_base(0x40000 * ((data & 0x300) >> 8));
}
-static WRITE32_HANDLER( finalgdr_backupram_bank_w )
+WRITE32_MEMBER(vamphalf_state::finalgdr_backupram_bank_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_finalgdr_backupram_bank = (data & 0xff000000) >> 24;
+ m_finalgdr_backupram_bank = (data & 0xff000000) >> 24;
}
-static READ32_HANDLER( finalgdr_backupram_r )
+READ32_MEMBER(vamphalf_state::finalgdr_backupram_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- return state->m_finalgdr_backupram[offset + state->m_finalgdr_backupram_bank * 0x80] << 24;
+ return m_finalgdr_backupram[offset + m_finalgdr_backupram_bank * 0x80] << 24;
}
-static WRITE32_HANDLER( finalgdr_backupram_w )
+WRITE32_MEMBER(vamphalf_state::finalgdr_backupram_w)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- state->m_finalgdr_backupram[offset + state->m_finalgdr_backupram_bank * 0x80] = data >> 24;
+ m_finalgdr_backupram[offset + m_finalgdr_backupram_bank * 0x80] = data >> 24;
}
-static WRITE32_HANDLER( finalgdr_prize_w )
+WRITE32_MEMBER(vamphalf_state::finalgdr_prize_w)
{
if(data & 0x1000000)
{
@@ -256,7 +279,7 @@ static WRITE16_DEVICE_HANDLER( boonggab_oki_bank_w )
downcast<okim6295_device *>(device)->set_bank_base(0x40000 * (data & 0x7));
}
-static WRITE16_HANDLER( boonggab_prize_w )
+WRITE16_MEMBER(vamphalf_state::boonggab_prize_w)
{
if(offset)
{
@@ -270,7 +293,7 @@ static WRITE16_HANDLER( boonggab_prize_w )
}
}
-static WRITE16_HANDLER( boonggab_lamps_w )
+WRITE16_MEMBER(vamphalf_state::boonggab_lamps_w)
{
if(offset == 1)
{
@@ -304,7 +327,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( common_32bit_map, AS_PROGRAM, 32, vamphalf_state )
AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE(m_wram32)
AM_RANGE(0x40000000, 0x4003ffff) AM_RAM AM_BASE(m_tiles32)
- AM_RANGE(0x80000000, 0x8000ffff) AM_RAM_WRITE_LEGACY(paletteram32_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x80000000, 0x8000ffff) AM_RAM_WRITE(paletteram32_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0xfff00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
ADDRESS_MAP_END
@@ -314,14 +337,14 @@ static ADDRESS_MAP_START( vamphalf_io, AS_IO, 16, vamphalf_state )
AM_RANGE(0x140, 0x143) AM_DEVWRITE8_LEGACY("ymsnd", ym2151_register_port_w, 0x00ff)
AM_RANGE(0x146, 0x147) AM_DEVREADWRITE8_LEGACY("ymsnd", ym2151_status_port_r, ym2151_data_port_w, 0x00ff)
AM_RANGE(0x1c0, 0x1c3) AM_DEVREAD_LEGACY("eeprom", eeprom_r)
- AM_RANGE(0x240, 0x243) AM_WRITE_LEGACY(flipscreen_w)
+ AM_RANGE(0x240, 0x243) AM_WRITE(flipscreen_w)
AM_RANGE(0x600, 0x603) AM_READ_PORT("SYSTEM")
AM_RANGE(0x604, 0x607) AM_READ_PORT("P1_P2")
AM_RANGE(0x608, 0x60b) AM_DEVWRITE_LEGACY("eeprom", eeprom_w)
ADDRESS_MAP_END
static ADDRESS_MAP_START( misncrft_io, AS_IO, 16, vamphalf_state )
- AM_RANGE(0x100, 0x103) AM_WRITE_LEGACY(flipscreen_w)
+ AM_RANGE(0x100, 0x103) AM_WRITE(flipscreen_w)
AM_RANGE(0x200, 0x203) AM_READ_PORT("P1_P2")
AM_RANGE(0x240, 0x243) AM_READ_PORT("SYSTEM")
AM_RANGE(0x3c0, 0x3c3) AM_DEVWRITE_LEGACY("eeprom", eeprom_w)
@@ -329,7 +352,7 @@ static ADDRESS_MAP_START( misncrft_io, AS_IO, 16, vamphalf_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( coolmini_io, AS_IO, 16, vamphalf_state )
- AM_RANGE(0x200, 0x203) AM_WRITE_LEGACY(flipscreen_w)
+ AM_RANGE(0x200, 0x203) AM_WRITE(flipscreen_w)
AM_RANGE(0x300, 0x303) AM_READ_PORT("SYSTEM")
AM_RANGE(0x304, 0x307) AM_READ_PORT("P1_P2")
AM_RANGE(0x308, 0x30b) AM_DEVWRITE_LEGACY("eeprom", eeprom_w)
@@ -352,8 +375,8 @@ static ADDRESS_MAP_START( suplup_io, AS_IO, 16, vamphalf_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( wyvernwg_io, AS_IO, 32, vamphalf_state )
- AM_RANGE(0x1800, 0x1803) AM_READWRITE_LEGACY(wyvernwg_prot_r, wyvernwg_prot_w)
- AM_RANGE(0x2000, 0x2003) AM_WRITE_LEGACY(flipscreen32_w)
+ AM_RANGE(0x1800, 0x1803) AM_READWRITE(wyvernwg_prot_r, wyvernwg_prot_w)
+ AM_RANGE(0x2000, 0x2003) AM_WRITE(flipscreen32_w)
AM_RANGE(0x2800, 0x2803) AM_READ_PORT("P1_P2")
AM_RANGE(0x3000, 0x3003) AM_READ_PORT("SYSTEM")
AM_RANGE(0x5400, 0x5403) AM_WRITENOP // soundlatch
@@ -362,9 +385,9 @@ static ADDRESS_MAP_START( wyvernwg_io, AS_IO, 32, vamphalf_state )
ADDRESS_MAP_END
static ADDRESS_MAP_START( finalgdr_io, AS_IO, 32, vamphalf_state )
- AM_RANGE(0x2400, 0x2403) AM_READ_LEGACY(finalgdr_prot_r)
- AM_RANGE(0x2800, 0x2803) AM_WRITE_LEGACY(finalgdr_backupram_bank_w)
- AM_RANGE(0x2c00, 0x2dff) AM_READWRITE_LEGACY(finalgdr_backupram_r, finalgdr_backupram_w)
+ AM_RANGE(0x2400, 0x2403) AM_READ(finalgdr_prot_r)
+ AM_RANGE(0x2800, 0x2803) AM_WRITE(finalgdr_backupram_bank_w)
+ AM_RANGE(0x2c00, 0x2dff) AM_READWRITE(finalgdr_backupram_r, finalgdr_backupram_w)
AM_RANGE(0x3000, 0x3007) AM_DEVREADWRITE8_LEGACY("ymsnd", ym2151_r, ym2151_w, 0x0000ff00)
AM_RANGE(0x3800, 0x3803) AM_READ_PORT("P1_P2")
AM_RANGE(0x3400, 0x3403) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x0000ff00)
@@ -372,9 +395,9 @@ static ADDRESS_MAP_START( finalgdr_io, AS_IO, 32, vamphalf_state )
AM_RANGE(0x4400, 0x4403) AM_DEVREAD_LEGACY("eeprom", eeprom32_r)
AM_RANGE(0x6000, 0x6003) AM_READNOP //?
AM_RANGE(0x6000, 0x6003) AM_DEVWRITE_LEGACY("eeprom", finalgdr_eeprom_w)
- AM_RANGE(0x6040, 0x6043) AM_WRITE_LEGACY(finalgdr_prot_w)
- //AM_RANGE(0x6080, 0x6083) AM_WRITE_LEGACY(flipscreen32_w) //?
- AM_RANGE(0x6060, 0x6063) AM_WRITE_LEGACY(finalgdr_prize_w)
+ AM_RANGE(0x6040, 0x6043) AM_WRITE(finalgdr_prot_w)
+ //AM_RANGE(0x6080, 0x6083) AM_WRITE(flipscreen32_w) //?
+ AM_RANGE(0x6060, 0x6063) AM_WRITE(finalgdr_prize_w)
AM_RANGE(0x60a0, 0x60a3) AM_DEVWRITE_LEGACY("oki", finalgdr_oki_bank_w)
ADDRESS_MAP_END
@@ -382,10 +405,10 @@ static ADDRESS_MAP_START( mrkicker_io, AS_IO, 32, vamphalf_state )
AM_RANGE(0x2400, 0x2403) AM_DEVREAD_LEGACY("eeprom", eeprom32_r)
AM_RANGE(0x4000, 0x4003) AM_READNOP //?
AM_RANGE(0x4000, 0x4003) AM_DEVWRITE_LEGACY("eeprom", finalgdr_eeprom_w)
- AM_RANGE(0x4040, 0x4043) AM_WRITE_LEGACY(finalgdr_prot_w)
+ AM_RANGE(0x4040, 0x4043) AM_WRITE(finalgdr_prot_w)
AM_RANGE(0x4084, 0x4087) AM_WRITENOP //?
AM_RANGE(0x40a0, 0x40a3) AM_DEVWRITE_LEGACY("oki", finalgdr_oki_bank_w)
- AM_RANGE(0x6400, 0x6403) AM_READ_LEGACY(finalgdr_prot_r)
+ AM_RANGE(0x6400, 0x6403) AM_READ(finalgdr_prot_r)
AM_RANGE(0x7000, 0x7007) AM_DEVREADWRITE8_LEGACY("ymsnd", ym2151_r, ym2151_w, 0x0000ff00)
AM_RANGE(0x7400, 0x7403) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x0000ff00)
AM_RANGE(0x7800, 0x7803) AM_READ_PORT("P1_P2")
@@ -419,7 +442,7 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( aoh_map, AS_PROGRAM, 32, vamphalf_state )
AM_RANGE(0x00000000, 0x003fffff) AM_RAM AM_BASE(m_wram32)
AM_RANGE(0x40000000, 0x4003ffff) AM_RAM AM_BASE(m_tiles32)
- AM_RANGE(0x80000000, 0x8000ffff) AM_RAM_WRITE_LEGACY(paletteram32_w) AM_BASE_GENERIC(paletteram)
+ AM_RANGE(0x80000000, 0x8000ffff) AM_RAM_WRITE(paletteram32_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x80210000, 0x80210003) AM_READ_PORT("SYSTEM")
AM_RANGE(0x80220000, 0x80220003) AM_READ_PORT("P1_P2")
AM_RANGE(0xffc00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
@@ -436,12 +459,12 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( boonggab_io, AS_IO, 16, vamphalf_state )
AM_RANGE(0x0c0, 0x0c3) AM_DEVREAD_LEGACY("eeprom", eeprom_r)
AM_RANGE(0x200, 0x203) AM_NOP // seems unused
- AM_RANGE(0x300, 0x303) AM_WRITE_LEGACY(flipscreen_w)
+ AM_RANGE(0x300, 0x303) AM_WRITE(flipscreen_w)
AM_RANGE(0x400, 0x403) AM_READ_PORT("SYSTEM")
AM_RANGE(0x404, 0x407) AM_READ_PORT("P1_P2")
AM_RANGE(0x408, 0x40b) AM_DEVWRITE_LEGACY("eeprom", eeprom_w)
- AM_RANGE(0x410, 0x413) AM_WRITE_LEGACY(boonggab_prize_w)
- AM_RANGE(0x414, 0x41b) AM_WRITE_LEGACY(boonggab_lamps_w)
+ AM_RANGE(0x410, 0x413) AM_WRITE(boonggab_prize_w)
+ AM_RANGE(0x414, 0x41b) AM_WRITE(boonggab_lamps_w)
AM_RANGE(0x600, 0x603) AM_DEVWRITE_LEGACY("oki", boonggab_oki_bank_w)
AM_RANGE(0x700, 0x701) AM_NOP // return 0, when oki chip is read / written
AM_RANGE(0x702, 0x703) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff)
@@ -2050,280 +2073,261 @@ static int irq_active(address_space *space)
return 0;
}
-static READ16_HANDLER( vamphalf_speedup_r )
+READ16_MEMBER(vamphalf_state::vamphalf_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x82de)
+ if(cpu_get_pc(&space.device()) == 0x82de)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x4a840/2)+offset];
+ return m_wram[(0x4a840/2)+offset];
}
-static READ16_HANDLER( vamphafk_speedup_r )
+READ16_MEMBER(vamphalf_state::vamphafk_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x82de)
+ if(cpu_get_pc(&space.device()) == 0x82de)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x4a6d0/2)+offset];
+ return m_wram[(0x4a6d0/2)+offset];
}
-static READ16_HANDLER( misncrft_speedup_r )
+READ16_MEMBER(vamphalf_state::misncrft_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xecc8)
+ if(cpu_get_pc(&space.device()) == 0xecc8)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x72eb4/2)+offset];
+ return m_wram[(0x72eb4/2)+offset];
}
-static READ16_HANDLER( coolmini_speedup_r )
+READ16_MEMBER(vamphalf_state::coolmini_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x75f7a)
+ if(cpu_get_pc(&space.device()) == 0x75f7a)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0xd2e80/2)+offset];
+ return m_wram[(0xd2e80/2)+offset];
}
-static READ16_HANDLER( suplup_speedup_r )
+READ16_MEMBER(vamphalf_state::suplup_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xaf18a )
+ if(cpu_get_pc(&space.device()) == 0xaf18a )
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x11605c/2)+offset];
+ return m_wram[(0x11605c/2)+offset];
}
-static READ16_HANDLER( luplup_speedup_r )
+READ16_MEMBER(vamphalf_state::luplup_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xaefac )
+ if(cpu_get_pc(&space.device()) == 0xaefac )
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x115e84/2)+offset];
+ return m_wram[(0x115e84/2)+offset];
}
-static READ16_HANDLER( luplup29_speedup_r )
+READ16_MEMBER(vamphalf_state::luplup29_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xae6c0 )
+ if(cpu_get_pc(&space.device()) == 0xae6c0 )
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x113f08/2)+offset];
+ return m_wram[(0x113f08/2)+offset];
}
-static READ16_HANDLER( puzlbang_speedup_r )
+READ16_MEMBER(vamphalf_state::puzlbang_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xae6d2 )
+ if(cpu_get_pc(&space.device()) == 0xae6d2 )
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x113ecc/2)+offset];
+ return m_wram[(0x113ecc/2)+offset];
}
-static READ32_HANDLER( wyvernwg_speedup_r )
+READ32_MEMBER(vamphalf_state::wyvernwg_speedup_r)
{
- int pc = cpu_get_pc(&space->device());
+ int pc = cpu_get_pc(&space.device());
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
if(pc == 0x10758)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram32[0x00b56fc/4];
+ return m_wram32[0x00b56fc/4];
}
-static READ32_HANDLER( wyvernwga_speedup_r )
+READ32_MEMBER(vamphalf_state::wyvernwga_speedup_r)
{
- int pc = cpu_get_pc(&space->device());
+ int pc = cpu_get_pc(&space.device());
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
if(pc == 0x10758)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram32[0x00b74f8/4];
+ return m_wram32[0x00b74f8/4];
}
-static READ32_HANDLER( finalgdr_speedup_r )
+READ32_MEMBER(vamphalf_state::finalgdr_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x1c212)
+ if(cpu_get_pc(&space.device()) == 0x1c212)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram32[0x005e874/4];
+ return m_wram32[0x005e874/4];
}
-static READ32_HANDLER( mrkicker_speedup_r )
+READ32_MEMBER(vamphalf_state::mrkicker_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- UINT32 pc = cpu_get_pc(&space->device());
+ UINT32 pc = cpu_get_pc(&space.device());
if(pc == 0x469de || pc == 0x46a36)
{
-// if(irq_active(space))
-// device_spin_until_interrupt(&space->device());
+// if(irq_active(&space))
+// device_spin_until_interrupt(&space.device());
// else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram32[0x00701a4/4];
+ return m_wram32[0x00701a4/4];
}
-static READ16_HANDLER( dquizgo2_speedup_r )
+READ16_MEMBER(vamphalf_state::dquizgo2_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xaa622)
+ if(cpu_get_pc(&space.device()) == 0xaa622)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0xcde70/2)+offset];
+ return m_wram[(0xcde70/2)+offset];
}
-static READ32_HANDLER( aoh_speedup_r )
+READ32_MEMBER(vamphalf_state::aoh_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0xb994 )
+ if(cpu_get_pc(&space.device()) == 0xb994 )
{
- device_eat_cycles(&space->device(), 500);
+ device_eat_cycles(&space.device(), 500);
}
- else if (cpu_get_pc(&space->device()) == 0xba40 )
+ else if (cpu_get_pc(&space.device()) == 0xba40 )
{
- device_eat_cycles(&space->device(), 500);
+ device_eat_cycles(&space.device(), 500);
}
- return state->m_wram32[0x28a09c/4];
+ return m_wram32[0x28a09c/4];
}
-static READ16_HANDLER( jmpbreak_speedup_r )
+READ16_MEMBER(vamphalf_state::jmpbreak_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x983c)
+ if(cpu_get_pc(&space.device()) == 0x983c)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x00906fc / 2)+offset];
+ return m_wram[(0x00906fc / 2)+offset];
}
-static READ16_HANDLER( mrdig_speedup_r )
+READ16_MEMBER(vamphalf_state::mrdig_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x1710)
+ if(cpu_get_pc(&space.device()) == 0x1710)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
else
- device_eat_cycles(&space->device(), 50);
+ device_eat_cycles(&space.device(), 50);
}
- return state->m_wram[(0x00a99c / 2)+offset];
+ return m_wram[(0x00a99c / 2)+offset];
}
-static READ16_HANDLER( dtfamily_speedup_r )
+READ16_MEMBER(vamphalf_state::dtfamily_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- int pc = cpu_get_pc(&space->device());
+ int pc = cpu_get_pc(&space.device());
if (pc == 0x12fa6)
- device_spin_until_interrupt(&space->device());
+ device_spin_until_interrupt(&space.device());
- return state->m_wram[0xcc2a8 / 2];
+ return m_wram[0xcc2a8 / 2];
}
-static READ16_HANDLER( toyland_speedup_r )
+READ16_MEMBER(vamphalf_state::toyland_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if (cpu_get_pc(&space->device()) == 0x130c2)
- device_spin_until_interrupt(&space->device());
+ if (cpu_get_pc(&space.device()) == 0x130c2)
+ device_spin_until_interrupt(&space.device());
- return state->m_wram[0x780d8 / 2];
+ return m_wram[0x780d8 / 2];
}
-static READ16_HANDLER( boonggab_speedup_r )
+READ16_MEMBER(vamphalf_state::boonggab_speedup_r)
{
- vamphalf_state *state = space->machine().driver_data<vamphalf_state>();
- if(cpu_get_pc(&space->device()) == 0x13198)
+ if(cpu_get_pc(&space.device()) == 0x13198)
{
- if(irq_active(space))
- device_spin_until_interrupt(&space->device());
+ if(irq_active(&space))
+ device_spin_until_interrupt(&space.device());
}
- return state->m_wram[(0xf1b7c / 2)+offset];
+ return m_wram[(0xf1b7c / 2)+offset];
}
static DRIVER_INIT( vamphalf )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0004a840, 0x0004a843, FUNC(vamphalf_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x0004a840, 0x0004a843, read16_delegate(FUNC(vamphalf_state::vamphalf_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 0x80;
@@ -2332,7 +2336,7 @@ static DRIVER_INIT( vamphalf )
static DRIVER_INIT( vamphafk )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0004a6d0, 0x0004a6d3, FUNC(vamphafk_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x0004a6d0, 0x0004a6d3, read16_delegate(FUNC(vamphalf_state::vamphafk_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 0x80;
@@ -2341,7 +2345,7 @@ static DRIVER_INIT( vamphafk )
static DRIVER_INIT( misncrft )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00072eb4, 0x00072eb7, FUNC(misncrft_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00072eb4, 0x00072eb7, read16_delegate(FUNC(vamphalf_state::misncrft_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2350,7 +2354,7 @@ static DRIVER_INIT( misncrft )
static DRIVER_INIT( coolmini )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x000d2e80, 0x000d2e83, FUNC(coolmini_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x000d2e80, 0x000d2e83, read16_delegate(FUNC(vamphalf_state::coolmini_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2359,7 +2363,7 @@ static DRIVER_INIT( coolmini )
static DRIVER_INIT( suplup )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0011605c, 0x0011605f, FUNC(suplup_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x0011605c, 0x0011605f, read16_delegate(FUNC(vamphalf_state::suplup_speedup_r), state));
state->m_palshift = 8;
/* no flipscreen */
@@ -2368,7 +2372,7 @@ static DRIVER_INIT( suplup )
static DRIVER_INIT( luplup )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00115e84, 0x00115e87, FUNC(luplup_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00115e84, 0x00115e87, read16_delegate(FUNC(vamphalf_state::luplup_speedup_r), state));
state->m_palshift = 8;
/* no flipscreen */
@@ -2377,7 +2381,7 @@ static DRIVER_INIT( luplup )
static DRIVER_INIT( luplup29 )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00113f08, 0x00113f0b, FUNC(luplup29_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00113f08, 0x00113f0b, read16_delegate(FUNC(vamphalf_state::luplup29_speedup_r), state));
state->m_palshift = 8;
/* no flipscreen */
@@ -2386,7 +2390,7 @@ static DRIVER_INIT( luplup29 )
static DRIVER_INIT( puzlbang )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00113ecc, 0x00113ecf, FUNC(puzlbang_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00113ecc, 0x00113ecf, read16_delegate(FUNC(vamphalf_state::puzlbang_speedup_r), state));
state->m_palshift = 8;
/* no flipscreen */
@@ -2395,8 +2399,8 @@ static DRIVER_INIT( puzlbang )
static DRIVER_INIT( wyvernwg )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00b56fc, 0x00b56ff, FUNC(wyvernwg_speedup_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00b74f8, 0x00b74fb, FUNC(wyvernwga_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00b56fc, 0x00b56ff, read32_delegate(FUNC(vamphalf_state::wyvernwg_speedup_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00b74f8, 0x00b74fb, read32_delegate(FUNC(vamphalf_state::wyvernwga_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2411,7 +2415,7 @@ static DRIVER_INIT( finalgdr )
vamphalf_state *state = machine.driver_data<vamphalf_state>();
state->m_finalgdr_backupram_bank = 1;
state->m_finalgdr_backupram = auto_alloc_array(machine, UINT8, 0x80*0x100);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x005e874, 0x005e877, FUNC(finalgdr_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x005e874, 0x005e877, read32_delegate(FUNC(vamphalf_state::finalgdr_speedup_r), state));
machine.device<nvram_device>("nvram")->set_base(state->m_finalgdr_backupram, 0x80*0x100);
state->m_palshift = 0;
@@ -2428,7 +2432,7 @@ static DRIVER_INIT( mrkicker )
// backup ram isn't used
state->m_finalgdr_backupram_bank = 1;
state->m_finalgdr_backupram = auto_alloc_array(machine, UINT8, 0x80*0x100);
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00701a4, 0x00701a7, FUNC(mrkicker_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00701a4, 0x00701a7, read32_delegate(FUNC(vamphalf_state::mrkicker_speedup_r), state));
machine.device<nvram_device>("nvram")->set_base(state->m_finalgdr_backupram, 0x80*0x100);
state->m_palshift = 0;
@@ -2442,7 +2446,7 @@ static DRIVER_INIT( mrkicker )
static DRIVER_INIT( dquizgo2 )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00cde70, 0x00cde73, FUNC(dquizgo2_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00cde70, 0x00cde73, read16_delegate(FUNC(vamphalf_state::dquizgo2_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2451,7 +2455,7 @@ static DRIVER_INIT( dquizgo2 )
static DRIVER_INIT( dtfamily )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xcc2a8, 0xcc2a9, FUNC(dtfamily_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xcc2a8, 0xcc2a9, read16_delegate(FUNC(vamphalf_state::dtfamily_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2461,7 +2465,7 @@ static DRIVER_INIT( dtfamily )
static DRIVER_INIT( toyland )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x780d8, 0x780d9, FUNC(toyland_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x780d8, 0x780d9, read16_delegate(FUNC(vamphalf_state::toyland_speedup_r), state));
state->m_palshift = 0;
state->m_flip_bit = 1;
@@ -2470,7 +2474,7 @@ static DRIVER_INIT( toyland )
static DRIVER_INIT( aoh )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x028a09c, 0x028a09f, FUNC(aoh_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x028a09c, 0x028a09f, read32_delegate(FUNC(vamphalf_state::aoh_speedup_r), state));
state->m_palshift = 0;
/* no flipscreen */
@@ -2479,8 +2483,8 @@ static DRIVER_INIT( aoh )
static DRIVER_INIT( jmpbreak )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00906fc, 0x00906ff, FUNC(jmpbreak_speedup_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe0000000, 0xe0000003, FUNC(jmpbreak_flipscreen_w) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00906fc, 0x00906ff, read16_delegate(FUNC(vamphalf_state::jmpbreak_speedup_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0xe0000000, 0xe0000003, write16_delegate(FUNC(vamphalf_state::jmpbreak_flipscreen_w), state));
state->m_palshift = 0;
}
@@ -2488,8 +2492,8 @@ static DRIVER_INIT( jmpbreak )
static DRIVER_INIT( mrdig )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00a99c, 0x00a99f, FUNC(mrdig_speedup_r) );
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe0000000, 0xe0000003, FUNC(jmpbreak_flipscreen_w) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00a99c, 0x00a99f, read16_delegate(FUNC(vamphalf_state::mrdig_speedup_r), state));
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0xe0000000, 0xe0000003, write16_delegate(FUNC(vamphalf_state::jmpbreak_flipscreen_w), state));
state->m_palshift = 0;
}
@@ -2498,7 +2502,7 @@ static DRIVER_INIT( mrdig )
static DRIVER_INIT( boonggab )
{
vamphalf_state *state = machine.driver_data<vamphalf_state>();
- machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x000f1b7c, 0x000f1b7f, FUNC(boonggab_speedup_r) );
+ machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x000f1b7c, 0x000f1b7f, read16_delegate(FUNC(vamphalf_state::boonggab_speedup_r), state));
state->m_palshift = 0;
state->m_has_extra_gfx = 1;
diff --git a/src/mame/drivers/witch.c b/src/mame/drivers/witch.c
index add39274898..f47a812e1ec 100644
--- a/src/mame/drivers/witch.c
+++ b/src/mame/drivers/witch.c
@@ -214,6 +214,17 @@ public:
int m_scrolly;
UINT8 m_reg_a002;
int m_bank;
+ DECLARE_WRITE8_MEMBER(gfx0_vram_w);
+ DECLARE_WRITE8_MEMBER(gfx0_cram_w);
+ DECLARE_READ8_MEMBER(gfx0_vram_r);
+ DECLARE_READ8_MEMBER(gfx0_cram_r);
+ DECLARE_WRITE8_MEMBER(gfx1_vram_w);
+ DECLARE_WRITE8_MEMBER(gfx1_cram_w);
+ DECLARE_READ8_MEMBER(gfx1_vram_r);
+ DECLARE_READ8_MEMBER(gfx1_cram_r);
+ DECLARE_READ8_MEMBER(read_a00x);
+ DECLARE_WRITE8_MEMBER(write_a00x);
+ DECLARE_READ8_MEMBER(prot_read_700x);
};
@@ -273,111 +284,101 @@ static TILE_GET_INFO( get_gfx1_tile_info )
0);
}
-static WRITE8_HANDLER( gfx0_vram_w )
+WRITE8_MEMBER(witch_state::gfx0_vram_w)
{
- witch_state *state = space->machine().driver_data<witch_state>();
- state->m_gfx0_vram[offset] = data;
- state->m_gfx0a_tilemap->mark_tile_dirty(offset);
- state->m_gfx0b_tilemap->mark_tile_dirty(offset);
+ m_gfx0_vram[offset] = data;
+ m_gfx0a_tilemap->mark_tile_dirty(offset);
+ m_gfx0b_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( gfx0_cram_w )
+WRITE8_MEMBER(witch_state::gfx0_cram_w)
{
- witch_state *state = space->machine().driver_data<witch_state>();
- state->m_gfx0_cram[offset] = data;
- state->m_gfx0a_tilemap->mark_tile_dirty(offset);
- state->m_gfx0b_tilemap->mark_tile_dirty(offset);
+ m_gfx0_cram[offset] = data;
+ m_gfx0a_tilemap->mark_tile_dirty(offset);
+ m_gfx0b_tilemap->mark_tile_dirty(offset);
}
-static READ8_HANDLER( gfx0_vram_r )
+READ8_MEMBER(witch_state::gfx0_vram_r)
{
- witch_state *state = space->machine().driver_data<witch_state>();
- return state->m_gfx0_vram[offset];
+ return m_gfx0_vram[offset];
}
-static READ8_HANDLER( gfx0_cram_r )
+READ8_MEMBER(witch_state::gfx0_cram_r)
{
- witch_state *state = space->machine().driver_data<witch_state>();
- return state->m_gfx0_cram[offset];
+ return m_gfx0_cram[offset];
}
#define FIX_OFFSET() do { \
- offset=(((offset + ((state->m_scrolly & 0xf8) << 2) ) & 0x3e0)+((offset + (state->m_scrollx >> 3) ) & 0x1f)+32)&0x3ff; } while(0)
+ offset=(((offset + ((m_scrolly & 0xf8) << 2) ) & 0x3e0)+((offset + (m_scrollx >> 3) ) & 0x1f)+32)&0x3ff; } while(0)
-static WRITE8_HANDLER( gfx1_vram_w )
+WRITE8_MEMBER(witch_state::gfx1_vram_w)
{
- witch_state *state = space->machine().driver_data<witch_state>();
FIX_OFFSET();
- state->m_gfx1_vram[offset] = data;
- state->m_gfx1_tilemap->mark_tile_dirty(offset);
+ m_gfx1_vram[offset] = data;
+ m_gfx1_tilemap->mark_tile_dirty(offset);
}
-static WRITE8_HANDLER( gfx1_cram_w )
+WRITE8_MEMBER(witch_state::gfx1_cram_w)
{
- witch_state *state = space->machine().driver_data<witch_state>();
FIX_OFFSET();
- state->m_gfx1_cram[offset] = data;
- state->m_gfx1_tilemap->mark_tile_dirty(offset);
+ m_gfx1_cram[offset] = data;
+ m_gfx1_tilemap->mark_tile_dirty(offset);
}
-static READ8_HANDLER( gfx1_vram_r )
+READ8_MEMBER(witch_state::gfx1_vram_r)
{
- witch_state *state = space->machine().driver_data<witch_state>();
FIX_OFFSET();
- return state->m_gfx1_vram[offset];
+ return m_gfx1_vram[offset];
}
-static READ8_HANDLER( gfx1_cram_r )
+READ8_MEMBER(witch_state::gfx1_cram_r)
{
- witch_state *state = space->machine().driver_data<witch_state>();
FIX_OFFSET();
- return state->m_gfx1_cram[offset];
+ return m_gfx1_cram[offset];
}
-static READ8_HANDLER(read_a00x)
+READ8_MEMBER(witch_state::read_a00x)
{
- witch_state *state = space->machine().driver_data<witch_state>();
switch(offset)
{
- case 0x02: return state->m_reg_a002;
- case 0x04: return input_port_read(space->machine(), "A004");
- case 0x05: return input_port_read(space->machine(), "A005");
- case 0x0c: return input_port_read(space->machine(), "SERVICE"); // stats / reset
- case 0x0e: return input_port_read(space->machine(), "A00E"); // coin/reset
+ case 0x02: return m_reg_a002;
+ case 0x04: return input_port_read(machine(), "A004");
+ case 0x05: return input_port_read(machine(), "A005");
+ case 0x0c: return input_port_read(machine(), "SERVICE"); // stats / reset
+ case 0x0e: return input_port_read(machine(), "A00E"); // coin/reset
}
if(offset == 0x00) //muxed with A002?
{
- switch(state->m_reg_a002 & 0x3f)
+ switch(m_reg_a002 & 0x3f)
{
case 0x3b:
- return input_port_read(space->machine(), "UNK"); //bet10 / pay out
+ return input_port_read(machine(), "UNK"); //bet10 / pay out
case 0x3e:
- return input_port_read(space->machine(), "INPUTS"); //TODO : trace f564
+ return input_port_read(machine(), "INPUTS"); //TODO : trace f564
case 0x3d:
- return input_port_read(space->machine(), "A005");
+ return input_port_read(machine(), "A005");
default:
- logerror("A000 read with mux=0x%02x\n", state->m_reg_a002 & 0x3f);
+ logerror("A000 read with mux=0x%02x\n", m_reg_a002 & 0x3f);
}
}
return 0xff;
}
-static WRITE8_HANDLER(write_a00x)
+WRITE8_MEMBER(witch_state::write_a00x)
{
- witch_state *state = space->machine().driver_data<witch_state>();
switch(offset)
{
- case 0x02: //A002 bit 7&6 = state->m_bank ????
+ case 0x02: //A002 bit 7&6 = m_bank ????
{
int newbank;
- state->m_reg_a002 = data;
+ m_reg_a002 = data;
newbank = (data>>6)&3;
- if(newbank != state->m_bank)
+ if(newbank != m_bank)
{
- UINT8 *ROM = space->machine().region("maincpu")->base();
- state->m_bank = newbank;
+ UINT8 *ROM = machine().region("maincpu")->base();
+ m_bank = newbank;
ROM = &ROM[0x10000+0x8000 * newbank + UNBANKED_SIZE];
- memory_set_bankptr(space->machine(), "bank1",ROM);
+ memory_set_bankptr(machine(), "bank1",ROM);
}
}
break;
@@ -386,12 +387,12 @@ static WRITE8_HANDLER(write_a00x)
break;
case 0x08: //A008
- device_set_input_line(&space->device(),0,CLEAR_LINE);
+ device_set_input_line(&space.device(),0,CLEAR_LINE);
break;
}
}
-static READ8_HANDLER(prot_read_700x)
+READ8_MEMBER(witch_state::prot_read_700x)
{
/*
Code @$21a looks like simple protection check.
@@ -403,7 +404,7 @@ static READ8_HANDLER(prot_read_700x)
Otherwise later in game some I/O (controls) reads are skipped.
*/
- switch(cpu_get_pc(&space->device()))
+ switch(cpu_get_pc(&space.device()))
{
case 0x23f:
case 0x246:
@@ -413,7 +414,7 @@ static READ8_HANDLER(prot_read_700x)
case 0x25e:
return offset;//enough to pass...
}
- return space->machine().region("sub")->base()[0x7000+offset];
+ return machine().region("sub")->base()[0x7000+offset];
}
/*
@@ -464,11 +465,11 @@ static ADDRESS_MAP_START( map_main, AS_PROGRAM, 8, witch_state )
AM_RANGE(UNBANKED_SIZE, 0x7fff) AM_ROMBANK("bank1")
AM_RANGE(0x8000, 0x8001) AM_DEVREADWRITE_LEGACY("ym1", ym2203_r, ym2203_w)
AM_RANGE(0x8008, 0x8009) AM_DEVREADWRITE_LEGACY("ym2", ym2203_r, ym2203_w)
- AM_RANGE(0xa000, 0xa00f) AM_READWRITE_LEGACY(read_a00x, write_a00x)
- AM_RANGE(0xc000, 0xc3ff) AM_READWRITE_LEGACY(gfx0_vram_r, gfx0_vram_w) AM_BASE(m_gfx0_vram)
- AM_RANGE(0xc400, 0xc7ff) AM_READWRITE_LEGACY(gfx0_cram_r, gfx0_cram_w) AM_BASE(m_gfx0_cram)
- AM_RANGE(0xc800, 0xcbff) AM_READWRITE_LEGACY(gfx1_vram_r, gfx1_vram_w) AM_BASE(m_gfx1_vram)
- AM_RANGE(0xcc00, 0xcfff) AM_READWRITE_LEGACY(gfx1_cram_r, gfx1_cram_w) AM_BASE(m_gfx1_cram)
+ AM_RANGE(0xa000, 0xa00f) AM_READWRITE(read_a00x, write_a00x)
+ AM_RANGE(0xc000, 0xc3ff) AM_READWRITE(gfx0_vram_r, gfx0_vram_w) AM_BASE(m_gfx0_vram)
+ AM_RANGE(0xc400, 0xc7ff) AM_READWRITE(gfx0_cram_r, gfx0_cram_w) AM_BASE(m_gfx0_cram)
+ AM_RANGE(0xc800, 0xcbff) AM_READWRITE(gfx1_vram_r, gfx1_vram_w) AM_BASE(m_gfx1_vram)
+ AM_RANGE(0xcc00, 0xcfff) AM_READWRITE(gfx1_cram_r, gfx1_cram_w) AM_BASE(m_gfx1_cram)
AM_RANGE(0xd000, 0xdfff) AM_RAM AM_BASE(m_sprite_ram)
AM_RANGE(0xe000, 0xe7ff) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split1_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0xe800, 0xefff) AM_RAM_WRITE_LEGACY(paletteram_xBBBBBGGGGGRRRRR_split2_w) AM_BASE_GENERIC(paletteram2)
@@ -483,7 +484,7 @@ static ADDRESS_MAP_START( map_sub, AS_PROGRAM, 8, witch_state )
AM_RANGE(0x8000, 0x8001) AM_DEVREADWRITE_LEGACY("ym1", ym2203_r, ym2203_w)
AM_RANGE(0x8008, 0x8009) AM_DEVREADWRITE_LEGACY("ym2", ym2203_r, ym2203_w)
AM_RANGE(0x8010, 0x8016) AM_DEVREADWRITE_LEGACY("essnd", read_8010, es8712_w)
- AM_RANGE(0xa000, 0xa00f) AM_READWRITE_LEGACY(read_a00x, write_a00x)
+ AM_RANGE(0xa000, 0xa00f) AM_READWRITE(read_a00x, write_a00x)
AM_RANGE(0xf000, 0xf0ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0xf180, 0xffff) AM_RAM AM_SHARE("share2")
ADDRESS_MAP_END
@@ -867,7 +868,7 @@ static DRIVER_INIT(witch)
UINT8 *ROM = (UINT8 *)machine.region("maincpu")->base();
memory_set_bankptr(machine, "bank1", &ROM[0x10000+UNBANKED_SIZE]);
- machine.device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7000, 0x700f, FUNC(prot_read_700x));
+ machine.device("sub")->memory().space(AS_PROGRAM)->install_read_handler(0x7000, 0x700f, read8_delegate(FUNC(witch_state::prot_read_700x), state));
state->m_bank = -1;
}