Merge branch 'next' into for-linus

Prepare input updates for 3.16.

12 files changed, 462 insertions, 243 deletions

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index ffc7ad3a2c88..f7e79b481349 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -524,6 +524,17 @@ config KEYBOARD_STOWAWAY
           To compile this driver as a module, choose M here: the
           module will be called stowaway.
 
+config KEYBOARD_ST_KEYSCAN
+        tristate "STMicroelectronics keyscan support"
+        depends on ARCH_STI || COMPILE_TEST
+        select INPUT_MATRIXKMAP
+        help
+          Say Y here if you want to use a keypad attached to the keyscan block
+          on some STMicroelectronics SoC devices.
+
+          To compile this driver as a module, choose M here: the
+          module will be called st-keyscan.
+
 config KEYBOARD_SUNKBD
         tristate "Sun Type 4 and Type 5 keyboard"
         select SERIO
@@ -578,7 +589,7 @@ config KEYBOARD_OMAP
 
 config KEYBOARD_OMAP4
         tristate "TI OMAP4+ keypad support"
-        depends on ARCH_OMAP2PLUS
+        depends on OF || ARCH_OMAP2PLUS
         select INPUT_MATRIXKMAP
         help
           Say Y here if you want to use the OMAP4+ keypad.
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 11cff7b84b47..7504ae19049d 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -51,6 +51,7 @@ obj-$(CONFIG_KEYBOARD_SH_KEYSC)		+= sh_keysc.o
 obj-$(CONFIG_KEYBOARD_SPEAR)            += spear-keyboard.o
 obj-$(CONFIG_KEYBOARD_STMPE)            += stmpe-keypad.o
 obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
+obj-$(CONFIG_KEYBOARD_ST_KEYSCAN)       += st-keyscan.o
 obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
 obj-$(CONFIG_KEYBOARD_TC3589X)          += tc3589x-keypad.o
 obj-$(CONFIG_KEYBOARD_TEGRA)            += tegra-kbc.o
diff --git a/drivers/input/keyboard/adp5520-keys.c b/drivers/input/keyboard/adp5520-keys.c
index 4cc14c2fa7d5..7f4a8b58efc1 100644
--- a/drivers/input/keyboard/adp5520-keys.c
+++ b/drivers/input/keyboard/adp5520-keys.c
@@ -12,6 +12,7 @@
 #include <linux/input.h>
 #include <linux/mfd/adp5520.h>
 #include <linux/slab.h>
+#include <linux/device.h>
 
 struct adp5520_keys {
         struct input_dev *input;
@@ -81,7 +82,7 @@ static int adp5520_keys_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        if (pdata == NULL) {
+        if (!pdata) {
                 dev_err(&pdev->dev, "missing platform data\n");
                 return -EINVAL;
         }
@@ -89,17 +90,15 @@ static int adp5520_keys_probe(struct platform_device *pdev)
         if (!(pdata->rows_en_mask && pdata->cols_en_mask))
                 return -EINVAL;
 
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (dev == NULL) {
+        dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
+        if (!dev) {
                 dev_err(&pdev->dev, "failed to alloc memory\n");
                 return -ENOMEM;
         }
 
-        input = input_allocate_device();
-        if (!input) {
-                ret = -ENOMEM;
-                goto err;
-        }
+        input = devm_input_allocate_device(&pdev->dev);
+        if (!input)
+                return -ENOMEM;
 
         dev->master = pdev->dev.parent;
         dev->input = input;
@@ -135,7 +134,7 @@ static int adp5520_keys_probe(struct platform_device *pdev)
         ret = input_register_device(input);
         if (ret) {
                 dev_err(&pdev->dev, "unable to register input device\n");
-                goto err;
+                return ret;
         }
 
         en_mask = pdata->rows_en_mask | pdata->cols_en_mask;
@@ -157,8 +156,7 @@ static int adp5520_keys_probe(struct platform_device *pdev)
 
         if (ret) {
                 dev_err(&pdev->dev, "failed to write\n");
-                ret = -EIO;
-                goto err1;
+                return -EIO;
         }
 
         dev->notifier.notifier_call = adp5520_keys_notifier;
@@ -166,19 +164,11 @@ static int adp5520_keys_probe(struct platform_device *pdev)
                         ADP5520_KP_IEN | ADP5520_KR_IEN);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register notifier\n");
-                goto err1;
+                return ret;
         }
 
         platform_set_drvdata(pdev, dev);
         return 0;
-
-err1:
-        input_unregister_device(input);
-        input = NULL;
-err:
-        input_free_device(input);
-        kfree(dev);
-        return ret;
 }
 
 static int adp5520_keys_remove(struct platform_device *pdev)
@@ -188,8 +178,6 @@ static int adp5520_keys_remove(struct platform_device *pdev)
         adp5520_unregister_notifier(dev->master, &dev->notifier,
                                 ADP5520_KP_IEN | ADP5520_KR_IEN);
 
