Merge branch 'next' into for-linus

Prepare first set of updates for 3.9 merge window.

7 files changed, 573 insertions, 374 deletions

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 48309641b1b2..992137cf3a64 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -224,7 +224,7 @@ config KEYBOARD_TCA6416
 
 config KEYBOARD_TCA8418
         tristate "TCA8418 Keypad Support"
-        depends on I2C
+        depends on I2C && GENERIC_HARDIRQS
         select INPUT_MATRIXKMAP
         help
           This driver implements basic keypad functionality
@@ -303,7 +303,7 @@ config KEYBOARD_HP7XX
 
 config KEYBOARD_LM8323
         tristate "LM8323 keypad chip"
-        depends on I2C
+        depends on I2C && GENERIC_HARDIRQS
         depends on LEDS_CLASS
         help
           If you say yes here you get support for the National Semiconductor
@@ -420,7 +420,7 @@ config KEYBOARD_NOMADIK
 
 config KEYBOARD_TEGRA
         tristate "NVIDIA Tegra internal matrix keyboard controller support"
-        depends on ARCH_TEGRA
+        depends on ARCH_TEGRA && OF
         select INPUT_MATRIXKMAP
         help
           Say Y here if you want to use a matrix keyboard connected directly
@@ -479,6 +479,16 @@ config KEYBOARD_SAMSUNG
           To compile this driver as a module, choose M here: the
           module will be called samsung-keypad.
 
+config KEYBOARD_GOLDFISH_EVENTS
+        depends on GOLDFISH
+        tristate "Generic Input Event device for Goldfish"
+        help
+          Say Y here to get an input event device for the Goldfish virtual
+          device emulator.
+
+          To compile this driver as a module, choose M here: the
+          module will be called goldfish-events.
+
 config KEYBOARD_STOWAWAY
         tristate "Stowaway keyboard"
         select SERIO
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 44e76002f54b..49b16453d00e 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_KEYBOARD_ATKBD)		+= atkbd.o
 obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_DAVINCI)          += davinci_keyscan.o
 obj-$(CONFIG_KEYBOARD_EP93XX)           += ep93xx_keypad.o
+obj-$(CONFIG_KEYBOARD_GOLDFISH_EVENTS)  += goldfish_events.o
 obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
 obj-$(CONFIG_KEYBOARD_GPIO_POLLED)      += gpio_keys_polled.o
 obj-$(CONFIG_KEYBOARD_TCA6416)          += tca6416-keypad.o
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index add5ffd9fe26..2626773ff29b 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -676,6 +676,39 @@ static inline void atkbd_disable(struct atkbd *atkbd)
         serio_continue_rx(atkbd->ps2dev.serio);
 }
 
+static int atkbd_activate(struct atkbd *atkbd)
+{
+        struct ps2dev *ps2dev = &atkbd->ps2dev;
+
+/*
+ * Enable the keyboard to receive keystrokes.
+ */
+
+        if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
+                dev_err(&ps2dev->serio->dev,
+                        "Failed to enable keyboard on %s\n",
+                        ps2dev->serio->phys);
+                return -1;
+        }
+
+        return 0;
+}
+
+/*
+ * atkbd_deactivate() resets and disables the keyboard from sending
+ * keystrokes.
+ */
+
+static void atkbd_deactivate(struct atkbd *atkbd)
+{
+        struct ps2dev *ps2dev = &atkbd->ps2dev;
+
+        if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
+                dev_err(&ps2dev->serio->dev,
+                        "Failed to deactivate keyboard on %s\n",
+                        ps2dev->serio->phys);
+}
+
 /*
  * atkbd_probe() probes for an AT keyboard on a serio port.
  */
@@ -726,11 +759,17 @@ static int atkbd_probe(struct atkbd *atkbd)
 
         if (atkbd->id == 0xaca1 && atkbd->translated) {
                 dev_err(&ps2dev->serio->dev,
-                        "NCD terminal keyboards are only supported on non-translating controlelrs. "
+                        "NCD terminal keyboards are only supported on non-translating controllers. "
                         "Use i8042.direct=1 to disable translation.\n");
                 return -1;
         }
 
+/*
+ * Make sure nothing is coming from the keyboard and disturbs our
+ * internal state.
+ */
+        atkbd_deactivate(atkbd);
+
         return 0;
 }
 
@@ -825,24 +864,6 @@ static int atkbd_reset_state(struct atkbd *atkbd)
         return 0;
 }
 
-static int atkbd_activate(struct atkbd *atkbd)
-{
-        struct ps2dev *ps2dev = &atkbd->ps2dev;
-
-/*
- * Enable the keyboard to receive keystrokes.
- */
-
-        if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
-                dev_err(&ps2dev->serio->dev,
-                        "Failed to enable keyboard on %s\n",
-                        ps2dev->serio->phys);
-                return -1;
-        }
-
-        return 0;
-}
-
 /*
  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
  * reboot.
@@ -1150,7 +1171,6 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
 
                 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
                 atkbd_reset_state(atkbd);
-                atkbd_activate(atkbd);
 
         } else {
                 atkbd->set = 2;
@@ -1165,6 +1185,8 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
                 goto fail3;
 
         atkbd_enable(atkbd);
+        if (serio->write)
+                atkbd_activate(atkbd);
 
         err = input_register_device(atkbd->dev);
         if (err)
@@ -1208,8 +1230,6 @@ static int atkbd_reconnect(struct serio *serio)
                 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
                         goto out;
 
-                atkbd_activate(atkbd);
-
                 /*
                  * Restore LED state and repeat rate. While input core
                  * will do this for us at resume time reconnect may happen
@@ -1223,7 +1243,17 @@ static int atkbd_reconnect(struct serio *serio)
 
         }
 
+        /*
+         * Reset our state machine in case reconnect happened in the middle
+         * of multi-byte scancode.
+         */
+        atkbd->xl_bit = 0;
+        atkbd->emul = 0;
+
         atkbd_enable(atkbd);
+        if (atkbd->write)
+                atkbd_activate(atkbd);
+
         retval = 0;
 
  out:
