Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-23 00:39:36 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

A hanful more. (nw)

Browse Source
This commit is contained in:
Andrew Gardner 2013-05-15 23:33:55 +00:00
parent 6f7dd684be
commit f1946c5a5e
32 changed files with 358 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/mame/drivers/asuka.c
View File

@ -230,14 +230,22 @@ DIP locations verified for:
INTERRUPTS
***********************************************************/
TIMER_CALLBACK_MEMBER(asuka_state::cadash_interrupt5)
void asuka_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(5, HOLD_LINE);
switch (id)
{
case TIMER_CADASH_INTERRUPT5:
m_maincpu->set_input_line(5, HOLD_LINE);
break;
default:
assert_always(FALSE, "Unknown id in asuka_state::device_timer");
}
}
INTERRUPT_GEN_MEMBER(asuka_state::cadash_interrupt)
{
machine().scheduler().timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(500), timer_expired_delegate(FUNC(asuka_state::cadash_interrupt5),this));
timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(500), TIMER_CADASH_INTERRUPT5);
device.execute().set_input_line(4, HOLD_LINE); /* interrupt vector 4 */
}

17
src/mame/drivers/dec8.c
View File

@ -132,11 +132,18 @@ READ8_MEMBER(dec8_state::gondo_player_2_r)
*
***************************************************/
TIMER_CALLBACK_MEMBER(dec8_state::dec8_i8751_timer_callback)
void dec8_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
// The schematics show a clocked LS194 shift register (3A) is used to automatically
// clear the IRQ request. The MCU does not clear it itself.
m_mcu->set_input_line(MCS51_INT1_LINE, CLEAR_LINE);
switch (id)
{
case TIMER_DEC8_I8751:
// The schematics show a clocked LS194 shift register (3A) is used to automatically
// clear the IRQ request. The MCU does not clear it itself.
m_mcu->set_input_line(MCS51_INT1_LINE, CLEAR_LINE);
break;
default:
assert_always(FALSE, "Unknown id in dec8_state::device_timer");
}
}
WRITE8_MEMBER(dec8_state::dec8_i8751_w)
@ -146,7 +153,7 @@ WRITE8_MEMBER(dec8_state::dec8_i8751_w)
case 0: /* High byte - SECIRQ is trigged on activating this latch */
m_i8751_value = (m_i8751_value & 0xff) | (data << 8);
m_mcu->set_input_line(MCS51_INT1_LINE, ASSERT_LINE);
machine().scheduler().timer_set(m_mcu->clocks_to_attotime(64), timer_expired_delegate(FUNC(dec8_state::dec8_i8751_timer_callback),this)); // 64 clocks not confirmed
timer_set(m_mcu->clocks_to_attotime(64), TIMER_DEC8_I8751); // 64 clocks not confirmed
break;
case 1: /* Low byte */
m_i8751_value = (m_i8751_value & 0xff00) | data;

43
src/mame/drivers/fuukifg3.c
View File

