12 files changed, 411 insertions, 119 deletions

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index e0a1ff927a5b..cf02ddc3436f 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -220,4 +220,16 @@ config THINKPAD_ACPI_BAY
           If you are not sure, say Y here.
 
 
+config ATMEL_SSC
+        tristate "Device driver for Atmel SSC peripheral"
+        depends on AVR32 || ARCH_AT91
+        ---help---
+          This option enables device driver support for Atmel Syncronized
+          Serial Communication peripheral (SSC).
+
+          The SSC peripheral supports a wide variety of serial frame based
+          communications, i.e. I2S, SPI, etc.
+
+          If unsure, say N.
+
 endif # MISC_DEVICES
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index be90d483d2f9..87f2685d728f 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_IBM_ASM)		+= ibmasm/
 obj-$(CONFIG_HDPU_FEATURES)     += hdpuftrs/
 obj-$(CONFIG_MSI_LAPTOP)     += msi-laptop.o
 obj-$(CONFIG_ASUS_LAPTOP)     += asus-laptop.o
+obj-$(CONFIG_ATMEL_SSC)         += atmel-ssc.o
 obj-$(CONFIG_LKDTM)             += lkdtm.o
 obj-$(CONFIG_TIFM_CORE)         += tifm_core.o
 obj-$(CONFIG_TIFM_7XX1)         += tifm_7xx1.o
diff --git a/drivers/misc/atmel-ssc.c b/drivers/misc/atmel-ssc.c
new file mode 100644
index 000000000000..058ccac700d0
--- /dev/null
+++ b/drivers/misc/atmel-ssc.c
@@ -0,0 +1,174 @@
+/*
+ * Atmel SSC driver
+ *
+ * Copyright (C) 2007 Atmel Corporation
+ *
+ * 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 <linux/platform_device.h>
+#include <linux/list.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/atmel-ssc.h>
+
+/* Serialize access to ssc_list and user count */
+static DEFINE_SPINLOCK(user_lock);
+static LIST_HEAD(ssc_list);
+
+struct ssc_device *ssc_request(unsigned int ssc_num)
+{
+        int ssc_valid = 0;
+        struct ssc_device *ssc;
+
+        spin_lock(&user_lock);
+        list_for_each_entry(ssc, &ssc_list, list) {
+                if (ssc->pdev->id == ssc_num) {
+                        ssc_valid = 1;
+                        break;
+                }
+        }
+
+        if (!ssc_valid) {
+                spin_unlock(&user_lock);
+                dev_dbg(&ssc->pdev->dev, "could not find requested device\n");
+                return ERR_PTR(-ENODEV);
+        }
+
+        if (ssc->user) {
+                spin_unlock(&user_lock);
+                dev_dbg(&ssc->pdev->dev, "module busy\n");
+                return ERR_PTR(-EBUSY);
+        }
+        ssc->user++;
+        spin_unlock(&user_lock);
+
+        clk_enable(ssc->clk);
+
+        return ssc;
+}
+EXPORT_SYMBOL(ssc_request);
+
+void ssc_free(struct ssc_device *ssc)
+{
+        spin_lock(&user_lock);
+        if (ssc->user) {
+                ssc->user--;
+                clk_disable(ssc->clk);
+        } else {
+                dev_dbg(&ssc->pdev->dev, "device already free\n");
+        }
+        spin_unlock(&user_lock);
+}
+EXPORT_SYMBOL(ssc_free);
+
+static int __init ssc_probe(struct platform_device *pdev)
+{
+        int retval = 0;
+        struct resource *regs;
+        struct ssc_device *ssc;
+
+        ssc = kzalloc(sizeof(struct ssc_device), GFP_KERNEL);
+        if (!ssc) {
+                dev_dbg(&pdev->dev, "out of memory\n");
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs) {
+                dev_dbg(&pdev->dev, "no mmio resource defined\n");
+                retval = -ENXIO;
+                goto out_free;
+        }
+
+        ssc->clk = clk_get(&pdev->dev, "pclk");
+        if (IS_ERR(ssc->clk)) {
+                dev_dbg(&pdev->dev, "no pclk clock defined\n");
+                retval = -ENXIO;
+                goto out_free;
+        }
+
+        ssc->pdev = pdev;
+        ssc->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        if (!ssc->regs) {
+                dev_dbg(&pdev->dev, "ioremap failed\n");
+                retval = -EINVAL;
+                goto out_clk;
+        }
+
+        /* disable all interrupts */
+        clk_enable(ssc->clk);
+        ssc_writel(ssc->regs, IDR, ~0UL);
+        ssc_readl(ssc->regs, SR);
+        clk_disable(ssc->clk);
+
+        ssc->irq = platform_get_irq(pdev, 0);
+        if (!ssc->irq) {
+                dev_dbg(&pdev->dev, "could not get irq\n");
+                retval = -ENXIO;
+                goto out_unmap;
+        }
+
+        spin_lock(&user_lock);
+        list_add_tail(&ssc->list, &ssc_list);
+        spin_unlock(&user_lock);
+
+        platform_set_drvdata(pdev, ssc);
+
+        dev_info(&pdev->dev, "Atmel SSC device at 0x%p (irq %d)\n",
+                        ssc->regs, ssc->irq);
+
+        goto out;
+
+out_unmap:
+        iounmap(ssc->regs);
+out_clk:
+        clk_put(ssc->clk);
+out_free:
+        kfree(ssc);
+out:
+        return retval;
+}
+
+static int __devexit ssc_remove(struct platform_device *pdev)
+{
+        struct ssc_device *ssc = platform_get_drvdata(pdev);
+
+        spin_lock(&user_lock);
+        iounmap(ssc->regs);
+        clk_put(ssc->clk);
+        list_del(&ssc->list);
+        kfree(ssc);
+        spin_unlock(&user_lock);
+
+        return 0;
+}
+
+static struct platform_driver ssc_driver = {
+        .remove         = __devexit_p(ssc_remove),
+        .driver         = {
+                .name           = "ssc",
+        },
+};
+
+static int __init ssc_init(void)
+{
+        return platform_driver_probe(&ssc_driver, ssc_probe);
+}
+module_init(ssc_init);
+
+static void __exit ssc_exit(void)
+{
+        platform_driver_unregister(&ssc_driver);
+}
+module_exit(ssc_exit);
+
+MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>");
+MODULE_DESCRIPTION("SSC driver for Atmel AVR32 and AT91");
+MODULE_LICENSE("GPL");
diff --git a/drivers/misc/hdpuftrs/hdpu_cpustate.c b/drivers/misc/hdpuftrs/hdpu_cpustate.c
index 276ba3c5143f..aa8ce7abe922 100644
--- a/drivers/misc/hdpuftrs/hdpu_cpustate.c
+++ b/drivers/misc/hdpuftrs/hdpu_cpustate.c
@@ -19,16 +19,41 @@
 #include <linux/spinlock.h>
 #include <linux/miscdevice.h>
 #include <linux/proc_fs.h>
