2 * Intel & MS High Precision Event Timer Implementation.
4 * Copyright (C) 2003 Intel Corporation
6 * (c) Copyright 2004 Hewlett-Packard Development Company, L.P.
7 * Bob Picco <robert.picco@hp.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/config.h>
15 #include <linux/interrupt.h>
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/miscdevice.h>
20 #include <linux/major.h>
21 #include <linux/ioport.h>
22 #include <linux/fcntl.h>
23 #include <linux/init.h>
24 #include <linux/poll.h>
25 #include <linux/proc_fs.h>
26 #include <linux/spinlock.h>
27 #include <linux/sysctl.h>
28 #include <linux/wait.h>
29 #include <linux/bcd.h>
30 #include <linux/seq_file.h>
31 #include <linux/bitops.h>
33 #include <asm/current.h>
34 #include <asm/uaccess.h>
35 #include <asm/system.h>
38 #include <asm/div64.h>
40 #include <linux/acpi.h>
41 #include <acpi/acpi_bus.h>
42 #include <linux/hpet.h>
45 * The High Precision Event Timer driver.
46 * This driver is closely modelled after the rtc.c driver.
47 * http://www.intel.com/hardwaredesign/hpetspec.htm
49 #define HPET_USER_FREQ (64)
50 #define HPET_DRIFT (500)
52 #define HPET_RANGE_SIZE 1024 /* from HPET spec */
54 static u32 hpet_nhpet
, hpet_max_freq
= HPET_USER_FREQ
;
56 /* A lock for concurrent access by app and isr hpet activity. */
57 static DEFINE_SPINLOCK(hpet_lock
);
58 /* A lock for concurrent intermodule access to hpet and isr hpet activity. */
59 static DEFINE_SPINLOCK(hpet_task_lock
);
61 #define HPET_DEV_NAME (7)
64 struct hpets
*hd_hpets
;
65 struct hpet __iomem
*hd_hpet
;
66 struct hpet_timer __iomem
*hd_timer
;
67 unsigned long hd_ireqfreq
;
68 unsigned long hd_irqdata
;
69 wait_queue_head_t hd_waitqueue
;
70 struct fasync_struct
*hd_async_queue
;
71 struct hpet_task
*hd_task
;
72 unsigned int hd_flags
;
74 unsigned int hd_hdwirq
;
75 char hd_name
[HPET_DEV_NAME
];
79 struct hpets
*hp_next
;
80 struct hpet __iomem
*hp_hpet
;
81 unsigned long hp_hpet_phys
;
82 struct time_interpolator
*hp_interpolator
;
83 unsigned long long hp_tick_freq
;
84 unsigned long hp_delta
;
85 unsigned int hp_ntimer
;
86 unsigned int hp_which
;
87 struct hpet_dev hp_dev
[1];
90 static struct hpets
*hpets
;
92 #define HPET_OPEN 0x0001
93 #define HPET_IE 0x0002 /* interrupt enabled */
94 #define HPET_PERIODIC 0x0004
95 #define HPET_SHARED_IRQ 0x0008
97 #if BITS_PER_LONG == 64
98 #define write_counter(V, MC) writeq(V, MC)
99 #define read_counter(MC) readq(MC)
101 #define write_counter(V, MC) writel(V, MC)
102 #define read_counter(MC) readl(MC)
106 static inline unsigned long long readq(void __iomem
*addr
)
108 return readl(addr
) | (((unsigned long long)readl(addr
+ 4)) << 32LL);
113 static inline void writeq(unsigned long long v
, void __iomem
*addr
)
115 writel(v
& 0xffffffff, addr
);
116 writel(v
>> 32, addr
+ 4);
120 static irqreturn_t
hpet_interrupt(int irq
, void *data
, struct pt_regs
*regs
)
122 struct hpet_dev
*devp
;
126 isr
= 1 << (devp
- devp
->hd_hpets
->hp_dev
);
128 if ((devp
->hd_flags
& HPET_SHARED_IRQ
) &&
129 !(isr
& readl(&devp
->hd_hpet
->hpet_isr
)))
132 spin_lock(&hpet_lock
);
136 * For non-periodic timers, increment the accumulator.
137 * This has the effect of treating non-periodic like periodic.
139 if ((devp
->hd_flags
& (HPET_IE
| HPET_PERIODIC
)) == HPET_IE
) {
142 t
= devp
->hd_ireqfreq
;
143 m
= read_counter(&devp
->hd_hpet
->hpet_mc
);
144 write_counter(t
+ m
+ devp
->hd_hpets
->hp_delta
,
145 &devp
->hd_timer
->hpet_compare
);
148 if (devp
->hd_flags
& HPET_SHARED_IRQ
)
149 writel(isr
, &devp
->hd_hpet
->hpet_isr
);
150 spin_unlock(&hpet_lock
);
152 spin_lock(&hpet_task_lock
);
154 devp
->hd_task
->ht_func(devp
->hd_task
->ht_data
);
155 spin_unlock(&hpet_task_lock
);
157 wake_up_interruptible(&devp
->hd_waitqueue
);
159 kill_fasync(&devp
->hd_async_queue
, SIGIO
, POLL_IN
);
164 static int hpet_open(struct inode
*inode
, struct file
*file
)
166 struct hpet_dev
*devp
;
170 if (file
->f_mode
& FMODE_WRITE
)
173 spin_lock_irq(&hpet_lock
);
175 for (devp
= NULL
, hpetp
= hpets
; hpetp
&& !devp
; hpetp
= hpetp
->hp_next
)
176 for (i
= 0; i
< hpetp
->hp_ntimer
; i
++)
177 if (hpetp
->hp_dev
[i
].hd_flags
& HPET_OPEN
178 || hpetp
->hp_dev
[i
].hd_task
)
181 devp
= &hpetp
->hp_dev
[i
];
186 spin_unlock_irq(&hpet_lock
);
190 file
->private_data
= devp
;
191 devp
->hd_irqdata
= 0;
192 devp
->hd_flags
|= HPET_OPEN
;
193 spin_unlock_irq(&hpet_lock
);
199 hpet_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
* ppos
)
201 DECLARE_WAITQUEUE(wait
, current
);
204 struct hpet_dev
*devp
;
206 devp
= file
->private_data
;
207 if (!devp
->hd_ireqfreq
)
210 if (count
< sizeof(unsigned long))
213 add_wait_queue(&devp
->hd_waitqueue
, &wait
);
216 set_current_state(TASK_INTERRUPTIBLE
);
218 spin_lock_irq(&hpet_lock
);
219 data
= devp
->hd_irqdata
;
220 devp
->hd_irqdata
= 0;
221 spin_unlock_irq(&hpet_lock
);
225 else if (file
->f_flags
& O_NONBLOCK
) {
228 } else if (signal_pending(current
)) {
229 retval
= -ERESTARTSYS
;
235 retval
= put_user(data
, (unsigned long __user
*)buf
);
237 retval
= sizeof(unsigned long);
239 __set_current_state(TASK_RUNNING
);
240 remove_wait_queue(&devp
->hd_waitqueue
, &wait
);
245 static unsigned int hpet_poll(struct file
*file
, poll_table
* wait
)
248 struct hpet_dev
*devp
;
250 devp
= file
->private_data
;
252 if (!devp
->hd_ireqfreq
)
255 poll_wait(file
, &devp
->hd_waitqueue
, wait
);
257 spin_lock_irq(&hpet_lock
);
258 v
= devp
->hd_irqdata
;
259 spin_unlock_irq(&hpet_lock
);
262 return POLLIN
| POLLRDNORM
;
267 static int hpet_mmap(struct file
*file
, struct vm_area_struct
*vma
)
269 #ifdef CONFIG_HPET_MMAP
270 struct hpet_dev
*devp
;
273 if (((vma
->vm_end
- vma
->vm_start
) != PAGE_SIZE
) || vma
->vm_pgoff
)
276 devp
= file
->private_data
;
277 addr
= devp
->hd_hpets
->hp_hpet_phys
;
279 if (addr
& (PAGE_SIZE
- 1))
282 vma
->vm_flags
|= VM_IO
;
283 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
285 if (io_remap_pfn_range(vma
, vma
->vm_start
, addr
>> PAGE_SHIFT
,
286 PAGE_SIZE
, vma
->vm_page_prot
)) {
287 printk(KERN_ERR
"remap_pfn_range failed in hpet.c\n");
297 static int hpet_fasync(int fd
, struct file
*file
, int on
)
299 struct hpet_dev
*devp
;
301 devp
= file
->private_data
;
303 if (fasync_helper(fd
, file
, on
, &devp
->hd_async_queue
) >= 0)
309 static int hpet_release(struct inode
*inode
, struct file
*file
)
311 struct hpet_dev
*devp
;
312 struct hpet_timer __iomem
*timer
;
315 devp
= file
->private_data
;
316 timer
= devp
->hd_timer
;
318 spin_lock_irq(&hpet_lock
);
320 writeq((readq(&timer
->hpet_config
) & ~Tn_INT_ENB_CNF_MASK
),
321 &timer
->hpet_config
);
326 devp
->hd_ireqfreq
= 0;
328 if (devp
->hd_flags
& HPET_PERIODIC
329 && readq(&timer
->hpet_config
) & Tn_TYPE_CNF_MASK
) {
332 v
= readq(&timer
->hpet_config
);
333 v
^= Tn_TYPE_CNF_MASK
;
334 writeq(v
, &timer
->hpet_config
);
337 devp
->hd_flags
&= ~(HPET_OPEN
| HPET_IE
| HPET_PERIODIC
);
338 spin_unlock_irq(&hpet_lock
);
343 if (file
->f_flags
& FASYNC
)
344 hpet_fasync(-1, file
, 0);
346 file
->private_data
= NULL
;
350 static int hpet_ioctl_common(struct hpet_dev
*, int, unsigned long, int);
353 hpet_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
,
356 struct hpet_dev
*devp
;
358 devp
= file
->private_data
;
359 return hpet_ioctl_common(devp
, cmd
, arg
, 0);
362 static int hpet_ioctl_ieon(struct hpet_dev
*devp
)
364 struct hpet_timer __iomem
*timer
;
365 struct hpet __iomem
*hpet
;
368 unsigned long g
, v
, t
, m
;
369 unsigned long flags
, isr
;
371 timer
= devp
->hd_timer
;
372 hpet
= devp
->hd_hpet
;
373 hpetp
= devp
->hd_hpets
;
375 if (!devp
->hd_ireqfreq
)
378 spin_lock_irq(&hpet_lock
);
380 if (devp
->hd_flags
& HPET_IE
) {
381 spin_unlock_irq(&hpet_lock
);
385 devp
->hd_flags
|= HPET_IE
;
387 if (readl(&timer
->hpet_config
) & Tn_INT_TYPE_CNF_MASK
)
388 devp
->hd_flags
|= HPET_SHARED_IRQ
;
389 spin_unlock_irq(&hpet_lock
);
391 irq
= devp
->hd_hdwirq
;
394 unsigned long irq_flags
;
396 sprintf(devp
->hd_name
, "hpet%d", (int)(devp
- hpetp
->hp_dev
));
397 irq_flags
= devp
->hd_flags
& HPET_SHARED_IRQ
398 ? SA_SHIRQ
: SA_INTERRUPT
;
399 if (request_irq(irq
, hpet_interrupt
, irq_flags
,
400 devp
->hd_name
, (void *)devp
)) {
401 printk(KERN_ERR
"hpet: IRQ %d is not free\n", irq
);
407 spin_lock_irq(&hpet_lock
);
408 devp
->hd_flags
^= HPET_IE
;
409 spin_unlock_irq(&hpet_lock
);
414 t
= devp
->hd_ireqfreq
;
415 v
= readq(&timer
->hpet_config
);
416 g
= v
| Tn_INT_ENB_CNF_MASK
;
418 if (devp
->hd_flags
& HPET_PERIODIC
) {
419 write_counter(t
, &timer
->hpet_compare
);
420 g
|= Tn_TYPE_CNF_MASK
;
421 v
|= Tn_TYPE_CNF_MASK
;
422 writeq(v
, &timer
->hpet_config
);
423 v
|= Tn_VAL_SET_CNF_MASK
;
424 writeq(v
, &timer
->hpet_config
);
425 local_irq_save(flags
);
426 m
= read_counter(&hpet
->hpet_mc
);
427 write_counter(t
+ m
+ hpetp
->hp_delta
, &timer
->hpet_compare
);
429 local_irq_save(flags
);
430 m
= read_counter(&hpet
->hpet_mc
);
431 write_counter(t
+ m
+ hpetp
->hp_delta
, &timer
->hpet_compare
);
434 if (devp
->hd_flags
& HPET_SHARED_IRQ
) {
435 isr
= 1 << (devp
- devp
->hd_hpets
->hp_dev
);
436 writel(isr
, &hpet
->hpet_isr
);
438 writeq(g
, &timer
->hpet_config
);
439 local_irq_restore(flags
);
444 /* converts Hz to number of timer ticks */
445 static inline unsigned long hpet_time_div(struct hpets
*hpets
,
448 unsigned long long m
;
450 m
= hpets
->hp_tick_freq
+ (dis
>> 1);
452 return (unsigned long)m
;
456 hpet_ioctl_common(struct hpet_dev
*devp
, int cmd
, unsigned long arg
, int kernel
)
458 struct hpet_timer __iomem
*timer
;
459 struct hpet __iomem
*hpet
;
470 timer
= devp
->hd_timer
;
471 hpet
= devp
->hd_hpet
;
472 hpetp
= devp
->hd_hpets
;
475 return hpet_ioctl_ieon(devp
);
484 if ((devp
->hd_flags
& HPET_IE
) == 0)
486 v
= readq(&timer
->hpet_config
);
487 v
&= ~Tn_INT_ENB_CNF_MASK
;
488 writeq(v
, &timer
->hpet_config
);
490 free_irq(devp
->hd_irq
, devp
);
493 devp
->hd_flags
^= HPET_IE
;
497 struct hpet_info info
;
499 if (devp
->hd_ireqfreq
)
501 hpet_time_div(hpetp
, devp
->hd_ireqfreq
);
503 info
.hi_ireqfreq
= 0;
505 readq(&timer
->hpet_config
) & Tn_PER_INT_CAP_MASK
;
506 info
.hi_hpet
= hpetp
->hp_which
;
507 info
.hi_timer
= devp
- hpetp
->hp_dev
;
509 memcpy((void *)arg
, &info
, sizeof(info
));
511 if (copy_to_user((void __user
*)arg
, &info
,
517 v
= readq(&timer
->hpet_config
);
518 if ((v
& Tn_PER_INT_CAP_MASK
) == 0) {
522 devp
->hd_flags
|= HPET_PERIODIC
;
525 v
= readq(&timer
->hpet_config
);
526 if ((v
& Tn_PER_INT_CAP_MASK
) == 0) {
530 if (devp
->hd_flags
& HPET_PERIODIC
&&
531 readq(&timer
->hpet_config
) & Tn_TYPE_CNF_MASK
) {
532 v
= readq(&timer
->hpet_config
);
533 v
^= Tn_TYPE_CNF_MASK
;
534 writeq(v
, &timer
->hpet_config
);
536 devp
->hd_flags
&= ~HPET_PERIODIC
;
539 if (!kernel
&& (arg
> hpet_max_freq
) &&
540 !capable(CAP_SYS_RESOURCE
)) {
550 devp
->hd_ireqfreq
= hpet_time_div(hpetp
, arg
);
556 static struct file_operations hpet_fops
= {
557 .owner
= THIS_MODULE
,
563 .release
= hpet_release
,
564 .fasync
= hpet_fasync
,
568 EXPORT_SYMBOL(hpet_alloc
);
569 EXPORT_SYMBOL(hpet_register
);
570 EXPORT_SYMBOL(hpet_unregister
);
571 EXPORT_SYMBOL(hpet_control
);
573 int hpet_register(struct hpet_task
*tp
, int periodic
)
577 struct hpet_timer __iomem
*timer
;
578 struct hpet_dev
*devp
;
583 mask
= Tn_PER_INT_CAP_MASK
;
592 tp
->ht_opaque
= NULL
;
594 spin_lock_irq(&hpet_task_lock
);
595 spin_lock(&hpet_lock
);
597 for (devp
= NULL
, hpetp
= hpets
; hpetp
&& !devp
; hpetp
= hpetp
->hp_next
)
598 for (timer
= hpetp
->hp_hpet
->hpet_timers
, i
= 0;
599 i
< hpetp
->hp_ntimer
; i
++, timer
++) {
600 if ((readq(&timer
->hpet_config
) & Tn_PER_INT_CAP_MASK
)
604 devp
= &hpetp
->hp_dev
[i
];
606 if (devp
->hd_flags
& HPET_OPEN
|| devp
->hd_task
) {
611 tp
->ht_opaque
= devp
;
616 spin_unlock(&hpet_lock
);
617 spin_unlock_irq(&hpet_task_lock
);
625 static inline int hpet_tpcheck(struct hpet_task
*tp
)
627 struct hpet_dev
*devp
;
630 devp
= tp
->ht_opaque
;
635 for (hpetp
= hpets
; hpetp
; hpetp
= hpetp
->hp_next
)
636 if (devp
>= hpetp
->hp_dev
637 && devp
< (hpetp
->hp_dev
+ hpetp
->hp_ntimer
)
638 && devp
->hd_hpet
== hpetp
->hp_hpet
)
644 int hpet_unregister(struct hpet_task
*tp
)
646 struct hpet_dev
*devp
;
647 struct hpet_timer __iomem
*timer
;
650 if ((err
= hpet_tpcheck(tp
)))
653 spin_lock_irq(&hpet_task_lock
);
654 spin_lock(&hpet_lock
);
656 devp
= tp
->ht_opaque
;
657 if (devp
->hd_task
!= tp
) {
658 spin_unlock(&hpet_lock
);
659 spin_unlock_irq(&hpet_task_lock
);
663 timer
= devp
->hd_timer
;
664 writeq((readq(&timer
->hpet_config
) & ~Tn_INT_ENB_CNF_MASK
),
665 &timer
->hpet_config
);
666 devp
->hd_flags
&= ~(HPET_IE
| HPET_PERIODIC
);
667 devp
->hd_task
= NULL
;
668 spin_unlock(&hpet_lock
);
669 spin_unlock_irq(&hpet_task_lock
);
674 int hpet_control(struct hpet_task
*tp
, unsigned int cmd
, unsigned long arg
)
676 struct hpet_dev
*devp
;
679 if ((err
= hpet_tpcheck(tp
)))
682 spin_lock_irq(&hpet_lock
);
683 devp
= tp
->ht_opaque
;
684 if (devp
->hd_task
!= tp
) {
685 spin_unlock_irq(&hpet_lock
);
688 spin_unlock_irq(&hpet_lock
);
689 return hpet_ioctl_common(devp
, cmd
, arg
, 1);
692 static ctl_table hpet_table
[] = {
695 .procname
= "max-user-freq",
696 .data
= &hpet_max_freq
,
697 .maxlen
= sizeof(int),
699 .proc_handler
= &proc_dointvec
,
704 static ctl_table hpet_root
[] = {
715 static ctl_table dev_root
[] = {
726 static struct ctl_table_header
*sysctl_header
;
728 static void hpet_register_interpolator(struct hpets
*hpetp
)
730 #ifdef CONFIG_TIME_INTERPOLATION
731 struct time_interpolator
*ti
;
733 ti
= kmalloc(sizeof(*ti
), GFP_KERNEL
);
737 memset(ti
, 0, sizeof(*ti
));
738 ti
->source
= TIME_SOURCE_MMIO64
;
740 ti
->addr
= &hpetp
->hp_hpet
->hpet_mc
;
741 ti
->frequency
= hpetp
->hp_tick_freq
;
742 ti
->drift
= HPET_DRIFT
;
745 hpetp
->hp_interpolator
= ti
;
746 register_time_interpolator(ti
);
751 * Adjustment for when arming the timer with
752 * initial conditions. That is, main counter
753 * ticks expired before interrupts are enabled.
755 #define TICK_CALIBRATE (1000UL)
757 static unsigned long hpet_calibrate(struct hpets
*hpetp
)
759 struct hpet_timer __iomem
*timer
= NULL
;
760 unsigned long t
, m
, count
, i
, flags
, start
;
761 struct hpet_dev
*devp
;
763 struct hpet __iomem
*hpet
;
765 for (j
= 0, devp
= hpetp
->hp_dev
; j
< hpetp
->hp_ntimer
; j
++, devp
++)
766 if ((devp
->hd_flags
& HPET_OPEN
) == 0) {
767 timer
= devp
->hd_timer
;
774 hpet
= hpetp
->hp_hpet
;
775 t
= read_counter(&timer
->hpet_compare
);
778 count
= hpet_time_div(hpetp
, TICK_CALIBRATE
);
780 local_irq_save(flags
);
782 start
= read_counter(&hpet
->hpet_mc
);
785 m
= read_counter(&hpet
->hpet_mc
);
786 write_counter(t
+ m
+ hpetp
->hp_delta
, &timer
->hpet_compare
);
787 } while (i
++, (m
- start
) < count
);
789 local_irq_restore(flags
);
791 return (m
- start
) / i
;
794 int hpet_alloc(struct hpet_data
*hdp
)
797 struct hpet_dev
*devp
;
801 struct hpet __iomem
*hpet
;
802 static struct hpets
*last
= (struct hpets
*)0;
803 unsigned long period
;
804 unsigned long long temp
;
807 * hpet_alloc can be called by platform dependent code.
808 * if platform dependent code has allocated the hpet
809 * ACPI also reports hpet, then we catch it here.
811 for (hpetp
= hpets
; hpetp
; hpetp
= hpetp
->hp_next
)
812 if (hpetp
->hp_hpet_phys
== hdp
->hd_phys_address
) {
813 printk(KERN_DEBUG
"%s: duplicate HPET ignored\n",
818 siz
= sizeof(struct hpets
) + ((hdp
->hd_nirqs
- 1) *
819 sizeof(struct hpet_dev
));
821 hpetp
= kmalloc(siz
, GFP_KERNEL
);
826 memset(hpetp
, 0, siz
);
828 hpetp
->hp_which
= hpet_nhpet
++;
829 hpetp
->hp_hpet
= hdp
->hd_address
;
830 hpetp
->hp_hpet_phys
= hdp
->hd_phys_address
;
832 hpetp
->hp_ntimer
= hdp
->hd_nirqs
;
834 for (i
= 0; i
< hdp
->hd_nirqs
; i
++)
835 hpetp
->hp_dev
[i
].hd_hdwirq
= hdp
->hd_irq
[i
];
837 hpet
= hpetp
->hp_hpet
;
839 cap
= readq(&hpet
->hpet_cap
);
841 ntimer
= ((cap
& HPET_NUM_TIM_CAP_MASK
) >> HPET_NUM_TIM_CAP_SHIFT
) + 1;
843 if (hpetp
->hp_ntimer
!= ntimer
) {
844 printk(KERN_WARNING
"hpet: number irqs doesn't agree"
845 " with number of timers\n");
851 last
->hp_next
= hpetp
;
857 period
= (cap
& HPET_COUNTER_CLK_PERIOD_MASK
) >>
858 HPET_COUNTER_CLK_PERIOD_SHIFT
; /* fs, 10^-15 */
859 temp
= 1000000000000000uLL; /* 10^15 femtoseconds per second */
860 temp
+= period
>> 1; /* round */
861 do_div(temp
, period
);
862 hpetp
->hp_tick_freq
= temp
; /* ticks per second */
864 printk(KERN_INFO
"hpet%d: at MMIO 0x%lx (virtual 0x%p), IRQ%s",
865 hpetp
->hp_which
, hdp
->hd_phys_address
, hdp
->hd_address
,
866 hpetp
->hp_ntimer
> 1 ? "s" : "");
867 for (i
= 0; i
< hpetp
->hp_ntimer
; i
++)
868 printk("%s %d", i
> 0 ? "," : "", hdp
->hd_irq
[i
]);
871 printk(KERN_INFO
"hpet%u: %u %d-bit timers, %Lu Hz\n",
872 hpetp
->hp_which
, hpetp
->hp_ntimer
,
873 cap
& HPET_COUNTER_SIZE_MASK
? 64 : 32, hpetp
->hp_tick_freq
);
875 mcfg
= readq(&hpet
->hpet_config
);
876 if ((mcfg
& HPET_ENABLE_CNF_MASK
) == 0) {
877 write_counter(0L, &hpet
->hpet_mc
);
878 mcfg
|= HPET_ENABLE_CNF_MASK
;
879 writeq(mcfg
, &hpet
->hpet_config
);
882 for (i
= 0, devp
= hpetp
->hp_dev
; i
< hpetp
->hp_ntimer
; i
++, devp
++) {
883 struct hpet_timer __iomem
*timer
;
885 timer
= &hpet
->hpet_timers
[devp
- hpetp
->hp_dev
];
887 devp
->hd_hpets
= hpetp
;
888 devp
->hd_hpet
= hpet
;
889 devp
->hd_timer
= timer
;
892 * If the timer was reserved by platform code,
893 * then make timer unavailable for opens.
895 if (hdp
->hd_state
& (1 << i
)) {
896 devp
->hd_flags
= HPET_OPEN
;
900 init_waitqueue_head(&devp
->hd_waitqueue
);
903 hpetp
->hp_delta
= hpet_calibrate(hpetp
);
904 hpet_register_interpolator(hpetp
);
909 static acpi_status
hpet_resources(struct acpi_resource
*res
, void *data
)
911 struct hpet_data
*hdp
;
913 struct acpi_resource_address64 addr
;
918 status
= acpi_resource_to_address64(res
, &addr
);
920 if (ACPI_SUCCESS(status
)) {
923 size
= addr
.max_address_range
- addr
.min_address_range
+ 1;
924 hdp
->hd_phys_address
= addr
.min_address_range
;
925 hdp
->hd_address
= ioremap(addr
.min_address_range
, size
);
927 for (hpetp
= hpets
; hpetp
; hpetp
= hpetp
->hp_next
)
928 if (hpetp
->hp_hpet_phys
== hdp
->hd_phys_address
) {
929 printk(KERN_DEBUG
"%s: 0x%lx is busy\n",
930 __FUNCTION__
, hdp
->hd_phys_address
);
931 iounmap(hdp
->hd_address
);
934 } else if (res
->id
== ACPI_RSTYPE_FIXED_MEM32
) {
935 struct acpi_resource_fixed_mem32
*fixmem32
;
937 fixmem32
= &res
->data
.fixed_memory32
;
941 hdp
->hd_phys_address
= fixmem32
->range_base_address
;
942 hdp
->hd_address
= ioremap(fixmem32
->range_base_address
,
945 for (hpetp
= hpets
; hpetp
; hpetp
= hpetp
->hp_next
)
946 if (hpetp
->hp_hpet_phys
== hdp
->hd_phys_address
) {
947 printk(KERN_DEBUG
"%s: 0x%lx is busy\n",
948 __FUNCTION__
, hdp
->hd_phys_address
);
949 iounmap(hdp
->hd_address
);
952 } else if (res
->id
== ACPI_RSTYPE_EXT_IRQ
) {
953 struct acpi_resource_ext_irq
*irqp
;
956 irqp
= &res
->data
.extended_irq
;
958 if (irqp
->number_of_interrupts
> 0) {
959 hdp
->hd_nirqs
= irqp
->number_of_interrupts
;
961 for (i
= 0; i
< hdp
->hd_nirqs
; i
++) {
963 acpi_register_gsi(irqp
->interrupts
[i
],
965 irqp
->active_high_low
);
976 static int hpet_acpi_add(struct acpi_device
*device
)
979 struct hpet_data data
;
981 memset(&data
, 0, sizeof(data
));
984 acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
985 hpet_resources
, &data
);
987 if (ACPI_FAILURE(result
))
990 if (!data
.hd_address
|| !data
.hd_nirqs
) {
991 printk("%s: no address or irqs in _CRS\n", __FUNCTION__
);
995 return hpet_alloc(&data
);
998 static int hpet_acpi_remove(struct acpi_device
*device
, int type
)
1000 /* XXX need to unregister interpolator, dealloc mem, etc */
1004 static struct acpi_driver hpet_acpi_driver
= {
1008 .add
= hpet_acpi_add
,
1009 .remove
= hpet_acpi_remove
,
1013 static struct miscdevice hpet_misc
= { HPET_MINOR
, "hpet", &hpet_fops
};
1015 static int __init
hpet_init(void)
1019 result
= misc_register(&hpet_misc
);
1023 sysctl_header
= register_sysctl_table(dev_root
, 0);
1025 result
= acpi_bus_register_driver(&hpet_acpi_driver
);
1028 unregister_sysctl_table(sysctl_header
);
1029 misc_deregister(&hpet_misc
);
1036 static void __exit
hpet_exit(void)
1038 acpi_bus_unregister_driver(&hpet_acpi_driver
);
1041 unregister_sysctl_table(sysctl_header
);
1042 misc_deregister(&hpet_misc
);
1047 module_init(hpet_init
);
1048 module_exit(hpet_exit
);
1049 MODULE_AUTHOR("Bob Picco <Robert.Picco@hp.com>");
1050 MODULE_LICENSE("GPL");