@ -521,25 +521,26 @@ GFXDECODE_END
***************************************************************************/
TIMER_CALLBACK_MEMBER(fuuki32_state::level_1_interrupt_callback)
void fuuki32_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(1, HOLD_LINE);
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(248), timer_expired_delegate(FUNC(fuuki32_state::level_1_interrupt_callback),this));
}
TIMER_CALLBACK_MEMBER(fuuki32_state::vblank_interrupt_callback)
{
m_maincpu->set_input_line(3, HOLD_LINE); // VBlank IRQ
machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_start(), timer_expired_delegate(FUNC(fuuki32_state::vblank_interrupt_callback),this));
}
TIMER_CALLBACK_MEMBER(fuuki32_state::raster_interrupt_callback)
{
m_maincpu->set_input_line(5, HOLD_LINE); // Raster Line IRQ
machine().primary_screen->update_partial(machine().primary_screen->vpos());
m_raster_interrupt_timer->adjust(machine().primary_screen->frame_period());
switch (id)
{
case TIMER_LEVEL_1_INTERRUPT:
m_maincpu->set_input_line(1, HOLD_LINE);
timer_set(machine().primary_screen->time_until_pos(248), TIMER_LEVEL_1_INTERRUPT);
break;
case TIMER_VBLANK_INTERRUPT:
m_maincpu->set_input_line(3, HOLD_LINE); // VBlank IRQ
timer_set(machine().primary_screen->time_until_vblank_start(), TIMER_VBLANK_INTERRUPT);
break;
case TIMER_RASTER_INTERRUPT:
m_maincpu->set_input_line(5, HOLD_LINE); // Raster Line IRQ
machine().primary_screen->update_partial(machine().primary_screen->vpos());
m_raster_interrupt_timer->adjust(machine().primary_screen->frame_period());
break;
default:
assert_always(FALSE, "Unknown id in fuuki32_state::device_timer");
}
}
@ -549,7 +550,7 @@ void fuuki32_state::machine_start()
membank("bank1")->configure_entries(0, 0x10, &ROM[0x10000], 0x8000);
m_raster_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(fuuki32_state::raster_interrupt_callback),this));
m_raster_interrupt_timer = timer_alloc(TIMER_RASTER_INTERRUPT);
save_item(NAME(m_spr_buffered_tilebank));
save_item(NAME(m_shared_ram));
@ -560,8 +561,8 @@ void fuuki32_state::machine_reset()
{
const rectangle &visarea = machine().primary_screen->visible_area();
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(248), timer_expired_delegate(FUNC(fuuki32_state::level_1_interrupt_callback),this));
machine().scheduler().timer_set(machine().primary_screen->time_until_vblank_start(), timer_expired_delegate(FUNC(fuuki32_state::vblank_interrupt_callback),this));
timer_set(machine().primary_screen->time_until_pos(248), TIMER_LEVEL_1_INTERRUPT);
timer_set(machine().primary_screen->time_until_vblank_start(), TIMER_VBLANK_INTERRUPT);
m_raster_interrupt_timer->adjust(machine().primary_screen->time_until_pos(0, visarea.max_x + 1));
}

13
src/mame/drivers/groundfx.c
View File

@ -98,9 +98,16 @@ WRITE32_MEMBER(groundfx_state::color_ram_w)
INTERRUPTS
***********************************************************/
TIMER_CALLBACK_MEMBER(groundfx_state::groundfx_interrupt5)
void groundfx_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(5, HOLD_LINE); //from 5... ADC port
switch (id)
{
case TIMER_GROUNDFX_INTERRUPT5:
m_maincpu->set_input_line(5, HOLD_LINE); //from 5... ADC port
break;
default:
assert_always(FALSE, "Unknown id in groundfx_state::device_timer");
}
}
@ -173,7 +180,7 @@ WRITE32_MEMBER(groundfx_state::groundfx_adc_w)
{
/* One interrupt per input port (4 per frame, though only 2 used).
1000 cycle delay is arbitrary */
machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(1000), timer_expired_delegate(FUNC(groundfx_state::groundfx_interrupt5),this));
timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(1000), TIMER_GROUNDFX_INTERRUPT5);
}
WRITE32_MEMBER(groundfx_state::rotate_control_w)/* only a guess that it's rotation */

36
src/mame/drivers/metro.c
View File

@ -194,6 +194,25 @@ WRITE16_MEMBER(metro_state::metro_irq_cause_w)
update_irq_state();
}
void metro_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_KARATOUR_IRQ:
m_requested_int[5] = 0;
break;
case TIMER_MOUJA_IRQ:
m_requested_int[0] = 1;
update_irq_state();
break;
case TIMER_METRO_BLIT_DONE:
metro_blit_done(ptr, param);
break;
default:
assert_always(FALSE, "Unknown id in metro_state::device_timer");
}
}
INTERRUPT_GEN_MEMBER(metro_state::metro_vblank_interrupt)
{
m_requested_int[m_vblank_bit] = 1;
@ -206,29 +225,18 @@ INTERRUPT_GEN_MEMBER(metro_state::metro_periodic_interrupt)
update_irq_state();
}
TIMER_CALLBACK_MEMBER(metro_state::karatour_irq_callback)
{
m_requested_int[5] = 0;
}
/* lev 2-7 (lev 1 seems sound related) */
INTERRUPT_GEN_MEMBER(metro_state::karatour_interrupt)
{
m_requested_int[m_vblank_bit] = 1;
/* write to scroll registers, the duration is a guess */
machine().scheduler().timer_set(attotime::from_usec(2500), timer_expired_delegate(FUNC(metro_state::karatour_irq_callback),this));
timer_set(attotime::from_usec(2500), TIMER_KARATOUR_IRQ);
m_requested_int[5] = 1;
update_irq_state();
}
TIMER_CALLBACK_MEMBER(metro_state::mouja_irq_callback)
{
m_requested_int[0] = 1;
update_irq_state();
}
WRITE16_MEMBER(metro_state::mouja_irq_timer_ctrl_w)
{
double freq = 58.0 + (0xff - (data & 0xff)) / 2.2; /* 0xff=58Hz, 0x80=116Hz? */
@ -620,7 +628,7 @@ WRITE16_MEMBER(metro_state::metro_blitter_w)
another blit. */
if (b1 == 0)
{
machine().scheduler().timer_set(attotime::from_usec(500), timer_expired_delegate(FUNC(metro_state::metro_blit_done),this));
timer_set(attotime::from_usec(500), TIMER_METRO_BLIT_DONE);
return;
}
@ -6340,7 +6348,7 @@ DRIVER_INIT_MEMBER(metro_state,mouja)
metro_common();
m_irq_line = -1; /* split interrupt handlers */
m_vblank_bit = 1;
m_mouja_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(metro_state::mouja_irq_callback),this));
m_mouja_irq_timer = timer_alloc(TIMER_MOUJA_IRQ);
}
DRIVER_INIT_MEMBER(metro_state,gakusai)

