2 * General purpose implementation of a simple periodic countdown timer.
4 * Copyright (c) 2007 CodeSourcery.
6 * This code is licensed under the GNU LGPL.
9 #include "qemu/osdep.h"
10 #include "hw/ptimer.h"
11 #include "migration/vmstate.h"
12 #include "qemu/host-utils.h"
13 #include "sysemu/replay.h"
14 #include "sysemu/cpu-timers.h"
15 #include "sysemu/qtest.h"
16 #include "block/aio.h"
17 #include "sysemu/cpus.h"
19 #define DELTA_ADJUST 1
20 #define DELTA_NO_ADJUST -1
24 uint8_t enabled
; /* 0 = disabled, 1 = periodic, 2 = oneshot. */
34 void *callback_opaque
;
36 * These track whether we're in a transaction block, and if we
37 * need to do a timer reload when the block finishes. They don't
38 * need to be migrated because migration can never happen in the
39 * middle of a transaction block.
45 /* Use a bottom-half routine to avoid reentrancy issues. */
46 static void ptimer_trigger(ptimer_state
*s
)
48 s
->callback(s
->callback_opaque
);
51 static void ptimer_reload(ptimer_state
*s
, int delta_adjust
)
56 bool suppress_trigger
= false;
59 * Note that if delta_adjust is 0 then we must be here because of
60 * a count register write or timer start, not because of timer expiry.
61 * In that case the policy might require us to suppress the timer trigger
62 * that we would otherwise generate for a zero delta.
64 if (delta_adjust
== 0 &&
65 (s
->policy_mask
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
)) {
66 suppress_trigger
= true;
68 if (s
->delta
== 0 && !(s
->policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
)
69 && !suppress_trigger
) {
74 * Note that ptimer_trigger() might call the device callback function,
75 * which can then modify timer state, so we must not cache any fields
76 * from ptimer_state until after we have called it.
80 period_frac
= s
->period_frac
;
82 if (delta
== 0 && !(s
->policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_RELOAD
)) {
83 delta
= s
->delta
= s
->limit
;
87 if (!qtest_enabled()) {
88 fprintf(stderr
, "Timer with period zero, disabling\n");
95 if (s
->policy_mask
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
) {
96 if (delta_adjust
!= DELTA_NO_ADJUST
) {
97 delta
+= delta_adjust
;
101 if (delta
== 0 && (s
->policy_mask
& PTIMER_POLICY_CONTINUOUS_TRIGGER
)) {
102 if (s
->enabled
== 1 && s
->limit
== 0) {
107 if (delta
== 0 && (s
->policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
)) {
108 if (delta_adjust
!= DELTA_NO_ADJUST
) {
113 if (delta
== 0 && (s
->policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_RELOAD
)) {
114 if (s
->enabled
== 1 && s
->limit
!= 0) {
120 if (!qtest_enabled()) {
121 fprintf(stderr
, "Timer with delta zero, disabling\n");
129 * Artificially limit timeout rate to something
130 * achievable under QEMU. Otherwise, QEMU spends all
131 * its time generating timer interrupts, and there
132 * is no forward progress.
133 * About ten microseconds is the fastest that really works
134 * on the current generation of host machines.
137 if (s
->enabled
== 1 && (delta
* period
< 10000) &&
138 !icount_enabled() && !qtest_enabled()) {
139 period
= 10000 / delta
;
143 s
->last_event
= s
->next_event
;
144 s
->next_event
= s
->last_event
+ delta
* period
;
146 s
->next_event
+= ((int64_t)period_frac
* delta
) >> 32;
148 timer_mod(s
->timer
, s
->next_event
);
151 static void ptimer_tick(void *opaque
)
153 ptimer_state
*s
= (ptimer_state
*)opaque
;
157 * We perform all the tick actions within a begin/commit block
158 * because the callback function that ptimer_trigger() calls
159 * might make calls into the ptimer APIs that provoke another
160 * trigger, and we want that to cause the callback function
161 * to be called iteratively, not recursively.
163 ptimer_transaction_begin(s
);
165 if (s
->enabled
== 2) {
169 int delta_adjust
= DELTA_ADJUST
;
171 if (s
->delta
== 0 || s
->limit
== 0) {
172 /* If a "continuous trigger" policy is not used and limit == 0,
173 we should error out. delta == 0 means that this tick is
174 caused by a "no immediate reload" policy, so it shouldn't
176 delta_adjust
= DELTA_NO_ADJUST
;
179 if (!(s
->policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
)) {
180 /* Avoid re-trigger on deferred reload if "no immediate trigger"
181 policy isn't used. */
182 trigger
= (delta_adjust
== DELTA_ADJUST
);
187 ptimer_reload(s
, delta_adjust
);
194 ptimer_transaction_commit(s
);
197 uint64_t ptimer_get_count(ptimer_state
*s
)
201 if (s
->enabled
&& s
->delta
!= 0) {
202 int64_t now
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
203 int64_t next
= s
->next_event
;
204 int64_t last
= s
->last_event
;
205 bool expired
= (now
- next
>= 0);
206 bool oneshot
= (s
->enabled
== 2);
208 /* Figure out the current counter value. */
210 /* Prevent timer underflowing if it should already have
218 uint32_t period_frac
= s
->period_frac
;
219 uint64_t period
= s
->period
;
221 if (!oneshot
&& (s
->delta
* period
< 10000) &&
222 !icount_enabled() && !qtest_enabled()) {
223 period
= 10000 / s
->delta
;
227 /* We need to divide time by period, where time is stored in
228 rem (64-bit integer) and period is stored in period/period_frac
231 Doing full precision division is hard, so scale values and
232 do a 64-bit division. The result should be rounded down,
233 so that the rounding error never causes the timer to go
242 shift
= clz1
< clz2
? clz1
: clz2
;
247 div
|= ((uint64_t)period_frac
<< (shift
- 32));
250 div
|= (period_frac
>> (32 - shift
));
251 /* Look at remaining bits of period_frac and round div up if
253 if ((uint32_t)(period_frac
<< shift
))
258 if (s
->policy_mask
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
) {
259 /* Before wrapping around, timer should stay with counter = 0
261 if (!oneshot
&& s
->delta
== s
->limit
) {
263 /* Counter == delta here, check whether it was
264 adjusted and if it was, then right now it is
265 that "one period". */
266 if (counter
== s
->limit
+ DELTA_ADJUST
) {
269 } else if (counter
== s
->limit
) {
270 /* Since the counter is rounded down and now != last,
271 the counter == limit means that delta was adjusted
272 by +1 and right now it is that adjusted period. */
279 if (s
->policy_mask
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
) {
280 /* If now == last then delta == limit, i.e. the counter already
281 represents the correct value. It would be rounded down a 1ns
293 void ptimer_set_count(ptimer_state
*s
, uint64_t count
)
295 assert(s
->in_transaction
);
298 s
->need_reload
= true;
302 void ptimer_run(ptimer_state
*s
, int oneshot
)
304 bool was_disabled
= !s
->enabled
;
306 assert(s
->in_transaction
);
308 if (was_disabled
&& s
->period
== 0) {
309 if (!qtest_enabled()) {
310 fprintf(stderr
, "Timer with period zero, disabling\n");
314 s
->enabled
= oneshot
? 2 : 1;
316 s
->need_reload
= true;
320 /* Pause a timer. Note that this may cause it to "lose" time, even if it
321 is immediately restarted. */
322 void ptimer_stop(ptimer_state
*s
)
324 assert(s
->in_transaction
);
329 s
->delta
= ptimer_get_count(s
);
332 s
->need_reload
= false;
335 /* Set counter increment interval in nanoseconds. */
336 void ptimer_set_period(ptimer_state
*s
, int64_t period
)
338 assert(s
->in_transaction
);
339 s
->delta
= ptimer_get_count(s
);
343 s
->need_reload
= true;
347 /* Set counter frequency in Hz. */
348 void ptimer_set_freq(ptimer_state
*s
, uint32_t freq
)
350 assert(s
->in_transaction
);
351 s
->delta
= ptimer_get_count(s
);
352 s
->period
= 1000000000ll / freq
;
353 s
->period_frac
= (1000000000ll << 32) / freq
;
355 s
->need_reload
= true;
359 /* Set the initial countdown value. If reload is nonzero then also set
361 void ptimer_set_limit(ptimer_state
*s
, uint64_t limit
, int reload
)
363 assert(s
->in_transaction
);
367 if (s
->enabled
&& reload
) {
368 s
->need_reload
= true;
372 uint64_t ptimer_get_limit(ptimer_state
*s
)
377 void ptimer_transaction_begin(ptimer_state
*s
)
379 assert(!s
->in_transaction
);
380 s
->in_transaction
= true;
381 s
->need_reload
= false;
384 void ptimer_transaction_commit(ptimer_state
*s
)
386 assert(s
->in_transaction
);
388 * We must loop here because ptimer_reload() can call the callback
389 * function, which might then update ptimer state in a way that
390 * means we need to do another reload and possibly another callback.
391 * A disabled timer never needs reloading (and if we don't check
392 * this then we loop forever if ptimer_reload() disables the timer).
394 while (s
->need_reload
&& s
->enabled
) {
395 s
->need_reload
= false;
396 s
->next_event
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
399 /* Now we've finished reload we can leave the transaction block. */
400 s
->in_transaction
= false;
403 const VMStateDescription vmstate_ptimer
= {
406 .minimum_version_id
= 1,
407 .fields
= (VMStateField
[]) {
408 VMSTATE_UINT8(enabled
, ptimer_state
),
409 VMSTATE_UINT64(limit
, ptimer_state
),
410 VMSTATE_UINT64(delta
, ptimer_state
),
411 VMSTATE_UINT32(period_frac
, ptimer_state
),
412 VMSTATE_INT64(period
, ptimer_state
),
413 VMSTATE_INT64(last_event
, ptimer_state
),
414 VMSTATE_INT64(next_event
, ptimer_state
),
415 VMSTATE_TIMER_PTR(timer
, ptimer_state
),
416 VMSTATE_END_OF_LIST()
420 ptimer_state
*ptimer_init(ptimer_cb callback
, void *callback_opaque
,
425 /* The callback function is mandatory. */
428 s
= g_new0(ptimer_state
, 1);
429 s
->timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, ptimer_tick
, s
);
430 s
->policy_mask
= policy_mask
;
431 s
->callback
= callback
;
432 s
->callback_opaque
= callback_opaque
;
435 * These two policies are incompatible -- trigger-on-decrement implies
436 * a timer trigger when the count becomes 0, but no-immediate-trigger
437 * implies a trigger when the count stops being 0.
439 assert(!((policy_mask
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
) &&
440 (policy_mask
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
)));
444 void ptimer_free(ptimer_state
*s
)
446 timer_free(s
->timer
);