drivers/input/touchscreen/mxs-lradc-ts.c

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