25
src/mame/drivers/mgolf.c
View File

@ -10,6 +10,11 @@
class mgolf_state : public driver_device
{
public:
enum
{
TIMER_INTERRUPT
};
mgolf_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_video_ram(*this, "video_ram"),
@ -43,6 +48,9 @@ public:
TIMER_CALLBACK_MEMBER(interrupt_callback);
void update_plunger( );
double calc_plunger_pos();
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};
@ -116,6 +124,19 @@ void mgolf_state::update_plunger( )
}
void mgolf_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_INTERRUPT:
interrupt_callback(ptr, param);
break;
default:
assert_always(FALSE, "Unknown id in mgolf_state::device_timer");
}
}
TIMER_CALLBACK_MEMBER(mgolf_state::interrupt_callback)
{
int scanline = param;
@ -129,7 +150,7 @@ TIMER_CALLBACK_MEMBER(mgolf_state::interrupt_callback)
if (scanline >= 262)
scanline = 16;
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(scanline), timer_expired_delegate(FUNC(mgolf_state::interrupt_callback),this), scanline);
timer_set(machine().primary_screen->time_until_pos(scanline), TIMER_INTERRUPT, scanline);
}
@ -314,7 +335,7 @@ void mgolf_state::machine_start()
void mgolf_state::machine_reset()
{
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(16), timer_expired_delegate(FUNC(mgolf_state::interrupt_callback),this), 16);
timer_set(machine().primary_screen->time_until_pos(16), TIMER_INTERRUPT, 16);
m_mask = 0;
m_prev = 0;

15
src/mame/drivers/othunder.c
View File

@ -277,10 +277,17 @@ INTERRUPT_GEN_MEMBER(othunder_state::vblank_interrupt)
update_irq();
}
TIMER_CALLBACK_MEMBER(othunder_state::ad_interrupt)
void othunder_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_ad_irq = 1;
update_irq();
switch (id)
{
case TIMER_AD_INTERRUPT:
m_ad_irq = 1;
update_irq();
break;
default:
assert_always(FALSE, "Unknown id in othunder_state::device_timer");
}
}
@ -374,7 +381,7 @@ WRITE16_MEMBER(othunder_state::othunder_lightgun_w)
The ADC60808 clock is 512kHz. Conversion takes between 0 and 8 clock
cycles, so would end in a maximum of 15.625us. We'll use 10. */
machine().scheduler().timer_set(attotime::from_usec(10), timer_expired_delegate(FUNC(othunder_state::ad_interrupt),this));
timer_set(attotime::from_usec(10), TIMER_AD_INTERRUPT);
}

13
src/mame/drivers/rollerg.c
View File

