1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * LPC32xx built-in touchscreen driver
4  *
5  * Copyright (C) 2010 NXP Semiconductors
6  */
7 
8 #include <linux/platform_device.h>
9 #include <linux/input.h>
10 #include <linux/interrupt.h>
11 #include <linux/module.h>
12 #include <linux/clk.h>
13 #include <linux/io.h>
14 #include <linux/slab.h>
15 #include <linux/of.h>
16 
17 /*
18  * Touchscreen controller register offsets
19  */
20 #define LPC32XX_TSC_STAT			0x00
21 #define LPC32XX_TSC_SEL				0x04
22 #define LPC32XX_TSC_CON				0x08
23 #define LPC32XX_TSC_FIFO			0x0C
24 #define LPC32XX_TSC_DTR				0x10
25 #define LPC32XX_TSC_RTR				0x14
26 #define LPC32XX_TSC_UTR				0x18
27 #define LPC32XX_TSC_TTR				0x1C
28 #define LPC32XX_TSC_DXP				0x20
29 #define LPC32XX_TSC_MIN_X			0x24
30 #define LPC32XX_TSC_MAX_X			0x28
31 #define LPC32XX_TSC_MIN_Y			0x2C
32 #define LPC32XX_TSC_MAX_Y			0x30
33 #define LPC32XX_TSC_AUX_UTR			0x34
34 #define LPC32XX_TSC_AUX_MIN			0x38
35 #define LPC32XX_TSC_AUX_MAX			0x3C
36 
37 #define LPC32XX_TSC_STAT_FIFO_OVRRN		BIT(8)
38 #define LPC32XX_TSC_STAT_FIFO_EMPTY		BIT(7)
39 
40 #define LPC32XX_TSC_SEL_DEFVAL			0x0284
41 
42 #define LPC32XX_TSC_ADCCON_IRQ_TO_FIFO_4	(0x1 << 11)
43 #define LPC32XX_TSC_ADCCON_X_SAMPLE_SIZE(s)	((10 - (s)) << 7)
44 #define LPC32XX_TSC_ADCCON_Y_SAMPLE_SIZE(s)	((10 - (s)) << 4)
45 #define LPC32XX_TSC_ADCCON_POWER_UP		BIT(2)
46 #define LPC32XX_TSC_ADCCON_AUTO_EN		BIT(0)
47 
48 #define LPC32XX_TSC_FIFO_TS_P_LEVEL		BIT(31)
49 #define LPC32XX_TSC_FIFO_NORMALIZE_X_VAL(x)	(((x) & 0x03FF0000) >> 16)
50 #define LPC32XX_TSC_FIFO_NORMALIZE_Y_VAL(y)	((y) & 0x000003FF)
51 
52 #define LPC32XX_TSC_ADCDAT_VALUE_MASK		0x000003FF
53 
54 #define LPC32XX_TSC_MIN_XY_VAL			0x0
55 #define LPC32XX_TSC_MAX_XY_VAL			0x3FF
56 
57 #define MOD_NAME "ts-lpc32xx"
58 
59 #define tsc_readl(dev, reg) \
60 	__raw_readl((dev)->tsc_base + (reg))
61 #define tsc_writel(dev, reg, val) \
62 	__raw_writel((val), (dev)->tsc_base + (reg))
63 
64 struct lpc32xx_tsc {
65 	struct input_dev *dev;
66 	void __iomem *tsc_base;
67 	int irq;
68 	struct clk *clk;
69 };
70 
71 static void lpc32xx_fifo_clear(struct lpc32xx_tsc *tsc)
72 {
73 	while (!(tsc_readl(tsc, LPC32XX_TSC_STAT) &
74 			LPC32XX_TSC_STAT_FIFO_EMPTY))
75 		tsc_readl(tsc, LPC32XX_TSC_FIFO);
76 }
77 
78 static irqreturn_t lpc32xx_ts_interrupt(int irq, void *dev_id)
79 {
80 	u32 tmp, rv[4], xs[4], ys[4];
81 	int idx;
82 	struct lpc32xx_tsc *tsc = dev_id;
83 	struct input_dev *input = tsc->dev;
84 
85 	tmp = tsc_readl(tsc, LPC32XX_TSC_STAT);
86 
87 	if (tmp & LPC32XX_TSC_STAT_FIFO_OVRRN) {
88 		/* FIFO overflow - throw away samples */
89 		lpc32xx_fifo_clear(tsc);
90 		return IRQ_HANDLED;
91 	}
92 
93 	/*
94 	 * Gather and normalize 4 samples. Pen-up events may have less
95 	 * than 4 samples, but its ok to pop 4 and let the last sample
96 	 * pen status check drop the samples.
97 	 */
98 	idx = 0;
99 	while (idx < 4 &&
100 	       !(tsc_readl(tsc, LPC32XX_TSC_STAT) &
101 			LPC32XX_TSC_STAT_FIFO_EMPTY)) {
102 		tmp = tsc_readl(tsc, LPC32XX_TSC_FIFO);
103 		xs[idx] = LPC32XX_TSC_ADCDAT_VALUE_MASK -
104 			LPC32XX_TSC_FIFO_NORMALIZE_X_VAL(tmp);
105 		ys[idx] = LPC32XX_TSC_ADCDAT_VALUE_MASK -
106 			LPC32XX_TSC_FIFO_NORMALIZE_Y_VAL(tmp);
107 		rv[idx] = tmp;
108 		idx++;
109 	}
110 
111 	/* Data is only valid if pen is still down in last sample */
112 	if (!(rv[3] & LPC32XX_TSC_FIFO_TS_P_LEVEL) && idx == 4) {
113 		/* Use average of 2nd and 3rd sample for position */
114 		input_report_abs(input, ABS_X, (xs[1] + xs[2]) / 2);
115 		input_report_abs(input, ABS_Y, (ys[1] + ys[2]) / 2);
116 		input_report_key(input, BTN_TOUCH, 1);
117 	} else {
118 		input_report_key(input, BTN_TOUCH, 0);
119 	}
120 
121 	input_sync(input);
122 
123 	return IRQ_HANDLED;
124 }
125 
126 static void lpc32xx_stop_tsc(struct lpc32xx_tsc *tsc)
127 {
128 	/* Disable auto mode */
129 	tsc_writel(tsc, LPC32XX_TSC_CON,
130 		   tsc_readl(tsc, LPC32XX_TSC_CON) &
131 			     ~LPC32XX_TSC_ADCCON_AUTO_EN);
132 
133 	clk_disable_unprepare(tsc->clk);
134 }
135 
136 static int lpc32xx_setup_tsc(struct lpc32xx_tsc *tsc)
137 {
138 	u32 tmp;
139 	int err;
140 
141 	err = clk_prepare_enable(tsc->clk);
142 	if (err)
143 		return err;
144 
145 	tmp = tsc_readl(tsc, LPC32XX_TSC_CON) & ~LPC32XX_TSC_ADCCON_POWER_UP;
146 
147 	/* Set the TSC FIFO depth to 4 samples @ 10-bits per sample (max) */
148 	tmp = LPC32XX_TSC_ADCCON_IRQ_TO_FIFO_4 |
149 	      LPC32XX_TSC_ADCCON_X_SAMPLE_SIZE(10) |
150 	      LPC32XX_TSC_ADCCON_Y_SAMPLE_SIZE(10);
151 	tsc_writel(tsc, LPC32XX_TSC_CON, tmp);
152 
153 	/* These values are all preset */
154 	tsc_writel(tsc, LPC32XX_TSC_SEL, LPC32XX_TSC_SEL_DEFVAL);
155 	tsc_writel(tsc, LPC32XX_TSC_MIN_X, LPC32XX_TSC_MIN_XY_VAL);
156 	tsc_writel(tsc, LPC32XX_TSC_MAX_X, LPC32XX_TSC_MAX_XY_VAL);
157 	tsc_writel(tsc, LPC32XX_TSC_MIN_Y, LPC32XX_TSC_MIN_XY_VAL);
158 	tsc_writel(tsc, LPC32XX_TSC_MAX_Y, LPC32XX_TSC_MAX_XY_VAL);
159 
160 	/* Aux support is not used */
161 	tsc_writel(tsc, LPC32XX_TSC_AUX_UTR, 0);
162 	tsc_writel(tsc, LPC32XX_TSC_AUX_MIN, 0);
163 	tsc_writel(tsc, LPC32XX_TSC_AUX_MAX, 0);
164 
165 	/*
166 	 * Set sample rate to about 240Hz per X/Y pair. A single measurement
167 	 * consists of 4 pairs which gives about a 60Hz sample rate based on
168 	 * a stable 32768Hz clock source. Values are in clocks.
169 	 * Rate is (32768 / (RTR + XCONV + RTR + YCONV + DXP + TTR + UTR) / 4
170 	 */
171 	tsc_writel(tsc, LPC32XX_TSC_RTR, 0x2);
172 	tsc_writel(tsc, LPC32XX_TSC_DTR, 0x2);
173 	tsc_writel(tsc, LPC32XX_TSC_TTR, 0x10);
174 	tsc_writel(tsc, LPC32XX_TSC_DXP, 0x4);
175 	tsc_writel(tsc, LPC32XX_TSC_UTR, 88);
176 
177 	lpc32xx_fifo_clear(tsc);
178 
179 	/* Enable automatic ts event capture */
180 	tsc_writel(tsc, LPC32XX_TSC_CON, tmp | LPC32XX_TSC_ADCCON_AUTO_EN);
181 
182 	return 0;
183 }
184 
185 static int lpc32xx_ts_open(struct input_dev *dev)
186 {
187 	struct lpc32xx_tsc *tsc = input_get_drvdata(dev);
188 
189 	return lpc32xx_setup_tsc(tsc);
190 }
191 
192 static void lpc32xx_ts_close(struct input_dev *dev)
193 {
194 	struct lpc32xx_tsc *tsc = input_get_drvdata(dev);
195 
196 	lpc32xx_stop_tsc(tsc);
197 }
198 
199 static int lpc32xx_ts_probe(struct platform_device *pdev)
200 {
201 	struct lpc32xx_tsc *tsc;
202 	struct input_dev *input;
203 	struct resource *res;
204 	resource_size_t size;
205 	int irq;
206 	int error;
207 
208 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
209 	if (!res) {
210 		dev_err(&pdev->dev, "Can't get memory resource\n");
211 		return -ENOENT;
212 	}
213 
214 	irq = platform_get_irq(pdev, 0);
215 	if (irq < 0)
216 		return irq;
217 
218 	tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
219 	input = input_allocate_device();
220 	if (!tsc || !input) {
221 		dev_err(&pdev->dev, "failed allocating memory\n");
222 		error = -ENOMEM;
223 		goto err_free_mem;
224 	}
225 
226 	tsc->dev = input;
227 	tsc->irq = irq;
228 
229 	size = resource_size(res);
230 
231 	if (!request_mem_region(res->start, size, pdev->name)) {
232 		dev_err(&pdev->dev, "TSC registers are not free\n");
233 		error = -EBUSY;
234 		goto err_free_mem;
235 	}
236 
237 	tsc->tsc_base = ioremap(res->start, size);
238 	if (!tsc->tsc_base) {
239 		dev_err(&pdev->dev, "Can't map memory\n");
240 		error = -ENOMEM;
241 		goto err_release_mem;
242 	}
243 
244 	tsc->clk = clk_get(&pdev->dev, NULL);
245 	if (IS_ERR(tsc->clk)) {
246 		dev_err(&pdev->dev, "failed getting clock\n");
247 		error = PTR_ERR(tsc->clk);
248 		goto err_unmap;
249 	}
250 
251 	input->name = MOD_NAME;
252 	input->phys = "lpc32xx/input0";
253 	input->id.bustype = BUS_HOST;
254 	input->id.vendor = 0x0001;
255 	input->id.product = 0x0002;
256 	input->id.version = 0x0100;
257 	input->dev.parent = &pdev->dev;
258 	input->open = lpc32xx_ts_open;
259 	input->close = lpc32xx_ts_close;
260 
261 	input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
262 	input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
263 	input_set_abs_params(input, ABS_X, LPC32XX_TSC_MIN_XY_VAL,
264 			     LPC32XX_TSC_MAX_XY_VAL, 0, 0);
265 	input_set_abs_params(input, ABS_Y, LPC32XX_TSC_MIN_XY_VAL,
266 			     LPC32XX_TSC_MAX_XY_VAL, 0, 0);
267 
268 	input_set_drvdata(input, tsc);
269 
270 	error = request_irq(tsc->irq, lpc32xx_ts_interrupt,
271 			    0, pdev->name, tsc);
272 	if (error) {
273 		dev_err(&pdev->dev, "failed requesting interrupt\n");
274 		goto err_put_clock;
275 	}
276 
277 	error = input_register_device(input);
278 	if (error) {
279 		dev_err(&pdev->dev, "failed registering input device\n");
280 		goto err_free_irq;
281 	}
282 
283 	platform_set_drvdata(pdev, tsc);
284 	device_init_wakeup(&pdev->dev, 1);
285 
286 	return 0;
287 
288 err_free_irq:
289 	free_irq(tsc->irq, tsc);
290 err_put_clock:
291 	clk_put(tsc->clk);
292 err_unmap:
293 	iounmap(tsc->tsc_base);
294 err_release_mem:
295 	release_mem_region(res->start, size);
296 err_free_mem:
297 	input_free_device(input);
298 	kfree(tsc);
299 
300 	return error;
301 }
302 
303 static int lpc32xx_ts_remove(struct platform_device *pdev)
304 {
305 	struct lpc32xx_tsc *tsc = platform_get_drvdata(pdev);
306 	struct resource *res;
307 
308 	free_irq(tsc->irq, tsc);
309 
310 	input_unregister_device(tsc->dev);
311 
312 	clk_put(tsc->clk);
313 
314 	iounmap(tsc->tsc_base);
315 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
316 	release_mem_region(res->start, resource_size(res));
317 
318 	kfree(tsc);
319 
320 	return 0;
321 }
322 
323 #ifdef CONFIG_PM
324 static int lpc32xx_ts_suspend(struct device *dev)
325 {
326 	struct lpc32xx_tsc *tsc = dev_get_drvdata(dev);
327 	struct input_dev *input = tsc->dev;
328 
329 	/*
330 	 * Suspend and resume can be called when the device hasn't been
331 	 * enabled. If there are no users that have the device open, then
332 	 * avoid calling the TSC stop and start functions as the TSC
333 	 * isn't yet clocked.
334 	 */
335 	mutex_lock(&input->mutex);
336 
337 	if (input_device_enabled(input)) {
338 		if (device_may_wakeup(dev))
339 			enable_irq_wake(tsc->irq);
340 		else
341 			lpc32xx_stop_tsc(tsc);
342 	}
343 
344 	mutex_unlock(&input->mutex);
345 
346 	return 0;
347 }
348 
349 static int lpc32xx_ts_resume(struct device *dev)
350 {
351 	struct lpc32xx_tsc *tsc = dev_get_drvdata(dev);
352 	struct input_dev *input = tsc->dev;
353 
354 	mutex_lock(&input->mutex);
355 
356 	if (input_device_enabled(input)) {
357 		if (device_may_wakeup(dev))
358 			disable_irq_wake(tsc->irq);
359 		else
360 			lpc32xx_setup_tsc(tsc);
361 	}
362 
363 	mutex_unlock(&input->mutex);
364 
365 	return 0;
366 }
367 
368 static const struct dev_pm_ops lpc32xx_ts_pm_ops = {
369 	.suspend	= lpc32xx_ts_suspend,
370 	.resume		= lpc32xx_ts_resume,
371 };
372 #define LPC32XX_TS_PM_OPS (&lpc32xx_ts_pm_ops)
373 #else
374 #define LPC32XX_TS_PM_OPS NULL
375 #endif
376 
377 #ifdef CONFIG_OF
378 static const struct of_device_id lpc32xx_tsc_of_match[] = {
379 	{ .compatible = "nxp,lpc3220-tsc", },
380 	{ },
381 };
382 MODULE_DEVICE_TABLE(of, lpc32xx_tsc_of_match);
383 #endif
384 
385 static struct platform_driver lpc32xx_ts_driver = {
386 	.probe		= lpc32xx_ts_probe,
387 	.remove		= lpc32xx_ts_remove,
388 	.driver		= {
389 		.name	= MOD_NAME,
390 		.pm	= LPC32XX_TS_PM_OPS,
391 		.of_match_table = of_match_ptr(lpc32xx_tsc_of_match),
392 	},
393 };
394 module_platform_driver(lpc32xx_ts_driver);
395 
396 MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com");
397 MODULE_DESCRIPTION("LPC32XX TSC Driver");
398 MODULE_LICENSE("GPL");
399 MODULE_ALIAS("platform:lpc32xx_ts");
400