Merge branch 'next' into for-linus

14 files changed, 248 insertions, 137 deletions

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index cdc385b2cf7d..f354813a13e8 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -394,6 +394,7 @@ config KEYBOARD_NOMADIK
 config KEYBOARD_TEGRA
         tristate "NVIDIA Tegra internal matrix keyboard controller support"
         depends on ARCH_TEGRA
+        select INPUT_OF_MATRIX_KEYMAP if USE_OF
         help
           Say Y here if you want to use a matrix keyboard connected directly
           to the internal keyboard controller on Tegra SoCs.
@@ -512,7 +513,6 @@ config KEYBOARD_OMAP
 
 config KEYBOARD_OMAP4
         tristate "TI OMAP4 keypad support"
-        depends on ARCH_OMAP4
         help
           Say Y here if you want to use the OMAP4 keypad.
 
diff --git a/drivers/input/keyboard/adp5588-keys.c b/drivers/input/keyboard/adp5588-keys.c
index 4a7f534cf64b..39ebffac207e 100644
--- a/drivers/input/keyboard/adp5588-keys.c
+++ b/drivers/input/keyboard/adp5588-keys.c
@@ -653,17 +653,7 @@ static struct i2c_driver adp5588_driver = {
         .id_table = adp5588_id,
 };
 