diff --git a/drivers/input/keyboard/goldfish_events.c b/drivers/input/keyboard/goldfish_events.c
new file mode 100644
index 000000000000..9f60a2ec88db
--- /dev/null
+++ b/drivers/input/keyboard/goldfish_events.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2007 Google, Inc.
+ * Copyright (C) 2012 Intel, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+
+enum {
+        REG_READ        = 0x00,
+        REG_SET_PAGE    = 0x00,
+        REG_LEN         = 0x04,
+        REG_DATA        = 0x08,
+
+        PAGE_NAME       = 0x00000,
+        PAGE_EVBITS     = 0x10000,
+        PAGE_ABSDATA    = 0x20000 | EV_ABS,
+};
+
+struct event_dev {
+        struct input_dev *input;
+        int irq;
+        void __iomem *addr;
+        char name[0];
+};
+
+static irqreturn_t events_interrupt(int irq, void *dev_id)
+{
+        struct event_dev *edev = dev_id;
+        unsigned type, code, value;
+
+        type = __raw_readl(edev->addr + REG_READ);
+        code = __raw_readl(edev->addr + REG_READ);
+        value = __raw_readl(edev->addr + REG_READ);
+
+        input_event(edev->input, type, code, value);
+        input_sync(edev->input);
+        return IRQ_HANDLED;
+}
+
+static void events_import_bits(struct event_dev *edev,
+                        unsigned long bits[], unsigned type, size_t count)
+{
+        void __iomem *addr = edev->addr;
+        int i, j;
+        size_t size;
+        uint8_t val;
+
+        __raw_writel(PAGE_EVBITS | type, addr + REG_SET_PAGE);
+
+        size = __raw_readl(addr + REG_LEN) * 8;
+        if (size < count)
+                count = size;
+
+        addr += REG_DATA;
+        for (i = 0; i < count; i += 8) {
+                val = __raw_readb(addr++);
+                for (j = 0; j < 8; j++)
+                        if (val & 1 << j)
+                                set_bit(i + j, bits);
+        }
+}
+
+static void events_import_abs_params(struct event_dev *edev)
+{
+        struct input_dev *input_dev = edev->input;
+        void __iomem *addr = edev->addr;
+        u32 val[4];
+        int count;
+        int i, j;
+
+        __raw_writel(PAGE_ABSDATA, addr + REG_SET_PAGE);
+
+        count = __raw_readl(addr + REG_LEN) / sizeof(val);
+        if (count > ABS_MAX)
+                count = ABS_MAX;
+
+        for (i = 0; i < count; i++) {
+                if (!test_bit(i, input_dev->absbit))
+                        continue;
+
+                for (j = 0; j < ARRAY_SIZE(val); j++) {
+                        int offset = (i * ARRAY_SIZE(val) + j) * sizeof(u32);
+                        val[j] = __raw_readl(edev->addr + REG_DATA + offset);
+                }
+
+                input_set_abs_params(input_dev, i,
+                                     val[0], val[1], val[2], val[3]);
+        }
+}
+
+static int events_probe(struct platform_device *pdev)
+{
+        struct input_dev *input_dev;
+        struct event_dev *edev;
+        struct resource *res;
+        unsigned keymapnamelen;
+        void __iomem *addr;
+        int irq;
+        int i;
+        int error;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return -EINVAL;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EINVAL;
+
+        addr = devm_ioremap(&pdev->dev, res->start, 4096);
+        if (!addr)
+                return -ENOMEM;
+
+        __raw_writel(PAGE_NAME, addr + REG_SET_PAGE);
+        keymapnamelen = __raw_readl(addr + REG_LEN);
+
+        edev = devm_kzalloc(&pdev->dev,
+                            sizeof(struct event_dev) + keymapnamelen + 1,
+                            GFP_KERNEL);
+        if (!edev)
+                return -ENOMEM;
+
+        input_dev = devm_input_allocate_device(&pdev->dev);
+        if (!input_dev)
+                return -ENOMEM;
+
+        edev->input = input_dev;
+        edev->addr = addr;
+        edev->irq = irq;
+
+        for (i = 0; i < keymapnamelen; i++)
+                edev->name[i] = __raw_readb(edev->addr + REG_DATA + i);
+
+        pr_debug("events_probe() keymap=%s\n", edev->name);
+
+        input_dev->name = edev->name;
+        input_dev->id.bustype = BUS_HOST;
+
+        events_import_bits(edev, input_dev->evbit, EV_SYN, EV_MAX);
+        events_import_bits(edev, input_dev->keybit, EV_KEY, KEY_MAX);
+        events_import_bits(edev, input_dev->relbit, EV_REL, REL_MAX);
+        events_import_bits(edev, input_dev->absbit, EV_ABS, ABS_MAX);
+        events_import_bits(edev, input_dev->mscbit, EV_MSC, MSC_MAX);
+        events_import_bits(edev, input_dev->ledbit, EV_LED, LED_MAX);
+        events_import_bits(edev, input_dev->sndbit, EV_SND, SND_MAX);
+        events_import_bits(edev, input_dev->ffbit, EV_FF, FF_MAX);
+        events_import_bits(edev, input_dev->swbit, EV_SW, SW_MAX);
+
+        events_import_abs_params(edev);
+
+        error = devm_request_irq(&pdev->dev, edev->irq, events_interrupt, 0,
+                                 "goldfish-events-keypad", edev);
+        if (error)
+                return error;
+
+        error = input_register_device(input_dev);
+        if (error)
+                return error;
+
+        return 0;
+}
+
+static struct platform_driver events_driver = {
+        .probe  = events_probe,
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "goldfish_events",
+        },
+};
+
+module_platform_driver(events_driver);
+
+MODULE_AUTHOR("Brian Swetland");
+MODULE_DESCRIPTION("Goldfish Event Device");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/imx_keypad.c b/drivers/input/keyboard/imx_keypad.c
index 6d150e3e1f55..98f9113251d2 100644
--- a/drivers/input/keyboard/imx_keypad.c
+++ b/drivers/input/keyboard/imx_keypad.c
@@ -20,6 +20,7 @@
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
@@ -414,15 +415,23 @@ open_err:
         return -EIO;
 }
 