@ -59,15 +59,22 @@ WRITE8_MEMBER(rollerg_state::soundirq_w)
m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
}
TIMER_CALLBACK_MEMBER(rollerg_state::nmi_callback)
void rollerg_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
switch (id)
{
case TIMER_NMI:
m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
break;
default:
assert_always(FALSE, "Unknown id in rollerg_state::device_timer");
}
}
WRITE8_MEMBER(rollerg_state::sound_arm_nmi_w)
{
m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
machine().scheduler().timer_set(attotime::from_usec(50), timer_expired_delegate(FUNC(rollerg_state::nmi_callback),this)); /* kludge until the K053260 is emulated correctly */
timer_set(attotime::from_usec(50), TIMER_NMI); /* kludge until the K053260 is emulated correctly */
}
READ8_MEMBER(rollerg_state::pip_r)

13
src/mame/drivers/skullxbo.c
View File

@ -39,9 +39,16 @@ void skullxbo_state::update_interrupts()
}
TIMER_CALLBACK_MEMBER(skullxbo_state::irq_gen)
void skullxbo_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
scanline_int_gen(m_maincpu);
switch (id)
{
case TIMER_IRQ_GEN:
scanline_int_gen(m_maincpu);
break;
default:
assert_always(FALSE, "Unknown id in skullxbo_state::device_timer");
}
}
@ -55,7 +62,7 @@ void skullxbo_state::scanline_update(screen_device &screen, int scanline)
{
int width = screen.width();
attotime period = screen.time_until_pos(screen.vpos() + 6, width * 0.9);
machine().scheduler().timer_set(period, timer_expired_delegate(FUNC(skullxbo_state::irq_gen), this));
timer_set(period, TIMER_IRQ_GEN);
}
/* update the playfield and motion objects */

13
src/mame/drivers/slapshot.c
View File

@ -171,15 +171,22 @@ WRITE16_MEMBER(slapshot_state::color_ram_word_w)
INTERRUPTS
***********************************************************/
TIMER_CALLBACK_MEMBER(slapshot_state::slapshot_interrupt6)
void slapshot_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(6, HOLD_LINE);
switch (id)
{
case TIMER_SLAPSHOT_INTERRUPT6:
m_maincpu->set_input_line(6, HOLD_LINE);
break;
default:
assert_always(FALSE, "Unknown id in slapshot_state::device_timer");
}
}
INTERRUPT_GEN_MEMBER(slapshot_state::slapshot_interrupt)
{
machine().scheduler().timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(200000 - 500), timer_expired_delegate(FUNC(slapshot_state::slapshot_interrupt6),this));
timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(200000 - 500), TIMER_SLAPSHOT_INTERRUPT6);
device.execute().set_input_line(5, HOLD_LINE);
}

17
src/mame/drivers/sprint4.c
View File

@ -41,6 +41,19 @@ CUSTOM_INPUT_MEMBER(sprint4_state::get_collision)
}
void sprint4_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_NMI:
nmi_callback(ptr, param);
break;
default:
assert_always(FALSE, "Unknown id in sprint4_state::device_timer");
}
}
TIMER_CALLBACK_MEMBER(sprint4_state::nmi_callback)
{
int scanline = param;
@ -103,13 +116,13 @@ TIMER_CALLBACK_MEMBER(sprint4_state::nmi_callback)
if (ioport("IN0")->read() & 0x40)
m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(scanline), timer_expired_delegate(FUNC(sprint4_state::nmi_callback),this), scanline);
timer_set(machine().primary_screen->time_until_pos(scanline), TIMER_NMI, scanline);
}
void sprint4_state::machine_reset()
{
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(32), timer_expired_delegate(FUNC(sprint4_state::nmi_callback),this), 32);
timer_set(machine().primary_screen->time_until_pos(32), TIMER_NMI, 32);
memset(m_steer_FF1, 0, sizeof m_steer_FF1);
memset(m_steer_FF2, 0, sizeof m_steer_FF2);

13
src/mame/drivers/taito_f3.c
View File

@ -390,15 +390,22 @@ GFXDECODE_END
/******************************************************************************/
TIMER_CALLBACK_MEMBER(taito_f3_state::f3_interrupt3)
void taito_f3_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(3, HOLD_LINE); // some signal from video hardware?
switch (id)
{
case TIMER_F3_INTERRUPT3:
m_maincpu->set_input_line(3, HOLD_LINE); // some signal from video hardware?
break;
default:
assert_always(FALSE, "Unknown id in taito_f3_state::device_timer");
}
}
INTERRUPT_GEN_MEMBER(taito_f3_state::f3_interrupt2)
{
device.execute().set_input_line(2, HOLD_LINE); // vblank
machine().scheduler().timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(10000), timer_expired_delegate(FUNC(taito_f3_state::f3_interrupt3),this));
timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(10000), TIMER_F3_INTERRUPT3);
}
static SOUND_RESET( f3 )

31
src/mame/drivers/taito_z.c
View File

@ -1016,18 +1016,21 @@ WRITE16_MEMBER(taitoz_state::dblaxle_cpua_ctrl_w)
INTERRUPTS
***********************************************************/
/* 68000 A */
TIMER_CALLBACK_MEMBER(taitoz_state::taitoz_interrupt6)
void taitoz_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(6, HOLD_LINE);
}
/* 68000 B */
TIMER_CALLBACK_MEMBER(taitoz_state::taitoz_cpub_interrupt5)
{
m_subcpu->set_input_line(5, HOLD_LINE);
switch (id)
{
case TIMER_TAITOZ_INTERRUPT6:
/* 68000 A */
m_maincpu->set_input_line(6, HOLD_LINE);
break;
case TIMER_TAITOZ_CPUB_INTERRUPT5:
/* 68000 B */
m_subcpu->set_input_line(5, HOLD_LINE);
break;
default:
assert_always(FALSE, "Unknown id in taitoz_state::device_timer");
}
}
@ -1042,7 +1045,7 @@ INTERRUPT_GEN_MEMBER(taitoz_state::sci_interrupt)
m_sci_int6 = !m_sci_int6;
if (m_sci_int6)
machine().scheduler().timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(200000 - 500), timer_expired_delegate(FUNC(taitoz_state::taitoz_interrupt6),this));
timer_set(downcast<cpu_device *>(&device)->cycles_to_attotime(200000 - 500), TIMER_TAITOZ_INTERRUPT6);
device.execute().set_input_line(4, HOLD_LINE);
}
@ -1226,7 +1229,7 @@ WRITE16_MEMBER(taitoz_state::bshark_stick_w)
but we don't want CPUA to have an int6 before int4 is over (?)
*/
machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), timer_expired_delegate(FUNC(taitoz_state::taitoz_interrupt6),this));
timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), TIMER_TAITOZ_INTERRUPT6);
}
@ -1291,7 +1294,7 @@ WRITE16_MEMBER(taitoz_state::spacegun_lightgun_w)
Four lightgun interrupts happen before the collected coords
are moved to shared ram where CPUA can use them. */
machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), timer_expired_delegate(FUNC(taitoz_state::taitoz_cpub_interrupt5),this));
timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), TIMER_TAITOZ_CPUB_INTERRUPT5);
}
WRITE16_MEMBER(taitoz_state::spacegun_gun_output_w)

13
src/mame/drivers/tehkanwc.c
View File

@ -144,9 +144,16 @@ WRITE8_MEMBER(tehkanwc_state::sound_command_w)
m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
}
TIMER_CALLBACK_MEMBER(tehkanwc_state::reset_callback)
void tehkanwc_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_audiocpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
switch (id)
{
case TIMER_RESET:
m_audiocpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
break;
default:
assert_always(FALSE, "Unknown id in tehkanwc_state::device_timer");
}
}
WRITE8_MEMBER(tehkanwc_state::sound_answer_w)
@ -155,7 +162,7 @@ WRITE8_MEMBER(tehkanwc_state::sound_answer_w)
/* in Gridiron, the sound CPU goes in a tight loop after the self test, */
/* probably waiting to be reset by a watchdog */
if (space.device().safe_pc() == 0x08bc) machine().scheduler().timer_set(attotime::from_seconds(1), timer_expired_delegate(FUNC(tehkanwc_state::reset_callback),this));
if (space.device().safe_pc() == 0x08bc) timer_set(attotime::from_seconds(1), TIMER_RESET);
}

24
src/mame/drivers/tugboat.c
View File

