1
2
3
4
5
6
7
8
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 "hw/clock.h"
18
19#define DELTA_ADJUST 1
20#define DELTA_NO_ADJUST -1
21
22struct ptimer_state
23{
24 uint8_t enabled;
25 uint64_t limit;
26 uint64_t delta;
27 uint32_t period_frac;
28 int64_t period;
29 int64_t last_event;
30 int64_t next_event;
31 uint8_t policy_mask;
32 QEMUTimer *timer;
33 ptimer_cb callback;
34 void *callback_opaque;
35
36
37
38
39
40
41 bool in_transaction;
42 bool need_reload;
43};
44
45
46static void ptimer_trigger(ptimer_state *s)
47{
48 s->callback(s->callback_opaque);
49}
50
51static void ptimer_reload(ptimer_state *s, int delta_adjust)
52{
53 uint32_t period_frac;
54 uint64_t period;
55 uint64_t delta;
56 bool suppress_trigger = false;
57
58
59
60
61
62
63
64 if (delta_adjust == 0 &&
65 (s->policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT)) {
66 suppress_trigger = true;
67 }
68 if (s->delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)
69 && !suppress_trigger) {
70 ptimer_trigger(s);
71 }
72
73
74
75
76
77
78 delta = s->delta;
79 period = s->period;
80 period_frac = s->period_frac;
81
82 if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
83 delta = s->delta = s->limit;
84 }
85
86 if (s->period == 0) {
87 if (!qtest_enabled()) {
88 fprintf(stderr, "Timer with period zero, disabling\n");
89 }
90 timer_del(s->timer);
91 s->enabled = 0;
92 return;
93 }
94
95 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
96 if (delta_adjust != DELTA_NO_ADJUST) {
97 delta += delta_adjust;
98 }
99 }
100
101 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_CONTINUOUS_TRIGGER)) {
102 if (s->enabled == 1 && s->limit == 0) {
103 delta = 1;
104 }
105 }
106
107 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
108 if (delta_adjust != DELTA_NO_ADJUST) {
109 delta = 1;
110 }
111 }
112
113 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
114 if (s->enabled == 1 && s->limit != 0) {
115 delta = 1;
116 }
117 }
118
119 if (delta == 0) {
120 if (s->enabled == 0) {
121
122 return;
123 }
124 if (!qtest_enabled()) {
125 fprintf(stderr, "Timer with delta zero, disabling\n");
126 }
127 timer_del(s->timer);
128 s->enabled = 0;
129 return;
130 }
131
132
133
134
135
136
137
138
139
140
141 if (s->enabled == 1 && (delta * period < 10000) &&
142 !icount_enabled() && !qtest_enabled()) {
143 period = 10000 / delta;
144 period_frac = 0;
145 }
146
147 s->last_event = s->next_event;
148 s->next_event = s->last_event + delta * period;
149 if (period_frac) {
150 s->next_event += ((int64_t)period_frac * delta) >> 32;
151 }
152 timer_mod(s->timer, s->next_event);
153}
154
155static void ptimer_tick(void *opaque)
156{
157 ptimer_state *s = (ptimer_state *)opaque;
158 bool trigger = true;
159
160
161
162
163
164
165
166
167 ptimer_transaction_begin(s);
168
169 if (s->enabled == 2) {
170 s->delta = 0;
171 s->enabled = 0;
172 } else {
173 int delta_adjust = DELTA_ADJUST;
174
175 if (s->delta == 0 || s->limit == 0) {
176
177
178
179
180 delta_adjust = DELTA_NO_ADJUST;
181 }
182
183 if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
184
185
186 trigger = (delta_adjust == DELTA_ADJUST);
187 }
188
189 s->delta = s->limit;
190
191 ptimer_reload(s, delta_adjust);
192 }
193
194 if (trigger) {
195 ptimer_trigger(s);
196 }
197
198 ptimer_transaction_commit(s);
199}
200
201uint64_t ptimer_get_count(ptimer_state *s)
202{
203 uint64_t counter;
204
205 if (s->enabled && s->delta != 0) {
206 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
207 int64_t next = s->next_event;
208 int64_t last = s->last_event;
209 bool expired = (now - next >= 0);
210 bool oneshot = (s->enabled == 2);
211
212
213 if (expired) {
214
215
216 counter = 0;
217 } else {
218 uint64_t rem;
219 uint64_t div;
220 int clz1, clz2;
221 int shift;
222 uint32_t period_frac = s->period_frac;
223 uint64_t period = s->period;
224
225 if (!oneshot && (s->delta * period < 10000) &&
226 !icount_enabled() && !qtest_enabled()) {
227 period = 10000 / s->delta;
228 period_frac = 0;
229 }
230
231
232
233
234
235
236
237
238
239
240
241 rem = next - now;
242 div = period;
243
244 clz1 = clz64(rem);
245 clz2 = clz64(div);
246 shift = clz1 < clz2 ? clz1 : clz2;
247
248 rem <<= shift;
249 div <<= shift;
250 if (shift >= 32) {
251 div |= ((uint64_t)period_frac << (shift - 32));
252 } else {
253 if (shift != 0)
254 div |= (period_frac >> (32 - shift));
255
256
257 if ((uint32_t)(period_frac << shift))
258 div += 1;
259 }
260 counter = rem / div;
261
262 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
263
264
265 if (!oneshot && s->delta == s->limit) {
266 if (now == last) {
267
268
269
270 if (counter == s->limit + DELTA_ADJUST) {
271 return 0;
272 }
273 } else if (counter == s->limit) {
274
275
276
277 return 0;
278 }
279 }
280 }
281 }
282
283 if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
284
285
286
287 if (now != last) {
288 counter += 1;
289 }
290 }
291 } else {
292 counter = s->delta;
293 }
294 return counter;
295}
296
297void ptimer_set_count(ptimer_state *s, uint64_t count)
298{
299 assert(s->in_transaction);
300 s->delta = count;
301 if (s->enabled) {
302 s->need_reload = true;
303 }
304}
305
306void ptimer_run(ptimer_state *s, int oneshot)
307{
308 bool was_disabled = !s->enabled;
309
310 assert(s->in_transaction);
311
312 if (was_disabled && s->period == 0) {
313 if (!qtest_enabled()) {
314 fprintf(stderr, "Timer with period zero, disabling\n");
315 }
316 return;
317 }
318 s->enabled = oneshot ? 2 : 1;
319 if (was_disabled) {
320 s->need_reload = true;
321 }
322}
323
324
325
326void ptimer_stop(ptimer_state *s)
327{
328 assert(s->in_transaction);
329
330 if (!s->enabled)
331 return;
332
333 s->delta = ptimer_get_count(s);
334 timer_del(s->timer);
335 s->enabled = 0;
336 s->need_reload = false;
337}
338
339
340void ptimer_set_period(ptimer_state *s, int64_t period)
341{
342 assert(s->in_transaction);
343 s->delta = ptimer_get_count(s);
344 s->period = period;
345 s->period_frac = 0;
346 if (s->enabled) {
347 s->need_reload = true;
348 }
349}
350
351
352void ptimer_set_period_from_clock(ptimer_state *s, const Clock *clk,
353 unsigned int divisor)
354{
355
356
357
358
359
360
361 uint64_t raw_period = clock_get(clk);
362 uint64_t period_frac;
363
364 assert(s->in_transaction);
365 s->delta = ptimer_get_count(s);
366 s->period = extract64(raw_period, 32, 32);
367 period_frac = extract64(raw_period, 0, 32);
368
369
370
371
372
373
374 s->period *= divisor;
375 period_frac *= divisor;
376 s->period += extract64(period_frac, 32, 32);
377 s->period_frac = (uint32_t)period_frac;
378
379 if (s->enabled) {
380 s->need_reload = true;
381 }
382}
383
384
385void ptimer_set_freq(ptimer_state *s, uint32_t freq)
386{
387 assert(s->in_transaction);
388 s->delta = ptimer_get_count(s);
389 s->period = 1000000000ll / freq;
390 s->period_frac = (1000000000ll << 32) / freq;
391 if (s->enabled) {
392 s->need_reload = true;
393 }
394}
395
396
397
398void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
399{
400 assert(s->in_transaction);
401 s->limit = limit;
402 if (reload)
403 s->delta = limit;
404 if (s->enabled && reload) {
405 s->need_reload = true;
406 }
407}
408
409uint64_t ptimer_get_limit(ptimer_state *s)
410{
411 return s->limit;
412}
413
414void ptimer_transaction_begin(ptimer_state *s)
415{
416 assert(!s->in_transaction);
417 s->in_transaction = true;
418 s->need_reload = false;
419}
420
421void ptimer_transaction_commit(ptimer_state *s)
422{
423 assert(s->in_transaction);
424
425
426
427
428
429
430
431 while (s->need_reload && s->enabled) {
432 s->need_reload = false;
433 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
434 ptimer_reload(s, 0);
435 }
436
437 s->in_transaction = false;
438}
439
440const VMStateDescription vmstate_ptimer = {
441 .name = "ptimer",
442 .version_id = 1,
443 .minimum_version_id = 1,
444 .fields = (VMStateField[]) {
445 VMSTATE_UINT8(enabled, ptimer_state),
446 VMSTATE_UINT64(limit, ptimer_state),
447 VMSTATE_UINT64(delta, ptimer_state),
448 VMSTATE_UINT32(period_frac, ptimer_state),
449 VMSTATE_INT64(period, ptimer_state),
450 VMSTATE_INT64(last_event, ptimer_state),
451 VMSTATE_INT64(next_event, ptimer_state),
452 VMSTATE_TIMER_PTR(timer, ptimer_state),
453 VMSTATE_END_OF_LIST()
454 }
455};
456
457ptimer_state *ptimer_init(ptimer_cb callback, void *callback_opaque,
458 uint8_t policy_mask)
459{
460 ptimer_state *s;
461
462
463 assert(callback);
464
465 s = g_new0(ptimer_state, 1);
466 s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
467 s->policy_mask = policy_mask;
468 s->callback = callback;
469 s->callback_opaque = callback_opaque;
470
471
472
473
474
475
476 assert(!((policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT) &&
477 (policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)));
478 return s;
479}
480
481void ptimer_free(ptimer_state *s)
482{
483 timer_free(s->timer);
484 g_free(s);
485}
486