2 * Copyright (C) 2014-2015 Pengutronix, Markus Pargmann <mpa@pengutronix.de>
4 * This program is free software; you can redistribute it and/or modify it under
5 * the terms of the GNU General Public License version 2 as published by the
6 * Free Software Foundation.
8 * Based on driver from 2011:
9 * Juergen Beisert, Pengutronix <kernel@pengutronix.de>
11 * This is the driver for the imx25 TCQ (Touchscreen Conversion Queue)
12 * connected to the imx25 ADC.
15 #include <linux/clk.h>
16 #include <linux/device.h>
17 #include <linux/input.h>
18 #include <linux/interrupt.h>
19 #include <linux/mfd/imx25-tsadc.h>
20 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <linux/regmap.h>
25 static const char mx25_tcq_name[] = "mx25-tcq";
31 struct mx25_tcq_priv {
33 struct regmap *core_regs;
34 struct input_dev *idev;
35 enum mx25_tcq_mode mode;
36 unsigned int pen_threshold;
37 unsigned int sample_count;
38 unsigned int expected_samples;
39 unsigned int pen_debounce;
40 unsigned int settling_time;
46 static struct regmap_config mx25_tcq_regconfig = {
54 static const struct of_device_id mx25_tcq_ids[] = {
55 { .compatible = "fsl,imx25-tcq", },
58 MODULE_DEVICE_TABLE(of, mx25_tcq_ids);
60 #define TSC_4WIRE_PRE_INDEX 0
61 #define TSC_4WIRE_X_INDEX 1
62 #define TSC_4WIRE_Y_INDEX 2
63 #define TSC_4WIRE_POST_INDEX 3
64 #define TSC_4WIRE_LEAVE 4
66 #define MX25_TSC_DEF_THRESHOLD 80
67 #define TSC_MAX_SAMPLES 16
69 #define MX25_TSC_REPEAT_WAIT 14
71 enum mx25_adc_configurations {
72 MX25_CFG_PRECHARGE = 0,
73 MX25_CFG_TOUCH_DETECT,
74 MX25_CFG_X_MEASUREMENT,
75 MX25_CFG_Y_MEASUREMENT,
78 #define MX25_PRECHARGE_VALUE (\
79 MX25_ADCQ_CFG_YPLL_OFF | \
80 MX25_ADCQ_CFG_XNUR_OFF | \
81 MX25_ADCQ_CFG_XPUL_HIGH | \
82 MX25_ADCQ_CFG_REFP_INT | \
83 MX25_ADCQ_CFG_IN_XP | \
84 MX25_ADCQ_CFG_REFN_NGND2 | \
87 #define MX25_TOUCH_DETECT_VALUE (\
88 MX25_ADCQ_CFG_YNLR | \
89 MX25_ADCQ_CFG_YPLL_OFF | \
90 MX25_ADCQ_CFG_XNUR_OFF | \
91 MX25_ADCQ_CFG_XPUL_OFF | \
92 MX25_ADCQ_CFG_REFP_INT | \
93 MX25_ADCQ_CFG_IN_XP | \
94 MX25_ADCQ_CFG_REFN_NGND2 | \
95 MX25_ADCQ_CFG_PENIACK)
97 static void imx25_setup_queue_cfgs(struct mx25_tcq_priv *priv,
98 unsigned int settling_cnt)
101 MX25_PRECHARGE_VALUE |
102 MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
103 u32 touch_detect_cfg =
104 MX25_TOUCH_DETECT_VALUE |
105 MX25_ADCQ_CFG_NOS(1) |
106 MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
108 regmap_write(priv->core_regs, MX25_TSC_TICR, precharge_cfg);
111 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE),
115 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_TOUCH_DETECT),
119 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT),
120 MX25_ADCQ_CFG_YPLL_OFF |
121 MX25_ADCQ_CFG_XNUR_LOW |
122 MX25_ADCQ_CFG_XPUL_HIGH |
123 MX25_ADCQ_CFG_REFP_XP |
124 MX25_ADCQ_CFG_IN_YP |
125 MX25_ADCQ_CFG_REFN_XN |
126 MX25_ADCQ_CFG_NOS(priv->sample_count) |
127 MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
130 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_Y_MEASUREMENT),
132 MX25_ADCQ_CFG_YPLL_HIGH |
133 MX25_ADCQ_CFG_XNUR_OFF |
134 MX25_ADCQ_CFG_XPUL_OFF |
135 MX25_ADCQ_CFG_REFP_YP |
136 MX25_ADCQ_CFG_IN_XP |
137 MX25_ADCQ_CFG_REFN_YN |
138 MX25_ADCQ_CFG_NOS(priv->sample_count) |
139 MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
141 /* Enable the touch detection right now */
142 regmap_write(priv->core_regs, MX25_TSC_TICR, touch_detect_cfg |
146 static int imx25_setup_queue_4wire(struct mx25_tcq_priv *priv,
147 unsigned settling_cnt, int *items)
149 imx25_setup_queue_cfgs(priv, settling_cnt);
151 /* Setup the conversion queue */
152 regmap_write(priv->regs, MX25_ADCQ_ITEM_7_0,
153 MX25_ADCQ_ITEM(0, MX25_CFG_PRECHARGE) |
154 MX25_ADCQ_ITEM(1, MX25_CFG_TOUCH_DETECT) |
155 MX25_ADCQ_ITEM(2, MX25_CFG_X_MEASUREMENT) |
156 MX25_ADCQ_ITEM(3, MX25_CFG_Y_MEASUREMENT) |
157 MX25_ADCQ_ITEM(4, MX25_CFG_PRECHARGE) |
158 MX25_ADCQ_ITEM(5, MX25_CFG_TOUCH_DETECT));
161 * We measure X/Y with 'sample_count' number of samples and execute a
162 * touch detection twice, with 1 sample each
164 priv->expected_samples = priv->sample_count * 2 + 2;
170 static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv)
172 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK,
176 static void mx25_tcq_enable_touch_irq(struct mx25_tcq_priv *priv)
178 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, 0);
181 static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv)
183 regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ,
184 MX25_ADCQ_MR_FDRY_IRQ);
187 static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv)
189 regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, 0);
192 static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
194 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
199 static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv)
201 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
202 MX25_ADCQ_CR_FQS, 0);
205 static void mx25_tcq_fifo_reset(struct mx25_tcq_priv *priv)
209 regmap_read(priv->regs, MX25_ADCQ_CR, &tcqcr);
210 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST,
212 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, 0);
213 regmap_write(priv->regs, MX25_ADCQ_CR, tcqcr);
216 static void mx25_tcq_re_enable_touch_detection(struct mx25_tcq_priv *priv)
218 /* stop the queue from looping */
219 mx25_tcq_force_queue_stop(priv);
221 /* for a clean touch detection, preload the X plane */
222 regmap_write(priv->core_regs, MX25_TSC_TICR, MX25_PRECHARGE_VALUE);
224 /* waste some time now to pre-load the X plate to high voltage */
225 mx25_tcq_fifo_reset(priv);
227 /* re-enable the detection right now */
228 regmap_write(priv->core_regs, MX25_TSC_TICR,
229 MX25_TOUCH_DETECT_VALUE | MX25_ADCQ_CFG_IGS);
231 regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_PD,
234 /* enable the pen down event to be a source for the interrupt */
235 regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_PD_IRQ, 0);
237 /* lets fire the next IRQ if someone touches the touchscreen */
238 mx25_tcq_enable_touch_irq(priv);
241 static void mx25_tcq_create_event_for_4wire(struct mx25_tcq_priv *priv,
243 unsigned int samples)
245 unsigned int x_pos = 0;
246 unsigned int y_pos = 0;
247 unsigned int touch_pre = 0;
248 unsigned int touch_post = 0;
251 for (i = 0; i < samples; i++) {
252 unsigned int index = MX25_ADCQ_FIFO_ID(sample_buf[i]);
253 unsigned int val = MX25_ADCQ_FIFO_DATA(sample_buf[i]);
269 dev_dbg(priv->dev, "Dropped samples because of invalid index %d\n",
277 * only if both touch measures are below a threshold,
278 * the position is valid
280 if (touch_pre < priv->pen_threshold &&
281 touch_post < priv->pen_threshold) {
282 /* valid samples, generate a report */
283 x_pos /= priv->sample_count;
284 y_pos /= priv->sample_count;
285 input_report_abs(priv->idev, ABS_X, x_pos);
286 input_report_abs(priv->idev, ABS_Y, y_pos);
287 input_report_key(priv->idev, BTN_TOUCH, 1);
288 input_sync(priv->idev);
290 /* get next sample */
291 mx25_tcq_enable_fifo_irq(priv);
292 } else if (touch_pre >= priv->pen_threshold &&
293 touch_post >= priv->pen_threshold) {
295 * if both samples are invalid,
296 * generate a release report
298 input_report_key(priv->idev, BTN_TOUCH, 0);
299 input_sync(priv->idev);
300 mx25_tcq_re_enable_touch_detection(priv);
303 * if only one of both touch measurements are
304 * below the threshold, still some bouncing
305 * happens. Take additional samples in this
308 mx25_tcq_enable_fifo_irq(priv);
313 static irqreturn_t mx25_tcq_irq_thread(int irq, void *dev_id)
315 struct mx25_tcq_priv *priv = dev_id;
316 u32 sample_buf[TSC_MAX_SAMPLES];
317 unsigned int samples;
322 * Check how many samples are available. We always have to read exactly
323 * sample_count samples from the fifo, or a multiple of sample_count.
324 * Otherwise we mixup samples into different touch events.
326 regmap_read(priv->regs, MX25_ADCQ_SR, &stats);
327 samples = MX25_ADCQ_SR_FDN(stats);
328 samples -= samples % priv->sample_count;
333 for (i = 0; i != samples; ++i)
334 regmap_read(priv->regs, MX25_ADCQ_FIFO, &sample_buf[i]);
336 mx25_tcq_create_event_for_4wire(priv, sample_buf, samples);
341 static irqreturn_t mx25_tcq_irq(int irq, void *dev_id)
343 struct mx25_tcq_priv *priv = dev_id;
345 int ret = IRQ_HANDLED;
347 regmap_read(priv->regs, MX25_ADCQ_SR, &stat);
349 if (stat & (MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR))
350 mx25_tcq_re_enable_touch_detection(priv);
352 if (stat & MX25_ADCQ_SR_PD) {
353 mx25_tcq_disable_touch_irq(priv);
354 mx25_tcq_force_queue_start(priv);
355 mx25_tcq_enable_fifo_irq(priv);
358 if (stat & MX25_ADCQ_SR_FDRY) {
359 mx25_tcq_disable_fifo_irq(priv);
360 ret = IRQ_WAKE_THREAD;
363 regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_FRR |
364 MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR |
366 MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR |
367 MX25_ADCQ_SR_FOR | MX25_ADCQ_SR_PD);
372 /* configure the state machine for a 4-wire touchscreen */
373 static int mx25_tcq_init(struct mx25_tcq_priv *priv)
376 unsigned int ipg_div;
377 unsigned int adc_period;
378 unsigned int debounce_cnt;
379 unsigned int settling_cnt;
383 regmap_read(priv->core_regs, MX25_TSC_TGCR, &tgcr);
384 ipg_div = max_t(unsigned int, 4, MX25_TGCR_GET_ADCCLK(tgcr));
385 adc_period = USEC_PER_SEC * ipg_div * 2 + 2;
386 adc_period /= clk_get_rate(priv->clk) / 1000 + 1;
387 debounce_cnt = DIV_ROUND_UP(priv->pen_debounce, adc_period * 8) - 1;
388 settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1;
391 regmap_write(priv->regs, MX25_ADCQ_CR,
392 MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST);
393 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
394 MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST, 0);
396 /* up to 128 * 8 ADC clocks are possible */
397 if (debounce_cnt > 127)
400 /* up to 255 * 8 ADC clocks are possible */
401 if (settling_cnt > 255)
404 error = imx25_setup_queue_4wire(priv, settling_cnt, &itemct);
408 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
409 MX25_ADCQ_CR_LITEMID_MASK | MX25_ADCQ_CR_WMRK_MASK,
410 MX25_ADCQ_CR_LITEMID(itemct - 1) |
411 MX25_ADCQ_CR_WMRK(priv->expected_samples - 1));
413 /* setup debounce count */
414 regmap_update_bits(priv->core_regs, MX25_TSC_TGCR,
415 MX25_TGCR_PDBTIME_MASK,
416 MX25_TGCR_PDBTIME(debounce_cnt));
418 /* enable debounce */
419 regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN,
421 regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDEN,
424 /* enable the engine on demand */
425 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_QSM_MASK,
426 MX25_ADCQ_CR_QSM_FQS);
428 /* Enable repeat and repeat wait */
429 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
430 MX25_ADCQ_CR_RPT | MX25_ADCQ_CR_RWAIT_MASK,
432 MX25_ADCQ_CR_RWAIT(MX25_TSC_REPEAT_WAIT));
437 static int mx25_tcq_parse_dt(struct platform_device *pdev,
438 struct mx25_tcq_priv *priv)
440 struct device_node *np = pdev->dev.of_node;
445 priv->pen_threshold = 500;
446 priv->sample_count = 3;
447 priv->pen_debounce = 1000000;
448 priv->settling_time = 250000;
450 error = of_property_read_u32(np, "fsl,wires", &wires);
452 dev_err(&pdev->dev, "Failed to find fsl,wires properties\n");
457 priv->mode = MX25_TS_4WIRE;
459 dev_err(&pdev->dev, "%u-wire mode not supported\n", wires);
463 /* These are optional, we don't care about the return values */
464 of_property_read_u32(np, "fsl,pen-threshold", &priv->pen_threshold);
465 of_property_read_u32(np, "fsl,settling-time-ns", &priv->settling_time);
466 of_property_read_u32(np, "fsl,pen-debounce-ns", &priv->pen_debounce);
471 static int mx25_tcq_open(struct input_dev *idev)
473 struct device *dev = &idev->dev;
474 struct mx25_tcq_priv *priv = dev_get_drvdata(dev);
477 error = clk_prepare_enable(priv->clk);
479 dev_err(dev, "Failed to enable ipg clock\n");
483 error = mx25_tcq_init(priv);
485 dev_err(dev, "Failed to init tcq\n");
486 clk_disable_unprepare(priv->clk);
490 mx25_tcq_re_enable_touch_detection(priv);
495 static void mx25_tcq_close(struct input_dev *idev)
497 struct mx25_tcq_priv *priv = input_get_drvdata(idev);
499 mx25_tcq_force_queue_stop(priv);
500 mx25_tcq_disable_touch_irq(priv);
501 mx25_tcq_disable_fifo_irq(priv);
502 clk_disable_unprepare(priv->clk);
505 static int mx25_tcq_probe(struct platform_device *pdev)
507 struct device *dev = &pdev->dev;
508 struct input_dev *idev;
509 struct mx25_tcq_priv *priv;
510 struct mx25_tsadc *tsadc = dev_get_drvdata(dev->parent);
511 struct resource *res;
515 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
520 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
521 mem = devm_ioremap_resource(dev, res);
525 error = mx25_tcq_parse_dt(pdev, priv);
529 priv->regs = devm_regmap_init_mmio(dev, mem, &mx25_tcq_regconfig);
530 if (IS_ERR(priv->regs)) {
531 dev_err(dev, "Failed to initialize regmap\n");
532 return PTR_ERR(priv->regs);
535 priv->irq = platform_get_irq(pdev, 0);
536 if (priv->irq <= 0) {
537 dev_err(dev, "Failed to get IRQ\n");
541 idev = devm_input_allocate_device(dev);
543 dev_err(dev, "Failed to allocate input device\n");
547 idev->name = mx25_tcq_name;
548 input_set_capability(idev, EV_KEY, BTN_TOUCH);
549 input_set_abs_params(idev, ABS_X, 0, 0xfff, 0, 0);
550 input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);
552 idev->id.bustype = BUS_HOST;
553 idev->open = mx25_tcq_open;
554 idev->close = mx25_tcq_close;
557 input_set_drvdata(idev, priv);
559 priv->core_regs = tsadc->regs;
560 if (!priv->core_regs)
563 priv->clk = tsadc->clk;
567 platform_set_drvdata(pdev, priv);
569 error = devm_request_threaded_irq(dev, priv->irq, mx25_tcq_irq,
570 mx25_tcq_irq_thread, 0, pdev->name,
573 dev_err(dev, "Failed requesting IRQ\n");
577 error = input_register_device(idev);
579 dev_err(dev, "Failed to register input device\n");
586 static struct platform_driver mx25_tcq_driver = {
589 .of_match_table = mx25_tcq_ids,
591 .probe = mx25_tcq_probe,
593 module_platform_driver(mx25_tcq_driver);
595 MODULE_DESCRIPTION("TS input driver for Freescale mx25");
596 MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
597 MODULE_LICENSE("GPL v2");