static void ata_change_power_mode(ata_drive_t *drv, BYTE value) { if (drv->power == 0x00 && value != 0x00) { drv->busy |= 1; alarm_set(drv->spindle_alarm, maincpu_clk + drv->spinup_time); } if (drv->power != 0x00 && value == 0x00) { drv->busy |= 1; alarm_set(drv->spindle_alarm, maincpu_clk + drv->spindown_time); } if (value == 0x00) { drv->standby = 0; } else { drv->standby = drv->standby_max; } if (value != 0xff) { drv->pos = 0; } if (drv->standby) { alarm_set(drv->standby_alarm, maincpu_clk + 5 * drv->cycles_1s); } else { alarm_unset(drv->standby_alarm); } drv->power = value; }
static void dhcp_alarm_cb(int8 arg) // for alarm mode { if(dhcp_alarm == FALSE) return; if(arg == 0) { if(workinfo.DHCP == NETINFO_DHCP_FAIL) { workinfo.DHCP = NETINFO_DHCP_BUSY; di.action = DHCP_ACT_START; } if(dhcp_get_state() == DHCP_STATE_IP_CHECK) { alarm_set(wizpf_tick_conv(FALSE, di.renew_time), dhcp_alarm_cb, 1); alarm_set(wizpf_tick_conv(FALSE, di.rebind_time), dhcp_alarm_cb, 2); } dhcp_run(); } else if(arg == 1) { // renew SET_STATE(DHCP_STATE_SELECTING); di.action = DHCP_ACT_RENEW; di.xid++; alarm_set(10, dhcp_alarm_cb, 0); } else if(arg == 2) { // rebind SET_STATE(DHCP_STATE_SELECTING); di.action = DHCP_ACT_REBIND; di.xid++; alarm_set(10, dhcp_alarm_cb, 0); } }
static long alarm_do_ioctl(struct file *file, unsigned int cmd, struct timespec *ts) { int rv = 0; unsigned long flags; enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd); if (alarm_type >= ANDROID_ALARM_TYPE_COUNT) return -EINVAL; if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0) && ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_WAIT_CHANGE) { if ((file->f_flags & O_ACCMODE) == O_RDONLY) return -EPERM; if (file->private_data == NULL && cmd != ANDROID_ALARM_SET_RTC) { spin_lock_irqsave(&alarm_slock, flags); if (alarm_opened) { spin_unlock_irqrestore(&alarm_slock, flags); return -EBUSY; } alarm_opened = 1; file->private_data = (void *)1; spin_unlock_irqrestore(&alarm_slock, flags); } } switch (ANDROID_ALARM_BASE_CMD(cmd)) { case ANDROID_ALARM_CLEAR(0): alarm_clear(alarm_type); break; case ANDROID_ALARM_SET(0): alarm_set(alarm_type, ts); break; case ANDROID_ALARM_SET_AND_WAIT(0): alarm_set(alarm_type, ts); /* fall though */ case ANDROID_ALARM_WAIT: rv = alarm_wait(); break; case ANDROID_ALARM_WAIT_CHANGE: { rv = wait_event_interruptible(alarm_wait_change_queue, delta); if (rv == -ERESTARTSYS) { rv = -EINTR; } break; } case ANDROID_ALARM_SET_RTC: rv = alarm_set_rtc(ts); break; case ANDROID_ALARM_GET_TIME(0): rv = alarm_get_time(alarm_type, ts); break; default: rv = -EINVAL; } err1: return rv; }
static void dhcp_alarm_cb(int8 arg) // for DHCP auto mode { if(dhcp_alarm == FALSE) return; if(arg == 0) { if(di.state == DHCP_STATE_BOUND) { alarm_set(wizpf_tick_conv(FALSE, di.renew_time), dhcp_alarm_cb, 1); alarm_set(wizpf_tick_conv(FALSE, di.rebind_time), dhcp_alarm_cb, 2); } if(di.state == DHCP_STATE_FAILED) { di.state = DHCP_STATE_INIT; di.action = DHCP_ACT_START; } dhcp_run(); } else if(arg == 1) { // renew SET_STATE(DHCP_STATE_SELECTING); di.action = DHCP_ACT_RENEW; di.xid++; alarm_set(10, dhcp_alarm_cb, 0); } else if(arg == 2) { // rebind SET_STATE(DHCP_STATE_SELECTING); di.action = DHCP_ACT_REBIND; di.xid++; alarm_set(10, dhcp_alarm_cb, 0); } }
void cart_undump_alarms(void) { if (cart_freeze_alarm_time < CLOCK_MAX) { alarm_set(cartridge_freeze_alarm, cart_freeze_alarm_time); } if (cart_nmi_alarm_time < CLOCK_MAX) { alarm_set(cartridge_nmi_alarm, cart_nmi_alarm_time); } }
static long alarm_do_ioctl(struct file *file, unsigned int cmd, struct timespec *ts) { int rv = 0; unsigned long flags; enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd); if (alarm_type >= ANDROID_ALARM_TYPE_COUNT) return -EINVAL; if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) { if ((file->f_flags & O_ACCMODE) == O_RDONLY) return -EPERM; if (file->private_data == NULL && cmd != ANDROID_ALARM_SET_RTC) { spin_lock_irqsave(&alarm_slock, flags); if (alarm_opened) { spin_unlock_irqrestore(&alarm_slock, flags); return -EBUSY; } alarm_opened = 1; file->private_data = (void *)1; spin_unlock_irqrestore(&alarm_slock, flags); } } switch (ANDROID_ALARM_BASE_CMD(cmd)) { case ANDROID_ALARM_CLEAR(0): alarm_clear(alarm_type); break; case ANDROID_ALARM_SET(0): alarm_set(alarm_type, ts); break; case ANDROID_ALARM_SET_AND_WAIT(0): alarm_set(alarm_type, ts); /* fall though */ case ANDROID_ALARM_WAIT: rv = alarm_wait(); break; case ANDROID_ALARM_SET_RTC: rv = alarm_set_rtc(ts); break; #ifdef CONFIG_RTC_BOOT_ALARM case ANDROID_ALARM_SET_BOOT_ALARM: rv = alarm_set_boot_alarm(ts); break; #endif case ANDROID_ALARM_GET_TIME(0): rv = alarm_get_time(alarm_type, ts); break; default: rv = -EINVAL; } return rv; }
/* CBM-II-specific initialization. */ void machine_specific_reset(void) { ciacore_reset(machine_context.cia1); tpicore_reset(machine_context.tpi1); tpicore_reset(machine_context.tpi2); acia1_reset(); sid_reset(); if (!cbm2_isC500) { crtc_reset(); } else { c500_powerline_clk = maincpu_clk + C500_POWERLINE_CYCLES_PER_IRQ; alarm_set(c500_powerline_clk_alarm, c500_powerline_clk); vicii_reset(); } printer_reset(); rs232drv_reset(); drive_reset(); datasette_reset(); mem_reset(); }
/* Flush pending characters into the kernal's queue if possible. This is (at least) called once per frame in vsync handler */ void kbdbuf_flush(void) { unsigned int i, n; if ((!kbd_buf_enabled) || (num_pending == 0) || !kbdbuf_is_empty() || (maincpu_clk < kernal_init_cycles) || (kbdbuf_flush_alarm_time != 0)) { return; } n = num_pending > buffer_size ? buffer_size : num_pending; /* printf("kbdbuf_flush pending: %d n: %d head_idx: %d\n", num_pending, n, head_idx); */ for (i = 0; i < n; i++) { /* printf("kbdbuf_flush i:%d head_idx:%d queue[head_idx]: %d use_kbdbuf_flush_alarm: %d\n",i,head_idx,queue[head_idx],use_kbdbuf_flush_alarm); */ /* use an alarm to randomly delay RETURN for up to one frame */ if ((queue[head_idx] == 13) && (use_kbdbuf_flush_alarm == 1)) { /* we actually need to wait _at least_ one frame to not overrun the buffer */ kbdbuf_flush_alarm_time = maincpu_clk + machine_get_cycles_per_frame(); kbdbuf_flush_alarm_time += lib_unsigned_rand(1, machine_get_cycles_per_frame()); alarm_set(kbdbuf_flush_alarm, kbdbuf_flush_alarm_time); return; } tokbdbuffer(queue[head_idx]); removefromqueue(); } }
static gssize log_transport_device_read_method(LogTransport *s, gpointer buf, gsize buflen, GSockAddr **sa) { LogTransportDevice *self = (LogTransportDevice *) s; gint rc; if (sa) *sa = NULL; do { if (self->timeout) alarm_set(self->timeout); rc = read(self->super.fd, buf, buflen); if (self->timeout > 0 && rc == -1 && errno == EINTR && alarm_has_fired()) { msg_notice("Nonblocking read has blocked, returning with an error", evt_tag_int("fd", self->super.fd), evt_tag_int("timeout", self->timeout), NULL); alarm_cancel(); break; } if (self->timeout) alarm_cancel(); } while (rc == -1 && errno == EINTR); return rc; }
static void viacore_intt1(CLOCK offset, void *data) { CLOCK rclk; via_context_t *via_context = (via_context_t *)data; rclk = *(via_context->clk_ptr) - offset; #ifdef MYVIA_TIMER_DEBUG if (app_resources.debugFlag) log_message(via_context->log, "myvia timer A interrupt"); #endif if (!(via_context->via[VIA_ACR] & 0x40)) { /* one-shot mode */ #ifdef MYVIA_TIMER_DEBUG log_message(via_context->log, "MYVIA Timer A interrupt -- one-shot mode: next int won't happen"); #endif alarm_unset(via_context->t1_alarm); via_context->tai = 0; } else { /* continuous mode */ /* load counter with latch value */ via_context->tai += via_context->tal + 2; alarm_set(via_context->t1_alarm, via_context->tai); /* Let tau also keep up with the cpu clock this should avoid "% (via_context->tal + 2)" case */ via_context->tau += via_context->tal + 2; } via_context->ifr |= VIA_IM_T1; update_myviairq_rclk(via_context, rclk); /* TODO: toggle PB7? */ /*(viaier & VIA_IM_T1) ? 1:0; */ }
void non_repeating_timer_restart_if(non_repeating_timer_t *timer, bool condition) { assert(timer != NULL); if (condition) alarm_set(timer->alarm, timer->duration, timer->callback, timer->data); else non_repeating_timer_cancel(timer); }
static gssize log_transport_plain_write_method(LogTransport *s, const gpointer buf, gsize buflen) { LogTransportPlain *self = (LogTransportPlain *) s; gint rc; do { if (self->super.timeout) alarm_set(self->super.timeout); if (self->super.flags & LTF_APPEND) lseek(self->super.fd, 0, SEEK_END); rc = write(self->super.fd, buf, buflen); if (self->super.timeout > 0 && rc == -1 && errno == EINTR && alarm_has_fired()) { msg_notice("Nonblocking write has blocked, returning with an error", evt_tag_int("fd", self->super.fd), evt_tag_int("timeout", self->super.timeout), NULL); alarm_cancel(); break; } if (self->super.timeout) alarm_cancel(); if (self->super.flags & LTF_FSYNC) fsync(self->super.fd); } while (rc == -1 && errno == EINTR); return rc; }
inline static int handle_check_sprite_dma(long offset, CLOCK sub) { swap_sprite_data_buffers(); check_sprite_dma(); if (vicii.raster.sprite_status->dma_msk || vicii.raster.sprite_status->new_dma_msk) { vicii_sprites_reset_sprline(); } /* FIXME? Slow! */ vicii.sprite_fetch_clk = (VICII_LINE_START_CLK(maincpu_clk) + vicii.sprite_fetch_cycle); vicii.sprite_fetch_msk = vicii.raster.sprite_status->new_dma_msk; if (vicii_sprites_fetch_table[vicii.sprite_fetch_msk][0].cycle == -1) { if (vicii.raster.current_line >= vicii.first_dma_line - 1 && vicii.raster.current_line <= vicii.last_dma_line + 1) { vicii.fetch_idx = VICII_FETCH_MATRIX; vicii.fetch_clk = (vicii.sprite_fetch_clk - vicii.sprite_fetch_cycle + VICII_FETCH_CYCLE + vicii.cycles_per_line); } else { vicii.fetch_idx = VICII_CHECK_SPRITE_DMA; vicii.fetch_clk = (vicii.sprite_fetch_clk + vicii.cycles_per_line); } } else { /* Next time, fetch sprite data. */ vicii.fetch_idx = VICII_FETCH_SPRITE; vicii.sprite_fetch_idx = 0; vicii.fetch_clk = (vicii.sprite_fetch_clk + vicii_sprites_fetch_table[vicii.sprite_fetch_msk][0].cycle); } /*log_debug("HCSD SCLK %i FCLK %i CLK %i OFFSET %li SUB %i", vicii.store_clk, vicii.fetch_clk, clk, offset, sub);*/ if (vicii.store_clk != CLOCK_MAX) { if (vicii.store_clk + offset - 3 < vicii.fetch_clk) { vicii.ram_base_phi2[vicii.store_addr] = vicii.store_value; } vicii.store_clk = CLOCK_MAX; } vicii.num_idle_3fff_old = vicii.num_idle_3fff; if (vicii.num_idle_3fff > 0) memcpy(vicii.idle_3fff_old, vicii.idle_3fff, sizeof(idle_3fff_t) * vicii.num_idle_3fff); vicii.num_idle_3fff = 0; if (vicii.fetch_clk > maincpu_clk || offset == 0) { alarm_set(vicii.raster_fetch_alarm, vicii.fetch_clk); return 1; } return 0; }
static void viacore_intt1(CLOCK offset, void *data) { via_context_t *via_context = (via_context_t *)data; #ifdef MYVIA_TIMER_DEBUG if (app_resources.debugFlag) log_message(via_context->log, "myvia timer A interrupt"); #endif if (!(via_context->via[VIA_ACR] & 0x40)) { /* one-shot mode */ #ifdef MYVIA_TIMER_DEBUG log_message(via_context->log, "MYVIA Timer A interrupt -- one-shot mode: next int won't happen"); #endif alarm_unset(via_context->t1_alarm); via_context->tai = 0; } else { /* continuous mode */ /* load counter with latch value */ via_context->tai += via_context->tal + 2; alarm_set(via_context->t1_alarm, via_context->tai); } via_context->ifr |= VIA_IM_T1; update_myviairq(via_context); /* TODO: toggle PB7? */ /*(viaier & VIA_IM_T1) ? 1:0; */ }
void datasette_set_motor(int flag) { DBG(("datasette_set_motor(%d) (image present:%s)", flag, current_image ? "yes" : "no")); if (datasette_alarm == NULL) { DBG(("datasette_set_motor (datasette_alarm == NULL)")); return; } if (flag) { /* abort pending motor stop */ motor_stop_clk = 0; if (!datasette_motor) { last_write_clk = (CLOCK)0; datasette_start_motor(); ui_display_tape_motor_status(1); datasette_motor = 1; } } if (!flag && datasette_motor && motor_stop_clk == 0) { motor_stop_clk = maincpu_clk + MOTOR_DELAY; DBG(("datasette_set_motor(maincpu_clk:%d motor_stop_clk:%d)", maincpu_clk, motor_stop_clk)); if (!datasette_alarm_pending) { /* make sure that the motor will stop */ alarm_set(datasette_alarm, motor_stop_clk); datasette_alarm_pending = 1; } } }
void ecg_on_no_qrs(void) { ecg_data_t ecg_data; int i; unit_get_data(ECG, &ecg_data); if ((ecg_data.break_byte & 0xF) == 0 && !alarm_isset(ECG_NOCONNECT)) // no breaks { alarm_set(ECG_ASYSTOLIA); // sched_stop(SCHED_QRS_WAIT); } else { alarm_clr(ECG_ASYSTOLIA); // reloads automatically // sched_start(SCHED_QRS_WAIT, ecg_data.asys_sec*1000, ecg_on_no_qrs, SCHED_NORMAL); } ecg_data.hr = UNDEF_VALUE; for (i=0; i<NUM_ECG; i++) ecg_data.st[i] = UNDEF_VALUE; if (ecg_data.hr_src == HRSRC_ECG || (ecg_data.hr_src == HRSRC_AUTO && ecg_data.hr_src_curr == ECG)) { unit_ioctl(ECG, SET_VALUE, UNIT_ECG_HR, UNDEF_VALUE); } unit_ioctl(ECG, SET_VALUE, UNIT_ECG_ST1_VALUE, UNDEF_VALUE); unit_ioctl(ECG, SET_VALUE, UNIT_ECG_ST2_VALUE, UNDEF_VALUE); unit_set_data(ECG, &ecg_data); unit_cfg_save(); }
int32 main(void) { if(platform_init(NULL) != RET_OK) goto FAIL_TRAP; if(network_init(ASSIST_SOCK, NULL, NULL) != RET_OK) { ERR("network_init fail"); goto FAIL_TRAP; } NL1; LOG("-----------------------------------"); LOG("Serial to Ethernet Using AT Command"); LOG("-----------------------------------"); NL2; atc_init(); alarm_set(2000, dhcp_trigger, 0); //dhcp_auto_start(); while(1) { atc_run(); alarm_run(); sockwatch_run(); wizpf_led_flicker(WIZ_LED1, 1000); // check loop is running } FAIL_TRAP: wizpf_led_trap(1); return 0; }
static void dhcp_async_cb(uint8 sock, uint8 item, int32 ret) // for async mode { switch(item) { case WATCH_SOCK_UDP_SEND: if(dhcp_alarm) alarm_set(10, dhcp_alarm_cb, 0); dhcp_run_tick = wizpf_get_systick(); if(ret == RET_OK) { DBG("DHCP Discovery Sent Async"); if(di.state == DHCP_STATE_INIT) SET_STATE(DHCP_STATE_SEARCHING); else if(di.state == DHCP_STATE_SELECTING) SET_STATE(DHCP_STATE_REQUESTING); else DBGCRTCA(TRUE, "wrong state(%d)", di.state); } else { DBGA("WATCH_SOCK_UDP_SEND fail - ret(%d)", ret); } break; case WATCH_SOCK_TCP_SEND: case WATCH_SOCK_CONN_TRY: case WATCH_SOCK_CLS_TRY: case WATCH_SOCK_CONN_EVT: case WATCH_SOCK_CLS_EVT: case WATCH_SOCK_RECV: DBGCRTC(TRUE, "DHCP does not use TCP"); default: DBGCRTCA(TRUE, "wrong item(0x%x)", item); } }
//'N hh mm ddddddd e' int cmd_alarm_set(int argc, char **argv) { if(argc == 6) { alarm_t newalarm; alarm_id_t na_id; na_id = (alarm_id_t)ustrtoul(argv[1], 0, 10); if(na_id<=ALARM_CT) { day_t temp; newalarm.hour = (uint8_t)ustrtoul(argv[2], 0, 10); newalarm.minute = (uint8_t)ustrtoul(argv[3], 0, 10); temp = (day_t)ustrtoul(argv[4], 0, 2); newalarm.enable_flags = ( ((uint8_t)ustrtoul(argv[5], 0, 10)) == 1 ) ? ALARM_ENABLE : 0; //bit order must be reversed - too tired for something clever newalarm.day_of_week = 0; cmd_printf("%02X:",temp); newalarm.day_of_week |= ( ( temp & 0x40 ) >> 6 ); newalarm.day_of_week |= ( ( temp & 0x20 ) >> 4 ); newalarm.day_of_week |= ( ( temp & 0x10 ) >> 2 ); newalarm.day_of_week |= ( ( temp & 0x08 ) ); newalarm.day_of_week |= ( ( temp & 0x04 ) << 2 ); newalarm.day_of_week |= ( ( temp & 0x02 ) << 4 ); newalarm.day_of_week |= ( ( temp & 0x01 ) << 6 ); cmd_printf("%02X\n",newalarm.day_of_week); alarm_set(na_id, &newalarm); }
/* Reset the CRTC chip. */ void crtc_reset(void) { raster_reset(&crtc.raster); alarm_set(crtc.raster_draw_alarm, CRTC_CYCLES_PER_LINE()); crtc.rl_visible = crtc.regs[1]; crtc.rl_sync = crtc.regs[2]; crtc.rl_len = crtc.regs[0]; crtc.prev_rl_visible = crtc.rl_visible; crtc.prev_rl_sync = crtc.rl_sync; crtc.prev_rl_len = crtc.rl_len; crtc.rl_start = maincpu_clk; crtc.frame_start = maincpu_clk; crtc_reset_screen_ptr(); crtc.raster.ycounter = 0; crtc.current_charline = 0; crtc.current_line = 0; /* expected number of rasterlines for next frame */ crtc.framelines = (crtc.regs[4] + 1) * (crtc.regs[9] + 1) + crtc.regs[5]; }
int fdc_snapshot_read_module(snapshot_t *p, int fnum) { BYTE vmajor, vminor; BYTE byte, ndrv; DWORD dword; snapshot_module_t *m; char *name; name = lib_msprintf("FDC%d", fnum); m = snapshot_module_open(p, name, &vmajor, &vminor); lib_free(name); if (m == NULL) { log_message(fdc_log, "Could not find snapshot module %s", name); return -1; } if (vmajor != FDC_DUMP_VER_MAJOR) { log_error(fdc_log, "Snapshot module version (%d.%d) newer than %d.%d.", vmajor, vminor, FDC_DUMP_VER_MAJOR, FDC_DUMP_VER_MINOR); snapshot_module_close(m); return -1; } SMR_B(m, &byte); if (byte > FDC_LAST_STATE) { snapshot_module_close(m); return -1; } fdc[fnum].fdc_state = byte; /* clk till next invocation */ SMR_DW(m, &dword); fdc[fnum].alarm_clk = drive_clk[fnum] + dword; alarm_set(fdc[fnum].fdc_alarm, fdc[fnum].alarm_clk); /* number of drives - so far 1 only */ SMR_B(m, &ndrv); /* last accessed track/sector */ SMR_B(m, &byte); fdc[fnum].last_track = byte; SMR_B(m, &byte); fdc[fnum].last_sector = byte; if (ndrv > 1) { /* ignore drv 0 values */ SMR_B(m, &byte); SMR_B(m, &byte); } if (snapshot_module_close(m) < 0) return -1; return 0; }
/* Reset the TED chip. */ void ted_reset(void) { /* ted_change_timing();*/ ted_timer_reset(); ted_sound_reset(); raster_reset(&ted.raster); /* FIXME this should be in powerup */ ted.tv_current_line = 0; ted.ted_raster_counter = ted.vsync_line; /* ted_set_geometry();*/ ted.last_emulate_line_clk = 0; ted.draw_clk = ted.draw_cycle; alarm_set(ted.raster_draw_alarm, ted.draw_clk); ted.fetch_clk = TED_FETCH_CYCLE; alarm_set(ted.raster_fetch_alarm, ted.fetch_clk); /* FIXME: I am not sure this is exact emulation. */ ted.raster_irq_line = 0; ted.raster_irq_clk = 0; /* Setup the raster IRQ alarm. The value is `1' instead of `0' because we are at the first line, which has a +1 clock cycle delay in IRQs. */ /* FIXME */ alarm_set(ted.raster_irq_alarm, 1); ted.force_display_state = 0; ted.reverse_mode = 0; /* Remove all the IRQ sources. */ ted.regs[0x0a] = 0; ted.raster.display_ystart = ted.raster.display_ystop = -1; ted.cursor_visible = 0; ted.cursor_phase = 0; ted.fastmode = 1; }
static void epyxfastload_trigger_access(void) { /* Discharge virtual capacitor, enable rom */ alarm_unset(epyxrom_alarm); epyxrom_alarm_time = maincpu_clk + EPYX_ROM_CYCLES; alarm_set(epyxrom_alarm, epyxrom_alarm_time); cart_config_changed_slotmain(0, 0, CMODE_READ); }
/* called by the UI when the freeze button is pressed sets cartridge_freeze_alarm to delay button press up to one frame, then - cart_freeze_alarm_triggered - cart_freeze_allowed (c64carthooks.c) checks wether freeze is allowed for currently active cart(s) if yes, sets up cartridge_nmi_alarm to delay NMI 3 cycles - cart_nmi_alarm_triggered - cart_nmi_alarm (c64carthooks.c) */ void cartridge_trigger_freeze(void) { int delay = lib_unsigned_rand(1, machine_get_cycles_per_frame()); cart_freeze_alarm_time = maincpu_clk + delay; alarm_set(cartridge_freeze_alarm, cart_freeze_alarm_time); DBG(("cartridge_trigger_freeze delay %d cycles\n", delay)); }
static void ted_timer_t3_store_high(BYTE value) { alarm_unset(ted_t3_alarm); t3_value = (t3_start = (t3_start & 0x00ff) | (value << 8)) << 1; alarm_set(ted_t3_alarm, maincpu_clk + (t3_start == 0 ? 65536 : t3_start) * 2); t3_last_restart = maincpu_clk; t3_running = 1; }
void joystick_event_delayed_playback(void *data) { /*! \todo SRT: why network_joystick_value? * and why sizeof latch_joystick_value, * if the target is network_joystick_value? */ memcpy(network_joystick_value, data, sizeof(latch_joystick_value)); alarm_set(joystick_alarm, maincpu_clk + joystick_delay); }
static void datasette_start_motor(void) { fseek(current_image->fd, current_image->current_file_seek_position + current_image->offset, SEEK_SET); if (!datasette_alarm_pending) { alarm_set(datasette_alarm, maincpu_clk + MOTOR_DELAY); datasette_alarm_pending = 1; } }
static void c500_powerline_clk_alarm_handler(CLOCK offset, void *data) { c500_powerline_clk += C500_POWERLINE_CYCLES_PER_IRQ; SIGNAL_VERT_BLANK_OFF alarm_set(c500_powerline_clk_alarm, c500_powerline_clk); SIGNAL_VERT_BLANK_ON }
static void datasette_rewind(void) { if (current_image->mode == DATASETTE_CONTROL_START || current_image->mode == DATASETTE_CONTROL_FORWARD) { alarm_unset(datasette_alarm); datasette_alarm_pending = 0; } alarm_set(datasette_alarm, maincpu_clk + 1000); datasette_alarm_pending = 1; }
static void ted_t3(CLOCK offset, void *data) { alarm_set(ted_t3_alarm, maincpu_clk + 65536 * 2 - offset); t3_start = 0; t3_value = 65536 * 2 - offset; #ifdef DEBUG_TIMER log_debug("TI3 ALARM %x", maincpu_clk); #endif ted_irq_timer3_set(); t3_last_restart = maincpu_clk - offset; }