23 files changed, 710 insertions, 247 deletions

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 7b46781c30c9..d62827271802 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -134,6 +134,18 @@ config INPUT_MAX8925_ONKEY
           To compile this driver as a module, choose M here: the module
           will be called max8925_onkey.
 
+config INPUT_MAX8997_HAPTIC
+        tristate "MAXIM MAX8997 haptic controller support"
+        depends on HAVE_PWM && MFD_MAX8997
+        select INPUT_FF_MEMLESS
+        help
+          This option enables device driver support for the haptic controller
+          on MAXIM MAX8997 chip. This driver supports ff-memless interface
+          from input framework.
+
+          To compile this driver as module, choose M here: the
+          module will be called max8997-haptic.
+
 config INPUT_MC13783_PWRBUTTON
         tristate "MC13783 ON buttons"
         depends on MFD_MC13783
@@ -415,7 +427,7 @@ config INPUT_PCF8574
         tristate "PCF8574 Keypad input device"
         depends on I2C && EXPERIMENTAL
         help
-          Say Y here if you want to support a keypad connetced via I2C
+          Say Y here if you want to support a keypad connected via I2C
           with a PCF8574.
 
           To compile this driver as a module, choose M here: the
@@ -455,6 +467,16 @@ config INPUT_RB532_BUTTON
           To compile this driver as a module, choose M here: the
           module will be called rb532_button.
 
+config INPUT_DA9052_ONKEY
+        tristate "Dialog DA9052/DA9053 Onkey"
+        depends on PMIC_DA9052
+        help
+          Support the ONKEY of Dialog DA9052 PMICs as an input device
+          reporting power button status.
+
+          To compile this driver as a module, choose M here: the
+          module will be called da9052_onkey.
+
 config INPUT_DM355EVM
         tristate "TI DaVinci DM355 EVM Keypad and IR Remote"
         depends on MFD_DM355EVM_MSP
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 46671a875b91..f55cdf4916fa 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_INPUT_CM109)		+= cm109.o
 obj-$(CONFIG_INPUT_CMA3000)             += cma3000_d0x.o
 obj-$(CONFIG_INPUT_CMA3000_I2C)         += cma3000_d0x_i2c.o
 obj-$(CONFIG_INPUT_COBALT_BTNS)         += cobalt_btns.o
+obj-$(CONFIG_INPUT_DA9052_ONKEY)        += da9052_onkey.o
 obj-$(CONFIG_INPUT_DM355EVM)            += dm355evm_keys.o
 obj-$(CONFIG_INPUT_GP2A)                += gp2ap002a00f.o
 obj-$(CONFIG_INPUT_GPIO_TILT_POLLED)    += gpio_tilt_polled.o
@@ -30,6 +31,7 @@ obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)	+= keyspan_remote.o
 obj-$(CONFIG_INPUT_KXTJ9)               += kxtj9.o
 obj-$(CONFIG_INPUT_M68K_BEEP)           += m68kspkr.o
 obj-$(CONFIG_INPUT_MAX8925_ONKEY)       += max8925_onkey.o
+obj-$(CONFIG_INPUT_MAX8997_HAPTIC)      += max8997_haptic.o
 obj-$(CONFIG_INPUT_MC13783_PWRBUTTON)   += mc13783-pwrbutton.o
 obj-$(CONFIG_INPUT_MMA8450)             += mma8450.o
 obj-$(CONFIG_INPUT_MPU3050)             += mpu3050.o