+#include <linux/hdpu_features.h>
 #include <linux/platform_device.h>
 #include <asm/uaccess.h>
-#include <linux/hdpu_features.h>
+#include <linux/seq_file.h>
+#include <asm/io.h>
 
 #define SKY_CPUSTATE_VERSION            "1.1"
 
 static int hdpu_cpustate_probe(struct platform_device *pdev);
 static int hdpu_cpustate_remove(struct platform_device *pdev);
 
-struct cpustate_t cpustate;
+static unsigned char cpustate_get_state(void);
+static int cpustate_proc_open(struct inode *inode, struct file *file);
+static int cpustate_proc_read(struct seq_file *seq, void *offset);
+
+static struct cpustate_t cpustate;
+
+static const struct file_operations proc_cpustate = {
+        .open = cpustate_proc_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int cpustate_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, cpustate_proc_read, NULL);
+}
+
+static int cpustate_proc_read(struct seq_file *seq, void *offset)
+{
+        seq_printf(seq, "CPU State: %04x\n", cpustate_get_state());
+        return 0;
+}
 
 static int cpustate_get_ref(int excl)
 {
@@ -66,13 +91,13 @@ static int cpustate_free_ref(void)
         return 0;
 }
 
-unsigned char cpustate_get_state(void)
+static unsigned char cpustate_get_state(void)
 {
 
         return cpustate.cached_val;
 }
 
-void cpustate_set_state(unsigned char new_state)
+static void cpustate_set_state(unsigned char new_state)
 {
         unsigned int state = (new_state << 21);
 
@@ -134,29 +159,6 @@ static int cpustate_release(struct inode *inode, struct file *file)
         return cpustate_free_ref();
 }
 
