1 files changed, 113 insertions, 51 deletions

diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index a0a1829d3198..34d6a1cab8de 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -14,7 +14,6 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/types.h>
 #include <linux/miscdevice.h>
 #include <linux/major.h>
@@ -30,13 +29,14 @@
 #include <linux/bcd.h>
 #include <linux/seq_file.h>
 #include <linux/bitops.h>
+#include <linux/compat.h>
 #include <linux/clocksource.h>
+#include <linux/uaccess.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 
 #include <asm/current.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/div64.h>
 
@@ -67,6 +67,7 @@
 #define read_counter(MC)        readl(MC)
 #endif
 
+static DEFINE_MUTEX(hpet_mutex); /* replaces BKL */
 static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
 
 /* This clocksource driver currently only works on ia64 */
@@ -79,13 +80,11 @@ static cycle_t read_hpet(struct clocksource *cs)
 }
 
 static struct clocksource clocksource_hpet = {
-        .name           = "hpet",
-        .rating         = 250,
-        .read           = read_hpet,
-        .mask           = CLOCKSOURCE_MASK(64),
-        .mult           = 0, /* to be calculated */
-        .shift          = 10,
-        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+        .name           = "hpet",
+        .rating         = 250,
+        .read           = read_hpet,
+        .mask           = CLOCKSOURCE_MASK(64),
+        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 static struct clocksource *hpet_clocksource;
 #endif
@@ -164,11 +163,32 @@ static irqreturn_t hpet_interrupt(int irq, void *data)
          * This has the effect of treating non-periodic like periodic.
          */
         if ((devp->hd_flags & (HPET_IE | HPET_PERIODIC)) == HPET_IE) {
-                unsigned long m, t;
+                unsigned long m, t, mc, base, k;
+                struct hpet __iomem *hpet = devp->hd_hpet;
+                struct hpets *hpetp = devp->hd_hpets;
 
                 t = devp->hd_ireqfreq;
                 m = read_counter(&devp->hd_timer->hpet_compare);
-                write_counter(t + m, &devp->hd_timer->hpet_compare);
+                mc = read_counter(&hpet->hpet_mc);
+                /* The time for the next interrupt would logically be t + m,
+                 * however, if we are very unlucky and the interrupt is delayed
+                 * for longer than t then we will completely miss the next
+                 * interrupt if we set t + m and an application will hang.
+                 * Therefore we need to make a more complex computation assuming
+                 * that there exists a k for which the following is true:
+                 * k * t + base < mc + delta
+                 * (k + 1) * t + base > mc + delta
+                 * where t is the interval in hpet ticks for the given freq,
+                 * base is the theoretical start value 0 < base < t,
+                 * mc is the main counter value at the time of the interrupt,
+                 * delta is the time it takes to write the a value to the
+                 * comparator.
+                 * k may then be computed as (mc - base + delta) / t .
+                 */
+                base = mc % t;
+                k = (mc - base + hpetp->hp_delta) / t;
+                write_counter(t * (k + 1) + base,
+                              &devp->hd_timer->hpet_compare);
         }
 
         if (devp->hd_flags & HPET_SHARED_IRQ)
@@ -250,7 +270,7 @@ static int hpet_open(struct inode *inode, struct file *file)
         if (file->f_mode & FMODE_WRITE)
                 return -EINVAL;
 
-        lock_kernel();
+        mutex_lock(&hpet_mutex);
         spin_lock_irq(&hpet_lock);
 
         for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next)
@@ -264,7 +284,7 @@ static int hpet_open(struct inode *inode, struct file *file)
 
         if (!devp) {
                 spin_unlock_irq(&hpet_lock);
-                unlock_kernel();
+                mutex_unlock(&hpet_mutex);
                 return -EBUSY;
         }
 
@@ -272,7 +292,7 @@ static int hpet_open(struct inode *inode, struct file *file)
         devp->hd_irqdata = 0;
         devp->hd_flags |= HPET_OPEN;
         spin_unlock_irq(&hpet_lock);
-        unlock_kernel();
+        mutex_unlock(&hpet_mutex);
 
         hpet_timer_set_irq(devp);
 