diff --git a/drivers/input/misc/ab8500-ponkey.c b/drivers/input/misc/ab8500-ponkey.c
index 79d901633635..350fd0c385d2 100644
--- a/drivers/input/misc/ab8500-ponkey.c
+++ b/drivers/input/misc/ab8500-ponkey.c
@@ -12,7 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/slab.h>
 
 /**
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
index 56810fb4eadd..c8a79015472a 100644
--- a/drivers/input/misc/ad714x-i2c.c
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -116,17 +116,7 @@ static struct i2c_driver ad714x_i2c_driver = {
         .id_table = ad714x_id,
 };
 
-static int __init ad714x_i2c_init(void)
-{
-        return i2c_add_driver(&ad714x_i2c_driver);
-}
-module_init(ad714x_i2c_init);
-
-static void __exit ad714x_i2c_exit(void)
-{
-        i2c_del_driver(&ad714x_i2c_driver);
-}
-module_exit(ad714x_i2c_exit);
+module_i2c_driver(ad714x_i2c_driver);
 
 MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor I2C Bus Driver");
 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
index 875b50811361..75f6136d608e 100644
--- a/drivers/input/misc/ad714x-spi.c
+++ b/drivers/input/misc/ad714x-spi.c
@@ -123,17 +123,7 @@ static struct spi_driver ad714x_spi_driver = {
         .remove         = __devexit_p(ad714x_spi_remove),
 };
 
-static __init int ad714x_spi_init(void)
-{
-        return spi_register_driver(&ad714x_spi_driver);
-}
-module_init(ad714x_spi_init);
-
-static __exit void ad714x_spi_exit(void)
-{
-        spi_unregister_driver(&ad714x_spi_driver);
-}
-module_exit(ad714x_spi_exit);
+module_spi_driver(ad714x_spi_driver);
 
 MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor SPI Bus Driver");
 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
diff --git a/drivers/input/misc/adxl34x-i2c.c b/drivers/input/misc/adxl34x-i2c.c
index ccacf2bb06a4..dd1d1c145a7f 100644
--- a/drivers/input/misc/adxl34x-i2c.c
+++ b/drivers/input/misc/adxl34x-i2c.c
@@ -148,17 +148,7 @@ static struct i2c_driver adxl34x_driver = {
         .id_table = adxl34x_id,
 };
 
-static int __init adxl34x_i2c_init(void)
-{
-        return i2c_add_driver(&adxl34x_driver);
-}
-module_init(adxl34x_i2c_init);
-
-static void __exit adxl34x_i2c_exit(void)
-{
-        i2c_del_driver(&adxl34x_driver);
-}
-module_exit(adxl34x_i2c_exit);
+module_i2c_driver(adxl34x_driver);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer I2C Bus Driver");
diff --git a/drivers/input/misc/adxl34x-spi.c b/drivers/input/misc/adxl34x-spi.c
index 34d401efd4a1..820a802a1e6e 100644
--- a/drivers/input/misc/adxl34x-spi.c
+++ b/drivers/input/misc/adxl34x-spi.c
@@ -129,17 +129,7 @@ static struct spi_driver adxl34x_driver = {
         .remove  = __devexit_p(adxl34x_spi_remove),
 };
 
-static int __init adxl34x_spi_init(void)
-{
-        return spi_register_driver(&adxl34x_driver);
-}
-module_init(adxl34x_spi_init);
-
-static void __exit adxl34x_spi_exit(void)
-{
-        spi_unregister_driver(&adxl34x_driver);
-}
-module_exit(adxl34x_spi_exit);
+module_spi_driver(adxl34x_driver);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer SPI Bus Driver");
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index a34896ed7ed3..f63341f20b91 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -1013,23 +1013,4 @@ static int ati_remote2_post_reset(struct usb_interface *interface)
         return r;
 }
 
-static int __init ati_remote2_init(void)
-{
-        int r;
-
-        r = usb_register(&ati_remote2_driver);
-        if (r)
-                printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r);
-        else
-                printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n");
-
-        return r;
-}
-
-static void __exit ati_remote2_exit(void)
-{
-        usb_deregister(&ati_remote2_driver);
-}
-
-module_init(ati_remote2_init);
-module_exit(ati_remote2_exit);
+module_usb_driver(ati_remote2_driver);
diff --git a/drivers/input/misc/bma150.c b/drivers/input/misc/bma150.c
index 8f55b54352b6..e2f1e9f952b1 100644
--- a/drivers/input/misc/bma150.c
+++ b/drivers/input/misc/bma150.c
@@ -673,19 +673,8 @@ static struct i2c_driver bma150_driver = {
         .remove         = __devexit_p(bma150_remove),
 };
 
-static int __init BMA150_init(void)
-{
-        return i2c_add_driver(&bma150_driver);
-}
-
-static void __exit BMA150_exit(void)
-{
-        i2c_del_driver(&bma150_driver);
-}
+module_i2c_driver(bma150_driver);
 
 MODULE_AUTHOR("Albert Zhang <xu.zhang@bosch-sensortec.com>");
 MODULE_DESCRIPTION("BMA150 driver");
 MODULE_LICENSE("GPL");
-
-module_init(BMA150_init);
-module_exit(BMA150_exit);
diff --git a/drivers/input/misc/cma3000_d0x_i2c.c b/drivers/input/misc/cma3000_d0x_i2c.c
index d100cc5c5783..fe9b85f07792 100644
--- a/drivers/input/misc/cma3000_d0x_i2c.c
+++ b/drivers/input/misc/cma3000_d0x_i2c.c
@@ -125,18 +125,7 @@ static struct i2c_driver cma3000_i2c_driver = {
         },
 };
 
-static int __init cma3000_i2c_init(void)
-{
-        return i2c_add_driver(&cma3000_i2c_driver);
-}
-
-static void __exit cma3000_i2c_exit(void)
-{
-        i2c_del_driver(&cma3000_i2c_driver);
-}
-
-module_init(cma3000_i2c_init);
-module_exit(cma3000_i2c_exit);
+module_i2c_driver(cma3000_i2c_driver);
 
 MODULE_DESCRIPTION("CMA3000-D0x Accelerometer I2C Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/da9052_onkey.c b/drivers/input/misc/da9052_onkey.c
new file mode 100644
index 000000000000..34aebb8cd080
--- /dev/null
+++ b/drivers/input/misc/da9052_onkey.c
@@ -0,0 +1,169 @@
+/*
+ * ON pin driver for Dialog DA9052 PMICs
+ *
+ * Copyright(c) 2012 Dialog Semiconductor Ltd.
+ *
+ * Author: David Dajun Chen <dchen@diasemi.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+
+#include <linux/mfd/da9052/da9052.h>
+#include <linux/mfd/da9052/reg.h>
+
+struct da9052_onkey {
+        struct da9052 *da9052;
+        struct input_dev *input;
+        struct delayed_work work;
+        unsigned int irq;
+};
+
+static void da9052_onkey_query(struct da9052_onkey *onkey)
+{
+        int key_stat;
+
+        key_stat = da9052_reg_read(onkey->da9052, DA9052_EVENT_B_REG);
+        if (key_stat < 0) {
+                dev_err(onkey->da9052->dev,
+                        "Failed to read onkey event %d\n", key_stat);
+        } else {
+                /*
+                 * Since interrupt for deassertion of ONKEY pin is not
+                 * generated, onkey event state determines the onkey
+                 * button state.
+                 */
+                key_stat &= DA9052_EVENTB_ENONKEY;
+                input_report_key(onkey->input, KEY_POWER, key_stat);
+                input_sync(onkey->input);
+        }
+
+        /*
+         * Interrupt is generated only when the ONKEY pin is asserted.
+         * Hence the deassertion of the pin is simulated through work queue.
+         */
+        if (key_stat)
+                schedule_delayed_work(&onkey->work, msecs_to_jiffies(50));
+}
+
+static void da9052_onkey_work(struct work_struct *work)
+{
+        struct da9052_onkey *onkey = container_of(work, struct da9052_onkey,
+                                                  work.work);
+
+        da9052_onkey_query(onkey);
+}
+
+static irqreturn_t da9052_onkey_irq(int irq, void *data)
+{
+        struct da9052_onkey *onkey = data;
+
+        da9052_onkey_query(onkey);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit da9052_onkey_probe(struct platform_device *pdev)
+{
+        struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent);
+        struct da9052_onkey *onkey;
+        struct input_dev *input_dev;
+        int irq;
+        int error;
+
+        if (!da9052) {
+                dev_err(&pdev->dev, "Failed to get the driver's data\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq_byname(pdev, "ONKEY");
+        if (irq < 0) {
+                dev_err(&pdev->dev,
+                        "Failed to get an IRQ for input device, %d\n", irq);
+                return -EINVAL;
+        }
+
+        onkey = kzalloc(sizeof(*onkey), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!onkey || !input_dev) {
+                dev_err(&pdev->dev, "Failed to allocate memory\n");
+                return -ENOMEM;
+        }
+
+        onkey->input = input_dev;
+        onkey->da9052 = da9052;
+        onkey->irq = irq;
+        INIT_DELAYED_WORK(&onkey->work, da9052_onkey_work);
+
+        input_dev->name = "da9052-onkey";
+        input_dev->phys = "da9052-onkey/input0";
+        input_dev->dev.parent = &pdev->dev;
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+        __set_bit(KEY_POWER, input_dev->keybit);
+
+        error = request_threaded_irq(onkey->irq, NULL, da9052_onkey_irq,
+                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                     "ONKEY", onkey);
+        if (error < 0) {
+                dev_err(onkey->da9052->dev,
+                        "Failed to register ONKEY IRQ %d, error = %d\n",
+                        onkey->irq, error);
+                goto err_free_mem;
+        }
+
+        error = input_register_device(onkey->input);
+        if (error) {
+                dev_err(&pdev->dev, "Unable to register input device, %d\n",
+                        error);
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, onkey);
+        return 0;
+
+err_free_irq:
+        free_irq(onkey->irq, onkey);
+        cancel_delayed_work_sync(&onkey->work);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(onkey);
+
+        return error;
+}
+
+static int __devexit da9052_onkey_remove(struct platform_device *pdev)
+{
+        struct da9052_onkey *onkey = platform_get_drvdata(pdev);
+
+        free_irq(onkey->irq, onkey);
+        cancel_delayed_work_sync(&onkey->work);
+
+        input_unregister_device(onkey->input);
+        kfree(onkey);
+
+        return 0;
+}
+
+static struct platform_driver da9052_onkey_driver = {
+        .probe  = da9052_onkey_probe,
+        .remove = __devexit_p(da9052_onkey_remove),
+        .driver = {
+                .name   = "da9052-onkey",
+                .owner  = THIS_MODULE,
+        },
+};
+module_platform_driver(da9052_onkey_driver);
+
+MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
+MODULE_DESCRIPTION("Onkey driver for DA9052");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:da9052-onkey");
diff --git a/drivers/input/misc/gp2ap002a00f.c b/drivers/input/misc/gp2ap002a00f.c
index 71fba8c2fc66..b6664cfa340a 100644
--- a/drivers/input/misc/gp2ap002a00f.c
+++ b/drivers/input/misc/gp2ap002a00f.c
@@ -281,18 +281,7 @@ static struct i2c_driver gp2a_i2c_driver = {
         .id_table       = gp2a_i2c_id,
 };
 
-static int __init gp2a_init(void)
-{
-        return i2c_add_driver(&gp2a_i2c_driver);
-}
-
-static void __exit gp2a_exit(void)
-{
-        i2c_del_driver(&gp2a_i2c_driver);
-}
-
-module_init(gp2a_init);
-module_exit(gp2a_exit);
+module_i2c_driver(gp2a_i2c_driver);
 
 MODULE_AUTHOR("Courtney Cavin <courtney.cavin@sonyericsson.com>");
 MODULE_DESCRIPTION("Sharp GP2AP002A00F I2C Proximity/Opto sensor driver");
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index fc62256c963f..d99151a8bf10 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -580,26 +580,7 @@ static struct usb_driver keyspan_driver =
         .id_table =     keyspan_table
 };
 
-static int __init usb_keyspan_init(void)
-{
-        int result;
-
-        /* register this driver with the USB subsystem */
-        result = usb_register(&keyspan_driver);
-        if (result)
-                err("usb_register failed. Error number %d\n", result);
-
-        return result;
-}
-
-static void __exit usb_keyspan_exit(void)
-{
-        /* deregister this driver with the USB subsystem */
-        usb_deregister(&keyspan_driver);
-}
-
-module_init(usb_keyspan_init);
-module_exit(usb_keyspan_exit);
+module_usb_driver(keyspan_driver);
 
 MODULE_DEVICE_TABLE(usb, keyspan_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
diff --git a/drivers/input/misc/kxtj9.c b/drivers/input/misc/kxtj9.c
index 783597a9a64a..f46139f19ff1 100644
--- a/drivers/input/misc/kxtj9.c
+++ b/drivers/input/misc/kxtj9.c
@@ -41,6 +41,14 @@
 #define PC1_ON                  (1 << 7)
 /* Data ready funtion enable bit: set during probe if using irq mode */
 #define DRDYE                   (1 << 5)
+/* DATA CONTROL REGISTER BITS */
+#define ODR12_5F                0
+#define ODR25F                  1
+#define ODR50F                  2
+#define ODR100F         3
+#define ODR200F         4
+#define ODR400F         5
+#define ODR800F         6
 /* INTERRUPT CONTROL REGISTER 1 BITS */
 /* Set these during probe if using irq mode */
 #define KXTJ9_IEL               (1 << 3)
@@ -116,9 +124,13 @@ static void kxtj9_report_acceleration_data(struct kxtj9_data *tj9)
         if (err < 0)
                 dev_err(&tj9->client->dev, "accelerometer data read failed\n");
 
-        x = le16_to_cpu(acc_data[tj9->pdata.axis_map_x]) >> tj9->shift;
-        y = le16_to_cpu(acc_data[tj9->pdata.axis_map_y]) >> tj9->shift;
-        z = le16_to_cpu(acc_data[tj9->pdata.axis_map_z]) >> tj9->shift;
+        x = le16_to_cpu(acc_data[tj9->pdata.axis_map_x]);
+        y = le16_to_cpu(acc_data[tj9->pdata.axis_map_y]);
+        z = le16_to_cpu(acc_data[tj9->pdata.axis_map_z]);
+
+        x >>= tj9->shift;
+        y >>= tj9->shift;
+        z >>= tj9->shift;
 
         input_report_abs(tj9->input_dev, ABS_X, tj9->pdata.negate_x ? -x : x);
         input_report_abs(tj9->input_dev, ABS_Y, tj9->pdata.negate_y ? -y : y);
@@ -487,7 +499,7 @@ static int __devinit kxtj9_verify(struct kxtj9_data *tj9)
                 goto out;
         }
 
-        retval = retval != 0x06 ? -EIO : 0;
+        retval = (retval != 0x07 && retval != 0x08) ? -EIO : 0;
 
 out:
         kxtj9_device_power_off(tj9);
@@ -537,7 +549,7 @@ static int __devinit kxtj9_probe(struct i2c_client *client,
         i2c_set_clientdata(client, tj9);
 
         tj9->ctrl_reg1 = tj9->pdata.res_12bit | tj9->pdata.g_range;
-        tj9->data_ctrl = tj9->pdata.data_odr_init;
+        tj9->last_poll_interval = tj9->pdata.init_interval;
 
         if (client->irq) {
                 /* If in irq mode, populate INT_CTRL_REG1 and enable DRDY. */
@@ -655,17 +667,7 @@ static struct i2c_driver kxtj9_driver = {
         .id_table       = kxtj9_id,
 };
 
-static int __init kxtj9_init(void)
-{
-        return i2c_add_driver(&kxtj9_driver);
-}
-module_init(kxtj9_init);
-
-static void __exit kxtj9_exit(void)
-{
-        i2c_del_driver(&kxtj9_driver);
-}
-module_exit(kxtj9_exit);
+module_i2c_driver(kxtj9_driver);
 
 MODULE_DESCRIPTION("KXTJ9 accelerometer driver");
 MODULE_AUTHOR("Chris Hudson <chudson@kionix.com>");
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
index 23cf08271049..0a12b74140d3 100644
--- a/drivers/input/misc/max8925_onkey.c
+++ b/drivers/input/misc/max8925_onkey.c
@@ -1,5 +1,5 @@
 /**
- * max8925_onkey.c - MAX8925 ONKEY driver
+ * MAX8925 ONKEY driver
  *
  * Copyright (C) 2009 Marvell International Ltd.
  *      Haojian Zhuang <haojian.zhuang@marvell.com>
@@ -35,7 +35,7 @@ struct max8925_onkey_info {
         struct input_dev        *idev;
         struct i2c_client       *i2c;
         struct device           *dev;
-        int                     irq[2];
+        unsigned int            irq[2];
 };
 
 /*
@@ -46,17 +46,14 @@ struct max8925_onkey_info {
 static irqreturn_t max8925_onkey_handler(int irq, void *data)
 {
         struct max8925_onkey_info *info = data;
-        int ret, event;
-
-        ret = max8925_reg_read(info->i2c, MAX8925_ON_OFF_STATUS);
-        if (ret & SW_INPUT)
-                event = 1;
-        else
-                event = 0;
-        input_report_key(info->idev, KEY_POWER, event);
+        int state;
+
+        state = max8925_reg_read(info->i2c, MAX8925_ON_OFF_STATUS);
+
+        input_report_key(info->idev, KEY_POWER, state & SW_INPUT);
         input_sync(info->idev);
 
-        dev_dbg(info->dev, "onkey event:%d\n", event);
+        dev_dbg(info->dev, "onkey state:%d\n", state);
 
         /* Enable hardreset to halt if system isn't shutdown on time */
         max8925_set_bits(info->i2c, MAX8925_SYSENSEL,
@@ -69,6 +66,7 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
 {
         struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
         struct max8925_onkey_info *info;
+        struct input_dev *input;
         int irq[2], error;
 
         irq[0] = platform_get_irq(pdev, 0);
@@ -76,6 +74,7 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "No IRQ resource!\n");
                 return -EINVAL;
         }
+
         irq[1] = platform_get_irq(pdev, 1);
         if (irq[1] < 0) {
                 dev_err(&pdev->dev, "No IRQ resource!\n");
@@ -83,11 +82,24 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
         }
 
         info = kzalloc(sizeof(struct max8925_onkey_info), GFP_KERNEL);
-        if (!info)
-                return -ENOMEM;
+        input = input_allocate_device();
+        if (!info || !input) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
 
+        info->idev = input;
         info->i2c = chip->i2c;
         info->dev = &pdev->dev;
+        info->irq[0] = irq[0];
+        info->irq[1] = irq[1];
+
+        input->name = "max8925_on";
+        input->phys = "max8925_on/input0";
+        input->id.bustype = BUS_I2C;
+        input->dev.parent = &pdev->dev;
+        input_set_capability(input, EV_KEY, KEY_POWER);
+
         irq[0] += chip->irq_base;
         irq[1] += chip->irq_base;
 
@@ -96,60 +108,46 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
         if (error < 0) {
                 dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
                         irq[0], error);
-                goto out;
+                goto err_free_mem;
         }
+
         error = request_threaded_irq(irq[1], NULL, max8925_onkey_handler,
                                      IRQF_ONESHOT, "onkey-up", info);
         if (error < 0) {
                 dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
                         irq[1], error);
-                goto out_irq;
+                goto err_free_irq0;
         }
 
-        info->idev = input_allocate_device();
-        if (!info->idev) {
-                dev_err(chip->dev, "Failed to allocate input dev\n");
-                error = -ENOMEM;
-                goto out_input;
-        }
-
-        info->idev->name = "max8925_on";
-        info->idev->phys = "max8925_on/input0";
-        info->idev->id.bustype = BUS_I2C;
-        info->idev->dev.parent = &pdev->dev;
-        info->irq[0] = irq[0];
-        info->irq[1] = irq[1];
-        info->idev->evbit[0] = BIT_MASK(EV_KEY);
-        info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
-
-
         error = input_register_device(info->idev);
         if (error) {
                 dev_err(chip->dev, "Can't register input device: %d\n", error);
-                goto out_reg;
+                goto err_free_irq1;
         }
 
         platform_set_drvdata(pdev, info);
+        device_init_wakeup(&pdev->dev, 1);
 
         return 0;
 
-out_reg:
-        input_free_device(info->idev);
-out_input:
-        free_irq(info->irq[1], info);
-out_irq:
-        free_irq(info->irq[0], info);
-out:
+err_free_irq1:
+        free_irq(irq[1], info);
+err_free_irq0:
+        free_irq(irq[0], info);
+err_free_mem:
+        input_free_device(input);
         kfree(info);
+
         return error;
 }
 
 static int __devexit max8925_onkey_remove(struct platform_device *pdev)
 {
         struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
 
-        free_irq(info->irq[0], info);
-        free_irq(info->irq[1], info);
+        free_irq(info->irq[0] + chip->irq_base, info);
+        free_irq(info->irq[1] + chip->irq_base, info);
         input_unregister_device(info->idev);
         kfree(info);
 
@@ -158,10 +156,43 @@ static int __devexit max8925_onkey_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int max8925_onkey_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+        if (device_may_wakeup(dev)) {
+                chip->wakeup_flag |= 1 << info->irq[0];
+                chip->wakeup_flag |= 1 << info->irq[1];
+        }
+
+        return 0;
+}
+
+static int max8925_onkey_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+        if (device_may_wakeup(dev)) {
+                chip->wakeup_flag &= ~(1 << info->irq[0]);
+                chip->wakeup_flag &= ~(1 << info->irq[1]);
+        }
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8925_onkey_pm_ops, max8925_onkey_suspend, max8925_onkey_resume);
+
 static struct platform_driver max8925_onkey_driver = {
         .driver         = {
                 .name   = "max8925-onkey",
                 .owner  = THIS_MODULE,
+                .pm     = &max8925_onkey_pm_ops,
         },
         .probe          = max8925_onkey_probe,
         .remove         = __devexit_p(max8925_onkey_remove),
diff --git a/drivers/input/misc/max8997_haptic.c b/drivers/input/misc/max8997_haptic.c
new file mode 100644
index 000000000000..05b7b8bfaf0a
--- /dev/null
+++ b/drivers/input/misc/max8997_haptic.c
@@ -0,0 +1,407 @@
+/*
+ * MAX8997-haptic controller driver
+ *
+ * Copyright (C) 2012 Samsung Electronics
+ * Donggeun Kim <dg77.kim@samsung.com>
+ *
+ * This program is not provided / owned by Maxim Integrated Products.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/pwm.h>
+#include <linux/input.h>
+#include <linux/mfd/max8997-private.h>
+#include <linux/mfd/max8997.h>
+#include <linux/regulator/consumer.h>
+
+/* Haptic configuration 2 register */
+#define MAX8997_MOTOR_TYPE_SHIFT        7
+#define MAX8997_ENABLE_SHIFT            6
+#define MAX8997_MODE_SHIFT              5
+
+/* Haptic driver configuration register */
+#define MAX8997_CYCLE_SHIFT             6
+#define MAX8997_SIG_PERIOD_SHIFT        4
+#define MAX8997_SIG_DUTY_SHIFT          2
+#define MAX8997_PWM_DUTY_SHIFT          0
+
+struct max8997_haptic {
+        struct device *dev;
+        struct i2c_client *client;
+        struct input_dev *input_dev;
+        struct regulator *regulator;
+
+        struct work_struct work;
+        struct mutex mutex;
+
+        bool enabled;
+        unsigned int level;
+
+        struct pwm_device *pwm;
+        unsigned int pwm_period;
+        enum max8997_haptic_pwm_divisor pwm_divisor;
+
+        enum max8997_haptic_motor_type type;
+        enum max8997_haptic_pulse_mode mode;
+
+        unsigned int internal_mode_pattern;
+        unsigned int pattern_cycle;
+        unsigned int pattern_signal_period;
+};
+
+static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
+{
+        int ret = 0;
+
+        if (chip->mode == MAX8997_EXTERNAL_MODE) {
+                unsigned int duty = chip->pwm_period * chip->level / 100;
+                ret = pwm_config(chip->pwm, duty, chip->pwm_period);
+        } else {
+                int i;
+                u8 duty_index = 0;
+
+                for (i = 0; i <= 64; i++) {
+                        if (chip->level <= i * 100 / 64) {
+                                duty_index = i;
+                                break;
+                        }
+                }
+                switch (chip->internal_mode_pattern) {
+                case 0:
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
+                        break;
+                case 1:
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
+                        break;
+                case 2:
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
+                        break;
+                case 3:
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
+                        break;
+                default:
+                        break;
+                }
+        }
+        return ret;
+}
+
+static void max8997_haptic_configure(struct max8997_haptic *chip)
+{
+        u8 value;
+
+        value = chip->type << MAX8997_MOTOR_TYPE_SHIFT |
+                chip->enabled << MAX8997_ENABLE_SHIFT |
+                chip->mode << MAX8997_MODE_SHIFT | chip->pwm_divisor;
+        max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);
+
+        if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
+                value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT |
+                        chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT |
+                        chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT |
+                        chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
+                max8997_write_reg(chip->client,
+                        MAX8997_HAPTIC_REG_DRVCONF, value);
+
+                switch (chip->internal_mode_pattern) {
+                case 0:
+                        value = chip->pattern_cycle << 4;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_CYCLECONF1, value);
+                        value = chip->pattern_signal_period;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGCONF1, value);
+                        break;
+
+                case 1:
+                        value = chip->pattern_cycle;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_CYCLECONF1, value);
+                        value = chip->pattern_signal_period;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGCONF2, value);
+                        break;
+
+                case 2:
+                        value = chip->pattern_cycle << 4;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_CYCLECONF2, value);
+                        value = chip->pattern_signal_period;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGCONF3, value);
+                        break;
+
+                case 3:
+                        value = chip->pattern_cycle;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_CYCLECONF2, value);
+                        value = chip->pattern_signal_period;
+                        max8997_write_reg(chip->client,
+                                MAX8997_HAPTIC_REG_SIGCONF4, value);
+                        break;
+
+                default:
+                        break;
+                }
+        }
+}
+
+static void max8997_haptic_enable(struct max8997_haptic *chip)
+{
+        int error;
+
+        mutex_lock(&chip->mutex);
+
+        error = max8997_haptic_set_duty_cycle(chip);
+        if (error) {
+                dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
+                goto out;
+        }
+
+        if (!chip->enabled) {
+                chip->enabled = true;
+                regulator_enable(chip->regulator);
+                max8997_haptic_configure(chip);
+                if (chip->mode == MAX8997_EXTERNAL_MODE)
+                        pwm_enable(chip->pwm);
+        }
+
+out:
+        mutex_unlock(&chip->mutex);
+}
+
+static void max8997_haptic_disable(struct max8997_haptic *chip)
+{
+        mutex_lock(&chip->mutex);
+
+        if (chip->enabled) {
+                chip->enabled = false;
+                max8997_haptic_configure(chip);
+                if (chip->mode == MAX8997_EXTERNAL_MODE)
+                        pwm_disable(chip->pwm);
+                regulator_disable(chip->regulator);
+        }
+
+        mutex_unlock(&chip->mutex);
+}
+
+static void max8997_haptic_play_effect_work(struct work_struct *work)
+{
+        struct max8997_haptic *chip =
+                        container_of(work, struct max8997_haptic, work);
+
+        if (chip->level)
+                max8997_haptic_enable(chip);
+        else
+                max8997_haptic_disable(chip);
+}
+
+static int max8997_haptic_play_effect(struct input_dev *dev, void *data,
+                                  struct ff_effect *effect)
+{
+        struct max8997_haptic *chip = input_get_drvdata(dev);
+
+        chip->level = effect->u.rumble.strong_magnitude;
+        if (!chip->level)
+                chip->level = effect->u.rumble.weak_magnitude;
+
+        schedule_work(&chip->work);
+
+        return 0;
+}
+
+static void max8997_haptic_close(struct input_dev *dev)
+{
+        struct max8997_haptic *chip = input_get_drvdata(dev);
+
+        cancel_work_sync(&chip->work);
+        max8997_haptic_disable(chip);
+}
+
+static int __devinit max8997_haptic_probe(struct platform_device *pdev)
+{
+        struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        const struct max8997_platform_data *pdata =
+                                        dev_get_platdata(iodev->dev);
+        const struct max8997_haptic_platform_data *haptic_pdata =
+                                        pdata->haptic_pdata;
+        struct max8997_haptic *chip;
+        struct input_dev *input_dev;
+        int error;
+
+        if (!haptic_pdata) {
+                dev_err(&pdev->dev, "no haptic platform data\n");
+                return -EINVAL;
+        }
+
+        chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!chip || !input_dev) {
+                dev_err(&pdev->dev, "unable to allocate memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
+        mutex_init(&chip->mutex);
+
+        chip->client = iodev->haptic;
+        chip->dev = &pdev->dev;
+        chip->input_dev = input_dev;
+        chip->pwm_period = haptic_pdata->pwm_period;
+        chip->type = haptic_pdata->type;
+        chip->mode = haptic_pdata->mode;
+        chip->pwm_divisor = haptic_pdata->pwm_divisor;
+
+        switch (chip->mode) {
+        case MAX8997_INTERNAL_MODE:
+                chip->internal_mode_pattern =
+                                haptic_pdata->internal_mode_pattern;
+                chip->pattern_cycle = haptic_pdata->pattern_cycle;
+                chip->pattern_signal_period =
+                                haptic_pdata->pattern_signal_period;
+                break;
+
+        case MAX8997_EXTERNAL_MODE:
+                chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
+                                        "max8997-haptic");
+                if (IS_ERR(chip->pwm)) {
+                        error = PTR_ERR(chip->pwm);
+                        dev_err(&pdev->dev,
+                                "unable to request PWM for haptic, error: %d\n",
+                                error);
+                        goto err_free_mem;
+                }
+                break;
+
+        default:
+                dev_err(&pdev->dev,
+                        "Invalid chip mode specified (%d)\n", chip->mode);
+                error = -EINVAL;
+                goto err_free_mem;
+        }
+
+        chip->regulator = regulator_get(&pdev->dev, "inmotor");
+        if (IS_ERR(chip->regulator)) {
+                error = PTR_ERR(chip->regulator);
+                dev_err(&pdev->dev,
+                        "unable to get regulator, error: %d\n",
+                        error);
+                goto err_free_pwm;
+        }
+
+        input_dev->name = "max8997-haptic";
+        input_dev->id.version = 1;
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->close = max8997_haptic_close;
+        input_set_drvdata(input_dev, chip);
+        input_set_capability(input_dev, EV_FF, FF_RUMBLE);
+
+        error = input_ff_create_memless(input_dev, NULL,
+                                max8997_haptic_play_effect);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to create FF device, error: %d\n",
+                        error);
+                goto err_put_regulator;
+        }
+
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to register input device, error: %d\n",
+                        error);
+                goto err_destroy_ff;
+        }
+
+        platform_set_drvdata(pdev, chip);
+        return 0;
+
+err_destroy_ff:
+        input_ff_destroy(input_dev);
+err_put_regulator:
+        regulator_put(chip->regulator);
+err_free_pwm:
+        if (chip->mode == MAX8997_EXTERNAL_MODE)
+                pwm_free(chip->pwm);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(chip);
+
+        return error;
+}
+
+static int __devexit max8997_haptic_remove(struct platform_device *pdev)
+{
+        struct max8997_haptic *chip = platform_get_drvdata(pdev);
+
+        input_unregister_device(chip->input_dev);
+        regulator_put(chip->regulator);
+
+        if (chip->mode == MAX8997_EXTERNAL_MODE)
+                pwm_free(chip->pwm);
+
+        kfree(chip);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int max8997_haptic_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max8997_haptic *chip = platform_get_drvdata(pdev);
+
+        max8997_haptic_disable(chip);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);
+
+static const struct platform_device_id max8997_haptic_id[] = {
+        { "max8997-haptic", 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, max8997_haptic_id);
+
+static struct platform_driver max8997_haptic_driver = {
+        .driver = {
+                .name   = "max8997-haptic",
+                .owner  = THIS_MODULE,
+                .pm     = &max8997_haptic_pm_ops,
+        },
+        .probe          = max8997_haptic_probe,
+        .remove         = __devexit_p(max8997_haptic_remove),
+        .id_table       = max8997_haptic_id,
+};
+module_platform_driver(max8997_haptic_driver);
+
+MODULE_ALIAS("platform:max8997-haptic");
+MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
+MODULE_DESCRIPTION("max8997_haptic driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/mma8450.c b/drivers/input/misc/mma8450.c
index 4d60080bb5d5..873ebced544e 100644
--- a/drivers/input/misc/mma8450.c
+++ b/drivers/input/misc/mma8450.c
@@ -247,17 +247,7 @@ static struct i2c_driver mma8450_driver = {
         .id_table       = mma8450_id,
 };
 
-static int __init mma8450_init(void)
-{
-        return i2c_add_driver(&mma8450_driver);
-}
-module_init(mma8450_init);
-
-static void __exit mma8450_exit(void)
-{
-        i2c_del_driver(&mma8450_driver);
-}
-module_exit(mma8450_exit);
+module_i2c_driver(mma8450_driver);
 
 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_DESCRIPTION("MMA8450 3-Axis Accelerometer Driver");
diff --git a/drivers/input/misc/mpu3050.c b/drivers/input/misc/mpu3050.c
index 208d1a1cc7f3..5403c571b6a5 100644
--- a/drivers/input/misc/mpu3050.c
+++ b/drivers/input/misc/mpu3050.c
@@ -475,17 +475,7 @@ static struct i2c_driver mpu3050_i2c_driver = {
         .id_table       = mpu3050_ids,
 };
 
-static int __init mpu3050_init(void)
-{
-        return i2c_add_driver(&mpu3050_i2c_driver);
-}
-module_init(mpu3050_init);
-
-static void __exit mpu3050_exit(void)
-{
-        i2c_del_driver(&mpu3050_i2c_driver);
-}
-module_exit(mpu3050_exit);
+module_i2c_driver(mpu3050_i2c_driver);
 
 MODULE_AUTHOR("Wistron Corp.");
 MODULE_DESCRIPTION("MPU3050 Tri-axis gyroscope driver");
diff --git a/drivers/input/misc/pcf8574_keypad.c b/drivers/input/misc/pcf8574_keypad.c
index 08be1a355956..544c6635abe9 100644
--- a/drivers/input/misc/pcf8574_keypad.c
+++ b/drivers/input/misc/pcf8574_keypad.c
@@ -216,17 +216,7 @@ static struct i2c_driver pcf8574_kp_driver = {
         .id_table = pcf8574_kp_id,
 };
 
-static int __init pcf8574_kp_init(void)
-{
-        return i2c_add_driver(&pcf8574_kp_driver);
-}
-module_init(pcf8574_kp_init);
-
-static void __exit pcf8574_kp_exit(void)
-{
-        i2c_del_driver(&pcf8574_kp_driver);
-}
-module_exit(pcf8574_kp_exit);
+module_i2c_driver(pcf8574_kp_driver);
 
 MODULE_AUTHOR("Michael Hennerich");
 MODULE_DESCRIPTION("Keypad input driver for 16 keys connected to PCF8574");
diff --git a/drivers/input/misc/powermate.c b/drivers/input/misc/powermate.c
index f45947190e4f..538f7049ec64 100644
--- a/drivers/input/misc/powermate.c
+++ b/drivers/input/misc/powermate.c
@@ -441,18 +441,7 @@ static struct usb_driver powermate_driver = {
         .id_table =     powermate_devices,
 };
 
-static int __init powermate_init(void)
-{
-        return usb_register(&powermate_driver);
-}
-
-static void __exit powermate_cleanup(void)
-{
-        usb_deregister(&powermate_driver);
-}
-
-module_init(powermate_init);
-module_exit(powermate_cleanup);
+module_usb_driver(powermate_driver);
 
 MODULE_AUTHOR( "William R Sowerbutts" );
 MODULE_DESCRIPTION( "Griffin Technology, Inc PowerMate driver" );
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index 52b419348983..e2bdfd4bea70 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -48,7 +48,7 @@ MODULE_DESCRIPTION("Wistron laptop button driver");
 MODULE_LICENSE("GPL v2");
 MODULE_VERSION("0.3");
 
-static int force; /* = 0; */
+static bool force; /* = 0; */
 module_param(force, bool, 0);
 MODULE_PARM_DESC(force, "Load even if computer is not in database");
 
diff --git a/drivers/input/misc/xen-kbdfront.c b/drivers/input/misc/xen-kbdfront.c
index ad2e51c04db8..02ca8680ea5b 100644
--- a/drivers/input/misc/xen-kbdfront.c
+++ b/drivers/input/misc/xen-kbdfront.c
@@ -361,15 +361,12 @@ static const struct xenbus_device_id xenkbd_ids[] = {
         { "" }
 };
 
-static struct xenbus_driver xenkbd_driver = {
-        .name = "vkbd",
-        .owner = THIS_MODULE,
-        .ids = xenkbd_ids,
+static DEFINE_XENBUS_DRIVER(xenkbd, ,
         .probe = xenkbd_probe,
         .remove = xenkbd_remove,
         .resume = xenkbd_resume,
         .otherend_changed = xenkbd_backend_changed,
-};
+);
 
 static int __init xenkbd_init(void)
 {
diff --git a/drivers/input/misc/yealink.c b/drivers/input/misc/yealink.c
index 41201c6b5e68..f4776e7f8c15 100644
--- a/drivers/input/misc/yealink.c
+++ b/drivers/input/misc/yealink.c
@@ -988,22 +988,7 @@ static struct usb_driver yealink_driver = {
         .id_table       = usb_table,
 };
 
-static int __init yealink_dev_init(void)
-{
-        int ret = usb_register(&yealink_driver);
-        if (ret == 0)
-                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-                       DRIVER_DESC "\n");
-        return ret;
-}
-
-static void __exit yealink_dev_exit(void)
-{
-        usb_deregister(&yealink_driver);
-}
-
-module_init(yealink_dev_init);
-module_exit(yealink_dev_exit);
+module_usb_driver(yealink_driver);
 
 MODULE_DEVICE_TABLE (usb, usb_table);