Merge remote branch 'gcl/next' into next

9 files changed, 353 insertions, 57 deletions

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index e3f7fc6f9565..68f09a868434 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -534,76 +534,73 @@ static int handle_eviocgbit(struct input_dev *dev,
 }
 #undef OLD_KEY_MAX
 
-static int evdev_handle_get_keycode(struct input_dev *dev,
-                                    void __user *p, size_t size)
+static int evdev_handle_get_keycode(struct input_dev *dev, void __user *p)
 {
-        struct input_keymap_entry ke;
+        struct input_keymap_entry ke = {
+                .len    = sizeof(unsigned int),
+                .flags  = 0,
+        };
+        int __user *ip = (int __user *)p;
         int error;
 
-        memset(&ke, 0, sizeof(ke));
-
-        if (size == sizeof(unsigned int[2])) {
-                /* legacy case */
-                int __user *ip = (int __user *)p;
+        /* legacy case */
+        if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
+                return -EFAULT;
 
-                if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
-                        return -EFAULT;
+        error = input_get_keycode(dev, &ke);
+        if (error)
+                return error;
 
-                ke.len = sizeof(unsigned int);
-                ke.flags = 0;
+        if (put_user(ke.keycode, ip + 1))
+                return -EFAULT;
 
-                error = input_get_keycode(dev, &ke);
-                if (error)
-                        return error;
+        return 0;
+}
 
-                if (put_user(ke.keycode, ip + 1))
-                        return -EFAULT;
+static int evdev_handle_get_keycode_v2(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke;
+        int error;
 
-        } else {
-                size = min(size, sizeof(ke));
+        if (copy_from_user(&ke, p, sizeof(ke)))
+                return -EFAULT;
 
-                if (copy_from_user(&ke, p, size))
-                        return -EFAULT;
+        error = input_get_keycode(dev, &ke);
+        if (error)
+                return error;
 
-                error = input_get_keycode(dev, &ke);
-                if (error)
-                        return error;
+        if (copy_to_user(p, &ke, sizeof(ke)))
+                return -EFAULT;
 
-                if (copy_to_user(p, &ke, size))
-                        return -EFAULT;
-        }
         return 0;
 }
 
-static int evdev_handle_set_keycode(struct input_dev *dev,
-                                    void __user *p, size_t size)
+static int evdev_handle_set_keycode(struct input_dev *dev, void __user *p)
 {
-        struct input_keymap_entry ke;
-
-        memset(&ke, 0, sizeof(ke));
+        struct input_keymap_entry ke = {
+                .len    = sizeof(unsigned int),
+                .flags  = 0,
+        };
+        int __user *ip = (int __user *)p;
 
-        if (size == sizeof(unsigned int[2])) {
-                /* legacy case */
-                int __user *ip = (int __user *)p;
+        if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
+                return -EFAULT;
 
-                if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
-                        return -EFAULT;
+        if (get_user(ke.keycode, ip + 1))
+                return -EFAULT;
 
-                if (get_user(ke.keycode, ip + 1))
-                        return -EFAULT;
+        return input_set_keycode(dev, &ke);
+}
 
-                ke.len = sizeof(unsigned int);
-                ke.flags = 0;
+static int evdev_handle_set_keycode_v2(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke;
 
-        } else {
-                size = min(size, sizeof(ke));
+        if (copy_from_user(&ke, p, sizeof(ke)))
+                return -EFAULT;
 
-                if (copy_from_user(&ke, p, size))
-                        return -EFAULT;
-
-                if (ke.len > sizeof(ke.scancode))
-                        return -EINVAL;
-        }
+        if (ke.len > sizeof(ke.scancode))
+                return -EINVAL;
 
         return input_set_keycode(dev, &ke);
 }
@@ -669,6 +666,18 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                         return evdev_grab(evdev, client);
                 else
                         return evdev_ungrab(evdev, client);
