X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Fchar%2Fhpet.c;h=20dc3be5ecfcf8fe987e41313902f41acdc4a2e0;hb=97bf2856c6014879bd04983a3e9dfcdac1e7fe85;hp=cef6032b84e2e7a3d8fb41880ff93407dcadcab7;hpb=5fc42a6ed0ec81088c37caadb45898ae6cd0ad2c;p=linux-2.6.git diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c index cef6032b8..20dc3be5e 100644 --- a/drivers/char/hpet.c +++ b/drivers/char/hpet.c @@ -1,11 +1,16 @@ /* * Intel & MS High Precision Event Timer Implementation. - * Contributors: + * + * Copyright (C) 2003 Intel Corporation * Venki Pallipadi - * Bob Picco + * (c) Copyright 2004 Hewlett-Packard Development Company, L.P. + * Bob Picco + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. */ -#include #include #include #include @@ -16,19 +21,20 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include #include #include #include #include -#include #include #include @@ -38,22 +44,26 @@ /* * The High Precision Event Timer driver. * This driver is closely modelled after the rtc.c driver. - * http://www.intel.com/labs/platcomp/hpet/hpetspec.htm + * http://www.intel.com/hardwaredesign/hpetspec.htm */ #define HPET_USER_FREQ (64) #define HPET_DRIFT (500) -static u32 hpet_ntimer, hpet_nhpet, hpet_max_freq = HPET_USER_FREQ; +#define HPET_RANGE_SIZE 1024 /* from HPET spec */ + +static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ; /* A lock for concurrent access by app and isr hpet activity. */ -static spinlock_t hpet_lock = SPIN_LOCK_UNLOCKED; +static DEFINE_SPINLOCK(hpet_lock); /* A lock for concurrent intermodule access to hpet and isr hpet activity. */ -static spinlock_t hpet_task_lock = SPIN_LOCK_UNLOCKED; +static DEFINE_SPINLOCK(hpet_task_lock); + +#define HPET_DEV_NAME (7) struct hpet_dev { struct hpets *hd_hpets; - struct hpet *hd_hpet; - struct hpet_timer *hd_timer; + struct hpet __iomem *hd_hpet; + struct hpet_timer __iomem *hd_timer; unsigned long hd_ireqfreq; unsigned long hd_irqdata; wait_queue_head_t hd_waitqueue; @@ -62,12 +72,15 @@ struct hpet_dev { unsigned int hd_flags; unsigned int hd_irq; unsigned int hd_hdwirq; + char hd_name[HPET_DEV_NAME]; }; struct hpets { struct hpets *hp_next; - struct hpet *hp_hpet; - unsigned long hp_period; + struct hpet __iomem *hp_hpet; + unsigned long hp_hpet_phys; + struct time_interpolator *hp_interpolator; + unsigned long long hp_tick_freq; unsigned long hp_delta; unsigned int hp_ntimer; unsigned int hp_which; @@ -79,6 +92,7 @@ static struct hpets *hpets; #define HPET_OPEN 0x0001 #define HPET_IE 0x0002 /* interrupt enabled */ #define HPET_PERIODIC 0x0004 +#define HPET_SHARED_IRQ 0x0008 #if BITS_PER_LONG == 64 #define write_counter(V, MC) writeq(V, MC) @@ -89,26 +103,31 @@ static struct hpets *hpets; #endif #ifndef readq -static unsigned long long __inline readq(void *addr) +static inline unsigned long long readq(void __iomem *addr) { return readl(addr) | (((unsigned long long)readl(addr + 4)) << 32LL); } #endif #ifndef writeq -static void __inline writeq(unsigned long long v, void *addr) +static inline void writeq(unsigned long long v, void __iomem *addr) { writel(v & 0xffffffff, addr); writel(v >> 32, addr + 4); } #endif -static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs) +static irqreturn_t hpet_interrupt(int irq, void *data) { struct hpet_dev *devp; unsigned long isr; devp = data; + isr = 1 << (devp - devp->hd_hpets->hp_dev); + + if ((devp->hd_flags & HPET_SHARED_IRQ) && + !(isr & readl(&devp->hd_hpet->hpet_isr))) + return IRQ_NONE; spin_lock(&hpet_lock); devp->hd_irqdata++; @@ -126,8 +145,8 @@ static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs) &devp->hd_timer->hpet_compare); } - isr = (1 << (devp - devp->hd_hpets->hp_dev)); - writeq(isr, &devp->hd_hpet->hpet_isr); + if (devp->hd_flags & HPET_SHARED_IRQ) + writel(isr, &devp->hd_hpet->hpet_isr); spin_unlock(&hpet_lock); spin_lock(&hpet_task_lock); @@ -148,6 +167,9 @@ static int hpet_open(struct inode *inode, struct file *file) struct hpets *hpetp; int i; + if (file->f_mode & FMODE_WRITE) + return -EINVAL; + spin_lock_irq(&hpet_lock); for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next) @@ -174,7 +196,7 @@ static int hpet_open(struct inode *inode, struct file *file) } static ssize_t -hpet_read(struct file *file, char *buf, size_t count, loff_t * ppos) +hpet_read(struct file *file, char __user *buf, size_t count, loff_t * ppos) { DECLARE_WAITQUEUE(wait, current); unsigned long data; @@ -190,8 +212,8 @@ hpet_read(struct file *file, char *buf, size_t count, loff_t * ppos) add_wait_queue(&devp->hd_waitqueue, &wait); - do { - __set_current_state(TASK_INTERRUPTIBLE); + for ( ; ; ) { + set_current_state(TASK_INTERRUPTIBLE); spin_lock_irq(&hpet_lock); data = devp->hd_irqdata; @@ -207,16 +229,14 @@ hpet_read(struct file *file, char *buf, size_t count, loff_t * ppos) retval = -ERESTARTSYS; goto out; } - schedule(); + } - } while (1); - - retval = put_user(data, (unsigned long *)buf); + retval = put_user(data, (unsigned long __user *)buf); if (!retval) retval = sizeof(unsigned long); - out: - current->state = TASK_RUNNING; +out: + __set_current_state(TASK_RUNNING); remove_wait_queue(&devp->hd_waitqueue, &wait); return retval; @@ -246,35 +266,32 @@ static unsigned int hpet_poll(struct file *file, poll_table * wait) static int hpet_mmap(struct file *file, struct vm_area_struct *vma) { -#ifdef CONFIG_HPET_NOMMAP - return -ENOSYS; -#else +#ifdef CONFIG_HPET_MMAP struct hpet_dev *devp; unsigned long addr; if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) || vma->vm_pgoff) return -EINVAL; - if (vma->vm_flags & VM_WRITE) - return -EPERM; - devp = file->private_data; - addr = (unsigned long)devp->hd_hpet; + addr = devp->hd_hpets->hp_hpet_phys; if (addr & (PAGE_SIZE - 1)) return -ENOSYS; vma->vm_flags |= VM_IO; vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); - addr = __pa(addr); - if (remap_page_range - (vma, vma->vm_start, addr, PAGE_SIZE, vma->vm_page_prot)) { - printk(KERN_ERR "remap_page_range failed in hpet.c\n"); + if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT, + PAGE_SIZE, vma->vm_page_prot)) { + printk(KERN_ERR "%s: io_remap_pfn_range failed\n", + __FUNCTION__); return -EAGAIN; } return 0; +#else + return -ENOSYS; #endif } @@ -293,7 +310,7 @@ static int hpet_fasync(int fd, struct file *file, int on) static int hpet_release(struct inode *inode, struct file *file) { struct hpet_dev *devp; - struct hpet_timer *timer; + struct hpet_timer __iomem *timer; int irq = 0; devp = file->private_data; @@ -327,7 +344,7 @@ static int hpet_release(struct inode *inode, struct file *file) if (file->f_flags & FASYNC) hpet_fasync(-1, file, 0); - file->private_data = 0; + file->private_data = NULL; return 0; } @@ -345,8 +362,8 @@ hpet_ioctl(struct inode *inode, struct file *file, unsigned int cmd, static int hpet_ioctl_ieon(struct hpet_dev *devp) { - struct hpet_timer *timer; - struct hpet *hpet; + struct hpet_timer __iomem *timer; + struct hpet __iomem *hpet; struct hpets *hpetp; int irq; unsigned long g, v, t, m; @@ -356,7 +373,9 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp) hpet = devp->hd_hpet; hpetp = devp->hd_hpets; - v = readq(&timer->hpet_config); + if (!devp->hd_ireqfreq) + return -EIO; + spin_lock_irq(&hpet_lock); if (devp->hd_flags & HPET_IE) { @@ -365,18 +384,21 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp) } devp->hd_flags |= HPET_IE; + + if (readl(&timer->hpet_config) & Tn_INT_TYPE_CNF_MASK) + devp->hd_flags |= HPET_SHARED_IRQ; spin_unlock_irq(&hpet_lock); - t = readq(&timer->hpet_config); irq = devp->hd_hdwirq; if (irq) { - char name[7]; - - sprintf(name, "hpet%d", (int)(devp - hpetp->hp_dev)); + unsigned long irq_flags; - if (request_irq - (irq, hpet_interrupt, SA_INTERRUPT, name, (void *)devp)) { + sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev)); + irq_flags = devp->hd_flags & HPET_SHARED_IRQ + ? IRQF_SHARED : IRQF_DISABLED; + if (request_irq(irq, hpet_interrupt, irq_flags, + devp->hd_name, (void *)devp)) { printk(KERN_ERR "hpet: IRQ %d is not free\n", irq); irq = 0; } @@ -410,28 +432,32 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp) write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare); } - isr = (1 << (devp - hpets->hp_dev)); - writeq(isr, &hpet->hpet_isr); + if (devp->hd_flags & HPET_SHARED_IRQ) { + isr = 1 << (devp - devp->hd_hpets->hp_dev); + writel(isr, &hpet->hpet_isr); + } writeq(g, &timer->hpet_config); local_irq_restore(flags); return 0; } -static inline unsigned long hpet_time_div(unsigned long dis) +/* converts Hz to number of timer ticks */ +static inline unsigned long hpet_time_div(struct hpets *hpets, + unsigned long dis) { - unsigned long long m = 1000000000000000ULL; + unsigned long long m; + m = hpets->hp_tick_freq + (dis >> 1); do_div(m, dis); - return (unsigned long)m; } static int hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) { - struct hpet_timer *timer; - struct hpet *hpet; + struct hpet_timer __iomem *timer; + struct hpet __iomem *hpet; struct hpets *hpetp; int err; unsigned long v; @@ -471,14 +497,21 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) { struct hpet_info info; - info.hi_ireqfreq = hpet_time_div(hpetp->hp_period * - devp->hd_ireqfreq); + if (devp->hd_ireqfreq) + info.hi_ireqfreq = + hpet_time_div(hpetp, devp->hd_ireqfreq); + else + info.hi_ireqfreq = 0; info.hi_flags = readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK; - info.hi_hpet = devp->hd_hpets->hp_which; - info.hi_timer = devp - devp->hd_hpets->hp_dev; - if (copy_to_user((void *)arg, &info, sizeof(info))) - err = -EFAULT; + info.hi_hpet = hpetp->hp_which; + info.hi_timer = devp - hpetp->hp_dev; + if (kernel) + memcpy((void *)arg, &info, sizeof(info)); + else + if (copy_to_user((void __user *)arg, &info, + sizeof(info))) + err = -EFAULT; break; } case HPET_EPI: @@ -510,18 +543,18 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) break; } - if (arg & (arg - 1)) { + if (!arg) { err = -EINVAL; break; } - devp->hd_ireqfreq = hpet_time_div(hpetp->hp_period * arg); + devp->hd_ireqfreq = hpet_time_div(hpetp, arg); } return err; } -static struct file_operations hpet_fops = { +static const struct file_operations hpet_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .read = hpet_read, @@ -533,6 +566,17 @@ static struct file_operations hpet_fops = { .mmap = hpet_mmap, }; +static int hpet_is_known(struct hpet_data *hdp) +{ + struct hpets *hpetp; + + for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next) + if (hpetp->hp_hpet_phys == hdp->hd_phys_address) + return 1; + + return 0; +} + EXPORT_SYMBOL(hpet_alloc); EXPORT_SYMBOL(hpet_register); EXPORT_SYMBOL(hpet_unregister); @@ -542,7 +586,7 @@ int hpet_register(struct hpet_task *tp, int periodic) { unsigned int i; u64 mask; - struct hpet_timer *timer; + struct hpet_timer __iomem *timer; struct hpet_dev *devp; struct hpets *hpetp; @@ -557,10 +601,12 @@ int hpet_register(struct hpet_task *tp, int periodic) return -EINVAL; } + tp->ht_opaque = NULL; + spin_lock_irq(&hpet_task_lock); spin_lock(&hpet_lock); - for (devp = 0, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next) + for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next) for (timer = hpetp->hp_hpet->hpet_timers, i = 0; i < hpetp->hp_ntimer; i++, timer++) { if ((readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK) @@ -570,7 +616,7 @@ int hpet_register(struct hpet_task *tp, int periodic) devp = &hpetp->hp_dev[i]; if (devp->hd_flags & HPET_OPEN || devp->hd_task) { - devp = 0; + devp = NULL; continue; } @@ -610,7 +656,7 @@ static inline int hpet_tpcheck(struct hpet_task *tp) int hpet_unregister(struct hpet_task *tp) { struct hpet_dev *devp; - struct hpet_timer *timer; + struct hpet_timer __iomem *timer; int err; if ((err = hpet_tpcheck(tp))) @@ -630,7 +676,7 @@ int hpet_unregister(struct hpet_task *tp) writeq((readq(&timer->hpet_config) & ~Tn_INT_ENB_CNF_MASK), &timer->hpet_config); devp->hd_flags &= ~(HPET_IE | HPET_PERIODIC); - devp->hd_task = 0; + devp->hd_task = NULL; spin_unlock(&hpet_lock); spin_unlock_irq(&hpet_task_lock); @@ -655,46 +701,6 @@ int hpet_control(struct hpet_task *tp, unsigned int cmd, unsigned long arg) return hpet_ioctl_common(devp, cmd, arg, 1); } -#ifdef CONFIG_TIME_INTERPOLATION - -static unsigned long hpet_offset, last_wall_hpet; -static long hpet_nsecs_per_cycle, hpet_cycles_per_sec; - -static unsigned long hpet_getoffset(void) -{ - return hpet_offset + (read_counter(&hpets->hp_hpet->hpet_mc) - - last_wall_hpet) * hpet_nsecs_per_cycle; -} - -static void hpet_update(long delta) -{ - unsigned long mc; - unsigned long offset; - - mc = read_counter(&hpets->hp_hpet->hpet_mc); - offset = hpet_offset + (mc - last_wall_hpet) * hpet_nsecs_per_cycle; - - if (delta < 0 || (unsigned long)delta < offset) - hpet_offset = offset - delta; - else - hpet_offset = 0; - last_wall_hpet = mc; -} - -static void hpet_reset(void) -{ - hpet_offset = 0; - last_wall_hpet = read_counter(&hpets->hp_hpet->hpet_mc); -} - -static struct time_interpolator hpet_interpolator = { - .get_offset = hpet_getoffset, - .update = hpet_update, - .reset = hpet_reset -}; - -#endif - static ctl_table hpet_table[] = { { .ctl_name = 1, @@ -731,73 +737,27 @@ static ctl_table dev_root[] = { static struct ctl_table_header *sysctl_header; -static void *hpet_start(struct seq_file *s, loff_t * pos) +static void hpet_register_interpolator(struct hpets *hpetp) { - struct hpets *hpetp; - loff_t n; - - for (n = *pos, hpetp = hpets; hpetp; hpetp = hpetp->hp_next) - if (!n--) - return hpetp; - - return 0; -} - -static void *hpet_next(struct seq_file *s, void *v, loff_t * pos) -{ - struct hpets *hpetp; - - hpetp = v; - ++*pos; - return hpetp->hp_next; -} - -static void hpet_stop(struct seq_file *s, void *v) -{ - return; -} - -static int hpet_show(struct seq_file *s, void *v) -{ - struct hpets *hpetp; - struct hpet *hpet; - u64 cap, vendor, period; - - hpetp = v; - hpet = hpetp->hp_hpet; - - cap = readq(&hpet->hpet_cap); - period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >> - HPET_COUNTER_CLK_PERIOD_SHIFT; - vendor = (cap & HPET_VENDOR_ID_MASK) >> HPET_VENDOR_ID_SHIFT; - - seq_printf(s, - "HPET%d period = %d 10**-15 vendor = 0x%x number timer = %d\n", - hpetp->hp_which, (u32) period, (u32) vendor, - hpetp->hp_ntimer); +#ifdef CONFIG_TIME_INTERPOLATION + struct time_interpolator *ti; - return 0; -} + ti = kzalloc(sizeof(*ti), GFP_KERNEL); + if (!ti) + return; -static struct seq_operations hpet_seq_ops = { - .start = hpet_start, - .next = hpet_next, - .stop = hpet_stop, - .show = hpet_show -}; + ti->source = TIME_SOURCE_MMIO64; + ti->shift = 10; + ti->addr = &hpetp->hp_hpet->hpet_mc; + ti->frequency = hpetp->hp_tick_freq; + ti->drift = HPET_DRIFT; + ti->mask = -1; -static int hpet_proc_open(struct inode *inode, struct file *file) -{ - return seq_open(file, &hpet_seq_ops); + hpetp->hp_interpolator = ti; + register_time_interpolator(ti); +#endif } -static struct file_operations hpet_proc_fops = { - .open = hpet_proc_open, - .read = seq_read, - .llseek = seq_lseek, - .release = seq_release -}; - /* * Adjustment for when arming the timer with * initial conditions. That is, main counter @@ -805,16 +765,15 @@ static struct file_operations hpet_proc_fops = { */ #define TICK_CALIBRATE (1000UL) -static unsigned long __init hpet_calibrate(struct hpets *hpetp) +static unsigned long hpet_calibrate(struct hpets *hpetp) { - struct hpet_timer *timer; + struct hpet_timer __iomem *timer = NULL; unsigned long t, m, count, i, flags, start; struct hpet_dev *devp; int j; - struct hpet *hpet; + struct hpet __iomem *hpet; - for (timer = 0, j = 0, devp = hpetp->hp_dev; j < hpetp->hp_ntimer; - j++, devp++) + for (j = 0, devp = hpetp->hp_dev; j < hpetp->hp_ntimer; j++, devp++) if ((devp->hd_flags & HPET_OPEN) == 0) { timer = devp->hd_timer; break; @@ -823,11 +782,11 @@ static unsigned long __init hpet_calibrate(struct hpets *hpetp) if (!timer) return 0; - hpet = hpets->hp_hpet; + hpet = hpetp->hp_hpet; t = read_counter(&timer->hpet_compare); i = 0; - count = hpet_time_div(hpetp->hp_period * TICK_CALIBRATE); + count = hpet_time_div(hpetp, TICK_CALIBRATE); local_irq_save(flags); @@ -843,37 +802,40 @@ static unsigned long __init hpet_calibrate(struct hpets *hpetp) return (m - start) / i; } -int __init hpet_alloc(struct hpet_data *hdp) +int hpet_alloc(struct hpet_data *hdp) { u64 cap, mcfg; struct hpet_dev *devp; u32 i, ntimer; struct hpets *hpetp; size_t siz; - struct hpet *hpet; - static struct hpets *last __initdata = (struct hpets *)0; + struct hpet __iomem *hpet; + static struct hpets *last = NULL; + unsigned long period; + unsigned long long temp; /* * hpet_alloc can be called by platform dependent code. - * if platform dependent code has allocated the hpet - * ACPI also reports hpet, then we catch it here. + * If platform dependent code has allocated the hpet that + * ACPI has also reported, then we catch it here. */ - for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next) - if (hpetp->hp_hpet == (struct hpet *)(hdp->hd_address)) - return 0; + if (hpet_is_known(hdp)) { + printk(KERN_DEBUG "%s: duplicate HPET ignored\n", + __FUNCTION__); + return 0; + } siz = sizeof(struct hpets) + ((hdp->hd_nirqs - 1) * sizeof(struct hpet_dev)); - hpetp = kmalloc(siz, GFP_KERNEL); + hpetp = kzalloc(siz, GFP_KERNEL); if (!hpetp) return -ENOMEM; - memset(hpetp, 0, siz); - hpetp->hp_which = hpet_nhpet++; - hpetp->hp_hpet = (struct hpet *)hdp->hd_address; + hpetp->hp_hpet = hdp->hd_address; + hpetp->hp_hpet_phys = hdp->hd_phys_address; hpetp->hp_ntimer = hdp->hd_nirqs; @@ -900,8 +862,23 @@ int __init hpet_alloc(struct hpet_data *hdp) last = hpetp; - hpetp->hp_period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >> - HPET_COUNTER_CLK_PERIOD_SHIFT; + period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >> + HPET_COUNTER_CLK_PERIOD_SHIFT; /* fs, 10^-15 */ + temp = 1000000000000000uLL; /* 10^15 femtoseconds per second */ + temp += period >> 1; /* round */ + do_div(temp, period); + hpetp->hp_tick_freq = temp; /* ticks per second */ + + printk(KERN_INFO "hpet%d: at MMIO 0x%lx, IRQ%s", + hpetp->hp_which, hdp->hd_phys_address, + hpetp->hp_ntimer > 1 ? "s" : ""); + for (i = 0; i < hpetp->hp_ntimer; i++) + printk("%s %d", i > 0 ? "," : "", hdp->hd_irq[i]); + printk("\n"); + + printk(KERN_INFO "hpet%u: %u %d-bit timers, %Lu Hz\n", + hpetp->hp_which, hpetp->hp_ntimer, + cap & HPET_COUNTER_SIZE_MASK ? 64 : 32, hpetp->hp_tick_freq); mcfg = readq(&hpet->hpet_config); if ((mcfg & HPET_ENABLE_CNF_MASK) == 0) { @@ -910,13 +887,10 @@ int __init hpet_alloc(struct hpet_data *hdp) writeq(mcfg, &hpet->hpet_config); } - for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer; - i++, hpet_ntimer++, devp++) { - unsigned long v; - struct hpet_timer *timer; + for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer; i++, devp++) { + struct hpet_timer __iomem *timer; timer = &hpet->hpet_timers[devp - hpetp->hp_dev]; - v = readq(&timer->hpet_config); devp->hd_hpets = hpetp; devp->hd_hpet = hpet; @@ -935,56 +909,69 @@ int __init hpet_alloc(struct hpet_data *hdp) } hpetp->hp_delta = hpet_calibrate(hpetp); + hpet_register_interpolator(hpetp); return 0; } -static acpi_status __init hpet_resources(struct acpi_resource *res, void *data) +static acpi_status hpet_resources(struct acpi_resource *res, void *data) { struct hpet_data *hdp; acpi_status status; struct acpi_resource_address64 addr; - struct hpets *hpetp; hdp = data; status = acpi_resource_to_address64(res, &addr); if (ACPI_SUCCESS(status)) { - unsigned long size; - - size = addr.max_address_range - addr.min_address_range + 1; - hdp->hd_address = - (unsigned long)ioremap(addr.min_address_range, size); - - for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next) - if (hpetp->hp_hpet == (struct hpet *)(hdp->hd_address)) - return -EBUSY; - } else if (res->id == ACPI_RSTYPE_EXT_IRQ) { - struct acpi_resource_ext_irq *irqp; - int i; + hdp->hd_phys_address = addr.minimum; + hdp->hd_address = ioremap(addr.minimum, addr.address_length); + + if (hpet_is_known(hdp)) { + printk(KERN_DEBUG "%s: 0x%lx is busy\n", + __FUNCTION__, hdp->hd_phys_address); + iounmap(hdp->hd_address); + return -EBUSY; + } + } else if (res->type == ACPI_RESOURCE_TYPE_FIXED_MEMORY32) { + struct acpi_resource_fixed_memory32 *fixmem32; + + fixmem32 = &res->data.fixed_memory32; + if (!fixmem32) + return -EINVAL; + + hdp->hd_phys_address = fixmem32->address; + hdp->hd_address = ioremap(fixmem32->address, + HPET_RANGE_SIZE); + + if (hpet_is_known(hdp)) { + printk(KERN_DEBUG "%s: 0x%lx is busy\n", + __FUNCTION__, hdp->hd_phys_address); + iounmap(hdp->hd_address); + return -EBUSY; + } + } else if (res->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) { + struct acpi_resource_extended_irq *irqp; + int i, irq; irqp = &res->data.extended_irq; - if (irqp->number_of_interrupts > 0) { - hdp->hd_nirqs = irqp->number_of_interrupts; + for (i = 0; i < irqp->interrupt_count; i++) { + irq = acpi_register_gsi(irqp->interrupts[i], + irqp->triggering, irqp->polarity); + if (irq < 0) + return AE_ERROR; - for (i = 0; i < hdp->hd_nirqs; i++) -#ifdef CONFIG_IA64 - hdp->hd_irq[i] = - acpi_register_gsi(irqp->interrupts[i], - irqp->edge_level, - irqp->active_high_low); -#else - hdp->hd_irq[i] = irqp->interrupts[i]; -#endif + hdp->hd_irq[hdp->hd_nirqs] = irq; + hdp->hd_nirqs++; } } return AE_OK; } -static int __init hpet_acpi_add(struct acpi_device *device) +static int hpet_acpi_add(struct acpi_device *device) { acpi_status result; struct hpet_data data; @@ -1006,14 +993,14 @@ static int __init hpet_acpi_add(struct acpi_device *device) return hpet_alloc(&data); } -static int __init hpet_acpi_remove(struct acpi_device *device, int type) +static int hpet_acpi_remove(struct acpi_device *device, int type) { - return 0; + /* XXX need to unregister interpolator, dealloc mem, etc */ + return -EINVAL; } -static struct acpi_driver hpet_acpi_driver __initdata = { +static struct acpi_driver hpet_acpi_driver = { .name = "hpet", - .class = "", .ids = "PNP0103", .ops = { .add = hpet_acpi_add, @@ -1025,47 +1012,32 @@ static struct miscdevice hpet_misc = { HPET_MINOR, "hpet", &hpet_fops }; static int __init hpet_init(void) { - struct proc_dir_entry *entry; - - (void)acpi_bus_register_driver(&hpet_acpi_driver); + int result; - if (hpets) { - if (misc_register(&hpet_misc)) - return -ENODEV; - - entry = create_proc_entry("driver/hpet", 0, 0); + result = misc_register(&hpet_misc); + if (result < 0) + return -ENODEV; - if (entry) - entry->proc_fops = &hpet_proc_fops; + sysctl_header = register_sysctl_table(dev_root, 0); - sysctl_header = register_sysctl_table(dev_root, 0); + result = acpi_bus_register_driver(&hpet_acpi_driver); + if (result < 0) { + if (sysctl_header) + unregister_sysctl_table(sysctl_header); + misc_deregister(&hpet_misc); + return result; + } -#ifdef CONFIG_TIME_INTERPOLATION - { - struct hpet *hpet; - - hpet = hpets->hp_hpet; - hpet_cycles_per_sec = hpet_time_div(hpets->hp_period); - hpet_interpolator.frequency = hpet_cycles_per_sec; - hpet_interpolator.drift = hpet_cycles_per_sec * - HPET_DRIFT / 1000000; - hpet_nsecs_per_cycle = 1000000000 / hpet_cycles_per_sec; - register_time_interpolator(&hpet_interpolator); - } -#endif - return 0; - } else - return -ENODEV; + return 0; } static void __exit hpet_exit(void) { acpi_bus_unregister_driver(&hpet_acpi_driver); - if (hpets) { + if (sysctl_header) unregister_sysctl_table(sysctl_header); - remove_proc_entry("driver/hpet", NULL); - } + misc_deregister(&hpet_misc); return; }