@ -31,6 +31,11 @@ always false - counter was reloaded and incremented before interrupt occurs
class tugboat_state : public driver_device
{
public:
enum
{
TIMER_INTERRUPT
};
tugboat_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_ram(*this, "ram"),
@ -51,8 +56,10 @@ public:
virtual void machine_reset();
virtual void palette_init();
UINT32 screen_update_tugboat(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(interrupt_gen);
required_device<cpu_device> m_maincpu;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};
@ -205,15 +212,22 @@ static const pia6821_interface pia1_intf =
DEVCB_NULL /* IRQB */
};
TIMER_CALLBACK_MEMBER(tugboat_state::interrupt_gen)
void tugboat_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(0, HOLD_LINE);
machine().scheduler().timer_set(machine().primary_screen->frame_period(), timer_expired_delegate(FUNC(tugboat_state::interrupt_gen),this));
switch (id)
{
case TIMER_INTERRUPT:
m_maincpu->set_input_line(0, HOLD_LINE);
timer_set(machine().primary_screen->frame_period(), TIMER_INTERRUPT);
break;
default:
assert_always(FALSE, "Unknown id in tugboat_state::device_timer");
}
}
void tugboat_state::machine_reset()
{
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(30*8+4), timer_expired_delegate(FUNC(tugboat_state::interrupt_gen),this));
timer_set(machine().primary_screen->time_until_pos(30*8+4), TIMER_INTERRUPT);
}

15
src/mame/drivers/undrfire.c
View File

@ -225,9 +225,16 @@ WRITE32_MEMBER(undrfire_state::color_ram_w)
INTERRUPTS
***********************************************************/
TIMER_CALLBACK_MEMBER(undrfire_state::interrupt5)
void undrfire_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_maincpu->set_input_line(5, HOLD_LINE);
switch (id)
{
case TIMER_INTERRUPT5:
m_maincpu->set_input_line(5, HOLD_LINE);
break;
default:
assert_always(FALSE, "Unknown id in undrfire_state::device_timer");
}
}
@ -358,7 +365,7 @@ READ32_MEMBER(undrfire_state::unknown_hardware_r)
WRITE32_MEMBER(undrfire_state::unknown_int_req_w)
{
/* 10000 cycle delay is arbitrary */
machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), timer_expired_delegate(FUNC(undrfire_state::interrupt5),this));
timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(10000), TIMER_INTERRUPT5);
}
@ -463,7 +470,7 @@ WRITE32_MEMBER(undrfire_state::cbombers_adc_w)
{
/* One interrupt per input port (4 per frame, though only 2 used).
1000 cycle delay is arbitrary */
machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(1000), timer_expired_delegate(FUNC(undrfire_state::interrupt5),this));
timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(1000), TIMER_INTERRUPT5);
}
/***********************************************************

13
src/mame/drivers/vendetta.c
View File

@ -194,16 +194,23 @@ WRITE8_MEMBER(vendetta_state::vendetta_5fe0_w)
k053246_set_objcha_line(m_k053246, (data & 0x20) ? ASSERT_LINE : CLEAR_LINE);
}
TIMER_CALLBACK_MEMBER(vendetta_state::z80_nmi_callback)
void vendetta_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
switch (id)
{
case TIMER_Z80_NMI:
m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
break;
default:
assert_always(FALSE, "Unknown id in vendetta_state::device_timer");
}
}
WRITE8_MEMBER(vendetta_state::z80_arm_nmi_w)
{
m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
machine().scheduler().timer_set(attotime::from_usec(25), timer_expired_delegate(FUNC(vendetta_state::z80_nmi_callback),this));
timer_set(attotime::from_usec(25), TIMER_Z80_NMI);
}
WRITE8_MEMBER(vendetta_state::z80_irq_w)

9
src/mame/includes/asuka.h
View File

@ -9,6 +9,11 @@
class asuka_state : public driver_device
{
public:
enum
{
TIMER_CADASH_INTERRUPT5
};
asuka_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_cadash_shared_ram(*this, "sharedram"),
@ -59,7 +64,6 @@ public:
UINT32 screen_update_asuka(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void screen_eof_asuka(screen_device &screen, bool state);
INTERRUPT_GEN_MEMBER(cadash_interrupt);
TIMER_CALLBACK_MEMBER(cadash_interrupt5);
/*----------- defined in machine/bonzeadv.c -----------*/
void WriteLevelData();
@ -72,4 +76,7 @@ public:
DECLARE_WRITE16_MEMBER( bonzeadv_cchip_ram_w );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
DECLARE_WRITE_LINE_MEMBER(asuka_msm5205_vck);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/dec8.h
View File

