diff options
| author | 2012-04-03 09:51:27 +0000 | |
|---|---|---|
| committer | 2012-04-03 09:51:27 +0000 | |
| commit | fd9822e2859faffee41c3f4a90f4f3bbc94ecb3b (patch) | |
| tree | 287e1ba6e7217bff96ed6edb96daf6ece2f0efb8 /src | |
| parent | 3783cf95515491d961776534fb5937b76accd464 (diff) | |
MAME going modern part 4 (no whatsnew)
Diffstat (limited to 'src')
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; } |
