Merge branch 'next' into for-linus

Prepare first round of input updates for 4.9 merge window.

11 files changed, 403 insertions, 390 deletions

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 2fb1f430a431..507981356921 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -305,19 +305,6 @@ config TOUCHSCREEN_EGALAX_SERIAL
           To compile this driver as a module, choose M here: the
           module will be called egalax_ts_serial.
 
-config TOUCHSCREEN_FT6236
-        tristate "FT6236 I2C touchscreen"
-        depends on I2C
-        depends on GPIOLIB || COMPILE_TEST
-        help
-          Say Y here to enable support for the I2C connected FT6x06 and
-          FT6x36 family of capacitive touchscreen drivers.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called ft6236.
-
 config TOUCHSCREEN_FUJITSU
         tristate "Fujitsu serial touchscreen"
         select SERIO
@@ -397,6 +384,18 @@ config TOUCHSCREEN_GUNZE
           To compile this driver as a module, choose M here: the
           module will be called gunze.
 
+config TOUCHSCREEN_EKTF2127
+        tristate "Elan eKTF2127 I2C touchscreen"
+        depends on I2C
+        help
+          Say Y here if you have an Elan eKTF2127 touchscreen
+          connected to your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ektf2127.
+
 config TOUCHSCREEN_ELAN
         tristate "Elan eKTH I2C touchscreen"
         depends on I2C
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index b4373d6be402..81b86451782d 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -32,11 +32,11 @@ obj-$(CONFIG_TOUCHSCREEN_EDT_FT5X06)	+= edt-ft5x06.o
 obj-$(CONFIG_TOUCHSCREEN_HAMPSHIRE)     += hampshire.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE)         += gunze.o
 obj-$(CONFIG_TOUCHSCREEN_EETI)          += eeti_ts.o
+obj-$(CONFIG_TOUCHSCREEN_EKTF2127)      += ektf2127.o
 obj-$(CONFIG_TOUCHSCREEN_ELAN)          += elants_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_ELO)           += elo.o
 obj-$(CONFIG_TOUCHSCREEN_EGALAX)        += egalax_ts.o
 obj-$(CONFIG_TOUCHSCREEN_EGALAX_SERIAL) += egalax_ts_serial.o
-obj-$(CONFIG_TOUCHSCREEN_FT6236)        += ft6236.o
 obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
 obj-$(CONFIG_TOUCHSCREEN_GOODIX)        += goodix.o
 obj-$(CONFIG_TOUCHSCREEN_ILI210X)       += ili210x.o
diff --git a/drivers/input/touchscreen/edt-ft5x06.c b/drivers/input/touchscreen/edt-ft5x06.c
index 703e295a37ed..28466e358fee 100644
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ b/drivers/input/touchscreen/edt-ft5x06.c
@@ -1063,9 +1063,15 @@ static const struct edt_i2c_chip_data edt_ft5506_data = {
         .max_support_points = 10,
 };
 
