hpet: /dev/hpet - fixes and cleanup
[linux-2.6.git] / arch / x86 / kernel / hpet.c
1 #include <linux/clocksource.h>
2 #include <linux/clockchips.h>
3 #include <linux/delay.h>
4 #include <linux/errno.h>
5 #include <linux/hpet.h>
6 #include <linux/init.h>
7 #include <linux/sysdev.h>
8 #include <linux/pm.h>
9
10 #include <asm/fixmap.h>
11 #include <asm/hpet.h>
12 #include <asm/i8253.h>
13 #include <asm/io.h>
14
15 #define HPET_MASK       CLOCKSOURCE_MASK(32)
16 #define HPET_SHIFT      22
17
18 /* FSEC = 10^-15
19    NSEC = 10^-9 */
20 #define FSEC_PER_NSEC   1000000L
21
22 /*
23  * HPET address is set in acpi/boot.c, when an ACPI entry exists
24  */
25 unsigned long hpet_address;
26 static void __iomem *hpet_virt_address;
27
28 unsigned long hpet_readl(unsigned long a)
29 {
30         return readl(hpet_virt_address + a);
31 }
32
33 static inline void hpet_writel(unsigned long d, unsigned long a)
34 {
35         writel(d, hpet_virt_address + a);
36 }
37
38 #ifdef CONFIG_X86_64
39 #include <asm/pgtable.h>
40 #endif
41
42 static inline void hpet_set_mapping(void)
43 {
44         hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
45 #ifdef CONFIG_X86_64
46         __set_fixmap(VSYSCALL_HPET, hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
47 #endif
48 }
49
50 static inline void hpet_clear_mapping(void)
51 {
52         iounmap(hpet_virt_address);
53         hpet_virt_address = NULL;
54 }
55
56 /*
57  * HPET command line enable / disable
58  */
59 static int boot_hpet_disable;
60 int hpet_force_user;
61
62 static int __init hpet_setup(char* str)
63 {
64         if (str) {
65                 if (!strncmp("disable", str, 7))
66                         boot_hpet_disable = 1;
67                 if (!strncmp("force", str, 5))
68                         hpet_force_user = 1;
69         }
70         return 1;
71 }
72 __setup("hpet=", hpet_setup);
73
74 static int __init disable_hpet(char *str)
75 {
76         boot_hpet_disable = 1;
77         return 1;
78 }
79 __setup("nohpet", disable_hpet);
80
81 static inline int is_hpet_capable(void)
82 {
83         return (!boot_hpet_disable && hpet_address);
84 }
85
86 /*
87  * HPET timer interrupt enable / disable
88  */
89 static int hpet_legacy_int_enabled;
90
91 /**
92  * is_hpet_enabled - check whether the hpet timer interrupt is enabled
93  */
94 int is_hpet_enabled(void)
95 {
96         return is_hpet_capable() && hpet_legacy_int_enabled;
97 }
98 EXPORT_SYMBOL_GPL(is_hpet_enabled);
99
100 /*
101  * When the hpet driver (/dev/hpet) is enabled, we need to reserve
102  * timer 0 and timer 1 in case of RTC emulation.
103  */
104 #ifdef CONFIG_HPET
105 static void hpet_reserve_platform_timers(unsigned long id)
106 {
107         struct hpet __iomem *hpet = hpet_virt_address;
108         struct hpet_timer __iomem *timer = &hpet->hpet_timers[2];
109         unsigned int nrtimers, i;
110         struct hpet_data hd;
111
112         nrtimers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
113
114         memset(&hd, 0, sizeof (hd));
115         hd.hd_phys_address = hpet_address;
116         hd.hd_address = hpet;
117         hd.hd_nirqs = nrtimers;
118         hpet_reserve_timer(&hd, 0);
119
120 #ifdef CONFIG_HPET_EMULATE_RTC
121         hpet_reserve_timer(&hd, 1);
122 #endif
123
124         /*
125          * NOTE that hd_irq[] reflects IOAPIC input pins (LEGACY_8254
126          * is wrong for i8259!) not the output IRQ.  Many BIOS writers
127          * don't bother configuring *any* comparator interrupts.
128          */
129         hd.hd_irq[0] = HPET_LEGACY_8254;
130         hd.hd_irq[1] = HPET_LEGACY_RTC;
131
132         for (i = 2; i < nrtimers; timer++, i++) {
133                 hd.hd_irq[i] = (readl(&timer->hpet_config) & Tn_INT_ROUTE_CNF_MASK) >>
134                         Tn_INT_ROUTE_CNF_SHIFT;
135         }
136
137         hpet_alloc(&hd);
138
139 }
140 #else
141 static void hpet_reserve_platform_timers(unsigned long id) { }
142 #endif
143
144 /*
145  * Common hpet info
146  */
147 static unsigned long hpet_period;
148
149 static void hpet_legacy_set_mode(enum clock_event_mode mode,
150                           struct clock_event_device *evt);
151 static int hpet_legacy_next_event(unsigned long delta,
152                            struct clock_event_device *evt);
153
154 /*
155  * The hpet clock event device
156  */
157 static struct clock_event_device hpet_clockevent = {
158         .name           = "hpet",
159         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
160         .set_mode       = hpet_legacy_set_mode,
161         .set_next_event = hpet_legacy_next_event,
162         .shift          = 32,
163         .irq            = 0,
164         .rating         = 50,
165 };
166
167 static void hpet_start_counter(void)
168 {
169         unsigned long cfg = hpet_readl(HPET_CFG);
170
171         cfg &= ~HPET_CFG_ENABLE;
172         hpet_writel(cfg, HPET_CFG);
173         hpet_writel(0, HPET_COUNTER);
174         hpet_writel(0, HPET_COUNTER + 4);
175         cfg |= HPET_CFG_ENABLE;
176         hpet_writel(cfg, HPET_CFG);
177 }
178
179 static void hpet_resume_device(void)
180 {
181         force_hpet_resume();
182 }
183
184 static void hpet_restart_counter(void)
185 {
186         hpet_resume_device();
187         hpet_start_counter();
188 }
189
190 static void hpet_enable_legacy_int(void)
191 {
192         unsigned long cfg = hpet_readl(HPET_CFG);
193
194         cfg |= HPET_CFG_LEGACY;
195         hpet_writel(cfg, HPET_CFG);
196         hpet_legacy_int_enabled = 1;
197 }
198
199 static void hpet_legacy_clockevent_register(void)
200 {
201         /* Start HPET legacy interrupts */
202         hpet_enable_legacy_int();
203
204         /*
205          * The mult factor is defined as (include/linux/clockchips.h)
206          *  mult/2^shift = cyc/ns (in contrast to ns/cyc in clocksource.h)
207          * hpet_period is in units of femtoseconds (per cycle), so
208          *  mult/2^shift = cyc/ns = 10^6/hpet_period
209          *  mult = (10^6 * 2^shift)/hpet_period
210          *  mult = (FSEC_PER_NSEC << hpet_clockevent.shift)/hpet_period
211          */
212         hpet_clockevent.mult = div_sc((unsigned long) FSEC_PER_NSEC,
213                                       hpet_period, hpet_clockevent.shift);
214         /* Calculate the min / max delta */
215         hpet_clockevent.max_delta_ns = clockevent_delta2ns(0x7FFFFFFF,
216                                                            &hpet_clockevent);
217         hpet_clockevent.min_delta_ns = clockevent_delta2ns(0x30,
218                                                            &hpet_clockevent);
219
220         /*
221          * Start hpet with the boot cpu mask and make it
222          * global after the IO_APIC has been initialized.
223          */
224         hpet_clockevent.cpumask = cpumask_of_cpu(smp_processor_id());
225         clockevents_register_device(&hpet_clockevent);
226         global_clock_event = &hpet_clockevent;
227         printk(KERN_DEBUG "hpet clockevent registered\n");
228 }
229
230 static void hpet_legacy_set_mode(enum clock_event_mode mode,
231                           struct clock_event_device *evt)
232 {
233         unsigned long cfg, cmp, now;
234         uint64_t delta;
235
236         switch(mode) {
237         case CLOCK_EVT_MODE_PERIODIC:
238                 delta = ((uint64_t)(NSEC_PER_SEC/HZ)) * hpet_clockevent.mult;
239                 delta >>= hpet_clockevent.shift;
240                 now = hpet_readl(HPET_COUNTER);
241                 cmp = now + (unsigned long) delta;
242                 cfg = hpet_readl(HPET_T0_CFG);
243                 cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC |
244                        HPET_TN_SETVAL | HPET_TN_32BIT;
245                 hpet_writel(cfg, HPET_T0_CFG);
246                 /*
247                  * The first write after writing TN_SETVAL to the
248                  * config register sets the counter value, the second
249                  * write sets the period.
250                  */
251                 hpet_writel(cmp, HPET_T0_CMP);
252                 udelay(1);
253                 hpet_writel((unsigned long) delta, HPET_T0_CMP);
254                 break;
255
256         case CLOCK_EVT_MODE_ONESHOT:
257                 cfg = hpet_readl(HPET_T0_CFG);
258                 cfg &= ~HPET_TN_PERIODIC;
259                 cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
260                 hpet_writel(cfg, HPET_T0_CFG);
261                 break;
262
263         case CLOCK_EVT_MODE_UNUSED:
264         case CLOCK_EVT_MODE_SHUTDOWN:
265                 cfg = hpet_readl(HPET_T0_CFG);
266                 cfg &= ~HPET_TN_ENABLE;
267                 hpet_writel(cfg, HPET_T0_CFG);
268                 break;
269
270         case CLOCK_EVT_MODE_RESUME:
271                 hpet_enable_legacy_int();
272                 break;
273         }
274 }
275
276 static int hpet_legacy_next_event(unsigned long delta,
277                            struct clock_event_device *evt)
278 {
279         unsigned long cnt;
280
281         cnt = hpet_readl(HPET_COUNTER);
282         cnt += delta;
283         hpet_writel(cnt, HPET_T0_CMP);
284
285         return ((long)(hpet_readl(HPET_COUNTER) - cnt ) > 0) ? -ETIME : 0;
286 }
287
288 /*
289  * Clock source related code
290  */
291 static cycle_t read_hpet(void)
292 {
293         return (cycle_t)hpet_readl(HPET_COUNTER);
294 }
295
296 #ifdef CONFIG_X86_64
297 static cycle_t __vsyscall_fn vread_hpet(void)
298 {
299         return readl((const void __iomem *)fix_to_virt(VSYSCALL_HPET) + 0xf0);
300 }
301 #endif
302
303 static struct clocksource clocksource_hpet = {
304         .name           = "hpet",
305         .rating         = 250,
306         .read           = read_hpet,
307         .mask           = HPET_MASK,
308         .shift          = HPET_SHIFT,
309         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
310         .resume         = hpet_restart_counter,
311 #ifdef CONFIG_X86_64
312         .vread          = vread_hpet,
313 #endif
314 };
315
316 static int hpet_clocksource_register(void)
317 {
318         u64 start, now;
319         cycle_t t1;
320
321         /* Start the counter */
322         hpet_start_counter();
323
324         /* Verify whether hpet counter works */
325         t1 = read_hpet();
326         rdtscll(start);
327
328         /*
329          * We don't know the TSC frequency yet, but waiting for
330          * 200000 TSC cycles is safe:
331          * 4 GHz == 50us
332          * 1 GHz == 200us
333          */
334         do {
335                 rep_nop();
336                 rdtscll(now);
337         } while ((now - start) < 200000UL);
338
339         if (t1 == read_hpet()) {
340                 printk(KERN_WARNING
341                        "HPET counter not counting. HPET disabled\n");
342                 return -ENODEV;
343         }
344
345         /*
346          * The definition of mult is (include/linux/clocksource.h)
347          * mult/2^shift = ns/cyc and hpet_period is in units of fsec/cyc
348          * so we first need to convert hpet_period to ns/cyc units:
349          *  mult/2^shift = ns/cyc = hpet_period/10^6
350          *  mult = (hpet_period * 2^shift)/10^6
351          *  mult = (hpet_period << shift)/FSEC_PER_NSEC
352          */
353         clocksource_hpet.mult = div_sc(hpet_period, FSEC_PER_NSEC, HPET_SHIFT);
354
355         clocksource_register(&clocksource_hpet);
356
357         return 0;
358 }
359
360 /**
361  * hpet_enable - Try to setup the HPET timer. Returns 1 on success.
362  */
363 int __init hpet_enable(void)
364 {
365         unsigned long id;
366
367         if (!is_hpet_capable())
368                 return 0;
369
370         hpet_set_mapping();
371
372         /*
373          * Read the period and check for a sane value:
374          */
375         hpet_period = hpet_readl(HPET_PERIOD);
376         if (hpet_period < HPET_MIN_PERIOD || hpet_period > HPET_MAX_PERIOD)
377                 goto out_nohpet;
378
379         /*
380          * Read the HPET ID register to retrieve the IRQ routing
381          * information and the number of channels
382          */
383         id = hpet_readl(HPET_ID);
384
385 #ifdef CONFIG_HPET_EMULATE_RTC
386         /*
387          * The legacy routing mode needs at least two channels, tick timer
388          * and the rtc emulation channel.
389          */
390         if (!(id & HPET_ID_NUMBER))
391                 goto out_nohpet;
392 #endif
393
394         if (hpet_clocksource_register())
395                 goto out_nohpet;
396
397         if (id & HPET_ID_LEGSUP) {
398                 hpet_legacy_clockevent_register();
399                 return 1;
400         }
401         return 0;
402
403 out_nohpet:
404         hpet_clear_mapping();
405         boot_hpet_disable = 1;
406         return 0;
407 }
408
409 /*
410  * Needs to be late, as the reserve_timer code calls kalloc !
411  *
412  * Not a problem on i386 as hpet_enable is called from late_time_init,
413  * but on x86_64 it is necessary !
414  */
415 static __init int hpet_late_init(void)
416 {
417         if (boot_hpet_disable)
418                 return -ENODEV;
419
420         if (!hpet_address) {
421                 if (!force_hpet_address)
422                         return -ENODEV;
423
424                 hpet_address = force_hpet_address;
425                 hpet_enable();
426                 if (!hpet_virt_address)
427                         return -ENODEV;
428         }
429
430         hpet_reserve_platform_timers(hpet_readl(HPET_ID));
431
432         return 0;
433 }
434 fs_initcall(hpet_late_init);
435
436 void hpet_disable(void)
437 {
438         if (is_hpet_capable()) {
439                 unsigned long cfg = hpet_readl(HPET_CFG);
440
441                 if (hpet_legacy_int_enabled) {
442                         cfg &= ~HPET_CFG_LEGACY;
443                         hpet_legacy_int_enabled = 0;
444                 }
445                 cfg &= ~HPET_CFG_ENABLE;
446                 hpet_writel(cfg, HPET_CFG);
447         }
448 }
449
450 #ifdef CONFIG_HPET_EMULATE_RTC
451
452 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
453  * is enabled, we support RTC interrupt functionality in software.
454  * RTC has 3 kinds of interrupts:
455  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
456  *    is updated
457  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
458  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
459  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
460  * (1) and (2) above are implemented using polling at a frequency of
461  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
462  * overhead. (DEFAULT_RTC_INT_FREQ)
463  * For (3), we use interrupts at 64Hz or user specified periodic
464  * frequency, whichever is higher.
465  */
466 #include <linux/mc146818rtc.h>
467 #include <linux/rtc.h>
468 #include <asm/rtc.h>
469
470 #define DEFAULT_RTC_INT_FREQ    64
471 #define DEFAULT_RTC_SHIFT       6
472 #define RTC_NUM_INTS            1
473
474 static unsigned long hpet_rtc_flags;
475 static int hpet_prev_update_sec;
476 static struct rtc_time hpet_alarm_time;
477 static unsigned long hpet_pie_count;
478 static unsigned long hpet_t1_cmp;
479 static unsigned long hpet_default_delta;
480 static unsigned long hpet_pie_delta;
481 static unsigned long hpet_pie_limit;
482
483 static rtc_irq_handler irq_handler;
484
485 /*
486  * Registers a IRQ handler.
487  */
488 int hpet_register_irq_handler(rtc_irq_handler handler)
489 {
490         if (!is_hpet_enabled())
491                 return -ENODEV;
492         if (irq_handler)
493                 return -EBUSY;
494
495         irq_handler = handler;
496
497         return 0;
498 }
499 EXPORT_SYMBOL_GPL(hpet_register_irq_handler);
500
501 /*
502  * Deregisters the IRQ handler registered with hpet_register_irq_handler()
503  * and does cleanup.
504  */
505 void hpet_unregister_irq_handler(rtc_irq_handler handler)
506 {
507         if (!is_hpet_enabled())
508                 return;
509
510         irq_handler = NULL;
511         hpet_rtc_flags = 0;
512 }
513 EXPORT_SYMBOL_GPL(hpet_unregister_irq_handler);
514
515 /*
516  * Timer 1 for RTC emulation. We use one shot mode, as periodic mode
517  * is not supported by all HPET implementations for timer 1.
518  *
519  * hpet_rtc_timer_init() is called when the rtc is initialized.
520  */
521 int hpet_rtc_timer_init(void)
522 {
523         unsigned long cfg, cnt, delta, flags;
524
525         if (!is_hpet_enabled())
526                 return 0;
527
528         if (!hpet_default_delta) {
529                 uint64_t clc;
530
531                 clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
532                 clc >>= hpet_clockevent.shift + DEFAULT_RTC_SHIFT;
533                 hpet_default_delta = (unsigned long) clc;
534         }
535
536         if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
537                 delta = hpet_default_delta;
538         else
539                 delta = hpet_pie_delta;
540
541         local_irq_save(flags);
542
543         cnt = delta + hpet_readl(HPET_COUNTER);
544         hpet_writel(cnt, HPET_T1_CMP);
545         hpet_t1_cmp = cnt;
546
547         cfg = hpet_readl(HPET_T1_CFG);
548         cfg &= ~HPET_TN_PERIODIC;
549         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
550         hpet_writel(cfg, HPET_T1_CFG);
551
552         local_irq_restore(flags);
553
554         return 1;
555 }
556 EXPORT_SYMBOL_GPL(hpet_rtc_timer_init);
557
558 /*
559  * The functions below are called from rtc driver.
560  * Return 0 if HPET is not being used.
561  * Otherwise do the necessary changes and return 1.
562  */
563 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
564 {
565         if (!is_hpet_enabled())
566                 return 0;
567
568         hpet_rtc_flags &= ~bit_mask;
569         return 1;
570 }
571 EXPORT_SYMBOL_GPL(hpet_mask_rtc_irq_bit);
572
573 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
574 {
575         unsigned long oldbits = hpet_rtc_flags;
576
577         if (!is_hpet_enabled())
578                 return 0;
579
580         hpet_rtc_flags |= bit_mask;
581
582         if ((bit_mask & RTC_UIE) && !(oldbits & RTC_UIE))
583                 hpet_prev_update_sec = -1;
584
585         if (!oldbits)
586                 hpet_rtc_timer_init();
587
588         return 1;
589 }
590 EXPORT_SYMBOL_GPL(hpet_set_rtc_irq_bit);
591
592 int hpet_set_alarm_time(unsigned char hrs, unsigned char min,
593                         unsigned char sec)
594 {
595         if (!is_hpet_enabled())
596                 return 0;
597
598         hpet_alarm_time.tm_hour = hrs;
599         hpet_alarm_time.tm_min = min;
600         hpet_alarm_time.tm_sec = sec;
601
602         return 1;
603 }
604 EXPORT_SYMBOL_GPL(hpet_set_alarm_time);
605
606 int hpet_set_periodic_freq(unsigned long freq)
607 {
608         uint64_t clc;
609
610         if (!is_hpet_enabled())
611                 return 0;
612
613         if (freq <= DEFAULT_RTC_INT_FREQ)
614                 hpet_pie_limit = DEFAULT_RTC_INT_FREQ / freq;
615         else {
616                 clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
617                 do_div(clc, freq);
618                 clc >>= hpet_clockevent.shift;
619                 hpet_pie_delta = (unsigned long) clc;
620         }
621         return 1;
622 }
623 EXPORT_SYMBOL_GPL(hpet_set_periodic_freq);
624
625 int hpet_rtc_dropped_irq(void)
626 {
627         return is_hpet_enabled();
628 }
629 EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq);
630
631 static void hpet_rtc_timer_reinit(void)
632 {
633         unsigned long cfg, delta;
634         int lost_ints = -1;
635
636         if (unlikely(!hpet_rtc_flags)) {
637                 cfg = hpet_readl(HPET_T1_CFG);
638                 cfg &= ~HPET_TN_ENABLE;
639                 hpet_writel(cfg, HPET_T1_CFG);
640                 return;
641         }
642
643         if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
644                 delta = hpet_default_delta;
645         else
646                 delta = hpet_pie_delta;
647
648         /*
649          * Increment the comparator value until we are ahead of the
650          * current count.
651          */
652         do {
653                 hpet_t1_cmp += delta;
654                 hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
655                 lost_ints++;
656         } while ((long)(hpet_readl(HPET_COUNTER) - hpet_t1_cmp) > 0);
657
658         if (lost_ints) {
659                 if (hpet_rtc_flags & RTC_PIE)
660                         hpet_pie_count += lost_ints;
661                 if (printk_ratelimit())
662                         printk(KERN_WARNING "hpet1: lost %d rtc interrupts\n",
663                                 lost_ints);
664         }
665 }
666
667 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
668 {
669         struct rtc_time curr_time;
670         unsigned long rtc_int_flag = 0;
671
672         hpet_rtc_timer_reinit();
673         memset(&curr_time, 0, sizeof(struct rtc_time));
674
675         if (hpet_rtc_flags & (RTC_UIE | RTC_AIE))
676                 get_rtc_time(&curr_time);
677
678         if (hpet_rtc_flags & RTC_UIE &&
679             curr_time.tm_sec != hpet_prev_update_sec) {
680                 if (hpet_prev_update_sec >= 0)
681                         rtc_int_flag = RTC_UF;
682                 hpet_prev_update_sec = curr_time.tm_sec;
683         }
684
685         if (hpet_rtc_flags & RTC_PIE &&
686             ++hpet_pie_count >= hpet_pie_limit) {
687                 rtc_int_flag |= RTC_PF;
688                 hpet_pie_count = 0;
689         }
690
691         if (hpet_rtc_flags & RTC_AIE &&
692             (curr_time.tm_sec == hpet_alarm_time.tm_sec) &&
693             (curr_time.tm_min == hpet_alarm_time.tm_min) &&
694             (curr_time.tm_hour == hpet_alarm_time.tm_hour))
695                         rtc_int_flag |= RTC_AF;
696
697         if (rtc_int_flag) {
698                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
699                 if (irq_handler)
700                         irq_handler(rtc_int_flag, dev_id);
701         }
702         return IRQ_HANDLED;
703 }
704 EXPORT_SYMBOL_GPL(hpet_rtc_interrupt);
705 #endif