sm501: Add missing arbitration control register
[qemu.git] / hw / core / ptimer.c
1 /*
2 * General purpose implementation of a simple periodic countdown timer.
3 *
4 * Copyright (c) 2007 CodeSourcery.
5 *
6 * This code is licensed under the GNU LGPL.
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
21 struct ptimer_state
22 {
23 uint8_t enabled; /* 0 = disabled, 1 = periodic, 2 = oneshot. */
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 /* Use a bottom-half routine to avoid reentrancy issues. */
36 static void ptimer_trigger(ptimer_state *s)
37 {
38 if (s->bh) {
39 replay_bh_schedule_event(s->bh);
40 }
41 }
42
43 static 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
49 if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
50 ptimer_trigger(s);
51 }
52
53 if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
54 delta = s->delta = s->limit;
55 }
56
57 if (s->period == 0) {
58 if (!qtest_enabled()) {
59 fprintf(stderr, "Timer with period zero, disabling\n");
60 }
61 timer_del(s->timer);
62 s->enabled = 0;
63 return;
64 }
65
66 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
67 if (delta_adjust != DELTA_NO_ADJUST) {
68 delta += delta_adjust;
69 }
70 }
71
72 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_CONTINUOUS_TRIGGER)) {
73 if (s->enabled == 1 && s->limit == 0) {
74 delta = 1;
75 }
76 }
77
78 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
79 if (delta_adjust != DELTA_NO_ADJUST) {
80 delta = 1;
81 }
82 }
83
84 if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
85 if (s->enabled == 1 && s->limit != 0) {
86 delta = 1;
87 }
88 }
89
90 if (delta == 0) {
91 if (!qtest_enabled()) {
92 fprintf(stderr, "Timer with delta zero, disabling\n");
93 }
94 timer_del(s->timer);
95 s->enabled = 0;
96 return;
97 }
98
99 /*
100 * Artificially limit timeout rate to something
101 * achievable under QEMU. Otherwise, QEMU spends all
102 * its time generating timer interrupts, and there
103 * is no forward progress.
104 * About ten microseconds is the fastest that really works
105 * on the current generation of host machines.
106 */
107
108 if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
109 period = 10000 / delta;
110 period_frac = 0;
111 }
112
113 s->last_event = s->next_event;
114 s->next_event = s->last_event + delta * period;
115 if (period_frac) {
116 s->next_event += ((int64_t)period_frac * delta) >> 32;
117 }
118 timer_mod(s->timer, s->next_event);
119 }
120
121 static void ptimer_tick(void *opaque)
122 {
123 ptimer_state *s = (ptimer_state *)opaque;
124 bool trigger = true;
125
126 if (s->enabled == 2) {
127 s->delta = 0;
128 s->enabled = 0;
129 } else {
130 int delta_adjust = DELTA_ADJUST;
131
132 if (s->delta == 0 || s->limit == 0) {
133 /* If a "continuous trigger" policy is not used and limit == 0,
134 we should error out. delta == 0 means that this tick is
135 caused by a "no immediate reload" policy, so it shouldn't
136 be adjusted. */
137 delta_adjust = DELTA_NO_ADJUST;
138 }
139
140 if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
141 /* Avoid re-trigger on deferred reload if "no immediate trigger"
142 policy isn't used. */
143 trigger = (delta_adjust == DELTA_ADJUST);
144 }
145
146 s->delta = s->limit;
147
148 ptimer_reload(s, delta_adjust);
149 }
150
151 if (trigger) {
152 ptimer_trigger(s);
153 }
154 }
155
156 uint64_t ptimer_get_count(ptimer_state *s)
157 {
158 uint64_t counter;
159
160 if (s->enabled && s->delta != 0) {
161 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
162 int64_t next = s->next_event;
163 int64_t last = s->last_event;
164 bool expired = (now - next >= 0);
165 bool oneshot = (s->enabled == 2);
166
167 /* Figure out the current counter value. */
168 if (expired) {
169 /* Prevent timer underflowing if it should already have
170 triggered. */
171 counter = 0;
172 } else {
173 uint64_t rem;
174 uint64_t div;
175 int clz1, clz2;
176 int shift;
177 uint32_t period_frac = s->period_frac;
178 uint64_t period = s->period;
179
180 if (!oneshot && (s->delta * period < 10000) && !use_icount) {
181 period = 10000 / s->delta;
182 period_frac = 0;
183 }
184
185 /* We need to divide time by period, where time is stored in
186 rem (64-bit integer) and period is stored in period/period_frac
187 (64.32 fixed point).
188
189 Doing full precision division is hard, so scale values and
190 do a 64-bit division. The result should be rounded down,
191 so that the rounding error never causes the timer to go
192 backwards.
193 */
194
195 rem = next - now;
196 div = period;
197
198 clz1 = clz64(rem);
199 clz2 = clz64(div);
200 shift = clz1 < clz2 ? clz1 : clz2;
201
202 rem <<= shift;
203 div <<= shift;
204 if (shift >= 32) {
205 div |= ((uint64_t)period_frac << (shift - 32));
206 } else {
207 if (shift != 0)
208 div |= (period_frac >> (32 - shift));
209 /* Look at remaining bits of period_frac and round div up if
210 necessary. */
211 if ((uint32_t)(period_frac << shift))
212 div += 1;
213 }
214 counter = rem / div;
215
216 if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
217 /* Before wrapping around, timer should stay with counter = 0
218 for a one period. */
219 if (!oneshot && s->delta == s->limit) {
220 if (now == last) {
221 /* Counter == delta here, check whether it was
222 adjusted and if it was, then right now it is
223 that "one period". */
224 if (counter == s->limit + DELTA_ADJUST) {
225 return 0;
226 }
227 } else if (counter == s->limit) {
228 /* Since the counter is rounded down and now != last,
229 the counter == limit means that delta was adjusted
230 by +1 and right now it is that adjusted period. */
231 return 0;
232 }
233 }
234 }
235 }
236
237 if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
238 /* If now == last then delta == limit, i.e. the counter already
239 represents the correct value. It would be rounded down a 1ns
240 later. */
241 if (now != last) {
242 counter += 1;
243 }
244 }
245 } else {
246 counter = s->delta;
247 }
248 return counter;
249 }
250
251 void ptimer_set_count(ptimer_state *s, uint64_t count)
252 {
253 s->delta = count;
254 if (s->enabled) {
255 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
256 ptimer_reload(s, 0);
257 }
258 }
259
260 void ptimer_run(ptimer_state *s, int oneshot)
261 {
262 bool was_disabled = !s->enabled;
263
264 if (was_disabled && s->period == 0) {
265 if (!qtest_enabled()) {
266 fprintf(stderr, "Timer with period zero, disabling\n");
267 }
268 return;
269 }
270 s->enabled = oneshot ? 2 : 1;
271 if (was_disabled) {
272 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
273 ptimer_reload(s, 0);
274 }
275 }
276
277 /* Pause a timer. Note that this may cause it to "lose" time, even if it
278 is immediately restarted. */
279 void ptimer_stop(ptimer_state *s)
280 {
281 if (!s->enabled)
282 return;
283
284 s->delta = ptimer_get_count(s);
285 timer_del(s->timer);
286 s->enabled = 0;
287 }
288
289 /* Set counter increment interval in nanoseconds. */
290 void ptimer_set_period(ptimer_state *s, int64_t period)
291 {
292 s->delta = ptimer_get_count(s);
293 s->period = period;
294 s->period_frac = 0;
295 if (s->enabled) {
296 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
297 ptimer_reload(s, 0);
298 }
299 }
300
301 /* Set counter frequency in Hz. */
302 void ptimer_set_freq(ptimer_state *s, uint32_t freq)
303 {
304 s->delta = ptimer_get_count(s);
305 s->period = 1000000000ll / freq;
306 s->period_frac = (1000000000ll << 32) / freq;
307 if (s->enabled) {
308 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
309 ptimer_reload(s, 0);
310 }
311 }
312
313 /* Set the initial countdown value. If reload is nonzero then also set
314 count = limit. */
315 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
316 {
317 s->limit = limit;
318 if (reload)
319 s->delta = limit;
320 if (s->enabled && reload) {
321 s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
322 ptimer_reload(s, 0);
323 }
324 }
325
326 uint64_t ptimer_get_limit(ptimer_state *s)
327 {
328 return s->limit;
329 }
330
331 const VMStateDescription vmstate_ptimer = {
332 .name = "ptimer",
333 .version_id = 1,
334 .minimum_version_id = 1,
335 .fields = (VMStateField[]) {
336 VMSTATE_UINT8(enabled, ptimer_state),
337 VMSTATE_UINT64(limit, ptimer_state),
338 VMSTATE_UINT64(delta, ptimer_state),
339 VMSTATE_UINT32(period_frac, ptimer_state),
340 VMSTATE_INT64(period, ptimer_state),
341 VMSTATE_INT64(last_event, ptimer_state),
342 VMSTATE_INT64(next_event, ptimer_state),
343 VMSTATE_TIMER_PTR(timer, ptimer_state),
344 VMSTATE_END_OF_LIST()
345 }
346 };
347
348 ptimer_state *ptimer_init(QEMUBH *bh, uint8_t policy_mask)
349 {
350 ptimer_state *s;
351
352 s = (ptimer_state *)g_malloc0(sizeof(ptimer_state));
353 s->bh = bh;
354 s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
355 s->policy_mask = policy_mask;
356 return s;
357 }
358
359 void ptimer_free(ptimer_state *s)
360 {
361 qemu_bh_delete(s->bh);
362 timer_free(s->timer);
363 g_free(s);
364 }