+#ifdef CONFIG_OF
+static struct of_device_id imx_keypad_of_match[] = {
+        { .compatible = "fsl,imx21-kpp", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_keypad_of_match);
+#endif
+
 static int imx_keypad_probe(struct platform_device *pdev)
 {
         const struct matrix_keymap_data *keymap_data = pdev->dev.platform_data;
         struct imx_keypad *keypad;
         struct input_dev *input_dev;
         struct resource *res;
-        int irq, error, i;
+        int irq, error, i, row, col;
 
-        if (keymap_data == NULL) {
+        if (!keymap_data && !pdev->dev.of_node) {
                 dev_err(&pdev->dev, "no keymap defined\n");
                 return -EINVAL;
         }
@@ -480,22 +489,6 @@ static int imx_keypad_probe(struct platform_device *pdev)
                 goto failed_unmap;
         }
 
-        /* Search for rows and cols enabled */
-        for (i = 0; i < keymap_data->keymap_size; i++) {
-                keypad->rows_en_mask |= 1 << KEY_ROW(keymap_data->keymap[i]);
-                keypad->cols_en_mask |= 1 << KEY_COL(keymap_data->keymap[i]);
-        }
-
-        if (keypad->rows_en_mask > ((1 << MAX_MATRIX_KEY_ROWS) - 1) ||
-            keypad->cols_en_mask > ((1 << MAX_MATRIX_KEY_COLS) - 1)) {
-                dev_err(&pdev->dev,
-                        "invalid key data (too many rows or colums)\n");
-                error = -EINVAL;
-                goto failed_clock_put;
-        }
-        dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask);
-        dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask);
-
         /* Init the Input device */
         input_dev->name = pdev->name;
         input_dev->id.bustype = BUS_HOST;
@@ -512,6 +505,19 @@ static int imx_keypad_probe(struct platform_device *pdev)
                 goto failed_clock_put;
         }
 
+        /* Search for rows and cols enabled */
+        for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) {
+                for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
+                        i = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT);
+                        if (keypad->keycodes[i] != KEY_RESERVED) {
+                                keypad->rows_en_mask |= 1 << row;
+                                keypad->cols_en_mask |= 1 << col;
+                        }
+                }
+        }
+        dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask);
+        dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask);
+
         __set_bit(EV_REP, input_dev->evbit);
         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
         input_set_drvdata(input_dev, keypad);
@@ -631,6 +637,7 @@ static struct platform_driver imx_keypad_driver = {
                 .name   = "imx-keypad",
                 .owner  = THIS_MODULE,
                 .pm     = &imx_kbd_pm_ops,
+                .of_match_table = of_match_ptr(imx_keypad_of_match),
         },
         .probe          = imx_keypad_probe,
         .remove         = imx_keypad_remove,
diff --git a/drivers/input/keyboard/qt2160.c b/drivers/input/keyboard/qt2160.c
index 3dc2b0f27b0c..1c0ddad0a1cc 100644
--- a/drivers/input/keyboard/qt2160.c
+++ b/drivers/input/keyboard/qt2160.c
@@ -20,6 +20,7 @@
 
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/leds.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
@@ -39,6 +40,11 @@
 #define QT2160_CMD_GPIOS      6
 #define QT2160_CMD_SUBVER     7
 #define QT2160_CMD_CALIBRATE  10
+#define QT2160_CMD_DRIVE_X    70
+#define QT2160_CMD_PWMEN_X    74
+#define QT2160_CMD_PWM_DUTY   76
+
+#define QT2160_NUM_LEDS_X       8
 
 #define QT2160_CYCLE_INTERVAL   (2*HZ)
 
@@ -49,6 +55,17 @@ static unsigned char qt2160_key2code[] = {
         KEY_C, KEY_D, KEY_E, KEY_F,
 };
 