+static const struct edt_i2c_chip_data edt_ft6236_data = {
+        .max_support_points = 2,
+};
+
 static const struct i2c_device_id edt_ft5x06_ts_id[] = {
         { .name = "edt-ft5x06", .driver_data = (long)&edt_ft5x06_data },
         { .name = "edt-ft5506", .driver_data = (long)&edt_ft5506_data },
+        /* Note no edt- prefix for compatibility with the ft6236.c driver */
+        { .name = "ft6236", .driver_data = (long)&edt_ft6236_data },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);
@@ -1076,6 +1082,8 @@ static const struct of_device_id edt_ft5x06_of_match[] = {
         { .compatible = "edt,edt-ft5306", .data = &edt_ft5x06_data },
         { .compatible = "edt,edt-ft5406", .data = &edt_ft5x06_data },
         { .compatible = "edt,edt-ft5506", .data = &edt_ft5506_data },
+        /* Note focaltech vendor prefix for compatibility with ft6236.c */
+        { .compatible = "focaltech,ft6236", .data = &edt_ft6236_data },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, edt_ft5x06_of_match);
diff --git a/drivers/input/touchscreen/ektf2127.c b/drivers/input/touchscreen/ektf2127.c
new file mode 100644
index 000000000000..0ed34ff787ce
--- /dev/null
+++ b/drivers/input/touchscreen/ektf2127.c
@@ -0,0 +1,336 @@
+/*
+ * Driver for ELAN eKTF2127 i2c touchscreen controller
+ *
+ * For this driver the layout of the Chipone icn8318 i2c
+ * touchscreencontroller is used.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Author:
+ * Michel Verlaan <michel.verl@gmail.com>
+ * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com>
+ *
+ * Original chipone_icn8318 driver:
+ * Hans de Goede <hdegoede@redhat.com>
+ */
+
+#include <linux/gpio/consumer.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/delay.h>
+
+/* Packet header defines (first byte of data send / received) */
+#define EKTF2127_NOISE                  0x40
+#define EKTF2127_RESPONSE               0x52
+#define EKTF2127_REQUEST                0x53
+#define EKTF2127_HELLO                  0x55
+#define EKTF2127_REPORT                 0x5d
+#define EKTF2127_CALIB_DONE             0x66
+
+/* Register defines (second byte of data send / received) */
+#define EKTF2127_ENV_NOISY              0x41
+#define EKTF2127_HEIGHT                 0x60
+#define EKTF2127_WIDTH                  0x63
+
+/* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */
+#define EKTF2127_TOUCH_REPORT_SIZE      21
+#define EKTF2127_MAX_TOUCHES            5
+
+struct ektf2127_ts {
+        struct i2c_client *client;
+        struct input_dev *input;
+        struct gpio_desc *power_gpios;
+        struct touchscreen_properties prop;
+};
+
+static void ektf2127_parse_coordinates(const u8* buf, unsigned int touch_count,
+                                       struct input_mt_pos *touches)
+{
+        int index = 0;
+        int i;
+
+        for (i = 0; i < touch_count; i++) {
+                index = 2 + i * 3;
+
+                touches[i].x = (buf[index] & 0x0f);
+                touches[i].x <<= 8;
+                touches[i].x |= buf[index + 2];
+
+                touches[i].y = (buf[index] & 0xf0);
+                touches[i].y <<= 4;
+                touches[i].y |= buf[index + 1];
+        }
+}
+
+static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf)
+{
+        struct input_mt_pos touches[EKTF2127_MAX_TOUCHES];
+        int slots[EKTF2127_MAX_TOUCHES];
+        unsigned int touch_count, i;
+
+        touch_count = buf[1] & 0x07;
+        if (touch_count > EKTF2127_MAX_TOUCHES) {
+                dev_err(&ts->client->dev,
+                        "Too many touches %d > %d\n",
+                        touch_count, EKTF2127_MAX_TOUCHES);
+                touch_count = EKTF2127_MAX_TOUCHES;
+        }
+
+        ektf2127_parse_coordinates(buf, touch_count, touches);
+        input_mt_assign_slots(ts->input, slots, touches,
+                              touch_count, 0);
+
+        for (i = 0; i < touch_count; i++) {
+                input_mt_slot(ts->input, slots[i]);
+                input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
+                touchscreen_report_pos(ts->input, &ts->prop,
+                                       touches[i].x, touches[i].y, true);
+        }
+
+        input_mt_sync_frame(ts->input);
+        input_sync(ts->input);
+}
+
+static irqreturn_t ektf2127_irq(int irq, void *dev_id)
+{
+        struct ektf2127_ts *ts = dev_id;
+        struct device *dev = &ts->client->dev;
+        char buf[EKTF2127_TOUCH_REPORT_SIZE];
+        int ret;
+
+        ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE);
+        if (ret != EKTF2127_TOUCH_REPORT_SIZE) {
+                dev_err(dev, "Error reading touch data: %d\n", ret);
+                goto out;
+        }
+
+        switch (buf[0]) {
+        case EKTF2127_REPORT:
+                ektf2127_report_event(ts, buf);
+                break;
+
+        case EKTF2127_NOISE:
+                if (buf[1] == EKTF2127_ENV_NOISY)
+                        dev_dbg(dev, "Environment is electrically noisy\n");
+                break;
+
+        case EKTF2127_HELLO:
+        case EKTF2127_CALIB_DONE:
+                break;
+
+        default:
+                dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]);
+                break;
+        }
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int ektf2127_start(struct input_dev *dev)
+{
+        struct ektf2127_ts *ts = input_get_drvdata(dev);
+
+        enable_irq(ts->client->irq);
+        gpiod_set_value_cansleep(ts->power_gpios, 1);
+
+        return 0;
+}
+
+static void ektf2127_stop(struct input_dev *dev)
+{
+        struct ektf2127_ts *ts = input_get_drvdata(dev);
+
+        disable_irq(ts->client->irq);
+        gpiod_set_value_cansleep(ts->power_gpios, 0);
+}
+
+static int __maybe_unused ektf2127_suspend(struct device *dev)
+{
+        struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
+
+        mutex_lock(&ts->input->mutex);
+        if (ts->input->users)
+                ektf2127_stop(ts->input);
+        mutex_unlock(&ts->input->mutex);
+
+        return 0;
+}
+
+static int __maybe_unused ektf2127_resume(struct device *dev)
+{
+        struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
+
+        mutex_lock(&ts->input->mutex);
+        if (ts->input->users)
+                ektf2127_start(ts->input);
+        mutex_unlock(&ts->input->mutex);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend,
+                         ektf2127_resume);
+
+static int ektf2127_query_dimension(struct i2c_client *client, bool width)
+{
+        struct device *dev = &client->dev;
+        const char *what = width ? "width" : "height";
+        u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
+        u8 buf[4];
+        int ret;
+        int error;
+
+        /* Request dimension */
+        buf[0] = EKTF2127_REQUEST;
+        buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        ret = i2c_master_send(client, buf, sizeof(buf));
+        if (ret != sizeof(buf)) {
+                error = ret < 0 ? ret : -EIO;
+                dev_err(dev, "Failed to request %s: %d\n", what, error);
+                return error;
+        }
+
+        msleep(20);
+
+        /* Read response */
+        ret = i2c_master_recv(client, buf, sizeof(buf));
+        if (ret != sizeof(buf)) {
+                error = ret < 0 ? ret : -EIO;
+                dev_err(dev, "Failed to receive %s data: %d\n", what, error);
+                return error;
+        }
+
+        if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) {
+                dev_err(dev, "Unexpected %s data: %#02x %#02x\n",
+                        what, buf[0], buf[1]);
+                return -EIO;
+        }
+
+        return (((buf[3] & 0xf0) << 4) | buf[2]) - 1;
+}
+
+static int ektf2127_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct ektf2127_ts *ts;
+        struct input_dev *input;
+        u8 buf[4];
+        int max_x, max_y;
+        int error;
+
+        if (!client->irq) {
+                dev_err(dev, "Error no irq specified\n");
+                return -EINVAL;
+        }
+
+        ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
+        if (!ts)
+                return -ENOMEM;
+
+        /* This requests the gpio *and* turns on the touchscreen controller */
+        ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
+        if (IS_ERR(ts->power_gpios)) {
+                error = PTR_ERR(ts->power_gpios);
+                if (error != -EPROBE_DEFER)
+                        dev_err(dev, "Error getting power gpio: %d\n", error);
+                return error;
+        }
+
+        input = devm_input_allocate_device(dev);
+        if (!input)
+                return -ENOMEM;
+
+        input->name = client->name;
+        input->id.bustype = BUS_I2C;
+        input->open = ektf2127_start;
+        input->close = ektf2127_stop;
+
+        ts->client = client;
+
+        /* Read hello (ignore result, depends on initial power state) */
+        msleep(20);
+        i2c_master_recv(ts->client, buf, sizeof(buf));
+
+        /* Read resolution from chip */
+        max_x = ektf2127_query_dimension(client, true);
+        if (max_x < 0)
+                return max_x;
+
+        max_y = ektf2127_query_dimension(client, false);
+        if (max_y < 0)
+                return max_y;
+
+        input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
+        input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
+        touchscreen_parse_properties(input, true, &ts->prop);
+
+        error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES,
+                                    INPUT_MT_DIRECT |
+                                        INPUT_MT_DROP_UNUSED |
+                                        INPUT_MT_TRACK);
+        if (error)
+                return error;
+
+        ts->input = input;
+        input_set_drvdata(input, ts);
+
+        error = devm_request_threaded_irq(dev, client->irq,
+                                          NULL, ektf2127_irq,
+                                          IRQF_ONESHOT, client->name, ts);
+        if (error) {
+                dev_err(dev, "Error requesting irq: %d\n", error);
+                return error;
+        }
+
+        /* Stop device till opened */
+        ektf2127_stop(ts->input);
+
+        error = input_register_device(input);
+        if (error)
+                return error;
+
+        i2c_set_clientdata(client, ts);
+
+        return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id ektf2127_of_match[] = {
+        { .compatible = "elan,ektf2127" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, ektf2127_of_match);
+#endif
+
+static const struct i2c_device_id ektf2127_i2c_id[] = {
+        { "ektf2127", 0 },
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id);
+
+static struct i2c_driver ektf2127_driver = {
+        .driver = {
+                .name   = "elan_ektf2127",
+                .pm     = &ektf2127_pm_ops,
+                .of_match_table = of_match_ptr(ektf2127_of_match),
+        },
+        .probe = ektf2127_probe,
+        .id_table = ektf2127_i2c_id,
+};
+module_i2c_driver(ektf2127_driver);
+
+MODULE_DESCRIPTION("ELAN eKTF2127 I2C Touchscreen Driver");
+MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/elants_i2c.c b/drivers/input/touchscreen/elants_i2c.c
index ac09855fa435..02aec284deca 100644
--- a/drivers/input/touchscreen/elants_i2c.c
+++ b/drivers/input/touchscreen/elants_i2c.c
@@ -298,7 +298,7 @@ static u16 elants_i2c_parse_version(u8 *buf)
         return get_unaligned_be32(buf) >> 4;
 }
 
-static int elants_i2c_query_fw_id(struct elants_data *ts)
+static int elants_i2c_query_hw_version(struct elants_data *ts)
 {
         struct i2c_client *client = ts->client;
         int error, retry_cnt;
@@ -318,8 +318,13 @@ static int elants_i2c_query_fw_id(struct elants_data *ts)
                         error, (int)sizeof(resp), resp);
         }
 
-        dev_err(&client->dev,
-                "Failed to read fw id or fw id is invalid\n");
+        if (error) {
+                dev_err(&client->dev,
+                        "Failed to read fw id: %d\n", error);
+                return error;
+        }
+
+        dev_err(&client->dev, "Invalid fw id: %#04x\n", ts->hw_version);
 
         return -EINVAL;
 }
@@ -508,7 +513,7 @@ static int elants_i2c_fastboot(struct i2c_client *client)
 static int elants_i2c_initialize(struct elants_data *ts)
 {
         struct i2c_client *client = ts->client;
-        int error, retry_cnt;
+        int error, error2, retry_cnt;
         const u8 hello_packet[] = { 0x55, 0x55, 0x55, 0x55 };
         const u8 recov_packet[] = { 0x55, 0x55, 0x80, 0x80 };
         u8 buf[HEADER_SIZE];
@@ -553,18 +558,22 @@ static int elants_i2c_initialize(struct elants_data *ts)
                 }
         }
 
