Patched in Tegra support.

65 files changed, 2284 insertions, 7169 deletions

diff --git a/drivers/input/touchscreen/88pm860x-ts.c b/drivers/input/touchscreen/88pm860x-ts.c
index c7068942ebe..b3aebc2166b 100644
--- a/drivers/input/touchscreen/88pm860x-ts.c
+++ b/drivers/input/touchscreen/88pm860x-ts.c
@@ -10,7 +10,6 @@
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/input.h>
@@ -114,69 +113,14 @@ static void pm860x_touch_close(struct input_dev *dev)
         pm860x_set_bits(touch->i2c, MEAS_EN3, data, 0);
 }
 
-#ifdef CONFIG_OF
-static int pm860x_touch_dt_init(struct platform_device *pdev,
-                                          struct pm860x_chip *chip,
-                                          int *res_x)
-{
-        struct device_node *np = pdev->dev.parent->of_node;
-        struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
-                                 : chip->companion;
-        int data, n, ret;
-        if (!np)
-                return -ENODEV;
-        np = of_find_node_by_name(np, "touch");
-        if (!np) {
-                dev_err(&pdev->dev, "Can't find touch node\n");
-                return -EINVAL;
-        }
-        /* set GPADC MISC1 register */
-        data = 0;
-        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-prebias", &n))
-                data |= (n << 1) & PM8607_GPADC_PREBIAS_MASK;
-        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-slot-cycle", &n))
-                data |= (n << 3) & PM8607_GPADC_SLOT_CYCLE_MASK;
-        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-off-scale", &n))
-                data |= (n << 5) & PM8607_GPADC_OFF_SCALE_MASK;
-        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-sw-cal", &n))
-                data |= (n << 7) & PM8607_GPADC_SW_CAL_MASK;
-        if (data) {
-                ret = pm860x_reg_write(i2c, PM8607_GPADC_MISC1, data);
-                if (ret < 0)
-                        return -EINVAL;
-        }
-        /* set tsi prebias time */
-        if (!of_property_read_u32(np, "marvell,88pm860x-tsi-prebias", &data)) {
-                ret = pm860x_reg_write(i2c, PM8607_TSI_PREBIAS, data);
-                if (ret < 0)
-                        return -EINVAL;
-        }
-        /* set prebias & prechg time of pen detect */
-        data = 0;
-        if (!of_property_read_u32(np, "marvell,88pm860x-pen-prebias", &n))
-                data |= n & PM8607_PD_PREBIAS_MASK;
-        if (!of_property_read_u32(np, "marvell,88pm860x-pen-prechg", &n))
-                data |= n & PM8607_PD_PRECHG_MASK;
-        if (data) {
-                ret = pm860x_reg_write(i2c, PM8607_PD_PREBIAS, data);
-                if (ret < 0)
-                        return -EINVAL;
-        }
-        of_property_read_u32(np, "marvell,88pm860x-resistor-X", res_x);
-        return 0;
-}
-#else
-#define pm860x_touch_dt_init(x, y, z)   (-1)
-#endif
-
-static int pm860x_touch_probe(struct platform_device *pdev)
+static int __devinit pm860x_touch_probe(struct platform_device *pdev)
 {
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-        struct pm860x_touch_pdata *pdata = pdev->dev.platform_data;
+        struct pm860x_platform_data *pm860x_pdata =             \
+                                pdev->dev.parent->platform_data;
+        struct pm860x_touch_pdata *pdata = NULL;
         struct pm860x_touch *touch;
-        struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
-                                 : chip->companion;
-        int irq, ret, res_x = 0, data = 0;
+        int irq, ret;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -184,55 +128,16 @@ static int pm860x_touch_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        if (pm860x_touch_dt_init(pdev, chip, &res_x)) {
-                if (pdata) {
-                        /* set GPADC MISC1 register */
-                        data = 0;
-                        data |= (pdata->gpadc_prebias << 1)
-                                & PM8607_GPADC_PREBIAS_MASK;
-                        data |= (pdata->slot_cycle << 3)
-                                & PM8607_GPADC_SLOT_CYCLE_MASK;
-                        data |= (pdata->off_scale << 5)
-                                & PM8607_GPADC_OFF_SCALE_MASK;
-                        data |= (pdata->sw_cal << 7)
-                                & PM8607_GPADC_SW_CAL_MASK;
-                        if (data) {
-                                ret = pm860x_reg_write(i2c,
-                                        PM8607_GPADC_MISC1, data);
-                                if (ret < 0)
-                                        return -EINVAL;
-                        }
-                        /* set tsi prebias time */
-                        if (pdata->tsi_prebias) {
-                                data = pdata->tsi_prebias;
-                                ret = pm860x_reg_write(i2c,
-                                        PM8607_TSI_PREBIAS, data);
-                                if (ret < 0)
-                                        return -EINVAL;
-                        }
-                        /* set prebias & prechg time of pen detect */
-                        data = 0;
-                        data |= pdata->pen_prebias
-                                & PM8607_PD_PREBIAS_MASK;
-                        data |= (pdata->pen_prechg << 5)
-                                & PM8607_PD_PRECHG_MASK;
-                        if (data) {
-                                ret = pm860x_reg_write(i2c,
-                                        PM8607_PD_PREBIAS, data);
-                                if (ret < 0)
-                                        return -EINVAL;
-                        }
-                        res_x = pdata->res_x;
-                } else {
-                        dev_err(&pdev->dev, "failed to get platform data\n");
-                        return -EINVAL;
-                }
+        if (!pm860x_pdata) {
+                dev_err(&pdev->dev, "platform data is missing\n");
+                return -EINVAL;
+        }
+
+        pdata = pm860x_pdata->touch;
+        if (!pdata) {
+                dev_err(&pdev->dev, "touchscreen data is missing\n");
+                return -EINVAL;
         }
-        /* enable GPADC */
-        ret = pm860x_set_bits(i2c, PM8607_GPADC_MISC1, PM8607_GPADC_EN,
-                              PM8607_GPADC_EN);
-        if (ret)
-                return ret;
 
         touch = kzalloc(sizeof(struct pm860x_touch), GFP_KERNEL);
         if (touch == NULL)
@@ -253,9 +158,9 @@ static int pm860x_touch_probe(struct platform_device *pdev)
         touch->idev->open = pm860x_touch_open;
         touch->idev->close = pm860x_touch_close;
         touch->chip = chip;
-        touch->i2c = i2c;
-        touch->irq = irq;
-        touch->res_x = res_x;
+        touch->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
+        touch->irq = irq + chip->irq_base;
+        touch->res_x = pdata->res_x;
         input_set_drvdata(touch->idev, touch);
 
         ret = request_threaded_irq(touch->irq, NULL, pm860x_touch_handler,
@@ -293,7 +198,7 @@ out:
         return ret;
 }
 
-static int pm860x_touch_remove(struct platform_device *pdev)
+static int __devexit pm860x_touch_remove(struct platform_device *pdev)
 {
         struct pm860x_touch *touch = platform_get_drvdata(pdev);
 
@@ -310,9 +215,20 @@ static struct platform_driver pm860x_touch_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = pm860x_touch_probe,
-        .remove = pm860x_touch_remove,
+        .remove = __devexit_p(pm860x_touch_remove),
 };
-module_platform_driver(pm860x_touch_driver);
+
+static int __init pm860x_touch_init(void)
+{
+        return platform_driver_register(&pm860x_touch_driver);
+}
+module_init(pm860x_touch_init);
+
+static void __exit pm860x_touch_exit(void)
+{
+        platform_driver_unregister(&pm860x_touch_driver);
+}
+module_exit(pm860x_touch_exit);
 
 MODULE_DESCRIPTION("Touchscreen driver for Marvell Semiconductor 88PM860x");
 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 515cfe79054..a8fc74f730d 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -98,18 +98,17 @@ config TOUCHSCREEN_ATMEL_MXT
           To compile this driver as a module, choose M here: the
           module will be called atmel_mxt_ts.
 
-config TOUCHSCREEN_AUO_PIXCIR
-        tristate "AUO in-cell touchscreen using Pixcir ICs"
-        depends on I2C
-        depends on GPIOLIB
+config TOUCHSCREEN_BITSY
+        tristate "Compaq iPAQ H3600 (Bitsy) touchscreen"
+        depends on SA1100_BITSY
+        select SERIO
         help
-          Say Y here if you have a AUO display with in-cell touchscreen
-          using Pixcir ICs.
+          Say Y here if you have the h3600 (Bitsy) touchscreen.
 
           If unsure, say N.
 
           To compile this driver as a module, choose M here: the
-          module will be called auo-pixcir-ts.
+          module will be called h3600_ts_input.
 
 config TOUCHSCREEN_BU21013
         tristate "BU21013 based touch panel controllers"
@@ -127,6 +126,7 @@ config TOUCHSCREEN_CY8CTMG110
         tristate "cy8ctmg110 touchscreen"
         depends on I2C
         depends on GPIOLIB
+
         help
           Say Y here if you have a cy8ctmg110 capacitive touchscreen on
           an AAVA device.
@@ -136,37 +136,6 @@ config TOUCHSCREEN_CY8CTMG110
           To compile this driver as a module, choose M here: the
           module will be called cy8ctmg110_ts.
 
-config TOUCHSCREEN_CYTTSP_CORE
-        tristate "Cypress TTSP touchscreen"
-        help
-          Say Y here if you have a touchscreen using controller from
-          the Cypress TrueTouch(tm) Standard Product family connected
-          to your system. You will also need to select appropriate
-          bus connection below.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called cyttsp_core.
-
-config TOUCHSCREEN_CYTTSP_I2C
-        tristate "support I2C bus connection"
-        depends on TOUCHSCREEN_CYTTSP_CORE && I2C
-        help
-          Say Y here if the touchscreen is connected via I2C bus.
-
-          To compile this driver as a module, choose M here: the
-          module will be called cyttsp_i2c.
-
-config TOUCHSCREEN_CYTTSP_SPI
-        tristate "support SPI bus connection"
-        depends on TOUCHSCREEN_CYTTSP_CORE && SPI_MASTER
-        help
-          Say Y here if the touchscreen is connected via SPI bus.
-
-          To compile this driver as a module, choose M here: the
-          module will be called cyttsp_spi.
-
 config TOUCHSCREEN_DA9034
         tristate "Touchscreen support for Dialog Semiconductor DA9034"
         depends on PMIC_DA903X
@@ -175,23 +144,6 @@ config TOUCHSCREEN_DA9034
           Say Y here to enable the support for the touchscreen found
           on Dialog Semiconductor DA9034 PMIC.
 
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called da9034-ts.
-
-config TOUCHSCREEN_DA9052
-        tristate "Dialog DA9052/DA9053 TSI"
-        depends on PMIC_DA9052
-        help
-          Say Y here to support the touchscreen found on Dialog Semiconductor
-          DA9052-BC and DA9053-AA/Bx PMICs.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called da9052_tsi.
-
 config TOUCHSCREEN_DYNAPRO
         tristate "Dynapro serial touchscreen"
         select SERIO
@@ -225,16 +177,6 @@ config TOUCHSCREEN_EETI
           To compile this driver as a module, choose M here: the
           module will be called eeti_ts.
 
-config TOUCHSCREEN_EGALAX
-        tristate "EETI eGalax multi-touch panel support"
-        depends on I2C && OF
-        help
-          Say Y here to enable support for I2C connected EETI
-          eGalax multi-touch panels.
-
-          To compile this driver as a module, choose M here: the
-          module will be called egalax_ts.
-
 config TOUCHSCREEN_FUJITSU
         tristate "Fujitsu serial touchscreen"
         select SERIO
@@ -248,24 +190,9 @@ config TOUCHSCREEN_FUJITSU
           To compile this driver as a module, choose M here: the
           module will be called fujitsu-ts.
 
-config TOUCHSCREEN_ILI210X
-        tristate "Ilitek ILI210X based touchscreen"
-        depends on I2C
-        help
-          Say Y here if you have a ILI210X based touchscreen
-          controller. This driver supports models ILI2102,
-          ILI2102s, ILI2103, ILI2103s and ILI2105.
-          Such kind of chipsets can be found in Amazon Kindle Fire
-          touchscreens.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called ili210x.
-
 config TOUCHSCREEN_S3C2410
         tristate "Samsung S3C2410/generic touchscreen input driver"
-        depends on ARCH_S3C24XX || SAMSUNG_DEV_TS
+        depends on ARCH_S3C2410 || SAMSUNG_DEV_TS
         select S3C_ADC
         help
           Say Y here if you have the s3c2410 touchscreen.
@@ -311,18 +238,6 @@ config TOUCHSCREEN_WACOM_W8001
           To compile this driver as a module, choose M here: the
           module will be called wacom_w8001.
 
-config TOUCHSCREEN_WACOM_I2C
-        tristate "Wacom Tablet support (I2C)"
-        depends on I2C
-        help
-          Say Y here if you want to use the I2C version of the Wacom
-          Pen Tablet.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the module
-          will be called wacom_i2c.
-
 config TOUCHSCREEN_LPC32XX
         tristate "LPC32XX touchscreen controller"
         depends on ARCH_LPC32XX
@@ -357,18 +272,6 @@ config TOUCHSCREEN_MCS5000
           To compile this driver as a module, choose M here: the
           module will be called mcs5000_ts.
 
-config TOUCHSCREEN_MMS114
-        tristate "MELFAS MMS114 touchscreen"
-        depends on I2C
-        help
-          Say Y here if you have the MELFAS MMS114 touchscreen controller
-          chip in your system.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called mms114.
-
 config TOUCHSCREEN_MTOUCH
         tristate "MicroTouch serial touchscreens"
         select SERIO
@@ -460,19 +363,6 @@ config TOUCHSCREEN_PENMOUNT
           To compile this driver as a module, choose M here: the
           module will be called penmount.
 
-config TOUCHSCREEN_EDT_FT5X06
-        tristate "EDT FocalTech FT5x06 I2C Touchscreen support"
-        depends on I2C
-        help
-          Say Y here if you have an EDT "Polytouch" touchscreen based
-          on the FocalTech FT5x06 family of controllers connected to
-          your system.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called edt-ft5x06.
-
 config TOUCHSCREEN_MIGOR
         tristate "Renesas MIGO-R touchscreen"
         depends on SH_MIGOR && I2C
@@ -484,6 +374,19 @@ config TOUCHSCREEN_MIGOR
           To compile this driver as a module, choose M here: the
           module will be called migor_ts.
 
+config TOUCHSCREEN_PANJIT_I2C
+        tristate "PANJIT I2C touchscreen driver"
+        depends on I2C
+        default n
+        help
+          Say Y here to enable PANJIT I2C capacitive touchscreen support,
+          covering devices such as the MGG1010AI06 and EGG1010AI06
+
+          If unsure, say N
+
+          To compile this driver as a module, choose M here: the module will
+          be called panjit_i2c.
+
 config TOUCHSCREEN_TNETV107X
         tristate "TI TNETV107X touchscreen support"
         depends on ARCH_DAVINCI_TNETV107X
@@ -493,6 +396,12 @@ config TOUCHSCREEN_TNETV107X
           To compile this driver as a module, choose M here: the
           module will be called tnetv107x-ts.
 
+config TOUCHSCREEN_SYNAPTICS_I2C_RMI
+        tristate "Synaptics i2c touchscreen"
+        depends on I2C
+        help
+          This enables support for Synaptics RMI over I2C based touchscreens.
+
 config TOUCHSCREEN_TOUCHRIGHT
         tristate "Touchright serial touchscreen"
         select SERIO
@@ -517,24 +426,12 @@ config TOUCHSCREEN_TOUCHWIN
           To compile this driver as a module, choose M here: the
           module will be called touchwin.
 
-config TOUCHSCREEN_TI_AM335X_TSC
-        tristate "TI Touchscreen Interface"
-        depends on MFD_TI_AM335X_TSCADC
-        help
-          Say Y here if you have 4/5/8 wire touchscreen controller
-          to be connected to the ADC controller on your TI AM335x SoC.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called ti_am335x_tsc.
-
 config TOUCHSCREEN_ATMEL_TSADCC
         tristate "Atmel Touchscreen Interface"
-        depends on ARCH_AT91
+        depends on ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
         help
           Say Y here if you have a 4-wire touchscreen connected to the
-          ADC Controller on your Atmel SoC.
+          ADC Controller on your Atmel SoC (such as the AT91SAM9RL).
 
           If unsure, say N.
 
@@ -557,18 +454,6 @@ config TOUCHSCREEN_UCB1400
           To compile this driver as a module, choose M here: the
           module will be called ucb1400_ts.
 
-config TOUCHSCREEN_PIXCIR
-        tristate "PIXCIR I2C touchscreens"
-        depends on I2C
-        help
-          Say Y here if you have a pixcir i2c touchscreen
-          controller.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called pixcir_i2c_ts.
-
 config TOUCHSCREEN_WM831X
         tristate "Support for WM831x touchscreen controllers"
         depends on MFD_WM831X
@@ -675,9 +560,6 @@ config TOUCHSCREEN_USB_COMPOSITE
           - GoTop Super_Q2/GogoPen/PenPower tablets
           - JASTEC USB Touch Controller/DigiTech DTR-02U
           - Zytronic controllers
-          - Elo TouchSystems 2700 IntelliTouch
-          - EasyTouch USB Touch Controller from Data Modul
-          - e2i (Mimo monitors)
 
           Have a look at <http://linux.chapter7.ch/touchkit/> for
           a usage description and the required user-space stuff.
@@ -757,14 +639,9 @@ config TOUCHSCREEN_USB_JASTEC
         bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
-config TOUCHSCREEN_USB_ELO
-        default y
-        bool "Elo TouchSystems 2700 IntelliTouch controller device support" if EXPERT
-        depends on TOUCHSCREEN_USB_COMPOSITE
-
 config TOUCHSCREEN_USB_E2I
         default y
-        bool "e2i Touchscreen controller (e.g. from Mimo 740)" if EXPERT
+        bool "e2i Touchscreen controller (e.g. from Mimo 740)"
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_ZYTRONIC
@@ -782,14 +659,6 @@ config TOUCHSCREEN_USB_NEXIO
         bool "NEXIO/iNexio device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
-config TOUCHSCREEN_USB_EASYTOUCH
-        default y
-        bool "EasyTouch USB Touch controller device support" if EMBEDDED
-        depends on TOUCHSCREEN_USB_COMPOSITE
-        help
-          Say Y here if you have an EasyTouch USB Touch controller.
-          If unsure, say N.
-
 config TOUCHSCREEN_TOUCHIT213
         tristate "Sahara TouchIT-213 touchscreen"
         select SERIO
@@ -801,18 +670,6 @@ config TOUCHSCREEN_TOUCHIT213
           To compile this driver as a module, choose M here: the
           module will be called touchit213.
 
-config TOUCHSCREEN_TSC_SERIO
-        tristate "TSC-10/25/40 serial touchscreen support"
-        select SERIO
-        help
-          Say Y here if you have a TSC-10, 25 or 40 serial touchscreen connected
-          to your system.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called tsc40.
-
 config TOUCHSCREEN_TSC2005
         tristate "TSC2005 based touchscreens"
         depends on SPI_MASTER && GENERIC_HARDIRQS
@@ -888,4 +745,29 @@ config TOUCHSCREEN_TPS6507X
           To compile this driver as a module, choose M here: the
           module will be called tps6507x_ts.
 
+config TOUCHSCREEN_RM31080A
+        tristate "RAYDIUM_31080A based touchscreens"
+        depends on SPI_MASTER
+        help
+          Say Y here if you have a touchscreen interface using the
+          RAYDIUM_T31080A controller, and your board-specific initialization
+          code includes that in its table of SPI devices.
+
+          If unsure, say N (but it's safe to say "Y").
+
+          To compile this driver as a module, choose M here: the
+          module will be called RAYDIUM_31080A.
+
+config TOUCHSCREEN_SYN_RMI4_SPI
+        tristate "RMI4 SPI Support"
+        depends on SPI_MASTER
+        help
+          Say Y here if you want to support RMI4 devices connect
+          to an SPI bus.
+
+          If unsure, say Y.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rmi-spi.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 6bfbeab67c9..9c42d2100b5 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -14,23 +14,16 @@ obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI)	+= ad7879-spi.o
 obj-$(CONFIG_TOUCHSCREEN_ADS7846)       += ads7846.o
 obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT)     += atmel_mxt_ts.o
 obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC)  += atmel_tsadcc.o
-obj-$(CONFIG_TOUCHSCREEN_AUO_PIXCIR)    += auo-pixcir-ts.o
-obj-$(CONFIG_TOUCHSCREEN_BU21013)       += bu21013_ts.o
+obj-$(CONFIG_TOUCHSCREEN_BITSY)         += h3600_ts_input.o
+obj-$(CONFIG_TOUCHSCREEN_BU21013)       += bu21013_ts.o
 obj-$(CONFIG_TOUCHSCREEN_CY8CTMG110)    += cy8ctmg110_ts.o
-obj-$(CONFIG_TOUCHSCREEN_CYTTSP_CORE)   += cyttsp_core.o
-obj-$(CONFIG_TOUCHSCREEN_CYTTSP_I2C)    += cyttsp_i2c.o
-obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)    += cyttsp_spi.o
 obj-$(CONFIG_TOUCHSCREEN_DA9034)        += da9034-ts.o
-obj-$(CONFIG_TOUCHSCREEN_DA9052)        += da9052_tsi.o
 obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)       += dynapro.o
-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_ELO)           += elo.o
-obj-$(CONFIG_TOUCHSCREEN_EGALAX)        += egalax_ts.o
 obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
-obj-$(CONFIG_TOUCHSCREEN_ILI210X)       += ili210x.o
 obj-$(CONFIG_TOUCHSCREEN_INEXIO)        += inexio.o
 obj-$(CONFIG_TOUCHSCREEN_INTEL_MID)     += intel-mid-touch.o
 obj-$(CONFIG_TOUCHSCREEN_LPC32XX)       += lpc32xx_ts.o
@@ -38,30 +31,27 @@ obj-$(CONFIG_TOUCHSCREEN_MAX11801)	+= max11801_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MC13783)       += mc13783_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MCS5000)       += mcs5000_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MIGOR)         += migor_ts.o
-obj-$(CONFIG_TOUCHSCREEN_MMS114)        += mms114.o
 obj-$(CONFIG_TOUCHSCREEN_MTOUCH)        += mtouch.o
 obj-$(CONFIG_TOUCHSCREEN_MK712)         += mk712.o
 obj-$(CONFIG_TOUCHSCREEN_HP600)         += hp680_ts_input.o
 obj-$(CONFIG_TOUCHSCREEN_HP7XX)         += jornada720_ts.o
 obj-$(CONFIG_TOUCHSCREEN_HTCPEN)        += htcpen.o
 obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
+obj-$(CONFIG_TOUCHSCREEN_PANJIT_I2C)    += panjit_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_PCAP)          += pcap_ts.o
 obj-$(CONFIG_TOUCHSCREEN_PENMOUNT)      += penmount.o
-obj-$(CONFIG_TOUCHSCREEN_PIXCIR)        += pixcir_i2c_ts.o
 obj-$(CONFIG_TOUCHSCREEN_S3C2410)       += s3c2410_ts.o
 obj-$(CONFIG_TOUCHSCREEN_ST1232)        += st1232.o
 obj-$(CONFIG_TOUCHSCREEN_STMPE)         += stmpe-ts.o
-obj-$(CONFIG_TOUCHSCREEN_TI_AM335X_TSC) += ti_am335x_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_TNETV107X)     += tnetv107x-ts.o
+obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI)     += synaptics_i2c_rmi.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)    += touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)    += touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)      += touchwin.o
-obj-$(CONFIG_TOUCHSCREEN_TSC_SERIO)     += tsc40.o
 obj-$(CONFIG_TOUCHSCREEN_TSC2005)       += tsc2005.o
 obj-$(CONFIG_TOUCHSCREEN_TSC2007)       += tsc2007.o
 obj-$(CONFIG_TOUCHSCREEN_UCB1400)       += ucb1400_ts.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)   += wacom_w8001.o
-obj-$(CONFIG_TOUCHSCREEN_WACOM_I2C)     += wacom_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_WM831X)        += wm831x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX)        += wm97xx-ts.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9705)  += wm9705.o
@@ -72,3 +62,5 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_MAINSTONE)	+= mainstone-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE)       += zylonite-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_W90X900)       += w90p910_ts.o
 obj-$(CONFIG_TOUCHSCREEN_TPS6507X)      += tps6507x-ts.o
+obj-$(CONFIG_TOUCHSCREEN_RM31080A)      += rm31080a_ts.o
+obj-$(CONFIG_TOUCHSCREEN_SYN_RMI4_SPI)  += rmi4/
diff --git a/drivers/input/touchscreen/ad7877.c b/drivers/input/touchscreen/ad7877.c
index 23fa829b869..714d4e0f9f9 100644
--- a/drivers/input/touchscreen/ad7877.c
+++ b/drivers/input/touchscreen/ad7877.c
@@ -45,7 +45,6 @@
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ad7877.h>
-#include <linux/module.h>
 #include <asm/irq.h>
 
 #define TS_PEN_UP_TIMEOUT       msecs_to_jiffies(100)
@@ -488,10 +487,10 @@ static ssize_t ad7877_disable_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ad7877 *ts = dev_get_drvdata(dev);
-        unsigned int val;
+        unsigned long val;
         int error;
 
-        error = kstrtouint(buf, 10, &val);
+        error = strict_strtoul(buf, 10, &val);
         if (error)
                 return error;
 
@@ -518,10 +517,10 @@ static ssize_t ad7877_dac_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ad7877 *ts = dev_get_drvdata(dev);
-        unsigned int val;
+        unsigned long val;
         int error;
 
-        error = kstrtouint(buf, 10, &val);
+        error = strict_strtoul(buf, 10, &val);
         if (error)
                 return error;
 
@@ -548,10 +547,10 @@ static ssize_t ad7877_gpio3_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ad7877 *ts = dev_get_drvdata(dev);
-        unsigned int val;
+        unsigned long val;
         int error;
 
-        error = kstrtouint(buf, 10, &val);
+        error = strict_strtoul(buf, 10, &val);
         if (error)
                 return error;
 
@@ -579,10 +578,10 @@ static ssize_t ad7877_gpio4_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ad7877 *ts = dev_get_drvdata(dev);
-        unsigned int val;
+        unsigned long val;
         int error;
 
-        error = kstrtouint(buf, 10, &val);
+        error = strict_strtoul(buf, 10, &val);
         if (error)
                 return error;
 
@@ -612,10 +611,10 @@ static struct attribute *ad7877_attributes[] = {
         NULL
 };
 
-static umode_t ad7877_attr_is_visible(struct kobject *kobj,
+static mode_t ad7877_attr_is_visible(struct kobject *kobj,
                                      struct attribute *attr, int n)
 {
-        umode_t mode = attr->mode;
+        mode_t mode = attr->mode;
 
         if (attr == &dev_attr_aux3.attr) {
                 if (gpio3)
@@ -682,7 +681,7 @@ static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts)
         }
 }
 
-static int ad7877_probe(struct spi_device *spi)
+static int __devinit ad7877_probe(struct spi_device *spi)
 {
         struct ad7877                   *ts;
         struct input_dev                *input_dev;
@@ -810,7 +809,7 @@ err_free_mem:
         return err;
 }
 
-static int ad7877_remove(struct spi_device *spi)
+static int __devexit ad7877_remove(struct spi_device *spi)
 {
         struct ad7877 *ts = dev_get_drvdata(&spi->dev);
 
@@ -853,14 +852,25 @@ static SIMPLE_DEV_PM_OPS(ad7877_pm, ad7877_suspend, ad7877_resume);
 static struct spi_driver ad7877_driver = {
         .driver = {
                 .name   = "ad7877",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
                 .pm     = &ad7877_pm,
         },
         .probe          = ad7877_probe,
-        .remove         = ad7877_remove,
+        .remove         = __devexit_p(ad7877_remove),
 };
 
-module_spi_driver(ad7877_driver);
+static int __init ad7877_init(void)
+{
+        return spi_register_driver(&ad7877_driver);
+}
+module_init(ad7877_init);
+
+static void __exit ad7877_exit(void)
+{
+        spi_unregister_driver(&ad7877_driver);
+}
+module_exit(ad7877_exit);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("AD7877 touchscreen Driver");
diff --git a/drivers/input/touchscreen/ad7879-i2c.c b/drivers/input/touchscreen/ad7879-i2c.c
index dcf39077154..4e4e58cec6c 100644
--- a/drivers/input/touchscreen/ad7879-i2c.c
+++ b/drivers/input/touchscreen/ad7879-i2c.c
@@ -16,6 +16,30 @@
 
 #define AD7879_DEVID            0x79    /* AD7879-1/AD7889-1 */
 
+#ifdef CONFIG_PM
+static int ad7879_i2c_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7879 *ts = i2c_get_clientdata(client);
+
+        ad7879_suspend(ts);
+
+        return 0;
+}
+
+static int ad7879_i2c_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7879 *ts = i2c_get_clientdata(client);
+
+        ad7879_resume(ts);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(ad7879_i2c_pm, ad7879_i2c_suspend, ad7879_i2c_resume);
+#endif
+
 /* All registers are word-sized.
  * AD7879 uses a high-byte first convention.
  */
@@ -23,7 +47,7 @@ static int ad7879_i2c_read(struct device *dev, u8 reg)
 {
         struct i2c_client *client = to_i2c_client(dev);
 
-        return i2c_smbus_read_word_swapped(client, reg);
+        return swab16(i2c_smbus_read_word_data(client, reg));
 }
 
 static int ad7879_i2c_multi_read(struct device *dev,
@@ -44,7 +68,7 @@ static int ad7879_i2c_write(struct device *dev, u8 reg, u16 val)
 {
         struct i2c_client *client = to_i2c_client(dev);
 
-        return i2c_smbus_write_word_swapped(client, reg, val);
+        return i2c_smbus_write_word_data(client, reg, swab16(val));
 }
 
 static const struct ad7879_bus_ops ad7879_i2c_bus_ops = {
@@ -54,7 +78,7 @@ static const struct ad7879_bus_ops ad7879_i2c_bus_ops = {
         .write          = ad7879_i2c_write,
 };
 
-static int ad7879_i2c_probe(struct i2c_client *client,
+static int __devinit ad7879_i2c_probe(struct i2c_client *client,
                                       const struct i2c_device_id *id)
 {
         struct ad7879 *ts;
@@ -75,7 +99,7 @@ static int ad7879_i2c_probe(struct i2c_client *client,
         return 0;
 }
 
-static int ad7879_i2c_remove(struct i2c_client *client)
+static int __devexit ad7879_i2c_remove(struct i2c_client *client)
 {
         struct ad7879 *ts = i2c_get_clientdata(client);
 
@@ -95,15 +119,28 @@ static struct i2c_driver ad7879_i2c_driver = {
         .driver = {
                 .name   = "ad7879",
                 .owner  = THIS_MODULE,
-                .pm     = &ad7879_pm_ops,
+#ifdef CONFIG_PM
+                .pm     = &ad7879_i2c_pm,
+#endif
         },
         .probe          = ad7879_i2c_probe,
-        .remove         = ad7879_i2c_remove,
+        .remove         = __devexit_p(ad7879_i2c_remove),
         .id_table       = ad7879_id,
 };
 
-module_i2c_driver(ad7879_i2c_driver);
+static int __init ad7879_i2c_init(void)
+{
+        return i2c_add_driver(&ad7879_i2c_driver);
+}
+module_init(ad7879_i2c_init);
+
+static void __exit ad7879_i2c_exit(void)
+{
+        i2c_del_driver(&ad7879_i2c_driver);
+}
+module_exit(ad7879_i2c_exit);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("AD7879(-1) touchscreen I2C bus driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("i2c:ad7879");
diff --git a/drivers/input/touchscreen/ad7879-spi.c b/drivers/input/touchscreen/ad7879-spi.c
index 606da5bd611..ddf732f3caf 100644
--- a/drivers/input/touchscreen/ad7879-spi.c
+++ b/drivers/input/touchscreen/ad7879-spi.c
@@ -9,7 +9,6 @@
 #include <linux/input.h>        /* BUS_SPI */
 #include <linux/pm.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
 
 #include "ad7879.h"
 
@@ -22,6 +21,30 @@
 #define AD7879_WRITECMD(reg) (AD7879_CMD(reg))
 #define AD7879_READCMD(reg)  (AD7879_CMD(reg) | AD7879_CMD_READ)
 
+#ifdef CONFIG_PM_SLEEP
+static int ad7879_spi_suspend(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct ad7879 *ts = spi_get_drvdata(spi);
+
+        ad7879_suspend(ts);
+
+        return 0;
+}
+
+static int ad7879_spi_resume(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct ad7879 *ts = spi_get_drvdata(spi);
+
+        ad7879_resume(ts);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(ad7879_spi_pm, ad7879_spi_suspend, ad7879_spi_resume);
+
 /*
  * ad7879_read/write are only used for initial setup and for sysfs controls.
  * The main traffic is done in ad7879_collect().
@@ -110,7 +133,7 @@ static const struct ad7879_bus_ops ad7879_spi_bus_ops = {
         .write          = ad7879_spi_write,
 };
 
-static int ad7879_spi_probe(struct spi_device *spi)
+static int __devinit ad7879_spi_probe(struct spi_device *spi)
 {
         struct ad7879 *ts;
         int err;
@@ -137,7 +160,7 @@ static int ad7879_spi_probe(struct spi_device *spi)
         return 0;
 }
 
-static int ad7879_spi_remove(struct spi_device *spi)
+static int __devexit ad7879_spi_remove(struct spi_device *spi)
 {
         struct ad7879 *ts = spi_get_drvdata(spi);
 
@@ -150,14 +173,25 @@ static int ad7879_spi_remove(struct spi_device *spi)
 static struct spi_driver ad7879_spi_driver = {
         .driver = {
                 .name   = "ad7879",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
-                .pm     = &ad7879_pm_ops,
+                .pm     = &ad7879_spi_pm,
         },
         .probe          = ad7879_spi_probe,
-        .remove         = ad7879_spi_remove,
+        .remove         = __devexit_p(ad7879_spi_remove),
 };
 
-module_spi_driver(ad7879_spi_driver);
+static int __init ad7879_spi_init(void)
+{
+        return spi_register_driver(&ad7879_spi_driver);
+}
+module_init(ad7879_spi_init);
+
+static void __exit ad7879_spi_exit(void)
+{
+        spi_unregister_driver(&ad7879_spi_driver);
+}
+module_exit(ad7879_spi_exit);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("AD7879(-1) touchscreen SPI bus driver");
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index facd3057b62..131f9d1c921 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -33,7 +33,6 @@
 #include <linux/gpio.h>
 
 #include <linux/spi/ad7879.h>
-#include <linux/module.h>
 #include "ad7879.h"
 
 #define AD7879_REG_ZEROS                0
@@ -118,7 +117,6 @@ struct ad7879 {
         unsigned int            irq;
         bool                    disabled;       /* P: input->mutex */
         bool                    suspended;      /* P: input->mutex */
-        bool                    swap_xy;
         u16                     conversion_data[AD7879_NR_SENSE];
         char                    phys[32];
         u8                      first_conversion_delay;
@@ -162,9 +160,6 @@ static int ad7879_report(struct ad7879 *ts)
         z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
         z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;
 
-        if (ts->swap_xy)
-                swap(x, y);
-
         /*
          * The samples processed here are already preprocessed by the AD7879.
          * The preprocessing function consists of a median and an averaging
@@ -285,11 +280,8 @@ static void ad7879_close(struct input_dev* input)
                 __ad7879_disable(ts);
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int ad7879_suspend(struct device *dev)
+void ad7879_suspend(struct ad7879 *ts)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
-
         mutex_lock(&ts->input->mutex);
 
         if (!ts->suspended && !ts->disabled && ts->input->users)
@@ -298,14 +290,11 @@ static int ad7879_suspend(struct device *dev)
         ts->suspended = true;
 
         mutex_unlock(&ts->input->mutex);
-
-        return 0;
 }
+EXPORT_SYMBOL(ad7879_suspend);
 
-static int ad7879_resume(struct device *dev)
+void ad7879_resume(struct ad7879 *ts)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
-
         mutex_lock(&ts->input->mutex);
 
         if (ts->suspended && !ts->disabled && ts->input->users)
@@ -314,13 +303,8 @@ static int ad7879_resume(struct device *dev)
         ts->suspended = false;
 
         mutex_unlock(&ts->input->mutex);
-
-        return 0;
 }
-#endif
-
-SIMPLE_DEV_PM_OPS(ad7879_pm_ops, ad7879_suspend, ad7879_resume);
-EXPORT_SYMBOL(ad7879_pm_ops);
+EXPORT_SYMBOL(ad7879_resume);
 
 static void ad7879_toggle(struct ad7879 *ts, bool disable)
 {
@@ -355,10 +339,10 @@ static ssize_t ad7879_disable_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ad7879 *ts = dev_get_drvdata(dev);
-        unsigned int val;
+        unsigned long val;
         int error;
 
-        error = kstrtouint(buf, 10, &val);
+        error = strict_strtoul(buf, 10, &val);
         if (error)
                 return error;
 
@@ -524,7 +508,6 @@ struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
         ts->dev = dev;
         ts->input = input_dev;
         ts->irq = irq;
-        ts->swap_xy = pdata->swap_xy;
 
         setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
 
@@ -602,7 +585,7 @@ struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
                         AD7879_TMR(ts->pen_down_acc_interval);
 
         err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
-                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                   IRQF_TRIGGER_FALLING,
                                    dev_name(dev), ts);
         if (err) {
                 dev_err(dev, "irq %d busy?\n", ts->irq);
diff --git a/drivers/input/touchscreen/ad7879.h b/drivers/input/touchscreen/ad7879.h
index 6fd13c48d37..6b45a27236c 100644
--- a/drivers/input/touchscreen/ad7879.h
+++ b/drivers/input/touchscreen/ad7879.h
@@ -21,8 +21,8 @@ struct ad7879_bus_ops {
         int (*write)(struct device *dev, u8 reg, u16 val);
 };
 
-extern const struct dev_pm_ops ad7879_pm_ops;
-
+void ad7879_suspend(struct ad7879 *);
+void ad7879_resume(struct ad7879 *);
 struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned irq,
                             const struct ad7879_bus_ops *bops);
 void ad7879_remove(struct ad7879 *);
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 4f702b3ec1a..d507b9b6780 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -31,7 +31,6 @@
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 #include <linux/regulator/consumer.h>
-#include <linux/module.h>
 #include <asm/irq.h>
 
 /*
@@ -602,12 +601,10 @@ static ssize_t ads7846_disable_store(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct ads7846 *ts = dev_get_drvdata(dev);
-        unsigned int i;
-        int err;
+        unsigned long i;
 
-        err = kstrtouint(buf, 10, &i);
-        if (err)
-                return err;
+        if (strict_strtoul(buf, 10, &i))
+                return -EINVAL;
 
         if (i)
                 ads7846_disable(ts);
@@ -955,8 +952,7 @@ static int ads7846_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
 
-static int ads7846_setup_pendown(struct spi_device *spi,
-                                           struct ads7846 *ts)
+static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads7846 *ts)
 {
         struct ads7846_platform_data *pdata = spi->dev.platform_data;
         int err;
@@ -982,9 +978,6 @@ static int ads7846_setup_pendown(struct spi_device *spi,
 
                 ts->gpio_pendown = pdata->gpio_pendown;
 
-                if (pdata->gpio_pendown_debounce)
-                        gpio_set_debounce(pdata->gpio_pendown,
-                                          pdata->gpio_pendown_debounce);
         } else {
                 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
                 return -EINVAL;
@@ -997,7 +990,7 @@ static int ads7846_setup_pendown(struct spi_device *spi,
  * Set up the transfers to read touchscreen state; this assumes we
  * use formula #2 for pressure, not #3.
  */
-static void ads7846_setup_spi_msg(struct ads7846 *ts,
+static void __devinit ads7846_setup_spi_msg(struct ads7846 *ts,
                                 const struct ads7846_platform_data *pdata)
 {
         struct spi_message *m = &ts->msg[0];
@@ -1196,7 +1189,7 @@ static void ads7846_setup_spi_msg(struct ads7846 *ts,
         spi_message_add_tail(x, m);
 }
 
-static int ads7846_probe(struct spi_device *spi)
+static int __devinit ads7846_probe(struct spi_device *spi)
 {
         struct ads7846 *ts;
         struct ads7846_packet *packet;
@@ -1390,7 +1383,7 @@ static int ads7846_probe(struct spi_device *spi)
         return err;
 }
 
-static int ads7846_remove(struct spi_device *spi)
+static int __devexit ads7846_remove(struct spi_device *spi)
 {
         struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 
@@ -1430,14 +1423,25 @@ static int ads7846_remove(struct spi_device *spi)
 static struct spi_driver ads7846_driver = {
         .driver = {
                 .name   = "ads7846",
+                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
                 .pm     = &ads7846_pm,
         },
         .probe          = ads7846_probe,
-        .remove         = ads7846_remove,
+        .remove         = __devexit_p(ads7846_remove),
 };
 
-module_spi_driver(ads7846_driver);
+static int __init ads7846_init(void)
+{
+        return spi_register_driver(&ads7846_driver);
+}
+module_init(ads7846_init);
+
+static void __exit ads7846_exit(void)
+{
+        spi_unregister_driver(&ads7846_driver);
+}
+module_exit(ads7846_exit);
 
 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/atmel-wm97xx.c b/drivers/input/touchscreen/atmel-wm97xx.c
index c5c2dbb9386..8034cbb20f7 100644
--- a/drivers/input/touchscreen/atmel-wm97xx.c
+++ b/drivers/input/touchscreen/atmel-wm97xx.c
@@ -392,10 +392,9 @@ static int __exit atmel_wm97xx_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int atmel_wm97xx_suspend(struct *dev)
+#ifdef CONFIG_PM
+static int atmel_wm97xx_suspend(struct platform_device *pdev, pm_message_t msg)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct atmel_wm97xx *atmel_wm97xx = platform_get_drvdata(pdev);
 
         ac97c_writel(atmel_wm97xx, IDR, AC97C_INT_CBEVT);
@@ -405,9 +404,8 @@ static int atmel_wm97xx_suspend(struct *dev)
         return 0;
 }
 
-static int atmel_wm97xx_resume(struct device *dev)
+static int atmel_wm97xx_resume(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct atmel_wm97xx *atmel_wm97xx = platform_get_drvdata(pdev);
         struct wm97xx *wm = atmel_wm97xx->wm;
 
@@ -418,18 +416,18 @@ static int atmel_wm97xx_resume(struct device *dev)
 
         return 0;
 }
+#else
+#define atmel_wm97xx_suspend    NULL
+#define atmel_wm97xx_resume     NULL
 #endif
 
-static SIMPLE_DEV_PM_OPS(atmel_wm97xx_pm_ops,
-                         atmel_wm97xx_suspend, atmel_wm97xx_resume);
-
 static struct platform_driver atmel_wm97xx_driver = {
         .remove         = __exit_p(atmel_wm97xx_remove),
         .driver         = {
-                .name   = "wm97xx-touch",
-                .owner  = THIS_MODULE,
-                .pm     = &atmel_wm97xx_pm_ops,
+                .name = "wm97xx-touch",
         },
+        .suspend        = atmel_wm97xx_suspend,
+        .resume         = atmel_wm97xx_resume,
 };
 
 static int __init atmel_wm97xx_init(void)
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index d04f810cb1d..ad21ef9c010 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -2,6 +2,8 @@
  * Atmel maXTouch Touchscreen driver
  *
  * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Copyright (C) 2011 Atmel Corporation
+ * Copyright (C) 2011 NVIDIA Corporation
  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -17,9 +19,17 @@
 #include <linux/firmware.h>
 #include <linux/i2c.h>
 #include <linux/i2c/atmel_mxt_ts.h>
-#include <linux/input/mt.h>
+#include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+#include <linux/earlysuspend.h>
+#endif
+
+/* Family ID */
+#define MXT224_ID               0x80
+#define MXT768E_ID              0xA1
+#define MXT1386_ID              0xA0
 
 /* Version */
 #define MXT_VER_20              20
@@ -36,7 +46,6 @@
 #define MXT_FW_NAME             "maxtouch.fw"
 
 /* Registers */
-#define MXT_INFO                0x00
 #define MXT_FAMILY_ID           0x00
 #define MXT_VARIANT_ID          0x01
 #define MXT_VERSION             0x02
@@ -173,14 +182,37 @@
 #define MXT_VOLTAGE_DEFAULT     2700000
 #define MXT_VOLTAGE_STEP        10000
 
+/* Defines for Suspend/Resume */
+#define MXT_SUSPEND_STATIC      0
+#define MXT_SUSPEND_DYNAMIC     1
+#define MXT_T7_IDLEACQ_DISABLE  0
+#define MXT_T7_ACTVACQ_DISABLE  0
+#define MXT_T7_ACTV2IDLE_DISABLE 0
+#define MXT_T9_DISABLE          0
+#define MXT_T9_ENABLE           0x83
+#define MXT_T22_DISABLE         0
+
 /* Define for MXT_GEN_COMMAND_T6 */
 #define MXT_BOOT_VALUE          0xa5
 #define MXT_BACKUP_VALUE        0x55
-#define MXT_BACKUP_TIME         25      /* msec */
-#define MXT_RESET_TIME          65      /* msec */
+#define MXT_BACKUP_TIME         200     /* msec */
+#define MXT224_RESET_TIME       65      /* msec */
+#define MXT768E_RESET_TIME      250     /* msec */
+#define MXT1386_RESET_TIME      200     /* msec */
+#define MXT_RESET_TIME          200     /* msec */
+#define MXT_RESET_NOCHGREAD     400     /* msec */
+
+#define MXT_WAKEUP_TIME         25      /* msec */
 
 #define MXT_FWRESET_TIME        175     /* msec */
 
+/* Defines for MXT_SLOWSCAN_EXTENSIONS */
+#define SLOSCAN_DISABLE         0       /* Disable slow scan */
+#define SLOSCAN_ENABLE          1       /* Enable slow scan */
+#define SLOSCAN_SET_ACTVACQINT  2       /* Set ACTV scan rate */
+#define SLOSCAN_SET_IDLEACQINT  3       /* Set IDLE scan rate */
+#define SLOSCAN_SET_ACTV2IDLETO 4       /* Set the ACTIVE to IDLE TimeOut */
+
 /* Command to unlock bootloader */
 #define MXT_UNLOCK_CMD_MSB      0xaa
 #define MXT_UNLOCK_CMD_LSB      0xdc
@@ -195,7 +227,6 @@
 #define MXT_BOOT_STATUS_MASK    0x3f
 
 /* Touch status */
-#define MXT_UNGRIP              (1 << 0)
 #define MXT_SUPPRESS            (1 << 1)
 #define MXT_AMP                 (1 << 2)
 #define MXT_VECTOR              (1 << 3)
@@ -212,6 +243,15 @@
 /* Touchscreen absolute values */
 #define MXT_MAX_AREA            0xff
 
+/* Fixed Report ID values */
+#define MXT_RPTID_NOMSG         0xFF    /* No messages available to read */
+
+#define MXT_MAX_FINGER          10
+
+#define RESUME_READS            100
+
+#define MXT_DEFAULT_PRESSURE    100
+
 struct mxt_info {
         u8 family_id;
         u8 variant_id;
@@ -225,37 +265,89 @@ struct mxt_info {
 struct mxt_object {
         u8 type;
         u16 start_address;
-        u8 size;                /* Size of each instance - 1 */
-        u8 instances;           /* Number of instances - 1 */
+        u16 size;
+        u16 instances;
         u8 num_report_ids;
-} __packed;
+
+        /* to map object and message */
+        u8 min_reportid;
+        u8 max_reportid;
+};
 
 struct mxt_message {
         u8 reportid;
         u8 message[7];
+        u8 checksum;
+};
+
+struct mxt_finger {
+        int status;
+        int x;
+        int y;
+        int area;
+        int pressure;
+};
+
+/* This structure is used to save/restore values during suspend/resume */
+struct mxt_suspend {
+        u8 suspend_obj;
+        u8 suspend_reg;
+        u8 suspend_val;
+        u8 suspend_flags;
+        u8 restore_val;
 };
 
 /* Each client has this additional data */
 struct mxt_data {
         struct i2c_client *client;
         struct input_dev *input_dev;
-        char phys[64];          /* device physical location */
         const struct mxt_platform_data *pdata;
         struct mxt_object *object_table;
         struct mxt_info info;
+        struct mxt_finger finger[MXT_MAX_FINGER];
         unsigned int irq;
         unsigned int max_x;
         unsigned int max_y;
+        u8(*read_chg) (void);
+        u16 msg_address;
+        u16 last_address;
+        u8 actv_cycle_time;
+        u8 idle_cycle_time;
+        u8 actv2idle_timeout;
+        u8 is_stopped;
+        struct mutex access_mutex;
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+        struct early_suspend early_suspend;
+#endif
+        unsigned int driver_paused;
+        struct bin_attribute mem_access_attr;
+        int debug_enabled;
+        int slowscan_enabled;
+        u8 slowscan_actv_cycle_time;
+        u8 slowscan_idle_cycle_time;
+        u8 slowscan_actv2idle_timeout;
+        u8 slowscan_shad_actv_cycle_time;
+        u8 slowscan_shad_idle_cycle_time;
+        u8 slowscan_shad_actv2idle_timeout;
+};
 
-        /* Cached parameters from object table */
-        u8 T6_reportid;
-        u8 T9_reportid_min;
-        u8 T9_reportid_max;
+static struct mxt_suspend mxt_save[] = {
+        {MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, MXT_T9_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
+        {MXT_PROCG_NOISE_T22, MXT_NOISE_CTRL, MXT_T22_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
+        {MXT_GEN_POWER_T7, MXT_POWER_IDLEACQINT, MXT_T7_IDLEACQ_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
+        {MXT_GEN_POWER_T7, MXT_POWER_ACTVACQINT, MXT_T7_ACTVACQ_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
+        {MXT_GEN_POWER_T7, MXT_POWER_ACTV2IDLETO, MXT_T7_ACTV2IDLE_DISABLE, MXT_SUSPEND_DYNAMIC, 0}
 };
 
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+static void mxt_early_suspend(struct early_suspend *es);
+static void mxt_early_resume(struct early_suspend *es);
+#endif
+
 static bool mxt_object_readable(unsigned int type)
 {
         switch (type) {
+        case MXT_GEN_MESSAGE_T5:
         case MXT_GEN_COMMAND_T6:
         case MXT_GEN_POWER_T7:
         case MXT_GEN_ACQUIRE_T8:
@@ -318,10 +410,17 @@ static bool mxt_object_writable(unsigned int type)
 }
 
 static void mxt_dump_message(struct device *dev,
-                             struct mxt_message *message)
+                                  struct mxt_message *message)
 {
-        dev_dbg(dev, "reportid: %u\tmessage: %*ph\n",
-                message->reportid, 7, message->message);
+        dev_dbg(dev, "reportid:\t0x%x\n", message->reportid);
+        dev_dbg(dev, "message1:\t0x%x\n", message->message[0]);
+        dev_dbg(dev, "message2:\t0x%x\n", message->message[1]);
+        dev_dbg(dev, "message3:\t0x%x\n", message->message[2]);
+        dev_dbg(dev, "message4:\t0x%x\n", message->message[3]);
+        dev_dbg(dev, "message5:\t0x%x\n", message->message[4]);
+        dev_dbg(dev, "message6:\t0x%x\n", message->message[5]);
+        dev_dbg(dev, "message7:\t0x%x\n", message->message[6]);
+        dev_dbg(dev, "checksum:\t0x%x\n", message->checksum);
 }
 
 static int mxt_check_bootloader(struct i2c_client *client,
@@ -385,36 +484,46 @@ static int mxt_fw_write(struct i2c_client *client,
 static int __mxt_read_reg(struct i2c_client *client,
                                u16 reg, u16 len, void *val)
 {
-        struct i2c_msg xfer[2];
         u8 buf[2];
-        int ret;
+        int retval = 0;
+        struct mxt_data *data = i2c_get_clientdata(client);
 
         buf[0] = reg & 0xff;
         buf[1] = (reg >> 8) & 0xff;
 
-        /* Write register */
-        xfer[0].addr = client->addr;
-        xfer[0].flags = 0;
-        xfer[0].len = 2;
-        xfer[0].buf = buf;
-
-        /* Read data */
-        xfer[1].addr = client->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = len;
-        xfer[1].buf = val;
-
-        ret = i2c_transfer(client->adapter, xfer, 2);
-        if (ret == 2) {
-                ret = 0;
-        } else {
-                if (ret >= 0)
-                        ret = -EIO;
-                dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
-                        __func__, ret);
+        mutex_lock(&data->access_mutex);
+
+        if ((data->last_address != reg) || (reg != data->msg_address)) {
+                if (i2c_master_send(client, (u8 *)buf, 2) != 2) {
+                        dev_dbg(&client->dev, "i2c retry\n");
+                        msleep(MXT_WAKEUP_TIME);
+
+                        if (i2c_master_send(client, (u8 *)buf, 2) != 2) {
+                                dev_err(&client->dev, "%s: i2c send failed\n",
+                                        __func__);
+                                retval = -EIO;
+                                goto mxt_read_exit;
+                        }
+                }
         }
 
-        return ret;
+        if (i2c_master_recv(client, (u8 *)val, len) != len) {
+                dev_dbg(&client->dev, "i2c retry\n");
+                msleep(MXT_WAKEUP_TIME);
+
+                if (i2c_master_recv(client, (u8 *)val, len) != len) {
+                        dev_err(&client->dev, "%s: i2c recv failed\n",
+                                __func__);
+                        retval = -EIO;
+                        goto mxt_read_exit;
+                }
+        }
+
+        data->last_address = reg;
+
+mxt_read_exit:
+        mutex_unlock(&data->access_mutex);
+        return retval;
 }
 
 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
@@ -422,39 +531,39 @@ static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
         return __mxt_read_reg(client, reg, 1, val);
 }
 
-static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
-                           const void *val)
+static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 {
-        u8 *buf;
-        size_t count;
-        int ret;
-
-        count = len + 2;
-        buf = kmalloc(count, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
+        u8 buf[3];
+        int retval = 0;
+        struct mxt_data *data = i2c_get_clientdata(client);
 
         buf[0] = reg & 0xff;
         buf[1] = (reg >> 8) & 0xff;
-        memcpy(&buf[2], val, len);
+        buf[2] = val;
 
-        ret = i2c_master_send(client, buf, count);
-        if (ret == count) {
-                ret = 0;
-        } else {
-                if (ret >= 0)
-                        ret = -EIO;
-                dev_err(&client->dev, "%s: i2c send failed (%d)\n",
-                        __func__, ret);
+        mutex_lock(&data->access_mutex);
+        if (i2c_master_send(client, buf, 3) != 3) {
+                dev_dbg(&client->dev, "i2c retry\n");
+                msleep(MXT_WAKEUP_TIME);
+
+                if (i2c_master_send(client, buf, 3) != 3) {
+                        dev_err(&client->dev, "%s: i2c send failed\n", __func__);
+                        retval = -EIO;
+                        goto mxt_write_exit;
+                }
         }
+        data->last_address = reg + 1;
 
-        kfree(buf);
-        return ret;
+mxt_write_exit:
+        mutex_unlock(&data->access_mutex);
+        return retval;
 }
 
-static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
+static int mxt_read_object_table(struct i2c_client *client,
+                                      u16 reg, u8 *object_buf)
 {
-        return __mxt_write_reg(client, reg, 1, &val);
+        return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE,
+                                   object_buf);
 }
 
 static struct mxt_object *
@@ -469,7 +578,7 @@ mxt_get_object(struct mxt_data *data, u8 type)
                         return object;
         }
 
-        dev_err(&data->client->dev, "Invalid object type\n");
+        dev_err(&data->client->dev, "Invalid object type T%d\n", type);
         return NULL;
 }
 
@@ -488,6 +597,20 @@ static int mxt_read_message(struct mxt_data *data,
                         sizeof(struct mxt_message), message);
 }
 
+static int mxt_read_object(struct mxt_data *data,
+                                u8 type, u8 offset, u8 *val)
+{
+        struct mxt_object *object;
+        u16 reg;
+
+        object = mxt_get_object(data, type);
+        if (!object)
+                return -EINVAL;
+
+        reg = object->start_address;
+        return __mxt_read_reg(data->client, reg + offset, 1, val);
+}
+
 static int mxt_write_object(struct mxt_data *data,
                                  u8 type, u8 offset, u8 val)
 {
@@ -495,24 +618,80 @@ static int mxt_write_object(struct mxt_data *data,
         u16 reg;
 
         object = mxt_get_object(data, type);
-        if (!object || offset >= object->size + 1)
+        if (!object)
                 return -EINVAL;
 
         reg = object->start_address;
         return mxt_write_reg(data->client, reg + offset, val);
 }
 
+static void mxt_input_report(struct mxt_data *data, int single_id)
+{
+        struct mxt_finger *finger = data->finger;
+        struct input_dev *input_dev = data->input_dev;
+        int status = finger[single_id].status;
+        int finger_num = 0;
+        int id;
+
+        for (id = 0; id < MXT_MAX_FINGER; id++) {
+                if (!finger[id].status)
+                        continue;
+
+                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
+                                finger[id].status != MXT_RELEASE ?
+                                finger[id].area : 0);
+                input_report_abs(input_dev, ABS_MT_POSITION_X,
+                                finger[id].x);
+                input_report_abs(input_dev, ABS_MT_POSITION_Y,
+                                finger[id].y);
+                input_report_abs(input_dev, ABS_MT_PRESSURE,
+                                finger[id].pressure);
+                input_mt_sync(input_dev);
+
+                if (finger[id].status == MXT_RELEASE)
+                        finger[id].status = 0;
+                else
+                        finger_num++;
+        }
+
+        input_report_key(input_dev, BTN_TOUCH, finger_num > 0);
+
+        if (status != MXT_RELEASE) {
+                input_report_abs(input_dev, ABS_X, finger[single_id].x);
+                input_report_abs(input_dev, ABS_Y, finger[single_id].y);
+                input_report_abs(input_dev, ABS_PRESSURE, finger[single_id].pressure);
+        }
+
+        input_sync(input_dev);
+}
+
 static void mxt_input_touchevent(struct mxt_data *data,
                                       struct mxt_message *message, int id)
 {
+        struct mxt_finger *finger = data->finger;
         struct device *dev = &data->client->dev;
         u8 status = message->message[0];
-        struct input_dev *input_dev = data->input_dev;
         int x;
         int y;
         int area;
         int pressure;
 
+        /* Check the touch is present on the screen */
+        if (!(status & MXT_DETECT)) {
+                if (status & MXT_RELEASE) {
+                        dev_dbg(dev, "[%d] released\n", id);
+
+                        finger[id].status = MXT_RELEASE;
+                        finger[id].pressure = 0;
+                        mxt_input_report(data, id);
+                }
+                return;
+        }
+
+        /* Check only AMP detection */
+        if (!(status & (MXT_PRESS | MXT_MOVE)))
+                return;
+
         x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
         y = (message->message[2] << 4) | ((message->message[3] & 0xf));
         if (data->max_x < 1024)
@@ -523,50 +702,31 @@ static void mxt_input_touchevent(struct mxt_data *data,
         area = message->message[4];
         pressure = message->message[5];
 
-        dev_dbg(dev,
-                "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
-                id,
-                (status & MXT_DETECT) ? 'D' : '.',
-                (status & MXT_PRESS) ? 'P' : '.',
-                (status & MXT_RELEASE) ? 'R' : '.',
-                (status & MXT_MOVE) ? 'M' : '.',
-                (status & MXT_VECTOR) ? 'V' : '.',
-                (status & MXT_AMP) ? 'A' : '.',
-                (status & MXT_SUPPRESS) ? 'S' : '.',
-                (status & MXT_UNGRIP) ? 'U' : '.',
-                x, y, area, pressure);
-
-        input_mt_slot(input_dev, id);
-        input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
-                                   status & MXT_DETECT);
-
-        if (status & MXT_DETECT) {
-                input_report_abs(input_dev, ABS_MT_POSITION_X, x);
-                input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
-                input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
-                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
-        }
-}
+        if ((pressure <= 0) || (pressure > 255))
+                pressure = MXT_DEFAULT_PRESSURE;
 
-static unsigned mxt_extract_T6_csum(const u8 *csum)
-{
-        return csum[0] | (csum[1] << 8) | (csum[2] << 16);
-}
+        dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
+                status & MXT_MOVE ? "moved" : "pressed",
+                x, y, area);
 
-static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
-{
-        u8 id = msg->reportid;
-        return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
+        finger[id].status = status & MXT_MOVE ?
+                                MXT_MOVE : MXT_PRESS;
+        finger[id].x = x;
+        finger[id].y = y;
+        finger[id].area = area;
+        finger[id].pressure = pressure;
+
+        mxt_input_report(data, id);
 }
 
 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 {
         struct mxt_data *data = dev_id;
         struct mxt_message message;
-        const u8 *payload = &message.message[0];
+        struct mxt_object *touch_object;
         struct device *dev = &data->client->dev;
+        int touchid;
         u8 reportid;
-        bool update_input = false;
 
         do {
                 if (mxt_read_message(data, &message)) {
@@ -576,133 +736,275 @@ static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 
                 reportid = message.reportid;
 
-                if (reportid == data->T6_reportid) {
-                        u8 status = payload[0];
-                        unsigned csum = mxt_extract_T6_csum(&payload[1]);
-                        dev_dbg(dev, "Status: %02x Config Checksum: %06x\n",
-                                status, csum);
-                } else if (mxt_is_T9_message(data, &message)) {
-                        int id = reportid - data->T9_reportid_min;
-                        mxt_input_touchevent(data, &message, id);
-                        update_input = true;
-                } else {
-                        mxt_dump_message(dev, &message);
-                }
-        } while (reportid != 0xff);
+                touch_object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
+                if (!touch_object)
+                        goto end;
 
-        if (update_input) {
-                input_mt_report_pointer_emulation(data->input_dev, false);
-                input_sync(data->input_dev);
-        }
+                if (data->debug_enabled)
+                        print_hex_dump(KERN_DEBUG, "MXT MSG:", DUMP_PREFIX_NONE,
+                                16, 1, &message, sizeof(struct mxt_message), false);
+
+                if (reportid >= touch_object->min_reportid
+                        && reportid <= touch_object->max_reportid) {
+                        touchid = reportid - touch_object->min_reportid;
+                        mxt_input_touchevent(data, &message, touchid);
+                } else if (reportid != MXT_RPTID_NOMSG)
+                        mxt_dump_message(dev, &message);
+        } while (reportid != MXT_RPTID_NOMSG);
 
 end:
         return IRQ_HANDLED;
 }
 
+static int mxt_make_highchg(struct mxt_data *data)
+{
+        struct device *dev = &data->client->dev;
+        struct mxt_message message;
+        int count = 30;
+        int error;
+
+        /* Read dummy message to make high CHG pin */
+        do {
+                error = mxt_read_message(data, &message);
+                if (error)
+                        return error;
+        } while (message.reportid != MXT_RPTID_NOMSG && --count);
+
+        if (!count) {
+                dev_err(dev, "CHG pin isn't cleared\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
 static int mxt_check_reg_init(struct mxt_data *data)
 {
+        struct i2c_client *client = data->client;
         const struct mxt_platform_data *pdata = data->pdata;
         struct mxt_object *object;
+        struct mxt_message message;
         struct device *dev = &data->client->dev;
         int index = 0;
-        int i, size;
-        int ret;
+        int timeout_counter = 0;
+        int i, j, config_offset;
+        int error;
+        unsigned long current_crc;
+        u8 command_register;
 
         if (!pdata->config) {
                 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
                 return 0;
         }
 
+        /* Try to read the config checksum of the existing cfg */
+        mxt_write_object(data, MXT_GEN_COMMAND_T6,
+                         MXT_COMMAND_REPORTALL, 1);
+        msleep(30);
+
+        error = mxt_read_message(data, &message);
+        if (error)
+                return error;
+
+        object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
+        if (!object)
+                return -EIO;
+
+        /* Check if this message is from command processor (which has
+           only one reporting ID), if so, bytes 1-3 are the checksum. */
+        if (message.reportid == object->max_reportid) {
+                current_crc = message.message[1] | (message.message[2] << 8) |
+                              (message.message[3] << 16);
+        } else {
+                dev_info(dev, "Couldn't retrieve the current cfg checksum, "
+                         "forcing load\n");
+                current_crc = 0xFFFFFFFF;
+        }
+        dev_info(dev,
+                 "Config CRC read from the mXT: %X\n",
+                 (unsigned int) current_crc);
+
+        if (current_crc == pdata->config_crc) {
+                dev_info(dev,
+                         "Matching CRC's, skipping CFG load.\n");
+                return 0;
+        } else {
+                dev_info(dev, "Doesn't match platform data config CRC (%X), "
+                         "writing config from platform data...\n",
+                         (unsigned int) pdata->config_crc);
+        }
+
         for (i = 0; i < data->info.object_num; i++) {
                 object = data->object_table + i;
 
                 if (!mxt_object_writable(object->type))
                         continue;
-
-                size = (object->size + 1) * (object->instances + 1);
-                if (index + size > pdata->config_length) {
-                        dev_err(dev, "Not enough config data!\n");
-                        return -EINVAL;
+                dev_info(dev, "Writing object type %d, config offset %d", data->object_table[i].type, index);
+                for (j = 0;
+                     j < object->size * object->instances;
+                     j++) {
+                        config_offset = index + j;
+                        if (config_offset > pdata->config_length) {
+                                dev_err(dev, "Not enough config data!\n");
+                                dev_err(dev, "config base is %d, offset is %d\n", index, config_offset);
+                                return -EINVAL;
+                        }
+                        mxt_write_object(data, object->type, j,
+                                         pdata->config[config_offset]);
                 }
+                index += object->size * object->instances;
+        }
+        dev_info(dev, "Config written!");
 
-                ret = __mxt_write_reg(data->client, object->start_address,
-                                size, &pdata->config[index]);
-                if (ret)
-                        return ret;
-                index += size;
+        error = mxt_make_highchg(data);
+        if (error)
+                return error;
+
+        /* Backup to memory */
+        mxt_write_object(data, MXT_GEN_COMMAND_T6,
+                        MXT_COMMAND_BACKUPNV,
+                        MXT_BACKUP_VALUE);
+        msleep(MXT_BACKUP_TIME);
+        do {
+                error =  mxt_read_object(data, MXT_GEN_COMMAND_T6,
+                                        MXT_COMMAND_BACKUPNV,
+                                        &command_register);
+                if (error)
+                        return error;
+                msleep(10);
+        } while ((command_register != 0) && (timeout_counter++ <= 100));
+        if (timeout_counter > 100) {
+                dev_err(&client->dev, "No response after backup!\n");
+                return -EIO;
+        }
+
+        /* Clear the interrupt line */
+        error = mxt_make_highchg(data);
+        if (error)
+                return error;
+
+        /* Soft reset */
+        mxt_write_object(data, MXT_GEN_COMMAND_T6,
+                        MXT_COMMAND_RESET, 1);
+        if (data->pdata->read_chg == NULL) {
+                msleep(MXT_RESET_NOCHGREAD);
+        } else {
+                switch (data->info.family_id) {
+                case MXT224_ID:
+                        msleep(MXT224_RESET_TIME);
+                        break;
+                case MXT768E_ID:
+                        msleep(MXT768E_RESET_TIME);
+                        break;
+                case MXT1386_ID:
+                        msleep(MXT1386_RESET_TIME);
+                        break;
+                default:
+                        msleep(MXT_RESET_TIME);
+                }
+                timeout_counter = 0;
+                while ((timeout_counter++ <= 100) && data->pdata->read_chg())
+                        msleep(10);
+                if (timeout_counter > 100) {
+                        dev_err(&client->dev, "No response after reset!\n");
+                        return -EIO;
+                }
         }
 
         return 0;
 }
 
-static int mxt_make_highchg(struct mxt_data *data)
+
+static void mxt_handle_pdata(struct mxt_data *data)
+{
+        const struct mxt_platform_data *pdata = data->pdata;
+
+        if (pdata->read_chg != NULL)
+                data->read_chg = pdata->read_chg;
+}
+
+static int mxt_set_power_cfg(struct mxt_data *data, u8 sleep)
 {
         struct device *dev = &data->client->dev;
-        struct mxt_message message;
-        int count = 10;
         int error;
+        u8 actv_cycle_time = 0;
+        u8 idle_cycle_time = 0;
+        u8 actv2idle_timeout = data->actv2idle_timeout;
 
-        /* Read dummy message to make high CHG pin */
-        do {
-                error = mxt_read_message(data, &message);
-                if (error)
-                        return error;
-        } while (message.reportid != 0xff && --count);
-
-        if (!count) {
-                dev_err(dev, "CHG pin isn't cleared\n");
-                return -EBUSY;
+        if (!sleep) {
+                actv_cycle_time = data->actv_cycle_time;
+                idle_cycle_time = data->idle_cycle_time;
         }
 
+        error = mxt_write_object(data, MXT_GEN_POWER_T7, MXT_POWER_ACTVACQINT,
+                                 actv_cycle_time);
+        if (error)
+                goto i2c_error;
+
+        error = mxt_write_object(data, MXT_GEN_POWER_T7, MXT_POWER_IDLEACQINT,
+                                 idle_cycle_time);
+        if (error)
+                goto i2c_error;
+
+        error = mxt_write_object(data, MXT_GEN_POWER_T7, MXT_POWER_ACTV2IDLETO,
+                                 actv2idle_timeout);
+        if (error)
+                goto i2c_error;
+
+        dev_dbg(dev, "%s: Set ACTV %d, IDLE %d", __func__,
+                actv_cycle_time, idle_cycle_time);
+
         return 0;
+
+i2c_error:
+        dev_err(dev, "Failed to set power cfg");
+        return error;
 }
 
-static void mxt_handle_pdata(struct mxt_data *data)
+static int mxt_init_power_cfg(struct mxt_data *data)
 {
         const struct mxt_platform_data *pdata = data->pdata;
-        u8 voltage;
-
-        /* Set touchscreen lines */
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE,
-                        pdata->x_line);
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE,
-                        pdata->y_line);
-
-        /* Set touchscreen orient */
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
-                        pdata->orient);
-
-        /* Set touchscreen burst length */
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_BLEN, pdata->blen);
-
-        /* Set touchscreen threshold */
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_TCHTHR, pdata->threshold);
-
-        /* Set touchscreen resolution */
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
-        mxt_write_object(data, MXT_TOUCH_MULTI_T9,
-                        MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
-
-        /* Set touchscreen voltage */
-        if (pdata->voltage) {
-                if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
-                        voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
-                                MXT_VOLTAGE_STEP;
-                        voltage = 0xff - voltage + 1;
-                } else
-                        voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
-                                MXT_VOLTAGE_STEP;
-
-                mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
-                                MXT_CTE_VOLTAGE, voltage);
+        struct device *dev = &data->client->dev;
+        int error;
+
+        data->slowscan_actv_cycle_time = 120;   /* 120mS */
+        data->slowscan_idle_cycle_time = 10;    /* 10mS */
+        data->slowscan_actv2idle_timeout = 100; /* 10 seconds */
+        if (pdata->actv_cycle_time > 0 && pdata->idle_cycle_time > 0) {
+                data->actv_cycle_time = pdata->actv_cycle_time;
+                data->idle_cycle_time = pdata->idle_cycle_time;
+        } else {
+                error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                        MXT_POWER_ACTVACQINT,
+                        &data->actv_cycle_time);
+
+                if (error)
+                        return error;
+
+                error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                        MXT_POWER_IDLEACQINT,
+                        &data->idle_cycle_time);
+
+                if (error)
+                        return error;
         }
+
+        error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                MXT_POWER_ACTV2IDLETO,
+                &data->actv2idle_timeout);
+
+        if (error)
+                return error;
+
+        /* On init, power up */
+        error = mxt_set_power_cfg(data, 0);
+        if (error)
+                return error;
+
+        dev_info(dev, "Initialised power cfg: ACTV %d, IDLE %d",
+                data->actv_cycle_time, data->idle_cycle_time);
+
+        return 0;
 }
 
 static int mxt_get_info(struct mxt_data *data)
@@ -710,82 +1012,89 @@ static int mxt_get_info(struct mxt_data *data)
         struct i2c_client *client = data->client;
         struct mxt_info *info = &data->info;
         int error;
+        u8 val;
+
+        /* force send of address pointer on first read during probe */
+        data->last_address = -1;
+
+        error = mxt_read_reg(client, MXT_FAMILY_ID, &val);
+        if (error)
+                return error;
+        info->family_id = val;
+
+        error = mxt_read_reg(client, MXT_VARIANT_ID, &val);
+        if (error)
+                return error;
+        info->variant_id = val;
+
+        error = mxt_read_reg(client, MXT_VERSION, &val);
+        if (error)
+                return error;
+        info->version = val;
 
-        /* Read 7-byte info block starting at address 0 */
-        error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
+        error = mxt_read_reg(client, MXT_BUILD, &val);
         if (error)
                 return error;
+        info->build = val;
+
+        error = mxt_read_reg(client, MXT_OBJECT_NUM, &val);
+        if (error)
+                return error;
+        info->object_num = val;
 
         return 0;
 }
 
 static int mxt_get_object_table(struct mxt_data *data)
 {
-        struct i2c_client *client = data->client;
-        size_t table_size;
+        struct device *dev = &data->client->dev;
         int error;
         int i;
-        u8 reportid;
-
-        table_size = data->info.object_num * sizeof(struct mxt_object);
-        error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
-                        data->object_table);
-        if (error)
-                return error;
+        u16 reg;
+        u8 reportid = 0;
+        u8 buf[MXT_OBJECT_SIZE];
 
-        /* Valid Report IDs start counting from 1 */
-        reportid = 1;
         for (i = 0; i < data->info.object_num; i++) {
                 struct mxt_object *object = data->object_table + i;
-                u8 min_id, max_id;
 
-                le16_to_cpus(&object->start_address);
+                reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i;
+                error = mxt_read_object_table(data->client, reg, buf);
+                if (error)
+                        return error;
+
+                object->type = buf[0];
+                object->start_address = (buf[2] << 8) | buf[1];
+                object->size = buf[3] + 1;
+                object->instances = buf[4] + 1;
+                object->num_report_ids = buf[5];
 
                 if (object->num_report_ids) {
-                        min_id = reportid;
-                        reportid += object->num_report_ids *
-                                        (object->instances + 1);
-                        max_id = reportid - 1;
-                } else {
-                        min_id = 0;
-                        max_id = 0;
+                        reportid += object->num_report_ids * object->instances;
+                        object->max_reportid = reportid;
+                        object->min_reportid = object->max_reportid -
+                                object->instances * object->num_report_ids + 1;
                 }
 
-                dev_dbg(&data->client->dev,
-                        "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
-                        object->type, object->start_address, object->size + 1,
-                        object->instances + 1, min_id, max_id);
+                /* Store message window address so we don't have to
+                   search the object table every time we read message */
+                if (object->type == MXT_GEN_MESSAGE_T5)
+                        data->msg_address = object->start_address;
 
-                switch (object->type) {
-                case MXT_GEN_COMMAND_T6:
-                        data->T6_reportid = min_id;
-                        break;
-                case MXT_TOUCH_MULTI_T9:
-                        data->T9_reportid_min = min_id;
-                        data->T9_reportid_max = max_id;
-                        break;
-                }
+                dev_dbg(dev, "T%d, start:%d size:%d instances:%d "
+                        "min_reportid:%d max_reportid:%d\n",
+                        object->type, object->start_address, object->size,
+                        object->instances,
+                        object->min_reportid, object->max_reportid);
         }
 
         return 0;
 }
 
-static void mxt_free_object_table(struct mxt_data *data)
-{
-        kfree(data->object_table);
-        data->object_table = NULL;
-        data->T6_reportid = 0;
-        data->T9_reportid_min = 0;
-        data->T9_reportid_max = 0;
-
-}
-
 static int mxt_initialize(struct mxt_data *data)
 {
         struct i2c_client *client = data->client;
         struct mxt_info *info = &data->info;
         int error;
-        u8 val;
 
         error = mxt_get_info(data);
         if (error)
@@ -801,53 +1110,37 @@ static int mxt_initialize(struct mxt_data *data)
 
         /* Get object table information */
         error = mxt_get_object_table(data);
-        if (error)
-                goto err_free_object_table;
+        if (error) {
+                dev_err(&client->dev, "Failed to read object table\n");
+                return error;
+        }
 
-        /* Check register init values */
+        /* Load initial touch chip configuration */
         error = mxt_check_reg_init(data);
-        if (error)
-                goto err_free_object_table;
+        if (error) {
+                dev_err(&client->dev, "Failed to initialize configuration\n");
+                return error;
+        }
 
         mxt_handle_pdata(data);
 
-        /* Backup to memory */
-        mxt_write_object(data, MXT_GEN_COMMAND_T6,
-                        MXT_COMMAND_BACKUPNV,
-                        MXT_BACKUP_VALUE);
-        msleep(MXT_BACKUP_TIME);
-
-        /* Soft reset */
-        mxt_write_object(data, MXT_GEN_COMMAND_T6,
-                        MXT_COMMAND_RESET, 1);
-        msleep(MXT_RESET_TIME);
-
-        /* Update matrix size at info struct */
-        error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
-        if (error)
-                goto err_free_object_table;
-        info->matrix_xsize = val;
-
-        error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
-        if (error)
-                goto err_free_object_table;
-        info->matrix_ysize = val;
+        error = mxt_init_power_cfg(data);
+        if (error) {
+                dev_err(&client->dev, "Failed to initialize power cfg\n");
+                return error;
+        }
 
         dev_info(&client->dev,
-                        "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
-                        info->family_id, info->variant_id, info->version >> 4,
-                        info->version & 0xf, info->build);
+                        "Family ID: %d Variant ID: %d Version: %d Build: %d\n",
+                        info->family_id, info->variant_id, info->version,
+                        info->build);
 
         dev_info(&client->dev,
-                        "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
+                        "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n",
                         info->matrix_xsize, info->matrix_ysize,
                         info->object_num);
 
         return 0;
-
-err_free_object_table:
-        mxt_free_object_table(data);
-        return error;
 }
 
 static void mxt_calc_resolution(struct mxt_data *data)
@@ -864,44 +1157,6 @@ static void mxt_calc_resolution(struct mxt_data *data)
         }
 }
 
-/* Firmware Version is returned as Major.Minor.Build */
-static ssize_t mxt_fw_version_show(struct device *dev,
-                                   struct device_attribute *attr, char *buf)
-{
-        struct mxt_data *data = dev_get_drvdata(dev);
-        struct mxt_info *info = &data->info;
-        return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
-                         info->version >> 4, info->version & 0xf, info->build);
-}
-
-/* Hardware Version is returned as FamilyID.VariantID */
-static ssize_t mxt_hw_version_show(struct device *dev,
-                                   struct device_attribute *attr, char *buf)
-{
-        struct mxt_data *data = dev_get_drvdata(dev);
-        struct mxt_info *info = &data->info;
-        return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
-                         info->family_id, info->variant_id);
-}
-
-static ssize_t mxt_show_instance(char *buf, int count,
-                                 struct mxt_object *object, int instance,
-                                 const u8 *val)
-{
-        int i;
-
-        if (object->instances > 0)
-                count += scnprintf(buf + count, PAGE_SIZE - count,
-                                   "Instance %u\n", instance);
-
-        for (i = 0; i < object->size + 1; i++)
-                count += scnprintf(buf + count, PAGE_SIZE - count,
-                                "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
-        count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
-
-        return count;
-}
-
 static ssize_t mxt_object_show(struct device *dev,
                                     struct device_attribute *attr, char *buf)
 {
@@ -910,38 +1165,43 @@ static ssize_t mxt_object_show(struct device *dev,
         int count = 0;
         int i, j;
         int error;
-        u8 *obuf;
-
-        /* Pre-allocate buffer large enough to hold max sized object. */
-        obuf = kmalloc(256, GFP_KERNEL);
-        if (!obuf)
-                return -ENOMEM;
+        u8 val;
 
-        error = 0;
         for (i = 0; i < data->info.object_num; i++) {
                 object = data->object_table + i;
 
-                if (!mxt_object_readable(object->type))
+                count += snprintf(buf + count, PAGE_SIZE - count,
+                                "Object[%d] (Type %d)\n",
+                                i + 1, object->type);
+                if (count >= PAGE_SIZE)
+                        return PAGE_SIZE - 1;
+
+                if (!mxt_object_readable(object->type)) {
+                        count += snprintf(buf + count, PAGE_SIZE - count,
+                                        "\n");
+                        if (count >= PAGE_SIZE)
+                                return PAGE_SIZE - 1;
                         continue;
+                }
 
-                count += scnprintf(buf + count, PAGE_SIZE - count,
-                                "T%u:\n", object->type);
-
-                for (j = 0; j < object->instances + 1; j++) {
-                        u16 size = object->size + 1;
-                        u16 addr = object->start_address + j * size;
-
-                        error = __mxt_read_reg(data->client, addr, size, obuf);
+                for (j = 0; j < object->size; j++) {
+                        error = mxt_read_object(data,
+                                                object->type, j, &val);
                         if (error)
-                                goto done;
+                                return error;
 
-                        count = mxt_show_instance(buf, count, object, j, obuf);
+                        count += snprintf(buf + count, PAGE_SIZE - count,
+                                        "\t[%2d]: %02x (%d)\n", j, val, val);
+                        if (count >= PAGE_SIZE)
+                                return PAGE_SIZE - 1;
                 }
+
+                count += snprintf(buf + count, PAGE_SIZE - count, "\n");
+                if (count >= PAGE_SIZE)
+                        return PAGE_SIZE - 1;
         }
 
-done:
-        kfree(obuf);
-        return error ?: count;
+        return count;
 }
 
 static int mxt_load_fw(struct device *dev, const char *fn)
@@ -1034,7 +1294,8 @@ static ssize_t mxt_update_fw_store(struct device *dev,
                 /* Wait for reset */
                 msleep(MXT_FWRESET_TIME);
 
-                mxt_free_object_table(data);
+                kfree(data->object_table);
+                data->object_table = NULL;
 
                 mxt_initialize(data);
         }
@@ -1048,16 +1309,240 @@ static ssize_t mxt_update_fw_store(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
-static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
-static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
-static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
+static ssize_t mxt_pause_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int count = 0;
+
+        count += sprintf(buf + count, "%d", data->driver_paused);
+        count += sprintf(buf + count, "\n");
+
+        return count;
+}
+
+static ssize_t mxt_pause_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int i;
+
+        if (sscanf(buf, "%u", &i) == 1 && i < 2) {
+                data->driver_paused = i;
+
+                dev_dbg(dev, "%s\n", i ? "paused" : "unpaused");
+        } else {
+                dev_dbg(dev, "pause_driver write error\n");
+        }
+        return count;
+}
+
+static ssize_t mxt_debug_enable_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int count = 0;
+
+        count += sprintf(buf + count, "%d", data->debug_enabled);
+        count += sprintf(buf + count, "\n");
+
+        return count;
+}
+
+static ssize_t mxt_debug_enable_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int i;
+
+        if (sscanf(buf, "%u", &i) == 1 && i < 2) {
+                data->debug_enabled = i;
+
+                dev_dbg(dev, "%s\n", i ? "debug enabled" : "debug disabled");
+        } else {
+                dev_dbg(dev, "debug_enabled write error\n");
+        }
+        return count;
+}
+
+static ssize_t mxt_slowscan_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int count = 0;
+        int error;
+        u8 actv_cycle_time;
+        u8 idle_cycle_time;
+        u8 actv2idle_timeout;
+        dev_info(dev, "Calling mxt_slowscan_show()\n");
+
+        error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                MXT_POWER_ACTVACQINT,
+                &actv_cycle_time);
+
+        if (error)
+                return error;
+
+        error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                MXT_POWER_IDLEACQINT,
+                &idle_cycle_time);
+
+        if (error)
+                return error;
+
+        error = mxt_read_object(data, MXT_GEN_POWER_T7,
+                MXT_POWER_ACTV2IDLETO,
+                &actv2idle_timeout);
+
+        if (error)
+                return error;
+
+        count += sprintf(buf + count, "SLOW SCAN (enable/disable) = %s.\n", data->slowscan_enabled ? "enabled" : "disabled");
+        count += sprintf(buf + count, "SLOW SCAN (actv_cycle_time) = %umS.\n", data->slowscan_actv_cycle_time);
+        count += sprintf(buf + count, "SLOW SCAN (idle_cycle_time) = %umS.\n", data->slowscan_idle_cycle_time);
+        count += sprintf(buf + count, "SLOW SCAN (actv2idle_timeout) = %u.%0uS.\n", data->slowscan_actv2idle_timeout / 10, \
+                                                                                        data->slowscan_actv2idle_timeout % 10);
+        count += sprintf(buf + count, "CURRENT   (actv_cycle_time) = %umS.\n", actv_cycle_time);
+        count += sprintf(buf + count, "CURRENT   (idle_cycle_time) = %umS.\n", idle_cycle_time);
+        count += sprintf(buf + count, "CURRENT   (actv2idle_timeout) = %u.%0uS.\n", actv2idle_timeout / 10, \
+                                                                                        actv2idle_timeout % 10);
+
+        return count;
+}
+
+static ssize_t mxt_slowscan_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int fn;
+        int val;
+        int ret;
+
+        dev_info(dev, "Calling mxt_slowscan_store()\n");
+        ret = sscanf(buf, "%u %u", &fn, &val);
+        if ((ret == 1) || (ret == 2)) {
+                switch (fn) {
+                case SLOSCAN_DISABLE:
+                        if (data->slowscan_enabled) {
+                                data->actv_cycle_time = data->slowscan_shad_actv_cycle_time;
+                                data->idle_cycle_time = data->slowscan_shad_idle_cycle_time;
+                                data->actv2idle_timeout = data->slowscan_shad_actv2idle_timeout;
+                                data->slowscan_enabled = 0;
+                                mxt_set_power_cfg(data, 0);
+                        }
+                        break;
+
+                case SLOSCAN_ENABLE:
+                        if (!data->slowscan_enabled) {
+                                data->slowscan_shad_actv_cycle_time = data->actv_cycle_time;
+                                data->slowscan_shad_idle_cycle_time = data->idle_cycle_time;
+                                data->slowscan_shad_actv2idle_timeout = data->actv2idle_timeout;
+                                data->actv_cycle_time = data->slowscan_actv_cycle_time;
+                                data->idle_cycle_time = data->slowscan_idle_cycle_time;
+                                data->actv2idle_timeout = data->slowscan_actv2idle_timeout;
+                                data->slowscan_enabled = 1;
+                                mxt_set_power_cfg(data, 0);
+                        }
+                        break;
+
+                case SLOSCAN_SET_ACTVACQINT:
+                        data->slowscan_actv_cycle_time = val;
+                        break;
+
+                case SLOSCAN_SET_IDLEACQINT:
+                        data->slowscan_idle_cycle_time = val;
+                        break;
+
+                case SLOSCAN_SET_ACTV2IDLETO:
+                        data->slowscan_actv2idle_timeout = val;
+                        break;
+                }
+        }
+        return count;
+}
+
+static ssize_t mxt_mem_access_read(struct file *filp, struct kobject *kobj,
+        struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (off >= 32768)
+                return -EIO;
+
+        if (off + count > 32768)
+                count = 32768 - off;
+
+        if (count > 256)
+                count = 256;
+
+        if (count > 0)
+                ret = __mxt_read_reg(data->client, off, count, buf);
+
+        return ret == 0 ? count : ret;
+}
+
+int mxt_write_block(struct i2c_client *client, u16 addr, u16 length, u8 *value)
+{
+        int i;
+        struct {
+                __le16 le_addr;
+                u8  data[256];
+        } i2c_block_transfer;
+
+        if (length > 256)
+                return -EINVAL;
+
+        i2c_get_clientdata(client);
+
+        for (i = 0; i < length; i++)
+                i2c_block_transfer.data[i] = *value++;
+
+        i2c_block_transfer.le_addr = cpu_to_le16(addr);
+
+        i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);
+
+        if (i == (length + 2))
+                return 0;
+        else
+                return -EIO;
+}
+
+static ssize_t mxt_mem_access_write(struct file *filp, struct kobject *kobj,
+        struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (off >= 32768)
+                return -EIO;
+
+        if (off + count > 32768)
+                count = 32768 - off;
+
+        if (count > 256)
+                count = 256;
+
+        if (count > 0)
+                ret = mxt_write_block(data->client, off, count, buf);
+
+        return ret == 0 ? count : 0;
+}
+
+static DEVICE_ATTR(object, 0444, mxt_object_show, NULL);
+static DEVICE_ATTR(update_fw, 0664, NULL, mxt_update_fw_store);
+static DEVICE_ATTR(pause_driver, 0664, mxt_pause_show, mxt_pause_store);
+static DEVICE_ATTR(debug_enable, 0664, mxt_debug_enable_show, mxt_debug_enable_store);
+static DEVICE_ATTR(slowscan_enable, 0664, mxt_slowscan_show, mxt_slowscan_store);
 
 static struct attribute *mxt_attrs[] = {
-        &dev_attr_fw_version.attr,
-        &dev_attr_hw_version.attr,
         &dev_attr_object.attr,
         &dev_attr_update_fw.attr,
+        &dev_attr_pause_driver.attr,
+        &dev_attr_debug_enable.attr,
+        &dev_attr_slowscan_enable.attr,
         NULL
 };
 
@@ -1067,16 +1552,54 @@ static const struct attribute_group mxt_attr_group = {
 
 static void mxt_start(struct mxt_data *data)
 {
+        int error = 0;
+        int cnt;
+        struct device *dev = &data->client->dev;
+
+        dev_info(dev, "mxt_start:  is_stopped = %d\n", data->is_stopped);
+        if (data->is_stopped == 0)
+                return;
+
         /* Touch enable */
-        mxt_write_object(data,
-                        MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
+        cnt = ARRAY_SIZE(mxt_save);
+        while (cnt--)
+                error |= mxt_write_object(data, mxt_save[cnt].suspend_obj,
+                                                mxt_save[cnt].suspend_reg,
+                                                mxt_save[cnt].restore_val);
+
+        if (!error)
+                dev_info(dev, "MXT started\n");
+
+        data->is_stopped = 0;
 }
 
 static void mxt_stop(struct mxt_data *data)
 {
+        int error = 0;
+        int i, cnt;
+        struct device *dev = &data->client->dev;
+
+        dev_info(dev, "mxt_stop:  is_stopped = %d\n", data->is_stopped);
+        if (data->is_stopped)
+                return;
+
         /* Touch disable */
-        mxt_write_object(data,
-                        MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
+        cnt = ARRAY_SIZE(mxt_save);
+        for (i = 0; i < cnt; i++) {
+                if (mxt_save[i].suspend_flags == MXT_SUSPEND_DYNAMIC)
+                        error |= mxt_read_object(data,
+                                                mxt_save[i].suspend_obj,
+                                                mxt_save[i].suspend_reg,
+                                                &mxt_save[i].restore_val);
+                error |= mxt_write_object(data, mxt_save[i].suspend_obj,
+                                                mxt_save[i].suspend_reg,
+                                                mxt_save[i].suspend_val);
+        }
+
+        if (!error)
+                dev_info(dev, "MXT suspended\n");
+
+        data->is_stopped = 1;
 }
 
 static int mxt_input_open(struct input_dev *dev)
@@ -1095,14 +1618,13 @@ static void mxt_input_close(struct input_dev *dev)
         mxt_stop(data);
 }
 
-static int mxt_probe(struct i2c_client *client,
+static int __devinit mxt_probe(struct i2c_client *client,
                 const struct i2c_device_id *id)
 {
         const struct mxt_platform_data *pdata = client->dev.platform_data;
         struct mxt_data *data;
         struct input_dev *input_dev;
         int error;
-        unsigned int num_mt_slots;
 
         if (!pdata)
                 return -EINVAL;
@@ -1115,11 +1637,7 @@ static int mxt_probe(struct i2c_client *client,
                 goto err_free_mem;
         }
 
-        input_dev->name = "Atmel maXTouch Touchscreen";
-        snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
-                 client->adapter->nr, client->addr);
-        input_dev->phys = data->phys;
-
+        input_dev->name = "atmel-maxtouch";
         input_dev->id.bustype = BUS_I2C;
         input_dev->dev.parent = &client->dev;
         input_dev->open = mxt_input_open;
@@ -1129,13 +1647,10 @@ static int mxt_probe(struct i2c_client *client,
         data->input_dev = input_dev;
         data->pdata = pdata;
         data->irq = client->irq;
+        data->is_stopped = 0;
 
         mxt_calc_resolution(data);
 
-        error = mxt_initialize(data);
-        if (error)
-                goto err_free_mem;
-
         __set_bit(EV_ABS, input_dev->evbit);
         __set_bit(EV_KEY, input_dev->evbit);
         __set_bit(BTN_TOUCH, input_dev->keybit);
@@ -1149,10 +1664,6 @@ static int mxt_probe(struct i2c_client *client,
                              0, 255, 0, 0);
 
         /* For multi touch */
-        num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
-        error = input_mt_init_slots(input_dev, num_mt_slots, 0);
-        if (error)
-                goto err_free_object;
         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
                              0, MXT_MAX_AREA, 0, 0);
         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
@@ -1165,25 +1676,55 @@ static int mxt_probe(struct i2c_client *client,
         input_set_drvdata(input_dev, data);
         i2c_set_clientdata(client, data);
 
+        mutex_init(&data->access_mutex);
+
+        error = mxt_initialize(data);
+        if (error)
+                goto err_free_object;
+
         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
-                                     pdata->irqflags | IRQF_ONESHOT,
-                                     client->name, data);
+                        pdata->irqflags, client->dev.driver->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
                 goto err_free_object;
         }
 
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+        data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+        data->early_suspend.suspend = mxt_early_suspend;
+        data->early_suspend.resume = mxt_early_resume;
+        register_early_suspend(&data->early_suspend);
+#endif
+
         error = mxt_make_highchg(data);
-        if (error)
+        if (error) {
+                dev_err(&client->dev, "Failed to make high CHG\n");
                 goto err_free_irq;
+        }
 
         error = input_register_device(input_dev);
-        if (error)
+        if (error) {
+                dev_err(&client->dev, "Failed to register input device\n");
                 goto err_free_irq;
+        }
 
         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
-        if (error)
+        if (error) {
+                dev_err(&client->dev, "Failed to create sysfs group\n");
+                goto err_unregister_device;
+        }
+
+        sysfs_bin_attr_init(&data->mem_access_attr);
+        data->mem_access_attr.attr.name = "mem_access";
+        data->mem_access_attr.attr.mode = S_IRUGO | S_IWUSR | S_IWGRP;
+        data->mem_access_attr.read = mxt_mem_access_read;
+        data->mem_access_attr.write = mxt_mem_access_write;
+        data->mem_access_attr.size = 65535;
+
+        if (sysfs_create_bin_file(&client->dev.kobj, &data->mem_access_attr) < 0) {
+                dev_err(&client->dev, "Failed to create %s\n", data->mem_access_attr.attr.name);
                 goto err_unregister_device;
+        }
 
         return 0;
 
@@ -1200,10 +1741,11 @@ err_free_mem:
         return error;
 }
 
-static int mxt_remove(struct i2c_client *client)
+static int __devexit mxt_remove(struct i2c_client *client)
 {
         struct mxt_data *data = i2c_get_clientdata(client);
 
+        sysfs_remove_bin_file(&client->dev.kobj, &data->mem_access_attr);
         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
         free_irq(data->irq, data);
         input_unregister_device(data->input_dev);
@@ -1213,7 +1755,7 @@ static int mxt_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
 static int mxt_suspend(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -1237,8 +1779,7 @@ static int mxt_resume(struct device *dev)
         struct input_dev *input_dev = data->input_dev;
 
         /* Soft reset */
-        mxt_write_object(data, MXT_GEN_COMMAND_T6,
-                        MXT_COMMAND_RESET, 1);
+        mxt_write_object(data, MXT_GEN_COMMAND_T6, MXT_COMMAND_RESET, 1);
 
         msleep(MXT_RESET_TIME);
 
@@ -1251,9 +1792,40 @@ static int mxt_resume(struct device *dev)
 
         return 0;
 }
-#endif
 
-static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+static void mxt_early_suspend(struct early_suspend *es)
+{
+        struct mxt_data *mxt;
+        struct device *dev;
+        mxt = container_of(es, struct mxt_data, early_suspend);
+        dev = &mxt->client->dev;
+        dev_info(dev, "MXT Early Suspend entered\n");
+
+        if (mxt_suspend(&mxt->client->dev) != 0)
+                dev_err(&mxt->client->dev, "%s: failed\n", __func__);
+        dev_info(dev, "MXT Early Suspended\n");
+}
+
+static void mxt_early_resume(struct early_suspend *es)
+{
+        struct mxt_data *mxt;
+        struct device *dev;
+        mxt = container_of(es, struct mxt_data, early_suspend);
+        dev = &mxt->client->dev;
+        dev_info(dev, "MXT Early Resume entered\n");
+
+        if (mxt_resume(&mxt->client->dev) != 0)
+                dev_err(&mxt->client->dev, "%s: failed\n", __func__);
+        dev_info(dev, "MXT Early Resumed\n");
+}
+#else
+static const struct dev_pm_ops mxt_pm_ops = {
+        .suspend        = mxt_suspend,
+        .resume         = mxt_resume,
+};
+#endif
+#endif
 
 static const struct i2c_device_id mxt_id[] = {
         { "qt602240_ts", 0 },
@@ -1267,14 +1839,27 @@ static struct i2c_driver mxt_driver = {
         .driver = {
                 .name   = "atmel_mxt_ts",
                 .owner  = THIS_MODULE,
+#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
                 .pm     = &mxt_pm_ops,
+#endif
         },
         .probe          = mxt_probe,
-        .remove         = mxt_remove,
+        .remove         = __devexit_p(mxt_remove),
         .id_table       = mxt_id,
 };
 
-module_i2c_driver(mxt_driver);
+static int __init mxt_init(void)
+{
+        return i2c_add_driver(&mxt_driver);
+}
+
+static void __exit mxt_exit(void)
+{
+        i2c_del_driver(&mxt_driver);
+}
+
+module_init(mxt_init);
+module_exit(mxt_exit);
 
 /* Module information */
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
diff --git a/drivers/input/touchscreen/atmel_tsadcc.c b/drivers/input/touchscreen/atmel_tsadcc.c
index 95f6785a94b..432c69be6ac 100644
--- a/drivers/input/touchscreen/atmel_tsadcc.c
+++ b/drivers/input/touchscreen/atmel_tsadcc.c
@@ -22,7 +22,7 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/platform_data/atmel.h>
+#include <mach/board.h>
 #include <mach/cpu.h>
 
 /* Register definitions based on AT91SAM9RL64 preliminary draft datasheet */
@@ -177,7 +177,7 @@ static irqreturn_t atmel_tsadcc_interrupt(int irq, void *dev)
  * The functions for inserting/removing us as a module.
  */
 
-static int atmel_tsadcc_probe(struct platform_device *pdev)
+static int __devinit atmel_tsadcc_probe(struct platform_device *pdev)
 {
         struct atmel_tsadcc     *ts_dev;
         struct input_dev        *input_dev;
@@ -229,7 +229,7 @@ static int atmel_tsadcc_probe(struct platform_device *pdev)
                 goto err_release_mem;
         }
 
-        err = request_irq(ts_dev->irq, atmel_tsadcc_interrupt, 0,
+        err = request_irq(ts_dev->irq, atmel_tsadcc_interrupt, IRQF_DISABLED,
                         pdev->dev.driver->name, ts_dev);
         if (err) {
                 dev_err(&pdev->dev, "failed to allocate irq.\n");
@@ -323,7 +323,7 @@ err_free_mem:
         return err;
 }
 
-static int atmel_tsadcc_remove(struct platform_device *pdev)
+static int __devexit atmel_tsadcc_remove(struct platform_device *pdev)
 {
         struct atmel_tsadcc *ts_dev = dev_get_drvdata(&pdev->dev);
         struct resource *res;
@@ -346,12 +346,25 @@ static int atmel_tsadcc_remove(struct platform_device *pdev)
 
 static struct platform_driver atmel_tsadcc_driver = {
         .probe          = atmel_tsadcc_probe,
-        .remove         = atmel_tsadcc_remove,
+        .remove         = __devexit_p(atmel_tsadcc_remove),
         .driver         = {
                 .name   = "atmel_tsadcc",
         },
 };
-module_platform_driver(atmel_tsadcc_driver);
+
+static int __init atmel_tsadcc_init(void)
+{
+        return platform_driver_register(&atmel_tsadcc_driver);
+}
+
+static void __exit atmel_tsadcc_exit(void)
+{
+        platform_driver_unregister(&atmel_tsadcc_driver);
+}
+
+module_init(atmel_tsadcc_init);
+module_exit(atmel_tsadcc_exit);
+
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Atmel TouchScreen Driver");
diff --git a/drivers/input/touchscreen/auo-pixcir-ts.c b/drivers/input/touchscreen/auo-pixcir-ts.c
deleted file mode 100644
index c6e19a96348..00000000000
--- a/drivers/input/touchscreen/auo-pixcir-ts.c
+++ /dev/null
@@ -1,642 +0,0 @@
-/*
- * Driver for AUO in-cell touchscreens
- *
- * Copyright (c) 2011 Heiko Stuebner <heiko@sntech.de>
- *
- * loosely based on auo_touch.c from Dell Streak vendor-kernel
- *
- * Copyright (c) 2008 QUALCOMM Incorporated.
- * Copyright (c) 2008 QUALCOMM USA, 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/kernel.h>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/input.h>
-#include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/mutex.h>
-#include <linux/delay.h>
-#include <linux/gpio.h>
-#include <linux/input/auo-pixcir-ts.h>
-
-/*
- * Coordinate calculation:
- * X1 = X1_LSB + X1_MSB*256
- * Y1 = Y1_LSB + Y1_MSB*256
- * X2 = X2_LSB + X2_MSB*256
- * Y2 = Y2_LSB + Y2_MSB*256
- */
-#define AUO_PIXCIR_REG_X1_LSB           0x00
-#define AUO_PIXCIR_REG_X1_MSB           0x01
-#define AUO_PIXCIR_REG_Y1_LSB           0x02
-#define AUO_PIXCIR_REG_Y1_MSB           0x03
-#define AUO_PIXCIR_REG_X2_LSB           0x04
-#define AUO_PIXCIR_REG_X2_MSB           0x05
-#define AUO_PIXCIR_REG_Y2_LSB           0x06
-#define AUO_PIXCIR_REG_Y2_MSB           0x07
-
-#define AUO_PIXCIR_REG_STRENGTH         0x0d
-#define AUO_PIXCIR_REG_STRENGTH_X1_LSB  0x0e
-#define AUO_PIXCIR_REG_STRENGTH_X1_MSB  0x0f
-
-#define AUO_PIXCIR_REG_RAW_DATA_X       0x2b
-#define AUO_PIXCIR_REG_RAW_DATA_Y       0x4f
-
-#define AUO_PIXCIR_REG_X_SENSITIVITY    0x6f
-#define AUO_PIXCIR_REG_Y_SENSITIVITY    0x70
-#define AUO_PIXCIR_REG_INT_SETTING      0x71
-#define AUO_PIXCIR_REG_INT_WIDTH        0x72
-#define AUO_PIXCIR_REG_POWER_MODE       0x73
-
-#define AUO_PIXCIR_REG_VERSION          0x77
-#define AUO_PIXCIR_REG_CALIBRATE        0x78
-
-#define AUO_PIXCIR_REG_TOUCHAREA_X1     0x1e
-#define AUO_PIXCIR_REG_TOUCHAREA_Y1     0x1f
-#define AUO_PIXCIR_REG_TOUCHAREA_X2     0x20
-#define AUO_PIXCIR_REG_TOUCHAREA_Y2     0x21
-
-#define AUO_PIXCIR_REG_EEPROM_CALIB_X   0x42
-#define AUO_PIXCIR_REG_EEPROM_CALIB_Y   0xad
-
-#define AUO_PIXCIR_INT_TPNUM_MASK       0xe0
-#define AUO_PIXCIR_INT_TPNUM_SHIFT      5
-#define AUO_PIXCIR_INT_RELEASE          (1 << 4)
-#define AUO_PIXCIR_INT_ENABLE           (1 << 3)
-#define AUO_PIXCIR_INT_POL_HIGH         (1 << 2)
-#define AUO_PIXCIR_INT_MODE_MASK        0x03
-
-/*
- * Power modes:
- * active:      scan speed 60Hz
- * sleep:       scan speed 10Hz can be auto-activated, wakeup on 1st touch
- * deep sleep:  scan speed 1Hz can only be entered or left manually.
- */
-#define AUO_PIXCIR_POWER_ACTIVE         0x00
-#define AUO_PIXCIR_POWER_SLEEP          0x01
-#define AUO_PIXCIR_POWER_DEEP_SLEEP     0x02
-#define AUO_PIXCIR_POWER_MASK           0x03
-
-#define AUO_PIXCIR_POWER_ALLOW_SLEEP    (1 << 2)
-#define AUO_PIXCIR_POWER_IDLE_TIME(ms)  ((ms & 0xf) << 4)
-
-#define AUO_PIXCIR_CALIBRATE            0x03
-
-#define AUO_PIXCIR_EEPROM_CALIB_X_LEN   62
-#define AUO_PIXCIR_EEPROM_CALIB_Y_LEN   36
-
-#define AUO_PIXCIR_RAW_DATA_X_LEN       18
-#define AUO_PIXCIR_RAW_DATA_Y_LEN       11
-
-#define AUO_PIXCIR_STRENGTH_ENABLE      (1 << 0)
-
-/* Touchscreen absolute values */
-#define AUO_PIXCIR_REPORT_POINTS        2
-#define AUO_PIXCIR_MAX_AREA             0xff
-#define AUO_PIXCIR_PENUP_TIMEOUT_MS     10
-
-struct auo_pixcir_ts {
-        struct i2c_client       *client;
-        struct input_dev        *input;
-        char                    phys[32];
-
-        /* special handling for touch_indicate interupt mode */
-        bool                    touch_ind_mode;
-
-        wait_queue_head_t       wait;
-        bool                    stopped;
-};
-
-struct auo_point_t {
-        int     coord_x;
-        int     coord_y;
-        int     area_major;
-        int     area_minor;
-        int     orientation;
-};
-
-static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts,
-                                   struct auo_point_t *point)
-{
-        struct i2c_client *client = ts->client;
-        const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
-        uint8_t raw_coord[8];
-        uint8_t raw_area[4];
-        int i, ret;
-
-        /* touch coordinates */
-        ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB,
-                                            8, raw_coord);
-        if (ret < 0) {
-                dev_err(&client->dev, "failed to read coordinate, %d\n", ret);
-                return ret;
-        }
-
-        /* touch area */
-        ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1,
-                                            4, raw_area);
-        if (ret < 0) {
-                dev_err(&client->dev, "could not read touch area, %d\n", ret);
-                return ret;
-        }
-
-        for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
-                point[i].coord_x =
-                        raw_coord[4 * i + 1] << 8 | raw_coord[4 * i];
-                point[i].coord_y =
-                        raw_coord[4 * i + 3] << 8 | raw_coord[4 * i + 2];
-
-                if (point[i].coord_x > pdata->x_max ||
-                    point[i].coord_y > pdata->y_max) {
-                        dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
-                                point[i].coord_x, point[i].coord_y);
-                        point[i].coord_x = point[i].coord_y = 0;
-                }
-
-                /* determine touch major, minor and orientation */
-                point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]);
-                point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]);
-                point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1];
-        }
-
-        return 0;
-}
-
-static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id)
-{
-        struct auo_pixcir_ts *ts = dev_id;
-        struct i2c_client *client = ts->client;
-        const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
-        struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS];
-        int i;
-        int ret;
-        int fingers = 0;
-        int abs = -1;
-
-        while (!ts->stopped) {
-
-                /* check for up event in touch touch_ind_mode */
-                if (ts->touch_ind_mode) {
-                        if (gpio_get_value(pdata->gpio_int) == 0) {
-                                input_mt_sync(ts->input);
-                                input_report_key(ts->input, BTN_TOUCH, 0);
-                                input_sync(ts->input);
-                                break;
-                        }
-                }
-
-                ret = auo_pixcir_collect_data(ts, point);
-                if (ret < 0) {
-                        /* we want to loop only in touch_ind_mode */
-                        if (!ts->touch_ind_mode)
-                                break;
-
-                        wait_event_timeout(ts->wait, ts->stopped,
-                                msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
-                        continue;
-                }
-
-                for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
-                        if (point[i].coord_x > 0 || point[i].coord_y > 0) {
-                                input_report_abs(ts->input, ABS_MT_POSITION_X,
-                                                 point[i].coord_x);
-                                input_report_abs(ts->input, ABS_MT_POSITION_Y,
-                                                 point[i].coord_y);
-                                input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
-                                                 point[i].area_major);
-                                input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
-                                                 point[i].area_minor);
-                                input_report_abs(ts->input, ABS_MT_ORIENTATION,
-                                                 point[i].orientation);
-                                input_mt_sync(ts->input);
-
-                                /* use first finger as source for singletouch */
-                                if (fingers == 0)
-                                        abs = i;
-
-                                /* number of touch points could also be queried
-                                 * via i2c but would require an additional call
-                                 */
-                                fingers++;
-                        }
-                }
-
-                input_report_key(ts->input, BTN_TOUCH, fingers > 0);
-
-                if (abs > -1) {
-                        input_report_abs(ts->input, ABS_X, point[abs].coord_x);
-                        input_report_abs(ts->input, ABS_Y, point[abs].coord_y);
-                }
-
-                input_sync(ts->input);
-
-                /* we want to loop only in touch_ind_mode */
-                if (!ts->touch_ind_mode)
-                        break;
-
-                wait_event_timeout(ts->wait, ts->stopped,
-                                 msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
-        }
-
-        return IRQ_HANDLED;
-}
-
-/*
- * Set the power mode of the device.
- * Valid modes are
- * - AUO_PIXCIR_POWER_ACTIVE
- * - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch
- * - AUO_PIXCIR_POWER_DEEP_SLEEP
- */
-static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode)
-{
-        struct i2c_client *client = ts->client;
-        int ret;
-
-        ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE);
-        if (ret < 0) {
-                dev_err(&client->dev, "unable to read reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_POWER_MODE, ret);
-                return ret;
-        }
-
-        ret &= ~AUO_PIXCIR_POWER_MASK;
-        ret |= mode;
-
-        ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret);
-        if (ret) {
-                dev_err(&client->dev, "unable to write reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_POWER_MODE, ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int auo_pixcir_int_config(struct auo_pixcir_ts *ts,
-                                           int int_setting)
-{
-        struct i2c_client *client = ts->client;
-        struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
-        int ret;
-
-        ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
-        if (ret < 0) {
-                dev_err(&client->dev, "unable to read reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_INT_SETTING, ret);
-                return ret;
-        }
-
-        ret &= ~AUO_PIXCIR_INT_MODE_MASK;
-        ret |= int_setting;
-        ret |= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */
-
-        ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
-                                        ret);
-        if (ret < 0) {
-                dev_err(&client->dev, "unable to write reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_INT_SETTING, ret);
-                return ret;
-        }
-
-        ts->touch_ind_mode = pdata->int_setting == AUO_PIXCIR_INT_TOUCH_IND;
-
-        return 0;
-}
-
-/* control the generation of interrupts on the device side */
-static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable)
-{
-        struct i2c_client *client = ts->client;
-        int ret;
-
-        ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
-        if (ret < 0) {
-                dev_err(&client->dev, "unable to read reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_INT_SETTING, ret);
-                return ret;
-        }
-
-        if (enable)
-                ret |= AUO_PIXCIR_INT_ENABLE;
-        else
-                ret &= ~AUO_PIXCIR_INT_ENABLE;
-
-        ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
-                                        ret);
-        if (ret < 0) {
-                dev_err(&client->dev, "unable to write reg %Xh, %d\n",
-                        AUO_PIXCIR_REG_INT_SETTING, ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int auo_pixcir_start(struct auo_pixcir_ts *ts)
-{
-        struct i2c_client *client = ts->client;
-        int ret;
-
-        ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE);
-        if (ret < 0) {
-                dev_err(&client->dev, "could not set power mode, %d\n",
-                        ret);
-                return ret;
-        }
-
-        ts->stopped = false;
-        mb();
-        enable_irq(client->irq);
-
-        ret = auo_pixcir_int_toggle(ts, 1);
-        if (ret < 0) {
-                dev_err(&client->dev, "could not enable interrupt, %d\n",
-                        ret);
-                disable_irq(client->irq);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int auo_pixcir_stop(struct auo_pixcir_ts *ts)
-{
-        struct i2c_client *client = ts->client;
-        int ret;
-
-        ret = auo_pixcir_int_toggle(ts, 0);
-        if (ret < 0) {
-                dev_err(&client->dev, "could not disable interrupt, %d\n",
-                        ret);
-                return ret;
-        }
-
-        /* disable receiving of interrupts */
-        disable_irq(client->irq);
-        ts->stopped = true;
-        mb();
-        wake_up(&ts->wait);
-
-        return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP);
-}
-
-static int auo_pixcir_input_open(struct input_dev *dev)
-{
-        struct auo_pixcir_ts *ts = input_get_drvdata(dev);
-        int ret;
-
-        ret = auo_pixcir_start(ts);
-        if (ret)
-                return ret;
-
-        return 0;
-}
-
-static void auo_pixcir_input_close(struct input_dev *dev)
-{
-        struct auo_pixcir_ts *ts = input_get_drvdata(dev);
-
-        auo_pixcir_stop(ts);
-
-        return;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int auo_pixcir_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
-        struct input_dev *input = ts->input;
-        int ret = 0;
-
-        mutex_lock(&input->mutex);
-
-        /* when configured as wakeup source, device should always wake system
-         * therefore start device if necessary
-         */
-        if (device_may_wakeup(&client->dev)) {
-                /* need to start device if not open, to be wakeup source */
-                if (!input->users) {
-                        ret = auo_pixcir_start(ts);
-                        if (ret)
-                                goto unlock;
-                }
-
-                enable_irq_wake(client->irq);
-                ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP);
-        } else if (input->users) {
-                ret = auo_pixcir_stop(ts);
-        }
-
-unlock:
-        mutex_unlock(&input->mutex);
-
-        return ret;
-}
-
-static int auo_pixcir_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
-        struct input_dev *input = ts->input;
-        int ret = 0;
-
-        mutex_lock(&input->mutex);
-
-        if (device_may_wakeup(&client->dev)) {
-                disable_irq_wake(client->irq);
-
-                /* need to stop device if it was not open on suspend */
-                if (!input->users) {
-                        ret = auo_pixcir_stop(ts);
-                        if (ret)
-                                goto unlock;
-                }
-
-                /* device wakes automatically from SLEEP */
-        } else if (input->users) {
-                ret = auo_pixcir_start(ts);
-        }
-
-unlock:
-        mutex_unlock(&input->mutex);
-
-        return ret;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops, auo_pixcir_suspend,
-                         auo_pixcir_resume);
-
-static int auo_pixcir_probe(struct i2c_client *client,
-                                      const struct i2c_device_id *id)
-{
-        const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
-        struct auo_pixcir_ts *ts;
-        struct input_dev *input_dev;
-        int ret;
-
-        if (!pdata)
-                return -EINVAL;
-
-        ts = kzalloc(sizeof(struct auo_pixcir_ts), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-
-        ret = gpio_request(pdata->gpio_int, "auo_pixcir_ts_int");
-        if (ret) {
-                dev_err(&client->dev, "request of gpio %d failed, %d\n",
-                        pdata->gpio_int, ret);
-                goto err_gpio_int;
-        }
-
-        if (pdata->init_hw)
-                pdata->init_hw(client);
-
-        ts->client = client;
-        ts->touch_ind_mode = 0;
-        init_waitqueue_head(&ts->wait);
-
-        snprintf(ts->phys, sizeof(ts->phys),
-                 "%s/input0", dev_name(&client->dev));
-
-        input_dev = input_allocate_device();
-        if (!input_dev) {
-                dev_err(&client->dev, "could not allocate input device\n");
-                goto err_input_alloc;
-        }
-
-        ts->input = input_dev;
-
-        input_dev->name = "AUO-Pixcir touchscreen";
-        input_dev->phys = ts->phys;
-        input_dev->id.bustype = BUS_I2C;
-        input_dev->dev.parent = &client->dev;
-
-        input_dev->open = auo_pixcir_input_open;
-        input_dev->close = auo_pixcir_input_close;
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-
-        /* For single touch */
-        input_set_abs_params(input_dev, ABS_X, 0, pdata->x_max, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, pdata->y_max, 0, 0);
-
-        /* For multi touch */
-        input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
-                             pdata->x_max, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
-                             pdata->y_max, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
-                             AUO_PIXCIR_MAX_AREA, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
-                             AUO_PIXCIR_MAX_AREA, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
-
-        ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION);
-        if (ret < 0)
-                goto err_fw_vers;
-        dev_info(&client->dev, "firmware version 0x%X\n", ret);
-
-        ret = auo_pixcir_int_config(ts, pdata->int_setting);
-        if (ret)
-                goto err_fw_vers;
-
-        input_set_drvdata(ts->input, ts);
-        ts->stopped = true;
-
-        ret = request_threaded_irq(client->irq, NULL, auo_pixcir_interrupt,
-                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                   input_dev->name, ts);
-        if (ret) {
-                dev_err(&client->dev, "irq %d requested failed\n", client->irq);
-                goto err_fw_vers;
-        }
-
-        /* stop device and put it into deep sleep until it is opened */
-        ret = auo_pixcir_stop(ts);
-        if (ret < 0)
-                goto err_input_register;
-
-        ret = input_register_device(input_dev);
-        if (ret) {
-                dev_err(&client->dev, "could not register input device\n");
-                goto err_input_register;
-        }
-
-        i2c_set_clientdata(client, ts);
-
-        return 0;
-
-err_input_register:
-        free_irq(client->irq, ts);
-err_fw_vers:
-        input_free_device(input_dev);
-err_input_alloc:
-        if (pdata->exit_hw)
-                pdata->exit_hw(client);
-        gpio_free(pdata->gpio_int);
-err_gpio_int:
-        kfree(ts);
-
-        return ret;
-}
-
-static int auo_pixcir_remove(struct i2c_client *client)
-{
-        struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
-        const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
-
-        free_irq(client->irq, ts);
-
-        input_unregister_device(ts->input);
-
-        if (pdata->exit_hw)
-                pdata->exit_hw(client);
-
-        gpio_free(pdata->gpio_int);
-
-        kfree(ts);
-
-        return 0;
-}
-
-static const struct i2c_device_id auo_pixcir_idtable[] = {
-        { "auo_pixcir_ts", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable);
-
-static struct i2c_driver auo_pixcir_driver = {
-        .driver = {
-                .owner  = THIS_MODULE,
-                .name   = "auo_pixcir_ts",
-                .pm     = &auo_pixcir_pm_ops,
-        },
-        .probe          = auo_pixcir_probe,
-        .remove         = auo_pixcir_remove,
-        .id_table       = auo_pixcir_idtable,
-};
-
-module_i2c_driver(auo_pixcir_driver);
-
-MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver");
-MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
diff --git a/drivers/input/touchscreen/bu21013_ts.c b/drivers/input/touchscreen/bu21013_ts.c
index b9b5ddad665..1507ce108d5 100644
--- a/drivers/input/touchscreen/bu21013_ts.c
+++ b/drivers/input/touchscreen/bu21013_ts.c
@@ -13,10 +13,6 @@
 #include <linux/input/bu21013.h>
 #include <linux/slab.h>
 #include <linux/regulator/consumer.h>
-#include <linux/module.h>
-#include <linux/gpio.h>
-#include <linux/of.h>
-#include <linux/of_gpio.h>
 
 #define PEN_DOWN_INTR   0
 #define MAX_FINGERS     2
@@ -151,12 +147,11 @@
 struct bu21013_ts_data {
         struct i2c_client *client;
         wait_queue_head_t wait;
+        bool touch_stopped;
         const struct bu21013_platform_device *chip;
         struct input_dev *in_dev;
-        struct regulator *regulator;
-        unsigned int irq;
         unsigned int intr_pin;
-        bool touch_stopped;
+        struct regulator *regulator;
 };
 
 /**
@@ -266,7 +261,7 @@ static irqreturn_t bu21013_gpio_irq(int irq, void *device_data)
                         return IRQ_NONE;
                 }
 
-                data->intr_pin = gpio_get_value(data->chip->touch_pin);
+                data->intr_pin = data->chip->irq_read_val();
                 if (data->intr_pin == PEN_DOWN_INTR)
                         wait_event_timeout(data->wait, data->touch_stopped,
                                            msecs_to_jiffies(2));
@@ -422,72 +417,10 @@ static void bu21013_free_irq(struct bu21013_ts_data *bu21013_data)
 {
         bu21013_data->touch_stopped = true;
         wake_up(&bu21013_data->wait);
-        free_irq(bu21013_data->irq, bu21013_data);
+        free_irq(bu21013_data->chip->irq, bu21013_data);
 }
 
 /**
- * bu21013_cs_disable() - deconfigures the touch panel controller
- * @bu21013_data: device structure pointer
- *
- * This function is used to deconfigure the chip selection
- * for touch panel controller.
- */
-static void bu21013_cs_disable(struct bu21013_ts_data *bu21013_data)
-{
-        int error;
-
-        error = gpio_direction_output(bu21013_data->chip->cs_pin, 0);
-        if (error < 0)
-                dev_warn(&bu21013_data->client->dev,
-                         "%s: gpio direction failed, error: %d\n",
-                         __func__, error);
-        else
-                gpio_set_value(bu21013_data->chip->cs_pin, 0);
-
-        gpio_free(bu21013_data->chip->cs_pin);
-}
-
-#ifdef CONFIG_OF
-static const struct bu21013_platform_device *
-bu21013_parse_dt(struct device *dev)
-{
-        struct device_node *np = dev->of_node;
-        struct bu21013_platform_device *pdata;
-
-        if (!np) {
-                dev_err(dev, "no device tree or platform data\n");
-                return ERR_PTR(-EINVAL);
-        }
-
-        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata)
-                return ERR_PTR(-ENOMEM);
-
-        pdata->y_flip = pdata->x_flip = false;
-
-        pdata->x_flip = of_property_read_bool(np, "rohm,flip-x");
-        pdata->y_flip = of_property_read_bool(np, "rohm,flip-y");
-
-        of_property_read_u32(np, "rohm,touch-max-x", &pdata->touch_x_max);
-        of_property_read_u32(np, "rohm,touch-max-y", &pdata->touch_y_max);
-
-        pdata->touch_pin = of_get_named_gpio(np, "touch-gpio", 0);
-        pdata->cs_pin = of_get_named_gpio(np, "reset-gpio", 0);
-
-        pdata->ext_clk = false;
-
-        return pdata;
-}
-#else
-static inline const struct bu21013_platform_device *
-bu21013_parse_dt(struct device *dev)
-{
-        dev_err(dev, "no platform data available\n");
-        return ERR_PTR(-EINVAL);
-}
-#endif
-
-/**
  * bu21013_probe() - initializes the i2c-client touchscreen driver
  * @client: i2c client structure pointer
  * @id: i2c device id pointer
@@ -495,13 +428,13 @@ bu21013_parse_dt(struct device *dev)
  * This function used to initializes the i2c-client touchscreen
  * driver and returns integer.
  */
-static int bu21013_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
+static int __devinit bu21013_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
 {
-        const struct bu21013_platform_device *pdata =
-                                        dev_get_platdata(&client->dev);
         struct bu21013_ts_data *bu21013_data;
         struct input_dev *in_dev;
+        const struct bu21013_platform_device *pdata =
+                                        client->dev.platform_data;
         int error;
 
         if (!i2c_check_functionality(client->adapter,
@@ -511,13 +444,7 @@ static int bu21013_probe(struct i2c_client *client,
         }
 
         if (!pdata) {
-                pdata = bu21013_parse_dt(&client->dev);
-                if (IS_ERR(pdata))
-                        return PTR_ERR(pdata);
-        }
-
-        if (!gpio_is_valid(pdata->touch_pin)) {
-                dev_err(&client->dev, "invalid touch_pin supplied\n");
+                dev_err(&client->dev, "platform data not defined\n");
                 return -EINVAL;
         }
 
@@ -532,9 +459,8 @@ static int bu21013_probe(struct i2c_client *client,
         bu21013_data->in_dev = in_dev;
         bu21013_data->chip = pdata;
         bu21013_data->client = client;
-        bu21013_data->irq = gpio_to_irq(pdata->touch_pin);
 
-        bu21013_data->regulator = regulator_get(&client->dev, "avdd");
+        bu21013_data->regulator = regulator_get(&client->dev, "V-TOUCH");
         if (IS_ERR(bu21013_data->regulator)) {
                 dev_err(&client->dev, "regulator_get failed\n");
                 error = PTR_ERR(bu21013_data->regulator);
@@ -551,11 +477,12 @@ static int bu21013_probe(struct i2c_client *client,
         init_waitqueue_head(&bu21013_data->wait);
 
         /* configure the gpio pins */
-        error = gpio_request_one(pdata->cs_pin, GPIOF_OUT_INIT_HIGH,
-                                 "touchp_reset");
-        if (error < 0) {
-                dev_err(&client->dev, "Unable to request gpio reset_pin\n");
-                goto err_disable_regulator;
+        if (pdata->cs_en) {
+                error = pdata->cs_en(pdata->cs_pin);
+                if (error < 0) {
+                        dev_err(&client->dev, "chip init failed\n");
+                        goto err_disable_regulator;
+                }
         }
 
         /* configure the touch panel controller */
@@ -580,13 +507,11 @@ static int bu21013_probe(struct i2c_client *client,
                                                 pdata->touch_y_max, 0, 0);
         input_set_drvdata(in_dev, bu21013_data);
 
-        error = request_threaded_irq(bu21013_data->irq, NULL, bu21013_gpio_irq,
-                                     IRQF_TRIGGER_FALLING | IRQF_SHARED |
-                                        IRQF_ONESHOT,
+        error = request_threaded_irq(pdata->irq, NULL, bu21013_gpio_irq,
+                                     IRQF_TRIGGER_FALLING | IRQF_SHARED,
                                      DRIVER_TP, bu21013_data);
         if (error) {
-                dev_err(&client->dev, "request irq %d failed\n",
-                        bu21013_data->irq);
+                dev_err(&client->dev, "request irq %d failed\n", pdata->irq);
                 goto err_cs_disable;
         }
 
@@ -604,7 +529,7 @@ static int bu21013_probe(struct i2c_client *client,
 err_free_irq:
         bu21013_free_irq(bu21013_data);
 err_cs_disable:
-        bu21013_cs_disable(bu21013_data);
+        pdata->cs_dis(pdata->cs_pin);
 err_disable_regulator:
         regulator_disable(bu21013_data->regulator);
 err_put_regulator:
@@ -622,13 +547,13 @@ err_free_mem:
  * This function uses to remove the i2c-client
  * touchscreen driver and returns integer.
  */
-static int bu21013_remove(struct i2c_client *client)
+static int __devexit bu21013_remove(struct i2c_client *client)
 {
         struct bu21013_ts_data *bu21013_data = i2c_get_clientdata(client);
 
         bu21013_free_irq(bu21013_data);
 
-        bu21013_cs_disable(bu21013_data);
+        bu21013_data->chip->cs_dis(bu21013_data->chip->cs_pin);
 
         input_unregister_device(bu21013_data->in_dev);
 
@@ -657,9 +582,9 @@ static int bu21013_suspend(struct device *dev)
 
         bu21013_data->touch_stopped = true;
         if (device_may_wakeup(&client->dev))
-                enable_irq_wake(bu21013_data->irq);
+                enable_irq_wake(bu21013_data->chip->irq);
         else
-                disable_irq(bu21013_data->irq);
+                disable_irq(bu21013_data->chip->irq);
 
         regulator_disable(bu21013_data->regulator);
 
@@ -694,9 +619,9 @@ static int bu21013_resume(struct device *dev)
         bu21013_data->touch_stopped = false;
 
         if (device_may_wakeup(&client->dev))
-                disable_irq_wake(bu21013_data->irq);
+                disable_irq_wake(bu21013_data->chip->irq);
         else
-                enable_irq(bu21013_data->irq);
+                enable_irq(bu21013_data->chip->irq);
 
         return 0;
 }
@@ -722,11 +647,34 @@ static struct i2c_driver bu21013_driver = {
 #endif
         },
         .probe          =       bu21013_probe,
-        .remove         =       bu21013_remove,
+        .remove         =       __devexit_p(bu21013_remove),
         .id_table       =       bu21013_id,
 };
 
-module_i2c_driver(bu21013_driver);
+/**
+ * bu21013_init() - initializes the bu21013 touchscreen driver
+ *
+ * This function used to initializes the bu21013
+ * touchscreen driver and returns integer.
+ */
+static int __init bu21013_init(void)
+{
+        return i2c_add_driver(&bu21013_driver);
+}
+
+/**
+ * bu21013_exit() - de-initializes the bu21013 touchscreen driver
+ *
+ * This function uses to de-initializes the bu21013
+ * touchscreen driver and returns none.
+ */
+static void __exit bu21013_exit(void)
+{
+        i2c_del_driver(&bu21013_driver);
+}
+
+module_init(bu21013_init);
+module_exit(bu21013_exit);
 
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>");
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
index 96e0eedcc7e..d8815c5d54a 100644
--- a/drivers/input/touchscreen/cy8ctmg110_ts.c
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -99,18 +99,9 @@ static int cy8ctmg110_read_regs(struct cy8ctmg110 *tsc,
         int ret;
         struct i2c_msg msg[2] = {
                 /* first write slave position to i2c devices */
-                {
-                        .addr = client->addr,
-                        .len = 1,
-                        .buf = &cmd
-                },
+                { client->addr, 0, 1, &cmd },
                 /* Second read data from position */
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = len,
-                        .buf = data
-                }
+                { client->addr, I2C_M_RD, len, data }
         };
 
         ret = i2c_transfer(client->adapter, msg, 2);
@@ -175,7 +166,7 @@ static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int cy8ctmg110_probe(struct i2c_client *client,
+static int __devinit cy8ctmg110_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
         const struct cy8ctmg110_pdata *pdata = client->dev.platform_data;
@@ -260,8 +251,7 @@ static int cy8ctmg110_probe(struct i2c_client *client,
         }
 
         err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
-                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                   "touch_reset_key", ts);
+                                   IRQF_TRIGGER_RISING, "touch_reset_key", ts);
         if (err < 0) {
                 dev_err(&client->dev,
                         "irq %d busy? error %d\n", client->irq, err);
@@ -323,7 +313,7 @@ static int cy8ctmg110_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume);
 #endif
 
-static int cy8ctmg110_remove(struct i2c_client *client)
+static int __devexit cy8ctmg110_remove(struct i2c_client *client)
 {
         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 
@@ -357,10 +347,21 @@ static struct i2c_driver cy8ctmg110_driver = {
         },
         .id_table       = cy8ctmg110_idtable,
         .probe          = cy8ctmg110_probe,
-        .remove         = cy8ctmg110_remove,
+        .remove         = __devexit_p(cy8ctmg110_remove),
 };
 
-module_i2c_driver(cy8ctmg110_driver);
+static int __init cy8ctmg110_init(void)
+{
+        return i2c_add_driver(&cy8ctmg110_driver);
+}
+
+static void __exit cy8ctmg110_exit(void)
+{
+        i2c_del_driver(&cy8ctmg110_driver);
+}
+
+module_init(cy8ctmg110_init);
+module_exit(cy8ctmg110_exit);
 
 MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>");
 MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver");
diff --git a/drivers/input/touchscreen/cyttsp_core.c b/drivers/input/touchscreen/cyttsp_core.c
deleted file mode 100644
index 8e60437ac85..00000000000
--- a/drivers/input/touchscreen/cyttsp_core.c
+++ /dev/null
@@ -1,625 +0,0 @@
-/*
- * Core Source for:
- * Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers.
- * For use with Cypress Txx3xx parts.
- * Supported parts include:
- * CY8CTST341
- * CY8CTMA340
- *
- * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
- * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2, and only version 2, as published by the
- * Free Software Foundation.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
- *
- */
-
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/input/mt.h>
-#include <linux/gpio.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-
-#include "cyttsp_core.h"
-
-/* Bootloader number of command keys */
-#define CY_NUM_BL_KEYS          8
-
-/* helpers */
-#define GET_NUM_TOUCHES(x)              ((x) & 0x0F)
-#define IS_LARGE_AREA(x)                (((x) & 0x10) >> 4)
-#define IS_BAD_PKT(x)                   ((x) & 0x20)
-#define IS_VALID_APP(x)                 ((x) & 0x01)
-#define IS_OPERATIONAL_ERR(x)           ((x) & 0x3F)
-#define GET_HSTMODE(reg)                (((reg) & 0x70) >> 4)
-#define GET_BOOTLOADERMODE(reg)         (((reg) & 0x10) >> 4)
-
-#define CY_REG_BASE                     0x00
-#define CY_REG_ACT_DIST                 0x1E
-#define CY_REG_ACT_INTRVL               0x1D
-#define CY_REG_TCH_TMOUT                (CY_REG_ACT_INTRVL + 1)
-#define CY_REG_LP_INTRVL                (CY_REG_TCH_TMOUT + 1)
-#define CY_MAXZ                         255
-#define CY_DELAY_DFLT                   20 /* ms */
-#define CY_DELAY_MAX                    500
-#define CY_ACT_DIST_DFLT                0xF8
-#define CY_HNDSHK_BIT                   0x80
-/* device mode bits */
-#define CY_OPERATE_MODE                 0x00
-#define CY_SYSINFO_MODE                 0x10
-/* power mode select bits */
-#define CY_SOFT_RESET_MODE              0x01 /* return to Bootloader mode */
-#define CY_DEEP_SLEEP_MODE              0x02
-#define CY_LOW_POWER_MODE               0x04
-
-/* Slots management */
-#define CY_MAX_FINGER                   4
-#define CY_MAX_ID                       16
-
-static const u8 bl_command[] = {
-        0x00,                   /* file offset */
-        0xFF,                   /* command */
-        0xA5,                   /* exit bootloader command */
-        0, 1, 2, 3, 4, 5, 6, 7  /* default keys */
-};
-
-static int ttsp_read_block_data(struct cyttsp *ts, u8 command,
-                                u8 length, void *buf)
-{
-        int error;
-        int tries;
-
-        for (tries = 0; tries < CY_NUM_RETRY; tries++) {
-                error = ts->bus_ops->read(ts, command, length, buf);
-                if (!error)
-                        return 0;
-
-                msleep(CY_DELAY_DFLT);
-        }
-
-        return -EIO;
-}
-
-static int ttsp_write_block_data(struct cyttsp *ts, u8 command,
-                                 u8 length, void *buf)
-{
-        int error;
-        int tries;
-
-        for (tries = 0; tries < CY_NUM_RETRY; tries++) {
-                error = ts->bus_ops->write(ts, command, length, buf);
-                if (!error)
-                        return 0;
-
-                msleep(CY_DELAY_DFLT);
-        }
-
-        return -EIO;
-}
-
-static int ttsp_send_command(struct cyttsp *ts, u8 cmd)
-{
-        return ttsp_write_block_data(ts, CY_REG_BASE, sizeof(cmd), &cmd);
-}
-
-static int cyttsp_load_bl_regs(struct cyttsp *ts)
-{
-        memset(&ts->bl_data, 0, sizeof(ts->bl_data));
-        ts->bl_data.bl_status = 0x10;
-
-        return ttsp_read_block_data(ts, CY_REG_BASE,
-                                    sizeof(ts->bl_data), &ts->bl_data);
-}
-
-static int cyttsp_exit_bl_mode(struct cyttsp *ts)
-{
-        int error;
-        u8 bl_cmd[sizeof(bl_command)];
-
-        memcpy(bl_cmd, bl_command, sizeof(bl_command));
-        if (ts->pdata->bl_keys)
-                memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS],
-                        ts->pdata->bl_keys, sizeof(bl_command));
-
-        error = ttsp_write_block_data(ts, CY_REG_BASE,
-                                      sizeof(bl_cmd), bl_cmd);
-        if (error)
-                return error;
-
-        /* wait for TTSP Device to complete the operation */
-        msleep(CY_DELAY_DFLT);
-
-        error = cyttsp_load_bl_regs(ts);
-        if (error)
-                return error;
-
-        if (GET_BOOTLOADERMODE(ts->bl_data.bl_status))
-                return -EIO;
-
-        return 0;
-}
-
-static int cyttsp_set_operational_mode(struct cyttsp *ts)
-{
-        int error;
-
-        error = ttsp_send_command(ts, CY_OPERATE_MODE);
-        if (error)
-                return error;
-
-        /* wait for TTSP Device to complete switch to Operational mode */
-        error = ttsp_read_block_data(ts, CY_REG_BASE,
-                                     sizeof(ts->xy_data), &ts->xy_data);
-        if (error)
-                return error;
-
-        return ts->xy_data.act_dist == CY_ACT_DIST_DFLT ? -EIO : 0;
-}
-
-static int cyttsp_set_sysinfo_mode(struct cyttsp *ts)
-{
-        int error;
-
-        memset(&ts->sysinfo_data, 0, sizeof(ts->sysinfo_data));
-
-        /* switch to sysinfo mode */
-        error = ttsp_send_command(ts, CY_SYSINFO_MODE);
-        if (error)
-                return error;
-
-        /* read sysinfo registers */
-        msleep(CY_DELAY_DFLT);
-        error = ttsp_read_block_data(ts, CY_REG_BASE, sizeof(ts->sysinfo_data),
-                                      &ts->sysinfo_data);
-        if (error)
-                return error;
-
-        if (!ts->sysinfo_data.tts_verh && !ts->sysinfo_data.tts_verl)
-                return -EIO;
-
-        return 0;
-}
-
-static int cyttsp_set_sysinfo_regs(struct cyttsp *ts)
-{
-        int retval = 0;
-
-        if (ts->pdata->act_intrvl != CY_ACT_INTRVL_DFLT ||
-            ts->pdata->tch_tmout != CY_TCH_TMOUT_DFLT ||
-            ts->pdata->lp_intrvl != CY_LP_INTRVL_DFLT) {
-
-                u8 intrvl_ray[] = {
-                        ts->pdata->act_intrvl,
-                        ts->pdata->tch_tmout,
-                        ts->pdata->lp_intrvl
-                };
-
-                /* set intrvl registers */
-                retval = ttsp_write_block_data(ts, CY_REG_ACT_INTRVL,
-                                        sizeof(intrvl_ray), intrvl_ray);
-                msleep(CY_DELAY_DFLT);
-        }
-
-        return retval;
-}
-
-static int cyttsp_soft_reset(struct cyttsp *ts)
-{
-        unsigned long timeout;
-        int retval;
-
-        /* wait for interrupt to set ready completion */
-        INIT_COMPLETION(ts->bl_ready);
-        ts->state = CY_BL_STATE;
-
-        enable_irq(ts->irq);
-
-        retval = ttsp_send_command(ts, CY_SOFT_RESET_MODE);
-        if (retval)
-                goto out;
-
-        timeout = wait_for_completion_timeout(&ts->bl_ready,
-                        msecs_to_jiffies(CY_DELAY_DFLT * CY_DELAY_MAX));
-        retval = timeout ? 0 : -EIO;
-
-out:
-        ts->state = CY_IDLE_STATE;
-        disable_irq(ts->irq);
-        return retval;
-}
-
-static int cyttsp_act_dist_setup(struct cyttsp *ts)
-{
-        u8 act_dist_setup = ts->pdata->act_dist;
-
-        /* Init gesture; active distance setup */
-        return ttsp_write_block_data(ts, CY_REG_ACT_DIST,
-                                sizeof(act_dist_setup), &act_dist_setup);
-}
-
-static void cyttsp_extract_track_ids(struct cyttsp_xydata *xy_data, int *ids)
-{
-        ids[0] = xy_data->touch12_id >> 4;
-        ids[1] = xy_data->touch12_id & 0xF;
-        ids[2] = xy_data->touch34_id >> 4;
-        ids[3] = xy_data->touch34_id & 0xF;
-}
-
-static const struct cyttsp_tch *cyttsp_get_tch(struct cyttsp_xydata *xy_data,
-                                               int idx)
-{
-        switch (idx) {
-        case 0:
-                return &xy_data->tch1;
-        case 1:
-                return &xy_data->tch2;
-        case 2:
-                return &xy_data->tch3;
-        case 3:
-                return &xy_data->tch4;
-        default:
-                return NULL;
-        }
-}
-
-static void cyttsp_report_tchdata(struct cyttsp *ts)
-{
-        struct cyttsp_xydata *xy_data = &ts->xy_data;
-        struct input_dev *input = ts->input;
-        int num_tch = GET_NUM_TOUCHES(xy_data->tt_stat);
-        const struct cyttsp_tch *tch;
-        int ids[CY_MAX_ID];
-        int i;
-        DECLARE_BITMAP(used, CY_MAX_ID);
-
-        if (IS_LARGE_AREA(xy_data->tt_stat) == 1) {
-                /* terminate all active tracks */
-                num_tch = 0;
-                dev_dbg(ts->dev, "%s: Large area detected\n", __func__);
-        } else if (num_tch > CY_MAX_FINGER) {
-                /* terminate all active tracks */
-                num_tch = 0;
-                dev_dbg(ts->dev, "%s: Num touch error detected\n", __func__);
-        } else if (IS_BAD_PKT(xy_data->tt_mode)) {
-                /* terminate all active tracks */
-                num_tch = 0;
-                dev_dbg(ts->dev, "%s: Invalid buffer detected\n", __func__);
-        }
-
-        cyttsp_extract_track_ids(xy_data, ids);
-
-        bitmap_zero(used, CY_MAX_ID);
-
-        for (i = 0; i < num_tch; i++) {
-                tch = cyttsp_get_tch(xy_data, i);
-
-                input_mt_slot(input, ids[i]);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
-                input_report_abs(input, ABS_MT_POSITION_X, be16_to_cpu(tch->x));
-                input_report_abs(input, ABS_MT_POSITION_Y, be16_to_cpu(tch->y));
-                input_report_abs(input, ABS_MT_TOUCH_MAJOR, tch->z);
-
-                __set_bit(ids[i], used);
-        }
-
-        for (i = 0; i < CY_MAX_ID; i++) {
-                if (test_bit(i, used))
-                        continue;
-
-                input_mt_slot(input, i);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
-        }
-
-        input_sync(input);
-}
-
-static irqreturn_t cyttsp_irq(int irq, void *handle)
-{
-        struct cyttsp *ts = handle;
-        int error;
-
-        if (unlikely(ts->state == CY_BL_STATE)) {
-                complete(&ts->bl_ready);
-                goto out;
-        }
-
-        /* Get touch data from CYTTSP device */
-        error = ttsp_read_block_data(ts, CY_REG_BASE,
-                                 sizeof(struct cyttsp_xydata), &ts->xy_data);
-        if (error)
-                goto out;
-
-        /* provide flow control handshake */
-        if (ts->pdata->use_hndshk) {
-                error = ttsp_send_command(ts,
-                                ts->xy_data.hst_mode ^ CY_HNDSHK_BIT);
-                if (error)
-                        goto out;
-        }
-
-        if (unlikely(ts->state == CY_IDLE_STATE))
-                goto out;
-
-        if (GET_BOOTLOADERMODE(ts->xy_data.tt_mode)) {
-                /*
-                 * TTSP device has reset back to bootloader mode.
-                 * Restore to operational mode.
-                 */
-                error = cyttsp_exit_bl_mode(ts);
-                if (error) {
-                        dev_err(ts->dev,
-                                "Could not return to operational mode, err: %d\n",
-                                error);
-                        ts->state = CY_IDLE_STATE;
-                }
-        } else {
-                cyttsp_report_tchdata(ts);
-        }
-
-out:
-        return IRQ_HANDLED;
-}
-
-static int cyttsp_power_on(struct cyttsp *ts)
-{
-        int error;
-
-        error = cyttsp_soft_reset(ts);
-        if (error)
-                return error;
-
-        error = cyttsp_load_bl_regs(ts);
-        if (error)
-                return error;
-
-        if (GET_BOOTLOADERMODE(ts->bl_data.bl_status) &&
-            IS_VALID_APP(ts->bl_data.bl_status)) {
-                error = cyttsp_exit_bl_mode(ts);
-                if (error)
-                        return error;
-        }
-
-        if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE ||
-            IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) {
-                return -ENODEV;
-        }
-
-        error = cyttsp_set_sysinfo_mode(ts);
-        if (error)
-                return error;
-
-        error = cyttsp_set_sysinfo_regs(ts);
-        if (error)
-                return error;
-
-        error = cyttsp_set_operational_mode(ts);
-        if (error)
-                return error;
-
-        /* init active distance */
-        error = cyttsp_act_dist_setup(ts);
-        if (error)
-                return error;
-
-        ts->state = CY_ACTIVE_STATE;
-
-        return 0;
-}
-
-static int cyttsp_enable(struct cyttsp *ts)
-{
-        int error;
-
-        /*
-         * The device firmware can wake on an I2C or SPI memory slave
-         * address match. So just reading a register is sufficient to
-         * wake up the device. The first read attempt will fail but it
-         * will wake it up making the second read attempt successful.
-         */
-        error = ttsp_read_block_data(ts, CY_REG_BASE,
-                                     sizeof(ts->xy_data), &ts->xy_data);
-        if (error)
-                return error;
-
-        if (GET_HSTMODE(ts->xy_data.hst_mode))
-                return -EIO;
-
-        enable_irq(ts->irq);
-
-        return 0;
-}
-
-static int cyttsp_disable(struct cyttsp *ts)
-{
-        int error;
-
-        error = ttsp_send_command(ts, CY_LOW_POWER_MODE);
-        if (error)
-                return error;
-
-        disable_irq(ts->irq);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int cyttsp_suspend(struct device *dev)
-{
-        struct cyttsp *ts = dev_get_drvdata(dev);
-        int retval = 0;
-
-        mutex_lock(&ts->input->mutex);
-
-        if (ts->input->users) {
-                retval = cyttsp_disable(ts);
-                if (retval == 0)
-                        ts->suspended = true;
-        }
-
-        mutex_unlock(&ts->input->mutex);
-
-        return retval;
-}
-
-static int cyttsp_resume(struct device *dev)
-{
-        struct cyttsp *ts = dev_get_drvdata(dev);
-
-        mutex_lock(&ts->input->mutex);
-
-        if (ts->input->users)
-                cyttsp_enable(ts);
-
-        ts->suspended = false;
-
-        mutex_unlock(&ts->input->mutex);
-
-        return 0;
-}
-
-#endif
-
-SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume);
-EXPORT_SYMBOL_GPL(cyttsp_pm_ops);
-
-static int cyttsp_open(struct input_dev *dev)
-{
-        struct cyttsp *ts = input_get_drvdata(dev);
-        int retval = 0;
-
-        if (!ts->suspended)
-                retval = cyttsp_enable(ts);
-
-        return retval;
-}
-
-static void cyttsp_close(struct input_dev *dev)
-{
-        struct cyttsp *ts = input_get_drvdata(dev);
-
-        if (!ts->suspended)
-                cyttsp_disable(ts);
-}
-
-struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops,
-                            struct device *dev, int irq, size_t xfer_buf_size)
-{
-        const struct cyttsp_platform_data *pdata = dev->platform_data;
-        struct cyttsp *ts;
-        struct input_dev *input_dev;
-        int error;
-
-        if (!pdata || !pdata->name || irq <= 0) {
-                error = -EINVAL;
-                goto err_out;
-        }
-
-        ts = kzalloc(sizeof(*ts) + xfer_buf_size, GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!ts || !input_dev) {
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        ts->dev = dev;
-        ts->input = input_dev;
-        ts->pdata = dev->platform_data;
-        ts->bus_ops = bus_ops;
-        ts->irq = irq;
-
-        init_completion(&ts->bl_ready);
-        snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
-
-        if (pdata->init) {
-                error = pdata->init();
-                if (error) {
-                        dev_err(ts->dev, "platform init failed, err: %d\n",
-                                error);
-                        goto err_free_mem;
-                }
-        }
-
-        input_dev->name = pdata->name;
-        input_dev->phys = ts->phys;
-        input_dev->id.bustype = bus_ops->bustype;
-        input_dev->dev.parent = ts->dev;
-
-        input_dev->open = cyttsp_open;
-        input_dev->close = cyttsp_close;
-
-        input_set_drvdata(input_dev, ts);
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
-                             0, pdata->maxx, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
-                             0, pdata->maxy, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
-                             0, CY_MAXZ, 0, 0);
-
-        input_mt_init_slots(input_dev, CY_MAX_ID, 0);
-
-        error = request_threaded_irq(ts->irq, NULL, cyttsp_irq,
-                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
-                                     pdata->name, ts);
-        if (error) {
-                dev_err(ts->dev, "failed to request IRQ %d, err: %d\n",
-                        ts->irq, error);
-                goto err_platform_exit;
-        }
-
-        disable_irq(ts->irq);
-
-        error = cyttsp_power_on(ts);
-        if (error)
-                goto err_free_irq;
-
-        error = input_register_device(input_dev);
-        if (error) {
-                dev_err(ts->dev, "failed to register input device: %d\n",
-                        error);
-                goto err_free_irq;
-        }
-
-        return ts;
-
-err_free_irq:
-        free_irq(ts->irq, ts);
-err_platform_exit:
-        if (pdata->exit)
-                pdata->exit();
-err_free_mem:
-        input_free_device(input_dev);
-        kfree(ts);
-err_out:
-        return ERR_PTR(error);
-}
-EXPORT_SYMBOL_GPL(cyttsp_probe);
-
-void cyttsp_remove(struct cyttsp *ts)
-{
-        free_irq(ts->irq, ts);
-        input_unregister_device(ts->input);
-        if (ts->pdata->exit)
-                ts->pdata->exit();
-        kfree(ts);
-}
-EXPORT_SYMBOL_GPL(cyttsp_remove);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core");
-MODULE_AUTHOR("Cypress");
diff --git a/drivers/input/touchscreen/cyttsp_core.h b/drivers/input/touchscreen/cyttsp_core.h
deleted file mode 100644
index 1aa3c6967e7..00000000000
--- a/drivers/input/touchscreen/cyttsp_core.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Header file for:
- * Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers.
- * For use with Cypress Txx3xx parts.
- * Supported parts include:
- * CY8CTST341
- * CY8CTMA340
- *
- * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
- * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2, and only version 2, as published by the
- * Free Software Foundation.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
- *
- */
-
-
-#ifndef __CYTTSP_CORE_H__
-#define __CYTTSP_CORE_H__
-
-#include <linux/kernel.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/device.h>
-#include <linux/input/cyttsp.h>
-
-#define CY_NUM_RETRY            16 /* max number of retries for read ops */
-
-struct cyttsp_tch {
-        __be16 x, y;
-        u8 z;
-} __packed;
-
-/* TrueTouch Standard Product Gen3 interface definition */
-struct cyttsp_xydata {
-        u8 hst_mode;
-        u8 tt_mode;
-        u8 tt_stat;
-        struct cyttsp_tch tch1;
-        u8 touch12_id;
-        struct cyttsp_tch tch2;
-        u8 gest_cnt;
-        u8 gest_id;
-        struct cyttsp_tch tch3;
-        u8 touch34_id;
-        struct cyttsp_tch tch4;
-        u8 tt_undef[3];
-        u8 act_dist;
-        u8 tt_reserved;
-} __packed;
-
-
-/* TTSP System Information interface definition */
-struct cyttsp_sysinfo_data {
-        u8 hst_mode;
-        u8 mfg_cmd;
-        u8 mfg_stat;
-        u8 cid[3];
-        u8 tt_undef1;
-        u8 uid[8];
-        u8 bl_verh;
-        u8 bl_verl;
-        u8 tts_verh;
-        u8 tts_verl;
-        u8 app_idh;
-        u8 app_idl;
-        u8 app_verh;
-        u8 app_verl;
-        u8 tt_undef[5];
-        u8 scn_typ;
-        u8 act_intrvl;
-        u8 tch_tmout;
-        u8 lp_intrvl;
-};
-
-/* TTSP Bootloader Register Map interface definition */
-#define CY_BL_CHKSUM_OK 0x01
-struct cyttsp_bootloader_data {
-        u8 bl_file;
-        u8 bl_status;
-        u8 bl_error;
-        u8 blver_hi;
-        u8 blver_lo;
-        u8 bld_blver_hi;
-        u8 bld_blver_lo;
-        u8 ttspver_hi;
-        u8 ttspver_lo;
-        u8 appid_hi;
-        u8 appid_lo;
-        u8 appver_hi;
-        u8 appver_lo;
-        u8 cid_0;
-        u8 cid_1;
-        u8 cid_2;
-};
-
-struct cyttsp;
-
-struct cyttsp_bus_ops {
-        u16 bustype;
-        int (*write)(struct cyttsp *ts,
-                     u8 addr, u8 length, const void *values);
-        int (*read)(struct cyttsp *ts, u8 addr, u8 length, void *values);
-};
-
-enum cyttsp_state {
-        CY_IDLE_STATE,
-        CY_ACTIVE_STATE,
-        CY_BL_STATE,
-};
-
-struct cyttsp {
-        struct device *dev;
-        int irq;
-        struct input_dev *input;
-        char phys[32];
-        const struct cyttsp_platform_data *pdata;
-        const struct cyttsp_bus_ops *bus_ops;
-        struct cyttsp_bootloader_data bl_data;
-        struct cyttsp_sysinfo_data sysinfo_data;
-        struct cyttsp_xydata xy_data;
-        struct completion bl_ready;
-        enum cyttsp_state state;
-        bool suspended;
-
-        u8 xfer_buf[] ____cacheline_aligned;
-};
-
-struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops,
-                            struct device *dev, int irq, size_t xfer_buf_size);
-void cyttsp_remove(struct cyttsp *ts);
-
-extern const struct dev_pm_ops cyttsp_pm_ops;
-
-#endif /* __CYTTSP_CORE_H__ */
diff --git a/drivers/input/touchscreen/cyttsp_i2c.c b/drivers/input/touchscreen/cyttsp_i2c.c
deleted file mode 100644
index 4dbdf44b8fc..00000000000
--- a/drivers/input/touchscreen/cyttsp_i2c.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Source for:
- * Cypress TrueTouch(TM) Standard Product (TTSP) I2C touchscreen driver.
- * For use with Cypress Txx3xx parts.
- * Supported parts include:
- * CY8CTST341
- * CY8CTMA340
- *
- * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
- * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2, and only version 2, as published by the
- * Free Software Foundation.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
- *
- */
-
-#include "cyttsp_core.h"
-
-#include <linux/i2c.h>
-#include <linux/input.h>
-
-#define CY_I2C_DATA_SIZE        128
-
-static int cyttsp_i2c_read_block_data(struct cyttsp *ts,
-                                      u8 addr, u8 length, void *values)
-{
-        struct i2c_client *client = to_i2c_client(ts->dev);
-        struct i2c_msg msgs[] = {
-                {
-                        .addr = client->addr,
-                        .flags = 0,
-                        .len = 1,
-                        .buf = &addr,
-                },
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = length,
-                        .buf = values,
-                },
-        };
-        int retval;
-
-        retval = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (retval < 0)
-                return retval;
-
-        return retval != ARRAY_SIZE(msgs) ? -EIO : 0;
-}
-
-static int cyttsp_i2c_write_block_data(struct cyttsp *ts,
-                                       u8 addr, u8 length, const void *values)
-{
-        struct i2c_client *client = to_i2c_client(ts->dev);
-        int retval;
-
-        ts->xfer_buf[0] = addr;
-        memcpy(&ts->xfer_buf[1], values, length);
-
-        retval = i2c_master_send(client, ts->xfer_buf, length + 1);
-
-        return retval < 0 ? retval : 0;
-}
-
-static const struct cyttsp_bus_ops cyttsp_i2c_bus_ops = {
-        .bustype        = BUS_I2C,
-        .write          = cyttsp_i2c_write_block_data,
-        .read           = cyttsp_i2c_read_block_data,
-};
-
-static int cyttsp_i2c_probe(struct i2c_client *client,
-                                      const struct i2c_device_id *id)
-{
-        struct cyttsp *ts;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                dev_err(&client->dev, "I2C functionality not Supported\n");
-                return -EIO;
-        }
-
-        ts = cyttsp_probe(&cyttsp_i2c_bus_ops, &client->dev, client->irq,
-                          CY_I2C_DATA_SIZE);
-
-        if (IS_ERR(ts))
-                return PTR_ERR(ts);
-
-        i2c_set_clientdata(client, ts);
-
-        return 0;
-}
-
-static int cyttsp_i2c_remove(struct i2c_client *client)
-{
-        struct cyttsp *ts = i2c_get_clientdata(client);
-
-        cyttsp_remove(ts);
-
-        return 0;
-}
-
-static const struct i2c_device_id cyttsp_i2c_id[] = {
-        { CY_I2C_NAME, 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, cyttsp_i2c_id);
-
-static struct i2c_driver cyttsp_i2c_driver = {
-        .driver = {
-                .name   = CY_I2C_NAME,
-                .owner  = THIS_MODULE,
-                .pm     = &cyttsp_pm_ops,
-        },
-        .probe          = cyttsp_i2c_probe,
-        .remove         = cyttsp_i2c_remove,
-        .id_table       = cyttsp_i2c_id,
-};
-
-module_i2c_driver(cyttsp_i2c_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard Product (TTSP) I2C driver");
-MODULE_AUTHOR("Cypress");
-MODULE_ALIAS("i2c:cyttsp");
diff --git a/drivers/input/touchscreen/cyttsp_spi.c b/drivers/input/touchscreen/cyttsp_spi.c
deleted file mode 100644
index 638e20310f1..00000000000
--- a/drivers/input/touchscreen/cyttsp_spi.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Source for:
- * Cypress TrueTouch(TM) Standard Product (TTSP) SPI touchscreen driver.
- * For use with Cypress Txx3xx parts.
- * Supported parts include:
- * CY8CTST341
- * CY8CTMA340
- *
- * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
- * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2, and only version 2, as published by the
- * Free Software Foundation.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
- *
- */
-
-#include "cyttsp_core.h"
-
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/spi/spi.h>
-
-#define CY_SPI_WR_OP            0x00 /* r/~w */
-#define CY_SPI_RD_OP            0x01
-#define CY_SPI_CMD_BYTES        4
-#define CY_SPI_SYNC_BYTE        2
-#define CY_SPI_SYNC_ACK1        0x62 /* from protocol v.2 */
-#define CY_SPI_SYNC_ACK2        0x9D /* from protocol v.2 */
-#define CY_SPI_DATA_SIZE        128
-#define CY_SPI_DATA_BUF_SIZE    (CY_SPI_CMD_BYTES + CY_SPI_DATA_SIZE)
-#define CY_SPI_BITS_PER_WORD    8
-
-static int cyttsp_spi_xfer(struct cyttsp *ts,
-                           u8 op, u8 reg, u8 *buf, int length)
-{
-        struct spi_device *spi = to_spi_device(ts->dev);
-        struct spi_message msg;
-        struct spi_transfer xfer[2];
-        u8 *wr_buf = &ts->xfer_buf[0];
-        u8 *rd_buf = &ts->xfer_buf[CY_SPI_DATA_BUF_SIZE];
-        int retval;
-        int i;
-
-        if (length > CY_SPI_DATA_SIZE) {
-                dev_err(ts->dev, "%s: length %d is too big.\n",
-                        __func__, length);
-                return -EINVAL;
-        }
-
-        memset(wr_buf, 0, CY_SPI_DATA_BUF_SIZE);
-        memset(rd_buf, 0, CY_SPI_DATA_BUF_SIZE);
-
-        wr_buf[0] = 0x00; /* header byte 0 */
-        wr_buf[1] = 0xFF; /* header byte 1 */
-        wr_buf[2] = reg;  /* reg index */
-        wr_buf[3] = op;   /* r/~w */
-        if (op == CY_SPI_WR_OP)
-                memcpy(wr_buf + CY_SPI_CMD_BYTES, buf, length);
-
-        memset(xfer, 0, sizeof(xfer));
-        spi_message_init(&msg);
-
-        /*
-          We set both TX and RX buffers because Cypress TTSP
-          requires full duplex operation.
-        */
-        xfer[0].tx_buf = wr_buf;
-        xfer[0].rx_buf = rd_buf;
-        switch (op) {
-        case CY_SPI_WR_OP:
-                xfer[0].len = length + CY_SPI_CMD_BYTES;
-                spi_message_add_tail(&xfer[0], &msg);
-                break;
-
-        case CY_SPI_RD_OP:
-                xfer[0].len = CY_SPI_CMD_BYTES;
-                spi_message_add_tail(&xfer[0], &msg);
-
-                xfer[1].rx_buf = buf;
-                xfer[1].len = length;
-                spi_message_add_tail(&xfer[1], &msg);
-                break;
-
-        default:
-                dev_err(ts->dev, "%s: bad operation code=%d\n", __func__, op);
-                return -EINVAL;
-        }
-
-        retval = spi_sync(spi, &msg);
-        if (retval < 0) {
-                dev_dbg(ts->dev, "%s: spi_sync() error %d, len=%d, op=%d\n",
-                        __func__, retval, xfer[1].len, op);
-
-                /*
-                 * do not return here since was a bad ACK sequence
-                 * let the following ACK check handle any errors and
-                 * allow silent retries
-                 */
-        }
-
-        if (rd_buf[CY_SPI_SYNC_BYTE] != CY_SPI_SYNC_ACK1 ||
-            rd_buf[CY_SPI_SYNC_BYTE + 1] != CY_SPI_SYNC_ACK2) {
-
-                dev_dbg(ts->dev, "%s: operation %d failed\n", __func__, op);
-
-                for (i = 0; i < CY_SPI_CMD_BYTES; i++)
-                        dev_dbg(ts->dev, "%s: test rd_buf[%d]:0x%02x\n",
-                                __func__, i, rd_buf[i]);
-                for (i = 0; i < length; i++)
-                        dev_dbg(ts->dev, "%s: test buf[%d]:0x%02x\n",
-                                __func__, i, buf[i]);
-
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static int cyttsp_spi_read_block_data(struct cyttsp *ts,
-                                      u8 addr, u8 length, void *data)
-{
-        return cyttsp_spi_xfer(ts, CY_SPI_RD_OP, addr, data, length);
-}
-
-static int cyttsp_spi_write_block_data(struct cyttsp *ts,
-                                       u8 addr, u8 length, const void *data)
-{
-        return cyttsp_spi_xfer(ts, CY_SPI_WR_OP, addr, (void *)data, length);
-}
-
-static const struct cyttsp_bus_ops cyttsp_spi_bus_ops = {
-        .bustype        = BUS_SPI,
-        .write          = cyttsp_spi_write_block_data,
-        .read           = cyttsp_spi_read_block_data,
-};
-
-static int cyttsp_spi_probe(struct spi_device *spi)
-{
-        struct cyttsp *ts;
-        int error;
-
-        /* Set up SPI*/
-        spi->bits_per_word = CY_SPI_BITS_PER_WORD;
-        spi->mode = SPI_MODE_0;
-        error = spi_setup(spi);
-        if (error < 0) {
-                dev_err(&spi->dev, "%s: SPI setup error %d\n",
-                        __func__, error);
-                return error;
-        }
-
-        ts = cyttsp_probe(&cyttsp_spi_bus_ops, &spi->dev, spi->irq,
-                          CY_SPI_DATA_BUF_SIZE * 2);
-        if (IS_ERR(ts))
-                return PTR_ERR(ts);
-
-        spi_set_drvdata(spi, ts);
-
-        return 0;
-}
-
-static int cyttsp_spi_remove(struct spi_device *spi)
-{
-        struct cyttsp *ts = spi_get_drvdata(spi);
-
-        cyttsp_remove(ts);
-
-        return 0;
-}
-
-static struct spi_driver cyttsp_spi_driver = {
-        .driver = {
-                .name   = CY_SPI_NAME,
-                .owner  = THIS_MODULE,
-                .pm     = &cyttsp_pm_ops,
-        },
-        .probe  = cyttsp_spi_probe,
-        .remove = cyttsp_spi_remove,
-};
-
-module_spi_driver(cyttsp_spi_driver);
-
-MODULE_ALIAS("spi:cyttsp");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard Product (TTSP) SPI driver");
-MODULE_AUTHOR("Cypress");
-MODULE_ALIAS("spi:cyttsp");
diff --git a/drivers/input/touchscreen/da9034-ts.c b/drivers/input/touchscreen/da9034-ts.c
index 34ad84105e6..2b72a5923c1 100644
--- a/drivers/input/touchscreen/da9034-ts.c
+++ b/drivers/input/touchscreen/da9034-ts.c
@@ -297,7 +297,7 @@ static void da9034_touch_close(struct input_dev *dev)
 }
 
 
-static int da9034_touch_probe(struct platform_device *pdev)
+static int __devinit da9034_touch_probe(struct platform_device *pdev)
 {
         struct da9034_touch_pdata *pdata = pdev->dev.platform_data;
         struct da9034_touch *touch;
@@ -361,7 +361,7 @@ err_free_touch:
         return ret;
 }
 
-static int da9034_touch_remove(struct platform_device *pdev)
+static int __devexit da9034_touch_remove(struct platform_device *pdev)
 {
         struct da9034_touch *touch = platform_get_drvdata(pdev);
 
@@ -377,9 +377,20 @@ static struct platform_driver da9034_touch_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = da9034_touch_probe,
-        .remove         = da9034_touch_remove,
+        .remove         = __devexit_p(da9034_touch_remove),
 };
-module_platform_driver(da9034_touch_driver);
+
+static int __init da9034_touch_init(void)
+{
+        return platform_driver_register(&da9034_touch_driver);
+}
+module_init(da9034_touch_init);
+
+static void __exit da9034_touch_exit(void)
+{
+        platform_driver_unregister(&da9034_touch_driver);
+}
+module_exit(da9034_touch_exit);
 
 MODULE_DESCRIPTION("Touchscreen driver for Dialog Semiconductor DA9034");
 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>, Bin Yang <bin.yang@marvell.com>");
diff --git a/drivers/input/touchscreen/da9052_tsi.c b/drivers/input/touchscreen/da9052_tsi.c
deleted file mode 100644
index 8f561e22bdd..00000000000
--- a/drivers/input/touchscreen/da9052_tsi.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- * TSI driver for Dialog DA9052
- *
- * Copyright(c) 2012 Dialog Semiconductor Ltd.
- *
- * Author: David Dajun Chen <dchen@diasemi.com>
- *
- *  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.
- *
- */
-#include <linux/module.h>
-#include <linux/input.h>
-#include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-
-#include <linux/mfd/da9052/reg.h>
-#include <linux/mfd/da9052/da9052.h>
-
-#define TSI_PEN_DOWN_STATUS 0x40
-
-struct da9052_tsi {
-        struct da9052 *da9052;
-        struct input_dev *dev;
-        struct delayed_work ts_pen_work;
-        struct mutex mutex;
-        bool stopped;
-        bool adc_on;
-};
-
-static void da9052_ts_adc_toggle(struct da9052_tsi *tsi, bool on)
-{
-        da9052_reg_update(tsi->da9052, DA9052_TSI_CONT_A_REG, 1 << 0, on);
-        tsi->adc_on = on;
-}
-
-static irqreturn_t da9052_ts_pendwn_irq(int irq, void *data)
-{
-        struct da9052_tsi *tsi = data;
-
-        if (!tsi->stopped) {
-                /* Mask PEN_DOWN event and unmask TSI_READY event */
-                da9052_disable_irq_nosync(tsi->da9052, DA9052_IRQ_PENDOWN);
-                da9052_enable_irq(tsi->da9052, DA9052_IRQ_TSIREADY);
-
-                da9052_ts_adc_toggle(tsi, true);
-
-                schedule_delayed_work(&tsi->ts_pen_work, HZ / 50);
-        }
-
-        return IRQ_HANDLED;
-}
-
-static void da9052_ts_read(struct da9052_tsi *tsi)
-{
-        struct input_dev *input = tsi->dev;
-        int ret;
-        u16 x, y, z;
-        u8 v;
-
-        ret = da9052_reg_read(tsi->da9052, DA9052_TSI_X_MSB_REG);
-        if (ret < 0)
-                return;
-
-        x = (u16) ret;
-
-        ret = da9052_reg_read(tsi->da9052, DA9052_TSI_Y_MSB_REG);
-        if (ret < 0)
-                return;
-
-        y = (u16) ret;
-
-        ret = da9052_reg_read(tsi->da9052, DA9052_TSI_Z_MSB_REG);
-        if (ret < 0)
-                return;
-
-        z = (u16) ret;
-
-        ret = da9052_reg_read(tsi->da9052, DA9052_TSI_LSB_REG);
-        if (ret < 0)
-                return;
-
-        v = (u8) ret;
-
-        x = ((x << 2) & 0x3fc) | (v & 0x3);
-        y = ((y << 2) & 0x3fc) | ((v & 0xc) >> 2);
-        z = ((z << 2) & 0x3fc) | ((v & 0x30) >> 4);
-
-        input_report_key(input, BTN_TOUCH, 1);
-        input_report_abs(input, ABS_X, x);
-        input_report_abs(input, ABS_Y, y);
-        input_report_abs(input, ABS_PRESSURE, z);
-        input_sync(input);
-}
-
-static irqreturn_t da9052_ts_datardy_irq(int irq, void *data)
-{
-        struct da9052_tsi *tsi = data;
-
-        da9052_ts_read(tsi);
-
-        return IRQ_HANDLED;
-}
-
-static void da9052_ts_pen_work(struct work_struct *work)
-{
-        struct da9052_tsi *tsi = container_of(work, struct da9052_tsi,
-                                              ts_pen_work.work);
-        if (!tsi->stopped) {
-                int ret = da9052_reg_read(tsi->da9052, DA9052_TSI_LSB_REG);
-                if (ret < 0 || (ret & TSI_PEN_DOWN_STATUS)) {
-                        /* Pen is still DOWN (or read error) */
-                        schedule_delayed_work(&tsi->ts_pen_work, HZ / 50);
-                } else {
-                        struct input_dev *input = tsi->dev;
-
-                        /* Pen UP */
-                        da9052_ts_adc_toggle(tsi, false);
-
-                        /* Report Pen UP */
-                        input_report_key(input, BTN_TOUCH, 0);
-                        input_report_abs(input, ABS_PRESSURE, 0);
-                        input_sync(input);
-
-                        /*
-                         * FIXME: Fixes the unhandled irq issue when quick
-                         * pen down and pen up events occurs
-                         */
-                        ret = da9052_reg_update(tsi->da9052,
-                                                DA9052_EVENT_B_REG, 0xC0, 0xC0);
-                        if (ret < 0)
-                                return;
-
-                        /* Mask TSI_READY event and unmask PEN_DOWN event */
-                        da9052_disable_irq(tsi->da9052, DA9052_IRQ_TSIREADY);
-                        da9052_enable_irq(tsi->da9052, DA9052_IRQ_PENDOWN);
-                }
-        }
-}
-
-static int da9052_ts_configure_gpio(struct da9052 *da9052)
-{
-        int error;
-
-        error = da9052_reg_update(da9052, DA9052_GPIO_2_3_REG, 0x30, 0);
-        if (error < 0)
-                return error;
-
-        error = da9052_reg_update(da9052, DA9052_GPIO_4_5_REG, 0x33, 0);
-        if (error < 0)
-                return error;
-
-        error = da9052_reg_update(da9052, DA9052_GPIO_6_7_REG, 0x33, 0);
-        if (error < 0)
-                return error;
-
-        return 0;
-}
-
-static int da9052_configure_tsi(struct da9052_tsi *tsi)
-{
-        int error;
-
-        error = da9052_ts_configure_gpio(tsi->da9052);
-        if (error)
-                return error;
-
-        /* Measure TSI sample every 1ms */
-        error = da9052_reg_update(tsi->da9052, DA9052_ADC_CONT_REG,
-                                  1 << 6, 1 << 6);
-        if (error < 0)
-                return error;
-
-        /* TSI_DELAY: 3 slots, TSI_SKIP: 0 slots, TSI_MODE: XYZP */
-        error = da9052_reg_update(tsi->da9052, DA9052_TSI_CONT_A_REG, 0xFC, 0xC0);
-        if (error < 0)
-                return error;
-
-        /* Supply TSIRef through LD09 */
-        error = da9052_reg_write(tsi->da9052, DA9052_LDO9_REG, 0x59);
-        if (error < 0)
-                return error;
-
-        return 0;
-}
-
-static int da9052_ts_input_open(struct input_dev *input_dev)
-{
-        struct da9052_tsi *tsi = input_get_drvdata(input_dev);
-
-        tsi->stopped = false;
-        mb();
-
-        /* Unmask PEN_DOWN event */
-        da9052_enable_irq(tsi->da9052, DA9052_IRQ_PENDOWN);
-
-        /* Enable Pen Detect Circuit */
-        return da9052_reg_update(tsi->da9052, DA9052_TSI_CONT_A_REG,
-                                 1 << 1, 1 << 1);
-}
-
-static void da9052_ts_input_close(struct input_dev *input_dev)
-{
-        struct da9052_tsi *tsi = input_get_drvdata(input_dev);
-
-        tsi->stopped = true;
-        mb();
-        da9052_disable_irq(tsi->da9052, DA9052_IRQ_PENDOWN);
-        cancel_delayed_work_sync(&tsi->ts_pen_work);
-
-        if (tsi->adc_on) {
-                da9052_disable_irq(tsi->da9052, DA9052_IRQ_TSIREADY);
-                da9052_ts_adc_toggle(tsi, false);
-
-                /*
-                 * If ADC was on that means that pendwn IRQ was disabled
-                 * twice and we need to enable it to keep enable/disable
-                 * counter balanced. IRQ is still off though.
-                 */
-                da9052_enable_irq(tsi->da9052, DA9052_IRQ_PENDOWN);
-        }
-
-        /* Disable Pen Detect Circuit */
-        da9052_reg_update(tsi->da9052, DA9052_TSI_CONT_A_REG, 1 << 1, 0);
-}
-
-static int da9052_ts_probe(struct platform_device *pdev)
-{
-        struct da9052 *da9052;
-        struct da9052_tsi *tsi;
-        struct input_dev *input_dev;
-        int error;
-
-        da9052 = dev_get_drvdata(pdev->dev.parent);
-        if (!da9052)
-                return -EINVAL;
-
-        tsi = kzalloc(sizeof(struct da9052_tsi), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!tsi || !input_dev) {
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        tsi->da9052 = da9052;
-        tsi->dev = input_dev;
-        tsi->stopped = true;
-        INIT_DELAYED_WORK(&tsi->ts_pen_work, da9052_ts_pen_work);
-
-        input_dev->id.version = 0x0101;
-        input_dev->id.vendor = 0x15B6;
-        input_dev->id.product = 0x9052;
-        input_dev->name = "Dialog DA9052 TouchScreen Driver";
-        input_dev->dev.parent = &pdev->dev;
-        input_dev->open = da9052_ts_input_open;
-        input_dev->close = da9052_ts_input_close;
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-
-        input_set_abs_params(input_dev, ABS_X, 0, 1023, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, 1023, 0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1023, 0, 0);
-
-        input_set_drvdata(input_dev, tsi);
-
-        /* Disable Pen Detect Circuit */
-        da9052_reg_update(tsi->da9052, DA9052_TSI_CONT_A_REG, 1 << 1, 0);
-
-        /* Disable ADC */
-        da9052_ts_adc_toggle(tsi, false);
-
-        error = da9052_request_irq(tsi->da9052, DA9052_IRQ_PENDOWN,
-                                "pendown-irq", da9052_ts_pendwn_irq, tsi);
-        if (error) {
-                dev_err(tsi->da9052->dev,
-                        "Failed to register PENDWN IRQ: %d\n", error);
-                goto err_free_mem;
-        }
-
-        error = da9052_request_irq(tsi->da9052, DA9052_IRQ_TSIREADY,
-                                "tsiready-irq", da9052_ts_datardy_irq, tsi);
-        if (error) {
-                dev_err(tsi->da9052->dev,
-                        "Failed to register TSIRDY IRQ :%d\n", error);
-                goto err_free_pendwn_irq;
-        }
-
-        /* Mask PEN_DOWN and TSI_READY events */
-        da9052_disable_irq(tsi->da9052, DA9052_IRQ_PENDOWN);
-        da9052_disable_irq(tsi->da9052, DA9052_IRQ_TSIREADY);
-
-        error = da9052_configure_tsi(tsi);
-        if (error)
-                goto err_free_datardy_irq;
-
-        error = input_register_device(tsi->dev);
-        if (error)
-                goto err_free_datardy_irq;
-
-        platform_set_drvdata(pdev, tsi);
-
-        return 0;
-
-err_free_datardy_irq:
-        da9052_free_irq(tsi->da9052, DA9052_IRQ_TSIREADY, tsi);
-err_free_pendwn_irq:
-        da9052_free_irq(tsi->da9052, DA9052_IRQ_PENDOWN, tsi);
-err_free_mem:
-        kfree(tsi);
-        input_free_device(input_dev);
-
-        return error;
-}
-
-static int  da9052_ts_remove(struct platform_device *pdev)
-{
-        struct da9052_tsi *tsi = platform_get_drvdata(pdev);
-
-        da9052_reg_write(tsi->da9052, DA9052_LDO9_REG, 0x19);
-
-        da9052_free_irq(tsi->da9052, DA9052_IRQ_TSIREADY, tsi);
-        da9052_free_irq(tsi->da9052, DA9052_IRQ_PENDOWN, tsi);
-
-        input_unregister_device(tsi->dev);
-        kfree(tsi);
-
-        platform_set_drvdata(pdev, NULL);
-
-        return 0;
-}
-
-static struct platform_driver da9052_tsi_driver = {
-        .probe  = da9052_ts_probe,
-        .remove = da9052_ts_remove,
-        .driver = {
-                .name   = "da9052-tsi",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(da9052_tsi_driver);
-
-MODULE_DESCRIPTION("Touchscreen driver for Dialog Semiconductor DA9052");
-MODULE_AUTHOR("Anthony Olech <Anthony.Olech@diasemi.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:da9052-tsi");
diff --git a/drivers/input/touchscreen/dynapro.c b/drivers/input/touchscreen/dynapro.c
index 1809677a651..455353908bd 100644
--- a/drivers/input/touchscreen/dynapro.c
+++ b/drivers/input/touchscreen/dynapro.c
@@ -188,4 +188,19 @@ static struct serio_driver dynapro_drv = {
         .disconnect     = dynapro_disconnect,
 };
 
-module_serio_driver(dynapro_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init dynapro_init(void)
+{
+        return serio_register_driver(&dynapro_drv);
+}
+
+static void __exit dynapro_exit(void)
+{
+        serio_unregister_driver(&dynapro_drv);
+}
+
+module_init(dynapro_init);
+module_exit(dynapro_exit);
diff --git a/drivers/input/touchscreen/edt-ft5x06.c b/drivers/input/touchscreen/edt-ft5x06.c
deleted file mode 100644
index a9170157b44..00000000000
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ /dev/null
@@ -1,893 +0,0 @@
-/*
- * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
- *
- * 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.
- *
- * 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
- */
-
-/*
- * This is a driver for the EDT "Polytouch" family of touch controllers
- * based on the FocalTech FT5x06 line of chips.
- *
- * Development of this driver has been sponsored by Glyn:
- *    http://www.glyn.com/Products/Displays
- */
-
-#include <linux/module.h>
-#include <linux/ratelimit.h>
-#include <linux/interrupt.h>
-#include <linux/input.h>
-#include <linux/i2c.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/debugfs.h>
-#include <linux/slab.h>
-#include <linux/gpio.h>
-#include <linux/input/mt.h>
-#include <linux/input/edt-ft5x06.h>
-
-#define MAX_SUPPORT_POINTS              5
-
-#define WORK_REGISTER_THRESHOLD         0x00
-#define WORK_REGISTER_REPORT_RATE       0x08
-#define WORK_REGISTER_GAIN              0x30
-#define WORK_REGISTER_OFFSET            0x31
-#define WORK_REGISTER_NUM_X             0x33
-#define WORK_REGISTER_NUM_Y             0x34
-
-#define WORK_REGISTER_OPMODE            0x3c
-#define FACTORY_REGISTER_OPMODE         0x01
-
-#define TOUCH_EVENT_DOWN                0x00
-#define TOUCH_EVENT_UP                  0x01
-#define TOUCH_EVENT_ON                  0x02
-#define TOUCH_EVENT_RESERVED            0x03
-
-#define EDT_NAME_LEN                    23
-#define EDT_SWITCH_MODE_RETRIES         10
-#define EDT_SWITCH_MODE_DELAY           5 /* msec */
-#define EDT_RAW_DATA_RETRIES            100
-#define EDT_RAW_DATA_DELAY              1 /* msec */
-
-struct edt_ft5x06_ts_data {
-        struct i2c_client *client;
-        struct input_dev *input;
-        u16 num_x;
-        u16 num_y;
-
-#if defined(CONFIG_DEBUG_FS)
-        struct dentry *debug_dir;
-        u8 *raw_buffer;
-        size_t raw_bufsize;
-#endif
-
-        struct mutex mutex;
-        bool factory_mode;
-        int threshold;
-        int gain;
-        int offset;
-        int report_rate;
-
-        char name[EDT_NAME_LEN];
-};
-
-static int edt_ft5x06_ts_readwrite(struct i2c_client *client,
-                                   u16 wr_len, u8 *wr_buf,
-                                   u16 rd_len, u8 *rd_buf)
-{
-        struct i2c_msg wrmsg[2];
-        int i = 0;
-        int ret;
-
-        if (wr_len) {
-                wrmsg[i].addr  = client->addr;
-                wrmsg[i].flags = 0;
-                wrmsg[i].len = wr_len;
-                wrmsg[i].buf = wr_buf;
-                i++;
-        }
-        if (rd_len) {
-                wrmsg[i].addr  = client->addr;
-                wrmsg[i].flags = I2C_M_RD;
-                wrmsg[i].len = rd_len;
-                wrmsg[i].buf = rd_buf;
-                i++;
-        }
-
-        ret = i2c_transfer(client->adapter, wrmsg, i);
-        if (ret < 0)
-                return ret;
-        if (ret != i)
-                return -EIO;
-
-        return 0;
-}
-
-static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data *tsdata,
-                                    u8 *buf, int buflen)
-{
-        int i;
-        u8 crc = 0;
-
-        for (i = 0; i < buflen - 1; i++)
-                crc ^= buf[i];
-
-        if (crc != buf[buflen-1]) {
-                dev_err_ratelimited(&tsdata->client->dev,
-                                    "crc error: 0x%02x expected, got 0x%02x\n",
-                                    crc, buf[buflen-1]);
-                return false;
-        }
-
-        return true;
-}
-
-static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id)
-{
-        struct edt_ft5x06_ts_data *tsdata = dev_id;
-        struct device *dev = &tsdata->client->dev;
-        u8 cmd = 0xf9;
-        u8 rdbuf[26];
-        int i, type, x, y, id;
-        int error;
-
-        memset(rdbuf, 0, sizeof(rdbuf));
-
-        error = edt_ft5x06_ts_readwrite(tsdata->client,
-                                        sizeof(cmd), &cmd,
-                                        sizeof(rdbuf), rdbuf);
-        if (error) {
-                dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
-                                    error);
-                goto out;
-        }
-
-        if (rdbuf[0] != 0xaa || rdbuf[1] != 0xaa || rdbuf[2] != 26) {
-                dev_err_ratelimited(dev, "Unexpected header: %02x%02x%02x!\n",
-                                    rdbuf[0], rdbuf[1], rdbuf[2]);
-                goto out;
-        }
-
-        if (!edt_ft5x06_ts_check_crc(tsdata, rdbuf, 26))
-                goto out;
-
-        for (i = 0; i < MAX_SUPPORT_POINTS; i++) {
-                u8 *buf = &rdbuf[i * 4 + 5];
-                bool down;
-
-                type = buf[0] >> 6;
-                /* ignore Reserved events */
-                if (type == TOUCH_EVENT_RESERVED)
-                        continue;
-
-                x = ((buf[0] << 8) | buf[1]) & 0x0fff;
-                y = ((buf[2] << 8) | buf[3]) & 0x0fff;
-                id = (buf[2] >> 4) & 0x0f;
-                down = (type != TOUCH_EVENT_UP);
-
-                input_mt_slot(tsdata->input, id);
-                input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER, down);
-
-                if (!down)
-                        continue;
-
-                input_report_abs(tsdata->input, ABS_MT_POSITION_X, x);
-                input_report_abs(tsdata->input, ABS_MT_POSITION_Y, y);
-        }
-
-        input_mt_report_pointer_emulation(tsdata->input, true);
-        input_sync(tsdata->input);
-
-out:
-        return IRQ_HANDLED;
-}
-
-static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data *tsdata,
-                                     u8 addr, u8 value)
-{
-        u8 wrbuf[4];
-
-        wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
-        wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
-        wrbuf[2] = value;
-        wrbuf[3] = wrbuf[0] ^ wrbuf[1] ^ wrbuf[2];
-
-        return edt_ft5x06_ts_readwrite(tsdata->client, 4, wrbuf, 0, NULL);
-}
-
-static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data *tsdata,
-                                    u8 addr)
-{
-        u8 wrbuf[2], rdbuf[2];
-        int error;
-
-        wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
-        wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
-        wrbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40;
-
-        error = edt_ft5x06_ts_readwrite(tsdata->client, 2, wrbuf, 2, rdbuf);
-        if (error)
-                return error;
-
-        if ((wrbuf[0] ^ wrbuf[1] ^ rdbuf[0]) != rdbuf[1]) {
-                dev_err(&tsdata->client->dev,
-                        "crc error: 0x%02x expected, got 0x%02x\n",
-                        wrbuf[0] ^ wrbuf[1] ^ rdbuf[0], rdbuf[1]);
-                return -EIO;
-        }
-
-        return rdbuf[0];
-}
-
-struct edt_ft5x06_attribute {
-        struct device_attribute dattr;
-        size_t field_offset;
-        u8 limit_low;
-        u8 limit_high;
-        u8 addr;
-};
-
-#define EDT_ATTR(_field, _mode, _addr, _limit_low, _limit_high)         \
-        struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = {        \
-                .dattr = __ATTR(_field, _mode,                          \
-                                edt_ft5x06_setting_show,                \
-                                edt_ft5x06_setting_store),              \
-                .field_offset =                                         \
-                        offsetof(struct edt_ft5x06_ts_data, _field),    \
-                .limit_low = _limit_low,                                \
-                .limit_high = _limit_high,                              \
-                .addr = _addr,                                          \
-        }
-
-static ssize_t edt_ft5x06_setting_show(struct device *dev,
-                                       struct device_attribute *dattr,
-                                       char *buf)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
-        struct edt_ft5x06_attribute *attr =
-                        container_of(dattr, struct edt_ft5x06_attribute, dattr);
-        u8 *field = (u8 *)((char *)tsdata + attr->field_offset);
-        int val;
-        size_t count = 0;
-        int error = 0;
-
-        mutex_lock(&tsdata->mutex);
-
-        if (tsdata->factory_mode) {
-                error = -EIO;
-                goto out;
-        }
-
-        val = edt_ft5x06_register_read(tsdata, attr->addr);
-        if (val < 0) {
-                error = val;
-                dev_err(&tsdata->client->dev,
-                        "Failed to fetch attribute %s, error %d\n",
-                        dattr->attr.name, error);
-                goto out;
-        }
-
-        if (val != *field) {
-                dev_warn(&tsdata->client->dev,
-                         "%s: read (%d) and stored value (%d) differ\n",
-                         dattr->attr.name, val, *field);
-                *field = val;
-        }
-
-        count = scnprintf(buf, PAGE_SIZE, "%d\n", val);
-out:
-        mutex_unlock(&tsdata->mutex);
-        return error ?: count;
-}
-
-static ssize_t edt_ft5x06_setting_store(struct device *dev,
-                                        struct device_attribute *dattr,
-                                        const char *buf, size_t count)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
-        struct edt_ft5x06_attribute *attr =
-                        container_of(dattr, struct edt_ft5x06_attribute, dattr);
-        u8 *field = (u8 *)((char *)tsdata + attr->field_offset);
-        unsigned int val;
-        int error;
-
-        mutex_lock(&tsdata->mutex);
-
-        if (tsdata->factory_mode) {
-                error = -EIO;
-                goto out;
-        }
-
-        error = kstrtouint(buf, 0, &val);
-        if (error)
-                goto out;
-
-        if (val < attr->limit_low || val > attr->limit_high) {
-                error = -ERANGE;
-                goto out;
-        }
-
-        error = edt_ft5x06_register_write(tsdata, attr->addr, val);
-        if (error) {
-                dev_err(&tsdata->client->dev,
-                        "Failed to update attribute %s, error: %d\n",
-                        dattr->attr.name, error);
-                goto out;
-        }
-
-        *field = val;
-
-out:
-        mutex_unlock(&tsdata->mutex);
-        return error ?: count;
-}
-
-static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN, 0, 31);
-static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET, 0, 31);
-static EDT_ATTR(threshold, S_IWUSR | S_IRUGO,
-                WORK_REGISTER_THRESHOLD, 20, 80);
-static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO,
-                WORK_REGISTER_REPORT_RATE, 3, 14);
-
-static struct attribute *edt_ft5x06_attrs[] = {
-        &edt_ft5x06_attr_gain.dattr.attr,
-        &edt_ft5x06_attr_offset.dattr.attr,
-        &edt_ft5x06_attr_threshold.dattr.attr,
-        &edt_ft5x06_attr_report_rate.dattr.attr,
-        NULL
-};
-
-static const struct attribute_group edt_ft5x06_attr_group = {
-        .attrs = edt_ft5x06_attrs,
-};
-
-#ifdef CONFIG_DEBUG_FS
-static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
-{
-        struct i2c_client *client = tsdata->client;
-        int retries = EDT_SWITCH_MODE_RETRIES;
-        int ret;
-        int error;
-
-        disable_irq(client->irq);
-
-        if (!tsdata->raw_buffer) {
-                tsdata->raw_bufsize = tsdata->num_x * tsdata->num_y *
-                                      sizeof(u16);
-                tsdata->raw_buffer = kzalloc(tsdata->raw_bufsize, GFP_KERNEL);
-                if (!tsdata->raw_buffer) {
-                        error = -ENOMEM;
-                        goto err_out;
-                }
-        }
-
-        /* mode register is 0x3c when in the work mode */
-        error = edt_ft5x06_register_write(tsdata, WORK_REGISTER_OPMODE, 0x03);
-        if (error) {
-                dev_err(&client->dev,
-                        "failed to switch to factory mode, error %d\n", error);
-                goto err_out;
-        }
-
-        tsdata->factory_mode = true;
-        do {
-                mdelay(EDT_SWITCH_MODE_DELAY);
-                /* mode register is 0x01 when in factory mode */
-                ret = edt_ft5x06_register_read(tsdata, FACTORY_REGISTER_OPMODE);
-                if (ret == 0x03)
-                        break;
-        } while (--retries > 0);
-
-        if (retries == 0) {
-                dev_err(&client->dev, "not in factory mode after %dms.\n",
-                        EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
-                error = -EIO;
-                goto err_out;
-        }
-
-        return 0;
-
-err_out:
-        kfree(tsdata->raw_buffer);
-        tsdata->raw_buffer = NULL;
-        tsdata->factory_mode = false;
-        enable_irq(client->irq);
-
-        return error;
-}
-
-static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data *tsdata)
-{
-        struct i2c_client *client = tsdata->client;
-        int retries = EDT_SWITCH_MODE_RETRIES;
-        int ret;
-        int error;
-
-        /* mode register is 0x01 when in the factory mode */
-        error = edt_ft5x06_register_write(tsdata, FACTORY_REGISTER_OPMODE, 0x1);
-        if (error) {
-                dev_err(&client->dev,
-                        "failed to switch to work mode, error: %d\n", error);
-                return error;
-        }
-
-        tsdata->factory_mode = false;
-
-        do {
-                mdelay(EDT_SWITCH_MODE_DELAY);
-                /* mode register is 0x01 when in factory mode */
-                ret = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OPMODE);
-                if (ret == 0x01)
-                        break;
-        } while (--retries > 0);
-
-        if (retries == 0) {
-                dev_err(&client->dev, "not in work mode after %dms.\n",
-                        EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
-                tsdata->factory_mode = true;
-                return -EIO;
-        }
-
-        if (tsdata->raw_buffer)
-                kfree(tsdata->raw_buffer);
-        tsdata->raw_buffer = NULL;
-
-        /* restore parameters */
-        edt_ft5x06_register_write(tsdata, WORK_REGISTER_THRESHOLD,
-                                  tsdata->threshold);
-        edt_ft5x06_register_write(tsdata, WORK_REGISTER_GAIN,
-                                  tsdata->gain);
-        edt_ft5x06_register_write(tsdata, WORK_REGISTER_OFFSET,
-                                  tsdata->offset);
-        edt_ft5x06_register_write(tsdata, WORK_REGISTER_REPORT_RATE,
-                                  tsdata->report_rate);
-
-        enable_irq(client->irq);
-
-        return 0;
-}
-
-static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode)
-{
-        struct edt_ft5x06_ts_data *tsdata = data;
-
-        *mode = tsdata->factory_mode;
-
-        return 0;
-};
-
-static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode)
-{
-        struct edt_ft5x06_ts_data *tsdata = data;
-        int retval = 0;
-
-        if (mode > 1)
-                return -ERANGE;
-
-        mutex_lock(&tsdata->mutex);
-
-        if (mode != tsdata->factory_mode) {
-                retval = mode ? edt_ft5x06_factory_mode(tsdata) :
-                                edt_ft5x06_work_mode(tsdata);
-        }
-
-        mutex_unlock(&tsdata->mutex);
-
-        return retval;
-};
-
-DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get,
-                        edt_ft5x06_debugfs_mode_set, "%llu\n");
-
-static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file,
-                                char __user *buf, size_t count, loff_t *off)
-{
-        struct edt_ft5x06_ts_data *tsdata = file->private_data;
-        struct i2c_client *client = tsdata->client;
-        int retries  = EDT_RAW_DATA_RETRIES;
-        int val, i, error;
-        size_t read = 0;
-        int colbytes;
-        char wrbuf[3];
-        u8 *rdbuf;
-
-        if (*off < 0 || *off >= tsdata->raw_bufsize)
-                return 0;
-
-        mutex_lock(&tsdata->mutex);
-
-        if (!tsdata->factory_mode || !tsdata->raw_buffer) {
-                error = -EIO;
-                goto out;
-        }
-
-        error = edt_ft5x06_register_write(tsdata, 0x08, 0x01);
-        if (error) {
-                dev_dbg(&client->dev,
-                        "failed to write 0x08 register, error %d\n", error);
-                goto out;
-        }
-
-        do {
-                msleep(EDT_RAW_DATA_DELAY);
-                val = edt_ft5x06_register_read(tsdata, 0x08);
-                if (val < 1)
-                        break;
-        } while (--retries > 0);
-
-        if (val < 0) {
-                error = val;
-                dev_dbg(&client->dev,
-                        "failed to read 0x08 register, error %d\n", error);
-                goto out;
-        }
-
-        if (retries == 0) {
-                dev_dbg(&client->dev,
-                        "timed out waiting for register to settle\n");
-                error = -ETIMEDOUT;
-                goto out;
-        }
-
-        rdbuf = tsdata->raw_buffer;
-        colbytes = tsdata->num_y * sizeof(u16);
-
-        wrbuf[0] = 0xf5;
-        wrbuf[1] = 0x0e;
-        for (i = 0; i < tsdata->num_x; i++) {
-                wrbuf[2] = i;  /* column index */
-                error = edt_ft5x06_ts_readwrite(tsdata->client,
-                                                sizeof(wrbuf), wrbuf,
-                                                colbytes, rdbuf);
-                if (error)
-                        goto out;
-
-                rdbuf += colbytes;
-        }
-
-        read = min_t(size_t, count, tsdata->raw_bufsize - *off);
-        if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) {
-                error = -EFAULT;
-                goto out;
-        }
-
-        *off += read;
-out:
-        mutex_unlock(&tsdata->mutex);
-        return error ?: read;
-};
-
-
-static const struct file_operations debugfs_raw_data_fops = {
-        .open = simple_open,
-        .read = edt_ft5x06_debugfs_raw_data_read,
-};
-
-static void
-edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
-                              const char *debugfs_name)
-{
-        tsdata->debug_dir = debugfs_create_dir(debugfs_name, NULL);
-        if (!tsdata->debug_dir)
-                return;
-
-        debugfs_create_u16("num_x", S_IRUSR, tsdata->debug_dir, &tsdata->num_x);
-        debugfs_create_u16("num_y", S_IRUSR, tsdata->debug_dir, &tsdata->num_y);
-
-        debugfs_create_file("mode", S_IRUSR | S_IWUSR,
-                            tsdata->debug_dir, tsdata, &debugfs_mode_fops);
-        debugfs_create_file("raw_data", S_IRUSR,
-                            tsdata->debug_dir, tsdata, &debugfs_raw_data_fops);
-}
-
-static void
-edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
-{
-        if (tsdata->debug_dir)
-                debugfs_remove_recursive(tsdata->debug_dir);
-        kfree(tsdata->raw_buffer);
-}
-
-#else
-
-static inline void
-edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
-                              const char *debugfs_name)
-{
-}
-
-static inline void
-edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
-{
-}
-
-#endif /* CONFIG_DEBUGFS */
-
-
-
-static int edt_ft5x06_ts_reset(struct i2c_client *client,
-                                         int reset_pin)
-{
-        int error;
-
-        if (gpio_is_valid(reset_pin)) {
-                /* this pulls reset down, enabling the low active reset */
-                error = gpio_request_one(reset_pin, GPIOF_OUT_INIT_LOW,
-                                         "edt-ft5x06 reset");
-                if (error) {
-                        dev_err(&client->dev,
-                                "Failed to request GPIO %d as reset pin, error %d\n",
-                                reset_pin, error);
-                        return error;
-                }
-
-                mdelay(50);
-                gpio_set_value(reset_pin, 1);
-                mdelay(100);
-        }
-
-        return 0;
-}
-
-static int edt_ft5x06_ts_identify(struct i2c_client *client,
-                                            char *model_name,
-                                            char *fw_version)
-{
-        u8 rdbuf[EDT_NAME_LEN];
-        char *p;
-        int error;
-
-        error = edt_ft5x06_ts_readwrite(client, 1, "\xbb",
-                                        EDT_NAME_LEN - 1, rdbuf);
-        if (error)
-                return error;
-
-        /* remove last '$' end marker */
-        rdbuf[EDT_NAME_LEN - 1] = '\0';
-        if (rdbuf[EDT_NAME_LEN - 2] == '$')
-                rdbuf[EDT_NAME_LEN - 2] = '\0';
-
-        /* look for Model/Version separator */
-        p = strchr(rdbuf, '*');
-        if (p)
-                *p++ = '\0';
-
-        strlcpy(model_name, rdbuf + 1, EDT_NAME_LEN);
-        strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
-
-        return 0;
-}
-
-#define EDT_ATTR_CHECKSET(name, reg) \
-        if (pdata->name >= edt_ft5x06_attr_##name.limit_low &&          \
-            pdata->name <= edt_ft5x06_attr_##name.limit_high)           \
-                edt_ft5x06_register_write(tsdata, reg, pdata->name)
-
-static void
-edt_ft5x06_ts_get_defaults(struct edt_ft5x06_ts_data *tsdata,
-                           const struct edt_ft5x06_platform_data *pdata)
-{
-        if (!pdata->use_parameters)
-                return;
-
-        /* pick up defaults from the platform data */
-        EDT_ATTR_CHECKSET(threshold, WORK_REGISTER_THRESHOLD);
-        EDT_ATTR_CHECKSET(gain, WORK_REGISTER_GAIN);
-        EDT_ATTR_CHECKSET(offset, WORK_REGISTER_OFFSET);
-        EDT_ATTR_CHECKSET(report_rate, WORK_REGISTER_REPORT_RATE);
-}
-
-static void
-edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata)
-{
-        tsdata->threshold = edt_ft5x06_register_read(tsdata,
-                                                     WORK_REGISTER_THRESHOLD);
-        tsdata->gain = edt_ft5x06_register_read(tsdata, WORK_REGISTER_GAIN);
-        tsdata->offset = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OFFSET);
-        tsdata->report_rate = edt_ft5x06_register_read(tsdata,
-                                                WORK_REGISTER_REPORT_RATE);
-        tsdata->num_x = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_X);
-        tsdata->num_y = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_Y);
-}
-
-static int edt_ft5x06_ts_probe(struct i2c_client *client,
-                                         const struct i2c_device_id *id)
-{
-        const struct edt_ft5x06_platform_data *pdata =
-                                                client->dev.platform_data;
-        struct edt_ft5x06_ts_data *tsdata;
-        struct input_dev *input;
-        int error;
-        char fw_version[EDT_NAME_LEN];
-
-        dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n");
-
-        if (!pdata) {
-                dev_err(&client->dev, "no platform data?\n");
-                return -EINVAL;
-        }
-
-        error = edt_ft5x06_ts_reset(client, pdata->reset_pin);
-        if (error)
-                return error;
-
-        if (gpio_is_valid(pdata->irq_pin)) {
-                error = gpio_request_one(pdata->irq_pin,
-                                         GPIOF_IN, "edt-ft5x06 irq");
-                if (error) {
-                        dev_err(&client->dev,
-                                "Failed to request GPIO %d, error %d\n",
-                                pdata->irq_pin, error);
-                        return error;
-                }
-        }
-
-        tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!tsdata || !input) {
-                dev_err(&client->dev, "failed to allocate driver data.\n");
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        mutex_init(&tsdata->mutex);
-        tsdata->client = client;
-        tsdata->input = input;
-        tsdata->factory_mode = false;
-
-        error = edt_ft5x06_ts_identify(client, tsdata->name, fw_version);
-        if (error) {
-                dev_err(&client->dev, "touchscreen probe failed\n");
-                goto err_free_mem;
-        }
-
-        edt_ft5x06_ts_get_defaults(tsdata, pdata);
-        edt_ft5x06_ts_get_parameters(tsdata);
-
-        dev_dbg(&client->dev,
-                "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
-                tsdata->name, fw_version, tsdata->num_x, tsdata->num_y);
-
-        input->name = tsdata->name;
-        input->id.bustype = BUS_I2C;
-        input->dev.parent = &client->dev;
-
-        __set_bit(EV_SYN, input->evbit);
-        __set_bit(EV_KEY, input->evbit);
-        __set_bit(EV_ABS, input->evbit);
-        __set_bit(BTN_TOUCH, input->keybit);
-        input_set_abs_params(input, ABS_X, 0, tsdata->num_x * 64 - 1, 0, 0);
-        input_set_abs_params(input, ABS_Y, 0, tsdata->num_y * 64 - 1, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_X,
-                             0, tsdata->num_x * 64 - 1, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_Y,
-                             0, tsdata->num_y * 64 - 1, 0, 0);
-        error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0);
-        if (error) {
-                dev_err(&client->dev, "Unable to init MT slots.\n");
-                goto err_free_mem;
-        }
-
-        input_set_drvdata(input, tsdata);
-        i2c_set_clientdata(client, tsdata);
-
-        error = request_threaded_irq(client->irq, NULL, edt_ft5x06_ts_isr,
-                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
-                                     client->name, tsdata);
-        if (error) {
-                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
-                goto err_free_mem;
-        }
-
-        error = sysfs_create_group(&client->dev.kobj, &edt_ft5x06_attr_group);
-        if (error)
-                goto err_free_irq;
-
-        error = input_register_device(input);
-        if (error)
-                goto err_remove_attrs;
-
-        edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev));
-        device_init_wakeup(&client->dev, 1);
-
-        dev_dbg(&client->dev,
-                "EDT FT5x06 initialized: IRQ pin %d, Reset pin %d.\n",
-                pdata->irq_pin, pdata->reset_pin);
-
-        return 0;
-
-err_remove_attrs:
-        sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group);
-err_free_irq:
-        free_irq(client->irq, tsdata);
-err_free_mem:
-        input_free_device(input);
-        kfree(tsdata);
-
-        if (gpio_is_valid(pdata->irq_pin))
-                gpio_free(pdata->irq_pin);
-
-        return error;
-}
-
-static int edt_ft5x06_ts_remove(struct i2c_client *client)
-{
-        const struct edt_ft5x06_platform_data *pdata =
-                                                dev_get_platdata(&client->dev);
-        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
-
-        edt_ft5x06_ts_teardown_debugfs(tsdata);
-        sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group);
-
-        free_irq(client->irq, tsdata);
-        input_unregister_device(tsdata->input);
-
-        if (gpio_is_valid(pdata->irq_pin))
-                gpio_free(pdata->irq_pin);
-        if (gpio_is_valid(pdata->reset_pin))
-                gpio_free(pdata->reset_pin);
-
-        kfree(tsdata);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int edt_ft5x06_ts_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(dev))
-                enable_irq_wake(client->irq);
-
-        return 0;
-}
-
-static int edt_ft5x06_ts_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(dev))
-                disable_irq_wake(client->irq);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops,
-                         edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume);
-
-static const struct i2c_device_id edt_ft5x06_ts_id[] = {
-        { "edt-ft5x06", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);
-
-static struct i2c_driver edt_ft5x06_ts_driver = {
-        .driver = {
-                .owner = THIS_MODULE,
-                .name = "edt_ft5x06",
-                .pm = &edt_ft5x06_ts_pm_ops,
-        },
-        .id_table = edt_ft5x06_ts_id,
-        .probe    = edt_ft5x06_ts_probe,
-        .remove   = edt_ft5x06_ts_remove,
-};
-
-module_i2c_driver(edt_ft5x06_ts_driver);
-
-MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
-MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/eeti_ts.c b/drivers/input/touchscreen/eeti_ts.c
index 55255a94007..7f8f538a980 100644
--- a/drivers/input/touchscreen/eeti_ts.c
+++ b/drivers/input/touchscreen/eeti_ts.c
@@ -35,11 +35,11 @@
 #include <linux/input/eeti_ts.h>
 #include <linux/slab.h>
 
-static bool flip_x;
+static int flip_x;
 module_param(flip_x, bool, 0644);
 MODULE_PARM_DESC(flip_x, "flip x coordinate");
 
-static bool flip_y;
+static int flip_y;
 module_param(flip_y, bool, 0644);
 MODULE_PARM_DESC(flip_y, "flip y coordinate");
 
@@ -48,7 +48,7 @@ struct eeti_ts_priv {
         struct input_dev *input;
         struct work_struct work;
         struct mutex mutex;
-        int irq_gpio, irq, irq_active_high;
+        int irq, irq_active_high;
 };
 
 #define EETI_TS_BITDEPTH        (11)
@@ -62,7 +62,7 @@ struct eeti_ts_priv {
 
 static inline int eeti_ts_irq_active(struct eeti_ts_priv *priv)
 {
-        return gpio_get_value(priv->irq_gpio) == priv->irq_active_high;
+        return gpio_get_value(irq_to_gpio(priv->irq)) == priv->irq_active_high;
 }
 
 static void eeti_ts_read(struct work_struct *work)
@@ -154,10 +154,10 @@ static void eeti_ts_close(struct input_dev *dev)
         eeti_ts_stop(priv);
 }
 
-static int eeti_ts_probe(struct i2c_client *client,
+static int __devinit eeti_ts_probe(struct i2c_client *client,
                                    const struct i2c_device_id *idp)
 {
-        struct eeti_ts_platform_data *pdata = client->dev.platform_data;
+        struct eeti_ts_platform_data *pdata;
         struct eeti_ts_priv *priv;
         struct input_dev *input;
         unsigned int irq_flags;
@@ -199,12 +199,9 @@ static int eeti_ts_probe(struct i2c_client *client,
 
         priv->client = client;
         priv->input = input;
-        priv->irq_gpio = pdata->irq_gpio;
-        priv->irq = gpio_to_irq(pdata->irq_gpio);
+        priv->irq = client->irq;
 
-        err = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name);
-        if (err < 0)
-                goto err1;
+        pdata = client->dev.platform_data;
 
         if (pdata)
                 priv->irq_active_high = pdata->irq_active_high;
@@ -218,13 +215,13 @@ static int eeti_ts_probe(struct i2c_client *client,
 
         err = input_register_device(input);
         if (err)
-                goto err2;
+                goto err1;
 
         err = request_irq(priv->irq, eeti_ts_isr, irq_flags,
                           client->name, priv);
         if (err) {
                 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
-                goto err3;
+                goto err2;
         }
 
         /*
@@ -236,11 +233,9 @@ static int eeti_ts_probe(struct i2c_client *client,
         device_init_wakeup(&client->dev, 0);
         return 0;
 
-err3:
+err2:
         input_unregister_device(input);
         input = NULL; /* so we dont try to free it below */
-err2:
-        gpio_free(pdata->irq_gpio);
 err1:
         input_free_device(input);
         kfree(priv);
@@ -248,7 +243,7 @@ err0:
         return err;
 }
 
-static int eeti_ts_remove(struct i2c_client *client)
+static int __devexit eeti_ts_remove(struct i2c_client *client)
 {
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
 
@@ -321,12 +316,24 @@ static struct i2c_driver eeti_ts_driver = {
 #endif
         },
         .probe = eeti_ts_probe,
-        .remove = eeti_ts_remove,
+        .remove = __devexit_p(eeti_ts_remove),
         .id_table = eeti_ts_id,
 };
 
-module_i2c_driver(eeti_ts_driver);
+static int __init eeti_ts_init(void)
+{
+        return i2c_add_driver(&eeti_ts_driver);
+}
+
+static void __exit eeti_ts_exit(void)
+{
+        i2c_del_driver(&eeti_ts_driver);
+}
 
 MODULE_DESCRIPTION("EETI Touchscreen driver");
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
 MODULE_LICENSE("GPL");
+
+module_init(eeti_ts_init);
+module_exit(eeti_ts_exit);
+
diff --git a/drivers/input/touchscreen/egalax_ts.c b/drivers/input/touchscreen/egalax_ts.c
deleted file mode 100644
index 17c9097f3b5..00000000000
--- a/drivers/input/touchscreen/egalax_ts.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Driver for EETI eGalax Multiple Touch Controller
- *
- * Copyright (C) 2011 Freescale Semiconductor, Inc.
- *
- * based on max11801_ts.c
- *
- * 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.
- */
-
-/* EETI eGalax serial touch screen controller is a I2C based multiple
- * touch screen controller, it supports 5 point multiple touch. */
-
-/* TODO:
-  - auto idle mode support
-*/
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/i2c.h>
-#include <linux/interrupt.h>
-#include <linux/input.h>
-#include <linux/irq.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/bitops.h>
-#include <linux/input/mt.h>
-#include <linux/of_gpio.h>
-
-/*
- * Mouse Mode: some panel may configure the controller to mouse mode,
- * which can only report one point at a given time.
- * This driver will ignore events in this mode.
- */
-#define REPORT_MODE_MOUSE               0x1
-/*
- * Vendor Mode: this mode is used to transfer some vendor specific
- * messages.
- * This driver will ignore events in this mode.
- */
-#define REPORT_MODE_VENDOR              0x3
-/* Multiple Touch Mode */
-#define REPORT_MODE_MTTOUCH             0x4
-
-#define MAX_SUPPORT_POINTS              5
-
-#define EVENT_VALID_OFFSET      7
-#define EVENT_VALID_MASK        (0x1 << EVENT_VALID_OFFSET)
-#define EVENT_ID_OFFSET         2
-#define EVENT_ID_MASK           (0xf << EVENT_ID_OFFSET)
-#define EVENT_IN_RANGE          (0x1 << 1)
-#define EVENT_DOWN_UP           (0X1 << 0)
-
-#define MAX_I2C_DATA_LEN        10
-
-#define EGALAX_MAX_X    32760
-#define EGALAX_MAX_Y    32760
-#define EGALAX_MAX_TRIES 100
-
-struct egalax_ts {
-        struct i2c_client               *client;
-        struct input_dev                *input_dev;
-};
-
-static irqreturn_t egalax_ts_interrupt(int irq, void *dev_id)
-{
-        struct egalax_ts *ts = dev_id;
-        struct input_dev *input_dev = ts->input_dev;
-        struct i2c_client *client = ts->client;
-        u8 buf[MAX_I2C_DATA_LEN];
-        int id, ret, x, y, z;
-        int tries = 0;
-        bool down, valid;
-        u8 state;
-
-        do {
-                ret = i2c_master_recv(client, buf, MAX_I2C_DATA_LEN);
-        } while (ret == -EAGAIN && tries++ < EGALAX_MAX_TRIES);
-
-        if (ret < 0)
-                return IRQ_HANDLED;
-
-        if (buf[0] != REPORT_MODE_MTTOUCH) {
-                /* ignore mouse events and vendor events */
-                return IRQ_HANDLED;
-        }
-
-        state = buf[1];
-        x = (buf[3] << 8) | buf[2];
-        y = (buf[5] << 8) | buf[4];
-        z = (buf[7] << 8) | buf[6];
-
-        valid = state & EVENT_VALID_MASK;
-        id = (state & EVENT_ID_MASK) >> EVENT_ID_OFFSET;
-        down = state & EVENT_DOWN_UP;
-
-        if (!valid || id > MAX_SUPPORT_POINTS) {
-                dev_dbg(&client->dev, "point invalid\n");
-                return IRQ_HANDLED;
-        }
-
-        input_mt_slot(input_dev, id);
-        input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, down);
-
-        dev_dbg(&client->dev, "%s id:%d x:%d y:%d z:%d",
-                down ? "down" : "up", id, x, y, z);
-
-        if (down) {
-                input_report_abs(input_dev, ABS_MT_POSITION_X, x);
-                input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
-                input_report_abs(input_dev, ABS_MT_PRESSURE, z);
-        }
-
-        input_mt_report_pointer_emulation(input_dev, true);
-        input_sync(input_dev);
-
-        return IRQ_HANDLED;
-}
-
-/* wake up controller by an falling edge of interrupt gpio.  */
-static int egalax_wake_up_device(struct i2c_client *client)
-{
-        struct device_node *np = client->dev.of_node;
-        int gpio;
-        int ret;
-
-        if (!np)
-                return -ENODEV;
-
-        gpio = of_get_named_gpio(np, "wakeup-gpios", 0);
-        if (!gpio_is_valid(gpio))
-                return -ENODEV;
-
-        ret = gpio_request(gpio, "egalax_irq");
-        if (ret < 0) {
-                dev_err(&client->dev,
-                        "request gpio failed, cannot wake up controller: %d\n",
-                        ret);
-                return ret;
-        }
-
-        /* wake up controller via an falling edge on IRQ gpio. */
-        gpio_direction_output(gpio, 0);
-        gpio_set_value(gpio, 1);
-
-        /* controller should be waken up, return irq.  */
-        gpio_direction_input(gpio);
-        gpio_free(gpio);
-
-        return 0;
-}
-
-static int egalax_firmware_version(struct i2c_client *client)
-{
-        static const u8 cmd[MAX_I2C_DATA_LEN] = { 0x03, 0x03, 0xa, 0x01, 0x41 };
-        int ret;
-
-        ret = i2c_master_send(client, cmd, MAX_I2C_DATA_LEN);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static int egalax_ts_probe(struct i2c_client *client,
-                                       const struct i2c_device_id *id)
-{
-        struct egalax_ts *ts;
-        struct input_dev *input_dev;
-        int ret;
-        int error;
-
-        ts = kzalloc(sizeof(struct egalax_ts), GFP_KERNEL);
-        if (!ts) {
-                dev_err(&client->dev, "Failed to allocate memory\n");
-                return -ENOMEM;
-        }
-
-        input_dev = input_allocate_device();
-        if (!input_dev) {
-                dev_err(&client->dev, "Failed to allocate memory\n");
-                error = -ENOMEM;
-                goto err_free_ts;
-        }
-
-        ts->client = client;
-        ts->input_dev = input_dev;
-
-        /* controller may be in sleep, wake it up. */
-        error = egalax_wake_up_device(client);
-        if (error) {
-                dev_err(&client->dev, "Failed to wake up the controller\n");
-                goto err_free_dev;
-        }
-
-        ret = egalax_firmware_version(client);
-        if (ret < 0) {
-                dev_err(&client->dev, "Failed to read firmware version\n");
-                error = -EIO;
-                goto err_free_dev;
-        }
-
-        input_dev->name = "EETI eGalax Touch Screen";
-        input_dev->id.bustype = BUS_I2C;
-        input_dev->dev.parent = &client->dev;
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-
-        input_set_abs_params(input_dev, ABS_X, 0, EGALAX_MAX_X, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, EGALAX_MAX_Y, 0, 0);
-        input_set_abs_params(input_dev,
-                             ABS_MT_POSITION_X, 0, EGALAX_MAX_X, 0, 0);
-        input_set_abs_params(input_dev,
-                             ABS_MT_POSITION_X, 0, EGALAX_MAX_Y, 0, 0);
-        input_mt_init_slots(input_dev, MAX_SUPPORT_POINTS, 0);
-
-        input_set_drvdata(input_dev, ts);
-
-        error = request_threaded_irq(client->irq, NULL, egalax_ts_interrupt,
-                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                     "egalax_ts", ts);
-        if (error < 0) {
-                dev_err(&client->dev, "Failed to register interrupt\n");
-                goto err_free_dev;
-        }
-
-        error = input_register_device(ts->input_dev);
-        if (error)
-                goto err_free_irq;
-
-        i2c_set_clientdata(client, ts);
-        return 0;
-
-err_free_irq:
-        free_irq(client->irq, ts);
-err_free_dev:
-        input_free_device(input_dev);
-err_free_ts:
-        kfree(ts);
-
-        return error;
-}
-
-static int egalax_ts_remove(struct i2c_client *client)
-{
-        struct egalax_ts *ts = i2c_get_clientdata(client);
-
-        free_irq(client->irq, ts);
-
-        input_unregister_device(ts->input_dev);
-        kfree(ts);
-
-        return 0;
-}
-
-static const struct i2c_device_id egalax_ts_id[] = {
-        { "egalax_ts", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, egalax_ts_id);
-
-#ifdef CONFIG_PM_SLEEP
-static int egalax_ts_suspend(struct device *dev)
-{
-        static const u8 suspend_cmd[MAX_I2C_DATA_LEN] = {
-                0x3, 0x6, 0xa, 0x3, 0x36, 0x3f, 0x2, 0, 0, 0
-        };
-        struct i2c_client *client = to_i2c_client(dev);
-        int ret;
-
-        ret = i2c_master_send(client, suspend_cmd, MAX_I2C_DATA_LEN);
-        return ret > 0 ? 0 : ret;
-}
-
-static int egalax_ts_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        return egalax_wake_up_device(client);
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(egalax_ts_pm_ops, egalax_ts_suspend, egalax_ts_resume);
-
-static struct of_device_id egalax_ts_dt_ids[] = {
-        { .compatible = "eeti,egalax_ts" },
-        { /* sentinel */ }
-};
-
-static struct i2c_driver egalax_ts_driver = {
-        .driver = {
-                .name   = "egalax_ts",
-                .owner  = THIS_MODULE,
-                .pm     = &egalax_ts_pm_ops,
-                .of_match_table = of_match_ptr(egalax_ts_dt_ids),
-        },
-        .id_table       = egalax_ts_id,
-        .probe          = egalax_ts_probe,
-        .remove         = egalax_ts_remove,
-};
-
-module_i2c_driver(egalax_ts_driver);
-
-MODULE_AUTHOR("Freescale Semiconductor, Inc.");
-MODULE_DESCRIPTION("Touchscreen driver for EETI eGalax touch controller");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/elo.c b/drivers/input/touchscreen/elo.c
index 957423d1471..486d31ba9c0 100644
--- a/drivers/input/touchscreen/elo.c
+++ b/drivers/input/touchscreen/elo.c
@@ -405,4 +405,19 @@ static struct serio_driver elo_drv = {
         .disconnect     = elo_disconnect,
 };
 
-module_serio_driver(elo_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init elo_init(void)
+{
+        return serio_register_driver(&elo_drv);
+}
+
+static void __exit elo_exit(void)
+{
+        serio_unregister_driver(&elo_drv);
+}
+
+module_init(elo_init);
+module_exit(elo_exit);
diff --git a/drivers/input/touchscreen/fujitsu_ts.c b/drivers/input/touchscreen/fujitsu_ts.c
index 10794ddbdf5..80b21800355 100644
--- a/drivers/input/touchscreen/fujitsu_ts.c
+++ b/drivers/input/touchscreen/fujitsu_ts.c
@@ -175,4 +175,15 @@ static struct serio_driver fujitsu_drv = {
         .disconnect     = fujitsu_disconnect,
 };
 
-module_serio_driver(fujitsu_drv);
+static int __init fujitsu_init(void)
+{
+        return serio_register_driver(&fujitsu_drv);
+}
+
+static void __exit fujitsu_exit(void)
+{
+        serio_unregister_driver(&fujitsu_drv);
+}
+
+module_init(fujitsu_init);
+module_exit(fujitsu_exit);
diff --git a/drivers/input/touchscreen/gunze.c b/drivers/input/touchscreen/gunze.c
index 41c71766bf1..a54f90e02ab 100644
--- a/drivers/input/touchscreen/gunze.c
+++ b/drivers/input/touchscreen/gunze.c
@@ -186,4 +186,19 @@ static struct serio_driver gunze_drv = {
         .disconnect     = gunze_disconnect,
 };
 
-module_serio_driver(gunze_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init gunze_init(void)
+{
+        return serio_register_driver(&gunze_drv);
+}
+
+static void __exit gunze_exit(void)
+{
+        serio_unregister_driver(&gunze_drv);
+}
+
+module_init(gunze_init);
+module_exit(gunze_exit);
diff --git a/drivers/input/touchscreen/hampshire.c b/drivers/input/touchscreen/hampshire.c
index 0cc47ea98ac..2da6cc31bb2 100644
--- a/drivers/input/touchscreen/hampshire.c
+++ b/drivers/input/touchscreen/hampshire.c
@@ -187,4 +187,19 @@ static struct serio_driver hampshire_drv = {
         .disconnect     = hampshire_disconnect,
 };
 
-module_serio_driver(hampshire_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init hampshire_init(void)
+{
+        return serio_register_driver(&hampshire_drv);
+}
+
+static void __exit hampshire_exit(void)
+{
+        serio_unregister_driver(&hampshire_drv);
+}
+
+module_init(hampshire_init);
+module_exit(hampshire_exit);
diff --git a/drivers/input/touchscreen/hp680_ts_input.c b/drivers/input/touchscreen/hp680_ts_input.c
index 85cf9bee801..dd4e8f020b9 100644
--- a/drivers/input/touchscreen/hp680_ts_input.c
+++ b/drivers/input/touchscreen/hp680_ts_input.c
@@ -93,7 +93,7 @@ static int __init hp680_ts_init(void)
         hp680_ts_dev->phys = "hp680_ts/input0";
 
         if (request_irq(HP680_TS_IRQ, hp680_ts_interrupt,
-                        0, MODNAME, NULL) < 0) {
+                        IRQF_DISABLED, MODNAME, 0) < 0) {
                 printk(KERN_ERR "hp680_touchscreen.c: Can't allocate irq %d\n",
                        HP680_TS_IRQ);
                 err = -EBUSY;
diff --git a/drivers/input/touchscreen/htcpen.c b/drivers/input/touchscreen/htcpen.c
index 6c4fb843695..62811de6f18 100644
--- a/drivers/input/touchscreen/htcpen.c
+++ b/drivers/input/touchscreen/htcpen.c
@@ -40,13 +40,19 @@ MODULE_LICENSE("GPL");
 #define X_AXIS_MAX              2040
 #define Y_AXIS_MAX              2040
 
-static bool invert_x;
+static int invert_x;
 module_param(invert_x, bool, 0644);
 MODULE_PARM_DESC(invert_x, "If set, X axis is inverted");
-static bool invert_y;
+static int invert_y;
 module_param(invert_y, bool, 0644);
 MODULE_PARM_DESC(invert_y, "If set, Y axis is inverted");
 
+static struct pnp_device_id pnp_ids[] = {
+        { .id = "PNP0cc0" },
+        { .id = "" }
+};
+MODULE_DEVICE_TABLE(pnp, pnp_ids);
+
 static irqreturn_t htcpen_interrupt(int irq, void *handle)
 {
         struct input_dev *htcpen_dev = handle;
@@ -102,7 +108,7 @@ static void htcpen_close(struct input_dev *dev)
         synchronize_irq(HTCPEN_IRQ);
 }
 
-static int htcpen_isa_probe(struct device *dev, unsigned int id)
+static int __devinit htcpen_isa_probe(struct device *dev, unsigned int id)
 {
         struct input_dev *htcpen_dev;
         int err = -EBUSY;
@@ -174,7 +180,7 @@ static int htcpen_isa_probe(struct device *dev, unsigned int id)
         return err;
 }
 
-static int htcpen_isa_remove(struct device *dev, unsigned int id)
+static int __devexit htcpen_isa_remove(struct device *dev, unsigned int id)
 {
         struct input_dev *htcpen_dev = dev_get_drvdata(dev);
 
@@ -210,7 +216,7 @@ static int htcpen_isa_resume(struct device *dev, unsigned int n)
 
 static struct isa_driver htcpen_isa_driver = {
         .probe          = htcpen_isa_probe,
-        .remove         = htcpen_isa_remove,
+        .remove         = __devexit_p(htcpen_isa_remove),
 #ifdef CONFIG_PM
         .suspend        = htcpen_isa_suspend,
         .resume         = htcpen_isa_resume,
@@ -231,7 +237,6 @@ static struct dmi_system_id __initdata htcshift_dmi_table[] = {
         },
         { }
 };
-MODULE_DEVICE_TABLE(dmi, htcshift_dmi_table);
 
 static int __init htcpen_isa_init(void)
 {
diff --git a/drivers/input/touchscreen/ili210x.c b/drivers/input/touchscreen/ili210x.c
deleted file mode 100644
index 1418bdda61b..00000000000
--- a/drivers/input/touchscreen/ili210x.c
+++ /dev/null
@@ -1,360 +0,0 @@
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/input.h>
-#include <linux/input/mt.h>
-#include <linux/delay.h>
-#include <linux/workqueue.h>
-#include <linux/input/ili210x.h>
-
-#define MAX_TOUCHES             2
-#define DEFAULT_POLL_PERIOD     20
-
-/* Touchscreen commands */
-#define REG_TOUCHDATA           0x10
-#define REG_PANEL_INFO          0x20
-#define REG_FIRMWARE_VERSION    0x40
-#define REG_CALIBRATE           0xcc
-
-struct finger {
-        u8 x_low;
-        u8 x_high;
-        u8 y_low;
-        u8 y_high;
-} __packed;
-
-struct touchdata {
-        u8 status;
-        struct finger finger[MAX_TOUCHES];
-} __packed;
-
-struct panel_info {
-        struct finger finger_max;
-        u8 xchannel_num;
-        u8 ychannel_num;
-} __packed;
-
-struct firmware_version {
-        u8 id;
-        u8 major;
-        u8 minor;
-} __packed;
-
-struct ili210x {
-        struct i2c_client *client;
-        struct input_dev *input;
-        bool (*get_pendown_state)(void);
-        unsigned int poll_period;
-        struct delayed_work dwork;
-};
-
-static int ili210x_read_reg(struct i2c_client *client, u8 reg, void *buf,
-                            size_t len)
-{
-        struct i2c_msg msg[2] = {
-                {
-                        .addr   = client->addr,
-                        .flags  = 0,
-                        .len    = 1,
-                        .buf    = &reg,
-                },
-                {
-                        .addr   = client->addr,
-                        .flags  = I2C_M_RD,
-                        .len    = len,
-                        .buf    = buf,
-                }
-        };
-
-        if (i2c_transfer(client->adapter, msg, 2) != 2) {
-                dev_err(&client->dev, "i2c transfer failed\n");
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static void ili210x_report_events(struct input_dev *input,
-                                  const struct touchdata *touchdata)
-{
-        int i;
-        bool touch;
-        unsigned int x, y;
-        const struct finger *finger;
-
-        for (i = 0; i < MAX_TOUCHES; i++) {
-                input_mt_slot(input, i);
-
-                finger = &touchdata->finger[i];
-
-                touch = touchdata->status & (1 << i);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
-                if (touch) {
-                        x = finger->x_low | (finger->x_high << 8);
-                        y = finger->y_low | (finger->y_high << 8);
-
-                        input_report_abs(input, ABS_MT_POSITION_X, x);
-                        input_report_abs(input, ABS_MT_POSITION_Y, y);
-                }
-        }
-
-        input_mt_report_pointer_emulation(input, false);
-        input_sync(input);
-}
-
-static bool get_pendown_state(const struct ili210x *priv)
-{
-        bool state = false;
-
-        if (priv->get_pendown_state)
-                state = priv->get_pendown_state();
-
-        return state;
-}
-
-static void ili210x_work(struct work_struct *work)
-{
-        struct ili210x *priv = container_of(work, struct ili210x,
-                                            dwork.work);
-        struct i2c_client *client = priv->client;
-        struct touchdata touchdata;
-        int error;
-
-        error = ili210x_read_reg(client, REG_TOUCHDATA,
-                                 &touchdata, sizeof(touchdata));
-        if (error) {
-                dev_err(&client->dev,
-                        "Unable to get touchdata, err = %d\n", error);
-                return;
-        }
-
-        ili210x_report_events(priv->input, &touchdata);
-
-        if ((touchdata.status & 0xf3) || get_pendown_state(priv))
-                schedule_delayed_work(&priv->dwork,
-                                      msecs_to_jiffies(priv->poll_period));
-}
-
-static irqreturn_t ili210x_irq(int irq, void *irq_data)
-{
-        struct ili210x *priv = irq_data;
-
-        schedule_delayed_work(&priv->dwork, 0);
-
-        return IRQ_HANDLED;
-}
-
-static ssize_t ili210x_calibrate(struct device *dev,
-                                 struct device_attribute *attr,
-                                 const char *buf, size_t count)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct ili210x *priv = i2c_get_clientdata(client);
-        unsigned long calibrate;
-        int rc;
-        u8 cmd = REG_CALIBRATE;
-
-        if (kstrtoul(buf, 10, &calibrate))
-                return -EINVAL;
-
-        if (calibrate > 1)
-                return -EINVAL;
-
-        if (calibrate) {
-                rc = i2c_master_send(priv->client, &cmd, sizeof(cmd));
-                if (rc != sizeof(cmd))
-                        return -EIO;
-        }
-
-        return count;
-}
-static DEVICE_ATTR(calibrate, 0644, NULL, ili210x_calibrate);
-
-static struct attribute *ili210x_attributes[] = {
-        &dev_attr_calibrate.attr,
-        NULL,
-};
-
-static const struct attribute_group ili210x_attr_group = {
-        .attrs = ili210x_attributes,
-};
-
-static int ili210x_i2c_probe(struct i2c_client *client,
-                                       const struct i2c_device_id *id)
-{
-        struct device *dev = &client->dev;
-        const struct ili210x_platform_data *pdata = dev->platform_data;
-        struct ili210x *priv;
-        struct input_dev *input;
-        struct panel_info panel;
-        struct firmware_version firmware;
-        int xmax, ymax;
-        int error;
-
-        dev_dbg(dev, "Probing for ILI210X I2C Touschreen driver");
-
-        if (!pdata) {
-                dev_err(dev, "No platform data!\n");
-                return -EINVAL;
-        }
-
-        if (client->irq <= 0) {
-                dev_err(dev, "No IRQ!\n");
-                return -EINVAL;
-        }
-
-        /* Get firmware version */
-        error = ili210x_read_reg(client, REG_FIRMWARE_VERSION,
-                                 &firmware, sizeof(firmware));
-        if (error) {
-                dev_err(dev, "Failed to get firmware version, err: %d\n",
-                        error);
-                return error;
-        }
-
-        /* get panel info */
-        error = ili210x_read_reg(client, REG_PANEL_INFO, &panel, sizeof(panel));
-        if (error) {
-                dev_err(dev, "Failed to get panel informations, err: %d\n",
-                        error);
-                return error;
-        }
-
-        xmax = panel.finger_max.x_low | (panel.finger_max.x_high << 8);
-        ymax = panel.finger_max.y_low | (panel.finger_max.y_high << 8);
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!priv || !input) {
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        priv->client = client;
-        priv->input = input;
-        priv->get_pendown_state = pdata->get_pendown_state;
-        priv->poll_period = pdata->poll_period ? : DEFAULT_POLL_PERIOD;
-        INIT_DELAYED_WORK(&priv->dwork, ili210x_work);
-
-        /* Setup input device */
-        input->name = "ILI210x Touchscreen";
-        input->id.bustype = BUS_I2C;
-        input->dev.parent = dev;
-
-        __set_bit(EV_SYN, input->evbit);
-        __set_bit(EV_KEY, input->evbit);
-        __set_bit(EV_ABS, input->evbit);
-        __set_bit(BTN_TOUCH, input->keybit);
-
-        /* Single touch */
-        input_set_abs_params(input, ABS_X, 0, xmax, 0, 0);
-        input_set_abs_params(input, ABS_Y, 0, ymax, 0, 0);
-
-        /* Multi touch */
-        input_mt_init_slots(input, MAX_TOUCHES, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_X, 0, xmax, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_Y, 0, ymax, 0, 0);
-
-        input_set_drvdata(input, priv);
-        i2c_set_clientdata(client, priv);
-
-        error = request_irq(client->irq, ili210x_irq, pdata->irq_flags,
-                            client->name, priv);
-        if (error) {
-                dev_err(dev, "Unable to request touchscreen IRQ, err: %d\n",
-                        error);
-                goto err_free_mem;
-        }
-
-        error = sysfs_create_group(&dev->kobj, &ili210x_attr_group);
-        if (error) {
-                dev_err(dev, "Unable to create sysfs attributes, err: %d\n",
-                        error);
-                goto err_free_irq;
-        }
-
-        error = input_register_device(priv->input);
-        if (error) {
-                dev_err(dev, "Cannot regiser input device, err: %d\n", error);
-                goto err_remove_sysfs;
-        }
-
-        device_init_wakeup(&client->dev, 1);
-
-        dev_dbg(dev,
-                "ILI210x initialized (IRQ: %d), firmware version %d.%d.%d",
-                client->irq, firmware.id, firmware.major, firmware.minor);
-
-        return 0;
-
-err_remove_sysfs:
-        sysfs_remove_group(&dev->kobj, &ili210x_attr_group);
-err_free_irq:
-        free_irq(client->irq, priv);
-err_free_mem:
-        input_free_device(input);
-        kfree(priv);
-        return error;
-}
-
-static int ili210x_i2c_remove(struct i2c_client *client)
-{
-        struct ili210x *priv = i2c_get_clientdata(client);
-
-        sysfs_remove_group(&client->dev.kobj, &ili210x_attr_group);
-        free_irq(priv->client->irq, priv);
-        cancel_delayed_work_sync(&priv->dwork);
-        input_unregister_device(priv->input);
-        kfree(priv);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int ili210x_i2c_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(&client->dev))
-                enable_irq_wake(client->irq);
-
-        return 0;
-}
-
-static int ili210x_i2c_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(&client->dev))
-                disable_irq_wake(client->irq);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(ili210x_i2c_pm,
-                         ili210x_i2c_suspend, ili210x_i2c_resume);
-
-static const struct i2c_device_id ili210x_i2c_id[] = {
-        { "ili210x", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, ili210x_i2c_id);
-
-static struct i2c_driver ili210x_ts_driver = {
-        .driver = {
-                .name = "ili210x_i2c",
-                .owner = THIS_MODULE,
-                .pm = &ili210x_i2c_pm,
-        },
-        .id_table = ili210x_i2c_id,
-        .probe = ili210x_i2c_probe,
-        .remove = ili210x_i2c_remove,
-};
-
-module_i2c_driver(ili210x_ts_driver);
-
-MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
-MODULE_DESCRIPTION("ILI210X I2C Touchscreen Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/inexio.c b/drivers/input/touchscreen/inexio.c
index a29c99c3224..192ade0a0fb 100644
--- a/drivers/input/touchscreen/inexio.c
+++ b/drivers/input/touchscreen/inexio.c
@@ -189,4 +189,19 @@ static struct serio_driver inexio_drv = {
         .disconnect     = inexio_disconnect,
 };
 
-module_serio_driver(inexio_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init inexio_init(void)
+{
+        return serio_register_driver(&inexio_drv);
+}
+
+static void __exit inexio_exit(void)
+{
+        serio_unregister_driver(&inexio_drv);
+}
+
+module_init(inexio_init);
+module_exit(inexio_exit);
diff --git a/drivers/input/touchscreen/intel-mid-touch.c b/drivers/input/touchscreen/intel-mid-touch.c
index 465db5dba8b..327695268e0 100644
--- a/drivers/input/touchscreen/intel-mid-touch.c
+++ b/drivers/input/touchscreen/intel-mid-touch.c
@@ -427,7 +427,7 @@ out:
 }
 
 /* Utility to read PMIC ID */
-static int mrstouch_read_pmic_id(uint *vendor, uint *rev)
+static int __devinit mrstouch_read_pmic_id(uint *vendor, uint *rev)
 {
         int err;
         u8 r;
@@ -446,7 +446,7 @@ static int mrstouch_read_pmic_id(uint *vendor, uint *rev)
  * Parse ADC channels to find end of the channel configured by other ADC user
  * NEC and MAXIM requires 4 channels and FreeScale needs 18 channels
  */
-static int mrstouch_chan_parse(struct mrstouch_dev *tsdev)
+static int __devinit mrstouch_chan_parse(struct mrstouch_dev *tsdev)
 {
         int found = 0;
         int err, i;
@@ -478,7 +478,7 @@ static int mrstouch_chan_parse(struct mrstouch_dev *tsdev)
 /*
  * Writes touch screen channels to ADC address selection registers
  */
-static int mrstouch_ts_chan_set(uint offset)
+static int __devinit mrstouch_ts_chan_set(uint offset)
 {
         u16 chan;
 
@@ -494,7 +494,7 @@ static int mrstouch_ts_chan_set(uint offset)
 }
 
 /* Initialize ADC */
-static int mrstouch_adc_init(struct mrstouch_dev *tsdev)
+static int __devinit mrstouch_adc_init(struct mrstouch_dev *tsdev)
 {
         int err, start;
         u8 ra, rm;
@@ -568,7 +568,7 @@ static int mrstouch_adc_init(struct mrstouch_dev *tsdev)
 
 
 /* Probe function for touch screen driver */
-static int mrstouch_probe(struct platform_device *pdev)
+static int __devinit mrstouch_probe(struct platform_device *pdev)
 {
         struct mrstouch_dev *tsdev;
         struct input_dev *input;
@@ -620,7 +620,7 @@ static int mrstouch_probe(struct platform_device *pdev)
                              MRST_PRESSURE_MIN, MRST_PRESSURE_MAX, 0, 0);
 
         err = request_threaded_irq(tsdev->irq, NULL, mrstouch_pendet_irq,
-                                   IRQF_ONESHOT, "mrstouch", tsdev);
+                                   0, "mrstouch", tsdev);
         if (err) {
                 dev_err(tsdev->dev, "unable to allocate irq\n");
                 goto err_free_mem;
@@ -643,7 +643,7 @@ err_free_mem:
         return err;
 }
 
-static int mrstouch_remove(struct platform_device *pdev)
+static int __devexit mrstouch_remove(struct platform_device *pdev)
 {
         struct mrstouch_dev *tsdev = platform_get_drvdata(pdev);
 
@@ -662,9 +662,20 @@ static struct platform_driver mrstouch_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = mrstouch_probe,
-        .remove         = mrstouch_remove,
+        .remove         = __devexit_p(mrstouch_remove),
 };
-module_platform_driver(mrstouch_driver);
+
+static int __init mrstouch_init(void)
+{
+        return platform_driver_register(&mrstouch_driver);
+}
+module_init(mrstouch_init);
+
+static void __exit mrstouch_exit(void)
+{
+        platform_driver_unregister(&mrstouch_driver);
+}
+module_exit(mrstouch_exit);
 
 MODULE_AUTHOR("Sreedhara Murthy. D.S, sreedhara.ds@intel.com");
 MODULE_DESCRIPTION("Intel Moorestown Resistive Touch Screen Driver");
diff --git a/drivers/input/touchscreen/jornada720_ts.c b/drivers/input/touchscreen/jornada720_ts.c
index 282d7c7ad2f..4b0a061811f 100644
--- a/drivers/input/touchscreen/jornada720_ts.c
+++ b/drivers/input/touchscreen/jornada720_ts.c
@@ -19,11 +19,9 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #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");
@@ -99,7 +97,7 @@ static irqreturn_t jornada720_ts_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int jornada720_ts_probe(struct platform_device *pdev)
+static int __devinit jornada720_ts_probe(struct platform_device *pdev)
 {
         struct jornada_ts *jornada_ts;
         struct input_dev *input_dev;
@@ -129,7 +127,7 @@ static int jornada720_ts_probe(struct platform_device *pdev)
 
         error = request_irq(IRQ_GPIO9,
                         jornada720_ts_interrupt,
-                        IRQF_TRIGGER_RISING,
+                        IRQF_DISABLED | IRQF_TRIGGER_RISING,
                         "HP7XX Touchscreen driver", pdev);
         if (error) {
                 printk(KERN_INFO "HP7XX TS : Unable to acquire irq!\n");
@@ -151,7 +149,7 @@ static int jornada720_ts_probe(struct platform_device *pdev)
         return error;
 }
 
-static int jornada720_ts_remove(struct platform_device *pdev)
+static int __devexit jornada720_ts_remove(struct platform_device *pdev)
 {
         struct jornada_ts *jornada_ts = platform_get_drvdata(pdev);
 
@@ -168,10 +166,22 @@ MODULE_ALIAS("platform:jornada_ts");
 
 static struct platform_driver jornada720_ts_driver = {
         .probe          = jornada720_ts_probe,
-        .remove         = jornada720_ts_remove,
+        .remove         = __devexit_p(jornada720_ts_remove),
         .driver         = {
                 .name   = "jornada_ts",
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(jornada720_ts_driver);
+
+static int __init jornada720_ts_init(void)
+{
+        return platform_driver_register(&jornada720_ts_driver);
+}
+
+static void __exit jornada720_ts_exit(void)
+{
+        platform_driver_unregister(&jornada720_ts_driver);
+}
+
+module_init(jornada720_ts_init);
+module_exit(jornada720_ts_exit);
diff --git a/drivers/input/touchscreen/lpc32xx_ts.c b/drivers/input/touchscreen/lpc32xx_ts.c
index 9101ee529c9..dcf803f5a1f 100644
--- a/drivers/input/touchscreen/lpc32xx_ts.c
+++ b/drivers/input/touchscreen/lpc32xx_ts.c
@@ -22,7 +22,6 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <linux/of.h>
 
 /*
  * Touchscreen controller register offsets
@@ -203,7 +202,7 @@ static void lpc32xx_ts_close(struct input_dev *dev)
         lpc32xx_stop_tsc(tsc);
 }
 
-static int lpc32xx_ts_probe(struct platform_device *pdev)
+static int __devinit lpc32xx_ts_probe(struct platform_device *pdev)
 {
         struct lpc32xx_tsc *tsc;
         struct input_dev *input;
@@ -277,7 +276,7 @@ static int lpc32xx_ts_probe(struct platform_device *pdev)
         input_set_drvdata(input, tsc);
 
         error = request_irq(tsc->irq, lpc32xx_ts_interrupt,
-                            0, pdev->name, tsc);
+                            IRQF_DISABLED, pdev->name, tsc);
         if (error) {
                 dev_err(&pdev->dev, "failed requesting interrupt\n");
                 goto err_put_clock;
@@ -309,7 +308,7 @@ err_free_mem:
         return error;
 }
 
-static int lpc32xx_ts_remove(struct platform_device *pdev)
+static int __devexit lpc32xx_ts_remove(struct platform_device *pdev)
 {
         struct lpc32xx_tsc *tsc = platform_get_drvdata(pdev);
         struct resource *res;
@@ -384,25 +383,27 @@ static const struct dev_pm_ops lpc32xx_ts_pm_ops = {
 #define LPC32XX_TS_PM_OPS NULL
 #endif
 
-#ifdef CONFIG_OF
-static struct of_device_id lpc32xx_tsc_of_match[] = {
-        { .compatible = "nxp,lpc3220-tsc", },
-        { },
-};
-MODULE_DEVICE_TABLE(of, lpc32xx_tsc_of_match);
-#endif
-
 static struct platform_driver lpc32xx_ts_driver = {
         .probe          = lpc32xx_ts_probe,
-        .remove         = lpc32xx_ts_remove,
+        .remove         = __devexit_p(lpc32xx_ts_remove),
         .driver         = {
                 .name   = MOD_NAME,
                 .owner  = THIS_MODULE,
                 .pm     = LPC32XX_TS_PM_OPS,
-                .of_match_table = of_match_ptr(lpc32xx_tsc_of_match),
         },
 };
-module_platform_driver(lpc32xx_ts_driver);
+
+static int __init lpc32xx_ts_init(void)
+{
+        return platform_driver_register(&lpc32xx_ts_driver);
+}
+module_init(lpc32xx_ts_init);
+
+static void __exit lpc32xx_ts_exit(void)
+{
+        platform_driver_unregister(&lpc32xx_ts_driver);
+}
+module_exit(lpc32xx_ts_exit);
 
 MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com");
 MODULE_DESCRIPTION("LPC32XX TSC Driver");
diff --git a/drivers/input/touchscreen/mainstone-wm97xx.c b/drivers/input/touchscreen/mainstone-wm97xx.c
index 7d2b2136e5a..e966c29ff1b 100644
--- a/drivers/input/touchscreen/mainstone-wm97xx.c
+++ b/drivers/input/touchscreen/mainstone-wm97xx.c
@@ -302,7 +302,19 @@ static struct platform_driver mainstone_wm97xx_driver = {
                 .name = "wm97xx-touch",
         },
 };
-module_platform_driver(mainstone_wm97xx_driver);
+
+static int __init mainstone_wm97xx_init(void)
+{
+        return platform_driver_register(&mainstone_wm97xx_driver);
+}
+
+static void __exit mainstone_wm97xx_exit(void)
+{
+        platform_driver_unregister(&mainstone_wm97xx_driver);
+}
+
+module_init(mainstone_wm97xx_init);
+module_exit(mainstone_wm97xx_exit);
 
 /* Module information */
 MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
diff --git a/drivers/input/touchscreen/max11801_ts.c b/drivers/input/touchscreen/max11801_ts.c
index 00bc6caa27f..4627fe55b40 100644
--- a/drivers/input/touchscreen/max11801_ts.c
+++ b/drivers/input/touchscreen/max11801_ts.c
@@ -156,7 +156,7 @@ out:
         return IRQ_HANDLED;
 }
 
-static void max11801_ts_phy_init(struct max11801_data *data)
+static void __devinit max11801_ts_phy_init(struct max11801_data *data)
 {
         struct i2c_client *client = data->client;
 
@@ -174,7 +174,7 @@ static void max11801_ts_phy_init(struct max11801_data *data)
         max11801_write_reg(client, OP_MODE_CONF_REG, 0x36);
 }
 
-static int max11801_ts_probe(struct i2c_client *client,
+static int __devinit max11801_ts_probe(struct i2c_client *client,
                                        const struct i2c_device_id *id)
 {
         struct max11801_data *data;
@@ -228,7 +228,7 @@ err_free_mem:
         return error;
 }
 
-static int max11801_ts_remove(struct i2c_client *client)
+static __devexit int max11801_ts_remove(struct i2c_client *client)
 {
         struct max11801_data *data = i2c_get_clientdata(client);
 
@@ -252,10 +252,21 @@ static struct i2c_driver max11801_ts_driver = {
         },
         .id_table       = max11801_ts_id,
         .probe          = max11801_ts_probe,
-        .remove         = max11801_ts_remove,
+        .remove         = __devexit_p(max11801_ts_remove),
 };
 
-module_i2c_driver(max11801_ts_driver);
+static int __init max11801_ts_init(void)
+{
+        return i2c_add_driver(&max11801_ts_driver);
+}
+
+static void __exit max11801_ts_exit(void)
+{
+        i2c_del_driver(&max11801_ts_driver);
+}
+
+module_init(max11801_ts_init);
+module_exit(max11801_ts_exit);
 
 MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
 MODULE_DESCRIPTION("Touchscreen driver for MAXI MAX11801 controller");
diff --git a/drivers/input/touchscreen/mc13783_ts.c b/drivers/input/touchscreen/mc13783_ts.c
index 02103b6abb3..c5bc62d85bb 100644
--- a/drivers/input/touchscreen/mc13783_ts.c
+++ b/drivers/input/touchscreen/mc13783_ts.c
@@ -35,18 +35,17 @@ MODULE_PARM_DESC(sample_tolerance,
 
 struct mc13783_ts_priv {
         struct input_dev *idev;
-        struct mc13xxx *mc13xxx;
+        struct mc13783 *mc13783;
         struct delayed_work work;
         struct workqueue_struct *workq;
         unsigned int sample[4];
-        struct mc13xxx_ts_platform_data *touch;
 };
 
 static irqreturn_t mc13783_ts_handler(int irq, void *data)
 {
         struct mc13783_ts_priv *priv = data;
 
-        mc13xxx_irq_ack(priv->mc13xxx, irq);
+        mc13783_irq_ack(priv->mc13783, irq);
 
         /*
          * Kick off reading coordinates. Note that if work happens already
@@ -122,13 +121,11 @@ static void mc13783_ts_work(struct work_struct *work)
 {
         struct mc13783_ts_priv *priv =
                 container_of(work, struct mc13783_ts_priv, work.work);
-        unsigned int mode = MC13XXX_ADC_MODE_TS;
+        unsigned int mode = MC13783_ADC_MODE_TS;
         unsigned int channel = 12;
 
-        if (mc13xxx_adc_do_conversion(priv->mc13xxx,
-                                mode, channel,
-                                priv->touch->ato, priv->touch->atox,
-                                priv->sample) == 0)
+        if (mc13783_adc_do_conversion(priv->mc13783,
+                                mode, channel, priv->sample) == 0)
                 mc13783_ts_report_sample(priv);
 }
 
@@ -137,21 +134,21 @@ static int mc13783_ts_open(struct input_dev *dev)
         struct mc13783_ts_priv *priv = input_get_drvdata(dev);
         int ret;
 
-        mc13xxx_lock(priv->mc13xxx);
+        mc13783_lock(priv->mc13783);
 
-        mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TS);
+        mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TS);
 
-        ret = mc13xxx_irq_request(priv->mc13xxx, MC13XXX_IRQ_TS,
+        ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_TS,
                 mc13783_ts_handler, MC13783_TS_NAME, priv);
         if (ret)
                 goto out;
 
-        ret = mc13xxx_reg_rmw(priv->mc13xxx, MC13XXX_ADC0,
-                        MC13XXX_ADC0_TSMOD_MASK, MC13XXX_ADC0_TSMOD0);
+        ret = mc13783_reg_rmw(priv->mc13783, MC13783_ADC0,
+                        MC13783_ADC0_TSMOD_MASK, MC13783_ADC0_TSMOD0);
         if (ret)
-                mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TS, priv);
+                mc13783_irq_free(priv->mc13783, MC13783_IRQ_TS, priv);
 out:
-        mc13xxx_unlock(priv->mc13xxx);
+        mc13783_unlock(priv->mc13783);
         return ret;
 }
 
@@ -159,11 +156,11 @@ static void mc13783_ts_close(struct input_dev *dev)
 {
         struct mc13783_ts_priv *priv = input_get_drvdata(dev);
 
-        mc13xxx_lock(priv->mc13xxx);
-        mc13xxx_reg_rmw(priv->mc13xxx, MC13XXX_ADC0,
-                        MC13XXX_ADC0_TSMOD_MASK, 0);
-        mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TS, priv);
-        mc13xxx_unlock(priv->mc13xxx);
+        mc13783_lock(priv->mc13783);
+        mc13783_reg_rmw(priv->mc13783, MC13783_ADC0,
+                        MC13783_ADC0_TSMOD_MASK, 0);
+        mc13783_irq_free(priv->mc13783, MC13783_IRQ_TS, priv);
+        mc13783_unlock(priv->mc13783);
 
         cancel_delayed_work_sync(&priv->work);
 }
@@ -180,14 +177,8 @@ static int __init mc13783_ts_probe(struct platform_device *pdev)
                 goto err_free_mem;
 
         INIT_DELAYED_WORK(&priv->work, mc13783_ts_work);
-        priv->mc13xxx = dev_get_drvdata(pdev->dev.parent);
+        priv->mc13783 = dev_get_drvdata(pdev->dev.parent);
         priv->idev = idev;
-        priv->touch = dev_get_platdata(&pdev->dev);
-        if (!priv->touch) {
-                dev_err(&pdev->dev, "missing platform data\n");
-                ret = -ENODEV;
-                goto err_free_mem;
-        }
 
         /*
          * We need separate workqueue because mc13783_adc_do_conversion
@@ -229,7 +220,7 @@ err_free_mem:
         return ret;
 }
 
-static int mc13783_ts_remove(struct platform_device *pdev)
+static int __devexit mc13783_ts_remove(struct platform_device *pdev)
 {
         struct mc13783_ts_priv *priv = platform_get_drvdata(pdev);
 
@@ -243,7 +234,7 @@ static int mc13783_ts_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver mc13783_ts_driver = {
-        .remove         = mc13783_ts_remove,
+        .remove         = __devexit_p(mc13783_ts_remove),
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = MC13783_TS_NAME,
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index f9f4e0c56ed..2d84c80ceb6 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -187,7 +187,7 @@ static void mcs5000_ts_phys_init(struct mcs5000_ts_data *data)
                         OP_MODE_ACTIVE | REPORT_RATE_80);
 }
 
-static int mcs5000_ts_probe(struct i2c_client *client,
+static int __devinit mcs5000_ts_probe(struct i2c_client *client,
                 const struct i2c_device_id *id)
 {
         struct mcs5000_ts_data *data;
@@ -249,7 +249,7 @@ err_free_mem:
         return ret;
 }
 
-static int mcs5000_ts_remove(struct i2c_client *client)
+static int __devexit mcs5000_ts_remove(struct i2c_client *client)
 {
         struct mcs5000_ts_data *data = i2c_get_clientdata(client);
 
@@ -292,7 +292,7 @@ MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
 
 static struct i2c_driver mcs5000_ts_driver = {
         .probe          = mcs5000_ts_probe,
-        .remove         = mcs5000_ts_remove,
+        .remove         = __devexit_p(mcs5000_ts_remove),
         .driver = {
                 .name = "mcs5000_ts",
 #ifdef CONFIG_PM
@@ -302,7 +302,18 @@ static struct i2c_driver mcs5000_ts_driver = {
         .id_table       = mcs5000_ts_id,
 };
 
-module_i2c_driver(mcs5000_ts_driver);
+static int __init mcs5000_ts_init(void)
+{
+        return i2c_add_driver(&mcs5000_ts_driver);
+}
+
+static void __exit mcs5000_ts_exit(void)
+{
+        i2c_del_driver(&mcs5000_ts_driver);
+}
+
+module_init(mcs5000_ts_init);
+module_exit(mcs5000_ts_exit);
 
 /* Module information */
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
diff --git a/drivers/input/touchscreen/migor_ts.c b/drivers/input/touchscreen/migor_ts.c
index c038db93e2c..5803bd0c1cc 100644
--- a/drivers/input/touchscreen/migor_ts.c
+++ b/drivers/input/touchscreen/migor_ts.c
@@ -36,6 +36,7 @@
 struct migor_ts_priv {
         struct i2c_client *client;
         struct input_dev *input;
+        struct delayed_work work;
         int irq;
 };
 
@@ -43,24 +44,15 @@ static const u_int8_t migor_ts_ena_seq[17] = { 0x33, 0x22, 0x11,
                                                0x01, 0x06, 0x07, };
 static const u_int8_t migor_ts_dis_seq[17] = { };
 
-static irqreturn_t migor_ts_isr(int irq, void *dev_id)
+static void migor_ts_poscheck(struct work_struct *work)
 {
-        struct migor_ts_priv *priv = dev_id;
+        struct migor_ts_priv *priv = container_of(work,
+                                                  struct migor_ts_priv,
+                                                  work.work);
         unsigned short xpos, ypos;
         unsigned char event;
         u_int8_t buf[16];
 
-        /*
-         * The touch screen controller chip is hooked up to the CPU
-         * using I2C and a single interrupt line. The interrupt line
-         * is pulled low whenever someone taps the screen. To deassert
-         * the interrupt line we need to acknowledge the interrupt by
-         * communicating with the controller over the slow i2c bus.
-         *
-         * Since I2C bus controller may sleep we are using threaded
-         * IRQ here.
-         */
-
         memset(buf, 0, sizeof(buf));
 
         /* Set Index 0 */
@@ -80,25 +72,41 @@ static irqreturn_t migor_ts_isr(int irq, void *dev_id)
         xpos = ((buf[11] & 0x03) << 8 | buf[10]);
         event = buf[12];
 
-        switch (event) {
-        case EVENT_PENDOWN:
-        case EVENT_REPEAT:
+        if (event == EVENT_PENDOWN || event == EVENT_REPEAT) {
                 input_report_key(priv->input, BTN_TOUCH, 1);
                 input_report_abs(priv->input, ABS_X, ypos); /*X-Y swap*/
                 input_report_abs(priv->input, ABS_Y, xpos);
                 input_sync(priv->input);
-                break;
-
-        case EVENT_PENUP:
+        } else if (event == EVENT_PENUP) {
                 input_report_key(priv->input, BTN_TOUCH, 0);
                 input_sync(priv->input);
-                break;
         }
-
  out:
+        enable_irq(priv->irq);
+}
+
+static irqreturn_t migor_ts_isr(int irq, void *dev_id)
+{
+        struct migor_ts_priv *priv = dev_id;
+
+        /* the touch screen controller chip is hooked up to the cpu
+         * using i2c and a single interrupt line. the interrupt line
+         * is pulled low whenever someone taps the screen. to deassert
+         * the interrupt line we need to acknowledge the interrupt by
+         * communicating with the controller over the slow i2c bus.
+         *
+         * we can't acknowledge from interrupt context since the i2c
+         * bus controller may sleep, so we just disable the interrupt
+         * here and handle the acknowledge using delayed work.
+         */
+
+        disable_irq_nosync(irq);
+        schedule_delayed_work(&priv->work, HZ / 20);
+
         return IRQ_HANDLED;
 }
 
+
 static int migor_ts_open(struct input_dev *dev)
 {
         struct migor_ts_priv *priv = input_get_drvdata(dev);
@@ -123,6 +131,15 @@ static void migor_ts_close(struct input_dev *dev)
 
         disable_irq(priv->irq);
 
+        /* cancel pending work and wait for migor_ts_poscheck() to finish */
+        if (cancel_delayed_work_sync(&priv->work)) {
+                /*
+                 * if migor_ts_poscheck was canceled we need to enable IRQ
+                 * here to balance disable done in migor_ts_isr.
+                 */
+                enable_irq(priv->irq);
+        }
+
         /* disable controller */
         i2c_master_send(client, migor_ts_dis_seq, sizeof(migor_ts_dis_seq));
 
@@ -137,20 +154,23 @@ static int migor_ts_probe(struct i2c_client *client,
         int error;
 
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!priv || !input) {
-                dev_err(&client->dev, "failed to allocate memory\n");
+        if (!priv) {
+                dev_err(&client->dev, "failed to allocate driver data\n");
                 error = -ENOMEM;
-                goto err_free_mem;
+                goto err0;
         }
 
-        priv->client = client;
-        priv->input = input;
-        priv->irq = client->irq;
+        dev_set_drvdata(&client->dev, priv);
 
-        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input = input_allocate_device();
+        if (!input) {
+                dev_err(&client->dev, "Failed to allocate input device.\n");
+                error = -ENOMEM;
+                goto err1;
+        }
 
-        __set_bit(BTN_TOUCH, input->keybit);
+        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
         input_set_abs_params(input, ABS_X, 95, 955, 0, 0);
         input_set_abs_params(input, ABS_Y, 85, 935, 0, 0);
@@ -164,34 +184,39 @@ static int migor_ts_probe(struct i2c_client *client,
 
         input_set_drvdata(input, priv);
 
-        error = request_threaded_irq(priv->irq, NULL, migor_ts_isr,
-                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                     client->name, priv);
-        if (error) {
-                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
-                goto err_free_mem;
-        }
+        priv->client = client;
+        priv->input = input;
+        INIT_DELAYED_WORK(&priv->work, migor_ts_poscheck);
+        priv->irq = client->irq;
 
         error = input_register_device(input);
         if (error)
-                goto err_free_irq;
+                goto err1;
 
-        i2c_set_clientdata(client, priv);
-        device_init_wakeup(&client->dev, 1);
+        error = request_irq(priv->irq, migor_ts_isr, IRQF_TRIGGER_LOW,
+                            client->name, priv);
+        if (error) {
+                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
+                goto err2;
+        }
 
+        device_init_wakeup(&client->dev, 1);
         return 0;
 
- err_free_irq:
-        free_irq(priv->irq, priv);
- err_free_mem:
+ err2:
+        input_unregister_device(input);
+        input = NULL; /* so we dont try to free it below */
+ err1:
         input_free_device(input);
         kfree(priv);
+ err0:
+        dev_set_drvdata(&client->dev, NULL);
         return error;
 }
 
 static int migor_ts_remove(struct i2c_client *client)
 {
-        struct migor_ts_priv *priv = i2c_get_clientdata(client);
+        struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         free_irq(priv->irq, priv);
         input_unregister_device(priv->input);
@@ -205,7 +230,7 @@ static int migor_ts_remove(struct i2c_client *client)
 static int migor_ts_suspend(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
-        struct migor_ts_priv *priv = i2c_get_clientdata(client);
+        struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
                 enable_irq_wake(priv->irq);
@@ -216,7 +241,7 @@ static int migor_ts_suspend(struct device *dev)
 static int migor_ts_resume(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
-        struct migor_ts_priv *priv = i2c_get_clientdata(client);
+        struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
                 disable_irq_wake(priv->irq);
@@ -242,8 +267,19 @@ static struct i2c_driver migor_ts_driver = {
         .id_table = migor_ts_id,
 };
 
-module_i2c_driver(migor_ts_driver);
+static int __init migor_ts_init(void)
+{
+        return i2c_add_driver(&migor_ts_driver);
+}
+
+static void __exit migor_ts_exit(void)
+{
+        i2c_del_driver(&migor_ts_driver);
+}
 
 MODULE_DESCRIPTION("MigoR Touchscreen driver");
 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
 MODULE_LICENSE("GPL");
+
+module_init(migor_ts_init);
+module_exit(migor_ts_exit);
diff --git a/drivers/input/touchscreen/mms114.c b/drivers/input/touchscreen/mms114.c
deleted file mode 100644
index 98841d8aa63..00000000000
--- a/drivers/input/touchscreen/mms114.c
+++ /dev/null
@@ -1,602 +0,0 @@
-/*
- * Copyright (C) 2012 Samsung Electronics Co.Ltd
- * Author: Joonyoung Shim <jy0922.shim@samsung.com>
- *
- * 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/module.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/of.h>
-#include <linux/i2c.h>
-#include <linux/i2c/mms114.h>
-#include <linux/input/mt.h>
-#include <linux/interrupt.h>
-#include <linux/regulator/consumer.h>
-#include <linux/slab.h>
-
-/* Write only registers */
-#define MMS114_MODE_CONTROL             0x01
-#define MMS114_OPERATION_MODE_MASK      0xE
-#define MMS114_ACTIVE                   (1 << 1)
-
-#define MMS114_XY_RESOLUTION_H          0x02
-#define MMS114_X_RESOLUTION             0x03
-#define MMS114_Y_RESOLUTION             0x04
-#define MMS114_CONTACT_THRESHOLD        0x05
-#define MMS114_MOVING_THRESHOLD         0x06
-
-/* Read only registers */
-#define MMS114_PACKET_SIZE              0x0F
-#define MMS114_INFOMATION               0x10
-#define MMS114_TSP_REV                  0xF0
-
-/* Minimum delay time is 50us between stop and start signal of i2c */
-#define MMS114_I2C_DELAY                50
-
-/* 200ms needs after power on */
-#define MMS114_POWERON_DELAY            200
-
-/* Touchscreen absolute values */
-#define MMS114_MAX_AREA                 0xff
-
-#define MMS114_MAX_TOUCH                10
-#define MMS114_PACKET_NUM               8
-
-/* Touch type */
-#define MMS114_TYPE_NONE                0
-#define MMS114_TYPE_TOUCHSCREEN         1
-#define MMS114_TYPE_TOUCHKEY            2
-
-struct mms114_data {
-        struct i2c_client       *client;
-        struct input_dev        *input_dev;
-        struct regulator        *core_reg;
-        struct regulator        *io_reg;
-        const struct mms114_platform_data       *pdata;
-
-        /* Use cache data for mode control register(write only) */
-        u8                      cache_mode_control;
-};
-
-struct mms114_touch {
-        u8 id:4, reserved_bit4:1, type:2, pressed:1;
-        u8 x_hi:4, y_hi:4;
-        u8 x_lo;
-        u8 y_lo;
-        u8 width;
-        u8 strength;
-        u8 reserved[2];
-} __packed;
-
-static int __mms114_read_reg(struct mms114_data *data, unsigned int reg,
-                             unsigned int len, u8 *val)
-{
-        struct i2c_client *client = data->client;
-        struct i2c_msg xfer[2];
-        u8 buf = reg & 0xff;
-        int error;
-
-        if (reg <= MMS114_MODE_CONTROL && reg + len > MMS114_MODE_CONTROL)
-                BUG();
-
-        /* Write register: use repeated start */
-        xfer[0].addr = client->addr;
-        xfer[0].flags = I2C_M_TEN | I2C_M_NOSTART;
-        xfer[0].len = 1;
-        xfer[0].buf = &buf;
-
-        /* Read data */
-        xfer[1].addr = client->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = len;
-        xfer[1].buf = val;
-
-        error = i2c_transfer(client->adapter, xfer, 2);
-        if (error != 2) {
-                dev_err(&client->dev,
-                        "%s: i2c transfer failed (%d)\n", __func__, error);
-                return error < 0 ? error : -EIO;
-        }
-        udelay(MMS114_I2C_DELAY);
-
-        return 0;
-}
-
-static int mms114_read_reg(struct mms114_data *data, unsigned int reg)
-{
-        u8 val;
-        int error;
-
-        if (reg == MMS114_MODE_CONTROL)
-                return data->cache_mode_control;
-
-        error = __mms114_read_reg(data, reg, 1, &val);
-        return error < 0 ? error : val;
-}
-
-static int mms114_write_reg(struct mms114_data *data, unsigned int reg,
-                            unsigned int val)
-{
-        struct i2c_client *client = data->client;
-        u8 buf[2];
-        int error;
-
-        buf[0] = reg & 0xff;
-        buf[1] = val & 0xff;
-
-        error = i2c_master_send(client, buf, 2);
-        if (error != 2) {
-                dev_err(&client->dev,
-                        "%s: i2c send failed (%d)\n", __func__, error);
-                return error < 0 ? error : -EIO;
-        }
-        udelay(MMS114_I2C_DELAY);
-
-        if (reg == MMS114_MODE_CONTROL)
-                data->cache_mode_control = val;
-
-        return 0;
-}
-
-static void mms114_process_mt(struct mms114_data *data, struct mms114_touch *touch)
-{
-        const struct mms114_platform_data *pdata = data->pdata;
-        struct i2c_client *client = data->client;
-        struct input_dev *input_dev = data->input_dev;
-        unsigned int id;
-        unsigned int x;
-        unsigned int y;
-
-        if (touch->id > MMS114_MAX_TOUCH) {
-                dev_err(&client->dev, "Wrong touch id (%d)\n", touch->id);
-                return;
-        }
-
-        if (touch->type != MMS114_TYPE_TOUCHSCREEN) {
-                dev_err(&client->dev, "Wrong touch type (%d)\n", touch->type);
-                return;
-        }
-
-        id = touch->id - 1;
-        x = touch->x_lo | touch->x_hi << 8;
-        y = touch->y_lo | touch->y_hi << 8;
-        if (x > pdata->x_size || y > pdata->y_size) {
-                dev_dbg(&client->dev,
-                        "Wrong touch coordinates (%d, %d)\n", x, y);
-                return;
-        }
-
-        if (pdata->x_invert)
-                x = pdata->x_size - x;
-        if (pdata->y_invert)
-                y = pdata->y_size - y;
-
-        dev_dbg(&client->dev,
-                "id: %d, type: %d, pressed: %d, x: %d, y: %d, width: %d, strength: %d\n",
-                id, touch->type, touch->pressed,
-                x, y, touch->width, touch->strength);
-
-        input_mt_slot(input_dev, id);
-        input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, touch->pressed);
-
-        if (touch->pressed) {
-                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, touch->width);
-                input_report_abs(input_dev, ABS_MT_POSITION_X, x);
-                input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
-                input_report_abs(input_dev, ABS_MT_PRESSURE, touch->strength);
-        }
-}
-
-static irqreturn_t mms114_interrupt(int irq, void *dev_id)
-{
-        struct mms114_data *data = dev_id;
-        struct input_dev *input_dev = data->input_dev;
-        struct mms114_touch touch[MMS114_MAX_TOUCH];
-        int packet_size;
-        int touch_size;
-        int index;
-        int error;
-
-        mutex_lock(&input_dev->mutex);
-        if (!input_dev->users) {
-                mutex_unlock(&input_dev->mutex);
-                goto out;
-        }
-        mutex_unlock(&input_dev->mutex);
-
-        packet_size = mms114_read_reg(data, MMS114_PACKET_SIZE);
-        if (packet_size <= 0)
-                goto out;
-
-        touch_size = packet_size / MMS114_PACKET_NUM;
-
-        error = __mms114_read_reg(data, MMS114_INFOMATION, packet_size,
-                        (u8 *)touch);
-        if (error < 0)
-                goto out;
-
-        for (index = 0; index < touch_size; index++)
-                mms114_process_mt(data, touch + index);
-
-        input_mt_report_pointer_emulation(data->input_dev, true);
-        input_sync(data->input_dev);
-
-out:
-        return IRQ_HANDLED;
-}
-
-static int mms114_set_active(struct mms114_data *data, bool active)
-{
-        int val;
-
-        val = mms114_read_reg(data, MMS114_MODE_CONTROL);
-        if (val < 0)
-                return val;
-
-        val &= ~MMS114_OPERATION_MODE_MASK;
-
-        /* If active is false, sleep mode */
-        if (active)
-                val |= MMS114_ACTIVE;
-
-        return mms114_write_reg(data, MMS114_MODE_CONTROL, val);
-}
-
-static int mms114_get_version(struct mms114_data *data)
-{
-        struct device *dev = &data->client->dev;
-        u8 buf[6];
-        int error;
-
-        error = __mms114_read_reg(data, MMS114_TSP_REV, 6, buf);
-        if (error < 0)
-                return error;
-
-        dev_info(dev, "TSP Rev: 0x%x, HW Rev: 0x%x, Firmware Ver: 0x%x\n",
-                 buf[0], buf[1], buf[3]);
-
-        return 0;
-}
-
-static int mms114_setup_regs(struct mms114_data *data)
-{
-        const struct mms114_platform_data *pdata = data->pdata;
-        int val;
-        int error;
-
-        error = mms114_get_version(data);
-        if (error < 0)
-                return error;
-
-        error = mms114_set_active(data, true);
-        if (error < 0)
-                return error;
-
-        val = (pdata->x_size >> 8) & 0xf;
-        val |= ((pdata->y_size >> 8) & 0xf) << 4;
-        error = mms114_write_reg(data, MMS114_XY_RESOLUTION_H, val);
-        if (error < 0)
-                return error;
-
-        val = pdata->x_size & 0xff;
-        error = mms114_write_reg(data, MMS114_X_RESOLUTION, val);
-        if (error < 0)
-                return error;
-
-        val = pdata->y_size & 0xff;
-        error = mms114_write_reg(data, MMS114_Y_RESOLUTION, val);
-        if (error < 0)
-                return error;
-
-        if (pdata->contact_threshold) {
-                error = mms114_write_reg(data, MMS114_CONTACT_THRESHOLD,
-                                pdata->contact_threshold);
-                if (error < 0)
-                        return error;
-        }
-
-        if (pdata->moving_threshold) {
-                error = mms114_write_reg(data, MMS114_MOVING_THRESHOLD,
-                                pdata->moving_threshold);
-                if (error < 0)
-                        return error;
-        }
-
-        return 0;
-}
-
-static int mms114_start(struct mms114_data *data)
-{
-        struct i2c_client *client = data->client;
-        int error;
-
-        if (data->core_reg)
-                regulator_enable(data->core_reg);
-        if (data->io_reg)
-                regulator_enable(data->io_reg);
-        mdelay(MMS114_POWERON_DELAY);
-
-        error = mms114_setup_regs(data);
-        if (error < 0)
-                return error;
-
-        if (data->pdata->cfg_pin)
-                data->pdata->cfg_pin(true);
-
-        enable_irq(client->irq);
-
-        return 0;
-}
-
-static void mms114_stop(struct mms114_data *data)
-{
-        struct i2c_client *client = data->client;
-
-        disable_irq(client->irq);
-
-        if (data->pdata->cfg_pin)
-                data->pdata->cfg_pin(false);
-
-        if (data->io_reg)
-                regulator_disable(data->io_reg);
-        if (data->core_reg)
-                regulator_disable(data->core_reg);
-}
-
-static int mms114_input_open(struct input_dev *dev)
-{
-        struct mms114_data *data = input_get_drvdata(dev);
-
-        return mms114_start(data);
-}
-
-static void mms114_input_close(struct input_dev *dev)
-{
-        struct mms114_data *data = input_get_drvdata(dev);
-
-        mms114_stop(data);
-}
-
-#ifdef CONFIG_OF
-static struct mms114_platform_data *mms114_parse_dt(struct device *dev)
-{
-        struct mms114_platform_data *pdata;
-        struct device_node *np = dev->of_node;
-
-        if (!np)
-                return NULL;
-
-        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata) {
-                dev_err(dev, "failed to allocate platform data\n");
-                return NULL;
-        }
-
-        if (of_property_read_u32(np, "x-size", &pdata->x_size)) {
-                dev_err(dev, "failed to get x-size property\n");
-                return NULL;
-        };
-
-        if (of_property_read_u32(np, "y-size", &pdata->y_size)) {
-                dev_err(dev, "failed to get y-size property\n");
-                return NULL;
-        };
-
-        of_property_read_u32(np, "contact-threshold",
-                                &pdata->contact_threshold);
-        of_property_read_u32(np, "moving-threshold",
-                                &pdata->moving_threshold);
-
-        if (of_find_property(np, "x-invert", NULL))
-                pdata->x_invert = true;
-        if (of_find_property(np, "y-invert", NULL))
-                pdata->y_invert = true;
-
-        return pdata;
-}
-#else
-static inline struct mms114_platform_data *mms114_parse_dt(struct device *dev)
-{
-        return NULL;
-}
-#endif
-
-static int mms114_probe(struct i2c_client *client,
-                                  const struct i2c_device_id *id)
-{
-        const struct mms114_platform_data *pdata;
-        struct mms114_data *data;
-        struct input_dev *input_dev;
-        int error;
-
-        pdata = dev_get_platdata(&client->dev);
-        if (!pdata)
-                pdata = mms114_parse_dt(&client->dev);
-
-        if (!pdata) {
-                dev_err(&client->dev, "Need platform data\n");
-                return -EINVAL;
-        }
-
-        if (!i2c_check_functionality(client->adapter,
-                                I2C_FUNC_PROTOCOL_MANGLING)) {
-                dev_err(&client->dev,
-                        "Need i2c bus that supports protocol mangling\n");
-                return -ENODEV;
-        }
-
-        data = kzalloc(sizeof(struct mms114_data), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!data || !input_dev) {
-                dev_err(&client->dev, "Failed to allocate memory\n");
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        data->client = client;
-        data->input_dev = input_dev;
-        data->pdata = pdata;
-
-        input_dev->name = "MELPAS MMS114 Touchscreen";
-        input_dev->id.bustype = BUS_I2C;
-        input_dev->dev.parent = &client->dev;
-        input_dev->open = mms114_input_open;
-        input_dev->close = mms114_input_close;
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-        input_set_abs_params(input_dev, ABS_X, 0, data->pdata->x_size, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, data->pdata->y_size, 0, 0);
-
-        /* For multi touch */
-        input_mt_init_slots(input_dev, MMS114_MAX_TOUCH, 0);
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
-                             0, MMS114_MAX_AREA, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
-                             0, data->pdata->x_size, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
-                             0, data->pdata->y_size, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
-
-        input_set_drvdata(input_dev, data);
-        i2c_set_clientdata(client, data);
-
-        data->core_reg = regulator_get(&client->dev, "avdd");
-        if (IS_ERR(data->core_reg)) {
-                error = PTR_ERR(data->core_reg);
-                dev_err(&client->dev,
-                        "Unable to get the Core regulator (%d)\n", error);
-                goto err_free_mem;
-        }
-
-        data->io_reg = regulator_get(&client->dev, "vdd");
-        if (IS_ERR(data->io_reg)) {
-                error = PTR_ERR(data->io_reg);
-                dev_err(&client->dev,
-                        "Unable to get the IO regulator (%d)\n", error);
-                goto err_core_reg;
-        }
-
-        error = request_threaded_irq(client->irq, NULL, mms114_interrupt,
-                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "mms114", data);
-        if (error) {
-                dev_err(&client->dev, "Failed to register interrupt\n");
-                goto err_io_reg;
-        }
-        disable_irq(client->irq);
-
-        error = input_register_device(data->input_dev);
-        if (error)
-                goto err_free_irq;
-
-        return 0;
-
-err_free_irq:
-        free_irq(client->irq, data);
-err_io_reg:
-        regulator_put(data->io_reg);
-err_core_reg:
-        regulator_put(data->core_reg);
-err_free_mem:
-        input_free_device(input_dev);
-        kfree(data);
-        return error;
-}
-
-static int mms114_remove(struct i2c_client *client)
-{
-        struct mms114_data *data = i2c_get_clientdata(client);
-
-        free_irq(client->irq, data);
-        regulator_put(data->io_reg);
-        regulator_put(data->core_reg);
-        input_unregister_device(data->input_dev);
-        kfree(data);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int mms114_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct mms114_data *data = i2c_get_clientdata(client);
-        struct input_dev *input_dev = data->input_dev;
-        int id;
-
-        /* Release all touch */
-        for (id = 0; id < MMS114_MAX_TOUCH; id++) {
-                input_mt_slot(input_dev, id);
-                input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, false);
-        }
-
-        input_mt_report_pointer_emulation(input_dev, true);
-        input_sync(input_dev);
-
-        mutex_lock(&input_dev->mutex);
-        if (input_dev->users)
-                mms114_stop(data);
-        mutex_unlock(&input_dev->mutex);
-
-        return 0;
-}
-
-static int mms114_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct mms114_data *data = i2c_get_clientdata(client);
-        struct input_dev *input_dev = data->input_dev;
-        int error;
-
-        mutex_lock(&input_dev->mutex);
-        if (input_dev->users) {
-                error = mms114_start(data);
-                if (error < 0) {
-                        mutex_unlock(&input_dev->mutex);
-                        return error;
-                }
-        }
-        mutex_unlock(&input_dev->mutex);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(mms114_pm_ops, mms114_suspend, mms114_resume);
-
-static const struct i2c_device_id mms114_id[] = {
-        { "mms114", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, mms114_id);
-
-#ifdef CONFIG_OF
-static struct of_device_id mms114_dt_match[] = {
-        { .compatible = "melfas,mms114" },
-        { }
-};
-#endif
-
-static struct i2c_driver mms114_driver = {
-        .driver = {
-                .name   = "mms114",
-                .owner  = THIS_MODULE,
-                .pm     = &mms114_pm_ops,
-                .of_match_table = of_match_ptr(mms114_dt_match),
-        },
-        .probe          = mms114_probe,
-        .remove         = mms114_remove,
-        .id_table       = mms114_id,
-};
-
-module_i2c_driver(mms114_driver);
-
-/* Module information */
-MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
-MODULE_DESCRIPTION("MELFAS mms114 Touchscreen driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/mtouch.c b/drivers/input/touchscreen/mtouch.c
index eb66b7c37c2..9077228418b 100644
--- a/drivers/input/touchscreen/mtouch.c
+++ b/drivers/input/touchscreen/mtouch.c
@@ -202,4 +202,19 @@ static struct serio_driver mtouch_drv = {
         .disconnect     = mtouch_disconnect,
 };
 
-module_serio_driver(mtouch_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init mtouch_init(void)
+{
+        return serio_register_driver(&mtouch_drv);
+}
+
+static void __exit mtouch_exit(void)
+{
+        serio_unregister_driver(&mtouch_drv);
+}
+
+module_init(mtouch_init);
+module_exit(mtouch_exit);
diff --git a/drivers/input/touchscreen/pcap_ts.c b/drivers/input/touchscreen/pcap_ts.c
index f22e04dd4e1..ea6ef16e59b 100644
--- a/drivers/input/touchscreen/pcap_ts.c
+++ b/drivers/input/touchscreen/pcap_ts.c
@@ -137,7 +137,7 @@ static void pcap_ts_close(struct input_dev *dev)
                                 pcap_ts->read_state << PCAP_ADC_TS_M_SHIFT);
 }
 
-static int pcap_ts_probe(struct platform_device *pdev)
+static int __devinit pcap_ts_probe(struct platform_device *pdev)
 {
         struct input_dev *input_dev;
         struct pcap_ts *pcap_ts;
@@ -202,7 +202,7 @@ fail:
         return err;
 }
 
-static int pcap_ts_remove(struct platform_device *pdev)
+static int __devexit pcap_ts_remove(struct platform_device *pdev)
 {
         struct pcap_ts *pcap_ts = platform_get_drvdata(pdev);
 
@@ -245,14 +245,26 @@ static const struct dev_pm_ops pcap_ts_pm_ops = {
 
 static struct platform_driver pcap_ts_driver = {
         .probe          = pcap_ts_probe,
-        .remove         = pcap_ts_remove,
+        .remove         = __devexit_p(pcap_ts_remove),
         .driver         = {
                 .name   = "pcap-ts",
                 .owner  = THIS_MODULE,
                 .pm     = PCAP_TS_PM_OPS,
         },
 };
-module_platform_driver(pcap_ts_driver);
+
+static int __init pcap_ts_init(void)
+{
+        return platform_driver_register(&pcap_ts_driver);
+}
+
+static void __exit pcap_ts_exit(void)
+{
+        platform_driver_unregister(&pcap_ts_driver);
+}
+
+module_init(pcap_ts_init);
+module_exit(pcap_ts_exit);
 
 MODULE_DESCRIPTION("Motorola PCAP2 touchscreen driver");
 MODULE_AUTHOR("Daniel Ribeiro / Harald Welte");
diff --git a/drivers/input/touchscreen/penmount.c b/drivers/input/touchscreen/penmount.c
index b49f0b83692..c7f9cebebbb 100644
--- a/drivers/input/touchscreen/penmount.c
+++ b/drivers/input/touchscreen/penmount.c
@@ -2,7 +2,6 @@
  * Penmount serial touchscreen driver
  *
  * Copyright (c) 2006 Rick Koch <n1gp@hotmail.com>
- * Copyright (c) 2011 John Sung <penmount.touch@gmail.com>
  *
  * Based on ELO driver (drivers/input/touchscreen/elo.c)
  * Copyright (c) 2004 Vojtech Pavlik
@@ -19,14 +18,12 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/input.h>
-#include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/init.h>
 
-#define DRIVER_DESC     "PenMount serial touchscreen driver"
+#define DRIVER_DESC     "Penmount serial touchscreen driver"
 
 MODULE_AUTHOR("Rick Koch <n1gp@hotmail.com>");
-MODULE_AUTHOR("John Sung <penmount.touch@gmail.com>");
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
@@ -34,19 +31,7 @@ MODULE_LICENSE("GPL");
  * Definitions & global arrays.
  */
 
-#define PM_MAX_LENGTH   6
-#define PM_MAX_MTSLOT   16
-#define PM_3000_MTSLOT  2
-#define PM_6250_MTSLOT  12
-
-/*
- * Multi-touch slot
- */
-
-struct mt_slot {
-        unsigned short x, y;
-        bool active; /* is the touch valid? */
-};
+#define PM_MAX_LENGTH   5
 
 /*
  * Per-touchscreen data.
@@ -58,119 +43,25 @@ struct pm {
         int idx;
         unsigned char data[PM_MAX_LENGTH];
         char phys[32];
-        unsigned char packetsize;
-        unsigned char maxcontacts;
-        struct mt_slot slots[PM_MAX_MTSLOT];
-        void (*parse_packet)(struct pm *);
 };
 
-/*
- * pm_mtevent() sends mt events and also emulates pointer movement
- */
-
-static void pm_mtevent(struct pm *pm, struct input_dev *input)
-{
-        int i;
-
-        for (i = 0; i < pm->maxcontacts; ++i) {
-                input_mt_slot(input, i);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER,
-                                pm->slots[i].active);
-                if (pm->slots[i].active) {
-                        input_event(input, EV_ABS, ABS_MT_POSITION_X, pm->slots[i].x);
-                        input_event(input, EV_ABS, ABS_MT_POSITION_Y, pm->slots[i].y);
-                }
-        }
-
-        input_mt_report_pointer_emulation(input, true);
-        input_sync(input);
-}
-
-/*
- * pm_checkpacket() checks if data packet is valid
- */
-
-static bool pm_checkpacket(unsigned char *packet)
-{
-        int total = 0;
-        int i;
-
-        for (i = 0; i < 5; i++)
-                total += packet[i];
-
-        return packet[5] == (unsigned char)~(total & 0xff);
-}
-
-static void pm_parse_9000(struct pm *pm)
-{
-        struct input_dev *dev = pm->dev;
-
-        if ((pm->data[0] & 0x80) && pm->packetsize == ++pm->idx) {
-                input_report_abs(dev, ABS_X, pm->data[1] * 128 + pm->data[2]);
-                input_report_abs(dev, ABS_Y, pm->data[3] * 128 + pm->data[4]);
-                input_report_key(dev, BTN_TOUCH, !!(pm->data[0] & 0x40));
-                input_sync(dev);
-                pm->idx = 0;
-        }
-}
-
-static void pm_parse_6000(struct pm *pm)
-{
-        struct input_dev *dev = pm->dev;
-
-        if ((pm->data[0] & 0xbf) == 0x30 && pm->packetsize == ++pm->idx) {
-                if (pm_checkpacket(pm->data)) {
-                        input_report_abs(dev, ABS_X,
-                                        pm->data[2] * 256 + pm->data[1]);
-                        input_report_abs(dev, ABS_Y,
-                                        pm->data[4] * 256 + pm->data[3]);
-                        input_report_key(dev, BTN_TOUCH, pm->data[0] & 0x40);
-                        input_sync(dev);
-                }
-                pm->idx = 0;
-        }
-}
-
-static void pm_parse_3000(struct pm *pm)
-{
-        struct input_dev *dev = pm->dev;
-
-        if ((pm->data[0] & 0xce) == 0x40 && pm->packetsize == ++pm->idx) {
-                if (pm_checkpacket(pm->data)) {
-                        int slotnum = pm->data[0] & 0x0f;
-                        pm->slots[slotnum].active = pm->data[0] & 0x30;
-                        pm->slots[slotnum].x = pm->data[2] * 256 + pm->data[1];
-                        pm->slots[slotnum].y = pm->data[4] * 256 + pm->data[3];
-                        pm_mtevent(pm, dev);
-                }
-                pm->idx = 0;
-        }
-}
-
-static void pm_parse_6250(struct pm *pm)
-{
-        struct input_dev *dev = pm->dev;
-
-        if ((pm->data[0] & 0xb0) == 0x30 && pm->packetsize == ++pm->idx) {
-                if (pm_checkpacket(pm->data)) {
-                        int slotnum = pm->data[0] & 0x0f;
-                        pm->slots[slotnum].active = pm->data[0] & 0x40;
-                        pm->slots[slotnum].x = pm->data[2] * 256 + pm->data[1];
-                        pm->slots[slotnum].y = pm->data[4] * 256 + pm->data[3];
-                        pm_mtevent(pm, dev);
-                }
-                pm->idx = 0;
-        }
-}
-
 static irqreturn_t pm_interrupt(struct serio *serio,
                 unsigned char data, unsigned int flags)
 {
         struct pm *pm = serio_get_drvdata(serio);
+        struct input_dev *dev = pm->dev;
 
         pm->data[pm->idx] = data;
 
-        pm->parse_packet(pm);
+        if (pm->data[0] & 0x80) {
+                if (PM_MAX_LENGTH == ++pm->idx) {
+                        input_report_abs(dev, ABS_X, pm->data[2] * 128 + pm->data[1]);
+                        input_report_abs(dev, ABS_Y, pm->data[4] * 128 + pm->data[3]);
+                        input_report_key(dev, BTN_TOUCH, !!(pm->data[0] & 0x40));
+                        input_sync(dev);
+                        pm->idx = 0;
+                }
+        }
 
         return IRQ_HANDLED;
 }
@@ -183,17 +74,17 @@ static void pm_disconnect(struct serio *serio)
 {
         struct pm *pm = serio_get_drvdata(serio);
 
-        serio_close(serio);
-
+        input_get_device(pm->dev);
         input_unregister_device(pm->dev);
-        kfree(pm);
-
+        serio_close(serio);
         serio_set_drvdata(serio, NULL);
+        input_put_device(pm->dev);
+        kfree(pm);
 }
 
 /*
  * pm_connect() is the routine that is called when someone adds a
- * new serio device that supports PenMount protocol and registers it as
+ * new serio device that supports Gunze protocol and registers it as
  * an input device.
  */
 
@@ -201,7 +92,6 @@ static int pm_connect(struct serio *serio, struct serio_driver *drv)
 {
         struct pm *pm;
         struct input_dev *input_dev;
-        int max_x, max_y;
         int err;
 
         pm = kzalloc(sizeof(struct pm), GFP_KERNEL);
@@ -214,9 +104,8 @@ static int pm_connect(struct serio *serio, struct serio_driver *drv)
         pm->serio = serio;
         pm->dev = input_dev;
         snprintf(pm->phys, sizeof(pm->phys), "%s/input0", serio->phys);
-        pm->maxcontacts = 1;
 
-        input_dev->name = "PenMount Serial TouchScreen";
+        input_dev->name = "Penmount Serial TouchScreen";
         input_dev->phys = pm->phys;
         input_dev->id.bustype = BUS_RS232;
         input_dev->id.vendor = SERIO_PENMOUNT;
@@ -224,52 +113,10 @@ static int pm_connect(struct serio *serio, struct serio_driver *drv)
         input_dev->id.version = 0x0100;
         input_dev->dev.parent = &serio->dev;
 
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
-
-        switch (serio->id.id) {
-        default:
-        case 0:
-                pm->packetsize = 5;
-                pm->parse_packet = pm_parse_9000;
-                input_dev->id.product = 0x9000;
-                max_x = max_y = 0x3ff;
-                break;
-
-        case 1:
-                pm->packetsize = 6;
-                pm->parse_packet = pm_parse_6000;
-                input_dev->id.product = 0x6000;
-                max_x = max_y = 0x3ff;
-                break;
-
-        case 2:
-                pm->packetsize = 6;
-                pm->parse_packet = pm_parse_3000;
-                input_dev->id.product = 0x3000;
-                max_x = max_y = 0x7ff;
-                pm->maxcontacts = PM_3000_MTSLOT;
-                break;
-
-        case 3:
-                pm->packetsize = 6;
-                pm->parse_packet = pm_parse_6250;
-                input_dev->id.product = 0x6250;
-                max_x = max_y = 0x3ff;
-                pm->maxcontacts = PM_6250_MTSLOT;
-                break;
-        }
-
-        input_set_abs_params(pm->dev, ABS_X, 0, max_x, 0, 0);
-        input_set_abs_params(pm->dev, ABS_Y, 0, max_y, 0, 0);
-
-        if (pm->maxcontacts > 1) {
-                input_mt_init_slots(pm->dev, pm->maxcontacts, 0);
-                input_set_abs_params(pm->dev,
-                                     ABS_MT_POSITION_X, 0, max_x, 0, 0);
-                input_set_abs_params(pm->dev,
-                                     ABS_MT_POSITION_Y, 0, max_y, 0, 0);
-        }
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(pm->dev, ABS_X, 0, 0x3ff, 0, 0);
+        input_set_abs_params(pm->dev, ABS_Y, 0, 0x3ff, 0, 0);
 
         serio_set_drvdata(serio, pm);
 
@@ -308,7 +155,7 @@ MODULE_DEVICE_TABLE(serio, pm_serio_ids);
 
 static struct serio_driver pm_drv = {
         .driver         = {
-                .name   = "serio-penmount",
+                .name   = "penmountlpc",
         },
         .description    = DRIVER_DESC,
         .id_table       = pm_serio_ids,
@@ -317,4 +164,19 @@ static struct serio_driver pm_drv = {
         .disconnect     = pm_disconnect,
 };
 
-module_serio_driver(pm_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init pm_init(void)
+{
+        return serio_register_driver(&pm_drv);
+}
+
+static void __exit pm_exit(void)
+{
+        serio_unregister_driver(&pm_drv);
+}
+
+module_init(pm_init);
+module_exit(pm_exit);
diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c
deleted file mode 100644
index 6cc6b36663f..00000000000
--- a/drivers/input/touchscreen/pixcir_i2c_ts.c
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Driver for Pixcir I2C touchscreen controllers.
- *
- * Copyright (C) 2010-2011 Pixcir, 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.
- *
- * 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>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/input/pixcir_ts.h>
-
-struct pixcir_i2c_ts_data {
-        struct i2c_client *client;
-        struct input_dev *input;
-        const struct pixcir_ts_platform_data *chip;
-        bool exiting;
-};
-
-static void pixcir_ts_poscheck(struct pixcir_i2c_ts_data *data)
-{
-        struct pixcir_i2c_ts_data *tsdata = data;
-        u8 rdbuf[10], wrbuf[1] = { 0 };
-        u8 touch;
-        int ret;
-
-        ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf));
-        if (ret != sizeof(wrbuf)) {
-                dev_err(&tsdata->client->dev,
-                        "%s: i2c_master_send failed(), ret=%d\n",
-                        __func__, ret);
-                return;
-        }
-
-        ret = i2c_master_recv(tsdata->client, rdbuf, sizeof(rdbuf));
-        if (ret != sizeof(rdbuf)) {
-                dev_err(&tsdata->client->dev,
-                        "%s: i2c_master_recv failed(), ret=%d\n",
-                        __func__, ret);
-                return;
-        }
-
-        touch = rdbuf[0];
-        if (touch) {
-                u16 posx1 = (rdbuf[3] << 8) | rdbuf[2];
-                u16 posy1 = (rdbuf[5] << 8) | rdbuf[4];
-                u16 posx2 = (rdbuf[7] << 8) | rdbuf[6];
-                u16 posy2 = (rdbuf[9] << 8) | rdbuf[8];
-
-                input_report_key(tsdata->input, BTN_TOUCH, 1);
-                input_report_abs(tsdata->input, ABS_X, posx1);
-                input_report_abs(tsdata->input, ABS_Y, posy1);
-
-                input_report_abs(tsdata->input, ABS_MT_POSITION_X, posx1);
-                input_report_abs(tsdata->input, ABS_MT_POSITION_Y, posy1);
-                input_mt_sync(tsdata->input);
-
-                if (touch == 2) {
-                        input_report_abs(tsdata->input,
-                                         ABS_MT_POSITION_X, posx2);
-                        input_report_abs(tsdata->input,
-                                         ABS_MT_POSITION_Y, posy2);
-                        input_mt_sync(tsdata->input);
-                }
-        } else {
-                input_report_key(tsdata->input, BTN_TOUCH, 0);
-        }
-
-        input_sync(tsdata->input);
-}
-
-static irqreturn_t pixcir_ts_isr(int irq, void *dev_id)
-{
-        struct pixcir_i2c_ts_data *tsdata = dev_id;
-
-        while (!tsdata->exiting) {
-                pixcir_ts_poscheck(tsdata);
-
-                if (tsdata->chip->attb_read_val())
-                        break;
-
-                msleep(20);
-        }
-
-        return IRQ_HANDLED;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int pixcir_i2c_ts_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(&client->dev))
-                enable_irq_wake(client->irq);
-
-        return 0;
-}
-
-static int pixcir_i2c_ts_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        if (device_may_wakeup(&client->dev))
-                disable_irq_wake(client->irq);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops,
-                         pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume);
-
-static int pixcir_i2c_ts_probe(struct i2c_client *client,
-                                         const struct i2c_device_id *id)
-{
-        const struct pixcir_ts_platform_data *pdata = client->dev.platform_data;
-        struct pixcir_i2c_ts_data *tsdata;
-        struct input_dev *input;
-        int error;
-
-        if (!pdata) {
-                dev_err(&client->dev, "platform data not defined\n");
-                return -EINVAL;
-        }
-
-        tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!tsdata || !input) {
-                dev_err(&client->dev, "Failed to allocate driver data!\n");
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        tsdata->client = client;
-        tsdata->input = input;
-        tsdata->chip = pdata;
-
-        input->name = client->name;
-        input->id.bustype = BUS_I2C;
-        input->dev.parent = &client->dev;
-
-        __set_bit(EV_KEY, input->evbit);
-        __set_bit(EV_ABS, input->evbit);
-        __set_bit(BTN_TOUCH, input->keybit);
-        input_set_abs_params(input, ABS_X, 0, pdata->x_max, 0, 0);
-        input_set_abs_params(input, ABS_Y, 0, pdata->y_max, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0);
-
-        input_set_drvdata(input, tsdata);
-
-        error = request_threaded_irq(client->irq, NULL, pixcir_ts_isr,
-                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
-                                     client->name, tsdata);
-        if (error) {
-                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
-                goto err_free_mem;
-        }
-
-        error = input_register_device(input);
-        if (error)
-                goto err_free_irq;
-
-        i2c_set_clientdata(client, tsdata);
-        device_init_wakeup(&client->dev, 1);
-
-        return 0;
-
-err_free_irq:
-        free_irq(client->irq, tsdata);
-err_free_mem:
-        input_free_device(input);
-        kfree(tsdata);
-        return error;
-}
-
-static int pixcir_i2c_ts_remove(struct i2c_client *client)
-{
-        struct pixcir_i2c_ts_data *tsdata = i2c_get_clientdata(client);
-
-        device_init_wakeup(&client->dev, 0);
-
-        tsdata->exiting = true;
-        mb();
-        free_irq(client->irq, tsdata);
-
-        input_unregister_device(tsdata->input);
-        kfree(tsdata);
-
-        return 0;
-}
-
-static const struct i2c_device_id pixcir_i2c_ts_id[] = {
-        { "pixcir_ts", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id);
-
-static struct i2c_driver pixcir_i2c_ts_driver = {
-        .driver = {
-                .owner  = THIS_MODULE,
-                .name   = "pixcir_ts",
-                .pm     = &pixcir_dev_pm_ops,
-        },
-        .probe          = pixcir_i2c_ts_probe,
-        .remove         = pixcir_i2c_ts_remove,
-        .id_table       = pixcir_i2c_ts_id,
-};
-
-module_i2c_driver(pixcir_i2c_ts_driver);
-
-MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>");
-MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c
index b061af2c837..8feb7f3c8be 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -37,7 +37,7 @@
 
 #include <plat/adc.h>
 #include <plat/regs-adc.h>
-#include <linux/platform_data/touchscreen-s3c2410.h>
+#include <plat/ts.h>
 
 #define TSC_SLEEP  (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))
 
@@ -238,7 +238,7 @@ static void s3c24xx_ts_select(struct s3c_adc_client *client, unsigned select)
  * Initialise, find and allocate any resources we need to run and then
  * register with the ADC and input systems.
  */
-static int s3c2410ts_probe(struct platform_device *pdev)
+static int __devinit s3c2410ts_probe(struct platform_device *pdev)
 {
         struct s3c2410_ts_mach_info *info;
         struct device *dev = &pdev->dev;
@@ -328,7 +328,7 @@ static int s3c2410ts_probe(struct platform_device *pdev)
         ts.shift = info->oversampling_shift;
         ts.features = platform_get_device_id(pdev)->driver_data;
 
-        ret = request_irq(ts.irq_tc, stylus_irq, 0,
+        ret = request_irq(ts.irq_tc, stylus_irq, IRQF_DISABLED,
                           "s3c2410_ts_pen", ts.input);
         if (ret) {
                 dev_err(dev, "cannot get TC interrupt\n");
@@ -365,7 +365,7 @@ static int s3c2410ts_probe(struct platform_device *pdev)
  *
  * Free up our state ready to be removed.
  */
-static int s3c2410ts_remove(struct platform_device *pdev)
+static int __devexit s3c2410ts_remove(struct platform_device *pdev)
 {
         free_irq(ts.irq_tc, ts.input);
         del_timer_sync(&touch_timer);
@@ -406,7 +406,7 @@ static int s3c2410ts_resume(struct device *dev)
         return 0;
 }
 
-static const struct dev_pm_ops s3c_ts_pmops = {
+static struct dev_pm_ops s3c_ts_pmops = {
         .suspend        = s3c2410ts_suspend,
         .resume         = s3c2410ts_resume,
 };
@@ -430,9 +430,21 @@ static struct platform_driver s3c_ts_driver = {
         },
         .id_table       = s3cts_driver_ids,
         .probe          = s3c2410ts_probe,
-        .remove         = s3c2410ts_remove,
+        .remove         = __devexit_p(s3c2410ts_remove),
 };
-module_platform_driver(s3c_ts_driver);
+
+static int __init s3c2410ts_init(void)
+{
+        return platform_driver_register(&s3c_ts_driver);
+}
+
+static void __exit s3c2410ts_exit(void)
+{
+        platform_driver_unregister(&s3c_ts_driver);
+}
+
+module_init(s3c2410ts_init);
+module_exit(s3c2410ts_exit);
 
 MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>, "
               "Ben Dooks <ben@simtec.co.uk>, "
diff --git a/drivers/input/touchscreen/st1232.c b/drivers/input/touchscreen/st1232.c
index d9d05e22242..4ab371358b3 100644
--- a/drivers/input/touchscreen/st1232.c
+++ b/drivers/input/touchscreen/st1232.c
@@ -23,7 +23,6 @@
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
-#include <linux/pm_qos.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 
@@ -47,7 +46,6 @@ struct st1232_ts_data {
         struct i2c_client *client;
         struct input_dev *input_dev;
         struct st1232_ts_finger finger[MAX_FINGERS];
-        struct dev_pm_qos_request low_latency_req;
 };
 
 static int st1232_ts_read_data(struct st1232_ts_data *ts)
@@ -120,17 +118,8 @@ static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
         }
 
         /* SYN_MT_REPORT only if no contact */
-        if (!count) {
+        if (!count)
                 input_mt_sync(input_dev);
-                if (ts->low_latency_req.dev) {
-                        dev_pm_qos_remove_request(&ts->low_latency_req);
-                        ts->low_latency_req.dev = NULL;
-                }
-        } else if (!ts->low_latency_req.dev) {
-                /* First contact, request 100 us latency. */
-                dev_pm_qos_add_ancestor_request(&ts->client->dev,
-                                                &ts->low_latency_req, 100);
-        }
 
         /* SYN_REPORT */
         input_sync(input_dev);
@@ -139,7 +128,7 @@ end:
         return IRQ_HANDLED;
 }
 
-static int st1232_ts_probe(struct i2c_client *client,
+static int __devinit st1232_ts_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
         struct st1232_ts_data *ts;
@@ -206,7 +195,7 @@ err_free_mem:
         return error;
 }
 
-static int st1232_ts_remove(struct i2c_client *client)
+static int __devexit st1232_ts_remove(struct i2c_client *client)
 {
         struct st1232_ts_data *ts = i2c_get_clientdata(client);
 
@@ -218,7 +207,7 @@ static int st1232_ts_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
 static int st1232_ts_suspend(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -243,38 +232,42 @@ static int st1232_ts_resume(struct device *dev)
         return 0;
 }
 
+static const struct dev_pm_ops st1232_ts_pm_ops = {
+        .suspend        = st1232_ts_suspend,
+        .resume         = st1232_ts_resume,
+};
 #endif
 
-static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops,
-                         st1232_ts_suspend, st1232_ts_resume);
-
 static const struct i2c_device_id st1232_ts_id[] = {
         { ST1232_TS_NAME, 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
 
-#ifdef CONFIG_OF
-static const struct of_device_id st1232_ts_dt_ids[] = {
-        { .compatible = "sitronix,st1232", },
-        { }
-};
-MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
-#endif
-
 static struct i2c_driver st1232_ts_driver = {
         .probe          = st1232_ts_probe,
-        .remove         = st1232_ts_remove,
+        .remove         = __devexit_p(st1232_ts_remove),
         .id_table       = st1232_ts_id,
         .driver = {
                 .name   = ST1232_TS_NAME,
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(st1232_ts_dt_ids),
+#ifdef CONFIG_PM
                 .pm     = &st1232_ts_pm_ops,
+#endif
         },
 };
 
-module_i2c_driver(st1232_ts_driver);
+static int __init st1232_ts_init(void)
+{
+        return i2c_add_driver(&st1232_ts_driver);
+}
+module_init(st1232_ts_init);
+
+static void __exit st1232_ts_exit(void)
+{
+        i2c_del_driver(&st1232_ts_driver);
+}
+module_exit(st1232_ts_exit);
 
 MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
 MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
diff --git a/drivers/input/touchscreen/stmpe-ts.c b/drivers/input/touchscreen/stmpe-ts.c
index 84d884b4ec3..ae88e13c99f 100644
--- a/drivers/input/touchscreen/stmpe-ts.c
+++ b/drivers/input/touchscreen/stmpe-ts.c
@@ -1,5 +1,4 @@
-/*
- * STMicroelectronics STMPE811 Touchscreen Driver
+/* STMicroelectronics STMPE811 Touchscreen Driver
  *
  * (C) 2010 Luotao Fu <l.fu@pengutronix.de>
  * All rights reserved.
@@ -17,7 +16,6 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/device.h>
-#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/slab.h>
@@ -168,7 +166,7 @@ static irqreturn_t stmpe_ts_handler(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static int stmpe_init_hw(struct stmpe_touch *ts)
+static int __devinit stmpe_init_hw(struct stmpe_touch *ts)
 {
         int ret;
         u8 adc_ctrl1, adc_ctrl1_mask, tsc_cfg, tsc_cfg_mask;
@@ -263,18 +261,41 @@ static void stmpe_ts_close(struct input_dev *dev)
                         STMPE_TSC_CTRL_TSC_EN, 0);
 }
 
-static void stmpe_ts_get_platform_info(struct platform_device *pdev,
-                                        struct stmpe_touch *ts)
+static int __devinit stmpe_input_probe(struct platform_device *pdev)
 {
         struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
-        struct device_node *np = pdev->dev.of_node;
+        struct stmpe_platform_data *pdata = stmpe->pdata;
+        struct stmpe_touch *ts;
+        struct input_dev *idev;
         struct stmpe_ts_platform_data *ts_pdata = NULL;
+        int ret;
+        int ts_irq;
+
+        ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
+        if (ts_irq < 0)
+                return ts_irq;
+
+        ts = kzalloc(sizeof(*ts), GFP_KERNEL);
+        if (!ts) {
+                ret = -ENOMEM;
+                goto err_out;
+        }
+
+        idev = input_allocate_device();
+        if (!idev) {
+                ret = -ENOMEM;
+                goto err_free_ts;
+        }
 
+        platform_set_drvdata(pdev, ts);
         ts->stmpe = stmpe;
+        ts->idev = idev;
+        ts->dev = &pdev->dev;
 
-        if (stmpe->pdata && stmpe->pdata->ts) {
-                ts_pdata = stmpe->pdata->ts;
+        if (pdata)
+                ts_pdata = pdata->ts;
 
+        if (ts_pdata) {
                 ts->sample_time = ts_pdata->sample_time;
                 ts->mod_12b = ts_pdata->mod_12b;
                 ts->ref_sel = ts_pdata->ref_sel;
@@ -284,71 +305,22 @@ static void stmpe_ts_get_platform_info(struct platform_device *pdev,
                 ts->settling = ts_pdata->settling;
                 ts->fraction_z = ts_pdata->fraction_z;
                 ts->i_drive = ts_pdata->i_drive;
-        } else if (np) {
-                u32 val;
-
-                if (!of_property_read_u32(np, "st,sample-time", &val))
-                        ts->sample_time = val;
-                if (!of_property_read_u32(np, "st,mod-12b", &val))
-                        ts->mod_12b = val;
-                if (!of_property_read_u32(np, "st,ref-sel", &val))
-                        ts->ref_sel = val;
-                if (!of_property_read_u32(np, "st,adc-freq", &val))
-                        ts->adc_freq = val;
-                if (!of_property_read_u32(np, "st,ave-ctrl", &val))
-                        ts->ave_ctrl = val;
-                if (!of_property_read_u32(np, "st,touch-det-delay", &val))
-                        ts->touch_det_delay = val;
-                if (!of_property_read_u32(np, "st,settling", &val))
-                        ts->settling = val;
-                if (!of_property_read_u32(np, "st,fraction-z", &val))
-                        ts->fraction_z = val;
-                if (!of_property_read_u32(np, "st,i-drive", &val))
-                        ts->i_drive = val;
         }
-}
-
-static int stmpe_input_probe(struct platform_device *pdev)
-{
-        struct stmpe_touch *ts;
-        struct input_dev *idev;
-        int error;
-        int ts_irq;
-
-        ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
-        if (ts_irq < 0)
-                return ts_irq;
-
-        ts = devm_kzalloc(&pdev->dev, sizeof(*ts), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-
-        idev = devm_input_allocate_device(&pdev->dev);
-        if (!idev)
-                return -ENOMEM;
-
-        platform_set_drvdata(pdev, ts);
-        ts->idev = idev;
-        ts->dev = &pdev->dev;
-
-        stmpe_ts_get_platform_info(pdev, ts);
 
         INIT_DELAYED_WORK(&ts->work, stmpe_work);
 
-        error = devm_request_threaded_irq(&pdev->dev, ts_irq,
-                                          NULL, stmpe_ts_handler,
-                                          IRQF_ONESHOT, STMPE_TS_NAME, ts);
-        if (error) {
+        ret = request_threaded_irq(ts_irq, NULL, stmpe_ts_handler,
+                        IRQF_ONESHOT, STMPE_TS_NAME, ts);
+        if (ret) {
                 dev_err(&pdev->dev, "Failed to request IRQ %d\n", ts_irq);
-                return error;
+                goto err_free_input;
         }
 
-        error = stmpe_init_hw(ts);
-        if (error)
-                return error;
+        ret = stmpe_init_hw(ts);
+        if (ret)
+                goto err_free_irq;
 
         idev->name = STMPE_TS_NAME;
-        idev->phys = STMPE_TS_NAME"/input0";
         idev->id.bustype = BUS_I2C;
         idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
         idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
@@ -362,21 +334,40 @@ static int stmpe_input_probe(struct platform_device *pdev)
         input_set_abs_params(idev, ABS_Y, 0, XY_MASK, 0, 0);
         input_set_abs_params(idev, ABS_PRESSURE, 0x0, 0xff, 0, 0);
 
-        error = input_register_device(idev);
-        if (error) {
+        ret = input_register_device(idev);
+        if (ret) {
                 dev_err(&pdev->dev, "Could not register input device\n");
-                return error;
+                goto err_free_irq;
         }
 
-        return 0;
+        return ret;
+
+err_free_irq:
+        free_irq(ts_irq, ts);
+err_free_input:
+        input_free_device(idev);
+        platform_set_drvdata(pdev, NULL);
+err_free_ts:
+        kfree(ts);
+err_out:
+        return ret;
 }
 
-static int stmpe_ts_remove(struct platform_device *pdev)
+static int __devexit stmpe_ts_remove(struct platform_device *pdev)
 {
         struct stmpe_touch *ts = platform_get_drvdata(pdev);
+        unsigned int ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
 
         stmpe_disable(ts->stmpe, STMPE_BLOCK_TOUCHSCREEN);
 
+        free_irq(ts_irq, ts);
+
+        platform_set_drvdata(pdev, NULL);
+
+        input_unregister_device(ts->idev);
+
+        kfree(ts);
+
         return 0;
 }
 
@@ -386,9 +377,22 @@ static struct platform_driver stmpe_ts_driver = {
                    .owner = THIS_MODULE,
                    },
         .probe = stmpe_input_probe,
-        .remove = stmpe_ts_remove,
+        .remove = __devexit_p(stmpe_ts_remove),
 };
-module_platform_driver(stmpe_ts_driver);
+
+static int __init stmpe_ts_init(void)
+{
+        return platform_driver_register(&stmpe_ts_driver);
+}
+
+module_init(stmpe_ts_init);
+
+static void __exit stmpe_ts_exit(void)
+{
+        platform_driver_unregister(&stmpe_ts_driver);
+}
+
+module_exit(stmpe_ts_exit);
 
 MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
 MODULE_DESCRIPTION("STMPEXXX touchscreen driver");
diff --git a/drivers/input/touchscreen/ti_am335x_tsc.c b/drivers/input/touchscreen/ti_am335x_tsc.c
deleted file mode 100644
index 51e7b87827a..00000000000
--- a/drivers/input/touchscreen/ti_am335x_tsc.c
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
- * TI Touch Screen driver
- *
- * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
- *
- * 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 version 2.
- *
- * This program is distributed "as is" WITHOUT ANY WARRANTY of any
- * kind, whether express or implied; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/input.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/clk.h>
-#include <linux/platform_device.h>
-#include <linux/io.h>
-#include <linux/input/ti_am335x_tsc.h>
-#include <linux/delay.h>
-
-#include <linux/mfd/ti_am335x_tscadc.h>
-
-#define ADCFSM_STEPID           0x10
-#define SEQ_SETTLE              275
-#define MAX_12BIT               ((1 << 12) - 1)
-
-struct titsc {
-        struct input_dev        *input;
-        struct ti_tscadc_dev    *mfd_tscadc;
-        unsigned int            irq;
-        unsigned int            wires;
-        unsigned int            x_plate_resistance;
-        bool                    pen_down;
-        int                     steps_to_configure;
-};
-
-static unsigned int titsc_readl(struct titsc *ts, unsigned int reg)
-{
-        return readl(ts->mfd_tscadc->tscadc_base + reg);
-}
-
-static void titsc_writel(struct titsc *tsc, unsigned int reg,
-                                        unsigned int val)
-{
-        writel(val, tsc->mfd_tscadc->tscadc_base + reg);
-}
-
-static void titsc_step_config(struct titsc *ts_dev)
-{
-        unsigned int    config;
-        int i, total_steps;
-
-        /* Configure the Step registers */
-        total_steps = 2 * ts_dev->steps_to_configure;
-
-        config = STEPCONFIG_MODE_HWSYNC |
-                        STEPCONFIG_AVG_16 | STEPCONFIG_XPP;
-        switch (ts_dev->wires) {
-        case 4:
-                config |= STEPCONFIG_INP_AN2 | STEPCONFIG_XNN;
-                break;
-        case 5:
-                config |= STEPCONFIG_YNN |
-                                STEPCONFIG_INP_AN4 | STEPCONFIG_XNN |
-                                STEPCONFIG_YPP;
-                break;
-        case 8:
-                config |= STEPCONFIG_INP_AN2 | STEPCONFIG_XNN;
-                break;
-        }
-
-        for (i = 1; i <= ts_dev->steps_to_configure; i++) {
-                titsc_writel(ts_dev, REG_STEPCONFIG(i), config);
-                titsc_writel(ts_dev, REG_STEPDELAY(i), STEPCONFIG_OPENDLY);
-        }
-
-        config = 0;
-        config = STEPCONFIG_MODE_HWSYNC |
-                        STEPCONFIG_AVG_16 | STEPCONFIG_YNN |
-                        STEPCONFIG_INM_ADCREFM | STEPCONFIG_FIFO1;
-        switch (ts_dev->wires) {
-        case 4:
-                config |= STEPCONFIG_YPP;
-                break;
-        case 5:
-                config |= STEPCONFIG_XPP | STEPCONFIG_INP_AN4 |
-                                STEPCONFIG_XNP | STEPCONFIG_YPN;
-                break;
-        case 8:
-                config |= STEPCONFIG_YPP;
-                break;
-        }
-
-        for (i = (ts_dev->steps_to_configure + 1); i <= total_steps; i++) {
-                titsc_writel(ts_dev, REG_STEPCONFIG(i), config);
-                titsc_writel(ts_dev, REG_STEPDELAY(i), STEPCONFIG_OPENDLY);
-        }
-
-        config = 0;
-        /* Charge step configuration */
-        config = STEPCONFIG_XPP | STEPCONFIG_YNN |
-                        STEPCHARGE_RFP_XPUL | STEPCHARGE_RFM_XNUR |
-                        STEPCHARGE_INM_AN1 | STEPCHARGE_INP_AN1;
-
-        titsc_writel(ts_dev, REG_CHARGECONFIG, config);
-        titsc_writel(ts_dev, REG_CHARGEDELAY, CHARGEDLY_OPENDLY);
-
-        config = 0;
-        /* Configure to calculate pressure */
-        config = STEPCONFIG_MODE_HWSYNC |
-                        STEPCONFIG_AVG_16 | STEPCONFIG_YPP |
-                        STEPCONFIG_XNN | STEPCONFIG_INM_ADCREFM;
-        titsc_writel(ts_dev, REG_STEPCONFIG(total_steps + 1), config);
-        titsc_writel(ts_dev, REG_STEPDELAY(total_steps + 1),
-                        STEPCONFIG_OPENDLY);
-
-        config |= STEPCONFIG_INP_AN3 | STEPCONFIG_FIFO1;
-        titsc_writel(ts_dev, REG_STEPCONFIG(total_steps + 2), config);
-        titsc_writel(ts_dev, REG_STEPDELAY(total_steps + 2),
-                        STEPCONFIG_OPENDLY);
-
-        titsc_writel(ts_dev, REG_SE, STPENB_STEPENB_TC);
-}
-
-static void titsc_read_coordinates(struct titsc *ts_dev,
-                                    unsigned int *x, unsigned int *y)
-{
-        unsigned int fifocount = titsc_readl(ts_dev, REG_FIFO0CNT);
-        unsigned int prev_val_x = ~0, prev_val_y = ~0;
-        unsigned int prev_diff_x = ~0, prev_diff_y = ~0;
-        unsigned int read, diff;
-        unsigned int i, channel;
-
-        /*
-         * Delta filter is used to remove large variations in sampled
-         * values from ADC. The filter tries to predict where the next
-         * coordinate could be. This is done by taking a previous
-         * coordinate and subtracting it form current one. Further the
-         * algorithm compares the difference with that of a present value,
-         * if true the value is reported to the sub system.
-         */
-        for (i = 0; i < fifocount - 1; i++) {
-                read = titsc_readl(ts_dev, REG_FIFO0);
-                channel = read & 0xf0000;
-                channel = channel >> 0x10;
-                if ((channel >= 0) && (channel < ts_dev->steps_to_configure)) {
-                        read &= 0xfff;
-                        diff = abs(read - prev_val_x);
-                        if (diff < prev_diff_x) {
-                                prev_diff_x = diff;
-                                *x = read;
-                        }
-                        prev_val_x = read;
-                }
-
-                read = titsc_readl(ts_dev, REG_FIFO1);
-                channel = read & 0xf0000;
-                channel = channel >> 0x10;
-                if ((channel >= ts_dev->steps_to_configure) &&
-                        (channel < (2 * ts_dev->steps_to_configure - 1))) {
-                        read &= 0xfff;
-                        diff = abs(read - prev_val_y);
-                        if (diff < prev_diff_y) {
-                                prev_diff_y = diff;
-                                *y = read;
-                        }
-                        prev_val_y = read;
-                }
-        }
-}
-
-static irqreturn_t titsc_irq(int irq, void *dev)
-{
-        struct titsc *ts_dev = dev;
-        struct input_dev *input_dev = ts_dev->input;
-        unsigned int status, irqclr = 0;
-        unsigned int x = 0, y = 0;
-        unsigned int z1, z2, z;
-        unsigned int fsm;
-        unsigned int fifo1count, fifo0count;
-        int i;
-
-        status = titsc_readl(ts_dev, REG_IRQSTATUS);
-        if (status & IRQENB_FIFO0THRES) {
-                titsc_read_coordinates(ts_dev, &x, &y);
-
-                z1 = titsc_readl(ts_dev, REG_FIFO0) & 0xfff;
-                z2 = titsc_readl(ts_dev, REG_FIFO1) & 0xfff;
-
-                fifo1count = titsc_readl(ts_dev, REG_FIFO1CNT);
-                for (i = 0; i < fifo1count; i++)
-                        titsc_readl(ts_dev, REG_FIFO1);
-
-                fifo0count = titsc_readl(ts_dev, REG_FIFO0CNT);
-                for (i = 0; i < fifo0count; i++)
-                        titsc_readl(ts_dev, REG_FIFO0);
-
-                if (ts_dev->pen_down && z1 != 0 && z2 != 0) {
-                        /*
-                         * Calculate pressure using formula
-                         * Resistance(touch) = x plate resistance *
-                         * x postion/4096 * ((z2 / z1) - 1)
-                         */
-                        z = z2 - z1;
-                        z *= x;
-                        z *= ts_dev->x_plate_resistance;
-                        z /= z1;
-                        z = (z + 2047) >> 12;
-
-                        if (z <= MAX_12BIT) {
-                                input_report_abs(input_dev, ABS_X, x);
-                                input_report_abs(input_dev, ABS_Y, y);
-                                input_report_abs(input_dev, ABS_PRESSURE, z);
-                                input_report_key(input_dev, BTN_TOUCH, 1);
-                                input_sync(input_dev);
-                        }
-                }
-                irqclr |= IRQENB_FIFO0THRES;
-        }
-
-        /*
-         * Time for sequencer to settle, to read
-         * correct state of the sequencer.
-         */
-        udelay(SEQ_SETTLE);
-
-        status = titsc_readl(ts_dev, REG_RAWIRQSTATUS);
-        if (status & IRQENB_PENUP) {
-                /* Pen up event */
-                fsm = titsc_readl(ts_dev, REG_ADCFSM);
-                if (fsm == ADCFSM_STEPID) {
-                        ts_dev->pen_down = false;
-                        input_report_key(input_dev, BTN_TOUCH, 0);
-                        input_report_abs(input_dev, ABS_PRESSURE, 0);
-                        input_sync(input_dev);
-                } else {
-                        ts_dev->pen_down = true;
-                }
-                irqclr |= IRQENB_PENUP;
-        }
-
-        titsc_writel(ts_dev, REG_IRQSTATUS, irqclr);
-
-        titsc_writel(ts_dev, REG_SE, STPENB_STEPENB_TC);
-        return IRQ_HANDLED;
-}
-
-/*
- * The functions for inserting/removing driver as a module.
- */
-
-static int titsc_probe(struct platform_device *pdev)
-{
-        struct titsc *ts_dev;
-        struct input_dev *input_dev;
-        struct ti_tscadc_dev *tscadc_dev = pdev->dev.platform_data;
-        struct mfd_tscadc_board *pdata;
-        int err;
-
-        pdata = tscadc_dev->dev->platform_data;
-
-        if (!pdata) {
-                dev_err(&pdev->dev, "Could not find platform data\n");
-                return -EINVAL;
-        }
-
-        /* Allocate memory for device */
-        ts_dev = kzalloc(sizeof(struct titsc), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!ts_dev || !input_dev) {
-                dev_err(&pdev->dev, "failed to allocate memory.\n");
-                err = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        tscadc_dev->tsc = ts_dev;
-        ts_dev->mfd_tscadc = tscadc_dev;
-        ts_dev->input = input_dev;
-        ts_dev->irq = tscadc_dev->irq;
-        ts_dev->wires = pdata->tsc_init->wires;
-        ts_dev->x_plate_resistance = pdata->tsc_init->x_plate_resistance;
-        ts_dev->steps_to_configure = pdata->tsc_init->steps_to_configure;
-
-        err = request_irq(ts_dev->irq, titsc_irq,
-                          0, pdev->dev.driver->name, ts_dev);
-        if (err) {
-                dev_err(&pdev->dev, "failed to allocate irq.\n");
-                goto err_free_mem;
-        }
-
-        titsc_writel(ts_dev, REG_IRQENABLE, IRQENB_FIFO0THRES);
-        titsc_step_config(ts_dev);
-        titsc_writel(ts_dev, REG_FIFO0THR, ts_dev->steps_to_configure);
-
-        input_dev->name = "ti-tsc";
-        input_dev->dev.parent = &pdev->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
-
-        input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);
-
-        /* register to the input system */
-        err = input_register_device(input_dev);
-        if (err)
-                goto err_free_irq;
-
-        platform_set_drvdata(pdev, ts_dev);
-        return 0;
-
-err_free_irq:
-        free_irq(ts_dev->irq, ts_dev);
-err_free_mem:
-        input_free_device(input_dev);
-        kfree(ts_dev);
-        return err;
-}
-
-static int titsc_remove(struct platform_device *pdev)
-{
-        struct ti_tscadc_dev *tscadc_dev = pdev->dev.platform_data;
-        struct titsc *ts_dev = tscadc_dev->tsc;
-
-        free_irq(ts_dev->irq, ts_dev);
-
-        input_unregister_device(ts_dev->input);
-
-        platform_set_drvdata(pdev, NULL);
-        kfree(ts_dev);
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int titsc_suspend(struct device *dev)
-{
-        struct ti_tscadc_dev *tscadc_dev = dev->platform_data;
-        struct titsc *ts_dev = tscadc_dev->tsc;
-        unsigned int idle;
-
-        if (device_may_wakeup(tscadc_dev->dev)) {
-                idle = titsc_readl(ts_dev, REG_IRQENABLE);
-                titsc_writel(ts_dev, REG_IRQENABLE,
-                                (idle | IRQENB_HW_PEN));
-                titsc_writel(ts_dev, REG_IRQWAKEUP, IRQWKUP_ENB);
-        }
-        return 0;
-}
-
-static int titsc_resume(struct device *dev)
-{
-        struct ti_tscadc_dev *tscadc_dev = dev->platform_data;
-        struct titsc *ts_dev = tscadc_dev->tsc;
-
-        if (device_may_wakeup(tscadc_dev->dev)) {
-                titsc_writel(ts_dev, REG_IRQWAKEUP,
-                                0x00);
-                titsc_writel(ts_dev, REG_IRQCLR, IRQENB_HW_PEN);
-        }
-        titsc_step_config(ts_dev);
-        titsc_writel(ts_dev, REG_FIFO0THR,
-                        ts_dev->steps_to_configure);
-        return 0;
-}
-
-static const struct dev_pm_ops titsc_pm_ops = {
-        .suspend = titsc_suspend,
-        .resume  = titsc_resume,
-};
-#define TITSC_PM_OPS (&titsc_pm_ops)
-#else
-#define TITSC_PM_OPS NULL
-#endif
-
-static struct platform_driver ti_tsc_driver = {
-        .probe  = titsc_probe,
-        .remove = titsc_remove,
-        .driver = {
-                .name   = "tsc",
-                .owner  = THIS_MODULE,
-                .pm     = TITSC_PM_OPS,
-        },
-};
-module_platform_driver(ti_tsc_driver);
-
-MODULE_DESCRIPTION("TI touchscreen controller driver");
-MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
index acfb87607b8..0e8f63e5b36 100644
--- a/drivers/input/touchscreen/tnetv107x-ts.c
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -243,7 +243,7 @@ static void tsc_stop(struct input_dev *dev)
         clk_disable(ts->clk);
 }
 
-static int tsc_probe(struct platform_device *pdev)
+static int __devinit tsc_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct tsc_data *ts;
@@ -297,7 +297,7 @@ static int tsc_probe(struct platform_device *pdev)
                 goto error_clk;
         }
 
-        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, IRQF_ONESHOT,
+        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, 0,
                                      dev_name(dev), ts);
         if (error < 0) {
                 dev_err(ts->dev, "Could not allocate ts irq\n");
@@ -357,7 +357,7 @@ error_res:
         return error;
 }
 
-static int tsc_remove(struct platform_device *pdev)
+static int __devexit tsc_remove(struct platform_device *pdev)
 {
         struct tsc_data *ts = platform_get_drvdata(pdev);
 
@@ -374,11 +374,23 @@ static int tsc_remove(struct platform_device *pdev)
 
 static struct platform_driver tsc_driver = {
         .probe          = tsc_probe,
-        .remove         = tsc_remove,
+        .remove         = __devexit_p(tsc_remove),
         .driver.name    = "tnetv107x-ts",
         .driver.owner   = THIS_MODULE,
 };
-module_platform_driver(tsc_driver);
+
+static int __init tsc_init(void)
+{
+        return platform_driver_register(&tsc_driver);
+}
+
+static void __exit tsc_exit(void)
+{
+        platform_driver_unregister(&tsc_driver);
+}
+
+module_init(tsc_init);
+module_exit(tsc_exit);
 
 MODULE_AUTHOR("Cyril Chemparathy");
 MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
diff --git a/drivers/input/touchscreen/touchit213.c b/drivers/input/touchscreen/touchit213.c
index 5f29e5b8e1c..d1297ba19da 100644
--- a/drivers/input/touchscreen/touchit213.c
+++ b/drivers/input/touchscreen/touchit213.c
@@ -216,4 +216,19 @@ static struct serio_driver touchit213_drv = {
         .disconnect     = touchit213_disconnect,
 };
 
-module_serio_driver(touchit213_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init touchit213_init(void)
+{
+        return serio_register_driver(&touchit213_drv);
+}
+
+static void __exit touchit213_exit(void)
+{
+        serio_unregister_driver(&touchit213_drv);
+}
+
+module_init(touchit213_init);
+module_exit(touchit213_exit);
diff --git a/drivers/input/touchscreen/touchright.c b/drivers/input/touchscreen/touchright.c
index 8a2887daf19..3a5c142c2a7 100644
--- a/drivers/input/touchscreen/touchright.c
+++ b/drivers/input/touchscreen/touchright.c
@@ -176,4 +176,19 @@ static struct serio_driver tr_drv = {
         .disconnect     = tr_disconnect,
 };
 
-module_serio_driver(tr_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init tr_init(void)
+{
+        return serio_register_driver(&tr_drv);
+}
+
+static void __exit tr_exit(void)
+{
+        serio_unregister_driver(&tr_drv);
+}
+
+module_init(tr_init);
+module_exit(tr_exit);
diff --git a/drivers/input/touchscreen/touchwin.c b/drivers/input/touchscreen/touchwin.c
index 588cdcb839d..763a656a59f 100644
--- a/drivers/input/touchscreen/touchwin.c
+++ b/drivers/input/touchscreen/touchwin.c
@@ -183,4 +183,19 @@ static struct serio_driver tw_drv = {
         .disconnect     = tw_disconnect,
 };
 
-module_serio_driver(tw_drv);
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init tw_init(void)
+{
+        return serio_register_driver(&tw_drv);
+}
+
+static void __exit tw_exit(void)
+{
+        serio_unregister_driver(&tw_drv);
+}
+
+module_init(tw_init);
+module_exit(tw_exit);
diff --git a/drivers/input/touchscreen/tps6507x-ts.c b/drivers/input/touchscreen/tps6507x-ts.c
index 820a066c3b8..43031492d73 100644
--- a/drivers/input/touchscreen/tps6507x-ts.c
+++ b/drivers/input/touchscreen/tps6507x-ts.c
@@ -1,4 +1,6 @@
 /*
+ * drivers/input/touchscreen/tps6507x_ts.c
+ *
  * Touchscreen driver for the tps6507x chip.
  *
  * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
@@ -345,7 +347,7 @@ err0:
         return error;
 }
 
-static int tps6507x_ts_remove(struct platform_device *pdev)
+static int __devexit tps6507x_ts_remove(struct platform_device *pdev)
 {
         struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
         struct tps6507x_ts *tsc = tps6507x_dev->ts;
@@ -367,11 +369,22 @@ static struct platform_driver tps6507x_ts_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = tps6507x_ts_probe,
-        .remove = tps6507x_ts_remove,
+        .remove = __devexit_p(tps6507x_ts_remove),
 };
-module_platform_driver(tps6507x_ts_driver);
+
+static int __init tps6507x_ts_init(void)
+{
+        return platform_driver_register(&tps6507x_ts_driver);
+}
+module_init(tps6507x_ts_init);
+
+static void __exit tps6507x_ts_exit(void)
+{
+        platform_driver_unregister(&tps6507x_ts_driver);
+}
+module_exit(tps6507x_ts_exit);
 
 MODULE_AUTHOR("Todd Fischer <todd.fischer@ridgerun.com>");
 MODULE_DESCRIPTION("TPS6507x - TouchScreen driver");
 MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:tps6507x-ts");
+MODULE_ALIAS("platform:tps6507x-tsc");
diff --git a/drivers/input/touchscreen/tsc2005.c b/drivers/input/touchscreen/tsc2005.c
index 9c0cdc7ea44..cbf0ff32267 100644
--- a/drivers/input/touchscreen/tsc2005.c
+++ b/drivers/input/touchscreen/tsc2005.c
@@ -450,13 +450,13 @@ static struct attribute *tsc2005_attrs[] = {
         NULL
 };
 
-static umode_t tsc2005_attr_is_visible(struct kobject *kobj,
+static mode_t tsc2005_attr_is_visible(struct kobject *kobj,
                                       struct attribute *attr, int n)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
         struct spi_device *spi = to_spi_device(dev);
         struct tsc2005 *ts = spi_get_drvdata(spi);
-        umode_t mode = attr->mode;
+        mode_t mode = attr->mode;
 
         if (attr == &dev_attr_selftest.attr) {
                 if (!ts->set_reset)
@@ -555,7 +555,7 @@ static void tsc2005_close(struct input_dev *input)
         mutex_unlock(&ts->mutex);
 }
 
-static void tsc2005_setup_spi_xfer(struct tsc2005 *ts)
+static void __devinit tsc2005_setup_spi_xfer(struct tsc2005 *ts)
 {
         tsc2005_setup_read(&ts->spi_x, TSC2005_REG_X, false);
         tsc2005_setup_read(&ts->spi_y, TSC2005_REG_Y, false);
@@ -569,7 +569,7 @@ static void tsc2005_setup_spi_xfer(struct tsc2005 *ts)
         spi_message_add_tail(&ts->spi_z2.spi_xfer, &ts->spi_read_msg);
 }
 
-static int tsc2005_probe(struct spi_device *spi)
+static int __devinit tsc2005_probe(struct spi_device *spi)
 {
         const struct tsc2005_platform_data *pdata = spi->dev.platform_data;
         struct tsc2005 *ts;
@@ -650,8 +650,7 @@ static int tsc2005_probe(struct spi_device *spi)
         tsc2005_stop_scan(ts);
 
         error = request_threaded_irq(spi->irq, NULL, tsc2005_irq_thread,
-                                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                     "tsc2005", ts);
+                                     IRQF_TRIGGER_RISING, "tsc2005", ts);
         if (error) {
                 dev_err(&spi->dev, "Failed to request irq, err: %d\n", error);
                 goto err_free_mem;
@@ -686,7 +685,7 @@ err_free_mem:
         return error;
 }
 
-static int tsc2005_remove(struct spi_device *spi)
+static int __devexit tsc2005_remove(struct spi_device *spi)
 {
         struct tsc2005 *ts = spi_get_drvdata(spi);
 
@@ -745,10 +744,20 @@ static struct spi_driver tsc2005_driver = {
                 .pm     = &tsc2005_pm_ops,
         },
         .probe  = tsc2005_probe,
-        .remove = tsc2005_remove,
+        .remove = __devexit_p(tsc2005_remove),
 };
 
-module_spi_driver(tsc2005_driver);
+static int __init tsc2005_init(void)
+{
+        return spi_register_driver(&tsc2005_driver);
+}
+module_init(tsc2005_init);
+
+static void __exit tsc2005_exit(void)
+{
+        spi_unregister_driver(&tsc2005_driver);
+}
+module_exit(tsc2005_exit);
 
 MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>");
 MODULE_DESCRIPTION("TSC2005 Touchscreen Driver");
diff --git a/drivers/input/touchscreen/tsc2007.c b/drivers/input/touchscreen/tsc2007.c
index 0b67ba476b4..fadc11545b1 100644
--- a/drivers/input/touchscreen/tsc2007.c
+++ b/drivers/input/touchscreen/tsc2007.c
@@ -66,6 +66,7 @@ struct ts_event {
 struct tsc2007 {
         struct input_dev        *input;
         char                    phys[32];
+        struct delayed_work     work;
 
         struct i2c_client       *client;
 
@@ -75,11 +76,9 @@ struct tsc2007 {
         unsigned long           poll_delay;
         unsigned long           poll_period;
 
+        bool                    pendown;
         int                     irq;
 
-        wait_queue_head_t       wait;
-        bool                    stopped;
-
         int                     (*get_pendown_state)(void);
         void                    (*clear_penirq)(void);
 };
@@ -142,8 +141,25 @@ static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc)
         return rt;
 }
 
-static bool tsc2007_is_pen_down(struct tsc2007 *ts)
+static void tsc2007_send_up_event(struct tsc2007 *tsc)
+{
+        struct input_dev *input = tsc->input;
+
+        dev_dbg(&tsc->client->dev, "UP\n");
+
+        input_report_key(input, BTN_TOUCH, 0);
+        input_report_abs(input, ABS_PRESSURE, 0);
+        input_sync(input);
+}
+
+static void tsc2007_work(struct work_struct *work)
 {
+        struct tsc2007 *ts =
+                container_of(to_delayed_work(work), struct tsc2007, work);
+        bool debounced = false;
+        struct ts_event tc;
+        u32 rt;
+
         /*
          * NOTE: We can't rely on the pressure to determine the pen down
          * state, even though this controller has a pressure sensor.
@@ -154,82 +170,79 @@ static bool tsc2007_is_pen_down(struct tsc2007 *ts)
          * The only safe way to check for the pen up condition is in the
          * work function by reading the pen signal state (it's a GPIO
          * and IRQ). Unfortunately such callback is not always available,
-         * in that case we assume that the pen is down and expect caller
-         * to fall back on the pressure reading.
+         * in that case we have rely on the pressure anyway.
          */
+        if (ts->get_pendown_state) {
+                if (unlikely(!ts->get_pendown_state())) {
+                        tsc2007_send_up_event(ts);
+                        ts->pendown = false;
+                        goto out;
+                }
 
-        if (!ts->get_pendown_state)
-                return true;
-
-        return ts->get_pendown_state();
-}
-
-static irqreturn_t tsc2007_soft_irq(int irq, void *handle)
-{
-        struct tsc2007 *ts = handle;
-        struct input_dev *input = ts->input;
-        struct ts_event tc;
-        u32 rt;
+                dev_dbg(&ts->client->dev, "pen is still down\n");
+        }
 
-        while (!ts->stopped && tsc2007_is_pen_down(ts)) {
+        tsc2007_read_values(ts, &tc);
 
-                /* pen is down, continue with the measurement */
-                tsc2007_read_values(ts, &tc);
+        rt = tsc2007_calculate_pressure(ts, &tc);
+        if (rt > ts->max_rt) {
+                /*
+                 * Sample found inconsistent by debouncing or pressure is
+                 * beyond the maximum. Don't report it to user space,
+                 * repeat at least once more the measurement.
+                 */
+                dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
+                debounced = true;
+                goto out;
 
-                rt = tsc2007_calculate_pressure(ts, &tc);
+        }
 
-                if (rt == 0 && !ts->get_pendown_state) {
-                        /*
-                         * If pressure reported is 0 and we don't have
-                         * callback to check pendown state, we have to
-                         * assume that pen was lifted up.
-                         */
-                        break;
-                }
+        if (rt) {
+                struct input_dev *input = ts->input;
 
-                if (rt <= ts->max_rt) {
-                        dev_dbg(&ts->client->dev,
-                                "DOWN point(%4d,%4d), pressure (%4u)\n",
-                                tc.x, tc.y, rt);
+                if (!ts->pendown) {
+                        dev_dbg(&ts->client->dev, "DOWN\n");
 
                         input_report_key(input, BTN_TOUCH, 1);
-                        input_report_abs(input, ABS_X, tc.x);
-                        input_report_abs(input, ABS_Y, tc.y);
-                        input_report_abs(input, ABS_PRESSURE, rt);
-
-                        input_sync(input);
-
-                } else {
-                        /*
-                         * Sample found inconsistent by debouncing or pressure is
-                         * beyond the maximum. Don't report it to user space,
-                         * repeat at least once more the measurement.
-                         */
-                        dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
+                        ts->pendown = true;
                 }
 
-                wait_event_timeout(ts->wait, ts->stopped,
-                                   msecs_to_jiffies(ts->poll_period));
-        }
+                input_report_abs(input, ABS_X, tc.x);
+                input_report_abs(input, ABS_Y, tc.y);
+                input_report_abs(input, ABS_PRESSURE, rt);
 
-        dev_dbg(&ts->client->dev, "UP\n");
+                input_sync(input);
 
-        input_report_key(input, BTN_TOUCH, 0);
-        input_report_abs(input, ABS_PRESSURE, 0);
-        input_sync(input);
+                dev_dbg(&ts->client->dev, "point(%4d,%4d), pressure (%4u)\n",
+                        tc.x, tc.y, rt);
 
-        if (ts->clear_penirq)
-                ts->clear_penirq();
+        } else if (!ts->get_pendown_state && ts->pendown) {
+                /*
+                 * We don't have callback to check pendown state, so we
+                 * have to assume that since pressure reported is 0 the
+                 * pen was lifted up.
+                 */
+                tsc2007_send_up_event(ts);
+                ts->pendown = false;
+        }
 
-        return IRQ_HANDLED;
+ out:
+        if (ts->pendown || debounced)
+                schedule_delayed_work(&ts->work,
+                                      msecs_to_jiffies(ts->poll_period));
+        else
+                enable_irq(ts->irq);
 }
 
-static irqreturn_t tsc2007_hard_irq(int irq, void *handle)
+static irqreturn_t tsc2007_irq(int irq, void *handle)
 {
         struct tsc2007 *ts = handle;
 
-        if (!ts->get_pendown_state || likely(ts->get_pendown_state()))
-                return IRQ_WAKE_THREAD;
+        if (!ts->get_pendown_state || likely(ts->get_pendown_state())) {
+                disable_irq_nosync(ts->irq);
+                schedule_delayed_work(&ts->work,
+                                      msecs_to_jiffies(ts->poll_delay));
+        }
 
         if (ts->clear_penirq)
                 ts->clear_penirq();
@@ -237,43 +250,20 @@ static irqreturn_t tsc2007_hard_irq(int irq, void *handle)
         return IRQ_HANDLED;
 }
 
-static void tsc2007_stop(struct tsc2007 *ts)
-{
-        ts->stopped = true;
-        mb();
-        wake_up(&ts->wait);
-
-        disable_irq(ts->irq);
-}
-
-static int tsc2007_open(struct input_dev *input_dev)
+static void tsc2007_free_irq(struct tsc2007 *ts)
 {
-        struct tsc2007 *ts = input_get_drvdata(input_dev);
-        int err;
-
-        ts->stopped = false;
-        mb();
-
-        enable_irq(ts->irq);
-
-        /* Prepare for touch readings - power down ADC and enable PENIRQ */
-        err = tsc2007_xfer(ts, PWRDOWN);
-        if (err < 0) {
-                tsc2007_stop(ts);
-                return err;
+        free_irq(ts->irq, ts);
+        if (cancel_delayed_work_sync(&ts->work)) {
+                /*
+                 * Work was pending, therefore we need to enable
+                 * IRQ here to balance the disable_irq() done in the
+                 * interrupt handler.
+                 */
+                enable_irq(ts->irq);
         }
-
-        return 0;
-}
-
-static void tsc2007_close(struct input_dev *input_dev)
-{
-        struct tsc2007 *ts = input_get_drvdata(input_dev);
-
-        tsc2007_stop(ts);
 }
 
-static int tsc2007_probe(struct i2c_client *client,
+static int __devinit tsc2007_probe(struct i2c_client *client,
                                    const struct i2c_device_id *id)
 {
         struct tsc2007 *ts;
@@ -300,7 +290,7 @@ static int tsc2007_probe(struct i2c_client *client,
         ts->client = client;
         ts->irq = client->irq;
         ts->input = input_dev;
-        init_waitqueue_head(&ts->wait);
+        INIT_DELAYED_WORK(&ts->work, tsc2007_work);
 
         ts->model             = pdata->model;
         ts->x_plate_ohms      = pdata->x_plate_ohms;
@@ -310,12 +300,6 @@ static int tsc2007_probe(struct i2c_client *client,
         ts->get_pendown_state = pdata->get_pendown_state;
         ts->clear_penirq      = pdata->clear_penirq;
 
-        if (pdata->x_plate_ohms == 0) {
-                dev_err(&client->dev, "x_plate_ohms is not set up in platform data");
-                err = -EINVAL;
-                goto err_free_mem;
-        }
-
         snprintf(ts->phys, sizeof(ts->phys),
                  "%s/input0", dev_name(&client->dev));
 
@@ -323,11 +307,6 @@ static int tsc2007_probe(struct i2c_client *client,
         input_dev->phys = ts->phys;
         input_dev->id.bustype = BUS_I2C;
 
-        input_dev->open = tsc2007_open;
-        input_dev->close = tsc2007_close;
-
-        input_set_drvdata(input_dev, ts);
-
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
@@ -339,14 +318,17 @@ static int tsc2007_probe(struct i2c_client *client,
         if (pdata->init_platform_hw)
                 pdata->init_platform_hw();
 
-        err = request_threaded_irq(ts->irq, tsc2007_hard_irq, tsc2007_soft_irq,
-                                   IRQF_ONESHOT, client->dev.driver->name, ts);
+        err = request_irq(ts->irq, tsc2007_irq, 0,
+                        client->dev.driver->name, ts);
         if (err < 0) {
                 dev_err(&client->dev, "irq %d busy?\n", ts->irq);
                 goto err_free_mem;
         }
 
-        tsc2007_stop(ts);
+        /* Prepare for touch readings - power down ADC and enable PENIRQ */
+        err = tsc2007_xfer(ts, PWRDOWN);
+        if (err < 0)
+                goto err_free_irq;
 
         err = input_register_device(input_dev);
         if (err)
@@ -357,7 +339,7 @@ static int tsc2007_probe(struct i2c_client *client,
         return 0;
 
  err_free_irq:
-        free_irq(ts->irq, ts);
+        tsc2007_free_irq(ts);
         if (pdata->exit_platform_hw)
                 pdata->exit_platform_hw();
  err_free_mem:
@@ -366,12 +348,12 @@ static int tsc2007_probe(struct i2c_client *client,
         return err;
 }
 
-static int tsc2007_remove(struct i2c_client *client)
+static int __devexit tsc2007_remove(struct i2c_client *client)
 {
         struct tsc2007  *ts = i2c_get_clientdata(client);
         struct tsc2007_platform_data *pdata = client->dev.platform_data;
 
-        free_irq(ts->irq, ts);
+        tsc2007_free_irq(ts);
 
         if (pdata->exit_platform_hw)
                 pdata->exit_platform_hw();
@@ -396,10 +378,21 @@ static struct i2c_driver tsc2007_driver = {
         },
         .id_table       = tsc2007_idtable,
         .probe          = tsc2007_probe,
-        .remove         = tsc2007_remove,
+        .remove         = __devexit_p(tsc2007_remove),
 };
 
-module_i2c_driver(tsc2007_driver);
+static int __init tsc2007_init(void)
+{
+        return i2c_add_driver(&tsc2007_driver);
+}
+
+static void __exit tsc2007_exit(void)
+{
+        i2c_del_driver(&tsc2007_driver);
+}
+
+module_init(tsc2007_init);
+module_exit(tsc2007_exit);
 
 MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>");
 MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
diff --git a/drivers/input/touchscreen/tsc40.c b/drivers/input/touchscreen/tsc40.c
deleted file mode 100644
index eb96f168fb9..00000000000
--- a/drivers/input/touchscreen/tsc40.c
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * TSC-40 serial touchscreen driver. It should be compatible with
- * TSC-10 and 25.
- *
- * Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
- * License: GPLv2 as published by the FSF.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/input.h>
-#include <linux/serio.h>
-#include <linux/init.h>
-
-#define PACKET_LENGTH  5
-struct tsc_ser {
-        struct input_dev *dev;
-        struct serio *serio;
-        u32 idx;
-        unsigned char data[PACKET_LENGTH];
-        char phys[32];
-};
-
-static void tsc_process_data(struct tsc_ser *ptsc)
-{
-        struct input_dev *dev = ptsc->dev;
-        u8 *data = ptsc->data;
-        u32 x;
-        u32 y;
-
-        x = ((data[1] & 0x03) << 8) | data[2];
-        y = ((data[3] & 0x03) << 8) | data[4];
-
-        input_report_abs(dev, ABS_X, x);
-        input_report_abs(dev, ABS_Y, y);
-        input_report_key(dev, BTN_TOUCH, 1);
-
-        input_sync(dev);
-}
-
-static irqreturn_t tsc_interrupt(struct serio *serio,
-                unsigned char data, unsigned int flags)
-{
-        struct tsc_ser *ptsc = serio_get_drvdata(serio);
-        struct input_dev *dev = ptsc->dev;
-
-        ptsc->data[ptsc->idx] = data;
-        switch (ptsc->idx++) {
-        case 0:
-                if (unlikely((data & 0x3e) != 0x10)) {
-                        dev_dbg(&serio->dev,
-                                "unsynchronized packet start (0x%02x)\n", data);
-                        ptsc->idx = 0;
-                } else if (!(data & 0x01)) {
-                        input_report_key(dev, BTN_TOUCH, 0);
-                        input_sync(dev);
-                        ptsc->idx = 0;
-                }
-                break;
-
-        case 1:
-        case 3:
-                if (unlikely(data & 0xfc)) {
-                        dev_dbg(&serio->dev,
-                                "unsynchronized data 0x%02x at offset %d\n",
-                                data, ptsc->idx - 1);
-                        ptsc->idx = 0;
-                }
-                break;
-
-        case 4:
-                tsc_process_data(ptsc);
-                ptsc->idx = 0;
-                break;
-        }
-
-        return IRQ_HANDLED;
-}
-
-static int tsc_connect(struct serio *serio, struct serio_driver *drv)
-{
-        struct tsc_ser *ptsc;
-        struct input_dev *input_dev;
-        int error;
-
-        ptsc = kzalloc(sizeof(struct tsc_ser), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!ptsc || !input_dev) {
-                error = -ENOMEM;
-                goto fail1;
-        }
-
-        ptsc->serio = serio;
-        ptsc->dev = input_dev;
-        snprintf(ptsc->phys, sizeof(ptsc->phys), "%s/input0", serio->phys);
-
-        input_dev->name = "TSC-10/25/40 Serial TouchScreen";
-        input_dev->phys = ptsc->phys;
-        input_dev->id.bustype = BUS_RS232;
-        input_dev->id.vendor = SERIO_TSC40;
-        input_dev->id.product = 40;
-        input_dev->id.version = 0x0001;
-        input_dev->dev.parent = &serio->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-        input_set_abs_params(ptsc->dev, ABS_X, 0, 0x3ff, 0, 0);
-        input_set_abs_params(ptsc->dev, ABS_Y, 0, 0x3ff, 0, 0);
-
-        serio_set_drvdata(serio, ptsc);
-
-        error = serio_open(serio, drv);
-        if (error)
-                goto fail2;
-
-        error = input_register_device(ptsc->dev);
-        if (error)
-                goto fail3;
-
-        return 0;
-
-fail3:
-        serio_close(serio);
-fail2:
-        serio_set_drvdata(serio, NULL);
-fail1:
-        input_free_device(input_dev);
-        kfree(ptsc);
-        return error;
-}
-
-static void tsc_disconnect(struct serio *serio)
-{
-        struct tsc_ser *ptsc = serio_get_drvdata(serio);
-
-        serio_close(serio);
-
-        input_unregister_device(ptsc->dev);
-        kfree(ptsc);
-
-        serio_set_drvdata(serio, NULL);
-}
-
-static struct serio_device_id tsc_serio_ids[] = {
-        {
-                .type   = SERIO_RS232,
-                .proto  = SERIO_TSC40,
-                .id     = SERIO_ANY,
-                .extra  = SERIO_ANY,
-        },
-        { 0 }
-};
-MODULE_DEVICE_TABLE(serio, tsc_serio_ids);
-
-#define DRIVER_DESC    "TSC-10/25/40 serial touchscreen driver"
-
-static struct serio_driver tsc_drv = {
-        .driver = {
-                .name   = "tsc40",
-        },
-        .description    = DRIVER_DESC,
-        .id_table       = tsc_serio_ids,
-        .interrupt      = tsc_interrupt,
-        .connect        = tsc_connect,
-        .disconnect     = tsc_disconnect,
-};
-
-module_serio_driver(tsc_drv);
-
-MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/ucb1400_ts.c b/drivers/input/touchscreen/ucb1400_ts.c
index 1271f97b407..3b5b5df04dd 100644
--- a/drivers/input/touchscreen/ucb1400_ts.c
+++ b/drivers/input/touchscreen/ucb1400_ts.c
@@ -20,24 +20,24 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/completion.h>
 #include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/wait.h>
 #include <linux/input.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
+#include <linux/suspend.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
 #include <linux/ucb1400.h>
 
-#define UCB1400_TS_POLL_PERIOD  10 /* ms */
-
-static bool adcsync;
+static int adcsync;
 static int ts_delay = 55; /* us */
 static int ts_delay_pressure;   /* us */
 
 /* Switch to interrupt mode. */
-static void ucb1400_ts_mode_int(struct ucb1400_ts *ucb)
+static inline void ucb1400_ts_mode_int(struct snd_ac97 *ac97)
 {
-        ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
+        ucb1400_reg_write(ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
                         UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
                         UCB_TS_CR_MODE_INT);
@@ -47,15 +47,13 @@ static void ucb1400_ts_mode_int(struct ucb1400_ts *ucb)
  * Switch to pressure mode, and read pressure.  We don't need to wait
  * here, since both plates are being driven.
  */
-static unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb)
+static inline unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb)
 {
         ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
                         UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
                         UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
-
         udelay(ts_delay_pressure);
-
         return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync);
 }
 
@@ -65,7 +63,7 @@ static unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb)
  * gives a faster response time.  Even so, we need to wait about 55us
  * for things to stabilise.
  */
-static unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb)
+static inline unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb)
 {
         ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
@@ -88,7 +86,7 @@ static unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb)
  * gives a faster response time.  Even so, we need to wait about 55us
  * for things to stabilise.
  */
-static int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb)
+static inline unsigned int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb)
 {
         ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
@@ -109,7 +107,7 @@ static int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb)
  * Switch to X plate resistance mode.  Set MX to ground, PX to
  * supply.  Measure current.
  */
-static unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb)
+static inline unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb)
 {
         ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
@@ -121,7 +119,7 @@ static unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb)
  * Switch to Y plate resistance mode.  Set MY to ground, PY to
  * supply.  Measure current.
  */
-static unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb)
+static inline unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb)
 {
         ucb1400_reg_write(ucb->ac97, UCB_TS_CR,
                         UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
@@ -129,26 +127,26 @@ static unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb)
         return ucb1400_adc_read(ucb->ac97, 0, adcsync);
 }
 
-static int ucb1400_ts_pen_up(struct ucb1400_ts *ucb)
+static inline int ucb1400_ts_pen_up(struct snd_ac97 *ac97)
 {
-        unsigned short val = ucb1400_reg_read(ucb->ac97, UCB_TS_CR);
+        unsigned short val = ucb1400_reg_read(ac97, UCB_TS_CR);
 
         return val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW);
 }
 
-static void ucb1400_ts_irq_enable(struct ucb1400_ts *ucb)
+static inline void ucb1400_ts_irq_enable(struct snd_ac97 *ac97)
 {
-        ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, UCB_IE_TSPX);
-        ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0);
-        ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_TSPX);
+        ucb1400_reg_write(ac97, UCB_IE_CLEAR, UCB_IE_TSPX);
+        ucb1400_reg_write(ac97, UCB_IE_CLEAR, 0);
+        ucb1400_reg_write(ac97, UCB_IE_FAL, UCB_IE_TSPX);
 }
 
-static void ucb1400_ts_irq_disable(struct ucb1400_ts *ucb)
+static inline void ucb1400_ts_irq_disable(struct snd_ac97 *ac97)
 {
-        ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0);
+        ucb1400_reg_write(ac97, UCB_IE_FAL, 0);
 }
 
-static void ucb1400_ts_report_event(struct input_dev *idev, u16 pressure, u16 x, u16 y)
+static void ucb1400_ts_evt_add(struct input_dev *idev, u16 pressure, u16 x, u16 y)
 {
         input_report_abs(idev, ABS_X, x);
         input_report_abs(idev, ABS_Y, y);
@@ -164,7 +162,7 @@ static void ucb1400_ts_event_release(struct input_dev *idev)
         input_sync(idev);
 }
 
-static void ucb1400_clear_pending_irq(struct ucb1400_ts *ucb)
+static void ucb1400_handle_pending_irq(struct ucb1400_ts *ucb)
 {
         unsigned int isr;
 
@@ -173,34 +171,32 @@ static void ucb1400_clear_pending_irq(struct ucb1400_ts *ucb)
         ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0);
 
         if (isr & UCB_IE_TSPX)
-                ucb1400_ts_irq_disable(ucb);
+                ucb1400_ts_irq_disable(ucb->ac97);
         else
-                dev_dbg(&ucb->ts_idev->dev,
-                        "ucb1400: unexpected IE_STATUS = %#x\n", isr);
+                dev_dbg(&ucb->ts_idev->dev, "ucb1400: unexpected IE_STATUS = %#x\n", isr);
+        enable_irq(ucb->irq);
 }
 
-/*
- * A restriction with interrupts exists when using the ucb1400, as
- * the codec read/write routines may sleep while waiting for codec
- * access completion and uses semaphores for access control to the
- * AC97 bus. Therefore the driver is forced to use threaded interrupt
- * handler.
- */
-static irqreturn_t ucb1400_irq(int irqnr, void *devid)
+static int ucb1400_ts_thread(void *_ucb)
 {
-        struct ucb1400_ts *ucb = devid;
-        unsigned int x, y, p;
-        bool penup;
+        struct ucb1400_ts *ucb = _ucb;
+        struct task_struct *tsk = current;
+        int valid = 0;
+        struct sched_param param = { .sched_priority = 1 };
 
-        if (unlikely(irqnr != ucb->irq))
-                return IRQ_NONE;
+        sched_setscheduler(tsk, SCHED_FIFO, &param);
 
-        ucb1400_clear_pending_irq(ucb);
+        set_freezable();
+        while (!kthread_should_stop()) {
+                unsigned int x, y, p;
+                long timeout;
 
-        /* Start with a small delay before checking pendown state */
-        msleep(UCB1400_TS_POLL_PERIOD);
+                ucb->ts_restart = 0;
 
-        while (!ucb->stopped && !(penup = ucb1400_ts_pen_up(ucb))) {
+                if (ucb->irq_pending) {
+                        ucb->irq_pending = 0;
+                        ucb1400_handle_pending_irq(ucb);
+                }
 
                 ucb1400_adc_enable(ucb->ac97);
                 x = ucb1400_ts_read_xpos(ucb);
@@ -208,62 +204,91 @@ static irqreturn_t ucb1400_irq(int irqnr, void *devid)
                 p = ucb1400_ts_read_pressure(ucb);
                 ucb1400_adc_disable(ucb->ac97);
 
-                ucb1400_ts_report_event(ucb->ts_idev, p, x, y);
-
-                wait_event_timeout(ucb->ts_wait, ucb->stopped,
-                                   msecs_to_jiffies(UCB1400_TS_POLL_PERIOD));
-        }
-
-        ucb1400_ts_event_release(ucb->ts_idev);
-
-        if (!ucb->stopped) {
                 /* Switch back to interrupt mode. */
-                ucb1400_ts_mode_int(ucb);
-                ucb1400_ts_irq_enable(ucb);
-        }
+                ucb1400_ts_mode_int(ucb->ac97);
+
+                msleep(10);
+
+                if (ucb1400_ts_pen_up(ucb->ac97)) {
+                        ucb1400_ts_irq_enable(ucb->ac97);
+
+                        /*
+                         * If we spat out a valid sample set last time,
+                         * spit out a "pen off" sample here.
+                         */
+                        if (valid) {
+                                ucb1400_ts_event_release(ucb->ts_idev);
+                                valid = 0;
+                        }
+
+                        timeout = MAX_SCHEDULE_TIMEOUT;
+                } else {
+                        valid = 1;
+                        ucb1400_ts_evt_add(ucb->ts_idev, p, x, y);
+                        timeout = msecs_to_jiffies(10);
+                }
 
-        return IRQ_HANDLED;
-}
+                wait_event_freezable_timeout(ucb->ts_wait,
+                        ucb->irq_pending || ucb->ts_restart ||
+                        kthread_should_stop(), timeout);
+        }
 
-static void ucb1400_ts_stop(struct ucb1400_ts *ucb)
-{
-        /* Signal IRQ thread to stop polling and disable the handler. */
-        ucb->stopped = true;
-        mb();
-        wake_up(&ucb->ts_wait);
-        disable_irq(ucb->irq);
+        /* Send the "pen off" if we are stopping with the pen still active */
+        if (valid)
+                ucb1400_ts_event_release(ucb->ts_idev);
 
-        ucb1400_ts_irq_disable(ucb);
-        ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 0);
+        ucb->ts_task = NULL;
+        return 0;
 }
 
-/* Must be called with ts->lock held */
-static void ucb1400_ts_start(struct ucb1400_ts *ucb)
+/*
+ * A restriction with interrupts exists when using the ucb1400, as
+ * the codec read/write routines may sleep while waiting for codec
+ * access completion and uses semaphores for access control to the
+ * AC97 bus.  A complete codec read cycle could take  anywhere from
+ * 60 to 100uSec so we *definitely* don't want to spin inside the
+ * interrupt handler waiting for codec access.  So, we handle the
+ * interrupt by scheduling a RT kernel thread to run in process
+ * context instead of interrupt context.
+ */
+static irqreturn_t ucb1400_hard_irq(int irqnr, void *devid)
 {
-        /* Tell IRQ thread that it may poll the device. */
-        ucb->stopped = false;
-        mb();
-
-        ucb1400_ts_mode_int(ucb);
-        ucb1400_ts_irq_enable(ucb);
+        struct ucb1400_ts *ucb = devid;
 
-        enable_irq(ucb->irq);
+        if (irqnr == ucb->irq) {
+                disable_irq_nosync(ucb->irq);
+                ucb->irq_pending = 1;
+                wake_up(&ucb->ts_wait);
+                return IRQ_HANDLED;
+        }
+        return IRQ_NONE;
 }
 
 static int ucb1400_ts_open(struct input_dev *idev)
 {
         struct ucb1400_ts *ucb = input_get_drvdata(idev);
+        int ret = 0;
 
-        ucb1400_ts_start(ucb);
+        BUG_ON(ucb->ts_task);
 
-        return 0;
+        ucb->ts_task = kthread_run(ucb1400_ts_thread, ucb, "UCB1400_ts");
+        if (IS_ERR(ucb->ts_task)) {
+                ret = PTR_ERR(ucb->ts_task);
+                ucb->ts_task = NULL;
+        }
+
+        return ret;
 }
 
 static void ucb1400_ts_close(struct input_dev *idev)
 {
         struct ucb1400_ts *ucb = input_get_drvdata(idev);
 
-        ucb1400_ts_stop(ucb);
+        if (ucb->ts_task)
+                kthread_stop(ucb->ts_task);
+
+        ucb1400_ts_irq_disable(ucb->ac97);
+        ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 0);
 }
 
 #ifndef NO_IRQ
@@ -274,8 +299,7 @@ static void ucb1400_ts_close(struct input_dev *idev)
  * Try to probe our interrupt, rather than relying on lots of
  * hard-coded machine dependencies.
  */
-static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb,
-                                           struct platform_device *pdev)
+static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb)
 {
         unsigned long mask, timeout;
 
@@ -297,7 +321,7 @@ static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb,
                                                 UCB_ADC_DAT_VALID)) {
                 cpu_relax();
                 if (time_after(jiffies, timeout)) {
-                        dev_err(&pdev->dev, "timed out in IRQ probe\n");
+                        printk(KERN_ERR "ucb1400: timed out in IRQ probe\n");
                         probe_irq_off(mask);
                         return -ENODEV;
                 }
@@ -318,11 +342,11 @@ static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb,
         return 0;
 }
 
-static int ucb1400_ts_probe(struct platform_device *pdev)
+static int ucb1400_ts_probe(struct platform_device *dev)
 {
-        struct ucb1400_ts *ucb = pdev->dev.platform_data;
         int error, x_res, y_res;
         u16 fcsr;
+        struct ucb1400_ts *ucb = dev->dev.platform_data;
 
         ucb->ts_idev = input_allocate_device();
         if (!ucb->ts_idev) {
@@ -332,19 +356,27 @@ static int ucb1400_ts_probe(struct platform_device *pdev)
 
         /* Only in case the IRQ line wasn't supplied, try detecting it */
         if (ucb->irq < 0) {
-                error = ucb1400_ts_detect_irq(ucb, pdev);
+                error = ucb1400_ts_detect_irq(ucb);
                 if (error) {
-                        dev_err(&pdev->dev, "IRQ probe failed\n");
+                        printk(KERN_ERR "UCB1400: IRQ probe failed\n");
                         goto err_free_devs;
                 }
         }
-        dev_dbg(&pdev->dev, "found IRQ %d\n", ucb->irq);
 
         init_waitqueue_head(&ucb->ts_wait);
 
+        error = request_irq(ucb->irq, ucb1400_hard_irq, IRQF_TRIGGER_RISING,
+                                "UCB1400", ucb);
+        if (error) {
+                printk(KERN_ERR "ucb1400: unable to grab irq%d: %d\n",
+                                ucb->irq, error);
+                goto err_free_devs;
+        }
+        printk(KERN_DEBUG "UCB1400: found IRQ %d\n", ucb->irq);
+
         input_set_drvdata(ucb->ts_idev, ucb);
 
-        ucb->ts_idev->dev.parent        = &pdev->dev;
+        ucb->ts_idev->dev.parent        = &dev->dev;
         ucb->ts_idev->name              = "UCB1400 touchscreen interface";
         ucb->ts_idev->id.vendor         = ucb1400_reg_read(ucb->ac97,
                                                 AC97_VENDOR_ID1);
@@ -366,23 +398,12 @@ static int ucb1400_ts_probe(struct platform_device *pdev)
         x_res = ucb1400_ts_read_xres(ucb);
         y_res = ucb1400_ts_read_yres(ucb);
         ucb1400_adc_disable(ucb->ac97);
-        dev_dbg(&pdev->dev, "x/y = %d/%d\n", x_res, y_res);
+        printk(KERN_DEBUG "UCB1400: x/y = %d/%d\n", x_res, y_res);
 
         input_set_abs_params(ucb->ts_idev, ABS_X, 0, x_res, 0, 0);
         input_set_abs_params(ucb->ts_idev, ABS_Y, 0, y_res, 0, 0);
         input_set_abs_params(ucb->ts_idev, ABS_PRESSURE, 0, 0, 0, 0);
 
-        ucb1400_ts_stop(ucb);
-
-        error = request_threaded_irq(ucb->irq, NULL, ucb1400_irq,
-                                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                     "UCB1400", ucb);
-        if (error) {
-                dev_err(&pdev->dev,
-                        "unable to grab irq%d: %d\n", ucb->irq, error);
-                goto err_free_devs;
-        }
-
         error = input_register_device(ucb->ts_idev);
         if (error)
                 goto err_free_irq;
@@ -395,61 +416,56 @@ err_free_devs:
         input_free_device(ucb->ts_idev);
 err:
         return error;
+
 }
 
-static int ucb1400_ts_remove(struct platform_device *pdev)
+static int ucb1400_ts_remove(struct platform_device *dev)
 {
-        struct ucb1400_ts *ucb = pdev->dev.platform_data;
+        struct ucb1400_ts *ucb = dev->dev.platform_data;
 
         free_irq(ucb->irq, ucb);
         input_unregister_device(ucb->ts_idev);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int ucb1400_ts_suspend(struct device *dev)
-{
-        struct ucb1400_ts *ucb = dev->platform_data;
-        struct input_dev *idev = ucb->ts_idev;
-
-        mutex_lock(&idev->mutex);
-
-        if (idev->users)
-                ucb1400_ts_start(ucb);
-
-        mutex_unlock(&idev->mutex);
         return 0;
 }
 
-static int ucb1400_ts_resume(struct device *dev)
+#ifdef CONFIG_PM
+static int ucb1400_ts_resume(struct platform_device *dev)
 {
-        struct ucb1400_ts *ucb = dev->platform_data;
-        struct input_dev *idev = ucb->ts_idev;
-
-        mutex_lock(&idev->mutex);
-
-        if (idev->users)
-                ucb1400_ts_stop(ucb);
-
-        mutex_unlock(&idev->mutex);
+        struct ucb1400_ts *ucb = dev->dev.platform_data;
+
+        if (ucb->ts_task) {
+                /*
+                 * Restart the TS thread to ensure the
+                 * TS interrupt mode is set up again
+                 * after sleep.
+                 */
+                ucb->ts_restart = 1;
+                wake_up(&ucb->ts_wait);
+        }
         return 0;
 }
+#else
+#define ucb1400_ts_resume NULL
 #endif
 
-static SIMPLE_DEV_PM_OPS(ucb1400_ts_pm_ops,
-                         ucb1400_ts_suspend, ucb1400_ts_resume);
-
 static struct platform_driver ucb1400_ts_driver = {
         .probe  = ucb1400_ts_probe,
         .remove = ucb1400_ts_remove,
+        .resume = ucb1400_ts_resume,
         .driver = {
                 .name   = "ucb1400_ts",
-                .owner  = THIS_MODULE,
-                .pm     = &ucb1400_ts_pm_ops,
         },
 };
-module_platform_driver(ucb1400_ts_driver);
+
+static int __init ucb1400_ts_init(void)
+{
+        return platform_driver_register(&ucb1400_ts_driver);
+}
+
+static void __exit ucb1400_ts_exit(void)
+{
+        platform_driver_unregister(&ucb1400_ts_driver);
+}
 
 module_param(adcsync, bool, 0444);
 MODULE_PARM_DESC(adcsync, "Synchronize touch readings with ADCSYNC pin.");
@@ -463,5 +479,8 @@ MODULE_PARM_DESC(ts_delay_pressure,
                 "delay between panel setup and pressure read."
                 "  Default = 0us.");
 
+module_init(ucb1400_ts_init);
+module_exit(ucb1400_ts_exit);
+
 MODULE_DESCRIPTION("Philips UCB1400 touchscreen driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 721fdb3597c..73fd6642b68 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -16,8 +16,6 @@
  *  - JASTEC USB touch controller/DigiTech DTR-02U
  *  - Zytronic capacitive touchscreen
  *  - NEXIO/iNexio
- *  - Elo TouchSystems 2700 IntelliTouch
- *  - EasyTouch USB Dual/Multi touch controller from Data Modul
  *
  * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
  * Copyright (C) by Todd E. Johnson (mtouchusb.c)
@@ -61,11 +59,11 @@
 #define DRIVER_AUTHOR           "Daniel Ritz <daniel.ritz@gmx.ch>"
 #define DRIVER_DESC             "USB Touchscreen Driver"
 
-static bool swap_xy;
+static int swap_xy;
 module_param(swap_xy, bool, 0644);
 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
 
-static bool hwcalib_xy;
+static int hwcalib_xy;
 module_param(hwcalib_xy, bool, 0644);
 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");
 
@@ -140,8 +138,6 @@ enum {
         DEVTYPE_ZYTRONIC,
         DEVTYPE_TC45USB,
         DEVTYPE_NEXIO,
-        DEVTYPE_ELO,
-        DEVTYPE_ETOUCH,
 };
 
 #define USB_DEVICE_HID_CLASS(vend, prod) \
@@ -243,14 +239,6 @@ static const struct usb_device_id usbtouch_devices[] = {
                 .driver_info = DEVTYPE_NEXIO},
 #endif
 
-#ifdef CONFIG_TOUCHSCREEN_USB_ELO
-        {USB_DEVICE(0x04e7, 0x0020), .driver_info = DEVTYPE_ELO},
-#endif
-
-#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
-        {USB_DEVICE(0x7374, 0x0001), .driver_info = DEVTYPE_ETOUCH},
-#endif
-
         {}
 };
 
@@ -269,9 +257,8 @@ static int e2i_init(struct usbtouch_usb *usbtouch)
                               0x01, 0x02, 0x0000, 0x0081,
                               NULL, 0, USB_CTRL_SET_TIMEOUT);
 
-        dev_dbg(&usbtouch->interface->dev,
-                "%s - usb_control_msg - E2I_RESET - bytes|err: %d\n",
-                __func__, ret);
+        dbg("%s - usb_control_msg - E2I_RESET - bytes|err: %d",
+            __func__, ret);
         return ret;
 }
 
@@ -304,45 +291,6 @@ static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #define EGALAX_PKT_TYPE_REPT            0x80
 #define EGALAX_PKT_TYPE_DIAG            0x0A
 
-static int egalax_init(struct usbtouch_usb *usbtouch)
-{
-        int ret, i;
-        unsigned char *buf;
-        struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
-
-        /*
-         * An eGalax diagnostic packet kicks the device into using the right
-         * protocol.  We send a "check active" packet.  The response will be
-         * read later and ignored.
-         */
-
-        buf = kmalloc(3, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-
-        buf[0] = EGALAX_PKT_TYPE_DIAG;
-        buf[1] = 1;     /* length */
-        buf[2] = 'A';   /* command - check active */
-
-        for (i = 0; i < 3; i++) {
-                ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                      0,
-                                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                                      0, 0, buf, 3,
-                                      USB_CTRL_SET_TIMEOUT);
-                if (ret >= 0) {
-                        ret = 0;
-                        break;
-                }
-                if (ret != -EPIPE)
-                        break;
-        }
-
-        kfree(buf);
-
-        return ret;
-}
-
 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
         if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
@@ -372,51 +320,6 @@ static int egalax_get_pkt_len(unsigned char *buf, int len)
 }
 #endif
 
-/*****************************************************************************
- * EasyTouch part
- */
-
-#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
-
-#ifndef MULTI_PACKET
-#define MULTI_PACKET
-#endif
-
-#define ETOUCH_PKT_TYPE_MASK            0xFE
-#define ETOUCH_PKT_TYPE_REPT            0x80
-#define ETOUCH_PKT_TYPE_REPT2           0xB0
-#define ETOUCH_PKT_TYPE_DIAG            0x0A
-
-static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
-{
-        if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT &&
-                (pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2)
-                return 0;
-
-        dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F);
-        dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F);
-        dev->touch = pkt[0] & 0x01;
-
-        return 1;
-}
-
-static int etouch_get_pkt_len(unsigned char *buf, int len)
-{
-        switch (buf[0] & ETOUCH_PKT_TYPE_MASK) {
-        case ETOUCH_PKT_TYPE_REPT:
-        case ETOUCH_PKT_TYPE_REPT2:
-                return 5;
-
-        case ETOUCH_PKT_TYPE_DIAG:
-                if (len < 2)
-                        return -1;
-
-                return buf[1] + 2;
-        }
-
-        return 0;
-}
-#endif
 
 /*****************************************************************************
  * PanJit Part
@@ -465,9 +368,8 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
                               MTOUCHUSB_RESET,
                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                               1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
-        dev_dbg(&usbtouch->interface->dev,
-                "%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n",
-                __func__, ret);
+        dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
+            __func__, ret);
         if (ret < 0)
                 return ret;
         msleep(150);
@@ -477,9 +379,8 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
                                       MTOUCHUSB_ASYNC_REPORT,
                                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                                       1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
-                dev_dbg(&usbtouch->interface->dev,
-                        "%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n",
-                        __func__, ret);
+                dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
+                    __func__, ret);
                 if (ret >= 0)
                         break;
                 if (ret != -EPIPE)
@@ -779,29 +680,27 @@ static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
-        struct usb_interface *intf = dev->interface;
-
         switch (pkt[0]) {
         case 0x3A: /* command response */
-                dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]);
+                dbg("%s: Command response %d", __func__, pkt[1]);
                 break;
 
         case 0xC0: /* down */
                 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
                 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
                 dev->touch = 1;
-                dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y);
+                dbg("%s: down %d,%d", __func__, dev->x, dev->y);
                 return 1;
 
         case 0x80: /* up */
                 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
                 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
                 dev->touch = 0;
-                dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y);
+                dbg("%s: up %d,%d", __func__, dev->x, dev->y);
                 return 1;
 
         default:
-                dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]);
+                dbg("%s: Unknown return %d", __func__, pkt[0]);
                 break;
         }
 
@@ -856,8 +755,7 @@ static int nexio_alloc(struct usbtouch_usb *usbtouch)
 
         priv->ack = usb_alloc_urb(0, GFP_KERNEL);
         if (!priv->ack) {
-                dev_dbg(&usbtouch->interface->dev,
-                        "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__);
+                dbg("%s - usb_alloc_urb failed: usbtouch->ack", __func__);
                 goto err_ack_buf;
         }
 
@@ -1047,24 +945,6 @@ static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
 
 
 /*****************************************************************************
- * ELO part
- */
-
-#ifdef CONFIG_TOUCHSCREEN_USB_ELO
-
-static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
-{
-        dev->x = (pkt[3] << 8) | pkt[2];
-        dev->y = (pkt[5] << 8) | pkt[4];
-        dev->touch = pkt[6] > 0;
-        dev->press = pkt[6];
-
-        return 1;
-}
-#endif
-
-
-/*****************************************************************************
  * the different device descriptors
  */
 #ifdef MULTI_PACKET
@@ -1073,18 +953,6 @@ static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
 #endif
 
 static struct usbtouch_device_info usbtouch_dev_info[] = {
-#ifdef CONFIG_TOUCHSCREEN_USB_ELO
-        [DEVTYPE_ELO] = {
-                .min_xc         = 0x0,
-                .max_xc         = 0x0fff,
-                .min_yc         = 0x0,
-                .max_yc         = 0x0fff,
-                .max_press      = 0xff,
-                .rept_size      = 8,
-                .read_data      = elo_read_data,
-        },
-#endif
-
 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
         [DEVTYPE_EGALAX] = {
                 .min_xc         = 0x0,
@@ -1095,7 +963,6 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                 .process_pkt    = usbtouch_process_multi,
                 .get_pkt_len    = egalax_get_pkt_len,
                 .read_data      = egalax_read_data,
-                .init           = egalax_init,
         },
 #endif
 
@@ -1272,18 +1139,6 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                 .exit           = nexio_exit,
         },
 #endif
-#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
-        [DEVTYPE_ETOUCH] = {
-                .min_xc         = 0x0,
-                .max_xc         = 0x07ff,
-                .min_yc         = 0x0,
-                .max_yc         = 0x07ff,
-                .rept_size      = 16,
-                .process_pkt    = usbtouch_process_multi,
-                .get_pkt_len    = etouch_get_pkt_len,
-                .read_data      = etouch_read_data,
-        },
-#endif
 };
 
 
@@ -1395,7 +1250,6 @@ out_flush_buf:
 static void usbtouch_irq(struct urb *urb)
 {
         struct usbtouch_usb *usbtouch = urb->context;
-        struct device *dev = &usbtouch->interface->dev;
         int retval;
 
         switch (urb->status) {
@@ -1404,21 +1258,20 @@ static void usbtouch_irq(struct urb *urb)
                 break;
         case -ETIME:
                 /* this urb is timing out */
-                dev_dbg(dev,
-                        "%s - urb timed out - was the device unplugged?\n",
-                        __func__);
+                dbg("%s - urb timed out - was the device unplugged?",
+                    __func__);
                 return;
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
         case -EPIPE:
                 /* this urb is terminated, clean up */
-                dev_dbg(dev, "%s - urb shutting down with status: %d\n",
-                        __func__, urb->status);
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, urb->status);
                 return;
         default:
-                dev_dbg(dev, "%s - nonzero urb status received: %d\n",
-                        __func__, urb->status);
+                dbg("%s - nonzero urb status received: %d",
+                    __func__, urb->status);
                 goto exit;
         }
 
@@ -1428,8 +1281,8 @@ exit:
         usb_mark_last_busy(interface_to_usbdev(usbtouch->interface));
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                dev_err(dev, "%s - usb_submit_urb failed with result: %d\n",
-                        __func__, retval);
+                err("%s - usb_submit_urb failed with result: %d",
+                    __func__, retval);
 }
 
 static int usbtouch_open(struct input_dev *input)
@@ -1504,9 +1357,8 @@ static int usbtouch_reset_resume(struct usb_interface *intf)
         if (usbtouch->type->init) {
                 err = usbtouch->type->init(usbtouch);
                 if (err) {
-                        dev_dbg(&intf->dev,
-                                "%s - type->init() failed, err: %d\n",
-                                __func__, err);
+                        dbg("%s - type->init() failed, err: %d",
+                            __func__, err);
                         return err;
                 }
         }
@@ -1581,8 +1433,7 @@ static int usbtouch_probe(struct usb_interface *intf,
 
         usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
         if (!usbtouch->irq) {
-                dev_dbg(&intf->dev,
-                        "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__);
+                dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
                 goto out_free_buffers;
         }
 
@@ -1644,9 +1495,7 @@ static int usbtouch_probe(struct usb_interface *intf,
         if (type->alloc) {
                 err = type->alloc(usbtouch);
                 if (err) {
-                        dev_dbg(&intf->dev,
-                                "%s - type->alloc() failed, err: %d\n",
-                                __func__, err);
+                        dbg("%s - type->alloc() failed, err: %d", __func__, err);
                         goto out_free_urb;
                 }
         }
@@ -1655,18 +1504,14 @@ static int usbtouch_probe(struct usb_interface *intf,
         if (type->init) {
                 err = type->init(usbtouch);
                 if (err) {
-                        dev_dbg(&intf->dev,
-                                "%s - type->init() failed, err: %d\n",
-                                __func__, err);
+                        dbg("%s - type->init() failed, err: %d", __func__, err);
                         goto out_do_exit;
                 }
         }
 
         err = input_register_device(usbtouch->input);
         if (err) {
-                dev_dbg(&intf->dev,
-                        "%s - input_register_device failed, err: %d\n",
-                        __func__, err);
+                dbg("%s - input_register_device failed, err: %d", __func__, err);
                 goto out_do_exit;
         }
 
@@ -1678,9 +1523,8 @@ static int usbtouch_probe(struct usb_interface *intf,
                 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL);
                 if (err) {
                         usb_autopm_put_interface(intf);
-                        dev_err(&intf->dev,
-                                "%s - usb_submit_urb failed with result: %d\n",
-                                __func__, err);
+                        err("%s - usb_submit_urb failed with result: %d",
+                            __func__, err);
                         goto out_unregister_input;
                 }
         }
@@ -1707,12 +1551,12 @@ static void usbtouch_disconnect(struct usb_interface *intf)
 {
         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
 
+        dbg("%s - called", __func__);
+
         if (!usbtouch)
                 return;
 
-        dev_dbg(&intf->dev,
-                "%s - usbtouch is initialized, cleaning up\n", __func__);
-
+        dbg("%s - usbtouch is initialized, cleaning up", __func__);
         usb_set_intfdata(intf, NULL);
         /* this will stop IO via close */
         input_unregister_device(usbtouch->input);
@@ -1736,7 +1580,18 @@ static struct usb_driver usbtouch_driver = {
         .supports_autosuspend = 1,
 };
 
-module_usb_driver(usbtouch_driver);
+static int __init usbtouch_init(void)
+{
+        return usb_register(&usbtouch_driver);
+}
+
+static void __exit usbtouch_cleanup(void)
+{
+        usb_deregister(&usbtouch_driver);
+}
+
+module_init(usbtouch_init);
+module_exit(usbtouch_cleanup);
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/input/touchscreen/w90p910_ts.c b/drivers/input/touchscreen/w90p910_ts.c
index d2ef8f05c66..7a45d68c351 100644
--- a/drivers/input/touchscreen/w90p910_ts.c
+++ b/drivers/input/touchscreen/w90p910_ts.c
@@ -215,7 +215,7 @@ static void w90p910_close(struct input_dev *dev)
         clk_disable(w90p910_ts->clk);
 }
 
-static int w90x900ts_probe(struct platform_device *pdev)
+static int __devinit w90x900ts_probe(struct platform_device *pdev)
 {
         struct w90p910_ts *w90p910_ts;
         struct input_dev *input_dev;
@@ -279,7 +279,7 @@ static int w90x900ts_probe(struct platform_device *pdev)
 
         w90p910_ts->irq_num = platform_get_irq(pdev, 0);
         if (request_irq(w90p910_ts->irq_num, w90p910_ts_interrupt,
-                        0, "w90p910ts", w90p910_ts)) {
+                        IRQF_DISABLED, "w90p910ts", w90p910_ts)) {
                 err = -EBUSY;
                 goto fail4;
         }
@@ -301,7 +301,7 @@ fail1:	input_free_device(input_dev);
         return err;
 }
 
-static int w90x900ts_remove(struct platform_device *pdev)
+static int __devexit w90x900ts_remove(struct platform_device *pdev)
 {
         struct w90p910_ts *w90p910_ts = platform_get_drvdata(pdev);
         struct resource *res;
@@ -325,13 +325,25 @@ static int w90x900ts_remove(struct platform_device *pdev)
 
 static struct platform_driver w90x900ts_driver = {
         .probe          = w90x900ts_probe,
-        .remove         = w90x900ts_remove,
+        .remove         = __devexit_p(w90x900ts_remove),
         .driver         = {
                 .name   = "nuc900-ts",
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(w90x900ts_driver);
+
+static int __init w90x900ts_init(void)
+{
+        return platform_driver_register(&w90x900ts_driver);
+}
+
+static void __exit w90x900ts_exit(void)
+{
+        platform_driver_unregister(&w90x900ts_driver);
+}
+
+module_init(w90x900ts_init);
+module_exit(w90x900ts_exit);
 
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("w90p910 touch screen driver!");
diff --git a/drivers/input/touchscreen/wacom_i2c.c b/drivers/input/touchscreen/wacom_i2c.c
deleted file mode 100644
index bf0d07620ba..00000000000
--- a/drivers/input/touchscreen/wacom_i2c.c
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * Wacom Penabled Driver for I2C
- *
- * Copyright (c) 2011 Tatsunosuke Tobita, Wacom.
- * <tobita.tatsunosuke@wacom.co.jp>
- *
- * 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 of 2 of the License,
- * or (at your option) any later version.
- */
-
-#include <linux/module.h>
-#include <linux/input.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/interrupt.h>
-#include <linux/gpio.h>
-#include <asm/unaligned.h>
-
-#define WACOM_CMD_QUERY0        0x04
-#define WACOM_CMD_QUERY1        0x00
-#define WACOM_CMD_QUERY2        0x33
-#define WACOM_CMD_QUERY3        0x02
-#define WACOM_CMD_THROW0        0x05
-#define WACOM_CMD_THROW1        0x00
-#define WACOM_QUERY_SIZE        19
-#define WACOM_RETRY_CNT         100
-
-struct wacom_features {
-        int x_max;
-        int y_max;
-        int pressure_max;
-        char fw_version;
-};
-
-struct wacom_i2c {
-        struct i2c_client *client;
-        struct input_dev *input;
-        u8 data[WACOM_QUERY_SIZE];
-};
-
-static int wacom_query_device(struct i2c_client *client,
-                              struct wacom_features *features)
-{
-        int ret;
-        u8 cmd1[] = { WACOM_CMD_QUERY0, WACOM_CMD_QUERY1,
-                        WACOM_CMD_QUERY2, WACOM_CMD_QUERY3 };
-        u8 cmd2[] = { WACOM_CMD_THROW0, WACOM_CMD_THROW1 };
-        u8 data[WACOM_QUERY_SIZE];
-        struct i2c_msg msgs[] = {
-                {
-                        .addr = client->addr,
-                        .flags = 0,
-                        .len = sizeof(cmd1),
-                        .buf = cmd1,
-                },
-                {
-                        .addr = client->addr,
-                        .flags = 0,
-                        .len = sizeof(cmd2),
-                        .buf = cmd2,
-                },
-                {
-                        .addr = client->addr,
-                        .flags = I2C_M_RD,
-                        .len = sizeof(data),
-                        .buf = data,
-                },
-        };
-
-        ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (ret < 0)
-                return ret;
-        if (ret != ARRAY_SIZE(msgs))
-                return -EIO;
-
-        features->x_max = get_unaligned_le16(&data[3]);
-        features->y_max = get_unaligned_le16(&data[5]);
-        features->pressure_max = get_unaligned_le16(&data[11]);
-        features->fw_version = get_unaligned_le16(&data[13]);
-
-        dev_dbg(&client->dev,
-                "x_max:%d, y_max:%d, pressure:%d, fw:%d\n",
-                features->x_max, features->y_max,
-                features->pressure_max, features->fw_version);
-
-        return 0;
-}
-
-static irqreturn_t wacom_i2c_irq(int irq, void *dev_id)
-{
-        struct wacom_i2c *wac_i2c = dev_id;
-        struct input_dev *input = wac_i2c->input;
-        u8 *data = wac_i2c->data;
-        unsigned int x, y, pressure;
-        unsigned char tsw, f1, f2, ers;
-        int error;
-
-        error = i2c_master_recv(wac_i2c->client,
-                                wac_i2c->data, sizeof(wac_i2c->data));
-        if (error < 0)
-                goto out;
-
-        tsw = data[3] & 0x01;
-        ers = data[3] & 0x04;
-        f1 = data[3] & 0x02;
-        f2 = data[3] & 0x10;
-        x = le16_to_cpup((__le16 *)&data[4]);
-        y = le16_to_cpup((__le16 *)&data[6]);
-        pressure = le16_to_cpup((__le16 *)&data[8]);
-
-        input_report_key(input, BTN_TOUCH, tsw || ers);
-        input_report_key(input, BTN_TOOL_PEN, tsw);
-        input_report_key(input, BTN_TOOL_RUBBER, ers);
-        input_report_key(input, BTN_STYLUS, f1);
-        input_report_key(input, BTN_STYLUS2, f2);
-        input_report_abs(input, ABS_X, x);
-        input_report_abs(input, ABS_Y, y);
-        input_report_abs(input, ABS_PRESSURE, pressure);
-        input_sync(input);
-
-out:
-        return IRQ_HANDLED;
-}
-
-static int wacom_i2c_open(struct input_dev *dev)
-{
-        struct wacom_i2c *wac_i2c = input_get_drvdata(dev);
-        struct i2c_client *client = wac_i2c->client;
-
-        enable_irq(client->irq);
-
-        return 0;
-}
-
-static void wacom_i2c_close(struct input_dev *dev)
-{
-        struct wacom_i2c *wac_i2c = input_get_drvdata(dev);
-        struct i2c_client *client = wac_i2c->client;
-
-        disable_irq(client->irq);
-}
-
-static int wacom_i2c_probe(struct i2c_client *client,
-                                     const struct i2c_device_id *id)
-{
-        struct wacom_i2c *wac_i2c;
-        struct input_dev *input;
-        struct wacom_features features = { 0 };
-        int error;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                dev_err(&client->dev, "i2c_check_functionality error\n");
-                return -EIO;
-        }
-
-        error = wacom_query_device(client, &features);
-        if (error)
-                return error;
-
-        wac_i2c = kzalloc(sizeof(*wac_i2c), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!wac_i2c || !input) {
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        wac_i2c->client = client;
-        wac_i2c->input = input;
-
-        input->name = "Wacom I2C Digitizer";
-        input->id.bustype = BUS_I2C;
-        input->id.vendor = 0x56a;
-        input->id.version = features.fw_version;
-        input->dev.parent = &client->dev;
-        input->open = wacom_i2c_open;
-        input->close = wacom_i2c_close;
-
-        input->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-
-        __set_bit(BTN_TOOL_PEN, input->keybit);
-        __set_bit(BTN_TOOL_RUBBER, input->keybit);
-        __set_bit(BTN_STYLUS, input->keybit);
-        __set_bit(BTN_STYLUS2, input->keybit);
-        __set_bit(BTN_TOUCH, input->keybit);
-
-        input_set_abs_params(input, ABS_X, 0, features.x_max, 0, 0);
-        input_set_abs_params(input, ABS_Y, 0, features.y_max, 0, 0);
-        input_set_abs_params(input, ABS_PRESSURE,
-                             0, features.pressure_max, 0, 0);
-
-        input_set_drvdata(input, wac_i2c);
-
-        error = request_threaded_irq(client->irq, NULL, wacom_i2c_irq,
-                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                     "wacom_i2c", wac_i2c);
-        if (error) {
-                dev_err(&client->dev,
-                        "Failed to enable IRQ, error: %d\n", error);
-                goto err_free_mem;
-        }
-
-        /* Disable the IRQ, we'll enable it in wac_i2c_open() */
-        disable_irq(client->irq);
-
-        error = input_register_device(wac_i2c->input);
-        if (error) {
-                dev_err(&client->dev,
-                        "Failed to register input device, error: %d\n", error);
-                goto err_free_irq;
-        }
-
-        i2c_set_clientdata(client, wac_i2c);
-        return 0;
-
-err_free_irq:
-        free_irq(client->irq, wac_i2c);
-err_free_mem:
-        input_free_device(input);
-        kfree(wac_i2c);
-
-        return error;
-}
-
-static int wacom_i2c_remove(struct i2c_client *client)
-{
-        struct wacom_i2c *wac_i2c = i2c_get_clientdata(client);
-
-        free_irq(client->irq, wac_i2c);
-        input_unregister_device(wac_i2c->input);
-        kfree(wac_i2c);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int wacom_i2c_suspend(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        disable_irq(client->irq);
-
-        return 0;
-}
-
-static int wacom_i2c_resume(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-
-        enable_irq(client->irq);
-
-        return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(wacom_i2c_pm, wacom_i2c_suspend, wacom_i2c_resume);
-
-static const struct i2c_device_id wacom_i2c_id[] = {
-        { "WAC_I2C_EMR", 0 },
-        { },
-};
-MODULE_DEVICE_TABLE(i2c, wacom_i2c_id);
-
-static struct i2c_driver wacom_i2c_driver = {
-        .driver = {
-                .name   = "wacom_i2c",
-                .owner  = THIS_MODULE,
-                .pm     = &wacom_i2c_pm,
-        },
-
-        .probe          = wacom_i2c_probe,
-        .remove         = wacom_i2c_remove,
-        .id_table       = wacom_i2c_id,
-};
-module_i2c_driver(wacom_i2c_driver);
-
-MODULE_AUTHOR("Tatsunosuke Tobita <tobita.tatsunosuke@wacom.co.jp>");
-MODULE_DESCRIPTION("WACOM EMR I2C Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index 9a83be6b658..9941d39df43 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -367,20 +367,6 @@ static int w8001_command(struct w8001 *w8001, unsigned char command,
         return rc;
 }
 
-static int w8001_open(struct input_dev *dev)
-{
-        struct w8001 *w8001 = input_get_drvdata(dev);
-
-        return w8001_command(w8001, W8001_CMD_START, false);
-}
-
-static void w8001_close(struct input_dev *dev)
-{
-        struct w8001 *w8001 = input_get_drvdata(dev);
-
-        w8001_command(w8001, W8001_CMD_STOP, false);
-}
-
 static int w8001_setup(struct w8001 *w8001)
 {
         struct input_dev *dev = w8001->dev;
@@ -471,7 +457,7 @@ static int w8001_setup(struct w8001 *w8001)
                 case 5:
                         w8001->pktlen = W8001_PKTLEN_TOUCH2FG;
 
-                        input_mt_init_slots(dev, 2, 0);
+                        input_mt_init_slots(dev, 2);
                         input_set_abs_params(dev, ABS_MT_POSITION_X,
                                                 0, touch.x, 0, 0);
                         input_set_abs_params(dev, ABS_MT_POSITION_Y,
@@ -490,7 +476,7 @@ static int w8001_setup(struct w8001 *w8001)
 
         strlcat(w8001->name, " Touchscreen", sizeof(w8001->name));
 
-        return 0;
+        return w8001_command(w8001, W8001_CMD_START, false);
 }
 
 /*
@@ -501,12 +487,12 @@ static void w8001_disconnect(struct serio *serio)
 {
         struct w8001 *w8001 = serio_get_drvdata(serio);
 
-        serio_close(serio);
-
+        input_get_device(w8001->dev);
         input_unregister_device(w8001->dev);
-        kfree(w8001);
-
+        serio_close(serio);
         serio_set_drvdata(serio, NULL);
+        input_put_device(w8001->dev);
+        kfree(w8001);
 }
 
 /*
@@ -550,11 +536,6 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         input_dev->id.version = 0x0100;
         input_dev->dev.parent = &serio->dev;
 
-        input_dev->open = w8001_open;
-        input_dev->close = w8001_close;
-
-        input_set_drvdata(input_dev, w8001);
-
         err = input_register_device(w8001->dev);
         if (err)
                 goto fail3;
@@ -594,4 +575,15 @@ static struct serio_driver w8001_drv = {
         .disconnect     = w8001_disconnect,
 };
 
-module_serio_driver(w8001_drv);
+static int __init w8001_init(void)
+{
+        return serio_register_driver(&w8001_drv);
+}
+
+static void __exit w8001_exit(void)
+{
+        serio_unregister_driver(&w8001_drv);
+}
+
+module_init(w8001_init);
+module_exit(w8001_exit);
diff --git a/drivers/input/touchscreen/wm831x-ts.c b/drivers/input/touchscreen/wm831x-ts.c
index f88fab56178..9175d49d254 100644
--- a/drivers/input/touchscreen/wm831x-ts.c
+++ b/drivers/input/touchscreen/wm831x-ts.c
@@ -221,7 +221,7 @@ static void wm831x_ts_input_close(struct input_dev *idev)
         synchronize_irq(wm831x_ts->pd_irq);
 
         /* Make sure the IRQ completion work is quiesced */
-        flush_work(&wm831x_ts->pd_data_work);
+        flush_work_sync(&wm831x_ts->pd_data_work);
 
         /* If we ended up with the pen down then make sure we revert back
          * to pen detection state for the next time we start up.
@@ -233,7 +233,7 @@ static void wm831x_ts_input_close(struct input_dev *idev)
         }
 }
 
-static int wm831x_ts_probe(struct platform_device *pdev)
+static __devinit int wm831x_ts_probe(struct platform_device *pdev)
 {
         struct wm831x_ts *wm831x_ts;
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
@@ -245,8 +245,7 @@ static int wm831x_ts_probe(struct platform_device *pdev)
         if (core_pdata)
                 pdata = core_pdata->touch;
 
-        wm831x_ts = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ts),
-                                 GFP_KERNEL);
+        wm831x_ts = kzalloc(sizeof(struct wm831x_ts), GFP_KERNEL);
         input_dev = input_allocate_device();
         if (!wm831x_ts || !input_dev) {
                 error = -ENOMEM;
@@ -261,16 +260,15 @@ static int wm831x_ts_probe(struct platform_device *pdev)
          * If we have a direct IRQ use it, otherwise use the interrupt
          * from the WM831x IRQ controller.
          */
-        wm831x_ts->data_irq = wm831x_irq(wm831x,
-                                         platform_get_irq_byname(pdev,
-                                                                 "TCHDATA"));
         if (pdata && pdata->data_irq)
                 wm831x_ts->data_irq = pdata->data_irq;
+        else
+                wm831x_ts->data_irq = platform_get_irq_byname(pdev, "TCHDATA");
 
-        wm831x_ts->pd_irq = wm831x_irq(wm831x,
-                                       platform_get_irq_byname(pdev, "TCHPD"));
         if (pdata && pdata->pd_irq)
                 wm831x_ts->pd_irq = pdata->pd_irq;
+        else
+                wm831x_ts->pd_irq = platform_get_irq_byname(pdev, "TCHPD");
 
         if (pdata)
                 wm831x_ts->pressure = pdata->pressure;
@@ -377,18 +375,21 @@ err_data_irq:
         free_irq(wm831x_ts->data_irq, wm831x_ts);
 err_alloc:
         input_free_device(input_dev);
+        kfree(wm831x_ts);
 
         return error;
 }
 
-static int wm831x_ts_remove(struct platform_device *pdev)
+static __devexit int wm831x_ts_remove(struct platform_device *pdev)
 {
         struct wm831x_ts *wm831x_ts = platform_get_drvdata(pdev);
 
         free_irq(wm831x_ts->pd_irq, wm831x_ts);
         free_irq(wm831x_ts->data_irq, wm831x_ts);
         input_unregister_device(wm831x_ts->input_dev);
+        kfree(wm831x_ts);
 
+        platform_set_drvdata(pdev, NULL);
         return 0;
 }
 
@@ -398,9 +399,20 @@ static struct platform_driver wm831x_ts_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = wm831x_ts_probe,
-        .remove = wm831x_ts_remove,
+        .remove = __devexit_p(wm831x_ts_remove),
 };
-module_platform_driver(wm831x_ts_driver);
+
+static int __init wm831x_ts_init(void)
+{
+        return platform_driver_register(&wm831x_ts_driver);
+}
+module_init(wm831x_ts_init);
+
+static void __exit wm831x_ts_exit(void)
+{
+        platform_driver_unregister(&wm831x_ts_driver);
+}
+module_exit(wm831x_ts_exit);
 
 /* Module information */
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/drivers/input/touchscreen/zylonite-wm97xx.c b/drivers/input/touchscreen/zylonite-wm97xx.c
index bf0869a7a78..f6328c0cded 100644
--- a/drivers/input/touchscreen/zylonite-wm97xx.c
+++ b/drivers/input/touchscreen/zylonite-wm97xx.c
@@ -22,7 +22,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/gpio.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
@@ -193,8 +192,8 @@ static int zylonite_wm97xx_probe(struct platform_device *pdev)
         else
                 gpio_touch_irq = mfp_to_gpio(MFP_PIN_GPIO26);
 
-        wm->pen_irq = gpio_to_irq(gpio_touch_irq);
-        irq_set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
+        wm->pen_irq = IRQ_GPIO(gpio_touch_irq);
+        irq_set_irq_type(IRQ_GPIO(gpio_touch_irq), IRQ_TYPE_EDGE_BOTH);
 
         wm97xx_config_gpio(wm, WM97XX_GPIO_13, WM97XX_GPIO_IN,
                            WM97XX_GPIO_POL_HIGH,
@@ -224,7 +223,19 @@ static struct platform_driver zylonite_wm97xx_driver = {
                 .name   = "wm97xx-touch",
         },
 };
-module_platform_driver(zylonite_wm97xx_driver);
+
+static int __init zylonite_wm97xx_init(void)
+{
+        return platform_driver_register(&zylonite_wm97xx_driver);
+}
+
+static void __exit zylonite_wm97xx_exit(void)
+{
+        platform_driver_unregister(&zylonite_wm97xx_driver);
+}
+
+module_init(zylonite_wm97xx_init);
+module_exit(zylonite_wm97xx_exit);
 
 /* Module information */
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");