// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Freescale MXS LRADC touchscreen driver
 *
 * Copyright (c) 2012 DENX Software Engineering, GmbH.
 * Copyright (c) 2017 Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
 *
 * Authors:
 *  Marek Vasut <marex@denx.de>
 *  Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mfd/core.h>
#include <linux/mfd/mxs-lradc.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>

static const char * const mxs_lradc_ts_irq_names[] = {
        "mxs-lradc-touchscreen",
        "mxs-lradc-channel6",
        "mxs-lradc-channel7",
};

/*
 * Touchscreen handling
 */
enum mxs_lradc_ts_plate {
        LRADC_TOUCH = 0,
        LRADC_SAMPLE_X,
        LRADC_SAMPLE_Y,
        LRADC_SAMPLE_PRESSURE,
        LRADC_SAMPLE_VALID,
};

struct mxs_lradc_ts {
        struct mxs_lradc        *lradc;
        struct device           *dev;

        void __iomem            *base;
        /*
         * When the touchscreen is enabled, we give it two private virtual
         * channels: #6 and #7. This means that only 6 virtual channels (instead
         * of 8) will be available for buffered capture.
         */
#define TOUCHSCREEN_VCHANNEL1           7
#define TOUCHSCREEN_VCHANNEL2           6

        struct input_dev        *ts_input;

        enum mxs_lradc_ts_plate cur_plate; /* state machine */
        bool                    ts_valid;
        unsigned int            ts_x_pos;
        unsigned int            ts_y_pos;
        unsigned int            ts_pressure;

        /* handle touchscreen's physical behaviour */
        /* samples per coordinate */
        unsigned int            over_sample_cnt;
        /* time clocks between samples */
        unsigned int            over_sample_delay;
        /* time in clocks to wait after the plates where switched */
        unsigned int            settling_delay;
        spinlock_t              lock;
};

struct state_info {
        u32             mask;
        u32             bit;
        u32             x_plate;
        u32             y_plate;
        u32             pressure;
};

static struct state_info info[] = {
        {LRADC_CTRL0_MX23_PLATE_MASK, LRADC_CTRL0_MX23_TOUCH_DETECT_ENABLE,
         LRADC_CTRL0_MX23_XP | LRADC_CTRL0_MX23_XM,
         LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_YM,
         LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_XM},
        {LRADC_CTRL0_MX28_PLATE_MASK, LRADC_CTRL0_MX28_TOUCH_DETECT_ENABLE,
         LRADC_CTRL0_MX28_XPPSW | LRADC_CTRL0_MX28_XNNSW,
         LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_YNNSW,
         LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_XNNSW}
};

static bool mxs_lradc_check_touch_event(struct mxs_lradc_ts *ts)
{
        return !!(readl(ts->base + LRADC_STATUS) &
                                        LRADC_STATUS_TOUCH_DETECT_RAW);
}

static void mxs_lradc_map_ts_channel(struct mxs_lradc_ts *ts, unsigned int vch,
                                     unsigned int ch)
{
        writel(LRADC_CTRL4_LRADCSELECT_MASK(vch),
               ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_CLR);
        writel(LRADC_CTRL4_LRADCSELECT(vch, ch),
               ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_SET);
}

static void mxs_lradc_setup_ts_channel(struct mxs_lradc_ts *ts, unsigned int ch)
{
        /*
         * prepare for oversampling conversion
         *
         * from the datasheet:
         * "The ACCUMULATE bit in the appropriate channel register
         * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
         * otherwise, the IRQs will not fire."
         */
        writel(LRADC_CH_ACCUMULATE |
               LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1),
               ts->base + LRADC_CH(ch));

        /* from the datasheet:
         * "Software must clear this register in preparation for a
         * multi-cycle accumulation.
         */
        writel(LRADC_CH_VALUE_MASK,
               ts->base + LRADC_CH(ch) + STMP_OFFSET_REG_CLR);

        /*
         * prepare the delay/loop unit according to the oversampling count
         *
         * from the datasheet:
         * "The DELAY fields in HW_LRADC_DELAY0, HW_LRADC_DELAY1,
         * HW_LRADC_DELAY2, and HW_LRADC_DELAY3 must be non-zero; otherwise,
         * the LRADC will not trigger the delay group."
         */
        writel(LRADC_DELAY_TRIGGER(1 << ch) | LRADC_DELAY_TRIGGER_DELAYS(0) |
               LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
               LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
               ts->base + LRADC_DELAY(3));

        writel(LRADC_CTRL1_LRADC_IRQ(ch),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);

        /*
         * after changing the touchscreen plates setting
         * the signals need some initial time to settle. Start the
         * SoC's delay unit and start the conversion later
         * and automatically.
         */
        writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
               ts->base + LRADC_DELAY(2));
}