-/*
- *      Info exported via "/proc/sky_cpustate".
- */
-static int cpustate_read_proc(char *page, char **start, off_t off,
-                              int count, int *eof, void *data)
-{
-        char *p = page;
-        int len = 0;
-
-        p += sprintf(p, "CPU State: %04x\n", cpustate_get_state());
-        len = p - page;
-
-        if (len <= off + count)
-                *eof = 1;
-        *start = page + off;
-        len -= off;
-        if (len > count)
-                len = count;
-        if (len < 0)
-                len = 0;
-        return len;
-}
-
 static struct platform_driver hdpu_cpustate_driver = {
         .probe = hdpu_cpustate_probe,
         .remove = hdpu_cpustate_remove,
@@ -169,22 +171,18 @@ static struct platform_driver hdpu_cpustate_driver = {
  *      The various file operations we support.
  */
 static const struct file_operations cpustate_fops = {
-      owner:THIS_MODULE,
-      open:cpustate_open,
-      release:cpustate_release,
-      read:cpustate_read,
-      write:cpustate_write,
-      fasync:NULL,
-      poll:NULL,
-      ioctl:NULL,
-      llseek:no_llseek,
-
+      .owner    = THIS_MODULE,
+      .open     = cpustate_open,
+      .release  = cpustate_release,
+      .read     = cpustate_read,
+      .write    = cpustate_write,
+      .llseek   = no_llseek,
 };
 
 static struct miscdevice cpustate_dev = {
-        MISC_DYNAMIC_MINOR,
-        "sky_cpustate",
-        &cpustate_fops
+        .minor  = MISC_DYNAMIC_MINOR,
+        .name   = "sky_cpustate",
+        .fops   = &cpustate_fops,
 };
 
 static int hdpu_cpustate_probe(struct platform_device *pdev)
@@ -194,23 +192,31 @@ static int hdpu_cpustate_probe(struct platform_device *pdev)
         int ret;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                printk(KERN_ERR "sky_cpustate: "
+                       "Invalid memory resource.\n");
+                return -EINVAL;
+        }
         cpustate.set_addr = (unsigned long *)res->start;
         cpustate.clr_addr = (unsigned long *)res->end - 1;
 
         ret = misc_register(&cpustate_dev);
         if (ret) {
-                printk(KERN_WARNING "sky_cpustate: Unable to register misc "
-                                        "device.\n");
+                printk(KERN_WARNING "sky_cpustate: "
+                       "Unable to register misc device.\n");
                 cpustate.set_addr = NULL;
                 cpustate.clr_addr = NULL;
                 return ret;
         }
 
-        proc_de = create_proc_read_entry("sky_cpustate", 0, 0,
-                                        cpustate_read_proc, NULL);
-        if (proc_de == NULL)
-                printk(KERN_WARNING "sky_cpustate: Unable to create proc "
-                                        "dir entry\n");
+        proc_de = create_proc_entry("sky_cpustate", 0666, &proc_root);
+        if (!proc_de) {
+                printk(KERN_WARNING "sky_cpustate: "
+                       "Unable to create proc entry\n");
+        } else {
+                proc_de->proc_fops = &proc_cpustate;
+                proc_de->owner = THIS_MODULE;
+        }
 
         printk(KERN_INFO "Sky CPU State Driver v" SKY_CPUSTATE_VERSION "\n");
         return 0;
@@ -218,21 +224,18 @@ static int hdpu_cpustate_probe(struct platform_device *pdev)
 
 static int hdpu_cpustate_remove(struct platform_device *pdev)
 {
-
         cpustate.set_addr = NULL;
         cpustate.clr_addr = NULL;
 
         remove_proc_entry("sky_cpustate", NULL);
         misc_deregister(&cpustate_dev);
-        return 0;
 
+        return 0;
 }
 
 static int __init cpustate_init(void)
 {
-        int rc;
-        rc = platform_driver_register(&hdpu_cpustate_driver);
-        return rc;
+        return platform_driver_register(&hdpu_cpustate_driver);
 }
 
 static void __exit cpustate_exit(void)
diff --git a/drivers/misc/hdpuftrs/hdpu_nexus.c b/drivers/misc/hdpuftrs/hdpu_nexus.c
index 60c8b26f0678..2887b2147980 100644
--- a/drivers/misc/hdpuftrs/hdpu_nexus.c
+++ b/drivers/misc/hdpuftrs/hdpu_nexus.c
@@ -18,17 +18,38 @@
 #include <linux/kernel.h>
 #include <linux/proc_fs.h>
 #include <linux/hdpu_features.h>
-
 #include <linux/platform_device.h>
+#include <linux/seq_file.h>
+#include <asm/io.h>
 
 static int hdpu_nexus_probe(struct platform_device *pdev);
 static int hdpu_nexus_remove(struct platform_device *pdev);
+static int hdpu_slot_id_open(struct inode *inode, struct file *file);
+static int hdpu_slot_id_read(struct seq_file *seq, void *offset);
+static int hdpu_chassis_id_open(struct inode *inode, struct file *file);
+static int hdpu_chassis_id_read(struct seq_file *seq, void *offset);
 
 static struct proc_dir_entry *hdpu_slot_id;
 static struct proc_dir_entry *hdpu_chassis_id;
 static int slot_id = -1;
 static int chassis_id = -1;
 
+static const struct file_operations proc_slot_id = {
+        .open = hdpu_slot_id_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static const struct file_operations proc_chassis_id = {
+        .open = hdpu_chassis_id_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
 static struct platform_driver hdpu_nexus_driver = {
         .probe = hdpu_nexus_probe,
         .remove = hdpu_nexus_remove,
@@ -37,43 +58,67 @@ static struct platform_driver hdpu_nexus_driver = {
         },
 };
 
-int hdpu_slot_id_read(char *buffer, char **buffer_location, off_t offset,
-                      int buffer_length, int *zero, void *ptr)
+static int hdpu_slot_id_open(struct inode *inode, struct file *file)
 {
+        return single_open(file, hdpu_slot_id_read, NULL);
+}
 
-        if (offset > 0)
-                return 0;
-        return sprintf(buffer, "%d\n", slot_id);
+static int hdpu_slot_id_read(struct seq_file *seq, void *offset)
+{
+        seq_printf(seq, "%d\n", slot_id);
+        return 0;
 }
 
-int hdpu_chassis_id_read(char *buffer, char **buffer_location, off_t offset,
-                         int buffer_length, int *zero, void *ptr)
+static int hdpu_chassis_id_open(struct inode *inode, struct file *file)
 {
+        return single_open(file, hdpu_chassis_id_read, NULL);
+}
 
-        if (offset > 0)
-                return 0;
-        return sprintf(buffer, "%d\n", chassis_id);
+static int hdpu_chassis_id_read(struct seq_file *seq, void *offset)
+{
+        seq_printf(seq, "%d\n", chassis_id);
+        return 0;
 }
 
 static int hdpu_nexus_probe(struct platform_device *pdev)
 {
         struct resource *res;
+        int *nexus_id_addr;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        int *nexus_id_addr;
-        nexus_id_addr =
-            ioremap(res->start, (unsigned long)(res->end - res->start));
+        if (!res) {
+                printk(KERN_ERR "sky_nexus: "
+                       "Invalid memory resource.\n");
+                return -EINVAL;
+        }
+        nexus_id_addr = ioremap(res->start,
+                                (unsigned long)(res->end - res->start));
         if (nexus_id_addr) {
                 slot_id = (*nexus_id_addr >> 8) & 0x1f;
                 chassis_id = *nexus_id_addr & 0xff;
                 iounmap(nexus_id_addr);
-        } else
-                printk("Could not map slot id\n");
+        } else {
+                printk(KERN_ERR "sky_nexus: Could not map slot id\n");
+        }
+
         hdpu_slot_id = create_proc_entry("sky_slot_id", 0666, &proc_root);
-        hdpu_slot_id->read_proc = hdpu_slot_id_read;
+        if (!hdpu_slot_id) {
+                printk(KERN_WARNING "sky_nexus: "
+                       "Unable to create proc dir entry: sky_slot_id\n");
+        } else {
+                hdpu_slot_id->proc_fops = &proc_slot_id;
+                hdpu_slot_id->owner = THIS_MODULE;
+        }
 
         hdpu_chassis_id = create_proc_entry("sky_chassis_id", 0666, &proc_root);
-        hdpu_chassis_id->read_proc = hdpu_chassis_id_read;
+        if (!hdpu_chassis_id) {
+                printk(KERN_WARNING "sky_nexus: "
+                       "Unable to create proc dir entry: sky_chassis_id\n");
+        } else {
+                hdpu_chassis_id->proc_fops = &proc_chassis_id;
+                hdpu_chassis_id->owner = THIS_MODULE;
+        }
+
         return 0;
 }
 
@@ -81,18 +126,19 @@ static int hdpu_nexus_remove(struct platform_device *pdev)
 {
         slot_id = -1;
         chassis_id = -1;
+
         remove_proc_entry("sky_slot_id", &proc_root);
         remove_proc_entry("sky_chassis_id", &proc_root);
+
         hdpu_slot_id = 0;
         hdpu_chassis_id = 0;
+
         return 0;
 }
 
 static int __init nexus_init(void)
 {
-        int rc;
-        rc = platform_driver_register(&hdpu_nexus_driver);
-        return rc;
+        return platform_driver_register(&hdpu_nexus_driver);
 }
 
 static void __exit nexus_exit(void)
diff --git a/drivers/misc/ibmasm/remote.c b/drivers/misc/ibmasm/remote.c
index 0550ce075fc4..1d9defb1a10c 100644
--- a/drivers/misc/ibmasm/remote.c
+++ b/drivers/misc/ibmasm/remote.c
@@ -226,9 +226,9 @@ int ibmasm_init_remote_input_dev(struct service_processor *sp)
         mouse_dev->id.product = pdev->device;
         mouse_dev->id.version = 1;
         mouse_dev->dev.parent = sp->dev;
-        mouse_dev->evbit[0]  = BIT(EV_KEY) | BIT(EV_ABS);
-        mouse_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) |
-                BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
+        mouse_dev->evbit[0]  = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        mouse_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
+                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
         set_bit(BTN_TOUCH, mouse_dev->keybit);
         mouse_dev->name = "ibmasm RSA I remote mouse";
         input_set_abs_params(mouse_dev, ABS_X, 0, MOUSE_X_MAX, 0, 0);
@@ -239,7 +239,7 @@ int ibmasm_init_remote_input_dev(struct service_processor *sp)
         keybd_dev->id.product = pdev->device;
         keybd_dev->id.version = 2;
         keybd_dev->dev.parent = sp->dev;
-        keybd_dev->evbit[0]  = BIT(EV_KEY);
+        keybd_dev->evbit[0]  = BIT_MASK(EV_KEY);
         keybd_dev->name = "ibmasm RSA I remote keyboard";
 
         for (i = 0; i < XLATE_SIZE; i++) {
diff --git a/drivers/misc/msi-laptop.c b/drivers/misc/msi-laptop.c
index 349be934db7c..83679c762925 100644
--- a/drivers/misc/msi-laptop.c
+++ b/drivers/misc/msi-laptop.c
@@ -283,7 +283,7 @@ static struct platform_device *msipf_device;
 
 /* Initialization */
 
-static int dmi_check_cb(struct dmi_system_id *id)
+static int dmi_check_cb(const struct dmi_system_id *id)
 {
         printk("msi-laptop: Identified laptop model '%s'.\n", id->ident);
         return 0;
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c
index 5108b7c576df..cd221fd0fb94 100644
--- a/drivers/misc/phantom.c
+++ b/drivers/misc/phantom.c
@@ -9,6 +9,7 @@
  *  You need an userspace library to cooperate with this driver. It (and other
  *  info) may be obtained here:
  *  http://www.fi.muni.cz/~xslaby/phantom.html
+ *  or alternatively, you might use OpenHaptics provided by Sensable.
  */
 
 #include <linux/kernel.h>
@@ -24,13 +25,14 @@
 #include <asm/atomic.h>
 #include <asm/io.h>
 
-#define PHANTOM_VERSION         "n0.9.5"
+#define PHANTOM_VERSION         "n0.9.7"
 
 #define PHANTOM_MAX_MINORS      8
 
 #define PHN_IRQCTL              0x4c    /* irq control in caddr space */
 
 #define PHB_RUNNING             1
+#define PHB_NOT_OH              2
 
 static struct class *phantom_class;
 static int phantom_major;
@@ -47,7 +49,11 @@ struct phantom_device {
         struct cdev cdev;
 
         struct mutex open_lock;
-        spinlock_t ioctl_lock;
+        spinlock_t regs_lock;
+
+        /* used in NOT_OH mode */
+        struct phm_regs oregs;
+        u32 ctl_reg;
 };
 
 static unsigned char phantom_devices[PHANTOM_MAX_MINORS];
@@ -82,6 +88,7 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
         struct phm_regs rs;
         struct phm_reg r;
         void __user *argp = (void __user *)arg;
+        unsigned long flags;
         unsigned int i;
 
         if (_IOC_TYPE(cmd) != PH_IOC_MAGIC ||
@@ -96,32 +103,45 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                 if (r.reg > 7)
                         return -EINVAL;
 
-                spin_lock(&dev->ioctl_lock);
+                spin_lock_irqsave(&dev->regs_lock, flags);
                 if (r.reg == PHN_CONTROL && (r.value & PHN_CTL_IRQ) &&
                                 phantom_status(dev, dev->status | PHB_RUNNING)){
-                        spin_unlock(&dev->ioctl_lock);
+                        spin_unlock_irqrestore(&dev->regs_lock, flags);
                         return -ENODEV;
                 }
 
                 pr_debug("phantom: writing %x to %u\n", r.value, r.reg);
+
+                /* preserve amp bit (don't allow to change it when in NOT_OH) */
+                if (r.reg == PHN_CONTROL && (dev->status & PHB_NOT_OH)) {
+                        r.value &= ~PHN_CTL_AMP;
+                        r.value |= dev->ctl_reg & PHN_CTL_AMP;
+                        dev->ctl_reg = r.value;
+                }
+
                 iowrite32(r.value, dev->iaddr + r.reg);
                 ioread32(dev->iaddr); /* PCI posting */
 
                 if (r.reg == PHN_CONTROL && !(r.value & PHN_CTL_IRQ))
                         phantom_status(dev, dev->status & ~PHB_RUNNING);
-                spin_unlock(&dev->ioctl_lock);
+                spin_unlock_irqrestore(&dev->regs_lock, flags);
                 break;
         case PHN_SET_REGS:
                 if (copy_from_user(&rs, argp, sizeof(rs)))
                         return -EFAULT;
 
                 pr_debug("phantom: SRS %u regs %x\n", rs.count, rs.mask);
-                spin_lock(&dev->ioctl_lock);
-                for (i = 0; i < min(rs.count, 8U); i++)
-                        if ((1 << i) & rs.mask)
-                                iowrite32(rs.values[i], dev->oaddr + i);
-                ioread32(dev->iaddr); /* PCI posting */
-                spin_unlock(&dev->ioctl_lock);
+                spin_lock_irqsave(&dev->regs_lock, flags);
+                if (dev->status & PHB_NOT_OH)
+                        memcpy(&dev->oregs, &rs, sizeof(rs));
+                else {
+                        u32 m = min(rs.count, 8U);
+                        for (i = 0; i < m; i++)
+                                if (rs.mask & BIT(i))
+                                        iowrite32(rs.values[i], dev->oaddr + i);
+                        ioread32(dev->iaddr); /* PCI posting */
+                }
+                spin_unlock_irqrestore(&dev->regs_lock, flags);
                 break;
         case PHN_GET_REG:
                 if (copy_from_user(&r, argp, sizeof(r)))
@@ -135,20 +155,35 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                 if (copy_to_user(argp, &r, sizeof(r)))
                         return -EFAULT;
                 break;
-        case PHN_GET_REGS:
+        case PHN_GET_REGS: {
+                u32 m;
+
                 if (copy_from_user(&rs, argp, sizeof(rs)))
                         return -EFAULT;
 
+                m = min(rs.count, 8U);
+
                 pr_debug("phantom: GRS %u regs %x\n", rs.count, rs.mask);
-                spin_lock(&dev->ioctl_lock);
-                for (i = 0; i < min(rs.count, 8U); i++)
-                        if ((1 << i) & rs.mask)
+                spin_lock_irqsave(&dev->regs_lock, flags);
+                for (i = 0; i < m; i++)
+                        if (rs.mask & BIT(i))
                                 rs.values[i] = ioread32(dev->iaddr + i);
-                spin_unlock(&dev->ioctl_lock);
+                spin_unlock_irqrestore(&dev->regs_lock, flags);
 
                 if (copy_to_user(argp, &rs, sizeof(rs)))
                         return -EFAULT;
                 break;
+        } case PHN_NOT_OH:
+                spin_lock_irqsave(&dev->regs_lock, flags);
+                if (dev->status & PHB_RUNNING) {
+                        printk(KERN_ERR "phantom: you need to set NOT_OH "
+                                        "before you start the device!\n");
+                        spin_unlock_irqrestore(&dev->regs_lock, flags);
+                        return -EINVAL;
+                }
+                dev->status |= PHB_NOT_OH;
+                spin_unlock_irqrestore(&dev->regs_lock, flags);
+                break;
         default:
                 return -ENOTTY;
         }
@@ -171,8 +206,11 @@ static int phantom_open(struct inode *inode, struct file *file)
                 return -EINVAL;
         }
 
+        WARN_ON(dev->status & PHB_NOT_OH);
+
         file->private_data = dev;
 
+        atomic_set(&dev->counter, 0);
         dev->opened++;
         mutex_unlock(&dev->open_lock);
 
@@ -187,6 +225,7 @@ static int phantom_release(struct inode *inode, struct file *file)
 
         dev->opened = 0;
         phantom_status(dev, dev->status & ~PHB_RUNNING);
+        dev->status &= ~PHB_NOT_OH;
 
         mutex_unlock(&dev->open_lock);
 
@@ -220,12 +259,32 @@ static struct file_operations phantom_file_ops = {
 static irqreturn_t phantom_isr(int irq, void *data)
 {
         struct phantom_device *dev = data;
+        unsigned int i;
+        u32 ctl;
 
-        if (!(ioread32(dev->iaddr + PHN_CONTROL) & PHN_CTL_IRQ))
+        spin_lock(&dev->regs_lock);
+        ctl = ioread32(dev->iaddr + PHN_CONTROL);
+        if (!(ctl & PHN_CTL_IRQ)) {
+                spin_unlock(&dev->regs_lock);
                 return IRQ_NONE;
+        }
 
         iowrite32(0, dev->iaddr);
         iowrite32(0xc0, dev->iaddr);
+
+        if (dev->status & PHB_NOT_OH) {
+                struct phm_regs *r = &dev->oregs;
+                u32 m = min(r->count, 8U);
+
+                for (i = 0; i < m; i++)
+                        if (r->mask & BIT(i))
+                                iowrite32(r->values[i], dev->oaddr + i);
+
+                dev->ctl_reg ^= PHN_CTL_AMP;
+                iowrite32(dev->ctl_reg, dev->iaddr + PHN_CONTROL);
+        }
+        spin_unlock(&dev->regs_lock);
+
         ioread32(dev->iaddr); /* PCI posting */
 
         atomic_inc(&dev->counter);
@@ -297,7 +356,7 @@ static int __devinit phantom_probe(struct pci_dev *pdev,
         }
 
         mutex_init(&pht->open_lock);
-        spin_lock_init(&pht->ioctl_lock);
+        spin_lock_init(&pht->regs_lock);
         init_waitqueue_head(&pht->wait);
         cdev_init(&pht->cdev, &phantom_file_ops);
         pht->cdev.owner = THIS_MODULE;
@@ -378,6 +437,8 @@ static int phantom_suspend(struct pci_dev *pdev, pm_message_t state)
         iowrite32(0, dev->caddr + PHN_IRQCTL);
         ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */
 
+        synchronize_irq(pdev->irq);
+
         return 0;
 }
 
diff --git a/drivers/misc/sony-laptop.c b/drivers/misc/sony-laptop.c
index f248080828f2..1bfbb87e5793 100644
--- a/drivers/misc/sony-laptop.c
+++ b/drivers/misc/sony-laptop.c
@@ -411,9 +411,9 @@ static int sony_laptop_setup_input(void)
         jog_dev->id.bustype = BUS_ISA;
         jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
 
-        jog_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
-        jog_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_MIDDLE);
-        jog_dev->relbit[0] = BIT(REL_WHEEL);
+        jog_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
+        jog_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_MIDDLE);
+        jog_dev->relbit[0] = BIT_MASK(REL_WHEEL);
 
         error = input_register_device(jog_dev);
         if (error)
@@ -807,7 +807,7 @@ static struct sony_nc_event *sony_nc_events;
 /* Vaio C* --maybe also FE*, N* and AR* ?-- special init sequence
  * for Fn keys
  */
-static int sony_nc_C_enable(struct dmi_system_id *id)
+static int sony_nc_C_enable(const struct dmi_system_id *id)
 {
         int result = 0;
 
@@ -845,7 +845,7 @@ static struct sony_nc_event sony_C_events[] = {
 };
 
 /* SNC-only model map */
-static struct dmi_system_id sony_nc_ids[] = {
+static const struct dmi_system_id sony_nc_ids[] = {
                 {
                         .ident = "Sony Vaio FE Series",
                         .callback = sony_nc_C_enable,
diff --git a/drivers/misc/thinkpad_acpi.c b/drivers/misc/thinkpad_acpi.c
index 37891a8c030a..e953276664a0 100644
--- a/drivers/misc/thinkpad_acpi.c
+++ b/drivers/misc/thinkpad_acpi.c
@@ -527,7 +527,7 @@ static char *next_cmd(char **cmds)
 
 static struct platform_device *tpacpi_pdev;
 static struct platform_device *tpacpi_sensors_pdev;
-static struct class_device *tpacpi_hwmon;
+static struct device *tpacpi_hwmon;
 static struct input_dev *tpacpi_inputdev;
 static struct mutex tpacpi_inputdev_send_mutex;
 
@@ -964,15 +964,15 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
                 KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
                 KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
-                KEY_RESERVED,   /* 0x0F: FN+HOME (brightness up) */
+                KEY_BRIGHTNESSUP,       /* 0x0F: FN+HOME (brightness up) */
                 /* Scan codes 0x10 to 0x1F: Extended ACPI HKEY hot keys */
-                KEY_RESERVED,   /* 0x10: FN+END (brightness down) */
+                KEY_BRIGHTNESSDOWN,     /* 0x10: FN+END (brightness down) */
                 KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
                 KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
                 KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
-                KEY_RESERVED,   /* 0x14: VOLUME UP */
-                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
-                KEY_RESERVED,   /* 0x16: MUTE */
+                KEY_VOLUMEUP,   /* 0x14: VOLUME UP */
+                KEY_VOLUMEDOWN, /* 0x15: VOLUME DOWN */
+                KEY_MUTE,       /* 0x16: MUTE */
                 KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
                 /* (assignments unknown, please report if found) */
                 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
@@ -993,9 +993,9 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
                 KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
                 KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
-                KEY_RESERVED,   /* 0x14: VOLUME UP */
-                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
-                KEY_RESERVED,   /* 0x16: MUTE */
+                KEY_VOLUMEUP,   /* 0x14: VOLUME UP */
+                KEY_VOLUMEDOWN, /* 0x15: VOLUME DOWN */
+                KEY_MUTE,       /* 0x16: MUTE */
                 KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
                 /* (assignments unknown, please report if found) */
                 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
@@ -4534,7 +4534,7 @@ static void ibm_exit(struct ibm_struct *ibm)
 
 static void __init get_thinkpad_model_data(struct thinkpad_id_data *tp)
 {
-        struct dmi_device *dev = NULL;
+        const struct dmi_device *dev = NULL;
         char ec_fw_string[18];
 
         if (!tp)
diff --git a/drivers/misc/thinkpad_acpi.h b/drivers/misc/thinkpad_acpi.h
index c5fdd688cc99..3abcc8120634 100644
--- a/drivers/misc/thinkpad_acpi.h
+++ b/drivers/misc/thinkpad_acpi.h
@@ -173,7 +173,7 @@ static int parse_strtoul(const char *buf, unsigned long max,
 /* Device model */
 static struct platform_device *tpacpi_pdev;
 static struct platform_device *tpacpi_sensors_pdev;
-static struct class_device *tpacpi_hwmon;
+static struct device *tpacpi_hwmon;
 static struct platform_driver tpacpi_pdriver;
 static struct input_dev *tpacpi_inputdev;
 static int tpacpi_create_driver_attributes(struct device_driver *drv);
diff --git a/drivers/misc/tifm_core.c b/drivers/misc/tifm_core.c
index d195fb088f4a..8f77949f93dd 100644
--- a/drivers/misc/tifm_core.c
+++ b/drivers/misc/tifm_core.c
@@ -57,16 +57,11 @@ static int tifm_bus_match(struct device *dev, struct device_driver *drv)
         return 0;
 }
 
-static int tifm_uevent(struct device *dev, char **envp, int num_envp,
-                       char *buffer, int buffer_size)
+static int tifm_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
-        int i = 0;
-        int length = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                           "TIFM_CARD_TYPE=%s",
-                           tifm_media_type_name(sock->type, 1)))
+        if (add_uevent_var(env, "TIFM_CARD_TYPE=%s", tifm_media_type_name(sock->type, 1)))
                 return -ENOMEM;
 
         return 0;