2 * linux/arch/ia64/kernel/time.c
4 * Copyright (C) 1998-2003 Hewlett-Packard Co
5 * Stephane Eranian <eranian@hpl.hp.com>
6 * David Mosberger <davidm@hpl.hp.com>
7 * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
8 * Copyright (C) 1999-2000 VA Linux Systems
9 * Copyright (C) 1999-2000 Walt Drummond <drummond@valinux.com>
12 #include <linux/cpu.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/profile.h>
17 #include <linux/sched.h>
18 #include <linux/time.h>
19 #include <linux/interrupt.h>
20 #include <linux/efi.h>
21 #include <linux/profile.h>
22 #include <linux/timex.h>
24 #include <asm/machvec.h>
25 #include <asm/delay.h>
26 #include <asm/hw_irq.h>
27 #include <asm/ptrace.h>
29 #include <asm/sections.h>
30 #include <asm/system.h>
32 volatile int time_keeper_id
= 0; /* smp_processor_id() of time-keeper */
34 #ifdef CONFIG_IA64_DEBUG_IRQ
36 unsigned long last_cli_ip
;
37 EXPORT_SYMBOL(last_cli_ip
);
41 static struct time_interpolator itc_interpolator
= {
43 .mask
= 0xffffffffffffffffLL
,
44 .source
= TIME_SOURCE_CPU
48 timer_interrupt (int irq
, void *dev_id
)
50 unsigned long new_itm
;
52 if (unlikely(cpu_is_offline(smp_processor_id()))) {
56 platform_timer_interrupt(irq
, dev_id
);
58 new_itm
= local_cpu_data
->itm_next
;
60 if (!time_after(ia64_get_itc(), new_itm
))
61 printk(KERN_ERR
"Oops: timer tick before it's due (itc=%lx,itm=%lx)\n",
62 ia64_get_itc(), new_itm
);
64 profile_tick(CPU_PROFILING
);
67 update_process_times(user_mode(get_irq_regs()));
69 new_itm
+= local_cpu_data
->itm_delta
;
71 if (smp_processor_id() == time_keeper_id
) {
73 * Here we are in the timer irq handler. We have irqs locally
74 * disabled, but we don't know if the timer_bh is running on
75 * another CPU. We need to avoid to SMP race by acquiring the
78 write_seqlock(&xtime_lock
);
80 local_cpu_data
->itm_next
= new_itm
;
81 write_sequnlock(&xtime_lock
);
83 local_cpu_data
->itm_next
= new_itm
;
85 if (time_after(new_itm
, ia64_get_itc()))
91 * If we're too close to the next clock tick for
92 * comfort, we increase the safety margin by
93 * intentionally dropping the next tick(s). We do NOT
94 * update itm.next because that would force us to call
95 * do_timer() which in turn would let our clock run
96 * too fast (with the potentially devastating effect
97 * of losing monotony of time).
99 while (!time_after(new_itm
, ia64_get_itc() + local_cpu_data
->itm_delta
/2))
100 new_itm
+= local_cpu_data
->itm_delta
;
101 ia64_set_itm(new_itm
);
102 /* double check, in case we got hit by a (slow) PMI: */
103 } while (time_after_eq(ia64_get_itc(), new_itm
));
108 * Encapsulate access to the itm structure for SMP.
111 ia64_cpu_local_tick (void)
113 int cpu
= smp_processor_id();
114 unsigned long shift
= 0, delta
;
116 /* arrange for the cycle counter to generate a timer interrupt: */
117 ia64_set_itv(IA64_TIMER_VECTOR
);
119 delta
= local_cpu_data
->itm_delta
;
121 * Stagger the timer tick for each CPU so they don't occur all at (almost) the
125 unsigned long hi
= 1UL << ia64_fls(cpu
);
126 shift
= (2*(cpu
- hi
) + 1) * delta
/hi
/2;
128 local_cpu_data
->itm_next
= ia64_get_itc() + delta
+ shift
;
129 ia64_set_itm(local_cpu_data
->itm_next
);
134 static int __init
nojitter_setup(char *str
)
137 printk("Jitter checking for ITC timers disabled\n");
141 __setup("nojitter", nojitter_setup
);
147 unsigned long platform_base_freq
, itc_freq
;
148 struct pal_freq_ratio itc_ratio
, proc_ratio
;
149 long status
, platform_base_drift
, itc_drift
;
152 * According to SAL v2.6, we need to use a SAL call to determine the platform base
153 * frequency and then a PAL call to determine the frequency ratio between the ITC
154 * and the base frequency.
156 status
= ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM
,
157 &platform_base_freq
, &platform_base_drift
);
159 printk(KERN_ERR
"SAL_FREQ_BASE_PLATFORM failed: %s\n", ia64_sal_strerror(status
));
161 status
= ia64_pal_freq_ratios(&proc_ratio
, NULL
, &itc_ratio
);
163 printk(KERN_ERR
"PAL_FREQ_RATIOS failed with status=%ld\n", status
);
166 /* invent "random" values */
168 "SAL/PAL failed to obtain frequency info---inventing reasonable values\n");
169 platform_base_freq
= 100000000;
170 platform_base_drift
= -1; /* no drift info */
174 if (platform_base_freq
< 40000000) {
175 printk(KERN_ERR
"Platform base frequency %lu bogus---resetting to 75MHz!\n",
177 platform_base_freq
= 75000000;
178 platform_base_drift
= -1;
181 proc_ratio
.den
= 1; /* avoid division by zero */
183 itc_ratio
.den
= 1; /* avoid division by zero */
185 itc_freq
= (platform_base_freq
*itc_ratio
.num
)/itc_ratio
.den
;
187 local_cpu_data
->itm_delta
= (itc_freq
+ HZ
/2) / HZ
;
188 printk(KERN_DEBUG
"CPU %d: base freq=%lu.%03luMHz, ITC ratio=%u/%u, "
189 "ITC freq=%lu.%03luMHz", smp_processor_id(),
190 platform_base_freq
/ 1000000, (platform_base_freq
/ 1000) % 1000,
191 itc_ratio
.num
, itc_ratio
.den
, itc_freq
/ 1000000, (itc_freq
/ 1000) % 1000);
193 if (platform_base_drift
!= -1) {
194 itc_drift
= platform_base_drift
*itc_ratio
.num
/itc_ratio
.den
;
195 printk("+/-%ldppm\n", itc_drift
);
201 local_cpu_data
->proc_freq
= (platform_base_freq
*proc_ratio
.num
)/proc_ratio
.den
;
202 local_cpu_data
->itc_freq
= itc_freq
;
203 local_cpu_data
->cyc_per_usec
= (itc_freq
+ USEC_PER_SEC
/2) / USEC_PER_SEC
;
204 local_cpu_data
->nsec_per_cyc
= ((NSEC_PER_SEC
<<IA64_NSEC_PER_CYC_SHIFT
)
205 + itc_freq
/2)/itc_freq
;
207 if (!(sal_platform_features
& IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT
)) {
208 itc_interpolator
.frequency
= local_cpu_data
->itc_freq
;
209 itc_interpolator
.drift
= itc_drift
;
211 /* On IA64 in an SMP configuration ITCs are never accurately synchronized.
212 * Jitter compensation requires a cmpxchg which may limit
213 * the scalability of the syscalls for retrieving time.
214 * The ITC synchronization is usually successful to within a few
215 * ITC ticks but this is not a sure thing. If you need to improve
216 * timer performance in SMP situations then boot the kernel with the
217 * "nojitter" option. However, doing so may result in time fluctuating (maybe
218 * even going backward) if the ITC offsets between the individual CPUs
221 if (!nojitter
) itc_interpolator
.jitter
= 1;
223 register_time_interpolator(&itc_interpolator
);
226 /* Setup the CPU local timer tick */
227 ia64_cpu_local_tick();
230 static struct irqaction timer_irqaction
= {
231 .handler
= timer_interrupt
,
232 .flags
= IRQF_DISABLED
,
236 void __devinit
ia64_disable_timer(void)
238 ia64_set_itv(1 << 16);
244 register_percpu_irq(IA64_TIMER_VECTOR
, &timer_irqaction
);
245 efi_gettimeofday(&xtime
);
249 * Initialize wall_to_monotonic such that adding it to xtime will yield zero, the
250 * tv_nsec field must be normalized (i.e., 0 <= nsec < NSEC_PER_SEC).
252 set_normalized_timespec(&wall_to_monotonic
, -xtime
.tv_sec
, -xtime
.tv_nsec
);
256 * Generic udelay assumes that if preemption is allowed and the thread
257 * migrates to another CPU, that the ITC values are synchronized across
261 ia64_itc_udelay (unsigned long usecs
)
263 unsigned long start
= ia64_get_itc();
264 unsigned long end
= start
+ usecs
*local_cpu_data
->cyc_per_usec
;
266 while (time_before(ia64_get_itc(), end
))
270 void (*ia64_udelay
)(unsigned long usecs
) = &ia64_itc_udelay
;
273 udelay (unsigned long usecs
)
275 (*ia64_udelay
)(usecs
);
277 EXPORT_SYMBOL(udelay
);
279 static unsigned long long ia64_itc_printk_clock(void)
281 if (ia64_get_kr(IA64_KR_PER_CPU_DATA
))
282 return sched_clock();
286 static unsigned long long ia64_default_printk_clock(void)
288 return (unsigned long long)(jiffies_64
- INITIAL_JIFFIES
) *
292 unsigned long long (*ia64_printk_clock
)(void) = &ia64_default_printk_clock
;
294 unsigned long long printk_clock(void)
296 return ia64_printk_clock();
300 ia64_setup_printk_clock(void)
302 if (!(sal_platform_features
& IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT
))
303 ia64_printk_clock
= ia64_itc_printk_clock
;