Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input: (64 commits)
  Input: tsc2005 - remove 'disable' sysfs attribute
  Input: tsc2005 - add open/close
  Input: tsc2005 - handle read errors from SPI layer
  Input: tsc2005 - do not rearm timer in hardirq handler
  Input: tsc2005 - don't use work for 'pen up' handling
  Input: tsc2005 - do not use 0 in place of NULL
  Input: tsc2005 - use true/false for boolean variables
  Input: tsc2005 - hide selftest attribute if we can't reset
  Input: tsc2005 - rework driver initialization code
  Input: tsc2005 - set up bus type in input device
  Input: tsc2005 - set up parent device
  Input: tsc2005 - clear driver data after unbinding
  Input: tsc2005 - add module description
  Input: tsc2005 - remove driver banner message
  Input: tsc2005 - remove incorrect module alias
  Input: tsc2005 - convert to using dev_pm_ops
  Input: tsc2005 - use spi_get/set_drvdata()
  Input: introduce tsc2005 driver
  Input: xen-kbdfront - move to drivers/input/misc
  Input: xen-kbdfront - add grant reference for shared page
  ...

9 files changed, 455 insertions, 45 deletions

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index c7a92028f450..b16bed038f72 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -112,6 +112,16 @@ config KEYBOARD_ATKBD_RDI_KEYCODES
           right-hand column will be interpreted as the key shown in the
           left-hand column.
 
+config KEYBOARD_QT1070
+       tristate "Atmel AT42QT1070 Touch Sensor Chip"
+       depends on I2C
+       help
+         Say Y here if you want to use Atmel AT42QT1070 QTouch
+         Sensor chip as input device.
+
+         To compile this driver as a module, choose M here:
+         the module will be called qt1070
+
 config KEYBOARD_QT2160
         tristate "Atmel AT42QT2160 Touch Sensor Chip"
         depends on I2C && EXPERIMENTAL
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 468c627a2844..878e6c20deb0 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -34,6 +34,7 @@ obj-$(CONFIG_KEYBOARD_OMAP4)		+= omap4-keypad.o
 obj-$(CONFIG_KEYBOARD_OPENCORES)        += opencores-kbd.o
 obj-$(CONFIG_KEYBOARD_PXA27x)           += pxa27x_keypad.o
 obj-$(CONFIG_KEYBOARD_PXA930_ROTARY)    += pxa930_rotary.o
+obj-$(CONFIG_KEYBOARD_QT1070)           += qt1070.o
 obj-$(CONFIG_KEYBOARD_QT2160)           += qt2160.o
 obj-$(CONFIG_KEYBOARD_SAMSUNG)          += samsung-keypad.o
 obj-$(CONFIG_KEYBOARD_SH_KEYSC)         += sh_keysc.o
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index f7c2a166576b..b732870ecc89 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -30,6 +30,7 @@
 #include <linux/delay.h>
 #include <linux/input.h>
 #include <linux/leds.h>
+#include <linux/pm.h>
 #include <linux/i2c/lm8323.h>
 #include <linux/slab.h>
 
@@ -802,8 +803,9 @@ static int __devexit lm8323_remove(struct i2c_client *client)
  * We don't need to explicitly suspend the chip, as it already switches off
  * when there's no activity.
  */
