linux/drivers/input/touchscreen/mxs-lradc-ts.c
<<
>>
Prefs
   1/*
   2 * Freescale MXS LRADC touchscreen driver
   3 *
   4 * Copyright (c) 2012 DENX Software Engineering, GmbH.
   5 * Copyright (c) 2017 Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
   6 *
   7 * Authors:
   8 *  Marek Vasut <marex@denx.de>
   9 *  Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2 of the License, or
  14 * (at your option) any later version.
  15 *
  16 * This program is distributed in the hope that it will be useful,
  17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19 * GNU General Public License for more details.
  20 */
  21
  22#include <linux/device.h>
  23#include <linux/err.h>
  24#include <linux/input.h>
  25#include <linux/interrupt.h>
  26#include <linux/module.h>
  27#include <linux/mfd/core.h>
  28#include <linux/mfd/mxs-lradc.h>
  29#include <linux/of.h>
  30#include <linux/of_irq.h>
  31#include <linux/platform_device.h>
  32
  33static const char * const mxs_lradc_ts_irq_names[] = {
  34        "mxs-lradc-touchscreen",
  35        "mxs-lradc-channel6",
  36        "mxs-lradc-channel7",
  37};
  38
  39/*
  40 * Touchscreen handling
  41 */
  42enum mxs_lradc_ts_plate {
  43        LRADC_TOUCH = 0,
  44        LRADC_SAMPLE_X,
  45        LRADC_SAMPLE_Y,
  46        LRADC_SAMPLE_PRESSURE,
  47        LRADC_SAMPLE_VALID,
  48};
  49
  50struct mxs_lradc_ts {
  51        struct mxs_lradc        *lradc;
  52        struct device           *dev;
  53
  54        void __iomem            *base;
  55        /*
  56         * When the touchscreen is enabled, we give it two private virtual
  57         * channels: #6 and #7. This means that only 6 virtual channels (instead
  58         * of 8) will be available for buffered capture.
  59         */
  60#define TOUCHSCREEN_VCHANNEL1           7
  61#define TOUCHSCREEN_VCHANNEL2           6
  62
  63        struct input_dev        *ts_input;
  64
  65        enum mxs_lradc_ts_plate cur_plate; /* state machine */
  66        bool                    ts_valid;
  67        unsigned int            ts_x_pos;
  68        unsigned int            ts_y_pos;
  69        unsigned int            ts_pressure;
  70
  71        /* handle touchscreen's physical behaviour */
  72        /* samples per coordinate */
  73        unsigned int            over_sample_cnt;
  74        /* time clocks between samples */
  75        unsigned int            over_sample_delay;
  76        /* time in clocks to wait after the plates where switched */
  77        unsigned int            settling_delay;
  78        spinlock_t              lock;
  79};
  80
  81struct state_info {
  82        u32             mask;
  83        u32             bit;
  84        u32             x_plate;
  85        u32             y_plate;
  86        u32             pressure;
  87};
  88
  89static struct state_info info[] = {
  90        {LRADC_CTRL0_MX23_PLATE_MASK, LRADC_CTRL0_MX23_TOUCH_DETECT_ENABLE,
  91         LRADC_CTRL0_MX23_XP | LRADC_CTRL0_MX23_XM,
  92         LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_YM,
  93         LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_XM},
  94        {LRADC_CTRL0_MX28_PLATE_MASK, LRADC_CTRL0_MX28_TOUCH_DETECT_ENABLE,
  95         LRADC_CTRL0_MX28_XPPSW | LRADC_CTRL0_MX28_XNNSW,
  96         LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_YNNSW,
  97         LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_XNNSW}
  98};
  99
 100static bool mxs_lradc_check_touch_event(struct mxs_lradc_ts *ts)
 101{
 102        return !!(readl(ts->base + LRADC_STATUS) &
 103                                        LRADC_STATUS_TOUCH_DETECT_RAW);
 104}
 105
 106static void mxs_lradc_map_ts_channel(struct mxs_lradc_ts *ts, unsigned int vch,
 107                                     unsigned int ch)
 108{
 109        writel(LRADC_CTRL4_LRADCSELECT_MASK(vch),
 110               ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_CLR);
 111        writel(LRADC_CTRL4_LRADCSELECT(vch, ch),
 112               ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_SET);
 113}
 114
 115static void mxs_lradc_setup_ts_channel(struct mxs_lradc_ts *ts, unsigned int ch)
 116{
 117        /*
 118         * prepare for oversampling conversion
 119         *
 120         * from the datasheet:
 121         * "The ACCUMULATE bit in the appropriate channel register
 122         * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
 123         * otherwise, the IRQs will not fire."
 124         */
 125        writel(LRADC_CH_ACCUMULATE |
 126               LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1),
 127               ts->base + LRADC_CH(ch));
 128
 129        /* from the datasheet:
 130         * "Software must clear this register in preparation for a
 131         * multi-cycle accumulation.
 132         */
 133        writel(LRADC_CH_VALUE_MASK,
 134               ts->base + LRADC_CH(ch) + STMP_OFFSET_REG_CLR);
 135
 136        /*
 137         * prepare the delay/loop unit according to the oversampling count
 138         *
 139         * from the datasheet:
 140         * "The DELAY fields in HW_LRADC_DELAY0, HW_LRADC_DELAY1,
 141         * HW_LRADC_DELAY2, and HW_LRADC_DELAY3 must be non-zero; otherwise,
 142         * the LRADC will not trigger the delay group."
 143         */
 144        writel(LRADC_DELAY_TRIGGER(1 << ch) | LRADC_DELAY_TRIGGER_DELAYS(0) |
 145               LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
 146               LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
 147               ts->base + LRADC_DELAY(3));
 148
 149        writel(LRADC_CTRL1_LRADC_IRQ(ch),
 150               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 151
 152        /*
 153         * after changing the touchscreen plates setting
 154         * the signals need some initial time to settle. Start the
 155         * SoC's delay unit and start the conversion later
 156         * and automatically.
 157         */
 158        writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
 159               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
 160               ts->base + LRADC_DELAY(2));
 161}
 162
 163/*
 164 * Pressure detection is special:
 165 * We want to do both required measurements for the pressure detection in
 166 * one turn. Use the hardware features to chain both conversions and let the
 167 * hardware report one interrupt if both conversions are done
 168 */
 169static void mxs_lradc_setup_ts_pressure(struct mxs_lradc_ts *ts,
 170                                        unsigned int ch1, unsigned int ch2)
 171{
 172        u32 reg;
 173
 174        /*
 175         * prepare for oversampling conversion
 176         *
 177         * from the datasheet:
 178         * "The ACCUMULATE bit in the appropriate channel register
 179         * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
 180         * otherwise, the IRQs will not fire."
 181         */
 182        reg = LRADC_CH_ACCUMULATE |
 183                LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1);
 184        writel(reg, ts->base + LRADC_CH(ch1));
 185        writel(reg, ts->base + LRADC_CH(ch2));
 186
 187        /* from the datasheet:
 188         * "Software must clear this register in preparation for a
 189         * multi-cycle accumulation.
 190         */
 191        writel(LRADC_CH_VALUE_MASK,
 192               ts->base + LRADC_CH(ch1) + STMP_OFFSET_REG_CLR);
 193        writel(LRADC_CH_VALUE_MASK,
 194               ts->base + LRADC_CH(ch2) + STMP_OFFSET_REG_CLR);
 195
 196        /* prepare the delay/loop unit according to the oversampling count */
 197        writel(LRADC_DELAY_TRIGGER(1 << ch1) | LRADC_DELAY_TRIGGER(1 << ch2) |
 198               LRADC_DELAY_TRIGGER_DELAYS(0) |
 199               LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
 200               LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
 201               ts->base + LRADC_DELAY(3));
 202
 203        writel(LRADC_CTRL1_LRADC_IRQ(ch2),
 204               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 205
 206        /*
 207         * after changing the touchscreen plates setting
 208         * the signals need some initial time to settle. Start the
 209         * SoC's delay unit and start the conversion later
 210         * and automatically.
 211         */
 212        writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
 213               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
 214               ts->base + LRADC_DELAY(2));
 215}
 216
 217static unsigned int mxs_lradc_ts_read_raw_channel(struct mxs_lradc_ts *ts,
 218                                                  unsigned int channel)
 219{
 220        u32 reg;
 221        unsigned int num_samples, val;
 222
 223        reg = readl(ts->base + LRADC_CH(channel));
 224        if (reg & LRADC_CH_ACCUMULATE)
 225                num_samples = ts->over_sample_cnt;
 226        else
 227                num_samples = 1;
 228
 229        val = (reg & LRADC_CH_VALUE_MASK) >> LRADC_CH_VALUE_OFFSET;
 230        return val / num_samples;
 231}
 232
 233static unsigned int mxs_lradc_read_ts_pressure(struct mxs_lradc_ts *ts,
 234                                        unsigned int ch1, unsigned int ch2)
 235{
 236        u32 reg, mask;
 237        unsigned int pressure, m1, m2;
 238
 239        mask = LRADC_CTRL1_LRADC_IRQ(ch1) | LRADC_CTRL1_LRADC_IRQ(ch2);
 240        reg = readl(ts->base + LRADC_CTRL1) & mask;
 241
 242        while (reg != mask) {
 243                reg = readl(ts->base + LRADC_CTRL1) & mask;
 244                dev_dbg(ts->dev, "One channel is still busy: %X\n", reg);
 245        }
 246
 247        m1 = mxs_lradc_ts_read_raw_channel(ts, ch1);
 248        m2 = mxs_lradc_ts_read_raw_channel(ts, ch2);
 249
 250        if (m2 == 0) {
 251                dev_warn(ts->dev, "Cannot calculate pressure\n");
 252                return 1 << (LRADC_RESOLUTION - 1);
 253        }
 254
 255        /* simply scale the value from 0 ... max ADC resolution */
 256        pressure = m1;
 257        pressure *= (1 << LRADC_RESOLUTION);
 258        pressure /= m2;
 259
 260        dev_dbg(ts->dev, "Pressure = %u\n", pressure);
 261        return pressure;
 262}
 263
 264#define TS_CH_XP 2
 265#define TS_CH_YP 3
 266#define TS_CH_XM 4
 267#define TS_CH_YM 5
 268
 269/*
 270 * YP(open)--+-------------+
 271 *           |             |--+
 272 *           |             |  |
 273 *    YM(-)--+-------------+  |
 274 *             +--------------+
 275 *             |              |
 276 *         XP(weak+)        XM(open)
 277 *
 278 * "weak+" means 200k Ohm VDDIO
 279 * (-) means GND
 280 */
 281static void mxs_lradc_setup_touch_detection(struct mxs_lradc_ts *ts)
 282{
 283        struct mxs_lradc *lradc = ts->lradc;
 284
 285        /*
 286         * In order to detect a touch event the 'touch detect enable' bit
 287         * enables:
 288         *  - a weak pullup to the X+ connector
 289         *  - a strong ground at the Y- connector
 290         */
 291        writel(info[lradc->soc].mask,
 292               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 293        writel(info[lradc->soc].bit,
 294               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
 295}
 296
 297/*
 298 * YP(meas)--+-------------+
 299 *           |             |--+
 300 *           |             |  |
 301 * YM(open)--+-------------+  |
 302 *             +--------------+
 303 *             |              |
 304 *           XP(+)          XM(-)
 305 *
 306 * (+) means here 1.85 V
 307 * (-) means here GND
 308 */
 309static void mxs_lradc_prepare_x_pos(struct mxs_lradc_ts *ts)
 310{
 311        struct mxs_lradc *lradc = ts->lradc;
 312
 313        writel(info[lradc->soc].mask,
 314               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 315        writel(info[lradc->soc].x_plate,
 316               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
 317
 318        ts->cur_plate = LRADC_SAMPLE_X;
 319        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YP);
 320        mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
 321}
 322
 323/*
 324 *   YP(+)--+-------------+
 325 *          |             |--+
 326 *          |             |  |
 327 *   YM(-)--+-------------+  |
 328 *            +--------------+
 329 *            |              |
 330 *         XP(open)        XM(meas)
 331 *
 332 * (+) means here 1.85 V
 333 * (-) means here GND
 334 */
 335static void mxs_lradc_prepare_y_pos(struct mxs_lradc_ts *ts)
 336{
 337        struct mxs_lradc *lradc = ts->lradc;
 338
 339        writel(info[lradc->soc].mask,
 340               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 341        writel(info[lradc->soc].y_plate,
 342               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
 343
 344        ts->cur_plate = LRADC_SAMPLE_Y;
 345        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_XM);
 346        mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
 347}
 348
 349/*
 350 *    YP(+)--+-------------+
 351 *           |             |--+
 352 *           |             |  |
 353 * YM(meas)--+-------------+  |
 354 *             +--------------+
 355 *             |              |
 356 *          XP(meas)        XM(-)
 357 *
 358 * (+) means here 1.85 V
 359 * (-) means here GND
 360 */
 361static void mxs_lradc_prepare_pressure(struct mxs_lradc_ts *ts)
 362{
 363        struct mxs_lradc *lradc = ts->lradc;
 364
 365        writel(info[lradc->soc].mask,
 366               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 367        writel(info[lradc->soc].pressure,
 368               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
 369
 370        ts->cur_plate = LRADC_SAMPLE_PRESSURE;
 371        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YM);
 372        mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL2, TS_CH_XP);
 373        mxs_lradc_setup_ts_pressure(ts, TOUCHSCREEN_VCHANNEL2,
 374                                    TOUCHSCREEN_VCHANNEL1);
 375}
 376
 377static void mxs_lradc_enable_touch_detection(struct mxs_lradc_ts *ts)
 378{
 379        mxs_lradc_setup_touch_detection(ts);
 380
 381        ts->cur_plate = LRADC_TOUCH;
 382        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ | LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
 383               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 384        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
 385               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
 386}
 387
 388static void mxs_lradc_start_touch_event(struct mxs_lradc_ts *ts)
 389{
 390        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
 391               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 392        writel(LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1),
 393               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
 394        /*
 395         * start with the Y-pos, because it uses nearly the same plate
 396         * settings like the touch detection
 397         */
 398        mxs_lradc_prepare_y_pos(ts);
 399}
 400
 401static void mxs_lradc_report_ts_event(struct mxs_lradc_ts *ts)
 402{
 403        input_report_abs(ts->ts_input, ABS_X, ts->ts_x_pos);
 404        input_report_abs(ts->ts_input, ABS_Y, ts->ts_y_pos);
 405        input_report_abs(ts->ts_input, ABS_PRESSURE, ts->ts_pressure);
 406        input_report_key(ts->ts_input, BTN_TOUCH, 1);
 407        input_sync(ts->ts_input);
 408}
 409
 410static void mxs_lradc_complete_touch_event(struct mxs_lradc_ts *ts)
 411{
 412        mxs_lradc_setup_touch_detection(ts);
 413        ts->cur_plate = LRADC_SAMPLE_VALID;
 414        /*
 415         * start a dummy conversion to burn time to settle the signals
 416         * note: we are not interested in the conversion's value
 417         */
 418        writel(0, ts->base + LRADC_CH(TOUCHSCREEN_VCHANNEL1));
 419        writel(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
 420               LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2),
 421               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 422        writel(LRADC_DELAY_TRIGGER(1 << TOUCHSCREEN_VCHANNEL1) |
 423               LRADC_DELAY_KICK | LRADC_DELAY_DELAY(10),
 424               ts->base + LRADC_DELAY(2));
 425}
 426
 427/*
 428 * in order to avoid false measurements, report only samples where
 429 * the surface is still touched after the position measurement
 430 */
 431static void mxs_lradc_finish_touch_event(struct mxs_lradc_ts *ts, bool valid)
 432{
 433        /* if it is still touched, report the sample */
 434        if (valid && mxs_lradc_check_touch_event(ts)) {
 435                ts->ts_valid = true;
 436                mxs_lradc_report_ts_event(ts);
 437        }
 438
 439        /* if it is even still touched, continue with the next measurement */
 440        if (mxs_lradc_check_touch_event(ts)) {
 441                mxs_lradc_prepare_y_pos(ts);
 442                return;
 443        }
 444
 445        if (ts->ts_valid) {
 446                /* signal the release */
 447                ts->ts_valid = false;
 448                input_report_key(ts->ts_input, BTN_TOUCH, 0);
 449                input_sync(ts->ts_input);
 450        }
 451
 452        /* if it is released, wait for the next touch via IRQ */
 453        ts->cur_plate = LRADC_TOUCH;
 454        writel(0, ts->base + LRADC_DELAY(2));
 455        writel(0, ts->base + LRADC_DELAY(3));
 456        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ |
 457               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
 458               LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1),
 459               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 460        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
 461               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
 462}
 463
 464/* touchscreen's state machine */
 465static void mxs_lradc_handle_touch(struct mxs_lradc_ts *ts)
 466{
 467        switch (ts->cur_plate) {
 468        case LRADC_TOUCH:
 469                if (mxs_lradc_check_touch_event(ts))
 470                        mxs_lradc_start_touch_event(ts);
 471                writel(LRADC_CTRL1_TOUCH_DETECT_IRQ,
 472                       ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 473                return;
 474
 475        case LRADC_SAMPLE_Y:
 476                ts->ts_y_pos =
 477                    mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
 478                mxs_lradc_prepare_x_pos(ts);
 479                return;
 480
 481        case LRADC_SAMPLE_X:
 482                ts->ts_x_pos =
 483                    mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
 484                mxs_lradc_prepare_pressure(ts);
 485                return;
 486
 487        case LRADC_SAMPLE_PRESSURE:
 488                ts->ts_pressure =
 489                    mxs_lradc_read_ts_pressure(ts,
 490                                               TOUCHSCREEN_VCHANNEL2,
 491                                               TOUCHSCREEN_VCHANNEL1);
 492                mxs_lradc_complete_touch_event(ts);
 493                return;
 494
 495        case LRADC_SAMPLE_VALID:
 496                mxs_lradc_finish_touch_event(ts, 1);
 497                break;
 498        }
 499}
 500
 501/* IRQ Handling */
 502static irqreturn_t mxs_lradc_ts_handle_irq(int irq, void *data)
 503{
 504        struct mxs_lradc_ts *ts = data;
 505        struct mxs_lradc *lradc = ts->lradc;
 506        unsigned long reg = readl(ts->base + LRADC_CTRL1);
 507        u32 clr_irq = mxs_lradc_irq_mask(lradc);
 508        const u32 ts_irq_mask =
 509                LRADC_CTRL1_TOUCH_DETECT_IRQ |
 510                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
 511                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2);
 512        unsigned long flags;
 513
 514        if (!(reg & mxs_lradc_irq_mask(lradc)))
 515                return IRQ_NONE;
 516
 517        if (reg & ts_irq_mask) {
 518                spin_lock_irqsave(&ts->lock, flags);
 519                mxs_lradc_handle_touch(ts);
 520                spin_unlock_irqrestore(&ts->lock, flags);
 521                /* Make sure we don't clear the next conversion's interrupt. */
 522                clr_irq &= ~(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
 523                                LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2));
 524                writel(reg & clr_irq,
 525                       ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 526        }
 527
 528        return IRQ_HANDLED;
 529}
 530
 531static int mxs_lradc_ts_open(struct input_dev *dev)
 532{
 533        struct mxs_lradc_ts *ts = input_get_drvdata(dev);
 534
 535        /* Enable the touch-detect circuitry. */
 536        mxs_lradc_enable_touch_detection(ts);
 537
 538        return 0;
 539}
 540
 541static void mxs_lradc_ts_stop(struct mxs_lradc_ts *ts)
 542{
 543        int i;
 544        struct mxs_lradc *lradc = ts->lradc;
 545
 546        /* stop all interrupts from firing */
 547        writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN |
 548               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
 549               LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL2),
 550               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 551
 552        /* Power-down touchscreen touch-detect circuitry. */
 553        writel(info[lradc->soc].mask,
 554               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 555
 556        writel(lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET,
 557               ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
 558
 559        for (i = 1; i < LRADC_MAX_DELAY_CHANS; i++)
 560                writel(0, ts->base + LRADC_DELAY(i));
 561}
 562
 563static void mxs_lradc_ts_close(struct input_dev *dev)
 564{
 565        struct mxs_lradc_ts *ts = input_get_drvdata(dev);
 566
 567        mxs_lradc_ts_stop(ts);
 568}
 569
 570static void mxs_lradc_ts_hw_init(struct mxs_lradc_ts *ts)
 571{
 572        struct mxs_lradc *lradc = ts->lradc;
 573
 574        /* Configure the touchscreen type */
 575        if (lradc->soc == IMX28_LRADC) {
 576                writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
 577                       ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
 578
 579                if (lradc->touchscreen_wire == MXS_LRADC_TOUCHSCREEN_5WIRE)
 580                        writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
 581                               ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
 582        }
 583}
 584
 585static int mxs_lradc_ts_register(struct mxs_lradc_ts *ts)
 586{
 587        struct input_dev *input;
 588        struct device *dev = ts->dev;
 589
 590        input = devm_input_allocate_device(dev);
 591        if (!input)
 592                return -ENOMEM;
 593
 594        input->name = "mxs-lradc-ts";
 595        input->id.bustype = BUS_HOST;
 596        input->open = mxs_lradc_ts_open;
 597        input->close = mxs_lradc_ts_close;
 598
 599        __set_bit(INPUT_PROP_DIRECT, input->propbit);
 600        input_set_capability(input, EV_KEY, BTN_TOUCH);
 601        input_set_abs_params(input, ABS_X, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
 602        input_set_abs_params(input, ABS_Y, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
 603        input_set_abs_params(input, ABS_PRESSURE, 0, LRADC_SINGLE_SAMPLE_MASK,
 604                             0, 0);
 605
 606        ts->ts_input = input;
 607        input_set_drvdata(input, ts);
 608
 609        return input_register_device(input);
 610}
 611
 612static int mxs_lradc_ts_probe(struct platform_device *pdev)
 613{
 614        struct device *dev = &pdev->dev;
 615        struct device_node *node = dev->parent->of_node;
 616        struct mxs_lradc *lradc = dev_get_drvdata(dev->parent);
 617        struct mxs_lradc_ts *ts;
 618        struct resource *iores;
 619        int ret, irq, virq, i;
 620        u32 ts_wires = 0, adapt;
 621
 622        ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
 623        if (!ts)
 624                return -ENOMEM;
 625
 626        platform_set_drvdata(pdev, ts);
 627
 628        ts->lradc = lradc;
 629        ts->dev = dev;
 630        spin_lock_init(&ts->lock);
 631
 632        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 633        if (!iores)
 634                return -EINVAL;
 635        ts->base = devm_ioremap(dev, iores->start, resource_size(iores));
 636        if (!ts->base)
 637                return -ENOMEM;
 638
 639        ret = of_property_read_u32(node, "fsl,lradc-touchscreen-wires",
 640                                   &ts_wires);
 641        if (ret)
 642                return ret;
 643
 644        if (of_property_read_u32(node, "fsl,ave-ctrl", &adapt)) {
 645                ts->over_sample_cnt = 4;
 646        } else {
 647                if (adapt >= 1 && adapt <= 32) {
 648                        ts->over_sample_cnt = adapt;
 649                } else {
 650                        dev_err(ts->dev, "Invalid sample count (%u)\n",
 651                                adapt);
 652                        return -EINVAL;
 653                }
 654        }
 655
 656        if (of_property_read_u32(node, "fsl,ave-delay", &adapt)) {
 657                ts->over_sample_delay = 2;
 658        } else {
 659                if (adapt >= 2 && adapt <= LRADC_DELAY_DELAY_MASK + 1) {
 660                        ts->over_sample_delay = adapt;
 661                } else {
 662                        dev_err(ts->dev, "Invalid sample delay (%u)\n",
 663                                adapt);
 664                        return -EINVAL;
 665                }
 666        }
 667
 668        if (of_property_read_u32(node, "fsl,settling", &adapt)) {
 669                ts->settling_delay = 10;
 670        } else {
 671                if (adapt >= 1 && adapt <= LRADC_DELAY_DELAY_MASK) {
 672                        ts->settling_delay = adapt;
 673                } else {
 674                        dev_err(ts->dev, "Invalid settling delay (%u)\n",
 675                                adapt);
 676                        return -EINVAL;
 677                }
 678        }
 679
 680        ret = stmp_reset_block(ts->base);
 681        if (ret)
 682                return ret;
 683
 684        mxs_lradc_ts_hw_init(ts);
 685
 686        for (i = 0; i < 3; i++) {
 687                irq = platform_get_irq_byname(pdev, mxs_lradc_ts_irq_names[i]);
 688                if (irq < 0)
 689                        return irq;
 690
 691                virq = irq_of_parse_and_map(node, irq);
 692
 693                mxs_lradc_ts_stop(ts);
 694
 695                ret = devm_request_irq(dev, virq,
 696                                       mxs_lradc_ts_handle_irq,
 697                                       0, mxs_lradc_ts_irq_names[i], ts);
 698                if (ret)
 699                        return ret;
 700        }
 701
 702        return mxs_lradc_ts_register(ts);
 703}
 704
 705static struct platform_driver mxs_lradc_ts_driver = {
 706        .driver = {
 707                .name = "mxs-lradc-ts",
 708        },
 709        .probe  = mxs_lradc_ts_probe,
 710};
 711module_platform_driver(mxs_lradc_ts_driver);
 712
 713MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
 714MODULE_DESCRIPTION("Freescale MXS LRADC touchscreen driver");
 715MODULE_LICENSE("GPL");
 716MODULE_ALIAS("platform:mxs-lradc-ts");
 717