@ -4,6 +4,11 @@
class dec8_state : public driver_device
{
public:
enum
{
TIMER_DEC8_I8751
};
dec8_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
@ -140,8 +145,10 @@ public:
void screen_eof_dec8(screen_device &screen, bool state);
INTERRUPT_GEN_MEMBER(gondo_interrupt);
INTERRUPT_GEN_MEMBER(oscar_interrupt);
TIMER_CALLBACK_MEMBER(dec8_i8751_timer_callback);
void srdarwin_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
DECLARE_WRITE_LINE_MEMBER(csilver_adpcm_int);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

10
src/mame/includes/fuukifg3.h
View File

@ -12,6 +12,13 @@
class fuuki32_state : public driver_device
{
public:
enum
{
TIMER_LEVEL_1_INTERRUPT,
TIMER_VBLANK_INTERRUPT,
TIMER_RASTER_INTERRUPT
};
fuuki32_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_vram(*this, "vram"),
@ -74,4 +81,7 @@ public:
void draw_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect );
void fuuki32_draw_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, int i, int flag, int pri );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/groundfx.h
View File

@ -11,6 +11,11 @@ struct tempsprite
class groundfx_state : public driver_device
{
public:
enum
{
TIMER_GROUNDFX_INTERRUPT5
};
groundfx_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_ram(*this,"ram"),
@ -40,7 +45,9 @@ public:
virtual void video_start();
UINT32 screen_update_groundfx(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(groundfx_interrupt);
TIMER_CALLBACK_MEMBER(groundfx_interrupt5);
void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,int do_hack,int x_offs,int y_offs);
required_device<cpu_device> m_maincpu;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

10
src/mame/includes/metro.h
View File

@ -12,6 +12,13 @@
class metro_state : public driver_device
{
public:
enum
{
TIMER_KARATOUR_IRQ,
TIMER_MOUJA_IRQ,
TIMER_METRO_BLIT_DONE
};
metro_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
@ -192,6 +199,9 @@ public:
int sx, int sy, int wx, int wy, int big, UINT16 *tilemapram, int layer );
DECLARE_WRITE_LINE_MEMBER(blzntrnd_irqhandler);
DECLARE_WRITE_LINE_MEMBER(ymf278b_interrupt);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/othunder.h
View File

@ -23,6 +23,11 @@ struct othunder_tempsprite
class othunder_state : public driver_device
{
public:
enum
{
TIMER_AD_INTERRUPT
};
othunder_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_spriteram(*this,"spriteram"),
@ -80,9 +85,11 @@ public:
virtual void video_start();
UINT32 screen_update_othunder(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(vblank_interrupt);
TIMER_CALLBACK_MEMBER(ad_interrupt);
void reset_sound_region();
void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, const int *primasks, int y_offs );
void update_irq( );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/rollerg.h
View File

@ -8,6 +8,11 @@
class rollerg_state : public driver_device
{
public:
enum
{
TIMER_NMI
};
rollerg_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
@ -43,7 +48,9 @@ public:
virtual void machine_reset();
virtual void video_start();
UINT32 screen_update_rollerg(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(nmi_callback);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};
/*----------- defined in video/rollerg.c -----------*/

9
src/mame/includes/skullxbo.h
View File

@ -9,6 +9,11 @@
class skullxbo_state : public atarigen_state
{
public:
enum
{
TIMER_IRQ_GEN
};
skullxbo_state(const machine_config &mconfig, device_type type, const char *tag)
: atarigen_state(mconfig, type, tag) { }
virtual void update_interrupts();
@ -23,10 +28,12 @@ public:
DECLARE_MACHINE_RESET(skullxbo);
DECLARE_VIDEO_START(skullxbo);
UINT32 screen_update_skullxbo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(irq_gen);
void skullxbo_scanline_update(int scanline);
DECLARE_WRITE16_MEMBER( skullxbo_playfieldlatch_w );
DECLARE_WRITE16_MEMBER( skullxbo_xscroll_w );
DECLARE_WRITE16_MEMBER( skullxbo_yscroll_w );
DECLARE_WRITE16_MEMBER( skullxbo_mobmsb_w );
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/slapshot.h
View File

@ -21,6 +21,11 @@ struct slapshot_tempsprite
class slapshot_state : public driver_device
{
public:
enum
{
TIMER_SLAPSHOT_INTERRUPT6
};
slapshot_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_color_ram(*this,"color_ram"),
@ -77,10 +82,12 @@ public:
UINT32 screen_update_slapshot(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void screen_eof_taito_no_buffer(screen_device &screen, bool state);
INTERRUPT_GEN_MEMBER(slapshot_interrupt);
TIMER_CALLBACK_MEMBER(slapshot_interrupt6);
void reset_sound_region();
void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int *primasks, int y_offset );
void taito_handle_sprite_buffering( );
void taito_update_sprites_active_area( );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

8
src/mame/includes/sprint4.h
View File

@ -1,6 +1,11 @@
class sprint4_state : public driver_device
{
public:
enum
{
TIMER_NMI
};
sprint4_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_videoram(*this, "videoram"),
@ -45,4 +50,7 @@ public:
TIMER_CALLBACK_MEMBER(nmi_callback);
required_device<cpu_device> m_maincpu;
required_device<discrete_device> m_discrete;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/taito_f3.h
View File

@ -45,6 +45,11 @@ enum {
class taito_f3_state : public driver_device
{
public:
enum
{
TIMER_F3_INTERRUPT3
};
taito_f3_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_f3_ram(*this,"f3_ram") ,
@ -278,8 +283,10 @@ public:
UINT32 screen_update_f3(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
void screen_eof_f3(screen_device &screen, bool state);
INTERRUPT_GEN_MEMBER(f3_interrupt2);
TIMER_CALLBACK_MEMBER(f3_interrupt3);
required_device<cpu_device> m_maincpu;
optional_device<cpu_device> m_audiocpu;
optional_device<okim6295_device> m_oki;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

11
src/mame/includes/taito_z.h
View File

@ -12,6 +12,12 @@
class taitoz_state : public driver_device
{
public:
enum
{
TIMER_TAITOZ_INTERRUPT6,
TIMER_TAITOZ_CPUB_INTERRUPT5
};
taitoz_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_spriteram(*this, "spriteram"),
@ -96,8 +102,6 @@ public:
UINT32 screen_update_dblaxle(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_racingb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(sci_interrupt);
TIMER_CALLBACK_MEMBER(taitoz_interrupt6);
TIMER_CALLBACK_MEMBER(taitoz_cpub_interrupt5);
void taitoz_postload();
void contcirc_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
void chasehq_draw_sprites_16x16( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
@ -109,4 +113,7 @@ public:
void reset_sound_region( );
DECLARE_WRITE_LINE_MEMBER(irqhandler);
DECLARE_WRITE_LINE_MEMBER(irqhandlerb);
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/tehkanwc.h
View File

@ -3,6 +3,11 @@
class tehkanwc_state : public driver_device
{
public:
enum
{
TIMER_RESET
};
tehkanwc_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_videoram(*this, "videoram"),
@ -53,7 +58,6 @@ public:
TILE_GET_INFO_MEMBER(get_fg_tile_info);
virtual void video_start();
UINT32 screen_update_tehkanwc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(reset_callback);
void gridiron_draw_led(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 led,int player);
void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
DECLARE_WRITE_LINE_MEMBER(tehkanwc_adpcm_int);
@ -61,4 +65,7 @@ public:
required_device<cpu_device> m_audiocpu;
required_device<cpu_device> m_subcpu;
required_device<msm5205_device> m_msm;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/undrfire.h
View File

@ -12,6 +12,11 @@ struct tempsprite
class undrfire_state : public driver_device
{
public:
enum
{
TIMER_INTERRUPT5
};
undrfire_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_ram(*this, "ram"),
@ -50,10 +55,12 @@ public:
UINT32 screen_update_undrfire(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_cbombers(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(undrfire_interrupt);
TIMER_CALLBACK_MEMBER(interrupt5);
void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs);
void draw_sprites_cbombers(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs);
required_device<cpu_device> m_maincpu;
optional_device<cpu_device> m_subcpu;
required_device<eeprom_device> m_eeprom;
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};

9
src/mame/includes/vendetta.h
View File

@ -8,6 +8,11 @@
class vendetta_state : public driver_device
{
public:
enum
{
TIMER_Z80_NMI
};
vendetta_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
@ -53,8 +58,10 @@ public:
virtual void machine_reset();
UINT32 screen_update_vendetta(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(vendetta_irq);
TIMER_CALLBACK_MEMBER(z80_nmi_callback);
void vendetta_video_banking( int select );
protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
};
/*----------- defined in video/vendetta.c -----------*/