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;
}