-        input_unregister_device(dev->input);
-        kfree(dev);
         return 0;
 }
 
diff --git a/drivers/input/keyboard/clps711x-keypad.c b/drivers/input/keyboard/clps711x-keypad.c
index 3955aecee44b..552b65c6e6b0 100644
--- a/drivers/input/keyboard/clps711x-keypad.c
+++ b/drivers/input/keyboard/clps711x-keypad.c
@@ -185,7 +185,7 @@ static int clps711x_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-static struct of_device_id clps711x_keypad_of_match[] = {
+static const struct of_device_id clps711x_keypad_of_match[] = {
         { .compatible = "cirrus,clps711x-keypad", },
         { }
 };
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index 2db13246eb8e..8c98e97f8e41 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -424,6 +424,16 @@ out:
         return IRQ_HANDLED;
 }
 
+static void gpio_keys_quiesce_key(void *data)
+{
+        struct gpio_button_data *bdata = data;
+
+        if (bdata->timer_debounce)
+                del_timer_sync(&bdata->timer);
+
+        cancel_work_sync(&bdata->work);
+}
+
 static int gpio_keys_setup_key(struct platform_device *pdev,
                                 struct input_dev *input,
                                 struct gpio_button_data *bdata,
@@ -433,7 +443,8 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
         struct device *dev = &pdev->dev;
         irq_handler_t isr;
         unsigned long irqflags;
-        int irq, error;
+        int irq;
+        int error;
 
         bdata->input = input;
         bdata->button = button;
@@ -441,7 +452,8 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
 
         if (gpio_is_valid(button->gpio)) {
 
-                error = gpio_request_one(button->gpio, GPIOF_IN, desc);
+                error = devm_gpio_request_one(&pdev->dev, button->gpio,
+                                              GPIOF_IN, desc);
                 if (error < 0) {
                         dev_err(dev, "Failed to request GPIO %d, error %d\n",
                                 button->gpio, error);
@@ -463,7 +475,7 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
                         dev_err(dev,
                                 "Unable to get irq number for GPIO %d, error %d\n",
                                 button->gpio, error);
-                        goto fail;
+                        return error;
                 }
                 bdata->irq = irq;
 
@@ -497,26 +509,33 @@ static int gpio_keys_setup_key(struct platform_device *pdev,
         input_set_capability(input, button->type ?: EV_KEY, button->code);
 
         /*
+         * Install custom action to cancel debounce timer and
+         * workqueue item.
+         */
+        error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "failed to register quiesce action, error: %d\n",
+                        error);
+                return error;
+        }
+
+        /*
          * If platform has specified that the button can be disabled,
          * we don't want it to share the interrupt line.
          */
         if (!button->can_disable)
                 irqflags |= IRQF_SHARED;
 
-        error = request_any_context_irq(bdata->irq, isr, irqflags, desc, bdata);
+        error = devm_request_any_context_irq(&pdev->dev, bdata->irq,
+                                             isr, irqflags, desc, bdata);
         if (error < 0) {
                 dev_err(dev, "Unable to claim irq %d; error %d\n",
                         bdata->irq, error);
-                goto fail;
+                return error;
         }
 
         return 0;
-
-fail:
-        if (gpio_is_valid(button->gpio))
-                gpio_free(button->gpio);
-
-        return error;
 }
 
 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
@@ -578,23 +597,18 @@ gpio_keys_get_devtree_pdata(struct device *dev)
         int i;
 
         node = dev->of_node;
-        if (!node) {
-                error = -ENODEV;
-                goto err_out;
-        }
+        if (!node)
+                return ERR_PTR(-ENODEV);
 
         nbuttons = of_get_child_count(node);
-        if (nbuttons == 0) {
-                error = -ENODEV;
-                goto err_out;
-        }
+        if (nbuttons == 0)
+                return ERR_PTR(-ENODEV);
 
-        pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
-                        GFP_KERNEL);
-        if (!pdata) {
-                error = -ENOMEM;
-                goto err_out;
-        }
+        pdata = devm_kzalloc(dev,
+                             sizeof(*pdata) + nbuttons * sizeof(*button),
+                             GFP_KERNEL);
+        if (!pdata)
+                return ERR_PTR(-ENOMEM);
 
         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
         pdata->nbuttons = nbuttons;
@@ -619,7 +633,7 @@ gpio_keys_get_devtree_pdata(struct device *dev)
                                 dev_err(dev,
                                         "Failed to get gpio flags, error: %d\n",
                                         error);
-                        goto err_free_pdata;
+                        return ERR_PTR(error);
                 }
 
                 button = &pdata->buttons[i++];