+
+        case EVIOCGKEYCODE:
+                return evdev_handle_get_keycode(dev, p);
+
+        case EVIOCSKEYCODE:
+                return evdev_handle_set_keycode(dev, p);
+
+        case EVIOCGKEYCODE_V2:
+                return evdev_handle_get_keycode_v2(dev, p);
+
+        case EVIOCSKEYCODE_V2:
+                return evdev_handle_set_keycode_v2(dev, p);
         }
 
         size = _IOC_SIZE(cmd);
@@ -708,12 +717,6 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                         return -EFAULT;
 
                 return error;
-
-        case EVIOC_MASK_SIZE(EVIOCGKEYCODE):
-                return evdev_handle_get_keycode(dev, p, size);
-
-        case EVIOC_MASK_SIZE(EVIOCSKEYCODE):
-                return evdev_handle_set_keycode(dev, p, size);
         }
 
         /* Multi-number variable-length handlers */
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index d53b9e900234..27b6a3ce18ca 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -245,6 +245,7 @@ static struct tgfx __init *tgfx_probe(int parport, int *n_buttons, int n_devs)
                 goto err_free_tgfx;
         }
 
+        parport_put_port(pp);
         return tgfx;
 
  err_free_dev:
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index b8c51b9781db..3a87f3ba5f75 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -179,6 +179,22 @@ config KEYBOARD_GPIO
           To compile this driver as a module, choose M here: the
           module will be called gpio_keys.
 
+config KEYBOARD_GPIO_POLLED
+        tristate "Polled GPIO buttons"
+        depends on GENERIC_GPIO
+        select INPUT_POLLDEV
+        help
+          This driver implements support for buttons connected
+          to GPIO pins that are not capable of generating interrupts.
+
+          Say Y here if your device has buttons connected
+          directly to such GPIO pins.  Your board-specific
+          setup logic must also provide a platform device,
+          with configuration data saying which GPIOs are used.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gpio_keys_polled.
+
 config KEYBOARD_TCA6416
         tristate "TCA6416 Keypad Support"
         depends on I2C
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index a34452e8ebe2..622de73a445d 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_KEYBOARD_BFIN)		+= bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_DAVINCI)          += davinci_keyscan.o
 obj-$(CONFIG_KEYBOARD_EP93XX)           += ep93xx_keypad.o
 obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
+obj-$(CONFIG_KEYBOARD_GPIO_POLLED)      += gpio_keys_polled.o
 obj-$(CONFIG_KEYBOARD_TCA6416)          += tca6416-keypad.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
