?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/tests: hdmi: Fix memory leaks in drm_display_mode_from_cea_vic()
[drm/drm-misc.git] / drivers / input / touchscreen / mxs-lradc-ts.c
blob9e36fee38d612b1700e727d0ace40a4477bcc800
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 int ret, irq, virq, i;
610 u32 ts_wires = 0, adapt;
611
612 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
613 if (!ts)
614 return -ENOMEM;
615
616 platform_set_drvdata(pdev, ts);
617
618 ts->lradc = lradc;
619 ts->dev = dev;
620 spin_lock_init(&ts->lock);
621
622 ts->base = devm_platform_ioremap_resource(pdev, 0);
623 if (IS_ERR(ts->base))
624 return PTR_ERR(ts->base);
625
626 ret = of_property_read_u32(node, "fsl,lradc-touchscreen-wires",
627 &ts_wires);
628 if (ret)
629 return ret;
630
631 if (of_property_read_u32(node, "fsl,ave-ctrl", &adapt)) {
632 ts->over_sample_cnt = 4;
633 } else {
634 if (adapt >= 1 && adapt <= 32) {
635 ts->over_sample_cnt = adapt;
636 } else {
637 dev_err(ts->dev, "Invalid sample count (%u)\n",
638 adapt);
639 return -EINVAL;
640 }
641 }
642
643 if (of_property_read_u32(node, "fsl,ave-delay", &adapt)) {
644 ts->over_sample_delay = 2;
645 } else {
646 if (adapt >= 2 && adapt <= LRADC_DELAY_DELAY_MASK + 1) {
647 ts->over_sample_delay = adapt;
648 } else {
649 dev_err(ts->dev, "Invalid sample delay (%u)\n",
650 adapt);
651 return -EINVAL;
652 }
653 }
654
655 if (of_property_read_u32(node, "fsl,settling", &adapt)) {
656 ts->settling_delay = 10;
657 } else {
658 if (adapt >= 1 && adapt <= LRADC_DELAY_DELAY_MASK) {
659 ts->settling_delay = adapt;
660 } else {
661 dev_err(ts->dev, "Invalid settling delay (%u)\n",
662 adapt);
663 return -EINVAL;
664 }
665 }
666
667 ret = stmp_reset_block(ts->base);
668 if (ret)
669 return ret;
670
671 mxs_lradc_ts_hw_init(ts);
672
673 for (i = 0; i < 3; i++) {
674 irq = platform_get_irq_byname(pdev, mxs_lradc_ts_irq_names[i]);
675 if (irq < 0)
676 return irq;
677
678 virq = irq_of_parse_and_map(node, irq);
679
680 mxs_lradc_ts_stop(ts);
681
682 ret = devm_request_irq(dev, virq,
683 mxs_lradc_ts_handle_irq,
684 0, mxs_lradc_ts_irq_names[i], ts);
685 if (ret)
686 return ret;
687 }
688
689 return mxs_lradc_ts_register(ts);
690 }
691
692 static struct platform_driver mxs_lradc_ts_driver = {
693 .driver = {
694 .name = "mxs-lradc-ts",
695 },
696 .probe = mxs_lradc_ts_probe,
697 };
698 module_platform_driver(mxs_lradc_ts_driver);
699
700 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
701 MODULE_DESCRIPTION("Freescale MXS LRADC touchscreen driver");
702 MODULE_LICENSE("GPL");
703 MODULE_ALIAS("platform:mxs-lradc-ts");
Kernel DRM miscellaneous fixes and cross-tree changes