@@ -630,8 +644,7 @@ gpio_keys_get_devtree_pdata(struct device *dev)
                 if (of_property_read_u32(pp, "linux,code", &button->code)) {
                         dev_err(dev, "Button without keycode: 0x%x\n",
                                 button->gpio);
-                        error = -EINVAL;
-                        goto err_free_pdata;
+                        return ERR_PTR(-EINVAL);
                 }
 
                 button->desc = of_get_property(pp, "label", NULL);
@@ -646,20 +659,13 @@ gpio_keys_get_devtree_pdata(struct device *dev)
                         button->debounce_interval = 5;
         }
 
-        if (pdata->nbuttons == 0) {
-                error = -EINVAL;
-                goto err_free_pdata;
-        }
+        if (pdata->nbuttons == 0)
+                return ERR_PTR(-EINVAL);
 
         return pdata;
-
-err_free_pdata:
-        kfree(pdata);
-err_out:
-        return ERR_PTR(error);
 }
 
-static struct of_device_id gpio_keys_of_match[] = {
+static const struct of_device_id gpio_keys_of_match[] = {
         { .compatible = "gpio-keys", },
         { },
 };
@@ -675,22 +681,13 @@ gpio_keys_get_devtree_pdata(struct device *dev)
 
 #endif
 
-static void gpio_remove_key(struct gpio_button_data *bdata)
-{
-        free_irq(bdata->irq, bdata);
-        if (bdata->timer_debounce)
-                del_timer_sync(&bdata->timer);
-        cancel_work_sync(&bdata->work);
-        if (gpio_is_valid(bdata->button->gpio))
-                gpio_free(bdata->button->gpio);
-}
-
 static int gpio_keys_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
         struct gpio_keys_drvdata *ddata;
         struct input_dev *input;
+        size_t size;
         int i, error;
         int wakeup = 0;
 
@@ -700,14 +697,18 @@ static int gpio_keys_probe(struct platform_device *pdev)
                         return PTR_ERR(pdata);
         }
 
-        ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
-                        pdata->nbuttons * sizeof(struct gpio_button_data),
-                        GFP_KERNEL);
-        input = input_allocate_device();
-        if (!ddata || !input) {
+        size = sizeof(struct gpio_keys_drvdata) +
+                        pdata->nbuttons * sizeof(struct gpio_button_data);
+        ddata = devm_kzalloc(dev, size, GFP_KERNEL);
+        if (!ddata) {
                 dev_err(dev, "failed to allocate state\n");
-                error = -ENOMEM;
-                goto fail1;
+                return -ENOMEM;
+        }
+
+        input = devm_input_allocate_device(dev);
+        if (!input) {
+                dev_err(dev, "failed to allocate input device\n");
+                return -ENOMEM;
         }
 
         ddata->pdata = pdata;
@@ -738,7 +739,7 @@ static int gpio_keys_probe(struct platform_device *pdev)
 
                 error = gpio_keys_setup_key(pdev, input, bdata, button);
                 if (error)
-                        goto fail2;
+                        return error;
 
                 if (button->wakeup)
                         wakeup = 1;
@@ -748,57 +749,31 @@ static int gpio_keys_probe(struct platform_device *pdev)
         if (error) {
                 dev_err(dev, "Unable to export keys/switches, error: %d\n",
                         error);
-                goto fail2;
+                return error;
         }
 
         error = input_register_device(input);
         if (error) {
                 dev_err(dev, "Unable to register input device, error: %d\n",
                         error);
-                goto fail3;
+                goto err_remove_group;
         }
 
         device_init_wakeup(&pdev->dev, wakeup);
 
         return 0;
 
- fail3:
+err_remove_group:
         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
- fail2:
-        while (--i >= 0)
-                gpio_remove_key(&ddata->data[i]);
-
- fail1:
-        input_free_device(input);
-        kfree(ddata);
-        /* If we have no platform data, we allocated pdata dynamically. */
-        if (!dev_get_platdata(&pdev->dev))
-                kfree(pdata);
-
         return error;
 }
 
 static int gpio_keys_remove(struct platform_device *pdev)
 {
-        struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
-        struct input_dev *input = ddata->input;
-        int i;
-
         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
 
         device_init_wakeup(&pdev->dev, 0);
 
-        for (i = 0; i < ddata->pdata->nbuttons; i++)
-                gpio_remove_key(&ddata->data[i]);
-
-        input_unregister_device(input);
-
-        /* If we have no platform data, we allocated pdata dynamically. */
-        if (!dev_get_platdata(&pdev->dev))
-                kfree(ddata->pdata);
-
-        kfree(ddata);
-
         return 0;
 }
 
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
index e571e194ff84..432d36395f35 100644
--- a/drivers/input/keyboard/gpio_keys_polled.c
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -120,12 +120,10 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
         if (nbuttons == 0)
                 return NULL;
 