+        /* hw version is available even if device in recovery state */
+        error2 = elants_i2c_query_hw_version(ts);
         if (!error)
-                error = elants_i2c_query_fw_id(ts);
+                error = error2;
+
         if (!error)
                 error = elants_i2c_query_fw_version(ts);
+        if (!error)
+                error = elants_i2c_query_test_version(ts);
+        if (!error)
+                error = elants_i2c_query_bc_version(ts);
+        if (!error)
+                error = elants_i2c_query_ts_info(ts);
 
-        if (error) {
+        if (error)
                 ts->iap_mode = ELAN_IAP_RECOVERY;
-        } else {
-                elants_i2c_query_test_version(ts);
-                elants_i2c_query_bc_version(ts);
-                elants_i2c_query_ts_info(ts);
-        }
 
         return 0;
 }
diff --git a/drivers/input/touchscreen/ft6236.c b/drivers/input/touchscreen/ft6236.c
deleted file mode 100644
index d240d2e212bd..000000000000
--- a/drivers/input/touchscreen/ft6236.c
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
- * FocalTech FT6236 TouchScreen driver.
- *
- * Copyright (c) 2010  Focal tech Ltd.
- *
- * 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/delay.h>
-#include <linux/gpio/consumer.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/input/mt.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/property.h>
-
-#define FT6236_MAX_TOUCH_POINTS         2
-
-#define FT6236_REG_TH_GROUP             0x80
-#define FT6236_REG_PERIODACTIVE         0x88
-#define FT6236_REG_LIB_VER_H            0xa1
-#define FT6236_REG_LIB_VER_L            0xa2
-#define FT6236_REG_CIPHER               0xa3
-#define FT6236_REG_FIRMID               0xa6
-#define FT6236_REG_FOCALTECH_ID         0xa8
-#define FT6236_REG_RELEASE_CODE_ID      0xaf
-
-#define FT6236_EVENT_PRESS_DOWN         0
-#define FT6236_EVENT_LIFT_UP            1
-#define FT6236_EVENT_CONTACT            2
-#define FT6236_EVENT_NO_EVENT           3
-
-struct ft6236_data {
-        struct i2c_client *client;
-        struct input_dev *input;
-        struct gpio_desc *reset_gpio;
-        u32 max_x;
-        u32 max_y;
-        bool invert_x;
-        bool invert_y;
-        bool swap_xy;
-};
-
-/*
- * This struct is a touchpoint as stored in hardware.  Note that the id,
- * as well as the event, are stored in the upper nybble of the hi byte.
- */
-struct ft6236_touchpoint {
-        union {
-                u8 xhi;
-                u8 event;
-        };
-        u8 xlo;
-        union {
-                u8 yhi;
-                u8 id;
-        };
-        u8 ylo;
-        u8 weight;
-        u8 misc;
-} __packed;
-
-/* This packet represents the register map as read from offset 0 */
-struct ft6236_packet {
-        u8 dev_mode;
-        u8 gest_id;
-        u8 touches;
-        struct ft6236_touchpoint points[FT6236_MAX_TOUCH_POINTS];
-} __packed;
-
-static int ft6236_read(struct i2c_client *client, u8 reg, u8 len, void *data)
-{
-        int error;
-
-        error = i2c_smbus_read_i2c_block_data(client, reg, len, data);
-        if (error < 0)
-                return error;
-
-        if (error != len)
-                return -EIO;
-
-        return 0;
-}
-
-static irqreturn_t ft6236_interrupt(int irq, void *dev_id)
-{
-        struct ft6236_data *ft6236 = dev_id;
-        struct device *dev = &ft6236->client->dev;
-        struct input_dev *input = ft6236->input;
-        struct ft6236_packet buf;
-        u8 touches;
-        int i, error;
-
-        error = ft6236_read(ft6236->client, 0, sizeof(buf), &buf);
-        if (error) {
-                dev_err(dev, "read touchdata failed %d\n", error);
-                return IRQ_HANDLED;
-        }
-
-        touches = buf.touches & 0xf;
-        if (touches > FT6236_MAX_TOUCH_POINTS) {
-                dev_dbg(dev,
-                        "%d touch points reported, only %d are supported\n",
-                        touches, FT6236_MAX_TOUCH_POINTS);
-                touches = FT6236_MAX_TOUCH_POINTS;
-        }
-
-        for (i = 0; i < touches; i++) {
-                struct ft6236_touchpoint *point = &buf.points[i];
-                u16 x = ((point->xhi & 0xf) << 8) | buf.points[i].xlo;
-                u16 y = ((point->yhi & 0xf) << 8) | buf.points[i].ylo;
-                u8 event = point->event >> 6;
-                u8 id = point->id >> 4;
-                bool act = (event == FT6236_EVENT_PRESS_DOWN ||
-                            event == FT6236_EVENT_CONTACT);
-
-                input_mt_slot(input, id);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER, act);
-                if (!act)
-                        continue;
-
-                if (ft6236->invert_x)
-                        x = ft6236->max_x - x;
-
-                if (ft6236->invert_y)
-                        y = ft6236->max_y - y;
-
-                if (ft6236->swap_xy) {
-                        input_report_abs(input, ABS_MT_POSITION_X, y);
-                        input_report_abs(input, ABS_MT_POSITION_Y, x);
-                } else {
-                        input_report_abs(input, ABS_MT_POSITION_X, x);
-                        input_report_abs(input, ABS_MT_POSITION_Y, y);
-                }
-        }
-
-        input_mt_sync_frame(input);
-        input_sync(input);
-
-        return IRQ_HANDLED;
-}
-
-static u8 ft6236_debug_read_byte(struct ft6236_data *ft6236, u8 reg)
-{
-        struct i2c_client *client = ft6236->client;
-        u8 val = 0;
-        int error;
-
-        error = ft6236_read(client, reg, 1, &val);
-        if (error)
-                dev_dbg(&client->dev,
-                        "error reading register 0x%02x: %d\n", reg, error);
-
-        return val;
-}
-
-static void ft6236_debug_info(struct ft6236_data *ft6236)
-{
-        struct device *dev = &ft6236->client->dev;
-
-        dev_dbg(dev, "Touch threshold is %d\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_TH_GROUP) * 4);
-        dev_dbg(dev, "Report rate is %dHz\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_PERIODACTIVE) * 10);
-        dev_dbg(dev, "Firmware library version 0x%02x%02x\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_LIB_VER_H),
-                ft6236_debug_read_byte(ft6236, FT6236_REG_LIB_VER_L));
-        dev_dbg(dev, "Firmware version 0x%02x\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_FIRMID));
-        dev_dbg(dev, "Chip vendor ID 0x%02x\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_CIPHER));
-        dev_dbg(dev, "CTPM vendor ID 0x%02x\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_FOCALTECH_ID));
-        dev_dbg(dev, "Release code version 0x%02x\n",
-                ft6236_debug_read_byte(ft6236, FT6236_REG_RELEASE_CODE_ID));
-}
-
-static void ft6236_reset(struct ft6236_data *ft6236)
-{
-        if (!ft6236->reset_gpio)
-                return;
-
-        gpiod_set_value_cansleep(ft6236->reset_gpio, 1);
-        usleep_range(5000, 20000);
-        gpiod_set_value_cansleep(ft6236->reset_gpio, 0);
-        msleep(300);
-}
-
-static int ft6236_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
-{
-        struct device *dev = &client->dev;
-        struct ft6236_data *ft6236;
-        struct input_dev *input;
-        u32 fuzz_x = 0, fuzz_y = 0;
-        u8 val;
-        int error;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
-                return -ENXIO;
-
-        if (!client->irq) {
-                dev_err(dev, "irq is missing\n");
-                return -EINVAL;
-        }
-
-        ft6236 = devm_kzalloc(dev, sizeof(*ft6236), GFP_KERNEL);
-        if (!ft6236)
-                return -ENOMEM;
-
-        ft6236->client = client;
-        ft6236->reset_gpio = devm_gpiod_get_optional(dev, "reset",
-                                                     GPIOD_OUT_LOW);
-        if (IS_ERR(ft6236->reset_gpio)) {
-                error = PTR_ERR(ft6236->reset_gpio);
-                if (error != -EPROBE_DEFER)
-                        dev_err(dev, "error getting reset gpio: %d\n", error);
-                return error;
-        }
-
-        ft6236_reset(ft6236);
-
-        /* verify that the controller is present */
-        error = ft6236_read(client, 0x00, 1, &val);
-        if (error) {
-                dev_err(dev, "failed to read from controller: %d\n", error);
-                return error;
-        }
-
-        ft6236_debug_info(ft6236);
-
-        input = devm_input_allocate_device(dev);
-        if (!input)
-                return -ENOMEM;
-
-        ft6236->input = input;
-        input->name = client->name;
-        input->id.bustype = BUS_I2C;
-
-        if (device_property_read_u32(dev, "touchscreen-size-x",
-                                     &ft6236->max_x) ||
-            device_property_read_u32(dev, "touchscreen-size-y",
-                                     &ft6236->max_y)) {
-                dev_err(dev, "touchscreen-size-x and/or -y missing\n");
-                return -EINVAL;
-        }
-
-        device_property_read_u32(dev, "touchscreen-fuzz-x", &fuzz_x);
-        device_property_read_u32(dev, "touchscreen-fuzz-y", &fuzz_y);
-        ft6236->invert_x = device_property_read_bool(dev,
-                                                     "touchscreen-inverted-x");
-        ft6236->invert_y = device_property_read_bool(dev,
-                                                     "touchscreen-inverted-y");
-        ft6236->swap_xy = device_property_read_bool(dev,
-                                                    "touchscreen-swapped-x-y");
-
-        if (ft6236->swap_xy) {
-                input_set_abs_params(input, ABS_MT_POSITION_X, 0,
-                                     ft6236->max_y, fuzz_y, 0);
-                input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
-                                     ft6236->max_x, fuzz_x, 0);
-        } else {
-                input_set_abs_params(input, ABS_MT_POSITION_X, 0,
-                                     ft6236->max_x, fuzz_x, 0);
-                input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
-                                     ft6236->max_y, fuzz_y, 0);
-        }
-
-        error = input_mt_init_slots(input, FT6236_MAX_TOUCH_POINTS,
-                                    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
-        if (error)
-                return error;
-
-        error = devm_request_threaded_irq(dev, client->irq, NULL,
-                                          ft6236_interrupt, IRQF_ONESHOT,
-                                          client->name, ft6236);
-        if (error) {
-                dev_err(dev, "request irq %d failed: %d\n", client->irq, error);
-                return error;
-        }
-
-        error = input_register_device(input);
-        if (error) {
-                dev_err(dev, "failed to register input device: %d\n", error);
-                return error;
-        }
-
-        return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id ft6236_of_match[] = {
-        { .compatible = "focaltech,ft6236", },
-        { }
-};
-MODULE_DEVICE_TABLE(of, ft6236_of_match);
-#endif
-
-static const struct i2c_device_id ft6236_id[] = {
-        { "ft6236", },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, ft6236_id);
-
-static struct i2c_driver ft6236_driver = {
-        .driver = {
-                .name = "ft6236",
-                .of_match_table = of_match_ptr(ft6236_of_match),
-        },
-        .probe = ft6236_probe,
-        .id_table = ft6236_id,
-};
-module_i2c_driver(ft6236_driver);
-
-MODULE_AUTHOR("Sean Cross <xobs@kosagi.com>");
-MODULE_AUTHOR("Noralf Trønnes <noralf@tronnes.org>");
-MODULE_DESCRIPTION("FocalTech FT6236 TouchScreen driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/jornada720_ts.c b/drivers/input/touchscreen/jornada720_ts.c
index ea3b6a5b83e6..729b3c89324c 100644
--- a/drivers/input/touchscreen/jornada720_ts.c
+++ b/drivers/input/touchscreen/jornada720_ts.c
@@ -13,6 +13,7 @@
  * HP Jornada 710/720/729 Touchscreen Driver
  */
 
+#include <linux/gpio/consumer.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
@@ -20,9 +21,7 @@
 #include <linux/slab.h>
 #include <linux/io.h>
 
-#include <mach/hardware.h>
 #include <mach/jornada720.h>
-#include <mach/irqs.h>
 
 MODULE_AUTHOR("Kristoffer Ericson <kristoffer.ericson@gmail.com>");
 MODULE_DESCRIPTION("HP Jornada 710/720/728 touchscreen driver");
@@ -30,6 +29,7 @@ MODULE_LICENSE("GPL v2");
 
 struct jornada_ts {
         struct input_dev *dev;
+        struct gpio_desc *gpio;
         int x_data[4];          /* X sample values */
         int y_data[4];          /* Y sample values */
 };
@@ -71,8 +71,8 @@ static irqreturn_t jornada720_ts_interrupt(int irq, void *dev_id)
         struct input_dev *input = jornada_ts->dev;
         int x, y;
 
-        /* If GPIO_GPIO9 is set to high then report pen up */
-        if (GPLR & GPIO_GPIO(9)) {
+        /* If gpio is high then report pen up */
+        if (gpiod_get_value(jornada_ts->gpio)) {
                 input_report_key(input, BTN_TOUCH, 0);
                 input_sync(input);
         } else {
@@ -101,7 +101,7 @@ static int jornada720_ts_probe(struct platform_device *pdev)
 {
         struct jornada_ts *jornada_ts;
         struct input_dev *input_dev;
-        int error;
+        int error, irq;
 
         jornada_ts = devm_kzalloc(&pdev->dev, sizeof(*jornada_ts), GFP_KERNEL);
         if (!jornada_ts)
@@ -113,6 +113,14 @@ static int jornada720_ts_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, jornada_ts);
 
+        jornada_ts->gpio = devm_gpiod_get(&pdev->dev, "penup", GPIOD_IN);
+        if (IS_ERR(jornada_ts->gpio))
+                return PTR_ERR(jornada_ts->gpio);
+
+        irq = gpiod_to_irq(jornada_ts->gpio);
+        if (irq <= 0)
+                return irq < 0 ? irq : -EINVAL;
+
         jornada_ts->dev = input_dev;
 
         input_dev->name = "HP Jornada 7xx Touchscreen";
@@ -125,8 +133,7 @@ static int jornada720_ts_probe(struct platform_device *pdev)
         input_set_abs_params(input_dev, ABS_X, 270, 3900, 0, 0);
         input_set_abs_params(input_dev, ABS_Y, 180, 3700, 0, 0);
 
-        error = devm_request_irq(&pdev->dev, IRQ_GPIO9,
-                                 jornada720_ts_interrupt,
+        error = devm_request_irq(&pdev->dev, irq, jornada720_ts_interrupt,
                                  IRQF_TRIGGER_RISING,
                                  "HP7XX Touchscreen driver", pdev);
         if (error) {
diff --git a/drivers/input/touchscreen/mc13783_ts.c b/drivers/input/touchscreen/mc13783_ts.c
index 913e25a994b4..ef64f36c5ffc 100644
--- a/drivers/input/touchscreen/mc13783_ts.c
+++ b/drivers/input/touchscreen/mc13783_ts.c
@@ -37,7 +37,6 @@ struct mc13783_ts_priv {
         struct input_dev *idev;
         struct mc13xxx *mc13xxx;
         struct delayed_work work;
-        struct workqueue_struct *workq;
         unsigned int sample[4];
         struct mc13xxx_ts_platform_data *touch;
 };
@@ -54,7 +53,7 @@ static irqreturn_t mc13783_ts_handler(int irq, void *data)
          * be rescheduled for immediate execution here. However the rearm
          * delay is HZ / 50 which is acceptable.
          */
-        queue_delayed_work(priv->workq, &priv->work, 0);
+        schedule_delayed_work(&priv->work, 0);
 
         return IRQ_HANDLED;
 }
@@ -106,16 +105,18 @@ static void mc13783_ts_report_sample(struct mc13783_ts_priv *priv)
 
                         dev_dbg(&idev->dev, "report (%d, %d, %d)\n",
                                         x1, y1, 0x1000 - cr0);
-                        queue_delayed_work(priv->workq, &priv->work, HZ / 50);
-                } else
+                        schedule_delayed_work(&priv->work, HZ / 50);
+                } else {
                         dev_dbg(&idev->dev, "report release\n");
+                }
 
                 input_report_abs(idev, ABS_PRESSURE,
                                 cr0 ? 0x1000 - cr0 : cr0);
                 input_report_key(idev, BTN_TOUCH, cr0);
                 input_sync(idev);
-        } else
+        } else {
                 dev_dbg(&idev->dev, "discard event\n");
+        }
 }
 
 static void mc13783_ts_work(struct work_struct *work)
@@ -189,14 +190,6 @@ static int __init mc13783_ts_probe(struct platform_device *pdev)
                 goto err_free_mem;
         }
 
-        /*
-         * We need separate workqueue because mc13783_adc_do_conversion
-         * uses keventd and thus would deadlock.
-         */
-        priv->workq = create_singlethread_workqueue("mc13783_ts");
-        if (!priv->workq)
-                goto err_free_mem;
-
         idev->name = MC13783_TS_NAME;
         idev->dev.parent = &pdev->dev;
 
@@ -215,14 +208,12 @@ static int __init mc13783_ts_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(&pdev->dev,
                         "register input device failed with %d\n", ret);
-                goto err_destroy_wq;
+                goto err_free_mem;
         }
 
         platform_set_drvdata(pdev, priv);
         return 0;
 
-err_destroy_wq:
-        destroy_workqueue(priv->workq);
 err_free_mem:
         input_free_device(idev);
         kfree(priv);
@@ -233,7 +224,6 @@ static int mc13783_ts_remove(struct platform_device *pdev)
 {
         struct mc13783_ts_priv *priv = platform_get_drvdata(pdev);
 
-        destroy_workqueue(priv->workq);
         input_unregister_device(priv->idev);
         kfree(priv);
 
diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c
index d159e14f4d20..3bb0637d832e 100644
--- a/drivers/input/touchscreen/pixcir_i2c_ts.c
+++ b/drivers/input/touchscreen/pixcir_i2c_ts.c
@@ -11,10 +11,6 @@
  * 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.
- *
- * You should have received a copy of the GNU General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
 #include <linux/delay.h>
@@ -404,7 +400,6 @@ static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev)
         mutex_lock(&input->mutex);
 
         if (device_may_wakeup(&client->dev)) {
-
                 if (!input->users) {
                         ret = pixcir_stop(ts);
                         if (ret) {
@@ -431,13 +426,7 @@ static const struct of_device_id pixcir_of_match[];
 static int pixcir_parse_dt(struct device *dev,
                            struct pixcir_i2c_ts_data *tsdata)
 {
-        const struct of_device_id *match;
-
-        match = of_match_device(of_match_ptr(pixcir_of_match), dev);
-        if (!match)
-                return -EINVAL;
-
-        tsdata->chip = (const struct pixcir_i2c_chip_data *)match->data;
+        tsdata->chip = of_device_get_match_data(dev);
         if (!tsdata->chip)
                 return -EINVAL;
 
diff --git a/drivers/input/touchscreen/wdt87xx_i2c.c b/drivers/input/touchscreen/wdt87xx_i2c.c
index 73861ad22df4..a9132603ab34 100644
--- a/drivers/input/touchscreen/wdt87xx_i2c.c
+++ b/drivers/input/touchscreen/wdt87xx_i2c.c
@@ -23,7 +23,7 @@
 #include <asm/unaligned.h>
 
 #define WDT87XX_NAME            "wdt87xx_i2c"
-#define WDT87XX_DRV_VER         "0.9.7"
+#define WDT87XX_DRV_VER         "0.9.8"
 #define WDT87XX_FW_NAME         "wdt87xx_fw.bin"
 #define WDT87XX_CFG_NAME        "wdt87xx_cfg.bin"
 
@@ -157,6 +157,7 @@
 /* Controller requires minimum 300us between commands */
 #define WDT_COMMAND_DELAY_MS            2
 #define WDT_FLASH_WRITE_DELAY_MS        4
+#define WDT_FLASH_ERASE_DELAY_MS        200
 #define WDT_FW_RESET_TIME               2500
 
 struct wdt87xx_sys_param {
@@ -726,7 +727,7 @@ static int wdt87xx_write_firmware(struct i2c_client *client, const void *chunk)
                                 break;
                         }
 
-                        msleep(50);
+                        msleep(WDT_FLASH_ERASE_DELAY_MS);
 
                         error = wdt87xx_write_data(client, data, start_addr,
                                                    page_size);
diff --git a/drivers/input/touchscreen/wm97xx-core.c b/drivers/input/touchscreen/wm97xx-core.c
index 1534e9b0788c..90d6be3c26cc 100644
--- a/drivers/input/touchscreen/wm97xx-core.c
+++ b/drivers/input/touchscreen/wm97xx-core.c
@@ -500,7 +500,7 @@ static int wm97xx_ts_input_open(struct input_dev *idev)
 {
         struct wm97xx *wm = input_get_drvdata(idev);
 
-        wm->ts_workq = create_singlethread_workqueue("kwm97xx");
+        wm->ts_workq = alloc_ordered_workqueue("kwm97xx", 0);
         if (wm->ts_workq == NULL) {
                 dev_err(wm->dev,
                         "Failed to create workqueue\n");