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: tc3589x-keypad - add missing kerneldoc
  Input: ucb1400-ts - switch to using dev_xxx() for diagnostic messages
  Input: ucb1400_ts - convert to threaded IRQ
  Input: ucb1400_ts - drop inline annotations
  Input: usb1400_ts - add __devinit/__devexit section annotations
  Input: ucb1400_ts - set driver owner
  Input: ucb1400_ts - convert to use dev_pm_ops
  Input: psmouse - make sure we do not use stale methods
  Input: evdev - do not block waiting for an event if fd is nonblock
  Input: evdev - if no events and non-block, return EAGAIN not 0
  Input: evdev - only allow reading events if a full packet is present
  Input: add driver for pixcir i2c touchscreens
  Input: samsung-keypad - implement runtime power management support
  Input: tegra-kbc - report wakeup key for some platforms
  Input: tegra-kbc - add device tree bindings
  Input: add driver for AUO In-Cell touchscreens using pixcir ICs
  Input: mpu3050 - configure the sampling method
  Input: mpu3050 - ensure we enable interrupts
  Input: mpu3050 - add of_match table for device-tree probing
  Input: sentelic - document the latest hardware
  ...

Fix up fairly trivial conflicts (device tree matching conflicting with
some independent cleanups) in drivers/input/keyboard/samsung-keypad.c

1 files changed, 82 insertions, 26 deletions

diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
index 8a0060cd3982..17ba7f9f80f3 100644
--- a/drivers/input/keyboard/samsung-keypad.c
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -20,11 +20,13 @@
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/sched.h>
-#include <plat/keypad.h>
+#include <linux/input/samsung-keypad.h>
 
 #define SAMSUNG_KEYIFCON                        0x00
 #define SAMSUNG_KEYIFSTSCLR                     0x04
@@ -65,10 +67,12 @@ enum samsung_keypad_type {
 
 struct samsung_keypad {
         struct input_dev *input_dev;
+        struct platform_device *pdev;
         struct clk *clk;
         void __iomem *base;
         wait_queue_head_t wait;
         bool stopped;
+        bool wake_enabled;
         int irq;
         enum samsung_keypad_type type;
         unsigned int row_shift;
@@ -155,6 +159,8 @@ static irqreturn_t samsung_keypad_irq(int irq, void *dev_id)
         unsigned int val;
         bool key_down;
 
+        pm_runtime_get_sync(&keypad->pdev->dev);
+
         do {
                 val = readl(keypad->base + SAMSUNG_KEYIFSTSCLR);
                 /* Clear interrupt. */
@@ -169,6 +175,8 @@ static irqreturn_t samsung_keypad_irq(int irq, void *dev_id)
 
         } while (key_down && !keypad->stopped);
 
+        pm_runtime_put_sync(&keypad->pdev->dev);
+
         return IRQ_HANDLED;
 }
 
@@ -176,6 +184,8 @@ static void samsung_keypad_start(struct samsung_keypad *keypad)
 {
         unsigned int val;
 
+        pm_runtime_get_sync(&keypad->pdev->dev);
+
         /* Tell IRQ thread that it may poll the device. */
         keypad->stopped = false;
 
@@ -188,12 +198,16 @@ static void samsung_keypad_start(struct samsung_keypad *keypad)
 
         /* KEYIFCOL reg clear. */
         writel(0, keypad->base + SAMSUNG_KEYIFCOL);
+
+        pm_runtime_put_sync(&keypad->pdev->dev);
 }
 
 static void samsung_keypad_stop(struct samsung_keypad *keypad)
 {
         unsigned int val;
 
+        pm_runtime_get_sync(&keypad->pdev->dev);
+
         /* Signal IRQ thread to stop polling and disable the handler. */
         keypad->stopped = true;
         wake_up(&keypad->wait);
@@ -214,6 +228,8 @@ static void samsung_keypad_stop(struct samsung_keypad *keypad)
          * re-enable the handler.
          */
         enable_irq(keypad->irq);
+
+        pm_runtime_put_sync(&keypad->pdev->dev);
 }
 
 static int samsung_keypad_open(struct input_dev *input_dev)
@@ -418,9 +434,11 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
         }
 
         keypad->input_dev = input_dev;
+        keypad->pdev = pdev;
         keypad->row_shift = row_shift;
         keypad->rows = pdata->rows;
         keypad->cols = pdata->cols;
+        keypad->stopped = true;
         init_waitqueue_head(&keypad->wait);
 
         if (pdev->dev.of_node) {
@@ -467,13 +485,14 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
                 goto err_put_clk;
         }
 
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+        platform_set_drvdata(pdev, keypad);
+        pm_runtime_enable(&pdev->dev);
+
         error = input_register_device(keypad->input_dev);
         if (error)
                 goto err_free_irq;
 
