1
2
3
4
5
6
7
8#include "qemu/osdep.h"
9#include "hw/hw.h"
10#include "qemu/timer.h"
11#include "hw/ptimer.h"
12#include "qemu/host-utils.h"
13#include "sysemu/replay.h"
14#include "sysemu/qtest.h"
15#include "block/aio.h"
16#include "sysemu/cpus.h"
17
18#define DELTA_ADJUST 1
19#define DELTA_NO_ADJUST -1
20
21struct ptimer_state
22{
23 uint8_t enabled;
24 uint64_t limit;
25 uint64_t delta;
26 uint32_t period_frac;
27 int64_t period;
28 int64_t last_event;
29 int64_t next_event;
30 uint8_t policy_mask;
31 QEMUBH *bh;
32 QEMUTimer *timer;
33};
34
35
36static void ptimer_trigger(ptimer_state *s)
37{
38 if (s->bh) {
39 replay_bh_schedule_event(s->bh);
40 }
41}
42
43static void ptimer_reload(ptimer_state *s, int delta_adjust)
44{
45 uint32_t period_frac = s->period_frac;
46 uint64_t period = s->period;
47 uint64_t delta = s->delta;
48 bool suppress_trigger = false;
49
50
51
52
53
54
55
56 if (delta_adjust == 0 &&
57 (s->policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT)) {
58 suppress_trigger = true;
59 }
60 if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)
61 && !suppress_trigger) {
62 ptimer_trigger(s);
63 }
64
65 if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
66 delta = s->delta = s->limit;
67 }
68
69 if (s->period == 0) {
70 if (!qtest_enabled()) {
71 fprintf(stderr, "Timer with period zero, disabling\n");
72 }
73 timer_del(s->timer);
74 s->enabled = 0;
75 return;
76 }
77
78 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
79 if (delta_adjust != DELTA_NO_ADJUST) {
80 delta += delta_adjust;
81 }
82 }
83
84 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_CONTINUOUS_TRIGGER)) {
85 if (s->enabled == 1 && s->limit == 0) {
86 delta = 1;
87 }
88 }
89
90 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
91 if (delta_adjust != DELTA_NO_ADJUST) {
92 delta = 1;
93 }
94 }
95
96 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
97 if (s->enabled == 1 && s->limit != 0) {
98 delta = 1;
99 }
100 }
101
102 if (delta == 0) {
103 if (!qtest_enabled()) {
104 fprintf(stderr, "Timer with delta zero, disabling\n");
105 }
106 timer_del(s->timer);
107 s->enabled = 0;
108 return;
109 }
110
111
112
113
114
115
116
117
118
119
120 if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
121 period = 10000 / delta;
122 period_frac = 0;
123 }
124
125 s->last_event = s->next_event;
126 s->next_event = s->last_event + delta * period;
127 if (period_frac) {
128 s->next_event += ((int64_t)period_frac * delta) >> 32;
129 }
130 timer_mod(s->timer, s->next_event);
131}
132
133static void ptimer_tick(void *opaque)
134{
135 ptimer_state *s = (ptimer_state *)opaque;
136 bool trigger = true;
137
138 if (s->enabled == 2) {
139 s->delta = 0;
140 s->enabled = 0;
141 } else {
142 int delta_adjust = DELTA_ADJUST;
143
144 if (s->delta == 0 || s->limit == 0) {
145
146
147
148
149 delta_adjust = DELTA_NO_ADJUST;
150 }
151
152 if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
153
154
155 trigger = (delta_adjust == DELTA_ADJUST);
156 }
157
158 s->delta = s->limit;
159
160 ptimer_reload(s, delta_adjust);
161 }
162
163 if (trigger) {
164 ptimer_trigger(s);
165 }
166}
167
168uint64_t ptimer_get_count(ptimer_state *s)
169{
170 uint64_t counter;
171
172 if (s->enabled && s->delta != 0) {
173 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
174 int64_t next = s->next_event;
175 int64_t last = s->last_event;
176 bool expired = (now - next >= 0);
177 bool oneshot = (s->enabled == 2);
178
179
180 if (expired) {
181
182
183 counter = 0;
184 } else {
185 uint64_t rem;
186 uint64_t div;
187 int clz1, clz2;
188 int shift;
189 uint32_t period_frac = s->period_frac;
190 uint64_t period = s->period;
191
192 if (!oneshot && (s->delta * period < 10000) && !use_icount) {
193 period = 10000 / s->delta;
194 period_frac = 0;
195 }
196
197
198
199
200
201
202
203
204
205
206
207 rem = next - now;
208 div = period;
209
210 clz1 = clz64(rem);
211 clz2 = clz64(div);
212 shift = clz1 < clz2 ? clz1 : clz2;
213
214 rem <<= shift;
215 div <<= shift;
216 if (shift >= 32) {
217 div |= ((uint64_t)period_frac << (shift - 32));
218 } else {
219 if (shift != 0)
220 div |= (period_frac >> (32 - shift));
221
222
223 if ((uint32_t)(period_frac << shift))
224 div += 1;
225 }
226 counter = rem / div;
227
228 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
229
230
231 if (!oneshot && s->delta == s->limit) {
232 if (now == last) {
233
234
235
236 if (counter == s->limit + DELTA_ADJUST) {
237 return 0;
238 }
239 } else if (counter == s->limit) {
240
241
242
243 return 0;
244 }
245 }
246 }
247 }
248
249 if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
250
251
252
253 if (now != last) {
254 counter += 1;
255 }
256 }
257 } else {
258 counter = s->delta;
259 }
260 return counter;
261}
262
263void ptimer_set_count(ptimer_state *s, uint64_t count)
264{
265 s->delta = count;
266 if (s->enabled) {
267 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
268 ptimer_reload(s, 0);
269 }
270}
271
272void ptimer_run(ptimer_state *s, int oneshot)
273{
274 bool was_disabled = !s->enabled;
275
276 if (was_disabled && s->period == 0) {
277 if (!qtest_enabled()) {
278 fprintf(stderr, "Timer with period zero, disabling\n");
279 }
280 return;
281 }
282 s->enabled = oneshot ? 2 : 1;
283 if (was_disabled) {
284 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
285 ptimer_reload(s, 0);
286 }
287}
288
289
290
291void ptimer_stop(ptimer_state *s)
292{
293 if (!s->enabled)
294 return;
295
296 s->delta = ptimer_get_count(s);
297 timer_del(s->timer);
298 s->enabled = 0;
299}
300
301
302void ptimer_set_period(ptimer_state *s, int64_t period)
303{
304 s->delta = ptimer_get_count(s);
305 s->period = period;
306 s->period_frac = 0;
307 if (s->enabled) {
308 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
309 ptimer_reload(s, 0);
310 }
311}
312
313
314void ptimer_set_freq(ptimer_state *s, uint32_t freq)
315{
316 s->delta = ptimer_get_count(s);
317 s->period = 1000000000ll / freq;
318 s->period_frac = (1000000000ll << 32) / freq;
319 if (s->enabled) {
320 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
321 ptimer_reload(s, 0);
322 }
323}
324
325
326
327void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
328{
329 s->limit = limit;
330 if (reload)
331 s->delta = limit;
332 if (s->enabled && reload) {
333 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
334 ptimer_reload(s, 0);
335 }
336}
337
338uint64_t ptimer_get_limit(ptimer_state *s)
339{
340 return s->limit;
341}
342
343const VMStateDescription vmstate_ptimer = {
344 .name = "ptimer",
345 .version_id = 1,
346 .minimum_version_id = 1,
347 .fields = (VMStateField[]) {
348 VMSTATE_UINT8(enabled, ptimer_state),
349 VMSTATE_UINT64(limit, ptimer_state),
350 VMSTATE_UINT64(delta, ptimer_state),
351 VMSTATE_UINT32(period_frac, ptimer_state),
352 VMSTATE_INT64(period, ptimer_state),
353 VMSTATE_INT64(last_event, ptimer_state),
354 VMSTATE_INT64(next_event, ptimer_state),
355 VMSTATE_TIMER_PTR(timer, ptimer_state),
356 VMSTATE_END_OF_LIST()
357 }
358};
359
360ptimer_state *ptimer_init(QEMUBH *bh, uint8_t policy_mask)
361{
362 ptimer_state *s;
363
364 s = (ptimer_state *)g_malloc0(sizeof(ptimer_state));
365 s->bh = bh;
366 s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
367 s->policy_mask = policy_mask;
368
369
370
371
372
373
374 assert(!((policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT) &&
375 (policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)));
376 return s;
377}
378
379void ptimer_free(ptimer_state *s)
380{
381 qemu_bh_delete(s->bh);
382 timer_free(s->timer);
383 g_free(s);
384}
385