target-arm: Pass fp status pointer explicitly to neon fp helpers
[qemu.git] / qemu-timer.h
blob06cbe20914900f12bbd5390246af93790b3cd398
1 #ifndef QEMU_TIMER_H
2 #define QEMU_TIMER_H
4 #include "qemu-common.h"
5 #include <time.h>
6 #include <sys/time.h>
8 #ifdef _WIN32
9 #include <windows.h>
10 #endif
12 /* timers */
14 #define SCALE_MS 1000000
15 #define SCALE_US 1000
16 #define SCALE_NS 1
18 typedef struct QEMUClock QEMUClock;
19 typedef void QEMUTimerCB(void *opaque);
21 /* The real time clock should be used only for stuff which does not
22 change the virtual machine state, as it is run even if the virtual
23 machine is stopped. The real time clock has a frequency of 1000
24 Hz. */
25 extern QEMUClock *rt_clock;
27 /* The virtual clock is only run during the emulation. It is stopped
28 when the virtual machine is stopped. Virtual timers use a high
29 precision clock, usually cpu cycles (use ticks_per_sec). */
30 extern QEMUClock *vm_clock;
32 /* The host clock should be use for device models that emulate accurate
33 real time sources. It will continue to run when the virtual machine
34 is suspended, and it will reflect system time changes the host may
35 undergo (e.g. due to NTP). The host clock has the same precision as
36 the virtual clock. */
37 extern QEMUClock *host_clock;
39 int64_t qemu_get_clock_ns(QEMUClock *clock);
40 void qemu_clock_enable(QEMUClock *clock, int enabled);
41 void qemu_clock_warp(QEMUClock *clock);
43 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
44 QEMUTimerCB *cb, void *opaque);
45 void qemu_free_timer(QEMUTimer *ts);
46 void qemu_del_timer(QEMUTimer *ts);
47 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
48 int qemu_timer_pending(QEMUTimer *ts);
49 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
51 void qemu_run_all_timers(void);
52 int qemu_alarm_pending(void);
53 int64_t qemu_next_icount_deadline(void);
54 void configure_alarms(char const *opt);
55 void configure_icount(const char *option);
56 int qemu_calculate_timeout(void);
57 void init_clocks(void);
58 int init_timer_alarm(void);
59 void quit_timers(void);
61 int64_t cpu_get_ticks(void);
62 void cpu_enable_ticks(void);
63 void cpu_disable_ticks(void);
65 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
66 void *opaque)
68 return qemu_new_timer(clock, SCALE_NS, cb, opaque);
71 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
72 void *opaque)
74 return qemu_new_timer(clock, SCALE_MS, cb, opaque);
77 static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
79 return qemu_get_clock_ns(clock) / SCALE_MS;
82 static inline int64_t get_ticks_per_sec(void)
84 return 1000000000LL;
87 /* real time host monotonic timer */
88 static inline int64_t get_clock_realtime(void)
90 struct timeval tv;
92 gettimeofday(&tv, NULL);
93 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
96 /* Warning: don't insert tracepoints into these functions, they are
97 also used by simpletrace backend and tracepoints would cause
98 an infinite recursion! */
99 #ifdef _WIN32
100 extern int64_t clock_freq;
102 static inline int64_t get_clock(void)
104 LARGE_INTEGER ti;
105 QueryPerformanceCounter(&ti);
106 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
109 #else
111 extern int use_rt_clock;
113 static inline int64_t get_clock(void)
115 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
116 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
117 if (use_rt_clock) {
118 struct timespec ts;
119 clock_gettime(CLOCK_MONOTONIC, &ts);
120 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
121 } else
122 #endif
124 /* XXX: using gettimeofday leads to problems if the date
125 changes, so it should be avoided. */
126 return get_clock_realtime();
129 #endif
131 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
132 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
134 /* ptimer.c */
135 typedef struct ptimer_state ptimer_state;
136 typedef void (*ptimer_cb)(void *opaque);
138 ptimer_state *ptimer_init(QEMUBH *bh);
139 void ptimer_set_period(ptimer_state *s, int64_t period);
140 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
141 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
142 uint64_t ptimer_get_count(ptimer_state *s);
143 void ptimer_set_count(ptimer_state *s, uint64_t count);
144 void ptimer_run(ptimer_state *s, int oneshot);
145 void ptimer_stop(ptimer_state *s);
147 /* icount */
148 int64_t qemu_icount_round(int64_t count);
149 extern int64_t qemu_icount;
150 extern int use_icount;
151 extern int icount_time_shift;
152 extern int64_t qemu_icount_bias;
153 int64_t cpu_get_icount(void);
155 /*******************************************/
156 /* host CPU ticks (if available) */
158 #if defined(_ARCH_PPC)
160 static inline int64_t cpu_get_real_ticks(void)
162 int64_t retval;
163 #ifdef _ARCH_PPC64
164 /* This reads timebase in one 64bit go and includes Cell workaround from:
165 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
167 __asm__ __volatile__ ("mftb %0\n\t"
168 "cmpwi %0,0\n\t"
169 "beq- $-8"
170 : "=r" (retval));
171 #else
172 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
173 unsigned long junk;
174 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
175 "mfspr %L0,268\n\t" /* mftb */
176 "mfspr %0,269\n\t" /* mftbu */
177 "cmpw %0,%1\n\t"
178 "bne $-16"
179 : "=r" (retval), "=r" (junk));
180 #endif
181 return retval;
184 #elif defined(__i386__)
186 static inline int64_t cpu_get_real_ticks(void)
188 int64_t val;
189 asm volatile ("rdtsc" : "=A" (val));
190 return val;
193 #elif defined(__x86_64__)
195 static inline int64_t cpu_get_real_ticks(void)
197 uint32_t low,high;
198 int64_t val;
199 asm volatile("rdtsc" : "=a" (low), "=d" (high));
200 val = high;
201 val <<= 32;
202 val |= low;
203 return val;
206 #elif defined(__hppa__)
208 static inline int64_t cpu_get_real_ticks(void)
210 int val;
211 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
212 return val;
215 #elif defined(__ia64)
217 static inline int64_t cpu_get_real_ticks(void)
219 int64_t val;
220 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
221 return val;
224 #elif defined(__s390__)
226 static inline int64_t cpu_get_real_ticks(void)
228 int64_t val;
229 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
230 return val;
233 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
235 static inline int64_t cpu_get_real_ticks (void)
237 #if defined(_LP64)
238 uint64_t rval;
239 asm volatile("rd %%tick,%0" : "=r"(rval));
240 return rval;
241 #else
242 union {
243 uint64_t i64;
244 struct {
245 uint32_t high;
246 uint32_t low;
247 } i32;
248 } rval;
249 asm volatile("rd %%tick,%1; srlx %1,32,%0"
250 : "=r"(rval.i32.high), "=r"(rval.i32.low));
251 return rval.i64;
252 #endif
255 #elif defined(__mips__) && \
256 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
258 * binutils wants to use rdhwr only on mips32r2
259 * but as linux kernel emulate it, it's fine
260 * to use it.
263 #define MIPS_RDHWR(rd, value) { \
264 __asm__ __volatile__ (".set push\n\t" \
265 ".set mips32r2\n\t" \
266 "rdhwr %0, "rd"\n\t" \
267 ".set pop" \
268 : "=r" (value)); \
271 static inline int64_t cpu_get_real_ticks(void)
273 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
274 uint32_t count;
275 static uint32_t cyc_per_count = 0;
277 if (!cyc_per_count) {
278 MIPS_RDHWR("$3", cyc_per_count);
281 MIPS_RDHWR("$2", count);
282 return (int64_t)(count * cyc_per_count);
285 #elif defined(__alpha__)
287 static inline int64_t cpu_get_real_ticks(void)
289 uint64_t cc;
290 uint32_t cur, ofs;
292 asm volatile("rpcc %0" : "=r"(cc));
293 cur = cc;
294 ofs = cc >> 32;
295 return cur - ofs;
298 #else
299 /* The host CPU doesn't have an easily accessible cycle counter.
300 Just return a monotonically increasing value. This will be
301 totally wrong, but hopefully better than nothing. */
302 static inline int64_t cpu_get_real_ticks (void)
304 static int64_t ticks = 0;
305 return ticks++;
307 #endif
309 #ifdef NEED_CPU_H
310 /* Deterministic execution requires that IO only be performed on the last
311 instruction of a TB so that interrupts take effect immediately. */
312 static inline int can_do_io(CPUState *env)
314 if (!use_icount)
315 return 1;
317 /* If not executing code then assume we are ok. */
318 if (!env->current_tb)
319 return 1;
321 return env->can_do_io != 0;
323 #endif
325 #ifdef CONFIG_PROFILER
326 static inline int64_t profile_getclock(void)
328 return cpu_get_real_ticks();
331 extern int64_t qemu_time, qemu_time_start;
332 extern int64_t tlb_flush_time;
333 extern int64_t dev_time;
334 #endif
336 #endif