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