/*
 * Pressure detection is special:
 * We want to do both required measurements for the pressure detection in
 * one turn. Use the hardware features to chain both conversions and let the
 * hardware report one interrupt if both conversions are done
 */
static void mxs_lradc_setup_ts_pressure(struct mxs_lradc_ts *ts,
                                        unsigned int ch1, unsigned int ch2)
{
        u32 reg;

        /*
         * prepare for oversampling conversion
         *
         * from the datasheet:
         * "The ACCUMULATE bit in the appropriate channel register
         * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
         * otherwise, the IRQs will not fire."
         */
        reg = LRADC_CH_ACCUMULATE |
                LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1);
        writel(reg, ts->base + LRADC_CH(ch1));
        writel(reg, ts->base + LRADC_CH(ch2));

        /* from the datasheet:
         * "Software must clear this register in preparation for a
         * multi-cycle accumulation.
         */
        writel(LRADC_CH_VALUE_MASK,
               ts->base + LRADC_CH(ch1) + STMP_OFFSET_REG_CLR);
        writel(LRADC_CH_VALUE_MASK,
               ts->base + LRADC_CH(ch2) + STMP_OFFSET_REG_CLR);

        /* prepare the delay/loop unit according to the oversampling count */
        writel(LRADC_DELAY_TRIGGER(1 << ch1) | LRADC_DELAY_TRIGGER(1 << ch2) |
               LRADC_DELAY_TRIGGER_DELAYS(0) |
               LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
               LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
               ts->base + LRADC_DELAY(3));

        writel(LRADC_CTRL1_LRADC_IRQ(ch2),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);

        /*
         * after changing the touchscreen plates setting
         * the signals need some initial time to settle. Start the
         * SoC's delay unit and start the conversion later
         * and automatically.
         */
        writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
               ts->base + LRADC_DELAY(2));
}

static unsigned int mxs_lradc_ts_read_raw_channel(struct mxs_lradc_ts *ts,
                                                  unsigned int channel)
{
        u32 reg;
        unsigned int num_samples, val;

        reg = readl(ts->base + LRADC_CH(channel));
        if (reg & LRADC_CH_ACCUMULATE)
                num_samples = ts->over_sample_cnt;
        else
                num_samples = 1;

        val = (reg & LRADC_CH_VALUE_MASK) >> LRADC_CH_VALUE_OFFSET;
        return val / num_samples;
}

static unsigned int mxs_lradc_read_ts_pressure(struct mxs_lradc_ts *ts,
                                        unsigned int ch1, unsigned int ch2)
{
        u32 reg, mask;
        unsigned int pressure, m1, m2;

        mask = LRADC_CTRL1_LRADC_IRQ(ch1) | LRADC_CTRL1_LRADC_IRQ(ch2);
        reg = readl(ts->base + LRADC_CTRL1) & mask;

        while (reg != mask) {
                reg = readl(ts->base + LRADC_CTRL1) & mask;
                dev_dbg(ts->dev, "One channel is still busy: %X\n", reg);
        }

        m1 = mxs_lradc_ts_read_raw_channel(ts, ch1);
        m2 = mxs_lradc_ts_read_raw_channel(ts, ch2);

        if (m2 == 0) {
                dev_warn(ts->dev, "Cannot calculate pressure\n");
                return 1 << (LRADC_RESOLUTION - 1);
        }

        /* simply scale the value from 0 ... max ADC resolution */
        pressure = m1;
        pressure *= (1 << LRADC_RESOLUTION);
        pressure /= m2;

        dev_dbg(ts->dev, "Pressure = %u\n", pressure);
        return pressure;
}

#define TS_CH_XP 2
#define TS_CH_YP 3
#define TS_CH_XM 4
#define TS_CH_YM 5

/*
 * YP(open)--+-------------+
 *           |             |--+
 *           |             |  |
 *    YM(-)--+-------------+  |
 *             +--------------+
 *             |              |
 *         XP(weak+)        XM(open)
 *
 * "weak+" means 200k Ohm VDDIO
 * (-) means GND
 */
static void mxs_lradc_setup_touch_detection(struct mxs_lradc_ts *ts)
{
        struct mxs_lradc *lradc = ts->lradc;

        /*
         * In order to detect a touch event the 'touch detect enable' bit
         * enables:
         *  - a weak pullup to the X+ connector
         *  - a strong ground at the Y- connector
         */
        writel(info[lradc->soc].mask,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
        writel(info[lradc->soc].bit,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
}

/*
 * YP(meas)--+-------------+
 *           |             |--+
 *           |             |  |
 * YM(open)--+-------------+  |
 *             +--------------+
 *             |              |
 *           XP(+)          XM(-)
 *
 * (+) means here 1.85 V
 * (-) means here GND
 */
static void mxs_lradc_prepare_x_pos(struct mxs_lradc_ts *ts)
{
        struct mxs_lradc *lradc = ts->lradc;

        writel(info[lradc->soc].mask,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
        writel(info[lradc->soc].x_plate,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);

        ts->cur_plate = LRADC_SAMPLE_X;
        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YP);
        mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
}

/*
 *   YP(+)--+-------------+
 *          |             |--+
 *          |             |  |
 *   YM(-)--+-------------+  |
 *            +--------------+
 *            |              |
 *         XP(open)        XM(meas)
 *
 * (+) means here 1.85 V
 * (-) means here GND
 */
static void mxs_lradc_prepare_y_pos(struct mxs_lradc_ts *ts)
{
        struct mxs_lradc *lradc = ts->lradc;

        writel(info[lradc->soc].mask,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
        writel(info[lradc->soc].y_plate,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);

        ts->cur_plate = LRADC_SAMPLE_Y;
        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_XM);
        mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
}

/*
 *    YP(+)--+-------------+
 *           |             |--+
 *           |             |  |
 * YM(meas)--+-------------+  |
 *             +--------------+
 *             |              |
 *          XP(meas)        XM(-)
 *
 * (+) means here 1.85 V
 * (-) means here GND
 */
static void mxs_lradc_prepare_pressure(struct mxs_lradc_ts *ts)
{
        struct mxs_lradc *lradc = ts->lradc;

        writel(info[lradc->soc].mask,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
        writel(info[lradc->soc].pressure,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);

        ts->cur_plate = LRADC_SAMPLE_PRESSURE;
        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YM);
        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL2, TS_CH_XP);
        mxs_lradc_setup_ts_pressure(ts, TOUCHSCREEN_VCHANNEL2,
                                    TOUCHSCREEN_VCHANNEL1);
}

static void mxs_lradc_enable_touch_detection(struct mxs_lradc_ts *ts)
{
        mxs_lradc_setup_touch_detection(ts);

        ts->cur_plate = LRADC_TOUCH;
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ | LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
}

static void mxs_lradc_start_touch_event(struct mxs_lradc_ts *ts)
{
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
        writel(LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
        /*
         * start with the Y-pos, because it uses nearly the same plate
         * settings like the touch detection
         */
        mxs_lradc_prepare_y_pos(ts);
}

static void mxs_lradc_report_ts_event(struct mxs_lradc_ts *ts)
{
        input_report_abs(ts->ts_input, ABS_X, ts->ts_x_pos);
        input_report_abs(ts->ts_input, ABS_Y, ts->ts_y_pos);
        input_report_abs(ts->ts_input, ABS_PRESSURE, ts->ts_pressure);
        input_report_key(ts->ts_input, BTN_TOUCH, 1);
        input_sync(ts->ts_input);
}

static void mxs_lradc_complete_touch_event(struct mxs_lradc_ts *ts)
{
        mxs_lradc_setup_touch_detection(ts);
        ts->cur_plate = LRADC_SAMPLE_VALID;
        /*
         * start a dummy conversion to burn time to settle the signals
         * note: we are not interested in the conversion's value
         */
        writel(0, ts->base + LRADC_CH(TOUCHSCREEN_VCHANNEL1));
        writel(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
               LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
        writel(LRADC_DELAY_TRIGGER(1 << TOUCHSCREEN_VCHANNEL1) |
               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(10),
               ts->base + LRADC_DELAY(2));
}

/*
 * in order to avoid false measurements, report only samples where
 * the surface is still touched after the position measurement
 */
static void mxs_lradc_finish_touch_event(struct mxs_lradc_ts *ts, bool valid)
{
        /* if it is still touched, report the sample */
        if (valid && mxs_lradc_check_touch_event(ts)) {
                ts->ts_valid = true;
                mxs_lradc_report_ts_event(ts);
        }

        /* if it is even still touched, continue with the next measurement */
        if (mxs_lradc_check_touch_event(ts)) {
                mxs_lradc_prepare_y_pos(ts);
                return;
        }

        if (ts->ts_valid) {
                /* signal the release */
                ts->ts_valid = false;
                input_report_key(ts->ts_input, BTN_TOUCH, 0);
                input_sync(ts->ts_input);
        }

        /* if it is released, wait for the next touch via IRQ */
        ts->cur_plate = LRADC_TOUCH;
        writel(0, ts->base + LRADC_DELAY(2));
        writel(0, ts->base + LRADC_DELAY(3));
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ |
               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
               LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
}

/* touchscreen's state machine */
static void mxs_lradc_handle_touch(struct mxs_lradc_ts *ts)
{
        switch (ts->cur_plate) {
        case LRADC_TOUCH:
                if (mxs_lradc_check_touch_event(ts))
                        mxs_lradc_start_touch_event(ts);
                writel(LRADC_CTRL1_TOUCH_DETECT_IRQ,
                       ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
                return;

        case LRADC_SAMPLE_Y:
                ts->ts_y_pos =
                    mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
                mxs_lradc_prepare_x_pos(ts);
                return;

        case LRADC_SAMPLE_X:
                ts->ts_x_pos =
                    mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
                mxs_lradc_prepare_pressure(ts);
                return;

        case LRADC_SAMPLE_PRESSURE:
                ts->ts_pressure =
                    mxs_lradc_read_ts_pressure(ts,
                                               TOUCHSCREEN_VCHANNEL2,
                                               TOUCHSCREEN_VCHANNEL1);
                mxs_lradc_complete_touch_event(ts);
                return;

        case LRADC_SAMPLE_VALID:
                mxs_lradc_finish_touch_event(ts, 1);
                break;
        }
}

/* IRQ Handling */
static irqreturn_t mxs_lradc_ts_handle_irq(int irq, void *data)
{
        struct mxs_lradc_ts *ts = data;
        struct mxs_lradc *lradc = ts->lradc;
        unsigned long reg = readl(ts->base + LRADC_CTRL1);
        u32 clr_irq = mxs_lradc_irq_mask(lradc);
        const u32 ts_irq_mask =
                LRADC_CTRL1_TOUCH_DETECT_IRQ |
                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2);
        unsigned long flags;

        if (!(reg & mxs_lradc_irq_mask(lradc)))
                return IRQ_NONE;

        if (reg & ts_irq_mask) {
                spin_lock_irqsave(&ts->lock, flags);
                mxs_lradc_handle_touch(ts);
                spin_unlock_irqrestore(&ts->lock, flags);
                /* Make sure we don't clear the next conversion's interrupt. */
                clr_irq &= ~(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
                                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2));
                writel(reg & clr_irq,
                       ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
        }

        return IRQ_HANDLED;
}

static int mxs_lradc_ts_open(struct input_dev *dev)
{
        struct mxs_lradc_ts *ts = input_get_drvdata(dev);

        /* Enable the touch-detect circuitry. */
        mxs_lradc_enable_touch_detection(ts);

        return 0;
}

static void mxs_lradc_ts_stop(struct mxs_lradc_ts *ts)
{
        int i;
        struct mxs_lradc *lradc = ts->lradc;

        /* stop all interrupts from firing */
        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN |
               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL2),
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);

        /* Power-down touchscreen touch-detect circuitry. */
        writel(info[lradc->soc].mask,
               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);

        writel(lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET,
               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);

        for (i = 1; i < LRADC_MAX_DELAY_CHANS; i++)
                writel(0, ts->base + LRADC_DELAY(i));
}

static void mxs_lradc_ts_close(struct input_dev *dev)
{
        struct mxs_lradc_ts *ts = input_get_drvdata(dev);

        mxs_lradc_ts_stop(ts);
}

static void mxs_lradc_ts_hw_init(struct mxs_lradc_ts *ts)
{
        struct mxs_lradc *lradc = ts->lradc;

        /* Configure the touchscreen type */
        if (lradc->soc == IMX28_LRADC) {
                writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
                       ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);

                if (lradc->touchscreen_wire == MXS_LRADC_TOUCHSCREEN_5WIRE)
                        writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
                               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
        }
}

