Archipelago » qemu

        return;

    }

    if (s->freeze_output)

        return;

                             buffered_set_rate_limit,

			     buffered_get_rate_limit);

    return s->file;

}

    /* characters are pending: we send them a bit later (XXX:

       horrible, should change char device API) */

    if (s->out_fifo.count > 0) {

    }

}

    s->out_fifo.buf = s->out_fifo_buf;

    s->out_fifo.buf_size = sizeof(s->out_fifo_buf);

    s->ds = ds;

    if (!color_inited) {

    s->pm_am = 0;

    s->auto_comp = 0;

    s->round = 0;

    memset(&s->alarm_tm, 0, sizeof(s->alarm_tm));

    s->alarm_tm.tm_mday = 0x01;

    s->status = 1 << 7;

    s->irq = irq[0];

    s->alarm = irq[1];

    omap_rtc_reset(s);

    struct omap_lpg_s *s = opaque;

    if (s->cycle)

    else

    s->cycle = !s->cycle;

    printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off");

    struct omap_lpg_s *s = (struct omap_lpg_s *)

            qemu_mallocz(sizeof(struct omap_lpg_s));

    omap_lpg_reset(s);

static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)

{

    s->last_rcnr += ((rt - s->last_hz) << 15) /

            (1000 * ((s->rttr & 0xffff) + 1));

    s->last_rdcr += ((rt - s->last_hz) << 15) /

static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)

{

    if (s->rtsr & (1 << 12))

        s->last_swcr += (rt - s->last_sw) / 10;

    s->last_sw = rt;

static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s)

{

    if (s->rtsr & (1 << 15))

        s->last_swcr += rt - s->last_pi;

    s->last_pi = rt;

    case PIAR:

        return s->piar;

    case RCNR:

                (1000 * ((s->rttr & 0xffff) + 1));

    case RDCR:

                (1000 * ((s->rttr & 0xffff) + 1));

    case RYCR:

        return s->last_rycr;

    case SWCR:

        if (s->rtsr & (1 << 12))

        else

            return s->last_swcr;

    default:

    s->last_swcr = (tm.tm_hour << 19) |

            (tm.tm_min << 13) | (tm.tm_sec << 7);

    s->last_rtcpicr = 0;

    sysbus_init_irq(dev, &s->rtc_irq);

static inline void menelaus_rtc_start(MenelausState *s)

{

    qemu_mod_timer(s->rtc.hz_tm, s->rtc.next);

}

static inline void menelaus_rtc_stop(MenelausState *s)

{

    qemu_del_timer(s->rtc.hz_tm);

    if (s->rtc.next < 1)

        s->rtc.next = 1;

}

{

    MenelausState *s = opaque;

    /* Should be <= 1000 */

}

static int menelaus_post_load(void *opaque, int version_id)

{

    MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c);

    /* Three output pins plus one interrupt pin.  */

    qdev_init_gpio_out(&i2c->qdev, s->out, 4);

    qdev_init_gpio_in(&i2c->qdev, menelaus_gpio_set, 3);

        goto quit;

    }

    return;

quit:

        goto err;

    }

    return 0;

err:

                int64_t ti;

                int secs;

                if (d->timestamps_start == -1)

                    d->timestamps_start = ti;

                ti -= d->timestamps_start;

     * timeout to the normal (much longer) poll interval before the

     * timer triggers.

     */

}

static void pty_chr_state(CharDriverState *chr, int connected)

        /* (re-)connect poll interval for idle guests: once per second.

         * We check more frequently in case the guests sends data to

         * the virtual device linked to our pty. */

    } else {

        if (!s->connected)

            qemu_chr_generic_open(chr);

    chr->chr_update_read_handler = pty_chr_update_read_handler;

    chr->chr_close = pty_chr_close;

    return chr;

}

static void icount_adjust_rt(void * opaque)

{

    qemu_mod_timer(icount_rt_timer,

    icount_adjust();

}

       the virtual time trigger catches emulated time passing too fast.

       Realtime triggers occur even when idle, so use them less frequently

       than VM triggers.  */

    qemu_mod_timer(icount_rt_timer,

    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);

    qemu_mod_timer(icount_vm_timer,

                   qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);

    if (--count) {

        /* delay 50ms, 150ms, 250ms, ... */

                       50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);

    } else {

	    qemu_del_timer(timer);

void qemu_announce_self(void)

{

	static QEMUTimer *timer;

	qemu_announce_self_once(&timer);

}

    global_writefds = writefds;

    global_xfds = xfds;

    QTAILQ_FOREACH(slirp, &slirp_instances, entry) {

	/*

    SpiceTimer *timer;

    timer = qemu_mallocz(sizeof(*timer));

    QTAILQ_INSERT_TAIL(&timers, timer, next);

    return timer;

}

static void timer_start(SpiceTimer *timer, uint32_t ms)

{

}

static void timer_cancel(SpiceTimer *timer)

    if (data[0] > 3) {

        vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;

    }

    switch (data[0]) {

    if (vnc_trylock_display(vd)) {

        vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;

                       vd->timer_interval);

        return;

    }

        if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)

            vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;

    }

}

static void vnc_init_timer(VncDisplay *vd)

{

    vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;

    if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {

        vnc_dpy_resize(vd->ds);

        vnc_refresh(vd);

    }

    }

    if (!usb_auto_timer) {

        if (!usb_auto_timer) {

            return;

        }

    }

}

/*

            interval = dcl->gui_timer_interval;

        dcl = dcl->next;

    }

}

static void nographic_update(void *opaque)

    uint64_t interval = GUI_REFRESH_INTERVAL;

    qemu_flush_coalesced_mmio_buffer();

}

struct vm_change_state_entry {

    dcl = ds->listeners;

    while (dcl != NULL) {

        if (dcl->dpy_refresh != NULL) {

            break;

        }

        dcl = dcl->next;

    }

    if (ds->gui_timer == NULL) {

    }

    text_consoles_set_display(ds);