Merge branch 'cec-defines' into for-linus

Let's bring in HDMI CEC defines to ease merging CEC support in the next
merge window.

8 files changed, 614 insertions, 20 deletions

diff --git a/drivers/input/input-compat.c b/drivers/input/input-compat.c
index 64ca7113ff28..d84d20b9cec0 100644
--- a/drivers/input/input-compat.c
+++ b/drivers/input/input-compat.c
@@ -17,7 +17,7 @@
 int input_event_from_user(const char __user *buffer,
                           struct input_event *event)
 {
-        if (INPUT_COMPAT_TEST && !COMPAT_USE_64BIT_TIME) {
+        if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
                 struct input_event_compat compat_event;
 
                 if (copy_from_user(&compat_event, buffer,
@@ -41,7 +41,7 @@ int input_event_from_user(const char __user *buffer,
 int input_event_to_user(char __user *buffer,
                         const struct input_event *event)
 {
-        if (INPUT_COMPAT_TEST && !COMPAT_USE_64BIT_TIME) {
+        if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
                 struct input_event_compat compat_event;
 
                 compat_event.time.tv_sec = event->time.tv_sec;
@@ -65,7 +65,7 @@ int input_event_to_user(char __user *buffer,
 int input_ff_effect_from_user(const char __user *buffer, size_t size,
                               struct ff_effect *effect)
 {
-        if (INPUT_COMPAT_TEST) {
+        if (in_compat_syscall()) {
                 struct ff_effect_compat *compat_effect;
 
                 if (size != sizeof(struct ff_effect_compat))
diff --git a/drivers/input/input-compat.h b/drivers/input/input-compat.h
index 148f66fe3205..1563160a7af3 100644
--- a/drivers/input/input-compat.h
+++ b/drivers/input/input-compat.h
@@ -17,18 +17,6 @@
 
 #ifdef CONFIG_COMPAT
 
-/* Note to the author of this code: did it ever occur to
-   you why the ifdefs are needed? Think about it again. -AK */
-#if defined(CONFIG_X86_64) || defined(CONFIG_TILE)
-#  define INPUT_COMPAT_TEST is_compat_task()
-#elif defined(CONFIG_S390)
-#  define INPUT_COMPAT_TEST test_thread_flag(TIF_31BIT)
-#elif defined(CONFIG_MIPS)
-#  define INPUT_COMPAT_TEST test_thread_flag(TIF_32BIT_ADDR)
-#else
-#  define INPUT_COMPAT_TEST test_thread_flag(TIF_32BIT)
-#endif
-
 struct input_event_compat {
         struct compat_timeval time;
         __u16 type;
@@ -67,7 +55,7 @@ struct ff_effect_compat {
 
 static inline size_t input_event_size(void)
 {
-        return (INPUT_COMPAT_TEST && !COMPAT_USE_64BIT_TIME) ?
+        return (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) ?
                 sizeof(struct input_event_compat) : sizeof(struct input_event);
 }
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 880605959aa6..b87ffbd4547d 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -1015,7 +1015,7 @@ static int input_bits_to_string(char *buf, int buf_size,
 {
         int len = 0;
 
-        if (INPUT_COMPAT_TEST) {
+        if (in_compat_syscall()) {
                 u32 dword = bits >> 32;
                 if (dword || !skip_empty)
                         len += snprintf(buf, buf_size, "%x ", dword);
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 79338f4bdecb..65ebbd111702 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -664,7 +664,7 @@ struct uinput_ff_upload_compat {
 static int uinput_ff_upload_to_user(char __user *buffer,
                                     const struct uinput_ff_upload *ff_up)
 {
-        if (INPUT_COMPAT_TEST) {
+        if (in_compat_syscall()) {
                 struct uinput_ff_upload_compat ff_up_compat;
 
                 ff_up_compat.request_id = ff_up->request_id;
@@ -695,7 +695,7 @@ static int uinput_ff_upload_to_user(char __user *buffer,
 static int uinput_ff_upload_from_user(const char __user *buffer,
                                       struct uinput_ff_upload *ff_up)
 {
-        if (INPUT_COMPAT_TEST) {
+        if (in_compat_syscall()) {
                 struct uinput_ff_upload_compat ff_up_compat;
 
                 if (copy_from_user(&ff_up_compat, buffer,
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 1f99e7f30e27..8ecdc38fd489 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -833,6 +833,15 @@ config TOUCHSCREEN_USB_COMPOSITE
           To compile this driver as a module, choose M here: the
           module will be called usbtouchscreen.
 
+config TOUCHSCREEN_MX25
+        tristate "Freescale i.MX25 touchscreen input driver"
+        depends on MFD_MX25_TSADC
+        help
+          Enable support for touchscreen connected to your i.MX25.
+
+          To compile this driver as a module, choose M here: the
+          module will be called fsl-imx25-tcq.
+
 config TOUCHSCREEN_MC13783
         tristate "Freescale MC13783 touchscreen input driver"
         depends on MFD_MC13XXX
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 4b518c76e0d7..f42975e719e0 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_TOUCHSCREEN_INTEL_MID)	+= intel-mid-touch.o
 obj-$(CONFIG_TOUCHSCREEN_IPROC)         += bcm_iproc_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_LPC32XX)       += lpc32xx_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MAX11801)      += max11801_ts.o
+obj-$(CONFIG_TOUCHSCREEN_MX25)          += fsl-imx25-tcq.o
 obj-$(CONFIG_TOUCHSCREEN_MC13783)       += mc13783_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MCS5000)       += mcs5000_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MELFAS_MIP4)   += melfas_mip4.o
diff --git a/drivers/input/touchscreen/fsl-imx25-tcq.c b/drivers/input/touchscreen/fsl-imx25-tcq.c
new file mode 100644
index 000000000000..fe9877a6af9e
--- /dev/null
+++ b/drivers/input/touchscreen/fsl-imx25-tcq.c
@@ -0,0 +1,596 @@
+/*
+ * Copyright (C) 2014-2015 Pengutronix, Markus Pargmann <mpa@pengutronix.de>
+ *
+ * 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.
+ *
+ * Based on driver from 2011:
+ *   Juergen Beisert, Pengutronix <kernel@pengutronix.de>
+ *
+ * This is the driver for the imx25 TCQ (Touchscreen Conversion Queue)
+ * connected to the imx25 ADC.
+ */
+
+#include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/imx25-tsadc.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+
+static const char mx25_tcq_name[] = "mx25-tcq";
+
+enum mx25_tcq_mode {
+        MX25_TS_4WIRE,
+};
+
+struct mx25_tcq_priv {
+        struct regmap *regs;
+        struct regmap *core_regs;
+        struct input_dev *idev;
+        enum mx25_tcq_mode mode;
+        unsigned int pen_threshold;
+        unsigned int sample_count;
+        unsigned int expected_samples;
+        unsigned int pen_debounce;
+        unsigned int settling_time;
+        struct clk *clk;
+        int irq;
+        struct device *dev;
+};
+
+static struct regmap_config mx25_tcq_regconfig = {
+        .fast_io = true,
+        .max_register = 0x5c,
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
+};
+
+static const struct of_device_id mx25_tcq_ids[] = {
+        { .compatible = "fsl,imx25-tcq", },
+        { /* Sentinel */ }
+};
+
+#define TSC_4WIRE_PRE_INDEX 0
+#define TSC_4WIRE_X_INDEX 1
+#define TSC_4WIRE_Y_INDEX 2
+#define TSC_4WIRE_POST_INDEX 3
+#define TSC_4WIRE_LEAVE 4
+
+#define MX25_TSC_DEF_THRESHOLD 80
+#define TSC_MAX_SAMPLES 16
+
+#define MX25_TSC_REPEAT_WAIT 14
+
+enum mx25_adc_configurations {
+        MX25_CFG_PRECHARGE = 0,
+        MX25_CFG_TOUCH_DETECT,
+        MX25_CFG_X_MEASUREMENT,
+        MX25_CFG_Y_MEASUREMENT,
+};
+
+#define MX25_PRECHARGE_VALUE (\
+                        MX25_ADCQ_CFG_YPLL_OFF | \
+                        MX25_ADCQ_CFG_XNUR_OFF | \
+                        MX25_ADCQ_CFG_XPUL_HIGH | \
+                        MX25_ADCQ_CFG_REFP_INT | \
+                        MX25_ADCQ_CFG_IN_XP | \
+                        MX25_ADCQ_CFG_REFN_NGND2 | \
+                        MX25_ADCQ_CFG_IGS)
+
+#define MX25_TOUCH_DETECT_VALUE (\
+                        MX25_ADCQ_CFG_YNLR | \
+                        MX25_ADCQ_CFG_YPLL_OFF | \
+                        MX25_ADCQ_CFG_XNUR_OFF | \
+                        MX25_ADCQ_CFG_XPUL_OFF | \
+                        MX25_ADCQ_CFG_REFP_INT | \
+                        MX25_ADCQ_CFG_IN_XP | \
+                        MX25_ADCQ_CFG_REFN_NGND2 | \
+                        MX25_ADCQ_CFG_PENIACK)
+
+static void imx25_setup_queue_cfgs(struct mx25_tcq_priv *priv,
+                                   unsigned int settling_cnt)
+{
+        u32 precharge_cfg =
+                        MX25_PRECHARGE_VALUE |
+                        MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
+        u32 touch_detect_cfg =
+                        MX25_TOUCH_DETECT_VALUE |
+                        MX25_ADCQ_CFG_NOS(1) |
+                        MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
+
+        regmap_write(priv->core_regs, MX25_TSC_TICR, precharge_cfg);
+
+        /* PRECHARGE */
+        regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE),
+                     precharge_cfg);
+
+        /* TOUCH_DETECT */
+        regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_TOUCH_DETECT),
+                     touch_detect_cfg);
+
+        /* X Measurement */
+        regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT),
+                     MX25_ADCQ_CFG_YPLL_OFF |
+                     MX25_ADCQ_CFG_XNUR_LOW |
+                     MX25_ADCQ_CFG_XPUL_HIGH |
+                     MX25_ADCQ_CFG_REFP_XP |
+                     MX25_ADCQ_CFG_IN_YP |
+                     MX25_ADCQ_CFG_REFN_XN |
+                     MX25_ADCQ_CFG_NOS(priv->sample_count) |
+                     MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
+
+        /* Y Measurement */
+        regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_Y_MEASUREMENT),
+                     MX25_ADCQ_CFG_YNLR |
+                     MX25_ADCQ_CFG_YPLL_HIGH |
+                     MX25_ADCQ_CFG_XNUR_OFF |
+                     MX25_ADCQ_CFG_XPUL_OFF |
+                     MX25_ADCQ_CFG_REFP_YP |
+                     MX25_ADCQ_CFG_IN_XP |
+                     MX25_ADCQ_CFG_REFN_YN |
+                     MX25_ADCQ_CFG_NOS(priv->sample_count) |
+                     MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
+
+        /* Enable the touch detection right now */
+        regmap_write(priv->core_regs, MX25_TSC_TICR, touch_detect_cfg |
+                     MX25_ADCQ_CFG_IGS);
+}
+
+static int imx25_setup_queue_4wire(struct mx25_tcq_priv *priv,
+                                   unsigned settling_cnt, int *items)
+{
+        imx25_setup_queue_cfgs(priv, settling_cnt);
+
+        /* Setup the conversion queue */
+        regmap_write(priv->regs, MX25_ADCQ_ITEM_7_0,
+                     MX25_ADCQ_ITEM(0, MX25_CFG_PRECHARGE) |
+                     MX25_ADCQ_ITEM(1, MX25_CFG_TOUCH_DETECT) |
+                     MX25_ADCQ_ITEM(2, MX25_CFG_X_MEASUREMENT) |
+                     MX25_ADCQ_ITEM(3, MX25_CFG_Y_MEASUREMENT) |
+                     MX25_ADCQ_ITEM(4, MX25_CFG_PRECHARGE) |
+                     MX25_ADCQ_ITEM(5, MX25_CFG_TOUCH_DETECT));
+
+        /*
+         * We measure X/Y with 'sample_count' number of samples and execute a
+         * touch detection twice, with 1 sample each
+         */
+        priv->expected_samples = priv->sample_count * 2 + 2;
+        *items = 6;
+
+        return 0;
+}
+
+static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK,
+                           MX25_ADCQ_CR_PDMSK);
+}
+
+static void mx25_tcq_enable_touch_irq(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, 0);
+}
+
+static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ,
+                           MX25_ADCQ_MR_FDRY_IRQ);
+}
+
+static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, 0);
+}
+
+static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR,
+                           MX25_ADCQ_CR_FQS,
+                           MX25_ADCQ_CR_FQS);
+}
+
+static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv)
+{
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR,
+                           MX25_ADCQ_CR_FQS, 0);
+}
+
+static void mx25_tcq_fifo_reset(struct mx25_tcq_priv *priv)
+{
+        u32 tcqcr;
+
+        regmap_read(priv->regs, MX25_ADCQ_CR, &tcqcr);
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST,
+                           MX25_ADCQ_CR_FRST);
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, 0);
+        regmap_write(priv->regs, MX25_ADCQ_CR, tcqcr);
+}
+
+static void mx25_tcq_re_enable_touch_detection(struct mx25_tcq_priv *priv)
+{
+        /* stop the queue from looping */
+        mx25_tcq_force_queue_stop(priv);
+
+        /* for a clean touch detection, preload the X plane */
+        regmap_write(priv->core_regs, MX25_TSC_TICR, MX25_PRECHARGE_VALUE);
+
+        /* waste some time now to pre-load the X plate to high voltage */
+        mx25_tcq_fifo_reset(priv);
+
+        /* re-enable the detection right now */
+        regmap_write(priv->core_regs, MX25_TSC_TICR,
+                     MX25_TOUCH_DETECT_VALUE | MX25_ADCQ_CFG_IGS);
+
+        regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_PD,
+                           MX25_ADCQ_SR_PD);
+
+        /* enable the pen down event to be a source for the interrupt */
+        regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_PD_IRQ, 0);
+
+        /* lets fire the next IRQ if someone touches the touchscreen */
+        mx25_tcq_enable_touch_irq(priv);
+}
+
+static void mx25_tcq_create_event_for_4wire(struct mx25_tcq_priv *priv,
+                                            u32 *sample_buf,
+                                            unsigned int samples)
+{
+        unsigned int x_pos = 0;
+        unsigned int y_pos = 0;
+        unsigned int touch_pre = 0;
+        unsigned int touch_post = 0;
+        unsigned int i;
+
+        for (i = 0; i < samples; i++) {
+                unsigned int index = MX25_ADCQ_FIFO_ID(sample_buf[i]);
+                unsigned int val = MX25_ADCQ_FIFO_DATA(sample_buf[i]);
+
+                switch (index) {
+                case 1:
+                        touch_pre = val;
+                        break;
+                case 2:
+                        x_pos = val;
+                        break;
+                case 3:
+                        y_pos = val;
+                        break;
+                case 5:
+                        touch_post = val;
+                        break;
+                default:
+                        dev_dbg(priv->dev, "Dropped samples because of invalid index %d\n",
+                                index);
+                        return;
+                }
+        }
+
+        if (samples != 0) {
+                /*
+                 * only if both touch measures are below a threshold,
+                 * the position is valid
+                 */
+                if (touch_pre < priv->pen_threshold &&
+                    touch_post < priv->pen_threshold) {
+                        /* valid samples, generate a report */
+                        x_pos /= priv->sample_count;
+                        y_pos /= priv->sample_count;
+                        input_report_abs(priv->idev, ABS_X, x_pos);
+                        input_report_abs(priv->idev, ABS_Y, y_pos);
+                        input_report_key(priv->idev, BTN_TOUCH, 1);
+                        input_sync(priv->idev);
+
+                        /* get next sample */
+                        mx25_tcq_enable_fifo_irq(priv);
+                } else if (touch_pre >= priv->pen_threshold &&
+                           touch_post >= priv->pen_threshold) {
+                        /*
+                         * if both samples are invalid,
+                         * generate a release report
+                         */
+                        input_report_key(priv->idev, BTN_TOUCH, 0);
+                        input_sync(priv->idev);
+                        mx25_tcq_re_enable_touch_detection(priv);
+                } else {
+                        /*
+                         * if only one of both touch measurements are
+                         * below the threshold, still some bouncing
+                         * happens. Take additional samples in this
+                         * case to be sure
+                         */
+                        mx25_tcq_enable_fifo_irq(priv);
+                }
+        }
+}
+
+static irqreturn_t mx25_tcq_irq_thread(int irq, void *dev_id)
+{
+        struct mx25_tcq_priv *priv = dev_id;
+        u32 sample_buf[TSC_MAX_SAMPLES];
+        unsigned int samples;
+        u32 stats;
+        unsigned int i;
+
+        /*
+         * Check how many samples are available. We always have to read exactly
+         * sample_count samples from the fifo, or a multiple of sample_count.
+         * Otherwise we mixup samples into different touch events.
+         */
+        regmap_read(priv->regs, MX25_ADCQ_SR, &stats);
+        samples = MX25_ADCQ_SR_FDN(stats);
+        samples -= samples % priv->sample_count;
+
+        if (!samples)
+                return IRQ_HANDLED;
+
+        for (i = 0; i != samples; ++i)
+                regmap_read(priv->regs, MX25_ADCQ_FIFO, &sample_buf[i]);
+
+        mx25_tcq_create_event_for_4wire(priv, sample_buf, samples);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t mx25_tcq_irq(int irq, void *dev_id)
+{
+        struct mx25_tcq_priv *priv = dev_id;
+        u32 stat;
+        int ret = IRQ_HANDLED;
+
+        regmap_read(priv->regs, MX25_ADCQ_SR, &stat);
+
+        if (stat & (MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR))
+                mx25_tcq_re_enable_touch_detection(priv);
+
+        if (stat & MX25_ADCQ_SR_PD) {
+                mx25_tcq_disable_touch_irq(priv);
+                mx25_tcq_force_queue_start(priv);
+                mx25_tcq_enable_fifo_irq(priv);
+        }
+
+        if (stat & MX25_ADCQ_SR_FDRY) {
+                mx25_tcq_disable_fifo_irq(priv);
+                ret = IRQ_WAKE_THREAD;
+        }
+
+        regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_FRR |
+                           MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR |
+                           MX25_ADCQ_SR_PD,
+                           MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR |
+                           MX25_ADCQ_SR_FOR | MX25_ADCQ_SR_PD);
+
+        return ret;
+}
+
+/* configure the state machine for a 4-wire touchscreen */
+static int mx25_tcq_init(struct mx25_tcq_priv *priv)
+{
+        u32 tgcr;
+        unsigned int ipg_div;
+        unsigned int adc_period;
+        unsigned int debounce_cnt;
+        unsigned int settling_cnt;
+        int itemct;
+        int error;
+
+        regmap_read(priv->core_regs, MX25_TSC_TGCR, &tgcr);
+        ipg_div = max_t(unsigned int, 4, MX25_TGCR_GET_ADCCLK(tgcr));
+        adc_period = USEC_PER_SEC * ipg_div * 2 + 2;
+        adc_period /= clk_get_rate(priv->clk) / 1000 + 1;
+        debounce_cnt = DIV_ROUND_UP(priv->pen_debounce, adc_period * 8) - 1;
+        settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1;
+
+        /* Reset */
+        regmap_write(priv->regs, MX25_ADCQ_CR,
+                     MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST);
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR,
+                           MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST, 0);
+
+        /* up to 128 * 8 ADC clocks are possible */
+        if (debounce_cnt > 127)
+                debounce_cnt = 127;
+
+        /* up to 255 * 8 ADC clocks are possible */
+        if (settling_cnt > 255)
+                settling_cnt = 255;
+
+        error = imx25_setup_queue_4wire(priv, settling_cnt, &itemct);
+        if (error)
+                return error;
+
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR,
+                           MX25_ADCQ_CR_LITEMID_MASK | MX25_ADCQ_CR_WMRK_MASK,
+                           MX25_ADCQ_CR_LITEMID(itemct - 1) |
+                           MX25_ADCQ_CR_WMRK(priv->expected_samples - 1));
+
+        /* setup debounce count */
+        regmap_update_bits(priv->core_regs, MX25_TSC_TGCR,
+                           MX25_TGCR_PDBTIME_MASK,
+                           MX25_TGCR_PDBTIME(debounce_cnt));
+
+        /* enable debounce */
+        regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN,
+                           MX25_TGCR_PDBEN);
+        regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDEN,
+                           MX25_TGCR_PDEN);
+
+        /* enable the engine on demand */
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_QSM_MASK,
+                           MX25_ADCQ_CR_QSM_FQS);
+
+        /* Enable repeat and repeat wait */
+        regmap_update_bits(priv->regs, MX25_ADCQ_CR,
+                           MX25_ADCQ_CR_RPT | MX25_ADCQ_CR_RWAIT_MASK,
+                           MX25_ADCQ_CR_RPT |
+                           MX25_ADCQ_CR_RWAIT(MX25_TSC_REPEAT_WAIT));
+
+        return 0;
+}
+
+static int mx25_tcq_parse_dt(struct platform_device *pdev,
+                             struct mx25_tcq_priv *priv)
+{
+        struct device_node *np = pdev->dev.of_node;
+        u32 wires;
+        int error;
+
+        /* Setup defaults */
+        priv->pen_threshold = 500;
+        priv->sample_count = 3;
+        priv->pen_debounce = 1000000;
+        priv->settling_time = 250000;
+
+        error = of_property_read_u32(np, "fsl,wires", &wires);
+        if (error) {
+                dev_err(&pdev->dev, "Failed to find fsl,wires properties\n");
+                return error;
+        }
+
+        if (wires == 4) {
+                priv->mode = MX25_TS_4WIRE;
+        } else {
+                dev_err(&pdev->dev, "%u-wire mode not supported\n", wires);
+                return -EINVAL;
+        }
+
+        /* These are optional, we don't care about the return values */
+        of_property_read_u32(np, "fsl,pen-threshold", &priv->pen_threshold);
+        of_property_read_u32(np, "fsl,settling-time-ns", &priv->settling_time);
+        of_property_read_u32(np, "fsl,pen-debounce-ns", &priv->pen_debounce);
+
+        return 0;
+}
+
+static int mx25_tcq_open(struct input_dev *idev)
+{
+        struct device *dev = &idev->dev;
+        struct mx25_tcq_priv *priv = dev_get_drvdata(dev);
+        int error;
+
+        error = clk_prepare_enable(priv->clk);
+        if (error) {
+                dev_err(dev, "Failed to enable ipg clock\n");
+                return error;
+        }
+
+        error = mx25_tcq_init(priv);
+        if (error) {
+                dev_err(dev, "Failed to init tcq\n");
+                clk_disable_unprepare(priv->clk);
+                return error;
+        }
+
+        mx25_tcq_re_enable_touch_detection(priv);
+
+        return 0;
+}
+
+static void mx25_tcq_close(struct input_dev *idev)
+{
+        struct mx25_tcq_priv *priv = input_get_drvdata(idev);
+
+        mx25_tcq_force_queue_stop(priv);
+        mx25_tcq_disable_touch_irq(priv);
+        mx25_tcq_disable_fifo_irq(priv);
+        clk_disable_unprepare(priv->clk);
+}
+
+static int mx25_tcq_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct input_dev *idev;
+        struct mx25_tcq_priv *priv;
+        struct mx25_tsadc *tsadc = dev_get_drvdata(pdev->dev.parent);
+        struct resource *res;
+        void __iomem *mem;
+        int error;
+
+        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        priv->dev = dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mem = devm_ioremap_resource(dev, res);
+        if (IS_ERR(mem))
+                return PTR_ERR(mem);
+
+        error = mx25_tcq_parse_dt(pdev, priv);
+        if (error)
+                return error;
+
+        priv->regs = devm_regmap_init_mmio(dev, mem, &mx25_tcq_regconfig);
+        if (IS_ERR(priv->regs)) {
+                dev_err(dev, "Failed to initialize regmap\n");
+                return PTR_ERR(priv->regs);
+        }
+
+        priv->irq = platform_get_irq(pdev, 0);
+        if (priv->irq <= 0) {
+                dev_err(dev, "Failed to get IRQ\n");
+                return priv->irq;
+        }
+
+        idev = devm_input_allocate_device(dev);
+        if (!idev) {
+                dev_err(dev, "Failed to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        idev->name = mx25_tcq_name;
+        input_set_capability(idev, EV_KEY, BTN_TOUCH);
+        input_set_abs_params(idev, ABS_X, 0, 0xfff, 0, 0);
+        input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);
+
+        idev->id.bustype = BUS_HOST;
+        idev->open = mx25_tcq_open;
+        idev->close = mx25_tcq_close;
+
+        priv->idev = idev;
+        input_set_drvdata(idev, priv);
+
+        priv->core_regs = tsadc->regs;
+        if (!priv->core_regs)
+                return -EINVAL;
+
+        priv->clk = tsadc->clk;
+        if (!priv->clk)
+                return -EINVAL;
+
+        platform_set_drvdata(pdev, priv);
+
+        error = devm_request_threaded_irq(dev, priv->irq, mx25_tcq_irq,
+                                          mx25_tcq_irq_thread, 0, pdev->name,
+                                          priv);
+        if (error) {
+                dev_err(dev, "Failed requesting IRQ\n");
+                return error;
+        }
+
+        error = input_register_device(idev);
+        if (error) {
+                dev_err(dev, "Failed to register input device\n");
+                return error;
+        }
+
+        return 0;
+}
+
+static struct platform_driver mx25_tcq_driver = {
+        .driver         = {
+                .name   = "mx25-tcq",
+                .of_match_table = mx25_tcq_ids,
+        },
+        .probe          = mx25_tcq_probe,
+};
+module_platform_driver(mx25_tcq_driver);
+
+MODULE_DESCRIPTION("TS input driver for Freescale mx25");
+MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/wdt87xx_i2c.c b/drivers/input/touchscreen/wdt87xx_i2c.c
index 515c20a6e10f..73861ad22df4 100644
--- a/drivers/input/touchscreen/wdt87xx_i2c.c
+++ b/drivers/input/touchscreen/wdt87xx_i2c.c
@@ -848,7 +848,7 @@ static int wdt87xx_do_update_firmware(struct i2c_client *client,
         error = wdt87xx_get_sysparam(client, &wdt->param);
         if (error)
                 dev_err(&client->dev,
-                        "failed to refresh system paramaters: %d\n", error);
+                        "failed to refresh system parameters: %d\n", error);
 out:
         enable_irq(client->irq);
         mutex_unlock(&wdt->fw_mutex);