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(priv->core_regs, MX25_TSC_TICR, precharge_cfg);
104 
105 	/* PRECHARGE */
106 	regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE),
107 		     precharge_cfg);
108 
109 	/* TOUCH_DETECT */
110 	regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_TOUCH_DETECT),
111 		     touch_detect_cfg);
112 
113 	/* X Measurement */
114 	regmap_write(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(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(priv->core_regs, MX25_TSC_TICR, 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(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(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(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, 0);
174 }
175 
176 static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv)
177 {
178 	regmap_update_bits(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(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, 0);
185 }
186 
187 static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
188 {
189 	regmap_update_bits(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(priv->regs, MX25_ADCQ_CR,
197 			   MX25_ADCQ_CR_FQS, 0);
198 }
199 
200 static void mx25_tcq_fifo_reset(struct mx25_tcq_priv *priv)
201 {
202 	u32 tcqcr;
203 
204 	regmap_read(priv->regs, MX25_ADCQ_CR, &tcqcr);
205 	regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST,
206 			   MX25_ADCQ_CR_FRST);
207 	regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, 0);
208 	regmap_write(priv->regs, MX25_ADCQ_CR, 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(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(priv->core_regs, MX25_TSC_TICR,
224 		     MX25_TOUCH_DETECT_VALUE | MX25_ADCQ_CFG_IGS);
225 
226 	regmap_update_bits(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(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_PD_IRQ, 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(priv->idev, ABS_X, x_pos);
281 			input_report_abs(priv->idev, ABS_Y, y_pos);
282 			input_report_key(priv->idev, BTN_TOUCH, 1);
283 			input_sync(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(priv->idev, BTN_TOUCH, 0);
294 			input_sync(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(priv->regs, MX25_ADCQ_SR, &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(priv->regs, MX25_ADCQ_FIFO, &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(priv->regs, MX25_ADCQ_SR, &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(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(priv->core_regs, MX25_TSC_TGCR, &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(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(priv->regs, MX25_ADCQ_CR,
387 		     MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST);
388 	regmap_update_bits(priv->regs, MX25_ADCQ_CR,
389 			   MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST, 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, &itemct);
400 	if (error)
401 		return error;
402 
403 	regmap_update_bits(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(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(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN,
415 			   MX25_TGCR_PDBEN);
416 	regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDEN,
417 			   MX25_TGCR_PDEN);
418 
419 	/* enable the engine on demand */
420 	regmap_update_bits(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(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, "fsl,wires", &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, "fsl,pen-threshold", &priv->pen_threshold);
460 	of_property_read_u32(np, "fsl,settling-time-ns", &priv->settling_time);
461 	of_property_read_u32(np, "fsl,pen-debounce-ns", &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(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(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(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(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->parent);
506 	struct resource *res;
507 	void __iomem *mem;
508 	int error;
509 
510 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
511 	if (!priv)
512 		return -ENOMEM;
513 	priv->dev = dev;
514 
515 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
516 	mem = devm_ioremap_resource(dev, res);
517 	if (IS_ERR(mem))
518 		return PTR_ERR(mem);
519 
520 	error = mx25_tcq_parse_dt(pdev, priv);
521 	if (error)
522 		return error;
523 
524 	priv->regs = devm_regmap_init_mmio(dev, mem, &mx25_tcq_regconfig);
525 	if (IS_ERR(priv->regs)) {
526 		dev_err(dev, "Failed to initialize regmap\n");
527 		return PTR_ERR(priv->regs);
528 	}
529 
530 	priv->irq = platform_get_irq(pdev, 0);
531 	if (priv->irq <= 0) {
532 		dev_err(dev, "Failed to get IRQ\n");
533 		return priv->irq;
534 	}
535 
536 	idev = devm_input_allocate_device(dev);
537 	if (!idev) {
538 		dev_err(dev, "Failed to allocate input device\n");
539 		return -ENOMEM;
540 	}
541 
542 	idev->name = mx25_tcq_name;
543 	input_set_capability(idev, EV_KEY, BTN_TOUCH);
544 	input_set_abs_params(idev, ABS_X, 0, 0xfff, 0, 0);
545 	input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);
546 
547 	idev->id.bustype = BUS_HOST;
548 	idev->open = mx25_tcq_open;
549 	idev->close = mx25_tcq_close;
550 
551 	priv->idev = idev;
552 	input_set_drvdata(idev, priv);
553 
554 	priv->core_regs = tsadc->regs;
555 	if (!priv->core_regs)
556 		return -EINVAL;
557 
558 	priv->clk = tsadc->clk;
559 	if (!priv->clk)
560 		return -EINVAL;
561 
562 	platform_set_drvdata(pdev, priv);
563 
564 	error = devm_request_threaded_irq(dev, priv->irq, mx25_tcq_irq,
565 					  mx25_tcq_irq_thread, 0, pdev->name,
566 					  priv);
567 	if (error) {
568 		dev_err(dev, "Failed requesting IRQ\n");
569 		return error;
570 	}
571 
572 	error = input_register_device(idev);
573 	if (error) {
574 		dev_err(dev, "Failed to register input device\n");
575 		return error;
576 	}
577 
578 	return 0;
579 }
580 
581 static struct platform_driver mx25_tcq_driver = {
582 	.driver		= {
583 		.name	= "mx25-tcq",
584 		.of_match_table = mx25_tcq_ids,
585 	},
586 	.probe		= mx25_tcq_probe,
587 };
588 module_platform_driver(mx25_tcq_driver);
589 
590 MODULE_DESCRIPTION("TS input driver for Freescale mx25");
591 MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
592 MODULE_LICENSE("GPL v2");
593