-        pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
-                        GFP_KERNEL);
-        if (!pdata) {
-                error = -ENOMEM;
-                goto err_out;
-        }
+        pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
+                             GFP_KERNEL);
+        if (!pdata)
+                return ERR_PTR(-ENOMEM);
 
         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
         pdata->nbuttons = nbuttons;
@@ -151,7 +149,7 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                                 dev_err(dev,
                                         "Failed to get gpio flags, error: %d\n",
                                         error);
-                        goto err_free_pdata;
+                        return ERR_PTR(error);
                 }
 
                 button = &pdata->buttons[i++];
@@ -162,8 +160,7 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                 if (of_property_read_u32(pp, "linux,code", &button->code)) {
                         dev_err(dev, "Button without keycode: 0x%x\n",
                                 button->gpio);
-                        error = -EINVAL;
-                        goto err_free_pdata;
+                        return ERR_PTR(-EINVAL);
                 }
 
                 button->desc = of_get_property(pp, "label", NULL);
@@ -178,20 +175,13 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                         button->debounce_interval = 5;
         }
 
-        if (pdata->nbuttons == 0) {
-                error = -EINVAL;
-                goto err_free_pdata;
-        }
+        if (pdata->nbuttons == 0)
+                return ERR_PTR(-EINVAL);
 
         return pdata;
-
-err_free_pdata:
-        kfree(pdata);
-err_out:
-        return ERR_PTR(error);
 }
 
-static struct of_device_id gpio_keys_polled_of_match[] = {
+static const struct of_device_id gpio_keys_polled_of_match[] = {
         { .compatible = "gpio-keys-polled", },
         { },
 };
@@ -213,6 +203,7 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
         struct gpio_keys_polled_dev *bdev;
         struct input_polled_dev *poll_dev;
         struct input_dev *input;
+        size_t size;
         int error;
         int i;
 
@@ -228,24 +219,21 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
         if (!pdata->poll_interval) {
                 dev_err(dev, "missing poll_interval value\n");
-                error = -EINVAL;
-                goto err_free_pdata;
+                return -EINVAL;
         }
 
-        bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) +
-                       pdata->nbuttons * sizeof(struct gpio_keys_button_data),
-                       GFP_KERNEL);
+        size = sizeof(struct gpio_keys_polled_dev) +
+                        pdata->nbuttons * sizeof(struct gpio_keys_button_data);
+        bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
         if (!bdev) {
                 dev_err(dev, "no memory for private data\n");
-                error = -ENOMEM;
-                goto err_free_pdata;
+                return -ENOMEM;
         }
 
-        poll_dev = input_allocate_polled_device();
+        poll_dev = devm_input_allocate_polled_device(&pdev->dev);
         if (!poll_dev) {
                 dev_err(dev, "no memory for polled device\n");
-                error = -ENOMEM;
-                goto err_free_bdev;
+                return -ENOMEM;
         }
 
         poll_dev->private = bdev;
@@ -258,7 +246,6 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
         input->name = pdev->name;
         input->phys = DRV_NAME"/input0";
-        input->dev.parent = &pdev->dev;
 
         input->id.bustype = BUS_HOST;
         input->id.vendor = 0x0001;
@@ -277,16 +264,15 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
                 if (button->wakeup) {
                         dev_err(dev, DRV_NAME " does not support wakeup\n");
-                        error = -EINVAL;
-                        goto err_free_gpio;
+                        return -EINVAL;
                 }
 
-                error = gpio_request_one(gpio, GPIOF_IN,
-                                         button->desc ?: DRV_NAME);
+                error = devm_gpio_request_one(&pdev->dev, gpio, GPIOF_IN,
+                                              button->desc ? : DRV_NAME);
                 if (error) {
                         dev_err(dev, "unable to claim gpio %u, err=%d\n",
                                 gpio, error);
-                        goto err_free_gpio;
+                        return error;
                 }
 
                 bdata->can_sleep = gpio_cansleep(gpio);
@@ -306,7 +292,7 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
         if (error) {
                 dev_err(dev, "unable to register polled device, err=%d\n",
                         error);
-                goto err_free_gpio;
+                return error;
         }
 
         /* report initial state of the buttons */
@@ -315,52 +301,10 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
                                              &bdev->data[i]);
 
         return 0;
-
-err_free_gpio:
-        while (--i >= 0)
-                gpio_free(pdata->buttons[i].gpio);
-
-        input_free_polled_device(poll_dev);
-
-err_free_bdev:
-        kfree(bdev);
-
-err_free_pdata:
-        /* If we have no platform_data, we allocated pdata dynamically.  */
-        if (!dev_get_platdata(&pdev->dev))
-                kfree(pdata);
-
-        return error;
-}
-
-static int gpio_keys_polled_remove(struct platform_device *pdev)
-{
-        struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev);
-        const struct gpio_keys_platform_data *pdata = bdev->pdata;
-        int i;
-
-        input_unregister_polled_device(bdev->poll_dev);
-
-        for (i = 0; i < pdata->nbuttons; i++)
-                gpio_free(pdata->buttons[i].gpio);
-
-        input_free_polled_device(bdev->poll_dev);
-
-        /*
-         * If we had no platform_data, we allocated pdata dynamically and
-         * must free it here.
-         */
-        if (!dev_get_platdata(&pdev->dev))
-                kfree(pdata);
-
-        kfree(bdev);
-
-        return 0;
 }
 
 static struct platform_driver gpio_keys_polled_driver = {
         .probe  = gpio_keys_polled_probe,
-        .remove = gpio_keys_polled_remove,
         .driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
diff --git a/drivers/input/keyboard/imx_keypad.c b/drivers/input/keyboard/imx_keypad.c
index 97ec33572e56..8280cb16260b 100644
--- a/drivers/input/keyboard/imx_keypad.c
+++ b/drivers/input/keyboard/imx_keypad.c
@@ -415,7 +415,7 @@ open_err:
 }
 
 #ifdef CONFIG_OF
-static struct of_device_id imx_keypad_of_match[] = {
+static const struct of_device_id imx_keypad_of_match[] = {
         { .compatible = "fsl,imx21-kpp", },
         { /* sentinel */ }
 };
diff --git a/drivers/input/keyboard/jornada680_kbd.c b/drivers/input/keyboard/jornada680_kbd.c
index 69b1f002ff52..0ba4428da24a 100644
--- a/drivers/input/keyboard/jornada680_kbd.c
+++ b/drivers/input/keyboard/jornada680_kbd.c
@@ -16,6 +16,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/device.h>
 #include <linux/input.h>
 #include <linux/input-polldev.h>
 #include <linux/interrupt.h>
@@ -185,14 +186,15 @@ static int jornada680kbd_probe(struct platform_device *pdev)
         struct input_dev *input_dev;
         int i, error;
 
-        jornadakbd = kzalloc(sizeof(struct jornadakbd), GFP_KERNEL);
+        jornadakbd = devm_kzalloc(&pdev->dev, sizeof(struct jornadakbd),
+                                  GFP_KERNEL);
         if (!jornadakbd)
                 return -ENOMEM;
 
-        poll_dev = input_allocate_polled_device();
+        poll_dev = devm_input_allocate_polled_device(&pdev->dev);
         if (!poll_dev) {
-                error = -ENOMEM;
-                goto failed;
+                dev_err(&pdev->dev, "failed to allocate polled input device\n");
+                return -ENOMEM;
         }
 
         platform_set_drvdata(pdev, jornadakbd);
@@ -224,27 +226,10 @@ static int jornada680kbd_probe(struct platform_device *pdev)
         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
 
         error = input_register_polled_device(jornadakbd->poll_dev);
-        if (error)
-                goto failed;
-
-        return 0;
-
- failed:
-        printk(KERN_ERR "Jornadakbd: failed to register driver, error: %d\n",
-                error);
-        input_free_polled_device(poll_dev);
-        kfree(jornadakbd);
-        return error;
-
-}
-
-static int jornada680kbd_remove(struct platform_device *pdev)
-{
-        struct jornadakbd *jornadakbd = platform_get_drvdata(pdev);
-
-        input_unregister_polled_device(jornadakbd->poll_dev);
-        input_free_polled_device(jornadakbd->poll_dev);
-        kfree(jornadakbd);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register polled input device\n");
+                return error;
+        }
 
         return 0;
 }
@@ -255,7 +240,6 @@ static struct platform_driver jornada680kbd_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = jornada680kbd_probe,
-        .remove = jornada680kbd_remove,
 };
 module_platform_driver(jornada680kbd_driver);
 
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 1da8e0b44b56..375b05ca8e2a 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -147,7 +147,7 @@ static int mcs_touchkey_probe(struct i2c_client *client,
         }
         dev_info(&client->dev, "Firmware version: %d\n", fw_ver);
 
-        input_dev->name = "MELPAS MCS Touchkey";
+        input_dev->name = "MELFAS MCS Touchkey";
         input_dev->id.bustype = BUS_I2C;
         input_dev->dev.parent = &client->dev;
         input_dev->evbit[0] = BIT_MASK(EV_KEY);
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c
index 0400b3f2b4b9..024b7bdffe5b 100644
--- a/drivers/input/keyboard/omap4-keypad.c
+++ b/drivers/input/keyboard/omap4-keypad.c
@@ -28,11 +28,10 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
 
-#include <linux/platform_data/omap4-keypad.h>
-
 /* OMAP4 registers */
 #define OMAP4_KBD_REVISION              0x00
 #define OMAP4_KBD_SYSCONFIG             0x10
@@ -218,7 +217,6 @@ static void omap4_keypad_close(struct input_dev *input)
         pm_runtime_put_sync(input->dev.parent);
 }
 