+#ifdef CONFIG_LEDS_CLASS
+struct qt2160_led {
+        struct qt2160_data *qt2160;
+        struct led_classdev cdev;
+        struct work_struct work;
+        char name[32];
+        int id;
+        enum led_brightness new_brightness;
+};
+#endif
+
 struct qt2160_data {
         struct i2c_client *client;
         struct input_dev *input;
@@ -56,8 +73,61 @@ struct qt2160_data {
         spinlock_t lock;        /* Protects canceling/rescheduling of dwork */
         unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
         u16 key_matrix;
+#ifdef CONFIG_LEDS_CLASS
+        struct qt2160_led leds[QT2160_NUM_LEDS_X];
+        struct mutex led_lock;
+#endif
 };
 
+static int qt2160_read(struct i2c_client *client, u8 reg);
+static int qt2160_write(struct i2c_client *client, u8 reg, u8 data);
+
+#ifdef CONFIG_LEDS_CLASS
+
+static void qt2160_led_work(struct work_struct *work)
+{
+        struct qt2160_led *led = container_of(work, struct qt2160_led, work);
+        struct qt2160_data *qt2160 = led->qt2160;
+        struct i2c_client *client = qt2160->client;
+        int value = led->new_brightness;
+        u32 drive, pwmen;
+
+        mutex_lock(&qt2160->led_lock);
+
+        drive = qt2160_read(client, QT2160_CMD_DRIVE_X);
+        pwmen = qt2160_read(client, QT2160_CMD_PWMEN_X);
+        if (value != LED_OFF) {
+                drive |= (1 << led->id);
+                pwmen |= (1 << led->id);
+
+        } else {
+                drive &= ~(1 << led->id);
+                pwmen &= ~(1 << led->id);
+        }
+        qt2160_write(client, QT2160_CMD_DRIVE_X, drive);
+        qt2160_write(client, QT2160_CMD_PWMEN_X, pwmen);
+
+        /*
+         * Changing this register will change the brightness
+         * of every LED in the qt2160. It's a HW limitation.
+         */
+        if (value != LED_OFF)
+                qt2160_write(client, QT2160_CMD_PWM_DUTY, value);
+
+        mutex_unlock(&qt2160->led_lock);
+}
+
+static void qt2160_led_set(struct led_classdev *cdev,
+                           enum led_brightness value)
+{
+        struct qt2160_led *led = container_of(cdev, struct qt2160_led, cdev);
+
+        led->new_brightness = value;
+        schedule_work(&led->work);
+}
+
+#endif /* CONFIG_LEDS_CLASS */
+
 static int qt2160_read_block(struct i2c_client *client,
                              u8 inireg, u8 *buffer, unsigned int count)
 {
@@ -216,6 +286,63 @@ static int qt2160_write(struct i2c_client *client, u8 reg, u8 data)
         return ret;
 }
 
+#ifdef CONFIG_LEDS_CLASS
+
+static int qt2160_register_leds(struct qt2160_data *qt2160)
+{
+        struct i2c_client *client = qt2160->client;
+        int ret;
+        int i;
+
+        mutex_init(&qt2160->led_lock);
+
+        for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
+                struct qt2160_led *led = &qt2160->leds[i];
+
+                snprintf(led->name, sizeof(led->name), "qt2160:x%d", i);
+                led->cdev.name = led->name;
+                led->cdev.brightness_set = qt2160_led_set;
+                led->cdev.brightness = LED_OFF;
+                led->id = i;
+                led->qt2160 = qt2160;
+
+                INIT_WORK(&led->work, qt2160_led_work);
+
+                ret = led_classdev_register(&client->dev, &led->cdev);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /* Tur off LEDs */
+        qt2160_write(client, QT2160_CMD_DRIVE_X, 0);
+        qt2160_write(client, QT2160_CMD_PWMEN_X, 0);
+        qt2160_write(client, QT2160_CMD_PWM_DUTY, 0);
+
+        return 0;
+}
+
+static void qt2160_unregister_leds(struct qt2160_data *qt2160)
+{
+        int i;
+
+        for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
+                led_classdev_unregister(&qt2160->leds[i].cdev);
+                cancel_work_sync(&qt2160->leds[i].work);
+        }
+}
+
+#else
+
+static inline int qt2160_register_leds(struct qt2160_data *qt2160)
+{
+        return 0;
+}
+
+static inline void qt2160_unregister_leds(struct qt2160_data *qt2160)
+{
+}
+
+#endif
 
 static bool qt2160_identify(struct i2c_client *client)
 {
@@ -249,7 +376,7 @@ static bool qt2160_identify(struct i2c_client *client)
 }
 
 static int qt2160_probe(struct i2c_client *client,
-                                  const struct i2c_device_id *id)
+                        const struct i2c_device_id *id)
 {
         struct qt2160_data *qt2160;
         struct input_dev *input;
@@ -314,11 +441,17 @@ static int qt2160_probe(struct i2c_client *client,
                 }
         }
 
+        error = qt2160_register_leds(qt2160);
+        if (error) {
+                dev_err(&client->dev, "Failed to register leds\n");
+                goto err_free_irq;
+        }
+
         error = input_register_device(qt2160->input);
         if (error) {
                 dev_err(&client->dev,
                         "Failed to register input device\n");
-                goto err_free_irq;
+                goto err_unregister_leds;
         }
 
         i2c_set_clientdata(client, qt2160);
