1
2
3
4
5
6
7
8
9#include "qemu/osdep.h"
10#include "qemu/timer.h"
11#include "hw/ptimer.h"
12#include "migration/vmstate.h"
13#include "qemu/host-utils.h"
14#include "sysemu/replay.h"
15#include "sysemu/qtest.h"
16#include "block/aio.h"
17#include "sysemu/cpus.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 (!qtest_enabled()) {
121 fprintf(stderr, "Timer with delta zero, disabling\n");
122 }
123 timer_del(s->timer);
124 s->enabled = 0;
125 return;
126 }
127
128
129
130
131
132
133
134
135
136
137 if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
138 period = 10000 / delta;
139 period_frac = 0;
140 }
141
142 s->last_event = s->next_event;
143 s->next_event = s->last_event + delta * period;
144 if (period_frac) {
145 s->next_event += ((int64_t)period_frac * delta) >> 32;
146 }
147 timer_mod(s->timer, s->next_event);
148}
149
150static void ptimer_tick(void *opaque)
151{
152 ptimer_state *s = (ptimer_state *)opaque;
153 bool trigger = true;
154
155
156
157
158
159
160
161
162 ptimer_transaction_begin(s);
163
164 if (s->enabled == 2) {
165 s->delta = 0;
166 s->enabled = 0;
167 } else {
168 int delta_adjust = DELTA_ADJUST;
169
170 if (s->delta == 0 || s->limit == 0) {
171
172
173
174
175 delta_adjust = DELTA_NO_ADJUST;
176 }
177
178 if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
179
180
181 trigger = (delta_adjust == DELTA_ADJUST);
182 }
183
184 s->delta = s->limit;
185
186 ptimer_reload(s, delta_adjust);
187 }
188
189 if (trigger) {
190 ptimer_trigger(s);
191 }
192
193 ptimer_transaction_commit(s);
194}
195
196uint64_t ptimer_get_count(ptimer_state *s)
197{
198 uint64_t counter;
199
200 if (s->enabled && s->delta != 0) {
201 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
202 int64_t next = s->next_event;
203 int64_t last = s->last_event;
204 bool expired = (now - next >= 0);
205 bool oneshot = (s->enabled == 2);
206
207
208 if (expired) {
209
210
211 counter = 0;
212 } else {
213 uint64_t rem;
214 uint64_t div;
215 int clz1, clz2;
216 int shift;
217 uint32_t period_frac = s->period_frac;
218 uint64_t period = s->period;
219
220 if (!oneshot && (s->delta * period < 10000) && !use_icount) {
221 period = 10000 / s->delta;
222 period_frac = 0;
223 }
224
225
226
227
228
229
230
231
232
233
234
235 rem = next - now;
236 div = period;
237
238 clz1 = clz64(rem);
239 clz2 = clz64(div);
240 shift = clz1 < clz2 ? clz1 : clz2;
241
242 rem <<= shift;
243 div <<= shift;
244 if (shift >= 32) {
245 div |= ((uint64_t)period_frac << (shift - 32));
246 } else {
247 if (shift != 0)
248 div |= (period_frac >> (32 - shift));
249
250
251 if ((uint32_t)(period_frac << shift))
252 div += 1;
253 }
254 counter = rem / div;
255
256 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
257
258
259 if (!oneshot && s->delta == s->limit) {
260 if (now == last) {
261
262
263
264 if (counter == s->limit + DELTA_ADJUST) {
265 return 0;
266 }
267 } else if (counter == s->limit) {
268
269
270
271 return 0;
272 }
273 }
274 }
275 }
276
277 if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
278
279
280
281 if (now != last) {
282 counter += 1;
283 }
284 }
285 } else {
286 counter = s->delta;
287 }
288 return counter;
289}
290
291void ptimer_set_count(ptimer_state *s, uint64_t count)
292{
293 assert(s->in_transaction);
294 s->delta = count;
295 if (s->enabled) {
296 s->need_reload = true;
297 }
298}
299
300void ptimer_run(ptimer_state *s, int oneshot)
301{
302 bool was_disabled = !s->enabled;
303
304 assert(s->in_transaction);
305
306 if (was_disabled && s->period == 0) {
307 if (!qtest_enabled()) {
308 fprintf(stderr, "Timer with period zero, disabling\n");
309 }
310 return;
311 }
312 s->enabled = oneshot ? 2 : 1;
313 if (was_disabled) {
314 s->need_reload = true;
315 }
316}
317
318
319
320void ptimer_stop(ptimer_state *s)
321{
322 assert(s->in_transaction);
323
324 if (!s->enabled)
325 return;
326
327 s->delta = ptimer_get_count(s);
328 timer_del(s->timer);
329 s->enabled = 0;
330 s->need_reload = false;
331}
332
333
334void ptimer_set_period(ptimer_state *s, int64_t period)
335{
336 assert(s->in_transaction);
337 s->delta = ptimer_get_count(s);
338 s->period = period;
339 s->period_frac = 0;
340 if (s->enabled) {
341 s->need_reload = true;
342 }
343}
344
345
346void ptimer_set_freq(ptimer_state *s, uint32_t freq)
347{
348 assert(s->in_transaction);
349 s->delta = ptimer_get_count(s);
350 s->period = 1000000000ll / freq;
351 s->period_frac = (1000000000ll << 32) / freq;
352 if (s->enabled) {
353 s->need_reload = true;
354 }
355}
356
357
358
359void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
360{
361 assert(s->in_transaction);
362 s->limit = limit;
363 if (reload)
364 s->delta = limit;
365 if (s->enabled && reload) {
366 s->need_reload = true;
367 }
368}
369
370uint64_t ptimer_get_limit(ptimer_state *s)
371{
372 return s->limit;
373}
374
375void ptimer_transaction_begin(ptimer_state *s)
376{
377 assert(!s->in_transaction);
378 s->in_transaction = true;
379 s->need_reload = false;
380}
381
382void ptimer_transaction_commit(ptimer_state *s)
383{
384 assert(s->in_transaction);
385
386
387
388
389
390
391
392 while (s->need_reload && s->enabled) {
393 s->need_reload = false;
394 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
395 ptimer_reload(s, 0);
396 }
397
398 s->in_transaction = false;
399}
400
401const VMStateDescription vmstate_ptimer = {
402 .name = "ptimer",
403 .version_id = 1,
404 .minimum_version_id = 1,
405 .fields = (VMStateField[]) {
406 VMSTATE_UINT8(enabled, ptimer_state),
407 VMSTATE_UINT64(limit, ptimer_state),
408 VMSTATE_UINT64(delta, ptimer_state),
409 VMSTATE_UINT32(period_frac, ptimer_state),
410 VMSTATE_INT64(period, ptimer_state),
411 VMSTATE_INT64(last_event, ptimer_state),
412 VMSTATE_INT64(next_event, ptimer_state),
413 VMSTATE_TIMER_PTR(timer, ptimer_state),
414 VMSTATE_END_OF_LIST()
415 }
416};
417
418ptimer_state *ptimer_init(ptimer_cb callback, void *callback_opaque,
419 uint8_t policy_mask)
420{
421 ptimer_state *s;
422
423
424 assert(callback);
425
426 s = g_new0(ptimer_state, 1);
427 s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
428 s->policy_mask = policy_mask;
429 s->callback = callback;
430 s->callback_opaque = callback_opaque;
431
432
433
434
435
436
437 assert(!((policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT) &&
438 (policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)));
439 return s;
440}
441
442void ptimer_free(ptimer_state *s)
443{
444 timer_free(s->timer);
445 g_free(s);
446}
447