2 * linux/arch/i386/kernel/time_hpet.c
3 * This code largely copied from arch/x86_64/kernel/time.c
4 * See that file for credits.
6 * 2003-06-30 Venkatesh Pallipadi - Additional changes for HPET support
9 #include <linux/errno.h>
10 #include <linux/kernel.h>
11 #include <linux/param.h>
12 #include <linux/string.h>
13 #include <linux/init.h>
14 #include <linux/smp.h>
16 #include <asm/timer.h>
17 #include <asm/fixmap.h>
20 #include <linux/timex.h>
21 #include <linux/config.h>
24 #include <linux/hpet.h>
26 unsigned long hpet_period; /* fsecs / HPET clock */
27 unsigned long hpet_tick; /* hpet clks count per tick */
28 unsigned long hpet_address; /* hpet memory map physical address */
30 static int use_hpet; /* can be used for runtime check of hpet */
31 static int boot_hpet_disable; /* boottime override for HPET timer */
32 static void __iomem * hpet_virt_address; /* hpet kernel virtual address */
34 #define FSEC_TO_USEC (1000000000UL)
36 int hpet_readl(unsigned long a)
38 return readl(hpet_virt_address + a);
41 void hpet_writel(unsigned long d, unsigned long a)
43 writel(d, hpet_virt_address + a);
46 #ifdef CONFIG_X86_LOCAL_APIC
48 * HPET counters dont wrap around on every tick. They just change the
49 * comparator value and continue. Next tick can be caught by checking
50 * for a change in the comparator value. Used in apic.c.
52 void __init wait_hpet_tick(void)
54 unsigned int start_cmp_val, end_cmp_val;
56 start_cmp_val = hpet_readl(HPET_T0_CMP);
58 end_cmp_val = hpet_readl(HPET_T0_CMP);
59 } while (start_cmp_val == end_cmp_val);
63 static int hpet_timer_stop_set_go(unsigned long tick)
68 * Stop the timers and reset the main counter.
70 cfg = hpet_readl(HPET_CFG);
71 cfg &= ~HPET_CFG_ENABLE;
72 hpet_writel(cfg, HPET_CFG);
73 hpet_writel(0, HPET_COUNTER);
74 hpet_writel(0, HPET_COUNTER + 4);
77 * Set up timer 0, as periodic with first interrupt to happen at
78 * hpet_tick, and period also hpet_tick.
80 cfg = hpet_readl(HPET_T0_CFG);
81 cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC |
82 HPET_TN_SETVAL | HPET_TN_32BIT;
83 hpet_writel(cfg, HPET_T0_CFG);
84 hpet_writel(tick, HPET_T0_CMP);
89 cfg = hpet_readl(HPET_CFG);
90 cfg |= HPET_CFG_ENABLE | HPET_CFG_LEGACY;
91 hpet_writel(cfg, HPET_CFG);
97 * Check whether HPET was found by ACPI boot parse. If yes setup HPET
98 * counter 0 for kernel base timer.
100 int __init hpet_enable(void)
103 unsigned long tick_fsec_low, tick_fsec_high; /* tick in femto sec */
104 unsigned long hpet_tick_rem;
106 if (boot_hpet_disable)
112 hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
114 * Read the period, compute tick and quotient.
116 id = hpet_readl(HPET_ID);
119 * We are checking for value '1' or more in number field.
120 * So, we are OK with HPET_EMULATE_RTC part too, where we need
121 * to have atleast 2 timers.
123 if (!(id & HPET_ID_NUMBER) ||
124 !(id & HPET_ID_LEGSUP))
127 hpet_period = hpet_readl(HPET_PERIOD);
128 if ((hpet_period < HPET_MIN_PERIOD) || (hpet_period > HPET_MAX_PERIOD))
133 * First changing tick into fsec
134 * Then 64 bit div to find number of hpet clk per tick
136 ASM_MUL64_REG(tick_fsec_low, tick_fsec_high,
137 KERNEL_TICK_USEC, FSEC_TO_USEC);
138 ASM_DIV64_REG(hpet_tick, hpet_tick_rem,
139 hpet_period, tick_fsec_low, tick_fsec_high);
141 if (hpet_tick_rem > (hpet_period >> 1))
142 hpet_tick++; /* rounding the result */
144 if (hpet_timer_stop_set_go(hpet_tick))
154 memset(&hd, 0, sizeof (hd));
156 ntimer = hpet_readl(HPET_ID);
157 ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
161 * Register with driver.
162 * Timer0 and Timer1 is used by platform.
164 hd.hd_phys_address = hpet_address;
165 hd.hd_address = hpet_virt_address;
166 hd.hd_nirqs = ntimer;
167 hd.hd_flags = HPET_DATA_PLATFORM;
168 hpet_reserve_timer(&hd, 0);
169 #ifdef CONFIG_HPET_EMULATE_RTC
170 hpet_reserve_timer(&hd, 1);
172 hd.hd_irq[0] = HPET_LEGACY_8254;
173 hd.hd_irq[1] = HPET_LEGACY_RTC;
175 struct hpet __iomem *hpet;
176 struct hpet_timer __iomem *timer;
179 hpet = hpet_virt_address;
181 for (i = 2, timer = &hpet->hpet_timers[2]; i < ntimer;
183 hd.hd_irq[i] = (timer->hpet_config &
184 Tn_INT_ROUTE_CNF_MASK) >>
185 Tn_INT_ROUTE_CNF_SHIFT;
193 #ifdef CONFIG_X86_LOCAL_APIC
194 wait_timer_tick = wait_hpet_tick;
199 int hpet_reenable(void)
201 return hpet_timer_stop_set_go(hpet_tick);
204 int is_hpet_enabled(void)
209 int is_hpet_capable(void)
211 if (!boot_hpet_disable && hpet_address)
216 static int __init hpet_setup(char* str)
219 if (!strncmp("disable", str, 7))
220 boot_hpet_disable = 1;
225 __setup("hpet=", hpet_setup);
227 #ifdef CONFIG_HPET_EMULATE_RTC
228 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
229 * is enabled, we support RTC interrupt functionality in software.
230 * RTC has 3 kinds of interrupts:
231 * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
233 * 2) Alarm Interrupt - generate an interrupt at a specific time of day
234 * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
235 * 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
236 * (1) and (2) above are implemented using polling at a frequency of
237 * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
238 * overhead. (DEFAULT_RTC_INT_FREQ)
239 * For (3), we use interrupts at 64Hz or user specified periodic
240 * frequency, whichever is higher.
242 #include <linux/mc146818rtc.h>
243 #include <linux/rtc.h>
245 extern irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
247 #define DEFAULT_RTC_INT_FREQ 64
248 #define RTC_NUM_INTS 1
250 static unsigned long UIE_on;
251 static unsigned long prev_update_sec;
253 static unsigned long AIE_on;
254 static struct rtc_time alarm_time;
256 static unsigned long PIE_on;
257 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
258 static unsigned long PIE_count;
260 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
263 * Timer 1 for RTC, we do not use periodic interrupt feature,
264 * even if HPET supports periodic interrupts on Timer 1.
265 * The reason being, to set up a periodic interrupt in HPET, we need to
266 * stop the main counter. And if we do that everytime someone diables/enables
267 * RTC, we will have adverse effect on main kernel timer running on Timer 0.
268 * So, for the time being, simulate the periodic interrupt in software.
270 * hpet_rtc_timer_init() is called for the first time and during subsequent
271 * interuppts reinit happens through hpet_rtc_timer_reinit().
273 int hpet_rtc_timer_init(void)
275 unsigned int cfg, cnt;
278 if (!is_hpet_enabled())
281 * Set the counter 1 and enable the interrupts.
283 if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
284 hpet_rtc_int_freq = PIE_freq;
286 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
288 local_irq_save(flags);
289 cnt = hpet_readl(HPET_COUNTER);
290 cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
291 hpet_writel(cnt, HPET_T1_CMP);
292 local_irq_restore(flags);
294 cfg = hpet_readl(HPET_T1_CFG);
295 cfg |= HPET_TN_ENABLE | HPET_TN_SETVAL | HPET_TN_32BIT;
296 hpet_writel(cfg, HPET_T1_CFG);
301 static void hpet_rtc_timer_reinit(void)
303 unsigned int cfg, cnt;
305 if (!(PIE_on | AIE_on | UIE_on))
308 if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
309 hpet_rtc_int_freq = PIE_freq;
311 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
313 /* It is more accurate to use the comparator value than current count.*/
314 cnt = hpet_readl(HPET_T1_CMP);
315 cnt += hpet_tick*HZ/hpet_rtc_int_freq;
316 hpet_writel(cnt, HPET_T1_CMP);
318 cfg = hpet_readl(HPET_T1_CFG);
319 cfg |= HPET_TN_ENABLE | HPET_TN_SETVAL | HPET_TN_32BIT;
320 hpet_writel(cfg, HPET_T1_CFG);
326 * The functions below are called from rtc driver.
327 * Return 0 if HPET is not being used.
328 * Otherwise do the necessary changes and return 1.
330 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
332 if (!is_hpet_enabled())
335 if (bit_mask & RTC_UIE)
337 if (bit_mask & RTC_PIE)
339 if (bit_mask & RTC_AIE)
345 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
347 int timer_init_reqd = 0;
349 if (!is_hpet_enabled())
352 if (!(PIE_on | AIE_on | UIE_on))
355 if (bit_mask & RTC_UIE) {
358 if (bit_mask & RTC_PIE) {
362 if (bit_mask & RTC_AIE) {
367 hpet_rtc_timer_init();
372 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
374 if (!is_hpet_enabled())
377 alarm_time.tm_hour = hrs;
378 alarm_time.tm_min = min;
379 alarm_time.tm_sec = sec;
384 int hpet_set_periodic_freq(unsigned long freq)
386 if (!is_hpet_enabled())
395 int hpet_rtc_dropped_irq(void)
397 if (!is_hpet_enabled())
403 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
405 struct rtc_time curr_time;
406 unsigned long rtc_int_flag = 0;
407 int call_rtc_interrupt = 0;
409 hpet_rtc_timer_reinit();
411 if (UIE_on | AIE_on) {
412 rtc_get_rtc_time(&curr_time);
415 if (curr_time.tm_sec != prev_update_sec) {
416 /* Set update int info, call real rtc int routine */
417 call_rtc_interrupt = 1;
418 rtc_int_flag = RTC_UF;
419 prev_update_sec = curr_time.tm_sec;
424 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
425 /* Set periodic int info, call real rtc int routine */
426 call_rtc_interrupt = 1;
427 rtc_int_flag |= RTC_PF;
432 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
433 (curr_time.tm_min == alarm_time.tm_min) &&
434 (curr_time.tm_hour == alarm_time.tm_hour)) {
435 /* Set alarm int info, call real rtc int routine */
436 call_rtc_interrupt = 1;
437 rtc_int_flag |= RTC_AF;
440 if (call_rtc_interrupt) {
441 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
442 rtc_interrupt(rtc_int_flag, dev_id, regs);