-static int lm8323_suspend(struct i2c_client *client, pm_message_t mesg)
+static int lm8323_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
@@ -821,8 +823,9 @@ static int lm8323_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int lm8323_resume(struct i2c_client *client)
+static int lm8323_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
@@ -839,11 +842,10 @@ static int lm8323_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define lm8323_suspend  NULL
-#define lm8323_resume   NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(lm8323_pm_ops, lm8323_suspend, lm8323_resume);
+
 static const struct i2c_device_id lm8323_id[] = {
         { "lm8323", 0 },
         { }
@@ -852,11 +854,10 @@ static const struct i2c_device_id lm8323_id[] = {
 static struct i2c_driver lm8323_i2c_driver = {
         .driver = {
                 .name   = "lm8323",
+                .pm     = &lm8323_pm_ops,
         },
         .probe          = lm8323_probe,
         .remove         = __devexit_p(lm8323_remove),
-        .suspend        = lm8323_suspend,
-        .resume         = lm8323_resume,
         .id_table       = lm8323_id,
 };
 MODULE_DEVICE_TABLE(i2c, lm8323_id);
diff --git a/drivers/input/keyboard/max7359_keypad.c b/drivers/input/keyboard/max7359_keypad.c
index 9091ff5ea808..5afe35ad24d3 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -17,6 +17,7 @@
 #include <linux/i2c.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 #include <linux/input.h>
 #include <linux/input/matrix_keypad.h>
 
@@ -271,8 +272,10 @@ static int __devexit max7359_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int max7359_suspend(struct i2c_client *client, pm_message_t mesg)
+static int max7359_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         max7359_fall_deepsleep(client);
 
         if (device_may_wakeup(&client->dev))
@@ -281,8 +284,10 @@ static int max7359_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int max7359_resume(struct i2c_client *client)
+static int max7359_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         if (device_may_wakeup(&client->dev))
                 disable_irq_wake(client->irq);
 
@@ -291,11 +296,10 @@ static int max7359_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define max7359_suspend NULL
-#define max7359_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(max7359_pm, max7359_suspend, max7359_resume);
+
 static const struct i2c_device_id max7359_ids[] = {
         { "max7359", 0 },
         { }
@@ -305,11 +309,10 @@ MODULE_DEVICE_TABLE(i2c, max7359_ids);
 static struct i2c_driver max7359_i2c_driver = {
         .driver = {
                 .name = "max7359",
+                .pm   = &max7359_pm,
         },
         .probe          = max7359_probe,
         .remove         = __devexit_p(max7359_remove),
-        .suspend        = max7359_suspend,
-        .resume         = max7359_resume,
         .id_table       = max7359_ids,
 };
 
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 63b849d7e90b..af1aab324a4c 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -1,5 +1,5 @@
 /*
- * mcs_touchkey.c - Touchkey driver for MELFAS MCS5000/5080 controller
+ * Touchkey driver for MELFAS MCS5000/5080 controller
  *
  * Copyright (C) 2010 Samsung Electronics Co.Ltd
  * Author: HeungJun Kim <riverful.kim@samsung.com>
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
+#include <linux/pm.h>
 
 /* MCS5000 Touchkey */
 #define MCS5000_TOUCHKEY_STATUS         0x04
@@ -45,6 +46,8 @@ struct mcs_touchkey_chip {
 };
 
 struct mcs_touchkey_data {
+        void (*poweron)(bool);
+
         struct i2c_client *client;
         struct input_dev *input_dev;
         struct mcs_touchkey_chip chip;
@@ -169,6 +172,11 @@ static int __devinit mcs_touchkey_probe(struct i2c_client *client,
         if (pdata->cfg_pin)
                 pdata->cfg_pin();
 
+        if (pdata->poweron) {
+                data->poweron = pdata->poweron;
+                data->poweron(true);
+        }
+
         error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt,
                         IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
         if (error) {
@@ -196,12 +204,57 @@ static int __devexit mcs_touchkey_remove(struct i2c_client *client)
         struct mcs_touchkey_data *data = i2c_get_clientdata(client);
 
         free_irq(client->irq, data);
+        if (data->poweron)
+                data->poweron(false);
         input_unregister_device(data->input_dev);
         kfree(data);
 
         return 0;
 }
 
+static void mcs_touchkey_shutdown(struct i2c_client *client)
+{
+        struct mcs_touchkey_data *data = i2c_get_clientdata(client);
+
+        if (data->poweron)
+                data->poweron(false);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mcs_touchkey_suspend(struct device *dev)
+{
+        struct mcs_touchkey_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+
+        /* Disable the work */
+        disable_irq(client->irq);
+
+        /* Finally turn off the power */
+        if (data->poweron)
+                data->poweron(false);
+
+        return 0;
+}
+
+static int mcs_touchkey_resume(struct device *dev)
+{
+        struct mcs_touchkey_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+
+        /* Enable the device first */
+        if (data->poweron)
+                data->poweron(true);
+
+        /* Enable irq again */
+        enable_irq(client->irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(mcs_touchkey_pm_ops,
+                         mcs_touchkey_suspend, mcs_touchkey_resume);
+
 static const struct i2c_device_id mcs_touchkey_id[] = {
         { "mcs5000_touchkey", MCS5000_TOUCHKEY },
         { "mcs5080_touchkey", MCS5080_TOUCHKEY },
@@ -213,9 +266,11 @@ static struct i2c_driver mcs_touchkey_driver = {
         .driver = {
                 .name   = "mcs_touchkey",
                 .owner  = THIS_MODULE,
+                .pm     = &mcs_touchkey_pm_ops,
         },
         .probe          = mcs_touchkey_probe,
         .remove         = __devexit_p(mcs_touchkey_remove),
+        .shutdown       = mcs_touchkey_shutdown,
         .id_table       = mcs_touchkey_id,
 };
 
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c
index 45bd0977d006..c51a3c4a7feb 100644
--- a/drivers/input/keyboard/omap4-keypad.c
+++ b/drivers/input/keyboard/omap4-keypad.c
@@ -29,6 +29,7 @@
 #include <linux/io.h>
 #include <linux/input.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <plat/omap4-keypad.h>
 
@@ -80,20 +81,6 @@ struct omap4_keypad {
         unsigned short keymap[];
 };
 
-static void __devinit omap4_keypad_config(struct omap4_keypad *keypad_data)
-{
-        __raw_writel(OMAP4_VAL_FUNCTIONALCFG,
-                        keypad_data->base + OMAP4_KBD_CTRL);
-        __raw_writel(OMAP4_VAL_DEBOUNCINGTIME,
-                        keypad_data->base + OMAP4_KBD_DEBOUNCINGTIME);
-        __raw_writel(OMAP4_VAL_IRQDISABLE,
-                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
-        __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,
-                        keypad_data->base + OMAP4_KBD_IRQENABLE);
-        __raw_writel(OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA,
-                        keypad_data->base + OMAP4_KBD_WAKEUPENABLE);
-}
-
 /* Interrupt handler */
 static irqreturn_t omap4_keypad_interrupt(int irq, void *dev_id)
 {
@@ -144,6 +131,49 @@ static irqreturn_t omap4_keypad_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static int omap4_keypad_open(struct input_dev *input)
+{
+        struct omap4_keypad *keypad_data = input_get_drvdata(input);
+
+        pm_runtime_get_sync(input->dev.parent);
+
+        disable_irq(keypad_data->irq);
+
+        __raw_writel(OMAP4_VAL_FUNCTIONALCFG,
+                        keypad_data->base + OMAP4_KBD_CTRL);
+        __raw_writel(OMAP4_VAL_DEBOUNCINGTIME,
+                        keypad_data->base + OMAP4_KBD_DEBOUNCINGTIME);
+        __raw_writel(OMAP4_VAL_IRQDISABLE,
+                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
+        __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,
+                        keypad_data->base + OMAP4_KBD_IRQENABLE);
+        __raw_writel(OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA,
+                        keypad_data->base + OMAP4_KBD_WAKEUPENABLE);
+
+        enable_irq(keypad_data->irq);
+
+        return 0;
+}
+
+static void omap4_keypad_close(struct input_dev *input)
+{
+        struct omap4_keypad *keypad_data = input_get_drvdata(input);
+
+        disable_irq(keypad_data->irq);
+
+        /* Disable interrupts */
+        __raw_writel(OMAP4_VAL_IRQDISABLE,
+                     keypad_data->base + OMAP4_KBD_IRQENABLE);
+
+        /* clear pending interrupts */
+        __raw_writel(__raw_readl(keypad_data->base + OMAP4_KBD_IRQSTATUS),
+                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
+
+        enable_irq(keypad_data->irq);
+
+        pm_runtime_put_sync(input->dev.parent);
+}
+
 static int __devinit omap4_keypad_probe(struct platform_device *pdev)
 {
         const struct omap4_keypad_platform_data *pdata;
@@ -225,6 +255,9 @@ static int __devinit omap4_keypad_probe(struct platform_device *pdev)
         input_dev->id.product = 0x0001;
         input_dev->id.version = 0x0001;
 
+        input_dev->open = omap4_keypad_open;
+        input_dev->close = omap4_keypad_close;
+
         input_dev->keycode      = keypad_data->keymap;
         input_dev->keycodesize  = sizeof(keypad_data->keymap[0]);
         input_dev->keycodemax   = max_keys;
@@ -239,8 +272,6 @@ static int __devinit omap4_keypad_probe(struct platform_device *pdev)
         matrix_keypad_build_keymap(pdata->keymap_data, row_shift,
                         input_dev->keycode, input_dev->keybit);
 
-        omap4_keypad_config(keypad_data);
-
         error = request_irq(keypad_data->irq, omap4_keypad_interrupt,
                              IRQF_TRIGGER_RISING,
                              "omap4-keypad", keypad_data);
@@ -249,17 +280,19 @@ static int __devinit omap4_keypad_probe(struct platform_device *pdev)
                 goto err_free_input;
         }
 
+        pm_runtime_enable(&pdev->dev);
+
         error = input_register_device(keypad_data->input);
         if (error < 0) {
                 dev_err(&pdev->dev, "failed to register input device\n");
-                goto err_free_irq;
+                goto err_pm_disable;
         }
 
-
         platform_set_drvdata(pdev, keypad_data);
         return 0;
 
-err_free_irq:
+err_pm_disable:
+        pm_runtime_disable(&pdev->dev);
         free_irq(keypad_data->irq, keypad_data);
 err_free_input:
         input_free_device(input_dev);
@@ -278,6 +311,9 @@ static int __devexit omap4_keypad_remove(struct platform_device *pdev)
         struct resource *res;
 
         free_irq(keypad_data->irq, keypad_data);
+
+        pm_runtime_disable(&pdev->dev);
+
         input_unregister_device(keypad_data->input);
 
         iounmap(keypad_data->base);
diff --git a/drivers/input/keyboard/qt1070.c b/drivers/input/keyboard/qt1070.c
new file mode 100644
index 000000000000..fba8404c7297
--- /dev/null
+++ b/drivers/input/keyboard/qt1070.c
@@ -0,0 +1,276 @@
+/*
+ *  Atmel AT42QT1070 QTouch Sensor Controller
+ *
+ *  Copyright (C) 2011 Atmel
+ *
+ *  Authors: Bo Shen <voice.shen@atmel.com>
+ *
+ *  Base on AT42QT2160 driver by:
+ *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
+ *  Copyright (C) 2009
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/delay.h>
+
+/* Address for each register */
+#define CHIP_ID            0x00
+#define QT1070_CHIP_ID     0x2E
+
+#define FW_VERSION         0x01
+#define QT1070_FW_VERSION  0x15
+
+#define DET_STATUS         0x02
+
+#define KEY_STATUS         0x03
+
+/* Calibrate */
+#define CALIBRATE_CMD      0x38
+#define QT1070_CAL_TIME    200
+
+/* Reset */
+#define RESET              0x39
+#define QT1070_RESET_TIME  255
+
+/* AT42QT1070 support up to 7 keys */
+static const unsigned short qt1070_key2code[] = {
+        KEY_0, KEY_1, KEY_2, KEY_3,
+        KEY_4, KEY_5, KEY_6,
+};
+
+struct qt1070_data {
+        struct i2c_client *client;
+        struct input_dev *input;
+        unsigned int irq;
+        unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
+        u8 last_keys;
+};
+
+static int qt1070_read(struct i2c_client *client, u8 reg)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "can not read register, returned %d\n", ret);
+
+        return ret;
+}
+
+static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, data);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "can not write register, returned %d\n", ret);
+
+        return ret;
+}
+
+static bool __devinit qt1070_identify(struct i2c_client *client)
+{
+        int id, ver;
+
+        /* Read Chip ID */
+        id = qt1070_read(client, CHIP_ID);
+        if (id != QT1070_CHIP_ID) {
+                dev_err(&client->dev, "ID %d not supported\n", id);
+                return false;
+        }
+
+        /* Read firmware version */
+        ver = qt1070_read(client, FW_VERSION);
+        if (ver < 0) {
+                dev_err(&client->dev, "could not read the firmware version\n");
+                return false;
+        }
+
+        dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver);
+
+        return true;
+}
+
+static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
+{
+        struct qt1070_data *data = dev_id;
+        struct i2c_client *client = data->client;
+        struct input_dev *input = data->input;
+        int i;
+        u8 new_keys, keyval, mask = 0x01;
+
+        /* Read the detected status register, thus clearing interrupt */
+        qt1070_read(client, DET_STATUS);
+
+        /* Read which key changed */
+        new_keys = qt1070_read(client, KEY_STATUS);
+
+        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
+                keyval = new_keys & mask;
+                if ((data->last_keys & mask) != keyval)
+                        input_report_key(input, data->keycodes[i], keyval);
+                mask <<= 1;
+        }
+        input_sync(input);
+
+        data->last_keys = new_keys;
+        return IRQ_HANDLED;
+}
+
+static int __devinit qt1070_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        struct qt1070_data *data;
+        struct input_dev *input;
+        int i;
+        int err;
+
+        err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
+        if (!err) {
+                dev_err(&client->dev, "%s adapter not supported\n",
+                        dev_driver_string(&client->adapter->dev));
+                return -ENODEV;
+        }
+
+        if (!client->irq) {
+                dev_err(&client->dev, "please assign the irq to this device\n");
+                return -EINVAL;
+        }
+
+        /* Identify the qt1070 chip */
+        if (!qt1070_identify(client))
+                return -ENODEV;
+
+        data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!data || !input) {
+                dev_err(&client->dev, "insufficient memory\n");
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        data->client = client;
+        data->input = input;
+        data->irq = client->irq;
+
+        input->name = "AT42QT1070 QTouch Sensor";
+        input->dev.parent = &client->dev;
+        input->id.bustype = BUS_I2C;
+
+        /* Add the keycode */
+        input->keycode = data->keycodes;
+        input->keycodesize = sizeof(data->keycodes[0]);
+        input->keycodemax = ARRAY_SIZE(qt1070_key2code);
+
+        __set_bit(EV_KEY, input->evbit);
+
+        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
+                data->keycodes[i] = qt1070_key2code[i];
+                __set_bit(qt1070_key2code[i], input->keybit);
+        }
+
+        /* Calibrate device */
+        qt1070_write(client, CALIBRATE_CMD, 1);
+        msleep(QT1070_CAL_TIME);
+
+        /* Soft reset */
+        qt1070_write(client, RESET, 1);
+        msleep(QT1070_RESET_TIME);
+
+        err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
+                IRQF_TRIGGER_NONE, client->dev.driver->name, data);
+        if (err) {
+                dev_err(&client->dev, "fail to request irq\n");
+                goto err_free_mem;
+        }
+
+        /* Register the input device */
+        err = input_register_device(data->input);
+        if (err) {
+                dev_err(&client->dev, "Failed to register input device\n");
+                goto err_free_irq;
+        }
+
+        i2c_set_clientdata(client, data);
+
+        /* Read to clear the chang line */
+        qt1070_read(client, DET_STATUS);
+
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, data);
+err_free_mem:
+        input_free_device(input);
+        kfree(data);
+        return err;
+}
+
+static int __devexit qt1070_remove(struct i2c_client *client)
+{
+        struct qt1070_data *data = i2c_get_clientdata(client);
+
+        /* Release IRQ */
+        free_irq(client->irq, data);
+
+        input_unregister_device(data->input);
+        kfree(data);
+
+        i2c_set_clientdata(client, NULL);
+
+        return 0;
+}
+
+static const struct i2c_device_id qt1070_id[] = {
+        { "qt1070", 0 },
+        { },
+};
+
+static struct i2c_driver qt1070_driver = {
+        .driver = {
+                .name   = "qt1070",
+                .owner  = THIS_MODULE,
+        },
+        .id_table       = qt1070_id,
+        .probe          = qt1070_probe,
+        .remove         = __devexit_p(qt1070_remove),
+};
+
+static int __init qt1070_init(void)
+{
+        return i2c_add_driver(&qt1070_driver);
+}
+module_init(qt1070_init);
+
+static void __exit qt1070_exit(void)
+{
+        i2c_del_driver(&qt1070_driver);
+}
+module_exit(qt1070_exit);
+
+MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
+MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c
index dbbe761778d2..99122f59e988 100644
--- a/drivers/input/keyboard/tc3589x-keypad.c
+++ b/drivers/input/keyboard/tc3589x-keypad.c
@@ -402,7 +402,7 @@ static int __devexit tc3589x_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int tc3589x_keypad_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -439,19 +439,19 @@ static int tc3589x_keypad_resume(struct device *dev)
 
         return 0;
 }
