1 #include <linux/kernel.h>
2 #include <linux/sched.h>
3 #include <linux/init.h>
4 #include <linux/mc146818rtc.h>
5 #include <linux/time.h>
6 #include <linux/clocksource.h>
7 #include <linux/ioport.h>
8 #include <linux/acpi.h>
9 #include <linux/hpet.h>
10 #include <asm/pgtable.h>
11 #include <asm/vsyscall.h>
12 #include <asm/timex.h>
15 #define HPET_MASK 0xFFFFFFFF
18 /* FSEC = 10^-15 NSEC = 10^-9 */
19 #define FSEC_PER_NSEC 1000000
21 int nohpet __initdata
;
23 unsigned long hpet_address
;
24 unsigned long hpet_period
; /* fsecs / HPET clock */
25 unsigned long hpet_tick
; /* HPET clocks / interrupt */
27 int hpet_use_timer
; /* Use counter of hpet for time keeping,
32 static __init
int late_hpet_init(void)
40 memset(&hd
, 0, sizeof(hd
));
42 ntimer
= hpet_readl(HPET_ID
);
43 ntimer
= (ntimer
& HPET_ID_NUMBER
) >> HPET_ID_NUMBER_SHIFT
;
47 * Register with driver.
48 * Timer0 and Timer1 is used by platform.
50 hd
.hd_phys_address
= hpet_address
;
51 hd
.hd_address
= (void __iomem
*)fix_to_virt(FIX_HPET_BASE
);
53 hd
.hd_flags
= HPET_DATA_PLATFORM
;
54 hpet_reserve_timer(&hd
, 0);
55 #ifdef CONFIG_HPET_EMULATE_RTC
56 hpet_reserve_timer(&hd
, 1);
58 hd
.hd_irq
[0] = HPET_LEGACY_8254
;
59 hd
.hd_irq
[1] = HPET_LEGACY_RTC
;
62 struct hpet_timer
*timer
;
65 hpet
= (struct hpet
*) fix_to_virt(FIX_HPET_BASE
);
66 timer
= &hpet
->hpet_timers
[2];
67 for (i
= 2; i
< ntimer
; timer
++, i
++)
68 hd
.hd_irq
[i
] = (timer
->hpet_config
&
69 Tn_INT_ROUTE_CNF_MASK
) >>
70 Tn_INT_ROUTE_CNF_SHIFT
;
77 fs_initcall(late_hpet_init
);
80 int hpet_timer_stop_set_go(unsigned long tick
)
85 * Stop the timers and reset the main counter.
88 cfg
= hpet_readl(HPET_CFG
);
89 cfg
&= ~(HPET_CFG_ENABLE
| HPET_CFG_LEGACY
);
90 hpet_writel(cfg
, HPET_CFG
);
91 hpet_writel(0, HPET_COUNTER
);
92 hpet_writel(0, HPET_COUNTER
+ 4);
95 * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
96 * and period also hpet_tick.
99 hpet_writel(HPET_TN_ENABLE
| HPET_TN_PERIODIC
| HPET_TN_SETVAL
|
100 HPET_TN_32BIT
, HPET_T0_CFG
);
101 hpet_writel(hpet_tick
, HPET_T0_CMP
); /* next interrupt */
102 hpet_writel(hpet_tick
, HPET_T0_CMP
); /* period */
103 cfg
|= HPET_CFG_LEGACY
;
109 cfg
|= HPET_CFG_ENABLE
;
110 hpet_writel(cfg
, HPET_CFG
);
115 static cycle_t
read_hpet(void)
117 return (cycle_t
)hpet_readl(HPET_COUNTER
);
120 static cycle_t __vsyscall_fn
vread_hpet(void)
122 return readl((void __iomem
*)fix_to_virt(VSYSCALL_HPET
) + 0xf0);
125 struct clocksource clocksource_hpet
= {
129 .mask
= (cycle_t
)HPET_MASK
,
130 .mult
= 0, /* set below */
132 .flags
= CLOCK_SOURCE_IS_CONTINUOUS
,
136 int __init
hpet_arch_init(void)
143 set_fixmap_nocache(FIX_HPET_BASE
, hpet_address
);
144 __set_fixmap(VSYSCALL_HPET
, hpet_address
, PAGE_KERNEL_VSYSCALL_NOCACHE
);
147 * Read the period, compute tick and quotient.
150 id
= hpet_readl(HPET_ID
);
152 if (!(id
& HPET_ID_VENDOR
) || !(id
& HPET_ID_NUMBER
))
155 hpet_period
= hpet_readl(HPET_PERIOD
);
156 if (hpet_period
< 100000 || hpet_period
> 100000000)
159 hpet_tick
= (FSEC_PER_TICK
+ hpet_period
/ 2) / hpet_period
;
161 hpet_use_timer
= (id
& HPET_ID_LEGSUP
);
164 * hpet period is in femto seconds per cycle
165 * so we need to convert this to ns/cyc units
166 * aproximated by mult/2^shift
168 * fsec/cyc * 1nsec/1000000fsec = nsec/cyc = mult/2^shift
169 * fsec/cyc * 1ns/1000000fsec * 2^shift = mult
170 * fsec/cyc * 2^shift * 1nsec/1000000fsec = mult
171 * (fsec/cyc << shift)/1000000 = mult
172 * (hpet_period << shift)/FSEC_PER_NSEC = mult
174 tmp
= (u64
)hpet_period
<< HPET_SHIFT
;
175 do_div(tmp
, FSEC_PER_NSEC
);
176 clocksource_hpet
.mult
= (u32
)tmp
;
177 clocksource_register(&clocksource_hpet
);
179 return hpet_timer_stop_set_go(hpet_tick
);
182 int hpet_reenable(void)
184 return hpet_timer_stop_set_go(hpet_tick
);
187 #ifdef CONFIG_HPET_EMULATE_RTC
188 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
189 * is enabled, we support RTC interrupt functionality in software.
190 * RTC has 3 kinds of interrupts:
191 * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
193 * 2) Alarm Interrupt - generate an interrupt at a specific time of day
194 * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
195 * 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
196 * (1) and (2) above are implemented using polling at a frequency of
197 * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
198 * overhead. (DEFAULT_RTC_INT_FREQ)
199 * For (3), we use interrupts at 64Hz or user specified periodic
200 * frequency, whichever is higher.
202 #include <linux/rtc.h>
204 #define DEFAULT_RTC_INT_FREQ 64
205 #define RTC_NUM_INTS 1
207 static unsigned long UIE_on
;
208 static unsigned long prev_update_sec
;
210 static unsigned long AIE_on
;
211 static struct rtc_time alarm_time
;
213 static unsigned long PIE_on
;
214 static unsigned long PIE_freq
= DEFAULT_RTC_INT_FREQ
;
215 static unsigned long PIE_count
;
217 static unsigned long hpet_rtc_int_freq
; /* RTC interrupt frequency */
218 static unsigned int hpet_t1_cmp
; /* cached comparator register */
220 int is_hpet_enabled(void)
222 return hpet_address
!= 0;
226 * Timer 1 for RTC, we do not use periodic interrupt feature,
227 * even if HPET supports periodic interrupts on Timer 1.
228 * The reason being, to set up a periodic interrupt in HPET, we need to
229 * stop the main counter. And if we do that everytime someone diables/enables
230 * RTC, we will have adverse effect on main kernel timer running on Timer 0.
231 * So, for the time being, simulate the periodic interrupt in software.
233 * hpet_rtc_timer_init() is called for the first time and during subsequent
234 * interuppts reinit happens through hpet_rtc_timer_reinit().
236 int hpet_rtc_timer_init(void)
238 unsigned int cfg
, cnt
;
241 if (!is_hpet_enabled())
244 * Set the counter 1 and enable the interrupts.
246 if (PIE_on
&& (PIE_freq
> DEFAULT_RTC_INT_FREQ
))
247 hpet_rtc_int_freq
= PIE_freq
;
249 hpet_rtc_int_freq
= DEFAULT_RTC_INT_FREQ
;
251 local_irq_save(flags
);
253 cnt
= hpet_readl(HPET_COUNTER
);
254 cnt
+= ((hpet_tick
*HZ
)/hpet_rtc_int_freq
);
255 hpet_writel(cnt
, HPET_T1_CMP
);
258 cfg
= hpet_readl(HPET_T1_CFG
);
259 cfg
&= ~HPET_TN_PERIODIC
;
260 cfg
|= HPET_TN_ENABLE
| HPET_TN_32BIT
;
261 hpet_writel(cfg
, HPET_T1_CFG
);
263 local_irq_restore(flags
);
268 static void hpet_rtc_timer_reinit(void)
270 unsigned int cfg
, cnt
, ticks_per_int
, lost_ints
;
272 if (unlikely(!(PIE_on
| AIE_on
| UIE_on
))) {
273 cfg
= hpet_readl(HPET_T1_CFG
);
274 cfg
&= ~HPET_TN_ENABLE
;
275 hpet_writel(cfg
, HPET_T1_CFG
);
279 if (PIE_on
&& (PIE_freq
> DEFAULT_RTC_INT_FREQ
))
280 hpet_rtc_int_freq
= PIE_freq
;
282 hpet_rtc_int_freq
= DEFAULT_RTC_INT_FREQ
;
284 /* It is more accurate to use the comparator value than current count.*/
285 ticks_per_int
= hpet_tick
* HZ
/ hpet_rtc_int_freq
;
286 hpet_t1_cmp
+= ticks_per_int
;
287 hpet_writel(hpet_t1_cmp
, HPET_T1_CMP
);
290 * If the interrupt handler was delayed too long, the write above tries
291 * to schedule the next interrupt in the past and the hardware would
292 * not interrupt until the counter had wrapped around.
293 * So we have to check that the comparator wasn't set to a past time.
295 cnt
= hpet_readl(HPET_COUNTER
);
296 if (unlikely((int)(cnt
- hpet_t1_cmp
) > 0)) {
297 lost_ints
= (cnt
- hpet_t1_cmp
) / ticks_per_int
+ 1;
298 /* Make sure that, even with the time needed to execute
299 * this code, the next scheduled interrupt has been moved
300 * back to the future: */
303 hpet_t1_cmp
+= lost_ints
* ticks_per_int
;
304 hpet_writel(hpet_t1_cmp
, HPET_T1_CMP
);
307 PIE_count
+= lost_ints
;
309 if (printk_ratelimit())
310 printk(KERN_WARNING
"rtc: lost some interrupts at %ldHz.\n",
316 * The functions below are called from rtc driver.
317 * Return 0 if HPET is not being used.
318 * Otherwise do the necessary changes and return 1.
320 int hpet_mask_rtc_irq_bit(unsigned long bit_mask
)
322 if (!is_hpet_enabled())
325 if (bit_mask
& RTC_UIE
)
327 if (bit_mask
& RTC_PIE
)
329 if (bit_mask
& RTC_AIE
)
335 int hpet_set_rtc_irq_bit(unsigned long bit_mask
)
337 int timer_init_reqd
= 0;
339 if (!is_hpet_enabled())
342 if (!(PIE_on
| AIE_on
| UIE_on
))
345 if (bit_mask
& RTC_UIE
) {
348 if (bit_mask
& RTC_PIE
) {
352 if (bit_mask
& RTC_AIE
) {
357 hpet_rtc_timer_init();
362 int hpet_set_alarm_time(unsigned char hrs
, unsigned char min
, unsigned char sec
)
364 if (!is_hpet_enabled())
367 alarm_time
.tm_hour
= hrs
;
368 alarm_time
.tm_min
= min
;
369 alarm_time
.tm_sec
= sec
;
374 int hpet_set_periodic_freq(unsigned long freq
)
376 if (!is_hpet_enabled())
385 int hpet_rtc_dropped_irq(void)
387 if (!is_hpet_enabled())
393 irqreturn_t
hpet_rtc_interrupt(int irq
, void *dev_id
)
395 struct rtc_time curr_time
;
396 unsigned long rtc_int_flag
= 0;
397 int call_rtc_interrupt
= 0;
399 hpet_rtc_timer_reinit();
401 if (UIE_on
| AIE_on
) {
402 rtc_get_rtc_time(&curr_time
);
405 if (curr_time
.tm_sec
!= prev_update_sec
) {
406 /* Set update int info, call real rtc int routine */
407 call_rtc_interrupt
= 1;
408 rtc_int_flag
= RTC_UF
;
409 prev_update_sec
= curr_time
.tm_sec
;
414 if (PIE_count
>= hpet_rtc_int_freq
/PIE_freq
) {
415 /* Set periodic int info, call real rtc int routine */
416 call_rtc_interrupt
= 1;
417 rtc_int_flag
|= RTC_PF
;
422 if ((curr_time
.tm_sec
== alarm_time
.tm_sec
) &&
423 (curr_time
.tm_min
== alarm_time
.tm_min
) &&
424 (curr_time
.tm_hour
== alarm_time
.tm_hour
)) {
425 /* Set alarm int info, call real rtc int routine */
426 call_rtc_interrupt
= 1;
427 rtc_int_flag
|= RTC_AF
;
430 if (call_rtc_interrupt
) {
431 rtc_int_flag
|= (RTC_IRQF
| (RTC_NUM_INTS
<< 8));
432 rtc_interrupt(rtc_int_flag
, dev_id
);
438 static int __init
nohpet_setup(char *s
)
444 __setup("nohpet", nohpet_setup
);