2 * General purpose implementation of a simple periodic countdown timer.
4 * Copyright (c) 2007 CodeSourcery.
6 * This code is licensed under the GNU LGPL.
8 #include "qemu/osdep.h"
10 #include "qemu/timer.h"
11 #include "hw/ptimer.h"
12 #include "qemu/host-utils.h"
13 #include "sysemu/replay.h"
17 uint8_t enabled
; /* 0 = disabled, 1 = periodic, 2 = oneshot. */
28 /* Use a bottom-half routine to avoid reentrancy issues. */
29 static void ptimer_trigger(ptimer_state
*s
)
32 replay_bh_schedule_event(s
->bh
);
36 static void ptimer_reload(ptimer_state
*s
)
42 if (s
->delta
== 0 || s
->period
== 0) {
43 fprintf(stderr
, "Timer with period zero, disabling\n");
48 s
->last_event
= s
->next_event
;
49 s
->next_event
= s
->last_event
+ s
->delta
* s
->period
;
51 s
->next_event
+= ((int64_t)s
->period_frac
* s
->delta
) >> 32;
53 timer_mod(s
->timer
, s
->next_event
);
56 static void ptimer_tick(void *opaque
)
58 ptimer_state
*s
= (ptimer_state
*)opaque
;
61 if (s
->enabled
== 2) {
68 uint64_t ptimer_get_count(ptimer_state
*s
)
74 now
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
75 /* Figure out the current counter value. */
76 if (now
- s
->next_event
> 0
78 /* Prevent timer underflowing if it should already have
87 /* We need to divide time by period, where time is stored in
88 rem (64-bit integer) and period is stored in period/period_frac
91 Doing full precision division is hard, so scale values and
92 do a 64-bit division. The result should be rounded down,
93 so that the rounding error never causes the timer to go
97 rem
= s
->next_event
- now
;
102 shift
= clz1
< clz2
? clz1
: clz2
;
107 div
|= ((uint64_t)s
->period_frac
<< (shift
- 32));
110 div
|= (s
->period_frac
>> (32 - shift
));
111 /* Look at remaining bits of period_frac and round div up if
113 if ((uint32_t)(s
->period_frac
<< shift
))
124 void ptimer_set_count(ptimer_state
*s
, uint64_t count
)
128 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
133 void ptimer_run(ptimer_state
*s
, int oneshot
)
138 if (s
->period
== 0) {
139 fprintf(stderr
, "Timer with period zero, disabling\n");
142 s
->enabled
= oneshot
? 2 : 1;
143 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
147 /* Pause a timer. Note that this may cause it to "lose" time, even if it
148 is immediately restarted. */
149 void ptimer_stop(ptimer_state
*s
)
154 s
->delta
= ptimer_get_count(s
);
159 /* Set counter increment interval in nanoseconds. */
160 void ptimer_set_period(ptimer_state
*s
, int64_t period
)
165 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
170 /* Set counter frequency in Hz. */
171 void ptimer_set_freq(ptimer_state
*s
, uint32_t freq
)
173 s
->period
= 1000000000ll / freq
;
174 s
->period_frac
= (1000000000ll << 32) / freq
;
176 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
181 /* Set the initial countdown value. If reload is nonzero then also set
183 void ptimer_set_limit(ptimer_state
*s
, uint64_t limit
, int reload
)
186 * Artificially limit timeout rate to something
187 * achievable under QEMU. Otherwise, QEMU spends all
188 * its time generating timer interrupts, and there
189 * is no forward progress.
190 * About ten microseconds is the fastest that really works
191 * on the current generation of host machines.
194 if (!use_icount
&& limit
* s
->period
< 10000 && s
->period
) {
195 limit
= 10000 / s
->period
;
201 if (s
->enabled
&& reload
) {
202 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
207 const VMStateDescription vmstate_ptimer
= {
210 .minimum_version_id
= 1,
211 .fields
= (VMStateField
[]) {
212 VMSTATE_UINT8(enabled
, ptimer_state
),
213 VMSTATE_UINT64(limit
, ptimer_state
),
214 VMSTATE_UINT64(delta
, ptimer_state
),
215 VMSTATE_UINT32(period_frac
, ptimer_state
),
216 VMSTATE_INT64(period
, ptimer_state
),
217 VMSTATE_INT64(last_event
, ptimer_state
),
218 VMSTATE_INT64(next_event
, ptimer_state
),
219 VMSTATE_TIMER_PTR(timer
, ptimer_state
),
220 VMSTATE_END_OF_LIST()
224 ptimer_state
*ptimer_init(QEMUBH
*bh
)
228 s
= (ptimer_state
*)g_malloc0(sizeof(ptimer_state
));
230 s
->timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, ptimer_tick
, s
);