2 * General purpose implementation of a simple periodic countdown timer.
4 * Copyright (c) 2007 CodeSourcery.
6 * This code is licenced under the GNU LGPL.
9 #include "qemu-timer.h"
10 #include "host-utils.h"
14 int enabled; /* 0 = disabled, 1 = periodic, 2 = oneshot. */
25 /* Use a bottom-half routine to avoid reentrancy issues. */
26 static void ptimer_trigger(ptimer_state *s)
29 qemu_bh_schedule(s->bh);
33 static void ptimer_reload(ptimer_state *s)
39 if (s->delta == 0 || s->period == 0) {
40 fprintf(stderr, "Timer with period zero, disabling\n");
45 s->last_event = s->next_event;
46 s->next_event = s->last_event + s->delta * s->period;
48 s->next_event += ((int64_t)s->period_frac * s->delta) >> 32;
50 qemu_mod_timer(s->timer, s->next_event);
53 static void ptimer_tick(void *opaque)
55 ptimer_state *s = (ptimer_state *)opaque;
58 if (s->enabled == 2) {
65 uint64_t ptimer_get_count(ptimer_state *s)
71 now = qemu_get_clock(vm_clock);
72 /* Figure out the current counter value. */
73 if (now - s->next_event > 0
75 /* Prevent timer underflowing if it should already have
85 /* We need to divide time by period, where time is stored in
86 rem (64-bit integer) and period is stored in period/period_frac
89 Doing full precision division is hard, so scale values and
90 do a 64-bit division. The result should be rounded down,
91 so that the rounding error never causes the timer to go
95 rem = s->next_event - now;
100 shift = clz1 < clz2 ? clz1 : clz2;
105 div |= ((uint64_t)s->period_frac << (shift - 32));
108 div |= (s->period_frac >> (32 - shift));
109 /* Look at remaining bits of period_frac and round div up if
111 if ((uint32_t)(s->period_frac << shift))
122 void ptimer_set_count(ptimer_state *s, uint64_t count)
126 s->next_event = qemu_get_clock(vm_clock);
131 void ptimer_run(ptimer_state *s, int oneshot)
136 if (s->period == 0) {
137 fprintf(stderr, "Timer with period zero, disabling\n");
140 s->enabled = oneshot ? 2 : 1;
141 s->next_event = qemu_get_clock(vm_clock);
145 /* Pause a timer. Note that this may cause it to "lose" time, even if it
146 is immediately restarted. */
147 void ptimer_stop(ptimer_state *s)
152 s->delta = ptimer_get_count(s);
153 qemu_del_timer(s->timer);
157 /* Set counter increment interval in nanoseconds. */
158 void ptimer_set_period(ptimer_state *s, int64_t period)
163 s->next_event = qemu_get_clock(vm_clock);
168 /* Set counter frequency in Hz. */
169 void ptimer_set_freq(ptimer_state *s, uint32_t freq)
171 s->period = 1000000000ll / freq;
172 s->period_frac = (1000000000ll << 32) / freq;
174 s->next_event = qemu_get_clock(vm_clock);
179 /* Set the initial countdown value. If reload is nonzero then also set
181 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
186 if (s->enabled && reload) {
187 s->next_event = qemu_get_clock(vm_clock);
192 void qemu_put_ptimer(QEMUFile *f, ptimer_state *s)
194 qemu_put_byte(f, s->enabled);
195 qemu_put_be64s(f, &s->limit);
196 qemu_put_be64s(f, &s->delta);
197 qemu_put_be32s(f, &s->period_frac);
198 qemu_put_sbe64s(f, &s->period);
199 qemu_put_sbe64s(f, &s->last_event);
200 qemu_put_sbe64s(f, &s->next_event);
201 qemu_put_timer(f, s->timer);
204 void qemu_get_ptimer(QEMUFile *f, ptimer_state *s)
206 s->enabled = qemu_get_byte(f);
207 qemu_get_be64s(f, &s->limit);
208 qemu_get_be64s(f, &s->delta);
209 qemu_get_be32s(f, &s->period_frac);
210 qemu_get_sbe64s(f, &s->period);
211 qemu_get_sbe64s(f, &s->last_event);
212 qemu_get_sbe64s(f, &s->next_event);
213 qemu_get_timer(f, s->timer);
216 ptimer_state *ptimer_init(QEMUBH *bh)
220 s = (ptimer_state *)qemu_mallocz(sizeof(ptimer_state));
222 s->timer = qemu_new_timer(vm_clock, ptimer_tick, s);