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(addr: 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 | addr: ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_CLR); |
102 | writel(LRADC_CTRL4_LRADCSELECT(vch, ch), |
103 | addr: 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 | addr: 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 | addr: 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 | addr: ts->base + LRADC_DELAY(3)); |
139 | |
140 | writel(LRADC_CTRL1_LRADC_IRQ(ch), |
141 | addr: 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 | addr: 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(val: reg, addr: ts->base + LRADC_CH(ch1)); |
176 | writel(val: reg, addr: 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 | addr: ts->base + LRADC_CH(ch1) + STMP_OFFSET_REG_CLR); |
184 | writel(LRADC_CH_VALUE_MASK, |
185 | addr: 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 | addr: ts->base + LRADC_DELAY(3)); |
193 | |
194 | writel(LRADC_CTRL1_LRADC_IRQ(ch2), |
195 | addr: 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 | addr: 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(addr: 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(addr: ts->base + LRADC_CTRL1) & mask; |
232 | |
233 | while (reg != mask) { |
234 | reg = readl(addr: 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, channel: ch1); |
239 | m2 = mxs_lradc_ts_read_raw_channel(ts, channel: 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(val: info[lradc->soc].mask, |
283 | addr: ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR); |
284 | writel(val: info[lradc->soc].bit, |
285 | addr: 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(val: info[lradc->soc].mask, |
305 | addr: ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR); |
306 | writel(val: info[lradc->soc].x_plate, |
307 | addr: 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(val: info[lradc->soc].mask, |
331 | addr: ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR); |
332 | writel(val: info[lradc->soc].y_plate, |
333 | addr: 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(val: info[lradc->soc].mask, |
357 | addr: ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR); |
358 | writel(val: info[lradc->soc].pressure, |
359 | addr: 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 | addr: ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR); |
375 | writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, |
376 | addr: 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 | addr: ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR); |
383 | writel(LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1), |
384 | addr: 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(dev: ts->ts_input, ABS_X, value: ts->ts_x_pos); |
395 | input_report_abs(dev: ts->ts_input, ABS_Y, value: ts->ts_y_pos); |
396 | input_report_abs(dev: ts->ts_input, ABS_PRESSURE, value: ts->ts_pressure); |
397 | input_report_key(dev: ts->ts_input, BTN_TOUCH, value: 1); |
398 | input_sync(dev: 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(val: 0, addr: ts->base + LRADC_CH(TOUCHSCREEN_VCHANNEL1)); |
410 | writel(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) | |
411 | LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2), |
412 | addr: 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 | addr: 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(dev: ts->ts_input, BTN_TOUCH, value: 0); |
440 | input_sync(dev: 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(val: 0, addr: ts->base + LRADC_DELAY(2)); |
446 | writel(val: 0, addr: 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 | addr: ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR); |
451 | writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN, |
452 | addr: 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 | addr: 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, valid: 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(addr: 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(lock: &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(val: reg & clr_irq, |
516 | addr: 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 | addr: ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR); |
542 | |
543 | /* Power-down touchscreen touch-detect circuitry. */ |
544 | writel(val: info[lradc->soc].mask, |
545 | addr: ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR); |
546 | |
547 | writel(val: lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET, |
548 | addr: ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR); |
549 | |
550 | for (i = 1; i < LRADC_MAX_DELAY_CHANS; i++) |
551 | writel(val: 0, addr: 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 | addr: 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 | addr: 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(dev: input, EV_KEY, BTN_TOUCH); |
592 | input_set_abs_params(dev: input, ABS_X, min: 0, LRADC_SINGLE_SAMPLE_MASK, fuzz: 0, flat: 0); |
593 | input_set_abs_params(dev: input, ABS_Y, min: 0, LRADC_SINGLE_SAMPLE_MASK, fuzz: 0, flat: 0); |
594 | input_set_abs_params(dev: input, ABS_PRESSURE, min: 0, LRADC_SINGLE_SAMPLE_MASK, |
595 | fuzz: 0, flat: 0); |
596 | |
597 | ts->ts_input = input; |
598 | input_set_drvdata(dev: input, data: 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: 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, size: sizeof(*ts), GFP_KERNEL); |
613 | if (!ts) |
614 | return -ENOMEM; |
615 | |
616 | platform_set_drvdata(pdev, data: 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, index: 0); |
623 | if (IS_ERR(ptr: ts->base)) |
624 | return PTR_ERR(ptr: ts->base); |
625 | |
626 | ret = of_property_read_u32(np: node, propname: "fsl,lradc-touchscreen-wires" , |
627 | out_value: &ts_wires); |
628 | if (ret) |
629 | return ret; |
630 | |
631 | if (of_property_read_u32(np: node, propname: "fsl,ave-ctrl" , out_value: &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(np: node, propname: "fsl,ave-delay" , out_value: &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(np: node, propname: "fsl,settling" , out_value: &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, index: irq); |
679 | |
680 | mxs_lradc_ts_stop(ts); |
681 | |
682 | ret = devm_request_irq(dev, irq: virq, |
683 | handler: mxs_lradc_ts_handle_irq, |
684 | irqflags: 0, devname: mxs_lradc_ts_irq_names[i], dev_id: 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" ); |
704 | |