-static int __init adp5588_init(void)
-{
-        return i2c_add_driver(&adp5588_driver);
-}
-module_init(adp5588_init);
-
-static void __exit adp5588_exit(void)
-{
-        i2c_del_driver(&adp5588_driver);
-}
-module_exit(adp5588_exit);
+module_i2c_driver(adp5588_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
diff --git a/drivers/input/keyboard/adp5589-keys.c b/drivers/input/keyboard/adp5589-keys.c
index 02b5d53031bf..74e603213386 100644
--- a/drivers/input/keyboard/adp5589-keys.c
+++ b/drivers/input/keyboard/adp5589-keys.c
@@ -1108,17 +1108,7 @@ static struct i2c_driver adp5589_driver = {
         .id_table = adp5589_id,
 };
 
-static int __init adp5589_init(void)
-{
-        return i2c_add_driver(&adp5589_driver);
-}
-module_init(adp5589_init);
-
-static void __exit adp5589_exit(void)
-{
-        i2c_del_driver(&adp5589_driver);
-}
-module_exit(adp5589_exit);
+module_i2c_driver(adp5589_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index 21823bfc7911..39ac2787e275 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -851,17 +851,7 @@ static struct i2c_driver lm8323_i2c_driver = {
 };
 MODULE_DEVICE_TABLE(i2c, lm8323_id);
 
-static int __init lm8323_init(void)
-{
-        return i2c_add_driver(&lm8323_i2c_driver);
-}
-module_init(lm8323_init);
-
-static void __exit lm8323_exit(void)
-{
-        i2c_del_driver(&lm8323_i2c_driver);
-}
-module_exit(lm8323_exit);
+module_i2c_driver(lm8323_i2c_driver);
 
 MODULE_AUTHOR("Timo O. Karjalainen <timo.o.karjalainen@nokia.com>");
 MODULE_AUTHOR("Daniel Stone");
diff --git a/drivers/input/keyboard/max7359_keypad.c b/drivers/input/keyboard/max7359_keypad.c
index 5afe35ad24d3..8edada8ae712 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -316,17 +316,7 @@ static struct i2c_driver max7359_i2c_driver = {
         .id_table       = max7359_ids,
 };
 
-static int __init max7359_init(void)
-{
-        return i2c_add_driver(&max7359_i2c_driver);
-}
-module_init(max7359_init);
-
-static void __exit max7359_exit(void)
-{
-        i2c_del_driver(&max7359_i2c_driver);
-}
-module_exit(max7359_exit);
+module_i2c_driver(max7359_i2c_driver);
 
 MODULE_AUTHOR("Kim Kyuwon <q1.kim@samsung.com>");
 MODULE_DESCRIPTION("MAX7359 Key Switch Controller Driver");
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index af1aab324a4c..64a0ca4c92f3 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -274,18 +274,7 @@ static struct i2c_driver mcs_touchkey_driver = {
         .id_table       = mcs_touchkey_id,
 };
 
-static int __init mcs_touchkey_init(void)
-{
-        return i2c_add_driver(&mcs_touchkey_driver);
-}
-
-static void __exit mcs_touchkey_exit(void)
-{
-        i2c_del_driver(&mcs_touchkey_driver);
-}
-
-module_init(mcs_touchkey_init);
-module_exit(mcs_touchkey_exit);
+module_i2c_driver(mcs_touchkey_driver);
 
 /* Module information */
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
diff --git a/drivers/input/keyboard/mpr121_touchkey.c b/drivers/input/keyboard/mpr121_touchkey.c
index 1c1615d9a7f9..caa218a51b5a 100644
--- a/drivers/input/keyboard/mpr121_touchkey.c
+++ b/drivers/input/keyboard/mpr121_touchkey.c
@@ -330,17 +330,7 @@ static struct i2c_driver mpr_touchkey_driver = {
         .remove         = __devexit_p(mpr_touchkey_remove),
 };
 
-static int __init mpr_touchkey_init(void)
-{
-        return i2c_add_driver(&mpr_touchkey_driver);
-}
-module_init(mpr_touchkey_init);
-
-static void __exit mpr_touchkey_exit(void)
-{
-        i2c_del_driver(&mpr_touchkey_driver);
-}
-module_exit(mpr_touchkey_exit);
+module_i2c_driver(mpr_touchkey_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
diff --git a/drivers/input/keyboard/nomadik-ske-keypad.c b/drivers/input/keyboard/nomadik-ske-keypad.c
index e35566aa102f..101e245944e7 100644
--- a/drivers/input/keyboard/nomadik-ske-keypad.c
+++ b/drivers/input/keyboard/nomadik-ske-keypad.c
@@ -88,7 +88,7 @@ static void ske_keypad_set_bits(struct ske_keypad *keypad, u16 addr,
  *
  * Enable Multi key press detection, auto scan mode
  */
-static int __devinit ske_keypad_chip_init(struct ske_keypad *keypad)
+static int __init ske_keypad_chip_init(struct ske_keypad *keypad)
 {
         u32 value;
         int timeout = 50;
@@ -198,7 +198,7 @@ static irqreturn_t ske_keypad_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int __devinit ske_keypad_probe(struct platform_device *pdev)
+static int __init ske_keypad_probe(struct platform_device *pdev)
 {
         const struct ske_keypad_platform_data *plat = pdev->dev.platform_data;
         struct ske_keypad *keypad;
@@ -344,7 +344,7 @@ static int __devexit ske_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ske_keypad_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -372,22 +372,17 @@ static int ske_keypad_resume(struct device *dev)
 
         return 0;
 }
-
-static const struct dev_pm_ops ske_keypad_dev_pm_ops = {
-        .suspend = ske_keypad_suspend,
-        .resume = ske_keypad_resume,
-};
 #endif
 
+static SIMPLE_DEV_PM_OPS(ske_keypad_dev_pm_ops,
+                         ske_keypad_suspend, ske_keypad_resume);
+
 static struct platform_driver ske_keypad_driver = {
         .driver = {
                 .name = "nmk-ske-keypad",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
                 .pm = &ske_keypad_dev_pm_ops,
-#endif
         },
-        .probe = ske_keypad_probe,
         .remove = __devexit_p(ske_keypad_remove),
 };
 
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c
index d5c5d77f4b82..e809ac095a38 100644
--- a/drivers/input/keyboard/omap4-keypad.c
+++ b/drivers/input/keyboard/omap4-keypad.c
@@ -31,7 +31,7 @@
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
 
-#include <plat/omap4-keypad.h>
+#include <linux/platform_data/omap4-keypad.h>
 
 /* OMAP4 registers */
 #define OMAP4_KBD_REVISION              0x00
diff --git a/drivers/input/keyboard/qt1070.c b/drivers/input/keyboard/qt1070.c
index b21bf5b876bb..0b7b2f891752 100644
--- a/drivers/input/keyboard/qt1070.c
+++ b/drivers/input/keyboard/qt1070.c
@@ -258,17 +258,7 @@ static struct i2c_driver qt1070_driver = {
         .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_i2c_driver(qt1070_driver);
 
 MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
 MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
diff --git a/drivers/input/keyboard/qt2160.c b/drivers/input/keyboard/qt2160.c
index fac695157e8a..e7a5e36e1203 100644
--- a/drivers/input/keyboard/qt2160.c
+++ b/drivers/input/keyboard/qt2160.c
@@ -379,17 +379,7 @@ static struct i2c_driver qt2160_driver = {
         .remove         = __devexit_p(qt2160_remove),
 };
 
-static int __init qt2160_init(void)
-{
-        return i2c_add_driver(&qt2160_driver);
-}
-module_init(qt2160_init);
-
-static void __exit qt2160_cleanup(void)
-{
-        i2c_del_driver(&qt2160_driver);
-}
-module_exit(qt2160_cleanup);
+module_i2c_driver(qt2160_driver);
 
 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
index b746fce2d120..2391ae884fee 100644
--- a/drivers/input/keyboard/samsung-keypad.c
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -23,6 +23,8 @@
 #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 <linux/input/samsung-keypad.h>
 
@@ -72,31 +74,26 @@ struct samsung_keypad {
         bool stopped;
         bool wake_enabled;
         int irq;
+        enum samsung_keypad_type type;
         unsigned int row_shift;
         unsigned int rows;
         unsigned int cols;
         unsigned int row_state[SAMSUNG_MAX_COLS];
+#ifdef CONFIG_OF
+        int row_gpios[SAMSUNG_MAX_ROWS];
+        int col_gpios[SAMSUNG_MAX_COLS];
+#endif
         unsigned short keycodes[];
 };
 
-static int samsung_keypad_is_s5pv210(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        enum samsung_keypad_type type =
-                platform_get_device_id(pdev)->driver_data;
-
-        return type == KEYPAD_TYPE_S5PV210;
-}
-
 static void samsung_keypad_scan(struct samsung_keypad *keypad,
                                 unsigned int *row_state)
 {
-        struct device *dev = keypad->input_dev->dev.parent;
         unsigned int col;
         unsigned int val;
 
         for (col = 0; col < keypad->cols; col++) {
-                if (samsung_keypad_is_s5pv210(dev)) {
+                if (keypad->type == KEYPAD_TYPE_S5PV210) {
                         val = S5PV210_KEYIFCOLEN_MASK;
                         val &= ~(1 << col) << 8;
                 } else {
@@ -178,7 +175,7 @@ static irqreturn_t samsung_keypad_irq(int irq, void *dev_id)
 
         } while (key_down && !keypad->stopped);
 
-        pm_runtime_put_sync(&keypad->pdev->dev);
+        pm_runtime_put(&keypad->pdev->dev);
 
         return IRQ_HANDLED;
 }
@@ -202,7 +199,7 @@ 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);
+        pm_runtime_put(&keypad->pdev->dev);
 }
 
 static void samsung_keypad_stop(struct samsung_keypad *keypad)
@@ -232,7 +229,7 @@ static void samsung_keypad_stop(struct samsung_keypad *keypad)
          */
         enable_irq(keypad->irq);
 
-        pm_runtime_put_sync(&keypad->pdev->dev);
+        pm_runtime_put(&keypad->pdev->dev);
 }
 
 static int samsung_keypad_open(struct input_dev *input_dev)
@@ -251,6 +248,126 @@ static void samsung_keypad_close(struct input_dev *input_dev)
         samsung_keypad_stop(keypad);
 }
 
+#ifdef CONFIG_OF
+static struct samsung_keypad_platdata *samsung_keypad_parse_dt(
+                                struct device *dev)
+{
+        struct samsung_keypad_platdata *pdata;
+        struct matrix_keymap_data *keymap_data;
+        uint32_t *keymap, num_rows = 0, num_cols = 0;
+        struct device_node *np = dev->of_node, *key_np;
+        unsigned int key_count = 0;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                dev_err(dev, "could not allocate memory for platform data\n");
+                return NULL;
+        }
+
+        of_property_read_u32(np, "samsung,keypad-num-rows", &num_rows);
+        of_property_read_u32(np, "samsung,keypad-num-columns", &num_cols);
+        if (!num_rows || !num_cols) {
+                dev_err(dev, "number of keypad rows/columns not specified\n");
+                return NULL;
+        }
+        pdata->rows = num_rows;
+        pdata->cols = num_cols;
+
+        keymap_data = devm_kzalloc(dev, sizeof(*keymap_data), GFP_KERNEL);
+        if (!keymap_data) {
+                dev_err(dev, "could not allocate memory for keymap data\n");
+                return NULL;
+        }
+        pdata->keymap_data = keymap_data;
+
+        for_each_child_of_node(np, key_np)
+                key_count++;
+
+        keymap_data->keymap_size = key_count;
+        keymap = devm_kzalloc(dev, sizeof(uint32_t) * key_count, GFP_KERNEL);
+        if (!keymap) {
+                dev_err(dev, "could not allocate memory for keymap\n");
+                return NULL;
+        }
+        keymap_data->keymap = keymap;
+
+        for_each_child_of_node(np, key_np) {
+                u32 row, col, key_code;
+                of_property_read_u32(key_np, "keypad,row", &row);
+                of_property_read_u32(key_np, "keypad,column", &col);
+                of_property_read_u32(key_np, "linux,code", &key_code);
+                *keymap++ = KEY(row, col, key_code);
+        }
+
+        if (of_get_property(np, "linux,input-no-autorepeat", NULL))
+                pdata->no_autorepeat = true;
+        if (of_get_property(np, "linux,input-wakeup", NULL))
+                pdata->wakeup = true;
+
+        return pdata;
+}
+
+static void samsung_keypad_parse_dt_gpio(struct device *dev,
+                                struct samsung_keypad *keypad)
+{
+        struct device_node *np = dev->of_node;
+        int gpio, ret, row, col;
+
+        for (row = 0; row < keypad->rows; row++) {
+                gpio = of_get_named_gpio(np, "row-gpios", row);
+                keypad->row_gpios[row] = gpio;
+                if (!gpio_is_valid(gpio)) {
+                        dev_err(dev, "keypad row[%d]: invalid gpio %d\n",
+                                        row, gpio);
+                        continue;
+                }
+
+                ret = gpio_request(gpio, "keypad-row");
+                if (ret)
+                        dev_err(dev, "keypad row[%d] gpio request failed\n",
+                                        row);
+        }
+
+        for (col = 0; col < keypad->cols; col++) {
+                gpio = of_get_named_gpio(np, "col-gpios", col);
+                keypad->col_gpios[col] = gpio;
+                if (!gpio_is_valid(gpio)) {
+                        dev_err(dev, "keypad column[%d]: invalid gpio %d\n",
+                                        col, gpio);
+                        continue;
+                }
+
+                ret = gpio_request(gpio, "keypad-col");
+                if (ret)
+                        dev_err(dev, "keypad column[%d] gpio request failed\n",
+                                        col);
+        }
+}
+
+static void samsung_keypad_dt_gpio_free(struct samsung_keypad *keypad)
+{
+        int cnt;
+
+        for (cnt = 0; cnt < keypad->rows; cnt++)
+                if (gpio_is_valid(keypad->row_gpios[cnt]))
+                        gpio_free(keypad->row_gpios[cnt]);
+
+        for (cnt = 0; cnt < keypad->cols; cnt++)
+                if (gpio_is_valid(keypad->col_gpios[cnt]))
+                        gpio_free(keypad->col_gpios[cnt]);
+}
+#else
+static
+struct samsung_keypad_platdata *samsung_keypad_parse_dt(struct device *dev)
+{
+        return NULL;
+}
+
+static void samsung_keypad_dt_gpio_free(struct samsung_keypad *keypad)
+{
+}
+#endif
+
 static int __devinit samsung_keypad_probe(struct platform_device *pdev)
 {
         const struct samsung_keypad_platdata *pdata;
@@ -262,7 +379,10 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
         unsigned int keymap_size;
         int error;
 
-        pdata = pdev->dev.platform_data;
+        if (pdev->dev.of_node)
+                pdata = samsung_keypad_parse_dt(&pdev->dev);
+        else
+                pdata = pdev->dev.platform_data;
         if (!pdata) {
                 dev_err(&pdev->dev, "no platform data defined\n");
                 return -EINVAL;
@@ -321,6 +441,16 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
         keypad->stopped = true;
         init_waitqueue_head(&keypad->wait);
 
+        if (pdev->dev.of_node) {
+#ifdef CONFIG_OF
+                samsung_keypad_parse_dt_gpio(&pdev->dev, keypad);
+                keypad->type = of_device_is_compatible(pdev->dev.of_node,
+                                        "samsung,s5pv210-keypad");
+#endif
+        } else {
+                keypad->type = platform_get_device_id(pdev)->driver_data;
+        }
+
         input_dev->name = pdev->name;
         input_dev->id.bustype = BUS_HOST;
         input_dev->dev.parent = &pdev->dev;
@@ -363,6 +493,11 @@ static int __devinit samsung_keypad_probe(struct platform_device *pdev)
         if (error)
                 goto err_free_irq;
 
+        if (pdev->dev.of_node) {
+                devm_kfree(&pdev->dev, (void *)pdata->keymap_data->keymap);
+                devm_kfree(&pdev->dev, (void *)pdata->keymap_data);
+                devm_kfree(&pdev->dev, (void *)pdata);
+        }
         return 0;
 
 err_free_irq:
@@ -372,6 +507,7 @@ err_free_irq:
         platform_set_drvdata(pdev, NULL);
 err_put_clk:
         clk_put(keypad->clk);
+        samsung_keypad_dt_gpio_free(keypad);
 err_unmap_base:
         iounmap(keypad->base);
 err_free_mem:
@@ -398,6 +534,7 @@ static int __devexit samsung_keypad_remove(struct platform_device *pdev)
         free_irq(keypad->irq, keypad);
 
         clk_put(keypad->clk);
+        samsung_keypad_dt_gpio_free(keypad);
 
         iounmap(keypad->base);
         kfree(keypad);
@@ -518,6 +655,17 @@ static const struct dev_pm_ops samsung_keypad_pm_ops = {
                            samsung_keypad_runtime_resume, NULL)
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id samsung_keypad_dt_match[] = {
+        { .compatible = "samsung,s3c6410-keypad" },
+        { .compatible = "samsung,s5pv210-keypad" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, samsung_keypad_dt_match);
+#else
+#define samsung_keypad_dt_match NULL
+#endif
+
 static struct platform_device_id samsung_keypad_driver_ids[] = {
         {
                 .name           = "samsung-keypad",
@@ -536,6 +684,7 @@ static struct platform_driver samsung_keypad_driver = {
         .driver         = {
                 .name   = "samsung-keypad",
                 .owner  = THIS_MODULE,
+                .of_match_table = samsung_keypad_dt_match,
                 .pm     = &samsung_keypad_pm_ops,
         },
         .id_table       = samsung_keypad_driver_ids,
diff --git a/drivers/input/keyboard/spear-keyboard.c b/drivers/input/keyboard/spear-keyboard.c
index c88bd63dc9cc..3b6b528f02fd 100644
--- a/drivers/input/keyboard/spear-keyboard.c
+++ b/drivers/input/keyboard/spear-keyboard.c
@@ -50,6 +50,7 @@
 #define ROW_MASK        0xF0
 #define COLUMN_MASK     0x0F
 #define ROW_SHIFT       4
+#define KEY_MATRIX_SHIFT        6
 
 struct spear_kbd {
         struct input_dev *input;
@@ -57,6 +58,7 @@ struct spear_kbd {
         void __iomem *io_base;
         struct clk *clk;
         unsigned int irq;
+        unsigned int mode;
         unsigned short last_key;
         unsigned short keycodes[256];
 };
@@ -106,7 +108,8 @@ static int spear_kbd_open(struct input_dev *dev)
                 return error;
 
         /* program keyboard */
-        val = SCAN_RATE_80 | MODE_KEYBOARD | PCLK_FREQ_MSK;
+        val = SCAN_RATE_80 | MODE_KEYBOARD | PCLK_FREQ_MSK |
+                (kbd->mode << KEY_MATRIX_SHIFT);
         writew(val, kbd->io_base + MODE_REG);
         writeb(1, kbd->io_base + STATUS_REG);
 
@@ -176,6 +179,8 @@ static int __devinit spear_kbd_probe(struct platform_device *pdev)
 
         kbd->input = input_dev;
         kbd->irq = irq;
+        kbd->mode = pdata->mode;
+
         kbd->res = request_mem_region(res->start, resource_size(res),
                                       pdev->name);
         if (!kbd->res) {
@@ -308,22 +313,17 @@ static int spear_kbd_resume(struct device *dev)
 
         return 0;
 }
-
-static const struct dev_pm_ops spear_kbd_pm_ops = {
-        .suspend        = spear_kbd_suspend,
-        .resume         = spear_kbd_resume,
-};
 #endif
 
+static SIMPLE_DEV_PM_OPS(spear_kbd_pm_ops, spear_kbd_suspend, spear_kbd_resume);
+
 static struct platform_driver spear_kbd_driver = {
         .probe          = spear_kbd_probe,
         .remove         = __devexit_p(spear_kbd_remove),
         .driver         = {
                 .name   = "keyboard",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
                 .pm     = &spear_kbd_pm_ops,
-#endif
         },
 };
 module_platform_driver(spear_kbd_driver);
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
index a136e2e832be..21c42f852343 100644
--- a/drivers/input/keyboard/tegra-kbc.c
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -48,6 +48,7 @@
 #define KBC_FIFO_TH_CNT_SHIFT(cnt)      (cnt << 14)
 #define KBC_DEBOUNCE_CNT_SHIFT(cnt)     (cnt << 4)
 #define KBC_CONTROL_FIFO_CNT_INT_EN     (1 << 3)
+#define KBC_CONTROL_KEYPRESS_INT_EN     (1 << 1)
 #define KBC_CONTROL_KBC_EN              (1 << 0)
 
 /* KBC Interrupt Register */
@@ -356,6 +357,18 @@ static void tegra_kbc_set_fifo_interrupt(struct tegra_kbc *kbc, bool enable)
         writel(val, kbc->mmio + KBC_CONTROL_0);
 }
 
+static void tegra_kbc_set_keypress_interrupt(struct tegra_kbc *kbc, bool enable)
+{
+        u32 val;
+
+        val = readl(kbc->mmio + KBC_CONTROL_0);
+        if (enable)
+                val |= KBC_CONTROL_KEYPRESS_INT_EN;
+        else
+                val &= ~KBC_CONTROL_KEYPRESS_INT_EN;
+        writel(val, kbc->mmio + KBC_CONTROL_0);
+}
+
 static void tegra_kbc_keypress_timer(unsigned long data)
 {
         struct tegra_kbc *kbc = (struct tegra_kbc *)data;
@@ -455,10 +468,18 @@ static void tegra_kbc_config_pins(struct tegra_kbc *kbc)
                 row_cfg &= ~r_mask;
                 col_cfg &= ~c_mask;
 
-                if (pdata->pin_cfg[i].is_row)
+                switch (pdata->pin_cfg[i].type) {
+                case PIN_CFG_ROW:
                         row_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << r_shft;
-                else
+                        break;
+
+                case PIN_CFG_COL:
                         col_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << c_shft;
+                        break;
+
+                case PIN_CFG_IGNORE:
+                        break;
+                }
 
                 writel(row_cfg, kbc->mmio + r_offs);
                 writel(col_cfg, kbc->mmio + c_offs);
@@ -563,7 +584,8 @@ tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
         for (i = 0; i < KBC_MAX_GPIO; i++) {
                 const struct tegra_kbc_pin_cfg *pin_cfg = &pdata->pin_cfg[i];
 
-                if (pin_cfg->is_row) {
+                switch (pin_cfg->type) {
+                case PIN_CFG_ROW:
                         if (pin_cfg->num >= KBC_MAX_ROW) {
                                 dev_err(dev,
                                         "pin_cfg[%d]: invalid row number %d\n",
@@ -571,13 +593,25 @@ tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
                                 return false;
                         }
                         (*num_rows)++;
-                } else {
+                        break;
+
+                case PIN_CFG_COL:
                         if (pin_cfg->num >= KBC_MAX_COL) {
                                 dev_err(dev,
                                         "pin_cfg[%d]: invalid column number %d\n",
                                         i, pin_cfg->num);
                                 return false;
                         }
+                        break;
+
+                case PIN_CFG_IGNORE:
+                        break;
+
+                default:
+                        dev_err(dev,
+                                "pin_cfg[%d]: invalid entry type %d\n",
+                                pin_cfg->type, pin_cfg->num);
+                        return false;
                 }
         }
 
@@ -590,24 +624,25 @@ tegra_kbc_dt_parse_pdata(struct platform_device *pdev)
 {
         struct tegra_kbc_platform_data *pdata;
         struct device_node *np = pdev->dev.of_node;
+        u32 prop;
+        int i;
 
         if (!np)
                 return NULL;
 
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return NULL;
 
-        if (!of_property_read_u32(np, "debounce-delay", &prop))
+        if (!of_property_read_u32(np, "nvidia,debounce-delay-ms", &prop))
                 pdata->debounce_cnt = prop;
 
-        if (!of_property_read_u32(np, "repeat-delay", &prop))
+        if (!of_property_read_u32(np, "nvidia,repeat-delay-ms", &prop))
                 pdata->repeat_cnt = prop;
 
-        if (of_find_property(np, "needs-ghost-filter", NULL))
+        if (of_find_property(np, "nvidia,needs-ghost-filter", NULL))
                 pdata->use_ghost_filter = true;
 
-        if (of_find_property(np, "wakeup-source", NULL))
+        if (of_find_property(np, "nvidia,wakeup-source", NULL))
                 pdata->wakeup = true;
 
         /*
@@ -616,14 +651,18 @@ tegra_kbc_dt_parse_pdata(struct platform_device *pdev)
          */
         for (i = 0; i < KBC_MAX_ROW; i++) {
                 pdata->pin_cfg[i].num = i;
-                pdata->pin_cfg[i].is_row = true;
+                pdata->pin_cfg[i].type = PIN_CFG_ROW;
         }
 
         for (i = 0; i < KBC_MAX_COL; i++) {
                 pdata->pin_cfg[KBC_MAX_ROW + i].num = i;
-                pdata->pin_cfg[KBC_MAX_ROW + i].is_row = false;
+                pdata->pin_cfg[KBC_MAX_ROW + i].type = PIN_CFG_COL;
         }
 
+        pdata->keymap_data = matrix_keyboard_of_fill_keymap(np, "linux,keymap");
+
+        /* FIXME: Add handling of linux,fn-keymap here */
+
         return pdata;
 }
 #else
@@ -759,6 +798,9 @@ static int __devinit tegra_kbc_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, kbc);
         device_init_wakeup(&pdev->dev, pdata->wakeup);
 
+        if (!pdev->dev.platform_data)
+                matrix_keyboard_of_free_keymap(pdata->keymap_data);
+
         return 0;
 
 err_free_irq:
@@ -773,8 +815,10 @@ err_free_mem:
         input_free_device(input_dev);
         kfree(kbc);
 err_free_pdata:
-        if (!pdev->dev.platform_data)
+        if (!pdev->dev.platform_data) {
+                matrix_keyboard_of_free_keymap(pdata->keymap_data);
                 kfree(pdata);
+        }
 
         return err;
 }
@@ -831,6 +875,8 @@ static int tegra_kbc_suspend(struct device *dev)
                 msleep(30);
 
                 kbc->keypress_caused_wake = false;
+                /* Enable keypress interrupt before going into suspend. */
+                tegra_kbc_set_keypress_interrupt(kbc, true);
                 enable_irq(kbc->irq);
                 enable_irq_wake(kbc->irq);
         } else {
@@ -852,6 +898,8 @@ static int tegra_kbc_resume(struct device *dev)
         if (device_may_wakeup(&pdev->dev)) {
                 disable_irq_wake(kbc->irq);
                 tegra_kbc_setup_wakekeys(kbc, false);
+                /* We will use fifo interrupts for key detection. */
+                tegra_kbc_set_keypress_interrupt(kbc, false);
 
                 /* Restore the resident time of continuous polling mode. */
                 writel(kbc->cp_to_wkup_dly, kbc->mmio + KBC_TO_CNT_0);