@@ -429,22 +449,6 @@ static int hpet_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int hpet_ioctl_common(struct hpet_dev *, int, unsigned long, int);
-
-static long hpet_ioctl(struct file *file, unsigned int cmd,
-                        unsigned long arg)
-{
-        struct hpet_dev *devp;
-        int ret;
-
-        devp = file->private_data;
-        lock_kernel();
-        ret = hpet_ioctl_common(devp, cmd, arg, 0);
-        unlock_kernel();
-
-        return ret;
-}
-
 static int hpet_ioctl_ieon(struct hpet_dev *devp)
 {
         struct hpet_timer __iomem *timer;
@@ -479,6 +483,21 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
         if (irq) {
                 unsigned long irq_flags;
 
+                if (devp->hd_flags & HPET_SHARED_IRQ) {
+                        /*
+                         * To prevent the interrupt handler from seeing an
+                         * unwanted interrupt status bit, program the timer
+                         * so that it will not fire in the near future ...
+                         */
+                        writel(readl(&timer->hpet_config) & ~Tn_TYPE_CNF_MASK,
+                               &timer->hpet_config);
+                        write_counter(read_counter(&hpet->hpet_mc),
+                                      &timer->hpet_compare);
+                        /* ... and clear any left-over status. */
+                        isr = 1 << (devp - devp->hd_hpets->hp_dev);
+                        writel(isr, &hpet->hpet_isr);
+                }
+
                 sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
                 irq_flags = devp->hd_flags & HPET_SHARED_IRQ
                                                 ? IRQF_SHARED : IRQF_DISABLED;
@@ -553,7 +572,8 @@ static inline unsigned long hpet_time_div(struct hpets *hpets,
 }
 
 static int
-hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
+hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg,
+                  struct hpet_info *info)
 {
         struct hpet_timer __iomem *timer;
         struct hpet __iomem *hpet;
@@ -594,23 +614,14 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 break;
         case HPET_INFO:
                 {
-                        struct hpet_info info;
-
+                        memset(info, 0, sizeof(*info));
                         if (devp->hd_ireqfreq)
-                                info.hi_ireqfreq =
+                                info->hi_ireqfreq =
                                         hpet_time_div(hpetp, devp->hd_ireqfreq);
-                        else
-                                info.hi_ireqfreq = 0;
-                        info.hi_flags =
+                        info->hi_flags =
                             readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
-                        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;
+                        info->hi_hpet = hpetp->hp_which;
+                        info->hi_timer = devp - hpetp->hp_dev;
                         break;
                 }
         case HPET_EPI:
@@ -636,7 +647,7 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 devp->hd_flags &= ~HPET_PERIODIC;
                 break;
         case HPET_IRQFREQ:
-                if (!kernel && (arg > hpet_max_freq) &&
+                if ((arg > hpet_max_freq) &&
                     !capable(CAP_SYS_RESOURCE)) {
                         err = -EACCES;
                         break;
@@ -653,12 +664,63 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
         return err;
 }
 
+static long
+hpet_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct hpet_info info;
+        int err;
+
+        mutex_lock(&hpet_mutex);
+        err = hpet_ioctl_common(file->private_data, cmd, arg, &info);
+        mutex_unlock(&hpet_mutex);
+
+        if ((cmd == HPET_INFO) && !err &&
+            (copy_to_user((void __user *)arg, &info, sizeof(info))))
+                err = -EFAULT;
+
+        return err;
+}
+
+#ifdef CONFIG_COMPAT
+struct compat_hpet_info {
+        compat_ulong_t hi_ireqfreq;     /* Hz */
+        compat_ulong_t hi_flags;        /* information */
+        unsigned short hi_hpet;
+        unsigned short hi_timer;
+};
+
+static long
+hpet_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct hpet_info info;
+        int err;
+
+        mutex_lock(&hpet_mutex);
+        err = hpet_ioctl_common(file->private_data, cmd, arg, &info);
+        mutex_unlock(&hpet_mutex);
+
+        if ((cmd == HPET_INFO) && !err) {
+                struct compat_hpet_info __user *u = compat_ptr(arg);
+                if (put_user(info.hi_ireqfreq, &u->hi_ireqfreq) ||
+                    put_user(info.hi_flags, &u->hi_flags) ||
+                    put_user(info.hi_hpet, &u->hi_hpet) ||
+                    put_user(info.hi_timer, &u->hi_timer))
+                        err = -EFAULT;
+        }
+
+        return err;
+}
+#endif
+
 static const struct file_operations hpet_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .read = hpet_read,
         .poll = hpet_poll,
         .unlocked_ioctl = hpet_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = hpet_compat_ioctl,
+#endif
         .open = hpet_open,
         .release = hpet_release,
         .fasync = hpet_fasync,
@@ -781,7 +843,7 @@ int hpet_alloc(struct hpet_data *hdp)
         struct hpets *hpetp;
         size_t siz;
         struct hpet __iomem *hpet;
-        static struct hpets *last = NULL;
+        static struct hpets *last;
         unsigned long period;
         unsigned long long temp;
         u32 remainder;
@@ -891,9 +953,7 @@ int hpet_alloc(struct hpet_data *hdp)
         if (!hpet_clocksource) {
                 hpet_mctr = (void __iomem *)&hpetp->hp_hpet->hpet_mc;
                 CLKSRC_FSYS_MMIO_SET(clocksource_hpet.fsys_mmio, hpet_mctr);
-                clocksource_hpet.mult = clocksource_hz2mult(hpetp->hp_tick_freq,
-                                                clocksource_hpet.shift);
-                clocksource_register(&clocksource_hpet);
+                clocksource_register_hz(&clocksource_hpet, hpetp->hp_tick_freq);
                 hpetp->hp_clocksource = &clocksource_hpet;
                 hpet_clocksource = &clocksource_hpet;
         }
@@ -970,6 +1030,8 @@ static int hpet_acpi_add(struct acpi_device *device)
                 return -ENODEV;
 
         if (!data.hd_address || !data.hd_nirqs) {
+                if (data.hd_address)
+                        iounmap(data.hd_address);
                 printk("%s: no address or irqs in _CRS\n", __func__);
                 return -ENODEV;
         }