new file mode 100644
index 000000000000..4c17aff20657
--- /dev/null
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -0,0 +1,261 @@
+/*
+ *  Driver for buttons on GPIO lines not capable of generating interrupts
+ *
+ *  Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
+ *
+ *  This file was based on: /drivers/input/misc/cobalt_btns.c
+ *      Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *
+ *  also was based on: /drivers/input/keyboard/gpio_keys.c
+ *      Copyright 2005 Phil Blundell
+ *
+ *  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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/gpio_keys.h>
+
+#define DRV_NAME        "gpio-keys-polled"
+
+struct gpio_keys_button_data {
+        int last_state;
+        int count;
+        int threshold;
+        int can_sleep;
+};
+
+struct gpio_keys_polled_dev {
+        struct input_polled_dev *poll_dev;
+        struct device *dev;
+        struct gpio_keys_platform_data *pdata;
+        struct gpio_keys_button_data data[0];
+};
+
+static void gpio_keys_polled_check_state(struct input_dev *input,
+                                         struct gpio_keys_button *button,
+                                         struct gpio_keys_button_data *bdata)
+{
+        int state;
+
+        if (bdata->can_sleep)
+                state = !!gpio_get_value_cansleep(button->gpio);
+        else
+                state = !!gpio_get_value(button->gpio);
+
+        if (state != bdata->last_state) {
+                unsigned int type = button->type ?: EV_KEY;
+
+                input_event(input, type, button->code,
+                            !!(state ^ button->active_low));
+                input_sync(input);
+                bdata->count = 0;
+                bdata->last_state = state;
+        }
+}
+
+static void gpio_keys_polled_poll(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        struct input_dev *input = dev->input;
+        int i;
+
+        for (i = 0; i < bdev->pdata->nbuttons; i++) {
+                struct gpio_keys_button_data *bdata = &bdev->data[i];
+
+                if (bdata->count < bdata->threshold)
+                        bdata->count++;
+                else
+                        gpio_keys_polled_check_state(input, &pdata->buttons[i],
+                                                     bdata);
+        }
+}
+
+static void gpio_keys_polled_open(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+
+        if (pdata->enable)
+                pdata->enable(bdev->dev);
+}
+
+static void gpio_keys_polled_close(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+
+        if (pdata->disable)
+                pdata->disable(bdev->dev);
+}
+
+static int __devinit gpio_keys_polled_probe(struct platform_device *pdev)
+{
+        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct gpio_keys_polled_dev *bdev;
+        struct input_polled_dev *poll_dev;
+        struct input_dev *input;
+        int error;
+        int i;
+
+        if (!pdata || !pdata->poll_interval)
+                return -EINVAL;
+
+        bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) +
+                       pdata->nbuttons * sizeof(struct gpio_keys_button_data),
+                       GFP_KERNEL);
+        if (!bdev) {
+                dev_err(dev, "no memory for private data\n");
+                return -ENOMEM;
+        }
+
+        poll_dev = input_allocate_polled_device();
+        if (!poll_dev) {
+                dev_err(dev, "no memory for polled device\n");
+                error = -ENOMEM;
+                goto err_free_bdev;
+        }
+
+        poll_dev->private = bdev;
+        poll_dev->poll = gpio_keys_polled_poll;
+        poll_dev->poll_interval = pdata->poll_interval;
+        poll_dev->open = gpio_keys_polled_open;
+        poll_dev->close = gpio_keys_polled_close;
+
+        input = poll_dev->input;
+
+        input->evbit[0] = BIT(EV_KEY);
+        input->name = pdev->name;
+        input->phys = DRV_NAME"/input0";
+        input->dev.parent = &pdev->dev;
+
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = 0x0100;
+
+        for (i = 0; i < pdata->nbuttons; i++) {
+                struct gpio_keys_button *button = &pdata->buttons[i];
+                struct gpio_keys_button_data *bdata = &bdev->data[i];
+                unsigned int gpio = button->gpio;
+                unsigned int type = button->type ?: EV_KEY;
+
+                if (button->wakeup) {
+                        dev_err(dev, DRV_NAME " does not support wakeup\n");
+                        error = -EINVAL;
+                        goto err_free_gpio;
+                }
+
+                error = gpio_request(gpio,
+                                     button->desc ? button->desc : DRV_NAME);
+                if (error) {
+                        dev_err(dev, "unable to claim gpio %u, err=%d\n",
+                                gpio, error);
+                        goto err_free_gpio;
+                }
+
+                error = gpio_direction_input(gpio);
+                if (error) {
+                        dev_err(dev,
+                                "unable to set direction on gpio %u, err=%d\n",
+                                gpio, error);
+                        goto err_free_gpio;
+                }
+
+                bdata->can_sleep = gpio_cansleep(gpio);
+                bdata->last_state = -1;
+                bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
+                                                pdata->poll_interval);
+
+                input_set_capability(input, type, button->code);
+        }
+
+        bdev->poll_dev = poll_dev;
+        bdev->dev = dev;
+        bdev->pdata = pdata;
+        platform_set_drvdata(pdev, bdev);
+
+        error = input_register_polled_device(poll_dev);
+        if (error) {
+                dev_err(dev, "unable to register polled device, err=%d\n",
+                        error);
+                goto err_free_gpio;
+        }
+
+        /* report initial state of the buttons */
+        for (i = 0; i < pdata->nbuttons; i++)
+                gpio_keys_polled_check_state(input, &pdata->buttons[i],
+                                         &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);
+
+        platform_set_drvdata(pdev, NULL);
+        return error;
+}
+
+static int __devexit gpio_keys_polled_remove(struct platform_device *pdev)
+{
+        struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev);
+        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);
+
+        kfree(bdev);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver gpio_keys_polled_driver = {
+        .probe  = gpio_keys_polled_probe,
+        .remove = __devexit_p(gpio_keys_polled_remove),
+        .driver = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init gpio_keys_polled_init(void)
+{
+        return platform_driver_register(&gpio_keys_polled_driver);
+}
+
+static void __exit gpio_keys_polled_exit(void)
+{
+        platform_driver_unregister(&gpio_keys_polled_driver);
+}
+
+module_init(gpio_keys_polled_init);
+module_exit(gpio_keys_polled_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
+MODULE_DESCRIPTION("Polled GPIO Buttons driver");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index 613a3652f98f..0aefaa885871 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -51,7 +51,8 @@
 #define SYN_EXT_CAP_REQUESTS(c)         (((c) & 0x700000) >> 20)
 #define SYN_CAP_MULTI_BUTTON_NO(ec)     (((ec) & 0x00f000) >> 12)
 #define SYN_CAP_PRODUCT_ID(ec)          (((ec) & 0xff0000) >> 16)
-#define SYN_CAP_CLICKPAD(ex0c)          ((ex0c) & 0x100100)
+#define SYN_CAP_CLICKPAD(ex0c)          ((ex0c) & 0x100000) /* 1-button ClickPad */
+#define SYN_CAP_CLICKPAD2BTN(ex0c)      ((ex0c) & 0x000100) /* 2-button ClickPad */
 #define SYN_CAP_MAX_DIMENSIONS(ex0c)    ((ex0c) & 0x020000)
 
 /* synaptics modes query bits */
diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c
index 3c287dd879d3..4225f5d6b15f 100644
--- a/drivers/input/serio/gscps2.c
+++ b/drivers/input/serio/gscps2.c
@@ -358,7 +358,7 @@ static int __devinit gscps2_probe(struct parisc_device *dev)
         gscps2_reset(ps2port);
         ps2port->id = readb(ps2port->addr + GSC_ID) & 0x0f;
 
-        snprintf(serio->name, sizeof(serio->name), "GSC PS/2 %s",
+        snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s",
                  (ps2port->id == GSC_ID_KEYBOARD) ? "keyboard" : "mouse");
         strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
         serio->id.type          = SERIO_8042;
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index b3252ef1e279..435b0af401e4 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -1436,6 +1436,14 @@ static struct wacom_features wacom_features_0xD2 =
         { "Wacom Bamboo Craft",   WACOM_PKGLEN_BBFUN,     14720,  9200, 1023, 63, BAMBOO_PT };
 static struct wacom_features wacom_features_0xD3 =
         { "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN,     21648, 13530, 1023, 63, BAMBOO_PT };
+static const struct wacom_features wacom_features_0xD4 =
+        { "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200,  255, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xD8 =
+        { "Wacom Bamboo Comic 2FG", WACOM_PKGLEN_BBFUN,   21648, 13530, 1023, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xDA =
+        { "Wacom Bamboo 2FG 4x5 SE", WACOM_PKGLEN_BBFUN,  14720,  9200, 1023, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xDB =
+        { "Wacom Bamboo 2FG 6x8 SE", WACOM_PKGLEN_BBFUN,  21648, 13530, 1023, 63, BAMBOO_PT };
 
 #define USB_DEVICE_WACOM(prod)                                  \
         USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
@@ -1504,6 +1512,10 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0xD1) },
         { USB_DEVICE_WACOM(0xD2) },
         { USB_DEVICE_WACOM(0xD3) },
+        { USB_DEVICE_WACOM(0xD4) },
+        { USB_DEVICE_WACOM(0xD8) },
+        { USB_DEVICE_WACOM(0xDA) },
+        { USB_DEVICE_WACOM(0xDB) },
         { USB_DEVICE_WACOM(0xF0) },
         { USB_DEVICE_WACOM(0xCC) },
         { USB_DEVICE_WACOM(0x90) },
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index f45f80f6d336..73fd6642b681 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -178,6 +178,7 @@ static const struct usb_device_id usbtouch_devices[] = {
 
 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
         {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
+        {USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM},
 #endif
 
 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO