linux-user/arm/nwfpe: rename REG_PC to ARM_REG_PC
[qemu.git] / qemu-timer.h
blob2cacf655356a5977ac4ab073da65d962e1b38199
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 #include <mmsystem.h>
11 #endif
13 /* timers */
15 #define SCALE_MS 1000000
16 #define SCALE_US 1000
17 #define SCALE_NS 1
19 typedef struct QEMUClock QEMUClock;
20 typedef void QEMUTimerCB(void *opaque);
22 /* The real time clock should be used only for stuff which does not
23 change the virtual machine state, as it is run even if the virtual
24 machine is stopped. The real time clock has a frequency of 1000
25 Hz. */
26 extern QEMUClock *rt_clock;
28 /* The virtual clock is only run during the emulation. It is stopped
29 when the virtual machine is stopped. Virtual timers use a high
30 precision clock, usually cpu cycles (use ticks_per_sec). */
31 extern QEMUClock *vm_clock;
33 /* The host clock should be use for device models that emulate accurate
34 real time sources. It will continue to run when the virtual machine
35 is suspended, and it will reflect system time changes the host may
36 undergo (e.g. due to NTP). The host clock has the same precision as
37 the virtual clock. */
38 extern QEMUClock *host_clock;
40 int64_t qemu_get_clock_ns(QEMUClock *clock);
41 void qemu_clock_enable(QEMUClock *clock, int enabled);
42 void qemu_clock_warp(QEMUClock *clock);
44 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
45 QEMUTimerCB *cb, void *opaque);
46 void qemu_free_timer(QEMUTimer *ts);
47 void qemu_del_timer(QEMUTimer *ts);
48 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
49 int qemu_timer_pending(QEMUTimer *ts);
50 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
52 void qemu_run_all_timers(void);
53 int qemu_alarm_pending(void);
54 int64_t qemu_next_icount_deadline(void);
55 void configure_alarms(char const *opt);
56 void configure_icount(const char *option);
57 int qemu_calculate_timeout(void);
58 void init_clocks(void);
59 int init_timer_alarm(void);
60 void quit_timers(void);
62 int64_t cpu_get_ticks(void);
63 void cpu_enable_ticks(void);
64 void cpu_disable_ticks(void);
66 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
67 void *opaque)
69 return qemu_new_timer(clock, SCALE_NS, cb, opaque);
72 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
73 void *opaque)
75 return qemu_new_timer(clock, SCALE_MS, cb, opaque);
78 static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
80 return qemu_get_clock_ns(clock) / SCALE_MS;
83 static inline int64_t get_ticks_per_sec(void)
85 return 1000000000LL;
88 /* real time host monotonic timer */
89 static inline int64_t get_clock_realtime(void)
91 struct timeval tv;
93 gettimeofday(&tv, NULL);
94 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
97 /* Warning: don't insert tracepoints into these functions, they are
98 also used by simpletrace backend and tracepoints would cause
99 an infinite recursion! */
100 #ifdef _WIN32
101 extern int64_t clock_freq;
103 static inline int64_t get_clock(void)
105 LARGE_INTEGER ti;
106 QueryPerformanceCounter(&ti);
107 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
110 #else
112 extern int use_rt_clock;
114 static inline int64_t get_clock(void)
116 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
117 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
118 if (use_rt_clock) {
119 struct timespec ts;
120 clock_gettime(CLOCK_MONOTONIC, &ts);
121 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
122 } else
123 #endif
125 /* XXX: using gettimeofday leads to problems if the date
126 changes, so it should be avoided. */
127 return get_clock_realtime();
130 #endif
132 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
133 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
135 /* ptimer.c */
136 typedef struct ptimer_state ptimer_state;
137 typedef void (*ptimer_cb)(void *opaque);
139 ptimer_state *ptimer_init(QEMUBH *bh);
140 void ptimer_set_period(ptimer_state *s, int64_t period);
141 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
142 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
143 uint64_t ptimer_get_count(ptimer_state *s);
144 void ptimer_set_count(ptimer_state *s, uint64_t count);
145 void ptimer_run(ptimer_state *s, int oneshot);
146 void ptimer_stop(ptimer_state *s);
148 /* icount */
149 int64_t qemu_icount_round(int64_t count);
150 extern int64_t qemu_icount;
151 extern int use_icount;
152 extern int icount_time_shift;
153 extern int64_t qemu_icount_bias;
154 int64_t cpu_get_icount(void);
156 /*******************************************/
157 /* host CPU ticks (if available) */
159 #if defined(_ARCH_PPC)
161 static inline int64_t cpu_get_real_ticks(void)
163 int64_t retval;
164 #ifdef _ARCH_PPC64
165 /* This reads timebase in one 64bit go and includes Cell workaround from:
166 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
168 __asm__ __volatile__ ("mftb %0\n\t"
169 "cmpwi %0,0\n\t"
170 "beq- $-8"
171 : "=r" (retval));
172 #else
173 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
174 unsigned long junk;
175 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
176 "mfspr %L0,268\n\t" /* mftb */
177 "mfspr %0,269\n\t" /* mftbu */
178 "cmpw %0,%1\n\t"
179 "bne $-16"
180 : "=r" (retval), "=r" (junk));
181 #endif
182 return retval;
185 #elif defined(__i386__)
187 static inline int64_t cpu_get_real_ticks(void)
189 int64_t val;
190 asm volatile ("rdtsc" : "=A" (val));
191 return val;
194 #elif defined(__x86_64__)
196 static inline int64_t cpu_get_real_ticks(void)
198 uint32_t low,high;
199 int64_t val;
200 asm volatile("rdtsc" : "=a" (low), "=d" (high));
201 val = high;
202 val <<= 32;
203 val |= low;
204 return val;
207 #elif defined(__hppa__)
209 static inline int64_t cpu_get_real_ticks(void)
211 int val;
212 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
213 return val;
216 #elif defined(__ia64)
218 static inline int64_t cpu_get_real_ticks(void)
220 int64_t val;
221 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
222 return val;
225 #elif defined(__s390__)
227 static inline int64_t cpu_get_real_ticks(void)
229 int64_t val;
230 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
231 return val;
234 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
236 static inline int64_t cpu_get_real_ticks (void)
238 #if defined(_LP64)
239 uint64_t rval;
240 asm volatile("rd %%tick,%0" : "=r"(rval));
241 return rval;
242 #else
243 union {
244 uint64_t i64;
245 struct {
246 uint32_t high;
247 uint32_t low;
248 } i32;
249 } rval;
250 asm volatile("rd %%tick,%1; srlx %1,32,%0"
251 : "=r"(rval.i32.high), "=r"(rval.i32.low));
252 return rval.i64;
253 #endif
256 #elif defined(__mips__) && \
257 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
259 * binutils wants to use rdhwr only on mips32r2
260 * but as linux kernel emulate it, it's fine
261 * to use it.
264 #define MIPS_RDHWR(rd, value) { \
265 __asm__ __volatile__ (".set push\n\t" \
266 ".set mips32r2\n\t" \
267 "rdhwr %0, "rd"\n\t" \
268 ".set pop" \
269 : "=r" (value)); \
272 static inline int64_t cpu_get_real_ticks(void)
274 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
275 uint32_t count;
276 static uint32_t cyc_per_count = 0;
278 if (!cyc_per_count) {
279 MIPS_RDHWR("$3", cyc_per_count);
282 MIPS_RDHWR("$2", count);
283 return (int64_t)(count * cyc_per_count);
286 #elif defined(__alpha__)
288 static inline int64_t cpu_get_real_ticks(void)
290 uint64_t cc;
291 uint32_t cur, ofs;
293 asm volatile("rpcc %0" : "=r"(cc));
294 cur = cc;
295 ofs = cc >> 32;
296 return cur - ofs;
299 #else
300 /* The host CPU doesn't have an easily accessible cycle counter.
301 Just return a monotonically increasing value. This will be
302 totally wrong, but hopefully better than nothing. */
303 static inline int64_t cpu_get_real_ticks (void)
305 static int64_t ticks = 0;
306 return ticks++;
308 #endif
310 #ifdef NEED_CPU_H
311 /* Deterministic execution requires that IO only be performed on the last
312 instruction of a TB so that interrupts take effect immediately. */
313 static inline int can_do_io(CPUState *env)
315 if (!use_icount)
316 return 1;
318 /* If not executing code then assume we are ok. */
319 if (!env->current_tb)
320 return 1;
322 return env->can_do_io != 0;
324 #endif
326 #ifdef CONFIG_PROFILER
327 static inline int64_t profile_getclock(void)
329 return cpu_get_real_ticks();
332 extern int64_t qemu_time, qemu_time_start;
333 extern int64_t tlb_flush_time;
334 extern int64_t dev_time;
335 #endif
337 #endif