mirror of
https://github.com/qemu/qemu.git
synced 2024-11-27 22:03:35 +08:00
change all rt_clock references to use millisecond resolution accessors
This was done with:
sed -i '/get_clock\>.*rt_clock/s/get_clock\>/get_clock_ms/' \
$(git grep -l 'get_clock\>.*rt_clock' )
sed -i '/new_timer\>.*rt_clock/s/new_timer\>/new_timer_ms/' \
$(git grep -l 'new_timer\>.*rt_clock' )
after checking that get_clock and new_timer never occur twice
on the same line. There were no missed occurrences; however, even
if there had been, they would have been caught by the compiler.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini
parent
0ce1b9480e
commit
7bd427d801
@ -238,7 +238,7 @@ static void buffered_rate_tick(void *opaque)
|
||||
return;
|
||||
}
|
||||
|
||||
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100);
|
||||
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);
|
||||
|
||||
if (s->freeze_output)
|
||||
return;
|
||||
@ -274,9 +274,9 @@ QEMUFile *qemu_fopen_ops_buffered(void *opaque,
|
||||
buffered_set_rate_limit,
|
||||
buffered_get_rate_limit);
|
||||
|
||||
s->timer = qemu_new_timer(rt_clock, buffered_rate_tick, s);
|
||||
s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s);
|
||||
|
||||
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100);
|
||||
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);
|
||||
|
||||
return s->file;
|
||||
}
|
||||
|
||||
@ -1135,7 +1135,7 @@ static void kbd_send_chars(void *opaque)
|
||||
/* characters are pending: we send them a bit later (XXX:
|
||||
horrible, should change char device API) */
|
||||
if (s->out_fifo.count > 0) {
|
||||
qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);
|
||||
qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1457,7 +1457,7 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
|
||||
|
||||
s->out_fifo.buf = s->out_fifo_buf;
|
||||
s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
|
||||
s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
|
||||
s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);
|
||||
s->ds = ds;
|
||||
|
||||
if (!color_inited) {
|
||||
|
||||
10
hw/omap1.c
10
hw/omap1.c
@ -2802,7 +2802,7 @@ static void omap_rtc_reset(struct omap_rtc_s *s)
|
||||
s->pm_am = 0;
|
||||
s->auto_comp = 0;
|
||||
s->round = 0;
|
||||
s->tick = qemu_get_clock(rt_clock);
|
||||
s->tick = qemu_get_clock_ms(rt_clock);
|
||||
memset(&s->alarm_tm, 0, sizeof(s->alarm_tm));
|
||||
s->alarm_tm.tm_mday = 0x01;
|
||||
s->status = 1 << 7;
|
||||
@ -2822,7 +2822,7 @@ static struct omap_rtc_s *omap_rtc_init(target_phys_addr_t base,
|
||||
|
||||
s->irq = irq[0];
|
||||
s->alarm = irq[1];
|
||||
s->clk = qemu_new_timer(rt_clock, omap_rtc_tick, s);
|
||||
s->clk = qemu_new_timer_ms(rt_clock, omap_rtc_tick, s);
|
||||
|
||||
omap_rtc_reset(s);
|
||||
|
||||
@ -3399,9 +3399,9 @@ static void omap_lpg_tick(void *opaque)
|
||||
struct omap_lpg_s *s = opaque;
|
||||
|
||||
if (s->cycle)
|
||||
qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->period - s->on);
|
||||
qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->period - s->on);
|
||||
else
|
||||
qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->on);
|
||||
qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->on);
|
||||
|
||||
s->cycle = !s->cycle;
|
||||
printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off");
|
||||
@ -3516,7 +3516,7 @@ static struct omap_lpg_s *omap_lpg_init(target_phys_addr_t base, omap_clk clk)
|
||||
struct omap_lpg_s *s = (struct omap_lpg_s *)
|
||||
qemu_mallocz(sizeof(struct omap_lpg_s));
|
||||
|
||||
s->tm = qemu_new_timer(rt_clock, omap_lpg_tick, s);
|
||||
s->tm = qemu_new_timer_ms(rt_clock, omap_lpg_tick, s);
|
||||
|
||||
omap_lpg_reset(s);
|
||||
|
||||
|
||||
26
hw/pxa2xx.c
26
hw/pxa2xx.c
@ -921,7 +921,7 @@ static inline void pxa2xx_rtc_int_update(PXA2xxRTCState *s)
|
||||
|
||||
static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
|
||||
{
|
||||
int64_t rt = qemu_get_clock(rt_clock);
|
||||
int64_t rt = qemu_get_clock_ms(rt_clock);
|
||||
s->last_rcnr += ((rt - s->last_hz) << 15) /
|
||||
(1000 * ((s->rttr & 0xffff) + 1));
|
||||
s->last_rdcr += ((rt - s->last_hz) << 15) /
|
||||
@ -931,7 +931,7 @@ static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
|
||||
|
||||
static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
|
||||
{
|
||||
int64_t rt = qemu_get_clock(rt_clock);
|
||||
int64_t rt = qemu_get_clock_ms(rt_clock);
|
||||
if (s->rtsr & (1 << 12))
|
||||
s->last_swcr += (rt - s->last_sw) / 10;
|
||||
s->last_sw = rt;
|
||||
@ -939,7 +939,7 @@ static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
|
||||
|
||||
static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s)
|
||||
{
|
||||
int64_t rt = qemu_get_clock(rt_clock);
|
||||
int64_t rt = qemu_get_clock_ms(rt_clock);
|
||||
if (s->rtsr & (1 << 15))
|
||||
s->last_swcr += rt - s->last_pi;
|
||||
s->last_pi = rt;
|
||||
@ -1064,16 +1064,16 @@ static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr)
|
||||
case PIAR:
|
||||
return s->piar;
|
||||
case RCNR:
|
||||
return s->last_rcnr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) /
|
||||
return s->last_rcnr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
|
||||
(1000 * ((s->rttr & 0xffff) + 1));
|
||||
case RDCR:
|
||||
return s->last_rdcr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) /
|
||||
return s->last_rdcr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
|
||||
(1000 * ((s->rttr & 0xffff) + 1));
|
||||
case RYCR:
|
||||
return s->last_rycr;
|
||||
case SWCR:
|
||||
if (s->rtsr & (1 << 12))
|
||||
return s->last_swcr + (qemu_get_clock(rt_clock) - s->last_sw) / 10;
|
||||
return s->last_swcr + (qemu_get_clock_ms(rt_clock) - s->last_sw) / 10;
|
||||
else
|
||||
return s->last_swcr;
|
||||
default:
|
||||
@ -1219,14 +1219,14 @@ static int pxa2xx_rtc_init(SysBusDevice *dev)
|
||||
s->last_swcr = (tm.tm_hour << 19) |
|
||||
(tm.tm_min << 13) | (tm.tm_sec << 7);
|
||||
s->last_rtcpicr = 0;
|
||||
s->last_hz = s->last_sw = s->last_pi = qemu_get_clock(rt_clock);
|
||||
s->last_hz = s->last_sw = s->last_pi = qemu_get_clock_ms(rt_clock);
|
||||
|
||||
s->rtc_hz = qemu_new_timer(rt_clock, pxa2xx_rtc_hz_tick, s);
|
||||
s->rtc_rdal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal1_tick, s);
|
||||
s->rtc_rdal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal2_tick, s);
|
||||
s->rtc_swal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal1_tick, s);
|
||||
s->rtc_swal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal2_tick, s);
|
||||
s->rtc_pi = qemu_new_timer(rt_clock, pxa2xx_rtc_pi_tick, s);
|
||||
s->rtc_hz = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_hz_tick, s);
|
||||
s->rtc_rdal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal1_tick, s);
|
||||
s->rtc_rdal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal2_tick, s);
|
||||
s->rtc_swal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal1_tick, s);
|
||||
s->rtc_swal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal2_tick, s);
|
||||
s->rtc_pi = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_pi_tick, s);
|
||||
|
||||
sysbus_init_irq(dev, &s->rtc_irq);
|
||||
|
||||
|
||||
@ -74,14 +74,14 @@ static inline void menelaus_update(MenelausState *s)
|
||||
|
||||
static inline void menelaus_rtc_start(MenelausState *s)
|
||||
{
|
||||
s->rtc.next += qemu_get_clock(rt_clock);
|
||||
s->rtc.next += qemu_get_clock_ms(rt_clock);
|
||||
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);
|
||||
s->rtc.next -= qemu_get_clock(rt_clock);
|
||||
s->rtc.next -= qemu_get_clock_ms(rt_clock);
|
||||
if (s->rtc.next < 1)
|
||||
s->rtc.next = 1;
|
||||
}
|
||||
@ -786,7 +786,7 @@ static void menelaus_pre_save(void *opaque)
|
||||
{
|
||||
MenelausState *s = opaque;
|
||||
/* Should be <= 1000 */
|
||||
s->rtc_next_vmstate = s->rtc.next - qemu_get_clock(rt_clock);
|
||||
s->rtc_next_vmstate = s->rtc.next - qemu_get_clock_ms(rt_clock);
|
||||
}
|
||||
|
||||
static int menelaus_post_load(void *opaque, int version_id)
|
||||
@ -847,7 +847,7 @@ static int twl92230_init(i2c_slave *i2c)
|
||||
{
|
||||
MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c);
|
||||
|
||||
s->rtc.hz_tm = qemu_new_timer(rt_clock, menelaus_rtc_hz, s);
|
||||
s->rtc.hz_tm = qemu_new_timer_ms(rt_clock, menelaus_rtc_hz, s);
|
||||
/* 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);
|
||||
|
||||
@ -149,7 +149,7 @@ static void xen_domain_poll(void *opaque)
|
||||
goto quit;
|
||||
}
|
||||
|
||||
qemu_mod_timer(xen_poll, qemu_get_clock(rt_clock) + 1000);
|
||||
qemu_mod_timer(xen_poll, qemu_get_clock_ms(rt_clock) + 1000);
|
||||
return;
|
||||
|
||||
quit:
|
||||
@ -291,8 +291,8 @@ int xen_domain_build_pv(const char *kernel, const char *ramdisk,
|
||||
goto err;
|
||||
}
|
||||
|
||||
xen_poll = qemu_new_timer(rt_clock, xen_domain_poll, NULL);
|
||||
qemu_mod_timer(xen_poll, qemu_get_clock(rt_clock) + 1000);
|
||||
xen_poll = qemu_new_timer_ms(rt_clock, xen_domain_poll, NULL);
|
||||
qemu_mod_timer(xen_poll, qemu_get_clock_ms(rt_clock) + 1000);
|
||||
return 0;
|
||||
|
||||
err:
|
||||
|
||||
@ -267,7 +267,7 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
|
||||
int64_t ti;
|
||||
int secs;
|
||||
|
||||
ti = qemu_get_clock(rt_clock);
|
||||
ti = qemu_get_clock_ms(rt_clock);
|
||||
if (d->timestamps_start == -1)
|
||||
d->timestamps_start = ti;
|
||||
ti -= d->timestamps_start;
|
||||
@ -911,7 +911,7 @@ static void pty_chr_update_read_handler(CharDriverState *chr)
|
||||
* timeout to the normal (much longer) poll interval before the
|
||||
* timer triggers.
|
||||
*/
|
||||
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
|
||||
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 10);
|
||||
}
|
||||
|
||||
static void pty_chr_state(CharDriverState *chr, int connected)
|
||||
@ -925,7 +925,7 @@ 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. */
|
||||
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
|
||||
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 1000);
|
||||
} else {
|
||||
if (!s->connected)
|
||||
qemu_chr_generic_open(chr);
|
||||
@ -1001,7 +1001,7 @@ static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
|
||||
chr->chr_update_read_handler = pty_chr_update_read_handler;
|
||||
chr->chr_close = pty_chr_close;
|
||||
|
||||
s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
|
||||
s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
|
||||
|
||||
return chr;
|
||||
}
|
||||
|
||||
@ -264,7 +264,7 @@ static void icount_adjust(void)
|
||||
static void icount_adjust_rt(void * opaque)
|
||||
{
|
||||
qemu_mod_timer(icount_rt_timer,
|
||||
qemu_get_clock(rt_clock) + 1000);
|
||||
qemu_get_clock_ms(rt_clock) + 1000);
|
||||
icount_adjust();
|
||||
}
|
||||
|
||||
@ -601,9 +601,9 @@ void configure_icount(const char *option)
|
||||
the virtual time trigger catches emulated time passing too fast.
|
||||
Realtime triggers occur even when idle, so use them less frequently
|
||||
than VM triggers. */
|
||||
icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
|
||||
icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
|
||||
qemu_mod_timer(icount_rt_timer,
|
||||
qemu_get_clock(rt_clock) + 1000);
|
||||
qemu_get_clock_ms(rt_clock) + 1000);
|
||||
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);
|
||||
|
||||
4
savevm.c
4
savevm.c
@ -137,7 +137,7 @@ static void qemu_announce_self_once(void *opaque)
|
||||
|
||||
if (--count) {
|
||||
/* delay 50ms, 150ms, 250ms, ... */
|
||||
qemu_mod_timer(timer, qemu_get_clock(rt_clock) +
|
||||
qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
|
||||
50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
|
||||
} else {
|
||||
qemu_del_timer(timer);
|
||||
@ -148,7 +148,7 @@ static void qemu_announce_self_once(void *opaque)
|
||||
void qemu_announce_self(void)
|
||||
{
|
||||
static QEMUTimer *timer;
|
||||
timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer);
|
||||
timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
|
||||
qemu_announce_self_once(&timer);
|
||||
}
|
||||
|
||||
|
||||
@ -393,7 +393,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
|
||||
global_writefds = writefds;
|
||||
global_xfds = xfds;
|
||||
|
||||
curtime = qemu_get_clock(rt_clock);
|
||||
curtime = qemu_get_clock_ms(rt_clock);
|
||||
|
||||
QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
|
||||
/*
|
||||
|
||||
@ -55,14 +55,14 @@ static SpiceTimer *timer_add(SpiceTimerFunc func, void *opaque)
|
||||
SpiceTimer *timer;
|
||||
|
||||
timer = qemu_mallocz(sizeof(*timer));
|
||||
timer->timer = qemu_new_timer(rt_clock, func, opaque);
|
||||
timer->timer = qemu_new_timer_ms(rt_clock, func, opaque);
|
||||
QTAILQ_INSERT_TAIL(&timers, timer, next);
|
||||
return timer;
|
||||
}
|
||||
|
||||
static void timer_start(SpiceTimer *timer, uint32_t ms)
|
||||
{
|
||||
qemu_mod_timer(timer->timer, qemu_get_clock(rt_clock) + ms);
|
||||
qemu_mod_timer(timer->timer, qemu_get_clock_ms(rt_clock) + ms);
|
||||
}
|
||||
|
||||
static void timer_cancel(SpiceTimer *timer)
|
||||
|
||||
10
ui/vnc.c
10
ui/vnc.c
@ -1875,8 +1875,8 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
|
||||
|
||||
if (data[0] > 3) {
|
||||
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
||||
if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval))
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
|
||||
if (!qemu_timer_expired(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval))
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
|
||||
}
|
||||
|
||||
switch (data[0]) {
|
||||
@ -2441,7 +2441,7 @@ static void vnc_refresh(void *opaque)
|
||||
|
||||
if (vnc_trylock_display(vd)) {
|
||||
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) +
|
||||
vd->timer_interval);
|
||||
return;
|
||||
}
|
||||
@ -2468,14 +2468,14 @@ static void vnc_refresh(void *opaque)
|
||||
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
|
||||
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
|
||||
}
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
|
||||
qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
|
||||
}
|
||||
|
||||
static void vnc_init_timer(VncDisplay *vd)
|
||||
{
|
||||
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
||||
if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
|
||||
vd->timer = qemu_new_timer(rt_clock, vnc_refresh, vd);
|
||||
vd->timer = qemu_new_timer_ms(rt_clock, vnc_refresh, vd);
|
||||
vnc_dpy_resize(vd->ds);
|
||||
vnc_refresh(vd);
|
||||
}
|
||||
|
||||
@ -1535,12 +1535,12 @@ static void usb_host_auto_check(void *unused)
|
||||
}
|
||||
|
||||
if (!usb_auto_timer) {
|
||||
usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_check, NULL);
|
||||
usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
|
||||
if (!usb_auto_timer) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
|
||||
qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
12
vl.c
12
vl.c
@ -1142,7 +1142,7 @@ static void gui_update(void *opaque)
|
||||
interval = dcl->gui_timer_interval;
|
||||
dcl = dcl->next;
|
||||
}
|
||||
qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
|
||||
qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock_ms(rt_clock));
|
||||
}
|
||||
|
||||
static void nographic_update(void *opaque)
|
||||
@ -1150,7 +1150,7 @@ static void nographic_update(void *opaque)
|
||||
uint64_t interval = GUI_REFRESH_INTERVAL;
|
||||
|
||||
qemu_flush_coalesced_mmio_buffer();
|
||||
qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
|
||||
qemu_mod_timer(nographic_timer, interval + qemu_get_clock_ms(rt_clock));
|
||||
}
|
||||
|
||||
struct vm_change_state_entry {
|
||||
@ -3089,15 +3089,15 @@ int main(int argc, char **argv, char **envp)
|
||||
dcl = ds->listeners;
|
||||
while (dcl != NULL) {
|
||||
if (dcl->dpy_refresh != NULL) {
|
||||
ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
|
||||
qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
|
||||
ds->gui_timer = qemu_new_timer_ms(rt_clock, gui_update, ds);
|
||||
qemu_mod_timer(ds->gui_timer, qemu_get_clock_ms(rt_clock));
|
||||
break;
|
||||
}
|
||||
dcl = dcl->next;
|
||||
}
|
||||
if (ds->gui_timer == NULL) {
|
||||
nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
|
||||
qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
|
||||
nographic_timer = qemu_new_timer_ms(rt_clock, nographic_update, NULL);
|
||||
qemu_mod_timer(nographic_timer, qemu_get_clock_ms(rt_clock));
|
||||
}
|
||||
text_consoles_set_display(ds);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user