Merge branch 'master'
[linux-2.6] / arch / i386 / kernel / time_hpet.c
1 /*
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.
5  *
6  *  2003-06-30    Venkatesh Pallipadi - Additional changes for HPET support
7  */
8
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>
15
16 #include <asm/timer.h>
17 #include <asm/fixmap.h>
18 #include <asm/apic.h>
19
20 #include <linux/timex.h>
21 #include <linux/config.h>
22
23 #include <asm/hpet.h>
24 #include <linux/hpet.h>
25
26 static 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 */
29 int hpet_use_timer;
30
31 static int use_hpet;            /* can be used for runtime check of hpet */
32 static int boot_hpet_disable;   /* boottime override for HPET timer */
33 static void __iomem * hpet_virt_address;        /* hpet kernel virtual address */
34
35 #define FSEC_TO_USEC (1000000000UL)
36
37 int hpet_readl(unsigned long a)
38 {
39         return readl(hpet_virt_address + a);
40 }
41
42 static void hpet_writel(unsigned long d, unsigned long a)
43 {
44         writel(d, hpet_virt_address + a);
45 }
46
47 #ifdef CONFIG_X86_LOCAL_APIC
48 /*
49  * HPET counters dont wrap around on every tick. They just change the
50  * comparator value and continue. Next tick can be caught by checking
51  * for a change in the comparator value. Used in apic.c.
52  */
53 static void __devinit wait_hpet_tick(void)
54 {
55         unsigned int start_cmp_val, end_cmp_val;
56
57         start_cmp_val = hpet_readl(HPET_T0_CMP);
58         do {
59                 end_cmp_val = hpet_readl(HPET_T0_CMP);
60         } while (start_cmp_val == end_cmp_val);
61 }
62 #endif
63
64 static int hpet_timer_stop_set_go(unsigned long tick)
65 {
66         unsigned int cfg;
67
68         /*
69          * Stop the timers and reset the main counter.
70          */
71         cfg = hpet_readl(HPET_CFG);
72         cfg &= ~HPET_CFG_ENABLE;
73         hpet_writel(cfg, HPET_CFG);
74         hpet_writel(0, HPET_COUNTER);
75         hpet_writel(0, HPET_COUNTER + 4);
76
77         if (hpet_use_timer) {
78                 /*
79                  * Set up timer 0, as periodic with first interrupt to happen at
80                  * hpet_tick, and period also hpet_tick.
81                  */
82                 cfg = hpet_readl(HPET_T0_CFG);
83                 cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC |
84                        HPET_TN_SETVAL | HPET_TN_32BIT;
85                 hpet_writel(cfg, HPET_T0_CFG);
86
87                 /*
88                  * The first write after writing TN_SETVAL to the config register sets
89                  * the counter value, the second write sets the threshold.
90                  */
91                 hpet_writel(tick, HPET_T0_CMP);
92                 hpet_writel(tick, HPET_T0_CMP);
93         }
94         /*
95          * Go!
96          */
97         cfg = hpet_readl(HPET_CFG);
98         if (hpet_use_timer)
99                 cfg |= HPET_CFG_LEGACY;
100         cfg |= HPET_CFG_ENABLE;
101         hpet_writel(cfg, HPET_CFG);
102
103         return 0;
104 }
105
106 /*
107  * Check whether HPET was found by ACPI boot parse. If yes setup HPET
108  * counter 0 for kernel base timer.
109  */
110 int __init hpet_enable(void)
111 {
112         unsigned int id;
113         unsigned long tick_fsec_low, tick_fsec_high; /* tick in femto sec */
114         unsigned long hpet_tick_rem;
115
116         if (boot_hpet_disable)
117                 return -1;
118
119         if (!hpet_address) {
120                 return -1;
121         }
122         hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
123         /*
124          * Read the period, compute tick and quotient.
125          */
126         id = hpet_readl(HPET_ID);
127
128         /*
129          * We are checking for value '1' or more in number field if
130          * CONFIG_HPET_EMULATE_RTC is set because we will need an
131          * additional timer for RTC emulation.
132          * However, we can do with one timer otherwise using the
133          * the single HPET timer for system time.
134          */
135 #ifdef CONFIG_HPET_EMULATE_RTC
136         if (!(id & HPET_ID_NUMBER))
137                 return -1;
138 #endif
139
140
141         hpet_period = hpet_readl(HPET_PERIOD);
142         if ((hpet_period < HPET_MIN_PERIOD) || (hpet_period > HPET_MAX_PERIOD))
143                 return -1;
144
145         /*
146          * 64 bit math
147          * First changing tick into fsec
148          * Then 64 bit div to find number of hpet clk per tick
149          */
150         ASM_MUL64_REG(tick_fsec_low, tick_fsec_high,
151                         KERNEL_TICK_USEC, FSEC_TO_USEC);
152         ASM_DIV64_REG(hpet_tick, hpet_tick_rem,
153                         hpet_period, tick_fsec_low, tick_fsec_high);
154
155         if (hpet_tick_rem > (hpet_period >> 1))
156                 hpet_tick++; /* rounding the result */
157
158         hpet_use_timer = id & HPET_ID_LEGSUP;
159
160         if (hpet_timer_stop_set_go(hpet_tick))
161                 return -1;
162
163         use_hpet = 1;
164
165 #ifdef  CONFIG_HPET
166         {
167                 struct hpet_data        hd;
168                 unsigned int            ntimer;
169
170                 memset(&hd, 0, sizeof (hd));
171
172                 ntimer = hpet_readl(HPET_ID);
173                 ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
174                 ntimer++;
175
176                 /*
177                  * Register with driver.
178                  * Timer0 and Timer1 is used by platform.
179                  */
180                 hd.hd_phys_address = hpet_address;
181                 hd.hd_address = hpet_virt_address;
182                 hd.hd_nirqs = ntimer;
183                 hd.hd_flags = HPET_DATA_PLATFORM;
184                 hpet_reserve_timer(&hd, 0);
185 #ifdef  CONFIG_HPET_EMULATE_RTC
186                 hpet_reserve_timer(&hd, 1);
187 #endif
188                 hd.hd_irq[0] = HPET_LEGACY_8254;
189                 hd.hd_irq[1] = HPET_LEGACY_RTC;
190                 if (ntimer > 2) {
191                         struct hpet __iomem     *hpet;
192                         struct hpet_timer __iomem *timer;
193                         int                     i;
194
195                         hpet = hpet_virt_address;
196
197                         for (i = 2, timer = &hpet->hpet_timers[2]; i < ntimer;
198                                 timer++, i++)
199                                 hd.hd_irq[i] = (timer->hpet_config &
200                                         Tn_INT_ROUTE_CNF_MASK) >>
201                                         Tn_INT_ROUTE_CNF_SHIFT;
202
203                 }
204
205                 hpet_alloc(&hd);
206         }
207 #endif
208
209 #ifdef CONFIG_X86_LOCAL_APIC
210         if (hpet_use_timer)
211                 wait_timer_tick = wait_hpet_tick;
212 #endif
213         return 0;
214 }
215
216 int hpet_reenable(void)
217 {
218         return hpet_timer_stop_set_go(hpet_tick);
219 }
220
221 int is_hpet_enabled(void)
222 {
223         return use_hpet;
224 }
225
226 int is_hpet_capable(void)
227 {
228         if (!boot_hpet_disable && hpet_address)
229                 return 1;
230         return 0;
231 }
232
233 static int __init hpet_setup(char* str)
234 {
235         if (str) {
236                 if (!strncmp("disable", str, 7))
237                         boot_hpet_disable = 1;
238         }
239         return 1;
240 }
241
242 __setup("hpet=", hpet_setup);
243
244 #ifdef CONFIG_HPET_EMULATE_RTC
245 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
246  * is enabled, we support RTC interrupt functionality in software.
247  * RTC has 3 kinds of interrupts:
248  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
249  *    is updated
250  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
251  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
252  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
253  * (1) and (2) above are implemented using polling at a frequency of
254  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
255  * overhead. (DEFAULT_RTC_INT_FREQ)
256  * For (3), we use interrupts at 64Hz or user specified periodic
257  * frequency, whichever is higher.
258  */
259 #include <linux/mc146818rtc.h>
260 #include <linux/rtc.h>
261
262 extern irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
263
264 #define DEFAULT_RTC_INT_FREQ    64
265 #define RTC_NUM_INTS            1
266
267 static unsigned long UIE_on;
268 static unsigned long prev_update_sec;
269
270 static unsigned long AIE_on;
271 static struct rtc_time alarm_time;
272
273 static unsigned long PIE_on;
274 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
275 static unsigned long PIE_count;
276
277 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
278 static unsigned int hpet_t1_cmp; /* cached comparator register */
279
280 /*
281  * Timer 1 for RTC, we do not use periodic interrupt feature,
282  * even if HPET supports periodic interrupts on Timer 1.
283  * The reason being, to set up a periodic interrupt in HPET, we need to
284  * stop the main counter. And if we do that everytime someone diables/enables
285  * RTC, we will have adverse effect on main kernel timer running on Timer 0.
286  * So, for the time being, simulate the periodic interrupt in software.
287  *
288  * hpet_rtc_timer_init() is called for the first time and during subsequent
289  * interuppts reinit happens through hpet_rtc_timer_reinit().
290  */
291 int hpet_rtc_timer_init(void)
292 {
293         unsigned int cfg, cnt;
294         unsigned long flags;
295
296         if (!is_hpet_enabled())
297                 return 0;
298         /*
299          * Set the counter 1 and enable the interrupts.
300          */
301         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
302                 hpet_rtc_int_freq = PIE_freq;
303         else
304                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
305
306         local_irq_save(flags);
307         cnt = hpet_readl(HPET_COUNTER);
308         cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
309         hpet_writel(cnt, HPET_T1_CMP);
310         hpet_t1_cmp = cnt;
311         local_irq_restore(flags);
312
313         cfg = hpet_readl(HPET_T1_CFG);
314         cfg &= ~HPET_TN_PERIODIC;
315         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
316         hpet_writel(cfg, HPET_T1_CFG);
317
318         return 1;
319 }
320
321 static void hpet_rtc_timer_reinit(void)
322 {
323         unsigned int cfg, cnt;
324
325         if (unlikely(!(PIE_on | AIE_on | UIE_on))) {
326                 cfg = hpet_readl(HPET_T1_CFG);
327                 cfg &= ~HPET_TN_ENABLE;
328                 hpet_writel(cfg, HPET_T1_CFG);
329                 return;
330         }
331
332         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
333                 hpet_rtc_int_freq = PIE_freq;
334         else
335                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
336
337         /* It is more accurate to use the comparator value than current count.*/
338         cnt = hpet_t1_cmp;
339         cnt += hpet_tick*HZ/hpet_rtc_int_freq;
340         hpet_writel(cnt, HPET_T1_CMP);
341         hpet_t1_cmp = cnt;
342 }
343
344 /*
345  * The functions below are called from rtc driver.
346  * Return 0 if HPET is not being used.
347  * Otherwise do the necessary changes and return 1.
348  */
349 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
350 {
351         if (!is_hpet_enabled())
352                 return 0;
353
354         if (bit_mask & RTC_UIE)
355                 UIE_on = 0;
356         if (bit_mask & RTC_PIE)
357                 PIE_on = 0;
358         if (bit_mask & RTC_AIE)
359                 AIE_on = 0;
360
361         return 1;
362 }
363
364 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
365 {
366         int timer_init_reqd = 0;
367
368         if (!is_hpet_enabled())
369                 return 0;
370
371         if (!(PIE_on | AIE_on | UIE_on))
372                 timer_init_reqd = 1;
373
374         if (bit_mask & RTC_UIE) {
375                 UIE_on = 1;
376         }
377         if (bit_mask & RTC_PIE) {
378                 PIE_on = 1;
379                 PIE_count = 0;
380         }
381         if (bit_mask & RTC_AIE) {
382                 AIE_on = 1;
383         }
384
385         if (timer_init_reqd)
386                 hpet_rtc_timer_init();
387
388         return 1;
389 }
390
391 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
392 {
393         if (!is_hpet_enabled())
394                 return 0;
395
396         alarm_time.tm_hour = hrs;
397         alarm_time.tm_min = min;
398         alarm_time.tm_sec = sec;
399
400         return 1;
401 }
402
403 int hpet_set_periodic_freq(unsigned long freq)
404 {
405         if (!is_hpet_enabled())
406                 return 0;
407
408         PIE_freq = freq;
409         PIE_count = 0;
410
411         return 1;
412 }
413
414 int hpet_rtc_dropped_irq(void)
415 {
416         if (!is_hpet_enabled())
417                 return 0;
418
419         return 1;
420 }
421
422 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
423 {
424         struct rtc_time curr_time;
425         unsigned long rtc_int_flag = 0;
426         int call_rtc_interrupt = 0;
427
428         hpet_rtc_timer_reinit();
429
430         if (UIE_on | AIE_on) {
431                 rtc_get_rtc_time(&curr_time);
432         }
433         if (UIE_on) {
434                 if (curr_time.tm_sec != prev_update_sec) {
435                         /* Set update int info, call real rtc int routine */
436                         call_rtc_interrupt = 1;
437                         rtc_int_flag = RTC_UF;
438                         prev_update_sec = curr_time.tm_sec;
439                 }
440         }
441         if (PIE_on) {
442                 PIE_count++;
443                 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
444                         /* Set periodic int info, call real rtc int routine */
445                         call_rtc_interrupt = 1;
446                         rtc_int_flag |= RTC_PF;
447                         PIE_count = 0;
448                 }
449         }
450         if (AIE_on) {
451                 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
452                     (curr_time.tm_min == alarm_time.tm_min) &&
453                     (curr_time.tm_hour == alarm_time.tm_hour)) {
454                         /* Set alarm int info, call real rtc int routine */
455                         call_rtc_interrupt = 1;
456                         rtc_int_flag |= RTC_AF;
457                 }
458         }
459         if (call_rtc_interrupt) {
460                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
461                 rtc_interrupt(rtc_int_flag, dev_id, regs);
462         }
463         return IRQ_HANDLED;
464 }
465 #endif
466