-        device_init_wakeup(&pdev->dev, pdata->wakeup);
-        platform_set_drvdata(pdev, keypad);
-
         if (pdev->dev.of_node) {
                 devm_kfree(&pdev->dev, (void *)pdata->keymap_data->keymap);
                 devm_kfree(&pdev->dev, (void *)pdata->keymap_data);
@@ -483,6 +502,9 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
 
 err_free_irq:
         free_irq(keypad->irq, keypad);
+        pm_runtime_disable(&pdev->dev);
+        device_init_wakeup(&pdev->dev, 0);
+        platform_set_drvdata(pdev, NULL);
 err_put_clk:
         clk_put(keypad->clk);
         samsung_keypad_dt_gpio_free(keypad);
@@ -499,6 +521,7 @@ static int __devexit samsung_keypad_remove(struct platform_device *pdev)
 {
         struct samsung_keypad *keypad = platform_get_drvdata(pdev);
 
+        pm_runtime_disable(&pdev->dev);
         device_init_wakeup(&pdev->dev, 0);
         platform_set_drvdata(pdev, NULL);
 
@@ -519,11 +542,57 @@ static int __devexit samsung_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_RUNTIME
+static int samsung_keypad_runtime_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct samsung_keypad *keypad = platform_get_drvdata(pdev);
+        unsigned int val;
+        int error;
+
+        if (keypad->stopped)
+                return 0;
+
+        /* This may fail on some SoCs due to lack of controller support */
+        error = enable_irq_wake(keypad->irq);
+        if (!error)
+                keypad->wake_enabled = true;
+
+        val = readl(keypad->base + SAMSUNG_KEYIFCON);
+        val |= SAMSUNG_KEYIFCON_WAKEUPEN;
+        writel(val, keypad->base + SAMSUNG_KEYIFCON);
+
+        clk_disable(keypad->clk);
+
+        return 0;
+}
+
+static int samsung_keypad_runtime_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct samsung_keypad *keypad = platform_get_drvdata(pdev);
+        unsigned int val;
+
+        if (keypad->stopped)
+                return 0;
+
+        clk_enable(keypad->clk);
+
+        val = readl(keypad->base + SAMSUNG_KEYIFCON);
+        val &= ~SAMSUNG_KEYIFCON_WAKEUPEN;
+        writel(val, keypad->base + SAMSUNG_KEYIFCON);
+
+        if (keypad->wake_enabled)
+                disable_irq_wake(keypad->irq);
+
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
 static void samsung_keypad_toggle_wakeup(struct samsung_keypad *keypad,
                                          bool enable)
 {
-        struct device *dev = keypad->input_dev->dev.parent;
         unsigned int val;
 
         clk_enable(keypad->clk);
@@ -531,11 +600,11 @@ static void samsung_keypad_toggle_wakeup(struct samsung_keypad *keypad,
         val = readl(keypad->base + SAMSUNG_KEYIFCON);
         if (enable) {
                 val |= SAMSUNG_KEYIFCON_WAKEUPEN;
-                if (device_may_wakeup(dev))
+                if (device_may_wakeup(&keypad->pdev->dev))
                         enable_irq_wake(keypad->irq);
         } else {
                 val &= ~SAMSUNG_KEYIFCON_WAKEUPEN;
-                if (device_may_wakeup(dev))
+                if (device_may_wakeup(&keypad->pdev->dev))
                         disable_irq_wake(keypad->irq);
         }
         writel(val, keypad->base + SAMSUNG_KEYIFCON);
@@ -578,12 +647,13 @@ static int samsung_keypad_resume(struct device *dev)
 
         return 0;
 }
+#endif
 
 static const struct dev_pm_ops samsung_keypad_pm_ops = {
-        .suspend        = samsung_keypad_suspend,
-        .resume         = samsung_keypad_resume,
+        SET_SYSTEM_SLEEP_PM_OPS(samsung_keypad_suspend, samsung_keypad_resume)
+        SET_RUNTIME_PM_OPS(samsung_keypad_runtime_suspend,
+                           samsung_keypad_runtime_resume, NULL)
 };
-#endif
 
 #ifdef CONFIG_OF
 static const struct of_device_id samsung_keypad_dt_match[] = {
@@ -615,27 +685,13 @@ static struct platform_driver samsung_keypad_driver = {
                 .name   = "samsung-keypad",
                 .owner  = THIS_MODULE,
                 .of_match_table = samsung_keypad_dt_match,
-#ifdef CONFIG_PM
                 .pm     = &samsung_keypad_pm_ops,
-#endif
         },
         .id_table       = samsung_keypad_driver_ids,
 };
-
-static int __init samsung_keypad_init(void)
-{
-        return platform_driver_register(&samsung_keypad_driver);
-}
-module_init(samsung_keypad_init);
-
-static void __exit samsung_keypad_exit(void)
-{
-        platform_driver_unregister(&samsung_keypad_driver);
-}
-module_exit(samsung_keypad_exit);
+module_platform_driver(samsung_keypad_driver);
 
 MODULE_DESCRIPTION("Samsung keypad driver");
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 MODULE_AUTHOR("Donghwa Lee <dh09.lee@samsung.com>");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:samsung-keypad");