@@ -326,6 +459,8 @@ static int qt2160_probe(struct i2c_client *client,
 
         return 0;
 
+err_unregister_leds:
+        qt2160_unregister_leds(qt2160);
 err_free_irq:
         if (client->irq)
                 free_irq(client->irq, qt2160);
@@ -339,6 +474,8 @@ static int qt2160_remove(struct i2c_client *client)
 {
         struct qt2160_data *qt2160 = i2c_get_clientdata(client);
 
+        qt2160_unregister_leds(qt2160);
+
         /* Release IRQ so no queue will be scheduled */
         if (client->irq)
                 free_irq(client->irq, qt2160);
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
index c76f96872d31..d89e7d392d1e 100644
--- a/drivers/input/keyboard/tegra-kbc.c
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -29,9 +29,16 @@
 #include <linux/of.h>
 #include <linux/clk.h>
 #include <linux/slab.h>
-#include <linux/input/tegra_kbc.h>
+#include <linux/input/matrix_keypad.h>
 #include <mach/clk.h>
 
+#define KBC_MAX_GPIO    24
+#define KBC_MAX_KPENT   8
+
+#define KBC_MAX_ROW     16
+#define KBC_MAX_COL     8
+#define KBC_MAX_KEY     (KBC_MAX_ROW * KBC_MAX_COL)
+
 #define KBC_MAX_DEBOUNCE_CNT    0x3ffu
 
 /* KBC row scan time and delay for beginning the row scan. */
@@ -67,10 +74,27 @@
 
 #define KBC_ROW_SHIFT   3
 
+enum tegra_pin_type {
+        PIN_CFG_IGNORE,
+        PIN_CFG_COL,
+        PIN_CFG_ROW,
+};
+
+struct tegra_kbc_pin_cfg {
+        enum tegra_pin_type type;
+        unsigned char num;
+};
+
 struct tegra_kbc {
+        struct device *dev;
+        unsigned int debounce_cnt;
+        unsigned int repeat_cnt;
+        struct tegra_kbc_pin_cfg pin_cfg[KBC_MAX_GPIO];
+        const struct matrix_keymap_data *keymap_data;
+        bool wakeup;
         void __iomem *mmio;
         struct input_dev *idev;
-        unsigned int irq;
+        int irq;
         spinlock_t lock;
         unsigned int repoll_dly;
         unsigned long cp_dly_jiffies;
@@ -78,7 +102,6 @@ struct tegra_kbc {
         bool use_fn_map;
         bool use_ghost_filter;
         bool keypress_caused_wake;
-        const struct tegra_kbc_platform_data *pdata;
         unsigned short keycode[KBC_MAX_KEY * 2];
         unsigned short current_keys[KBC_MAX_KPENT];
         unsigned int num_pressed_keys;
@@ -87,147 +110,6 @@ struct tegra_kbc {
         struct clk *clk;
 };
 
-static const u32 tegra_kbc_default_keymap[] = {
-        KEY(0, 2, KEY_W),
-        KEY(0, 3, KEY_S),
-        KEY(0, 4, KEY_A),
-        KEY(0, 5, KEY_Z),
-        KEY(0, 7, KEY_FN),
-
-        KEY(1, 7, KEY_LEFTMETA),
-
-        KEY(2, 6, KEY_RIGHTALT),
-        KEY(2, 7, KEY_LEFTALT),
-
-        KEY(3, 0, KEY_5),
-        KEY(3, 1, KEY_4),
-        KEY(3, 2, KEY_R),
-        KEY(3, 3, KEY_E),
-        KEY(3, 4, KEY_F),
-        KEY(3, 5, KEY_D),
-        KEY(3, 6, KEY_X),
-
-        KEY(4, 0, KEY_7),
-        KEY(4, 1, KEY_6),
-        KEY(4, 2, KEY_T),
-        KEY(4, 3, KEY_H),
-        KEY(4, 4, KEY_G),
-        KEY(4, 5, KEY_V),
-        KEY(4, 6, KEY_C),
-        KEY(4, 7, KEY_SPACE),
-
-        KEY(5, 0, KEY_9),
-        KEY(5, 1, KEY_8),
-        KEY(5, 2, KEY_U),
-        KEY(5, 3, KEY_Y),
-        KEY(5, 4, KEY_J),
-        KEY(5, 5, KEY_N),
-        KEY(5, 6, KEY_B),
-        KEY(5, 7, KEY_BACKSLASH),
-
-        KEY(6, 0, KEY_MINUS),
-        KEY(6, 1, KEY_0),
-        KEY(6, 2, KEY_O),
-        KEY(6, 3, KEY_I),
-        KEY(6, 4, KEY_L),
-        KEY(6, 5, KEY_K),
-        KEY(6, 6, KEY_COMMA),
-        KEY(6, 7, KEY_M),
-
-        KEY(7, 1, KEY_EQUAL),
-        KEY(7, 2, KEY_RIGHTBRACE),
-        KEY(7, 3, KEY_ENTER),
-        KEY(7, 7, KEY_MENU),
-
-        KEY(8, 4, KEY_RIGHTSHIFT),
-        KEY(8, 5, KEY_LEFTSHIFT),
-
-        KEY(9, 5, KEY_RIGHTCTRL),
-        KEY(9, 7, KEY_LEFTCTRL),
-
-        KEY(11, 0, KEY_LEFTBRACE),
-        KEY(11, 1, KEY_P),
-        KEY(11, 2, KEY_APOSTROPHE),
-        KEY(11, 3, KEY_SEMICOLON),
-        KEY(11, 4, KEY_SLASH),
-        KEY(11, 5, KEY_DOT),
-
-        KEY(12, 0, KEY_F10),
-        KEY(12, 1, KEY_F9),
-        KEY(12, 2, KEY_BACKSPACE),
-        KEY(12, 3, KEY_3),
-        KEY(12, 4, KEY_2),
-        KEY(12, 5, KEY_UP),
-        KEY(12, 6, KEY_PRINT),
-        KEY(12, 7, KEY_PAUSE),
-
-        KEY(13, 0, KEY_INSERT),
-        KEY(13, 1, KEY_DELETE),
-        KEY(13, 3, KEY_PAGEUP),
-        KEY(13, 4, KEY_PAGEDOWN),
-        KEY(13, 5, KEY_RIGHT),
-        KEY(13, 6, KEY_DOWN),
-        KEY(13, 7, KEY_LEFT),
-
-        KEY(14, 0, KEY_F11),
-        KEY(14, 1, KEY_F12),
-        KEY(14, 2, KEY_F8),
-        KEY(14, 3, KEY_Q),
-        KEY(14, 4, KEY_F4),
-        KEY(14, 5, KEY_F3),
-        KEY(14, 6, KEY_1),
-        KEY(14, 7, KEY_F7),
-
-        KEY(15, 0, KEY_ESC),
-        KEY(15, 1, KEY_GRAVE),
-        KEY(15, 2, KEY_F5),
-        KEY(15, 3, KEY_TAB),
-        KEY(15, 4, KEY_F1),
-        KEY(15, 5, KEY_F2),
-        KEY(15, 6, KEY_CAPSLOCK),
-        KEY(15, 7, KEY_F6),
-
-        /* Software Handled Function Keys */
-        KEY(20, 0, KEY_KP7),
-
-        KEY(21, 0, KEY_KP9),
-        KEY(21, 1, KEY_KP8),
-        KEY(21, 2, KEY_KP4),
-        KEY(21, 4, KEY_KP1),
-
-        KEY(22, 1, KEY_KPSLASH),
-        KEY(22, 2, KEY_KP6),
-        KEY(22, 3, KEY_KP5),
-        KEY(22, 4, KEY_KP3),
-        KEY(22, 5, KEY_KP2),
-        KEY(22, 7, KEY_KP0),
-
-        KEY(27, 1, KEY_KPASTERISK),
-        KEY(27, 3, KEY_KPMINUS),
-        KEY(27, 4, KEY_KPPLUS),
-        KEY(27, 5, KEY_KPDOT),
-
-        KEY(28, 5, KEY_VOLUMEUP),
-
-        KEY(29, 3, KEY_HOME),
-        KEY(29, 4, KEY_END),
-        KEY(29, 5, KEY_BRIGHTNESSDOWN),
-        KEY(29, 6, KEY_VOLUMEDOWN),
-        KEY(29, 7, KEY_BRIGHTNESSUP),
-
-        KEY(30, 0, KEY_NUMLOCK),
-        KEY(30, 1, KEY_SCROLLLOCK),
-        KEY(30, 2, KEY_MUTE),
-
-        KEY(31, 4, KEY_HELP),
-};
-
-static const
-struct matrix_keymap_data tegra_kbc_default_keymap_data = {
-        .keymap         = tegra_kbc_default_keymap,
-        .keymap_size    = ARRAY_SIZE(tegra_kbc_default_keymap),
-};
-
 static void tegra_kbc_report_released_keys(struct input_dev *input,
                                            unsigned short old_keycodes[],
                                            unsigned int old_num_keys,
@@ -357,18 +239,6 @@ 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;
@@ -439,12 +309,11 @@ static irqreturn_t tegra_kbc_isr(int irq, void *args)
 
 static void tegra_kbc_setup_wakekeys(struct tegra_kbc *kbc, bool filter)
 {
-        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
         int i;
         unsigned int rst_val;
 
         /* Either mask all keys or none. */
-        rst_val = (filter && !pdata->wakeup) ? ~0 : 0;
+        rst_val = (filter && !kbc->wakeup) ? ~0 : 0;
 
         for (i = 0; i < KBC_MAX_ROW; i++)
                 writel(rst_val, kbc->mmio + KBC_ROW0_MASK_0 + i * 4);
@@ -452,7 +321,6 @@ static void tegra_kbc_setup_wakekeys(struct tegra_kbc *kbc, bool filter)
 
 static void tegra_kbc_config_pins(struct tegra_kbc *kbc)
 {
-        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
         int i;
 
         for (i = 0; i < KBC_MAX_GPIO; i++) {
@@ -468,13 +336,13 @@ static void tegra_kbc_config_pins(struct tegra_kbc *kbc)
                 row_cfg &= ~r_mask;
                 col_cfg &= ~c_mask;
 
-                switch (pdata->pin_cfg[i].type) {
+                switch (kbc->pin_cfg[i].type) {
                 case PIN_CFG_ROW:
-                        row_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << r_shft;
+                        row_cfg |= ((kbc->pin_cfg[i].num << 1) | 1) << r_shft;
                         break;
 
                 case PIN_CFG_COL:
-                        col_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << c_shft;
+                        col_cfg |= ((kbc->pin_cfg[i].num << 1) | 1) << c_shft;
                         break;
 
                 case PIN_CFG_IGNORE:
@@ -488,7 +356,6 @@ static void tegra_kbc_config_pins(struct tegra_kbc *kbc)
 
 static int tegra_kbc_start(struct tegra_kbc *kbc)
 {
-        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
         unsigned int debounce_cnt;
         u32 val = 0;
 
@@ -503,10 +370,10 @@ static int tegra_kbc_start(struct tegra_kbc *kbc)
         tegra_kbc_config_pins(kbc);
         tegra_kbc_setup_wakekeys(kbc, false);
 
-        writel(pdata->repeat_cnt, kbc->mmio + KBC_RPT_DLY_0);
+        writel(kbc->repeat_cnt, kbc->mmio + KBC_RPT_DLY_0);
 
         /* Keyboard debounce count is maximum of 12 bits. */
-        debounce_cnt = min(pdata->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
+        debounce_cnt = min(kbc->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
         val = KBC_DEBOUNCE_CNT_SHIFT(debounce_cnt);
         val |= KBC_FIFO_TH_CNT_SHIFT(1); /* set fifo interrupt threshold to 1 */
         val |= KBC_CONTROL_FIFO_CNT_INT_EN;  /* interrupt on FIFO threshold */
@@ -573,21 +440,20 @@ static void tegra_kbc_close(struct input_dev *dev)
         return tegra_kbc_stop(kbc);
 }
 
-static bool
-tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
-                        struct device *dev, unsigned int *num_rows)
+static bool tegra_kbc_check_pin_cfg(const struct tegra_kbc *kbc,
+                                        unsigned int *num_rows)
 {
         int i;
 
         *num_rows = 0;
 
         for (i = 0; i < KBC_MAX_GPIO; i++) {
-                const struct tegra_kbc_pin_cfg *pin_cfg = &pdata->pin_cfg[i];
+                const struct tegra_kbc_pin_cfg *pin_cfg = &kbc->pin_cfg[i];
 
                 switch (pin_cfg->type) {
                 case PIN_CFG_ROW:
                         if (pin_cfg->num >= KBC_MAX_ROW) {
-                                dev_err(dev,
+                                dev_err(kbc->dev,
                                         "pin_cfg[%d]: invalid row number %d\n",
                                         i, pin_cfg->num);
                                 return false;
@@ -597,7 +463,7 @@ tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
 
                 case PIN_CFG_COL:
                         if (pin_cfg->num >= KBC_MAX_COL) {
-                                dev_err(dev,
+                                dev_err(kbc->dev,
                                         "pin_cfg[%d]: invalid column number %d\n",
                                         i, pin_cfg->num);
                                 return false;
@@ -608,7 +474,7 @@ tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
                         break;
 
                 default:
-                        dev_err(dev,
+                        dev_err(kbc->dev,
                                 "pin_cfg[%d]: invalid entry type %d\n",
                                 pin_cfg->type, pin_cfg->num);
                         return false;
@@ -618,154 +484,140 @@ tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
         return true;
 }
 
-#ifdef CONFIG_OF
-static struct tegra_kbc_platform_data *tegra_kbc_dt_parse_pdata(
-        struct platform_device *pdev)
+static int tegra_kbc_parse_dt(struct tegra_kbc *kbc)
 {
-        struct tegra_kbc_platform_data *pdata;
-        struct device_node *np = pdev->dev.of_node;
+        struct device_node *np = kbc->dev->of_node;
         u32 prop;
         int i;
-
-        if (!np)
-                return NULL;
-
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
-        if (!pdata)
-                return NULL;
+        u32 num_rows = 0;
+        u32 num_cols = 0;
+        u32 cols_cfg[KBC_MAX_GPIO];
+        u32 rows_cfg[KBC_MAX_GPIO];
+        int proplen;
+        int ret;
 
         if (!of_property_read_u32(np, "nvidia,debounce-delay-ms", &prop))
-                pdata->debounce_cnt = prop;
+                kbc->debounce_cnt = prop;
 
         if (!of_property_read_u32(np, "nvidia,repeat-delay-ms", &prop))
-                pdata->repeat_cnt = prop;
+                kbc->repeat_cnt = prop;
 
         if (of_find_property(np, "nvidia,needs-ghost-filter", NULL))
-                pdata->use_ghost_filter = true;
+                kbc->use_ghost_filter = true;
 
         if (of_find_property(np, "nvidia,wakeup-source", NULL))
-                pdata->wakeup = true;
+                kbc->wakeup = true;
 
-        /*
-         * All currently known keymaps with device tree support use the same
-         * pin_cfg, so set it up here.
-         */
-        for (i = 0; i < KBC_MAX_ROW; i++) {
-                pdata->pin_cfg[i].num = i;
-                pdata->pin_cfg[i].type = PIN_CFG_ROW;
+        if (!of_get_property(np, "nvidia,kbc-row-pins", &proplen)) {
+                dev_err(kbc->dev, "property nvidia,kbc-row-pins not found\n");
+                return -ENOENT;
         }
+        num_rows = proplen / sizeof(u32);
 
-        for (i = 0; i < KBC_MAX_COL; i++) {
-                pdata->pin_cfg[KBC_MAX_ROW + i].num = i;
-                pdata->pin_cfg[KBC_MAX_ROW + i].type = PIN_CFG_COL;
+        if (!of_get_property(np, "nvidia,kbc-col-pins", &proplen)) {
+                dev_err(kbc->dev, "property nvidia,kbc-col-pins not found\n");
+                return -ENOENT;
         }
+        num_cols = proplen / sizeof(u32);
 
-        return pdata;
-}
-#else
-static inline struct tegra_kbc_platform_data *tegra_kbc_dt_parse_pdata(
-        struct platform_device *pdev)
-{
-        return NULL;
-}
-#endif
+        if (!of_get_property(np, "linux,keymap", &proplen)) {
+                dev_err(kbc->dev, "property linux,keymap not found\n");
+                return -ENOENT;
+        }
 
-static int tegra_kbd_setup_keymap(struct tegra_kbc *kbc)
-{
-        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
-        const struct matrix_keymap_data *keymap_data = pdata->keymap_data;
-        unsigned int keymap_rows = KBC_MAX_KEY;
-        int retval;
+        if (!num_rows || !num_cols || ((num_rows + num_cols) > KBC_MAX_GPIO)) {
+                dev_err(kbc->dev,
+                        "keypad rows/columns not porperly specified\n");
+                return -EINVAL;
+        }
 
-        if (keymap_data && pdata->use_fn_map)
-                keymap_rows *= 2;
+        /* Set all pins as non-configured */
+        for (i = 0; i < KBC_MAX_GPIO; i++)
+                kbc->pin_cfg[i].type = PIN_CFG_IGNORE;
 
-        retval = matrix_keypad_build_keymap(keymap_data, NULL,
-                                            keymap_rows, KBC_MAX_COL,
-                                            kbc->keycode, kbc->idev);
-        if (retval == -ENOSYS || retval == -ENOENT) {
-                /*
-                 * If there is no OF support in kernel or keymap
-                 * property is missing, use default keymap.
-                 */
-                retval = matrix_keypad_build_keymap(
-                                        &tegra_kbc_default_keymap_data, NULL,
-                                        keymap_rows, KBC_MAX_COL,
-                                        kbc->keycode, kbc->idev);
+        ret = of_property_read_u32_array(np, "nvidia,kbc-row-pins",
+                                rows_cfg, num_rows);
+        if (ret < 0) {
+                dev_err(kbc->dev, "Rows configurations are not proper\n");
+                return -EINVAL;
+        }
+
+        ret = of_property_read_u32_array(np, "nvidia,kbc-col-pins",
+                                cols_cfg, num_cols);
+        if (ret < 0) {
+                dev_err(kbc->dev, "Cols configurations are not proper\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < num_rows; i++) {
+                kbc->pin_cfg[rows_cfg[i]].type = PIN_CFG_ROW;
+                kbc->pin_cfg[rows_cfg[i]].num = i;
         }
 
-        return retval;
+        for (i = 0; i < num_cols; i++) {
+                kbc->pin_cfg[cols_cfg[i]].type = PIN_CFG_COL;
+                kbc->pin_cfg[cols_cfg[i]].num = i;
+        }
+
+        return 0;
 }
 
 static int tegra_kbc_probe(struct platform_device *pdev)
 {
-        const struct tegra_kbc_platform_data *pdata = pdev->dev.platform_data;
         struct tegra_kbc *kbc;
-        struct input_dev *input_dev;
         struct resource *res;
-        int irq;
         int err;
         int num_rows = 0;
         unsigned int debounce_cnt;
         unsigned int scan_time_rows;
+        unsigned int keymap_rows = KBC_MAX_KEY;
 
-        if (!pdata)
-                pdata = tegra_kbc_dt_parse_pdata(pdev);
+        kbc = devm_kzalloc(&pdev->dev, sizeof(*kbc), GFP_KERNEL);
+        if (!kbc) {
+                dev_err(&pdev->dev, "failed to alloc memory for kbc\n");
+                return -ENOMEM;
+        }
 
-        if (!pdata)
-                return -EINVAL;
+        kbc->dev = &pdev->dev;
+        spin_lock_init(&kbc->lock);
 
-        if (!tegra_kbc_check_pin_cfg(pdata, &pdev->dev, &num_rows)) {
-                err = -EINVAL;
-                goto err_free_pdata;
-        }
+        err = tegra_kbc_parse_dt(kbc);
+        if (err)
+                return err;
+
+        if (!tegra_kbc_check_pin_cfg(kbc, &num_rows))
+                return -EINVAL;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 dev_err(&pdev->dev, "failed to get I/O memory\n");
-                err = -ENXIO;
-                goto err_free_pdata;
+                return -ENXIO;
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
+        kbc->irq = platform_get_irq(pdev, 0);
+        if (kbc->irq < 0) {
                 dev_err(&pdev->dev, "failed to get keyboard IRQ\n");
-                err = -ENXIO;
-                goto err_free_pdata;
+                return -ENXIO;
         }
 
-        kbc = kzalloc(sizeof(*kbc), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!kbc || !input_dev) {
-                err = -ENOMEM;
-                goto err_free_mem;
+        kbc->idev = devm_input_allocate_device(&pdev->dev);
+        if (!kbc->idev) {
+                dev_err(&pdev->dev, "failed to allocate input device\n");
+                return -ENOMEM;
         }
 
-        kbc->pdata = pdata;
-        kbc->idev = input_dev;
-        kbc->irq = irq;
-        spin_lock_init(&kbc->lock);
         setup_timer(&kbc->timer, tegra_kbc_keypress_timer, (unsigned long)kbc);
 
-        res = request_mem_region(res->start, resource_size(res), pdev->name);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to request I/O memory\n");
-                err = -EBUSY;
-                goto err_free_mem;
-        }
-
-        kbc->mmio = ioremap(res->start, resource_size(res));
+        kbc->mmio = devm_request_and_ioremap(&pdev->dev, res);
         if (!kbc->mmio) {
-                dev_err(&pdev->dev, "failed to remap I/O memory\n");
-                err = -ENXIO;
-                goto err_free_mem_region;
+                dev_err(&pdev->dev, "Cannot request memregion/iomap address\n");
+                return -EBUSY;
         }
 
-        kbc->clk = clk_get(&pdev->dev, NULL);
+        kbc->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(kbc->clk)) {
                 dev_err(&pdev->dev, "failed to get keyboard clock\n");
-                err = PTR_ERR(kbc->clk);
-                goto err_iounmap;
+                return PTR_ERR(kbc->clk);
         }
 
         /*
@@ -774,37 +626,38 @@ static int tegra_kbc_probe(struct platform_device *pdev)
          * the rows. There is an additional delay before the row scanning
          * starts. The repoll delay is computed in milliseconds.
          */
-        debounce_cnt = min(pdata->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
+        debounce_cnt = min(kbc->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
         scan_time_rows = (KBC_ROW_SCAN_TIME + debounce_cnt) * num_rows;
-        kbc->repoll_dly = KBC_ROW_SCAN_DLY + scan_time_rows + pdata->repeat_cnt;
+        kbc->repoll_dly = KBC_ROW_SCAN_DLY + scan_time_rows + kbc->repeat_cnt;
         kbc->repoll_dly = DIV_ROUND_UP(kbc->repoll_dly, KBC_CYCLE_MS);
 
-        kbc->wakeup_key = pdata->wakeup_key;
-        kbc->use_fn_map = pdata->use_fn_map;
-        kbc->use_ghost_filter = pdata->use_ghost_filter;
+        kbc->idev->name = pdev->name;
+        kbc->idev->id.bustype = BUS_HOST;
+        kbc->idev->dev.parent = &pdev->dev;
+        kbc->idev->open = tegra_kbc_open;
+        kbc->idev->close = tegra_kbc_close;
 
-        input_dev->name = pdev->name;
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->dev.parent = &pdev->dev;
-        input_dev->open = tegra_kbc_open;
-        input_dev->close = tegra_kbc_close;
+        if (kbc->keymap_data && kbc->use_fn_map)
+                keymap_rows *= 2;
 
-        err = tegra_kbd_setup_keymap(kbc);
+        err = matrix_keypad_build_keymap(kbc->keymap_data, NULL,
+                                         keymap_rows, KBC_MAX_COL,
+                                         kbc->keycode, kbc->idev);
         if (err) {
                 dev_err(&pdev->dev, "failed to setup keymap\n");
-                goto err_put_clk;
+                return err;
         }
 
-        __set_bit(EV_REP, input_dev->evbit);
-        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+        __set_bit(EV_REP, kbc->idev->evbit);
+        input_set_capability(kbc->idev, EV_MSC, MSC_SCAN);
 
-        input_set_drvdata(input_dev, kbc);
+        input_set_drvdata(kbc->idev, kbc);
 
-        err = request_irq(kbc->irq, tegra_kbc_isr,
+        err = devm_request_irq(&pdev->dev, kbc->irq, tegra_kbc_isr,
                           IRQF_NO_SUSPEND | IRQF_TRIGGER_HIGH, pdev->name, kbc);
         if (err) {
                 dev_err(&pdev->dev, "failed to request keyboard IRQ\n");
-                goto err_put_clk;
+                return err;
         }
 
         disable_irq(kbc->irq);
@@ -812,60 +665,28 @@ static int tegra_kbc_probe(struct platform_device *pdev)
         err = input_register_device(kbc->idev);
         if (err) {
                 dev_err(&pdev->dev, "failed to register input device\n");
-                goto err_free_irq;
+                return err;
         }
 
         platform_set_drvdata(pdev, kbc);
-        device_init_wakeup(&pdev->dev, pdata->wakeup);
+        device_init_wakeup(&pdev->dev, kbc->wakeup);
 
         return 0;
-
-err_free_irq:
-        free_irq(kbc->irq, pdev);
-err_put_clk:
-        clk_put(kbc->clk);
-err_iounmap:
-        iounmap(kbc->mmio);
-err_free_mem_region:
-        release_mem_region(res->start, resource_size(res));
-err_free_mem:
-        input_free_device(input_dev);
-        kfree(kbc);
-err_free_pdata:
-        if (!pdev->dev.platform_data)
-                kfree(pdata);
-
-        return err;
 }
 
-static int tegra_kbc_remove(struct platform_device *pdev)
+#ifdef CONFIG_PM_SLEEP
+static void tegra_kbc_set_keypress_interrupt(struct tegra_kbc *kbc, bool enable)
 {
-        struct tegra_kbc *kbc = platform_get_drvdata(pdev);
-        struct resource *res;
-
-        platform_set_drvdata(pdev, NULL);
-
-        free_irq(kbc->irq, pdev);
-        clk_put(kbc->clk);
-
-        input_unregister_device(kbc->idev);
-        iounmap(kbc->mmio);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, resource_size(res));
-
-        /*
-         * If we do not have platform data attached to the device we
-         * allocated it ourselves and thus need to free it.
-         */
-        if (!pdev->dev.platform_data)
-                kfree(kbc->pdata);
-
-        kfree(kbc);
+        u32 val;
 
-        return 0;
+        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);
 }
 
-#ifdef CONFIG_PM_SLEEP
 static int tegra_kbc_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -954,7 +775,6 @@ MODULE_DEVICE_TABLE(of, tegra_kbc_of_match);
 
 static struct platform_driver tegra_kbc_driver = {
         .probe          = tegra_kbc_probe,
-        .remove         = tegra_kbc_remove,
         .driver = {
                 .name   = "tegra-kbc",
                 .owner  = THIS_MODULE,