-#ifdef CONFIG_OF
 static int omap4_keypad_parse_dt(struct device *dev,
                                  struct omap4_keypad *keypad_data)
 {
@@ -235,20 +233,9 @@ static int omap4_keypad_parse_dt(struct device *dev,
 
         return 0;
 }
-#else
-static inline int omap4_keypad_parse_dt(struct device *dev,
-                                        struct omap4_keypad *keypad_data)
-{
-        return -ENOSYS;
-}
-#endif
 
 static int omap4_keypad_probe(struct platform_device *pdev)
 {
-        const struct omap4_keypad_platform_data *pdata =
-                                dev_get_platdata(&pdev->dev);
-        const struct matrix_keymap_data *keymap_data =
-                                pdata ? pdata->keymap_data : NULL;
         struct omap4_keypad *keypad_data;
         struct input_dev *input_dev;
         struct resource *res;
@@ -277,14 +264,9 @@ static int omap4_keypad_probe(struct platform_device *pdev)
 
         keypad_data->irq = irq;
 
-        if (pdata) {
-                keypad_data->rows = pdata->rows;
-                keypad_data->cols = pdata->cols;
-        } else {
-                error = omap4_keypad_parse_dt(&pdev->dev, keypad_data);
-                if (error)
-                        return error;
-        }
+        error = omap4_keypad_parse_dt(&pdev->dev, keypad_data);
+        if (error)
+                return error;
 
         res = request_mem_region(res->start, resource_size(res), pdev->name);
         if (!res) {
@@ -363,7 +345,7 @@ static int omap4_keypad_probe(struct platform_device *pdev)
                 goto err_free_input;
         }
 
-        error = matrix_keypad_build_keymap(keymap_data, NULL,
+        error = matrix_keypad_build_keymap(NULL, NULL,
                                            keypad_data->rows, keypad_data->cols,
                                            keypad_data->keymap, input_dev);
         if (error) {
@@ -434,13 +416,11 @@ static int omap4_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_OF
 static const struct of_device_id omap_keypad_dt_match[] = {
         { .compatible = "ti,omap4-keypad" },
         {},
 };
 MODULE_DEVICE_TABLE(of, omap_keypad_dt_match);
-#endif
 
 #ifdef CONFIG_PM_SLEEP
 static int omap4_keypad_suspend(struct device *dev)
@@ -482,7 +462,7 @@ static struct platform_driver omap4_keypad_driver = {
                 .name   = "omap4-keypad",
                 .owner  = THIS_MODULE,
                 .pm     = &omap4_keypad_pm_ops,
-                .of_match_table = of_match_ptr(omap_keypad_dt_match),
+                .of_match_table = omap_keypad_dt_match,
         },
 };
 module_platform_driver(omap4_keypad_driver);
diff --git a/drivers/input/keyboard/st-keyscan.c b/drivers/input/keyboard/st-keyscan.c
new file mode 100644
index 000000000000..758b48731415
--- /dev/null
+++ b/drivers/input/keyboard/st-keyscan.c
@@ -0,0 +1,274 @@
+/*
+ * STMicroelectronics Key Scanning driver
+ *
+ * Copyright (c) 2014 STMicroelectonics Ltd.
+ * Author: Stuart Menefy <stuart.menefy@st.com>
+ *
+ * Based on sh_keysc.c, copyright 2008 Magnus Damm
+ *
+ * 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/module.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/input/matrix_keypad.h>
+
+#define ST_KEYSCAN_MAXKEYS 16
+
+#define KEYSCAN_CONFIG_OFF              0x0
+#define KEYSCAN_CONFIG_ENABLE           0x1
+#define KEYSCAN_DEBOUNCE_TIME_OFF       0x4
+#define KEYSCAN_MATRIX_STATE_OFF        0x8
+#define KEYSCAN_MATRIX_DIM_OFF          0xc
+#define KEYSCAN_MATRIX_DIM_X_SHIFT      0x0
+#define KEYSCAN_MATRIX_DIM_Y_SHIFT      0x2
+
+struct st_keyscan {
+        void __iomem *base;
+        int irq;
+        struct clk *clk;
+        struct input_dev *input_dev;
+        unsigned long last_state;
+        unsigned int n_rows;
+        unsigned int n_cols;
+        unsigned int debounce_us;
+};
+
+static irqreturn_t keyscan_isr(int irq, void *dev_id)
+{
+        struct st_keyscan *keypad = dev_id;
+        unsigned short *keycode = keypad->input_dev->keycode;
+        unsigned long state, change;
+        int bit_nr;
+
+        state = readl(keypad->base + KEYSCAN_MATRIX_STATE_OFF) & 0xffff;
+        change = keypad->last_state ^ state;
+        keypad->last_state = state;
+
+        for_each_set_bit(bit_nr, &change, BITS_PER_LONG)
+                input_report_key(keypad->input_dev,
+                                 keycode[bit_nr], state & BIT(bit_nr));
+
+        input_sync(keypad->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static int keyscan_start(struct st_keyscan *keypad)
+{
+        int error;
+
+        error = clk_enable(keypad->clk);
+        if (error)
+                return error;
+
+        writel(keypad->debounce_us * (clk_get_rate(keypad->clk) / 1000000),
+               keypad->base + KEYSCAN_DEBOUNCE_TIME_OFF);
+
+        writel(((keypad->n_cols - 1) << KEYSCAN_MATRIX_DIM_X_SHIFT) |
+               ((keypad->n_rows - 1) << KEYSCAN_MATRIX_DIM_Y_SHIFT),
+               keypad->base + KEYSCAN_MATRIX_DIM_OFF);
+
+        writel(KEYSCAN_CONFIG_ENABLE, keypad->base + KEYSCAN_CONFIG_OFF);
+
+        return 0;
+}
+
+static void keyscan_stop(struct st_keyscan *keypad)
+{
+        writel(0, keypad->base + KEYSCAN_CONFIG_OFF);
+
+        clk_disable(keypad->clk);
+}
+
+static int keyscan_open(struct input_dev *dev)
+{
+        struct st_keyscan *keypad = input_get_drvdata(dev);
+
+        return keyscan_start(keypad);
+}
+
+static void keyscan_close(struct input_dev *dev)
+{
+        struct st_keyscan *keypad = input_get_drvdata(dev);
+
+        keyscan_stop(keypad);
+}
+
+static int keypad_matrix_key_parse_dt(struct st_keyscan *keypad_data)
+{
+        struct device *dev = keypad_data->input_dev->dev.parent;
+        struct device_node *np = dev->of_node;
+        int error;
+
+        error = matrix_keypad_parse_of_params(dev, &keypad_data->n_rows,
+                                              &keypad_data->n_cols);
+        if (error) {
+                dev_err(dev, "failed to parse keypad params\n");
+                return error;
+        }
+
+        of_property_read_u32(np, "st,debounce-us", &keypad_data->debounce_us);
+
+        dev_dbg(dev, "n_rows=%d n_col=%d debounce=%d\n",
+                keypad_data->n_rows, keypad_data->n_cols,
+                keypad_data->debounce_us);
+
+        return 0;
+}
+
+static int keyscan_probe(struct platform_device *pdev)
+{
+        struct st_keyscan *keypad_data;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int error;
+
+        if (!pdev->dev.of_node) {
+                dev_err(&pdev->dev, "no DT data present\n");
+                return -EINVAL;
+        }
+
+        keypad_data = devm_kzalloc(&pdev->dev, sizeof(*keypad_data),
+                                   GFP_KERNEL);
+        if (!keypad_data)
+                return -ENOMEM;
+
+        input_dev = devm_input_allocate_device(&pdev->dev);
+        if (!input_dev) {
+                dev_err(&pdev->dev, "failed to allocate the input device\n");
+                return -ENOMEM;
+        }
+
+        input_dev->name = pdev->name;
+        input_dev->phys = "keyscan-keys/input0";
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->open = keyscan_open;
+        input_dev->close = keyscan_close;
+
+        input_dev->id.bustype = BUS_HOST;
+
+        error = keypad_matrix_key_parse_dt(keypad_data);
+        if (error)
+                return error;
+
+        error = matrix_keypad_build_keymap(NULL, NULL,
+                                           keypad_data->n_rows,
+                                           keypad_data->n_cols,
+                                           NULL, input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to build keymap\n");
+                return error;
+        }
+
+        input_set_drvdata(input_dev, keypad_data);
+
+        keypad_data->input_dev = input_dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        keypad_data->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(keypad_data->base))
+                return PTR_ERR(keypad_data->base);
+
+        keypad_data->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(keypad_data->clk)) {
+                dev_err(&pdev->dev, "cannot get clock\n");
+                return PTR_ERR(keypad_data->clk);
+        }
+
+        error = clk_enable(keypad_data->clk);
+        if (error) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                return error;
+        }
+
+        keyscan_stop(keypad_data);
+
+        keypad_data->irq = platform_get_irq(pdev, 0);
+        if (keypad_data->irq < 0) {
+                dev_err(&pdev->dev, "no IRQ specified\n");
+                return -EINVAL;
+        }
+
+        error = devm_request_irq(&pdev->dev, keypad_data->irq, keyscan_isr, 0,
+                                 pdev->name, keypad_data);
+        if (error) {
+                dev_err(&pdev->dev, "failed to request IRQ\n");
+                return error;
+        }
+
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                return error;
+        }
+
+        platform_set_drvdata(pdev, keypad_data);
+
+        device_set_wakeup_capable(&pdev->dev, 1);
+
+        return 0;
+}
+
+static int keyscan_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct st_keyscan *keypad = platform_get_drvdata(pdev);
+        struct input_dev *input = keypad->input_dev;
+
+        mutex_lock(&input->mutex);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(keypad->irq);
+        else if (input->users)
+                keyscan_stop(keypad);
+
+        mutex_unlock(&input->mutex);
+        return 0;
+}
+
+static int keyscan_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct st_keyscan *keypad = platform_get_drvdata(pdev);
+        struct input_dev *input = keypad->input_dev;
+        int retval = 0;
+
+        mutex_lock(&input->mutex);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(keypad->irq);
+        else if (input->users)
+                retval = keyscan_start(keypad);
+
+        mutex_unlock(&input->mutex);
+        return retval;
+}
+
+static SIMPLE_DEV_PM_OPS(keyscan_dev_pm_ops, keyscan_suspend, keyscan_resume);
+
+static const struct of_device_id keyscan_of_match[] = {
+        { .compatible = "st,sti-keyscan" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, keyscan_of_match);
+
+static struct platform_driver keyscan_device_driver = {
+        .probe          = keyscan_probe,
+        .driver         = {
+                .name   = "st-keyscan",
+                .pm     = &keyscan_dev_pm_ops,
+                .of_match_table = of_match_ptr(keyscan_of_match),
+        }
+};
+
+module_platform_driver(keyscan_device_driver);
+
+MODULE_AUTHOR("Stuart Menefy <stuart.menefy@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics keyscan device driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c
index 74494a357522..ad7abae69078 100644
--- a/drivers/input/keyboard/tc3589x-keypad.c
+++ b/drivers/input/keyboard/tc3589x-keypad.c
@@ -296,6 +296,65 @@ static void tc3589x_keypad_close(struct input_dev *input)
         tc3589x_keypad_disable(keypad);
 }
 
+#ifdef CONFIG_OF
+static const struct tc3589x_keypad_platform_data *
+tc3589x_keypad_of_probe(struct device *dev)
+{
+        struct device_node *np = dev->of_node;
+        struct tc3589x_keypad_platform_data *plat;
+        u32 cols, rows;
+        u32 debounce_ms;
+        int proplen;
+
+        if (!np)
+                return ERR_PTR(-ENODEV);
+
+        plat = devm_kzalloc(dev, sizeof(*plat), GFP_KERNEL);
+        if (!plat)
+                return ERR_PTR(-ENOMEM);
+
+        of_property_read_u32(np, "keypad,num-columns", &cols);
+        of_property_read_u32(np, "keypad,num-rows", &rows);
+        plat->kcol = (u8) cols;
+        plat->krow = (u8) rows;
+        if (!plat->krow || !plat->kcol ||
+             plat->krow > TC_KPD_ROWS || plat->kcol > TC_KPD_COLUMNS) {
+                dev_err(dev,
+                        "keypad columns/rows not properly specified (%ux%u)\n",
+                        plat->kcol, plat->krow);
+                return ERR_PTR(-EINVAL);
+        }
+
+        if (!of_get_property(np, "linux,keymap", &proplen)) {
+                dev_err(dev, "property linux,keymap not found\n");
+                return ERR_PTR(-ENOENT);
+        }
+
+        plat->no_autorepeat = of_property_read_bool(np, "linux,no-autorepeat");
+        plat->enable_wakeup = of_property_read_bool(np, "linux,wakeup");
+
+        /* The custom delay format is ms/16 */
+        of_property_read_u32(np, "debounce-delay-ms", &debounce_ms);
+        if (debounce_ms)
+                plat->debounce_period = debounce_ms * 16;
+        else
+                plat->debounce_period = TC_KPD_DEBOUNCE_PERIOD;
+
+        plat->settle_time = TC_KPD_SETTLE_TIME;
+        /* FIXME: should be property of the IRQ resource? */
+        plat->irqtype = IRQF_TRIGGER_FALLING;
+
+        return plat;
+}
+#else
+static inline const struct tc3589x_keypad_platform_data *
+tc3589x_keypad_of_probe(struct device *dev)
+{
+        return ERR_PTR(-ENODEV);
+}
+#endif
+
+
 static int tc3589x_keypad_probe(struct platform_device *pdev)
 {
         struct tc3589x *tc3589x = dev_get_drvdata(pdev->dev.parent);
@@ -306,8 +365,11 @@ static int tc3589x_keypad_probe(struct platform_device *pdev)
 
         plat = tc3589x->pdata->keypad;
         if (!plat) {
-                dev_err(&pdev->dev, "invalid keypad platform data\n");
-                return -EINVAL;
+                plat = tc3589x_keypad_of_probe(&pdev->dev);
+                if (IS_ERR(plat)) {
+                        dev_err(&pdev->dev, "invalid keypad platform data\n");
+                        return PTR_ERR(plat);
+                }
         }
 
         irq = platform_get_irq(pdev, 0);