treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / 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");