1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // |
3 | // Copyright (C) 2014-2015 Pengutronix, Markus Pargmann <mpa@pengutronix.de> |
4 | // Based on driver from 2011: |
5 | // Juergen Beisert, Pengutronix <kernel@pengutronix.de> |
6 | // |
7 | // This is the driver for the imx25 TCQ (Touchscreen Conversion Queue) |
8 | // connected to the imx25 ADC. |
9 | |
10 | #include <linux/clk.h> |
11 | #include <linux/device.h> |
12 | #include <linux/input.h> |
13 | #include <linux/interrupt.h> |
14 | #include <linux/mfd/imx25-tsadc.h> |
15 | #include <linux/module.h> |
16 | #include <linux/of.h> |
17 | #include <linux/platform_device.h> |
18 | #include <linux/regmap.h> |
19 | |
20 | static const char mx25_tcq_name[] = "mx25-tcq" ; |
21 | |
22 | enum mx25_tcq_mode { |
23 | MX25_TS_4WIRE, |
24 | }; |
25 | |
26 | struct mx25_tcq_priv { |
27 | struct regmap *regs; |
28 | struct regmap *core_regs; |
29 | struct input_dev *idev; |
30 | enum mx25_tcq_mode mode; |
31 | unsigned int pen_threshold; |
32 | unsigned int sample_count; |
33 | unsigned int expected_samples; |
34 | unsigned int pen_debounce; |
35 | unsigned int settling_time; |
36 | struct clk *clk; |
37 | int irq; |
38 | struct device *dev; |
39 | }; |
40 | |
41 | static struct regmap_config mx25_tcq_regconfig = { |
42 | .fast_io = true, |
43 | .max_register = 0x5c, |
44 | .reg_bits = 32, |
45 | .val_bits = 32, |
46 | .reg_stride = 4, |
47 | }; |
48 | |
49 | static const struct of_device_id mx25_tcq_ids[] = { |
50 | { .compatible = "fsl,imx25-tcq" , }, |
51 | { /* Sentinel */ } |
52 | }; |
53 | MODULE_DEVICE_TABLE(of, mx25_tcq_ids); |
54 | |
55 | #define TSC_4WIRE_PRE_INDEX 0 |
56 | #define TSC_4WIRE_X_INDEX 1 |
57 | #define TSC_4WIRE_Y_INDEX 2 |
58 | #define TSC_4WIRE_POST_INDEX 3 |
59 | #define TSC_4WIRE_LEAVE 4 |
60 | |
61 | #define MX25_TSC_DEF_THRESHOLD 80 |
62 | #define TSC_MAX_SAMPLES 16 |
63 | |
64 | #define MX25_TSC_REPEAT_WAIT 14 |
65 | |
66 | enum mx25_adc_configurations { |
67 | MX25_CFG_PRECHARGE = 0, |
68 | MX25_CFG_TOUCH_DETECT, |
69 | MX25_CFG_X_MEASUREMENT, |
70 | MX25_CFG_Y_MEASUREMENT, |
71 | }; |
72 | |
73 | #define MX25_PRECHARGE_VALUE (\ |
74 | MX25_ADCQ_CFG_YPLL_OFF | \ |
75 | MX25_ADCQ_CFG_XNUR_OFF | \ |
76 | MX25_ADCQ_CFG_XPUL_HIGH | \ |
77 | MX25_ADCQ_CFG_REFP_INT | \ |
78 | MX25_ADCQ_CFG_IN_XP | \ |
79 | MX25_ADCQ_CFG_REFN_NGND2 | \ |
80 | MX25_ADCQ_CFG_IGS) |
81 | |
82 | #define MX25_TOUCH_DETECT_VALUE (\ |
83 | MX25_ADCQ_CFG_YNLR | \ |
84 | MX25_ADCQ_CFG_YPLL_OFF | \ |
85 | MX25_ADCQ_CFG_XNUR_OFF | \ |
86 | MX25_ADCQ_CFG_XPUL_OFF | \ |
87 | MX25_ADCQ_CFG_REFP_INT | \ |
88 | MX25_ADCQ_CFG_IN_XP | \ |
89 | MX25_ADCQ_CFG_REFN_NGND2 | \ |
90 | MX25_ADCQ_CFG_PENIACK) |
91 | |
92 | static void imx25_setup_queue_cfgs(struct mx25_tcq_priv *priv, |
93 | unsigned int settling_cnt) |
94 | { |
95 | u32 precharge_cfg = |
96 | MX25_PRECHARGE_VALUE | |
97 | MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt); |
98 | u32 touch_detect_cfg = |
99 | MX25_TOUCH_DETECT_VALUE | |
100 | MX25_ADCQ_CFG_NOS(1) | |
101 | MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt); |
102 | |
103 | regmap_write(map: priv->core_regs, MX25_TSC_TICR, val: precharge_cfg); |
104 | |
105 | /* PRECHARGE */ |
106 | regmap_write(map: priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE), |
107 | val: precharge_cfg); |
108 | |
109 | /* TOUCH_DETECT */ |
110 | regmap_write(map: priv->regs, MX25_ADCQ_CFG(MX25_CFG_TOUCH_DETECT), |
111 | val: touch_detect_cfg); |
112 | |
113 | /* X Measurement */ |
114 | regmap_write(map: priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT), |
115 | MX25_ADCQ_CFG_YPLL_OFF | |
116 | MX25_ADCQ_CFG_XNUR_LOW | |
117 | MX25_ADCQ_CFG_XPUL_HIGH | |
118 | MX25_ADCQ_CFG_REFP_XP | |
119 | MX25_ADCQ_CFG_IN_YP | |
120 | MX25_ADCQ_CFG_REFN_XN | |
121 | MX25_ADCQ_CFG_NOS(priv->sample_count) | |
122 | MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt)); |
123 | |
124 | /* Y Measurement */ |
125 | regmap_write(map: priv->regs, MX25_ADCQ_CFG(MX25_CFG_Y_MEASUREMENT), |
126 | MX25_ADCQ_CFG_YNLR | |
127 | MX25_ADCQ_CFG_YPLL_HIGH | |
128 | MX25_ADCQ_CFG_XNUR_OFF | |
129 | MX25_ADCQ_CFG_XPUL_OFF | |
130 | MX25_ADCQ_CFG_REFP_YP | |
131 | MX25_ADCQ_CFG_IN_XP | |
132 | MX25_ADCQ_CFG_REFN_YN | |
133 | MX25_ADCQ_CFG_NOS(priv->sample_count) | |
134 | MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt)); |
135 | |
136 | /* Enable the touch detection right now */ |
137 | regmap_write(map: priv->core_regs, MX25_TSC_TICR, val: touch_detect_cfg | |
138 | MX25_ADCQ_CFG_IGS); |
139 | } |
140 | |
141 | static int imx25_setup_queue_4wire(struct mx25_tcq_priv *priv, |
142 | unsigned settling_cnt, int *items) |
143 | { |
144 | imx25_setup_queue_cfgs(priv, settling_cnt); |
145 | |
146 | /* Setup the conversion queue */ |
147 | regmap_write(map: priv->regs, MX25_ADCQ_ITEM_7_0, |
148 | MX25_ADCQ_ITEM(0, MX25_CFG_PRECHARGE) | |
149 | MX25_ADCQ_ITEM(1, MX25_CFG_TOUCH_DETECT) | |
150 | MX25_ADCQ_ITEM(2, MX25_CFG_X_MEASUREMENT) | |
151 | MX25_ADCQ_ITEM(3, MX25_CFG_Y_MEASUREMENT) | |
152 | MX25_ADCQ_ITEM(4, MX25_CFG_PRECHARGE) | |
153 | MX25_ADCQ_ITEM(5, MX25_CFG_TOUCH_DETECT)); |
154 | |
155 | /* |
156 | * We measure X/Y with 'sample_count' number of samples and execute a |
157 | * touch detection twice, with 1 sample each |
158 | */ |
159 | priv->expected_samples = priv->sample_count * 2 + 2; |
160 | *items = 6; |
161 | |
162 | return 0; |
163 | } |
164 | |
165 | static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv) |
166 | { |
167 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, |
168 | MX25_ADCQ_CR_PDMSK); |
169 | } |
170 | |
171 | static void mx25_tcq_enable_touch_irq(struct mx25_tcq_priv *priv) |
172 | { |
173 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, val: 0); |
174 | } |
175 | |
176 | static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv) |
177 | { |
178 | regmap_update_bits(map: priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, |
179 | MX25_ADCQ_MR_FDRY_IRQ); |
180 | } |
181 | |
182 | static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv) |
183 | { |
184 | regmap_update_bits(map: priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, val: 0); |
185 | } |
186 | |
187 | static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv) |
188 | { |
189 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, |
190 | MX25_ADCQ_CR_FQS, |
191 | MX25_ADCQ_CR_FQS); |
192 | } |
193 | |
194 | static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv) |
195 | { |
196 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, |
197 | MX25_ADCQ_CR_FQS, val: 0); |
198 | } |
199 | |
200 | static void mx25_tcq_fifo_reset(struct mx25_tcq_priv *priv) |
201 | { |
202 | u32 tcqcr; |
203 | |
204 | regmap_read(map: priv->regs, MX25_ADCQ_CR, val: &tcqcr); |
205 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, |
206 | MX25_ADCQ_CR_FRST); |
207 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, val: 0); |
208 | regmap_write(map: priv->regs, MX25_ADCQ_CR, val: tcqcr); |
209 | } |
210 | |
211 | static void mx25_tcq_re_enable_touch_detection(struct mx25_tcq_priv *priv) |
212 | { |
213 | /* stop the queue from looping */ |
214 | mx25_tcq_force_queue_stop(priv); |
215 | |
216 | /* for a clean touch detection, preload the X plane */ |
217 | regmap_write(map: priv->core_regs, MX25_TSC_TICR, MX25_PRECHARGE_VALUE); |
218 | |
219 | /* waste some time now to pre-load the X plate to high voltage */ |
220 | mx25_tcq_fifo_reset(priv); |
221 | |
222 | /* re-enable the detection right now */ |
223 | regmap_write(map: priv->core_regs, MX25_TSC_TICR, |
224 | MX25_TOUCH_DETECT_VALUE | MX25_ADCQ_CFG_IGS); |
225 | |
226 | regmap_update_bits(map: priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_PD, |
227 | MX25_ADCQ_SR_PD); |
228 | |
229 | /* enable the pen down event to be a source for the interrupt */ |
230 | regmap_update_bits(map: priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_PD_IRQ, val: 0); |
231 | |
232 | /* lets fire the next IRQ if someone touches the touchscreen */ |
233 | mx25_tcq_enable_touch_irq(priv); |
234 | } |
235 | |
236 | static void mx25_tcq_create_event_for_4wire(struct mx25_tcq_priv *priv, |
237 | u32 *sample_buf, |
238 | unsigned int samples) |
239 | { |
240 | unsigned int x_pos = 0; |
241 | unsigned int y_pos = 0; |
242 | unsigned int touch_pre = 0; |
243 | unsigned int touch_post = 0; |
244 | unsigned int i; |
245 | |
246 | for (i = 0; i < samples; i++) { |
247 | unsigned int index = MX25_ADCQ_FIFO_ID(sample_buf[i]); |
248 | unsigned int val = MX25_ADCQ_FIFO_DATA(sample_buf[i]); |
249 | |
250 | switch (index) { |
251 | case 1: |
252 | touch_pre = val; |
253 | break; |
254 | case 2: |
255 | x_pos = val; |
256 | break; |
257 | case 3: |
258 | y_pos = val; |
259 | break; |
260 | case 5: |
261 | touch_post = val; |
262 | break; |
263 | default: |
264 | dev_dbg(priv->dev, "Dropped samples because of invalid index %d\n" , |
265 | index); |
266 | return; |
267 | } |
268 | } |
269 | |
270 | if (samples != 0) { |
271 | /* |
272 | * only if both touch measures are below a threshold, |
273 | * the position is valid |
274 | */ |
275 | if (touch_pre < priv->pen_threshold && |
276 | touch_post < priv->pen_threshold) { |
277 | /* valid samples, generate a report */ |
278 | x_pos /= priv->sample_count; |
279 | y_pos /= priv->sample_count; |
280 | input_report_abs(dev: priv->idev, ABS_X, value: x_pos); |
281 | input_report_abs(dev: priv->idev, ABS_Y, value: y_pos); |
282 | input_report_key(dev: priv->idev, BTN_TOUCH, value: 1); |
283 | input_sync(dev: priv->idev); |
284 | |
285 | /* get next sample */ |
286 | mx25_tcq_enable_fifo_irq(priv); |
287 | } else if (touch_pre >= priv->pen_threshold && |
288 | touch_post >= priv->pen_threshold) { |
289 | /* |
290 | * if both samples are invalid, |
291 | * generate a release report |
292 | */ |
293 | input_report_key(dev: priv->idev, BTN_TOUCH, value: 0); |
294 | input_sync(dev: priv->idev); |
295 | mx25_tcq_re_enable_touch_detection(priv); |
296 | } else { |
297 | /* |
298 | * if only one of both touch measurements are |
299 | * below the threshold, still some bouncing |
300 | * happens. Take additional samples in this |
301 | * case to be sure |
302 | */ |
303 | mx25_tcq_enable_fifo_irq(priv); |
304 | } |
305 | } |
306 | } |
307 | |
308 | static irqreturn_t mx25_tcq_irq_thread(int irq, void *dev_id) |
309 | { |
310 | struct mx25_tcq_priv *priv = dev_id; |
311 | u32 sample_buf[TSC_MAX_SAMPLES]; |
312 | unsigned int samples; |
313 | u32 stats; |
314 | unsigned int i; |
315 | |
316 | /* |
317 | * Check how many samples are available. We always have to read exactly |
318 | * sample_count samples from the fifo, or a multiple of sample_count. |
319 | * Otherwise we mixup samples into different touch events. |
320 | */ |
321 | regmap_read(map: priv->regs, MX25_ADCQ_SR, val: &stats); |
322 | samples = MX25_ADCQ_SR_FDN(stats); |
323 | samples -= samples % priv->sample_count; |
324 | |
325 | if (!samples) |
326 | return IRQ_HANDLED; |
327 | |
328 | for (i = 0; i != samples; ++i) |
329 | regmap_read(map: priv->regs, MX25_ADCQ_FIFO, val: &sample_buf[i]); |
330 | |
331 | mx25_tcq_create_event_for_4wire(priv, sample_buf, samples); |
332 | |
333 | return IRQ_HANDLED; |
334 | } |
335 | |
336 | static irqreturn_t mx25_tcq_irq(int irq, void *dev_id) |
337 | { |
338 | struct mx25_tcq_priv *priv = dev_id; |
339 | u32 stat; |
340 | int ret = IRQ_HANDLED; |
341 | |
342 | regmap_read(map: priv->regs, MX25_ADCQ_SR, val: &stat); |
343 | |
344 | if (stat & (MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR)) |
345 | mx25_tcq_re_enable_touch_detection(priv); |
346 | |
347 | if (stat & MX25_ADCQ_SR_PD) { |
348 | mx25_tcq_disable_touch_irq(priv); |
349 | mx25_tcq_force_queue_start(priv); |
350 | mx25_tcq_enable_fifo_irq(priv); |
351 | } |
352 | |
353 | if (stat & MX25_ADCQ_SR_FDRY) { |
354 | mx25_tcq_disable_fifo_irq(priv); |
355 | ret = IRQ_WAKE_THREAD; |
356 | } |
357 | |
358 | regmap_update_bits(map: priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_FRR | |
359 | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR | |
360 | MX25_ADCQ_SR_PD, |
361 | MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | |
362 | MX25_ADCQ_SR_FOR | MX25_ADCQ_SR_PD); |
363 | |
364 | return ret; |
365 | } |
366 | |
367 | /* configure the state machine for a 4-wire touchscreen */ |
368 | static int mx25_tcq_init(struct mx25_tcq_priv *priv) |
369 | { |
370 | u32 tgcr; |
371 | unsigned int ipg_div; |
372 | unsigned int adc_period; |
373 | unsigned int debounce_cnt; |
374 | unsigned int settling_cnt; |
375 | int itemct; |
376 | int error; |
377 | |
378 | regmap_read(map: priv->core_regs, MX25_TSC_TGCR, val: &tgcr); |
379 | ipg_div = max_t(unsigned int, 4, MX25_TGCR_GET_ADCCLK(tgcr)); |
380 | adc_period = USEC_PER_SEC * ipg_div * 2 + 2; |
381 | adc_period /= clk_get_rate(clk: priv->clk) / 1000 + 1; |
382 | debounce_cnt = DIV_ROUND_UP(priv->pen_debounce, adc_period * 8) - 1; |
383 | settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1; |
384 | |
385 | /* Reset */ |
386 | regmap_write(map: priv->regs, MX25_ADCQ_CR, |
387 | MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST); |
388 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, |
389 | MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST, val: 0); |
390 | |
391 | /* up to 128 * 8 ADC clocks are possible */ |
392 | if (debounce_cnt > 127) |
393 | debounce_cnt = 127; |
394 | |
395 | /* up to 255 * 8 ADC clocks are possible */ |
396 | if (settling_cnt > 255) |
397 | settling_cnt = 255; |
398 | |
399 | error = imx25_setup_queue_4wire(priv, settling_cnt, items: &itemct); |
400 | if (error) |
401 | return error; |
402 | |
403 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, |
404 | MX25_ADCQ_CR_LITEMID_MASK | MX25_ADCQ_CR_WMRK_MASK, |
405 | MX25_ADCQ_CR_LITEMID(itemct - 1) | |
406 | MX25_ADCQ_CR_WMRK(priv->expected_samples - 1)); |
407 | |
408 | /* setup debounce count */ |
409 | regmap_update_bits(map: priv->core_regs, MX25_TSC_TGCR, |
410 | MX25_TGCR_PDBTIME_MASK, |
411 | MX25_TGCR_PDBTIME(debounce_cnt)); |
412 | |
413 | /* enable debounce */ |
414 | regmap_update_bits(map: priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN, |
415 | MX25_TGCR_PDBEN); |
416 | regmap_update_bits(map: priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDEN, |
417 | MX25_TGCR_PDEN); |
418 | |
419 | /* enable the engine on demand */ |
420 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_QSM_MASK, |
421 | MX25_ADCQ_CR_QSM_FQS); |
422 | |
423 | /* Enable repeat and repeat wait */ |
424 | regmap_update_bits(map: priv->regs, MX25_ADCQ_CR, |
425 | MX25_ADCQ_CR_RPT | MX25_ADCQ_CR_RWAIT_MASK, |
426 | MX25_ADCQ_CR_RPT | |
427 | MX25_ADCQ_CR_RWAIT(MX25_TSC_REPEAT_WAIT)); |
428 | |
429 | return 0; |
430 | } |
431 | |
432 | static int mx25_tcq_parse_dt(struct platform_device *pdev, |
433 | struct mx25_tcq_priv *priv) |
434 | { |
435 | struct device_node *np = pdev->dev.of_node; |
436 | u32 wires; |
437 | int error; |
438 | |
439 | /* Setup defaults */ |
440 | priv->pen_threshold = 500; |
441 | priv->sample_count = 3; |
442 | priv->pen_debounce = 1000000; |
443 | priv->settling_time = 250000; |
444 | |
445 | error = of_property_read_u32(np, propname: "fsl,wires" , out_value: &wires); |
446 | if (error) { |
447 | dev_err(&pdev->dev, "Failed to find fsl,wires properties\n" ); |
448 | return error; |
449 | } |
450 | |
451 | if (wires == 4) { |
452 | priv->mode = MX25_TS_4WIRE; |
453 | } else { |
454 | dev_err(&pdev->dev, "%u-wire mode not supported\n" , wires); |
455 | return -EINVAL; |
456 | } |
457 | |
458 | /* These are optional, we don't care about the return values */ |
459 | of_property_read_u32(np, propname: "fsl,pen-threshold" , out_value: &priv->pen_threshold); |
460 | of_property_read_u32(np, propname: "fsl,settling-time-ns" , out_value: &priv->settling_time); |
461 | of_property_read_u32(np, propname: "fsl,pen-debounce-ns" , out_value: &priv->pen_debounce); |
462 | |
463 | return 0; |
464 | } |
465 | |
466 | static int mx25_tcq_open(struct input_dev *idev) |
467 | { |
468 | struct device *dev = &idev->dev; |
469 | struct mx25_tcq_priv *priv = dev_get_drvdata(dev); |
470 | int error; |
471 | |
472 | error = clk_prepare_enable(clk: priv->clk); |
473 | if (error) { |
474 | dev_err(dev, "Failed to enable ipg clock\n" ); |
475 | return error; |
476 | } |
477 | |
478 | error = mx25_tcq_init(priv); |
479 | if (error) { |
480 | dev_err(dev, "Failed to init tcq\n" ); |
481 | clk_disable_unprepare(clk: priv->clk); |
482 | return error; |
483 | } |
484 | |
485 | mx25_tcq_re_enable_touch_detection(priv); |
486 | |
487 | return 0; |
488 | } |
489 | |
490 | static void mx25_tcq_close(struct input_dev *idev) |
491 | { |
492 | struct mx25_tcq_priv *priv = input_get_drvdata(dev: idev); |
493 | |
494 | mx25_tcq_force_queue_stop(priv); |
495 | mx25_tcq_disable_touch_irq(priv); |
496 | mx25_tcq_disable_fifo_irq(priv); |
497 | clk_disable_unprepare(clk: priv->clk); |
498 | } |
499 | |
500 | static int mx25_tcq_probe(struct platform_device *pdev) |
501 | { |
502 | struct device *dev = &pdev->dev; |
503 | struct input_dev *idev; |
504 | struct mx25_tcq_priv *priv; |
505 | struct mx25_tsadc *tsadc = dev_get_drvdata(dev: dev->parent); |
506 | void __iomem *mem; |
507 | int error; |
508 | |
509 | priv = devm_kzalloc(dev, size: sizeof(*priv), GFP_KERNEL); |
510 | if (!priv) |
511 | return -ENOMEM; |
512 | priv->dev = dev; |
513 | |
514 | mem = devm_platform_ioremap_resource(pdev, index: 0); |
515 | if (IS_ERR(ptr: mem)) |
516 | return PTR_ERR(ptr: mem); |
517 | |
518 | error = mx25_tcq_parse_dt(pdev, priv); |
519 | if (error) |
520 | return error; |
521 | |
522 | priv->regs = devm_regmap_init_mmio(dev, mem, &mx25_tcq_regconfig); |
523 | if (IS_ERR(ptr: priv->regs)) { |
524 | dev_err(dev, "Failed to initialize regmap\n" ); |
525 | return PTR_ERR(ptr: priv->regs); |
526 | } |
527 | |
528 | priv->irq = platform_get_irq(pdev, 0); |
529 | if (priv->irq <= 0) |
530 | return priv->irq; |
531 | |
532 | idev = devm_input_allocate_device(dev); |
533 | if (!idev) { |
534 | dev_err(dev, "Failed to allocate input device\n" ); |
535 | return -ENOMEM; |
536 | } |
537 | |
538 | idev->name = mx25_tcq_name; |
539 | input_set_capability(dev: idev, EV_KEY, BTN_TOUCH); |
540 | input_set_abs_params(dev: idev, ABS_X, min: 0, max: 0xfff, fuzz: 0, flat: 0); |
541 | input_set_abs_params(dev: idev, ABS_Y, min: 0, max: 0xfff, fuzz: 0, flat: 0); |
542 | |
543 | idev->id.bustype = BUS_HOST; |
544 | idev->open = mx25_tcq_open; |
545 | idev->close = mx25_tcq_close; |
546 | |
547 | priv->idev = idev; |
548 | input_set_drvdata(dev: idev, data: priv); |
549 | |
550 | priv->core_regs = tsadc->regs; |
551 | if (!priv->core_regs) |
552 | return -EINVAL; |
553 | |
554 | priv->clk = tsadc->clk; |
555 | if (!priv->clk) |
556 | return -EINVAL; |
557 | |
558 | platform_set_drvdata(pdev, data: priv); |
559 | |
560 | error = devm_request_threaded_irq(dev, irq: priv->irq, handler: mx25_tcq_irq, |
561 | thread_fn: mx25_tcq_irq_thread, irqflags: 0, devname: pdev->name, |
562 | dev_id: priv); |
563 | if (error) { |
564 | dev_err(dev, "Failed requesting IRQ\n" ); |
565 | return error; |
566 | } |
567 | |
568 | error = input_register_device(idev); |
569 | if (error) { |
570 | dev_err(dev, "Failed to register input device\n" ); |
571 | return error; |
572 | } |
573 | |
574 | return 0; |
575 | } |
576 | |
577 | static struct platform_driver mx25_tcq_driver = { |
578 | .driver = { |
579 | .name = "mx25-tcq" , |
580 | .of_match_table = mx25_tcq_ids, |
581 | }, |
582 | .probe = mx25_tcq_probe, |
583 | }; |
584 | module_platform_driver(mx25_tcq_driver); |
585 | |
586 | MODULE_DESCRIPTION("TS input driver for Freescale mx25" ); |
587 | MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>" ); |
588 | MODULE_LICENSE("GPL v2" ); |
589 | |