void ttl74123_device::start_pulse() { attotime duration = compute_duration(); if(timer_running()) { /* retriggering, but not if we are called to quickly */ attotime delay_time = attotime_make(0, ATTOSECONDS_PER_SECOND * m_config.m_cap * 220); if(attotime_compare(timer_timeelapsed(m_timer), delay_time) >= 0) { timer_adjust_oneshot(m_timer, duration, 0); if (LOG) logerror("74123 %s: Retriggering pulse. Duration: %f\n", tag(), attotime_to_double(duration)); } else { if (LOG) logerror("74123 %s: Retriggering failed.\n", tag()); } } else { /* starting */ timer_adjust_oneshot(m_timer, duration, 0); set_output(); if (LOG) logerror("74123 %s: Starting pulse. Duration: %f\n", tag(), attotime_to_double(duration)); } }
static DEVICE_RESET(duart68681) { duart68681_state *duart68681 = get_safe_token(device); emu_timer *save0, *save1; duart68681->ACR = 0; /* Interrupt Vector Register */ duart68681->IVR = 0x0f; /* Interrupt Vector Register */ duart68681->IMR = 0; /* Interrupt Mask Register */ duart68681->ISR = 0; /* Interrupt Status Register */ duart68681->OPCR = 0; /* Output Port Conf. Register */ duart68681->OPR = 0; /* Output Port Register */ duart68681->CTR.d = 0; /* Counter/Timer Preset Value */ duart68681->IP_last_state = 0; /* last state of IP bits */ // "reset clears internal registers (SRA, SRB, IMR, ISR, OPR, OPCR) puts OP0-7 in the high state, stops the counter/timer, and puts channels a/b in the inactive state" save0 = duart68681->channel[0].tx_timer; save1 = duart68681->channel[1].tx_timer; memset(duart68681->channel, 0, sizeof(duart68681->channel)); duart68681->channel[0].tx_timer = save0; duart68681->channel[1].tx_timer = save1; if (duart68681->duart_config->output_port_write) duart68681->duart_config->output_port_write(duart68681->device, duart68681->OPR ^ 0xff); // reset timers timer_adjust_oneshot(duart68681->channel[0].tx_timer, attotime_never, 0); timer_adjust_oneshot(duart68681->channel[1].tx_timer, attotime_never, 1); }
void via6522_device::shift() { if (SO_O2_CONTROL(m_acr) || SO_T2_CONTROL(m_acr)) { m_out_cb2 = (m_sr >> 7) & 1; m_sr = (m_sr << 1) | m_out_cb2; devcb_call_write_line(&m_out_cb2_func, m_out_cb2); m_in_cb1=1; /* this should be one cycle wide */ devcb_call_write_line(&m_out_cb1_func, 0); devcb_call_write_line(&m_out_cb1_func, 1); m_shift_counter = (m_shift_counter + 1) % 8; if (m_shift_counter) { if (SO_O2_CONTROL(m_acr)) { timer_adjust_oneshot(m_shift_timer, cycles_to_time(2), 0); } else { timer_adjust_oneshot(m_shift_timer, cycles_to_time((m_t2ll + 2)*2), 0); } } else { if (!(m_ifr & INT_SR)) { set_int(INT_SR); } } }
static void start_pulse(const device_config *device) { ttl74123_t *chip = get_safe_token(device); attotime duration = compute_duration(chip); if (timer_running(chip)) { /* retriggering, but not if we are called to quickly */ attotime delay_time = attotime_make(0, ATTOSECONDS_PER_SECOND * chip->intf->cap * 220); if (attotime_compare(timer_timeelapsed(chip->timer), delay_time) >= 0) { timer_adjust_oneshot(chip->timer, duration, 0); if (LOG) logerror("74123 %s: Retriggering pulse. Duration: %f\n", device->tag, attotime_to_double(duration)); } else { if (LOG) logerror("74123 %s: Retriggering failed.\n", device->tag); } } else { /* starting */ timer_adjust_oneshot(chip->timer, duration, 0); set_output(device); if (LOG) logerror("74123 %s: Starting pulse. Duration: %f\n", device->tag, attotime_to_double(duration)); } }
static TIMER_CALLBACK( vidc_vblank ) { archimedes_request_irq_a(machine, ARCHIMEDES_IRQA_VBL); // set up for next vbl timer_adjust_oneshot(vbl_timer, video_screen_get_time_until_pos(machine->primary_screen, vidc_regs[0xb4], 0), 0); }
void spacefev_start_red_cannon( running_machine *machine ) { n8080_state *state = (n8080_state *)machine->driver_data; state->spacefev_red_cannon = 1; timer_adjust_oneshot(state->cannon_timer, ATTOTIME_IN_USEC(550 * 68 * 10), 0); }
static TIMER_CALLBACK( spacefev_stop_red_cannon ) { n8080_state *state = (n8080_state *)machine->driver_data; state->spacefev_red_cannon = 0; timer_adjust_oneshot(state->cannon_timer, attotime_never, 0); }
void timer_device::device_reset() { // type based configuration switch (m_config.m_type) { case timer_device_config::TIMER_TYPE_GENERIC: case timer_device_config::TIMER_TYPE_PERIODIC: { // convert the period into attotime attotime period = attotime_never; if (m_config.m_period > 0) { period = UINT64_ATTOTIME_TO_ATTOTIME(m_config.m_period); // convert the start_delay into attotime attotime start_delay = attotime_zero; if (m_config.m_start_delay > 0) start_delay = UINT64_ATTOTIME_TO_ATTOTIME(m_config.m_start_delay); // allocate and start the backing timer timer_adjust_periodic(m_timer, start_delay, m_config.m_param, period); } break; } case timer_device_config::TIMER_TYPE_SCANLINE: if (m_screen == NULL) fatalerror("timer '%s': unable to find screen '%s'\n", tag(), m_config.m_screen); // set the timer to to fire immediately m_first_time = true; timer_adjust_oneshot(m_timer, attotime_zero, m_config.m_param); break; } }
static void msm5205_playmode(msm5205_state *voice,int select) { static const int prescaler_table[4] = {96,48,64,0}; int prescaler = prescaler_table[select & 3]; int bitwidth = (select & 4) ? 4 : 3; if( voice->prescaler != prescaler ) { stream_update(voice->stream); voice->prescaler = prescaler; /* timer set */ if( prescaler ) { attotime period = attotime_mul(ATTOTIME_IN_HZ(voice->clock), prescaler); timer_adjust_periodic(voice->timer, period, 0, period); } else timer_adjust_oneshot(voice->timer, attotime_never, 0); } if( voice->bitwidth != bitwidth ) { stream_update(voice->stream); voice->bitwidth = bitwidth; } }
static TIMER_CALLBACK( cursor_callback ) { if (lockon_main_inten) cputag_set_input_line_and_vector(machine, "maincpu", 0, HOLD_LINE, 0xff); timer_adjust_oneshot(cursor_timer, video_screen_get_time_until_pos(machine->primary_screen, CURSOR_YPOS, CURSOR_XPOS), 0); }
static TIMER_CALLBACK( pr8210_bit_callback ) { attotime duration = ATTOTIME_IN_MSEC(30); const device_config *laserdisc = ptr; UINT8 bitsleft = param >> 16; UINT8 data = param; /* if we have bits, process */ if (bitsleft != 0) { /* assert the line and set a timer for deassertion */ laserdisc_line_w(laserdisc, LASERDISC_LINE_CONTROL, ASSERT_LINE); timer_set(machine, ATTOTIME_IN_USEC(250), ptr, 0, pr8210_bit_off_callback); /* space 0 bits apart by 1msec, and 1 bits by 2msec */ duration = attotime_mul(ATTOTIME_IN_MSEC(1), (data & 0x80) ? 2 : 1); data <<= 1; bitsleft--; } /* if we're out of bits, queue up the next command */ else if (bitsleft == 0 && pr8210_command_buffer_in != pr8210_command_buffer_out) { data = pr8210_command_buffer[pr8210_command_buffer_out++ % ARRAY_LENGTH(pr8210_command_buffer)]; bitsleft = 12; } timer_adjust_oneshot(pr8210_bit_timer, duration, (bitsleft << 16) | data); }
static TIMER_CALLBACK( cliff_irq_callback ) { phillips_code = 0; switch (param) { case 17: phillips_code = laserdisc_get_field_code(laserdisc, LASERDISC_CODE_LINE17, TRUE); param = 18; break; case 18: phillips_code = laserdisc_get_field_code(laserdisc, LASERDISC_CODE_LINE18, TRUE); param = 17; break; } /* if we have a valid code, trigger an IRQ */ if (phillips_code & 0x800000) { // printf("%2d:code = %06X\n", param, phillips_code); cputag_set_input_line(machine, "maincpu", 0, ASSERT_LINE); } timer_adjust_oneshot(irq_timer, machine->primary_screen->time_until_pos(param * 2), param); }
INLINE void schedule_next_irq(running_machine *machine, int curscanline) { /* IRQ is clocked by /32V, so every 64 scanlines */ curscanline = (curscanline + 64) & 255; /* next one at the start of this scanline */ timer_adjust_oneshot(irq_timer, video_screen_get_time_until_pos(machine->primary_screen, curscanline, 0), curscanline); }
static void f3853_timer_start(running_device *device, UINT8 value) { f3853_t *f3853 = get_safe_token( device ); attotime period = (value != 0xff) ? attotime_mul(ATTOTIME_IN_HZ(device->clock), f3853_value_to_cycle[value]*31) : attotime_never; timer_adjust_oneshot(f3853->timer, period, 0); }
static MACHINE_RESET( atetris ) { /* reset the slapstic */ slapstic_reset(); current_bank = slapstic_bank() & 1; reset_bank(); /* start interrupts going (32V clocked by 16V) */ timer_adjust_oneshot(interrupt_timer, video_screen_get_time_until_pos(machine->primary_screen, 48, 0), 48); }
static void adjust_display_position_interrupt_timer(running_machine *machine) { if ((display_counter + 1) != 0) { attotime period = attotime_mul(ATTOTIME_IN_HZ(NEOGEO_PIXEL_CLOCK), display_counter + 1); if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer current y: %02x current x: %02x target y: %x target x: %x\n", video_screen_get_vpos(machine->primary_screen), video_screen_get_hpos(machine->primary_screen), (display_counter + 1) / NEOGEO_HTOTAL, (display_counter + 1) % NEOGEO_HTOTAL); timer_adjust_oneshot(display_position_interrupt_timer, period, 0); } }
INLINE void schedule_next_irq(running_machine *machine, int curscanline) { cloud9_state *state = (cloud9_state *)machine->driver_data; /* IRQ is clocked by /32V, so every 64 scanlines */ curscanline = (curscanline + 64) & 255; /* next one at the start of this scanline */ timer_adjust_oneshot(state->irq_timer, machine->primary_screen->time_until_pos(curscanline), curscanline); }
static TIMER_CALLBACK( ds2401_reset ) { int which = param; struct ds2401_chip *c = &ds2401[ which ]; verboselog( machine, 1, "ds2401_reset(%d)\n", which ); c->state = STATE_RESET; timer_adjust_oneshot( c->timer, attotime_never, which ); }
void running_machine::schedule_soft_reset() { timer_adjust_oneshot(m_soft_reset_timer, attotime_zero, 0); // we can't be paused since the timer needs to fire resume(); // if we're executing, abort out immediately m_scheduler.eat_all_cycles(); }
INLINE void count_states(int states) { attotime state_time = attotime_make(0, attotime_to_attoseconds(MICRO_STATE_CLOCK_PERIOD) * states); if (!micro.timer) { timer_adjust_oneshot(micro.timer, attotime_never, 0); micro.timer_active = 1; micro.endtime = state_time; } else if (attotime_compare(timer_timeelapsed(micro.timer), micro.endtime) > 0) { timer_adjust_oneshot(micro.timer, attotime_never, 0); micro.timer_active = 1; micro.endtime = state_time; } else micro.endtime = attotime_add(micro.endtime, state_time); }
static WRITE32_HANDLER( namcofl_paletteram_w ) { COMBINE_DATA(&space->machine->generic.paletteram.u32[offset]); if ((offset == 0x1808/4) && ACCESSING_BITS_16_31) { UINT16 v = space->machine->generic.paletteram.u32[offset] >> 16; UINT16 triggerscanline=(((v>>8)&0xff)|((v&0xff)<<8))-(32+1); timer_adjust_oneshot(raster_interrupt_timer, space->machine->primary_screen->time_until_pos(triggerscanline), 0); }
static TIMER_CALLBACK( tms34061_interrupt ) { /* set timer for next frame */ timer_adjust_oneshot(tms34061.timer, video_screen_get_frame_period(tms34061.screen), 0); /* set the interrupt bit in the status reg */ tms34061.regs[TMS34061_STATUS] |= 1; /* update the interrupt state */ update_interrupts(); }
static TIMER_CALLBACK( display_position_vblank_callback ) { if (display_position_interrupt_control & IRQ2CTRL_AUTOLOAD_VBLANK) { if (LOG_VIDEO_SYSTEM) logerror("AUTOLOAD_VBLANK "); adjust_display_position_interrupt_timer(machine); } /* set timer for next screen */ timer_adjust_oneshot(display_position_vblank_timer, video_screen_get_time_until_pos(machine->primary_screen, NEOGEO_VBSTART, NEOGEO_VBLANK_RELOAD_HPOS), 0); }
static void a310_set_timer(int tmr) { double freq; if(ioc_timercnt[tmr] != 0) // FIXME: dmdtouch does a divide by zero? { freq = 2000000.0 / (double)ioc_timercnt[tmr]; // logerror("IOC: starting timer %d, %d ticks, freq %f Hz\n", tmr, ioc_timercnt[tmr], freq); timer_adjust_oneshot(timer[tmr], ATTOTIME_IN_HZ(freq), tmr); } }
static MACHINE_RESET( magmax ) { timer_adjust_oneshot(interrupt_timer, video_screen_get_time_until_pos(machine->primary_screen, 64, 0), 64); #if 0 { int i; for (i=0; i<9; i++) logerror("SOUND Chan#%i name=%s\n", i, mixer_get_name(i) ); } #endif }
void running_machine::schedule_soft_reset() { retro_log(RETRO_LOG_INFO, "[MAME 2010] schedule_soft_reset for current MAME machine.\n"); timer_adjust_oneshot(m_soft_reset_timer, attotime_zero, 0); /* we can't be paused since the timer needs to fire */ resume(); /* if we're executing, abort out immediately */ m_scheduler.eat_all_cycles(); }
static void adjust_display_position_interrupt_timer( running_machine *machine ) { neogeo_state *state = (neogeo_state *)machine->driver_data; if ((state->display_counter + 1) != 0) { attotime period = attotime_mul(ATTOTIME_IN_HZ(NEOGEO_PIXEL_CLOCK), state->display_counter + 1); if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer current y: %02x current x: %02x target y: %x target x: %x\n", machine->primary_screen->vpos(), machine->primary_screen->hpos(), (state->display_counter + 1) / NEOGEO_HTOTAL, (state->display_counter + 1) % NEOGEO_HTOTAL); timer_adjust_oneshot(state->display_position_interrupt_timer, period, 0); } }
/* TimerHandler from fm.c */ static void TimerHandler(void *param,int c,attotime period) { ym3526_state *info = (ym3526_state *)param; if( attotime_compare(period, attotime_zero) == 0 ) { /* Reset FM Timer */ timer_enable(info->timer[c], 0); } else { /* Start FM Timer */ timer_adjust_oneshot(info->timer[c], period, 0); } }
void ds2401_write( running_machine *machine, int which, int data ) { struct ds2401_chip *c = &ds2401[ which ]; verboselog( machine, 1, "ds2401_write( %d, %d )\n", which, data ); if( data == 0 && c->rx != 0 ) { switch( c->state ) { case STATE_IDLE: break; case STATE_COMMAND: verboselog( machine, 2, "ds2401_write(%d) state_command\n", which ); timer_adjust_oneshot( c->timer, c->t_samp, which ); break; case STATE_READROM: if( c->bit == 0 ) { c->shift = c->data[ 7 - c->byte ]; verboselog( machine, 1, "ds2401_write(%d) <- data %02x\n", which, c->shift ); } c->tx = c->shift & 1; c->shift >>= 1; c->bit++; if( c->bit == 8 ) { c->bit = 0; c->byte++; } verboselog( machine, 2, "ds2401_write(%d) state_readrom %d\n", which, c->tx ); timer_adjust_oneshot( c->timer, c->t_rdv, which ); break; default: verboselog( machine, 0, "ds2401_write(%d) state not handled: %d\n", which, c->state ); break; } timer_adjust_oneshot( c->reset_timer, c->t_rstl, which ); } else if( data == 1 && c->rx == 0 )
static TIMER_CALLBACK( interrupt_gen ) { int scanline = param; /* assert/deassert the interrupt */ cputag_set_input_line(machine, "maincpu", 0, (scanline & 32) ? ASSERT_LINE : CLEAR_LINE); /* set the next timer */ scanline += 32; if (scanline >= 256) scanline -= 256; timer_adjust_oneshot(interrupt_timer, video_screen_get_time_until_pos(machine->primary_screen, scanline, 0), scanline); }