-
-static const SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops,
-                               tc3589x_keypad_suspend, tc3589x_keypad_resume);
 #endif
 
+static SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops,
+                         tc3589x_keypad_suspend, tc3589x_keypad_resume);
+
 static struct platform_driver tc3589x_keypad_driver = {
-        .driver.name  = "tc3589x-keypad",
-        .driver.owner = THIS_MODULE,
-#ifdef CONFIG_PM
-        .driver.pm = &tc3589x_keypad_dev_pm_ops,
-#endif
-        .probe = tc3589x_keypad_probe,
-        .remove = __devexit_p(tc3589x_keypad_remove),
+        .driver = {
+                .name   = "tc3589x-keypad",
+                .owner  = THIS_MODULE,
+                .pm     = &tc3589x_keypad_dev_pm_ops,
+        },
+        .probe  = tc3589x_keypad_probe,
+        .remove = __devexit_p(tc3589x_keypad_remove),
 };
 
 static int __init tc3589x_keypad_init(void)
diff --git a/drivers/input/keyboard/tca6416-keypad.c b/drivers/input/keyboard/tca6416-keypad.c
index 800fbccf1f0f..3afea3f89718 100644
--- a/drivers/input/keyboard/tca6416-keypad.c
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -297,6 +297,7 @@ static int __devinit tca6416_keypad_probe(struct i2c_client *client,
         }
 
         i2c_set_clientdata(client, chip);
+        device_init_wakeup(&client->dev, 1);
 
         return 0;
 
@@ -326,10 +327,37 @@ static int __devexit tca6416_keypad_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int tca6416_keypad_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(chip->irqnum);
+
+        return 0;
+}
+
+static int tca6416_keypad_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(chip->irqnum);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(tca6416_keypad_dev_pm_ops,
+                         tca6416_keypad_suspend, tca6416_keypad_resume);
 
 static struct i2c_driver tca6416_keypad_driver = {
         .driver = {
                 .name   = "tca6416-keypad",
+                .pm     = &tca6416_keypad_dev_pm_ops,
         },
         .probe          = tca6416_keypad_probe,
         .remove         = __devexit_p(tca6416_keypad_remove),