static int mxs_lradc_ts_register(struct mxs_lradc_ts *ts)
{
        struct input_dev *input;
        struct device *dev = ts->dev;

        input = devm_input_allocate_device(dev);
        if (!input)
                return -ENOMEM;

        input->name = "mxs-lradc-ts";
        input->id.bustype = BUS_HOST;
        input->open = mxs_lradc_ts_open;
        input->close = mxs_lradc_ts_close;

        __set_bit(INPUT_PROP_DIRECT, input->propbit);
        input_set_capability(input, EV_KEY, BTN_TOUCH);
        input_set_abs_params(input, ABS_X, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
        input_set_abs_params(input, ABS_Y, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
        input_set_abs_params(input, ABS_PRESSURE, 0, LRADC_SINGLE_SAMPLE_MASK,
                             0, 0);

        ts->ts_input = input;
        input_set_drvdata(input, ts);

        return input_register_device(input);
}

static int mxs_lradc_ts_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct device_node *node = dev->parent->of_node;
        struct mxs_lradc *lradc = dev_get_drvdata(dev->parent);
        struct mxs_lradc_ts *ts;
        int ret, irq, virq, i;
        u32 ts_wires = 0, adapt;

        ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
        if (!ts)
                return -ENOMEM;

        platform_set_drvdata(pdev, ts);

        ts->lradc = lradc;
        ts->dev = dev;
        spin_lock_init(&ts->lock);

        ts->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(ts->base))
                return PTR_ERR(ts->base);

        ret = of_property_read_u32(node, "fsl,lradc-touchscreen-wires",
                                   &ts_wires);
        if (ret)
                return ret;

        if (of_property_read_u32(node, "fsl,ave-ctrl", &adapt)) {
                ts->over_sample_cnt = 4;
        } else {
                if (adapt >= 1 && adapt <= 32) {
                        ts->over_sample_cnt = adapt;
                } else {
                        dev_err(ts->dev, "Invalid sample count (%u)\n",
                                adapt);
                        return -EINVAL;
                }
        }

        if (of_property_read_u32(node, "fsl,ave-delay", &adapt)) {
                ts->over_sample_delay = 2;
        } else {
                if (adapt >= 2 && adapt <= LRADC_DELAY_DELAY_MASK + 1) {
                        ts->over_sample_delay = adapt;
                } else {
                        dev_err(ts->dev, "Invalid sample delay (%u)\n",
                                adapt);
                        return -EINVAL;
                }
        }

        if (of_property_read_u32(node, "fsl,settling", &adapt)) {
                ts->settling_delay = 10;
        } else {
                if (adapt >= 1 && adapt <= LRADC_DELAY_DELAY_MASK) {
                        ts->settling_delay = adapt;
                } else {
                        dev_err(ts->dev, "Invalid settling delay (%u)\n",
                                adapt);
                        return -EINVAL;
                }
        }

        ret = stmp_reset_block(ts->base);
        if (ret)
                return ret;

        mxs_lradc_ts_hw_init(ts);

        for (i = 0; i < 3; i++) {
                irq = platform_get_irq_byname(pdev, mxs_lradc_ts_irq_names[i]);
                if (irq < 0)
                        return irq;

                virq = irq_of_parse_and_map(node, irq);

                mxs_lradc_ts_stop(ts);

                ret = devm_request_irq(dev, virq,
                                       mxs_lradc_ts_handle_irq,
                                       0, mxs_lradc_ts_irq_names[i], ts);
                if (ret)
                        return ret;
        }

        return mxs_lradc_ts_register(ts);
}

static struct platform_driver mxs_lradc_ts_driver = {
        .driver = {
                .name = "mxs-lradc-ts",
        },
        .probe  = mxs_lradc_ts_probe,
};
module_platform_driver(mxs_lradc_ts_driver);

MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
MODULE_DESCRIPTION("Freescale MXS LRADC touchscreen driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:mxs-lradc-ts");