1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * AD7879/AD7889 based touchscreen and GPIO driver
4  *
5  * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
6  *
7  * History:
8  * Copyright (c) 2005 David Brownell
9  * Copyright (c) 2006 Nokia Corporation
10  * Various changes: Imre Deak <imre.deak@nokia.com>
11  *
12  * Using code from:
13  *  - corgi_ts.c
14  *	Copyright (C) 2004-2005 Richard Purdie
15  *  - omap_ts.[hc], ads7846.h, ts_osk.c
16  *	Copyright (C) 2002 MontaVista Software
17  *	Copyright (C) 2004 Texas Instruments
18  *	Copyright (C) 2005 Dirk Behme
19  *  - ad7877.c
20  *	Copyright (C) 2006-2008 Analog Devices Inc.
21  */
22 
23 #include <linux/device.h>
24 #include <linux/delay.h>
25 #include <linux/input.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/property.h>
29 #include <linux/regmap.h>
30 #include <linux/slab.h>
31 #include <linux/gpio/driver.h>
32 
33 #include <linux/input/touchscreen.h>
34 #include <linux/module.h>
35 #include "ad7879.h"
36 
37 #define AD7879_REG_ZEROS		0
38 #define AD7879_REG_CTRL1		1
39 #define AD7879_REG_CTRL2		2
40 #define AD7879_REG_CTRL3		3
41 #define AD7879_REG_AUX1HIGH		4
42 #define AD7879_REG_AUX1LOW		5
43 #define AD7879_REG_TEMP1HIGH		6
44 #define AD7879_REG_TEMP1LOW		7
45 #define AD7879_REG_XPLUS		8
46 #define AD7879_REG_YPLUS		9
47 #define AD7879_REG_Z1			10
48 #define AD7879_REG_Z2			11
49 #define AD7879_REG_AUXVBAT		12
50 #define AD7879_REG_TEMP			13
51 #define AD7879_REG_REVID		14
52 
53 /* Control REG 1 */
54 #define AD7879_TMR(x)			((x & 0xFF) << 0)
55 #define AD7879_ACQ(x)			((x & 0x3) << 8)
56 #define AD7879_MODE_NOC			(0 << 10)	/* Do not convert */
57 #define AD7879_MODE_SCC			(1 << 10)	/* Single channel conversion */
58 #define AD7879_MODE_SEQ0		(2 << 10)	/* Sequence 0 in Slave Mode */
59 #define AD7879_MODE_SEQ1		(3 << 10)	/* Sequence 1 in Master Mode */
60 #define AD7879_MODE_INT			(1 << 15)	/* PENIRQ disabled INT enabled */
61 
62 /* Control REG 2 */
63 #define AD7879_FCD(x)			((x & 0x3) << 0)
64 #define AD7879_RESET			(1 << 4)
65 #define AD7879_MFS(x)			((x & 0x3) << 5)
66 #define AD7879_AVG(x)			((x & 0x3) << 7)
67 #define	AD7879_SER			(1 << 9)	/* non-differential */
68 #define	AD7879_DFR			(0 << 9)	/* differential */
69 #define AD7879_GPIOPOL			(1 << 10)
70 #define AD7879_GPIODIR			(1 << 11)
71 #define AD7879_GPIO_DATA		(1 << 12)
72 #define AD7879_GPIO_EN			(1 << 13)
73 #define AD7879_PM(x)			((x & 0x3) << 14)
74 #define AD7879_PM_SHUTDOWN		(0)
75 #define AD7879_PM_DYN			(1)
76 #define AD7879_PM_FULLON		(2)
77 
78 /* Control REG 3 */
79 #define AD7879_TEMPMASK_BIT		(1<<15)
80 #define AD7879_AUXVBATMASK_BIT		(1<<14)
81 #define AD7879_INTMODE_BIT		(1<<13)
82 #define AD7879_GPIOALERTMASK_BIT	(1<<12)
83 #define AD7879_AUXLOW_BIT		(1<<11)
84 #define AD7879_AUXHIGH_BIT		(1<<10)
85 #define AD7879_TEMPLOW_BIT		(1<<9)
86 #define AD7879_TEMPHIGH_BIT		(1<<8)
87 #define AD7879_YPLUS_BIT		(1<<7)
88 #define AD7879_XPLUS_BIT		(1<<6)
89 #define AD7879_Z1_BIT			(1<<5)
90 #define AD7879_Z2_BIT			(1<<4)
91 #define AD7879_AUX_BIT			(1<<3)
92 #define AD7879_VBAT_BIT			(1<<2)
93 #define AD7879_TEMP_BIT			(1<<1)
94 
95 enum {
96 	AD7879_SEQ_YPOS  = 0,
97 	AD7879_SEQ_XPOS  = 1,
98 	AD7879_SEQ_Z1    = 2,
99 	AD7879_SEQ_Z2    = 3,
100 	AD7879_NR_SENSE  = 4,
101 };
102 
103 #define	MAX_12BIT			((1<<12)-1)
104 #define	TS_PEN_UP_TIMEOUT		msecs_to_jiffies(50)
105 
106 struct ad7879 {
107 	struct regmap		*regmap;
108 	struct device		*dev;
109 	struct input_dev	*input;
110 	struct timer_list	timer;
111 #ifdef CONFIG_GPIOLIB
112 	struct gpio_chip	gc;
113 	struct mutex		mutex;
114 #endif
115 	unsigned int		irq;
116 	bool			disabled;	/* P: input->mutex */
117 	bool			suspended;	/* P: input->mutex */
118 	bool			swap_xy;
119 	u16			conversion_data[AD7879_NR_SENSE];
120 	char			phys[32];
121 	u8			first_conversion_delay;
122 	u8			acquisition_time;
123 	u8			averaging;
124 	u8			pen_down_acc_interval;
125 	u8			median;
126 	u16			x_plate_ohms;
127 	u16			cmd_crtl1;
128 	u16			cmd_crtl2;
129 	u16			cmd_crtl3;
130 	int			x;
131 	int			y;
132 	int			Rt;
133 };
134 
135 static int ad7879_read(struct ad7879 *ts, u8 reg)
136 {
137 	unsigned int val;
138 	int error;
139 
140 	error = regmap_read(ts->regmap, reg, &val);
141 	if (error) {
142 		dev_err(ts->dev, "failed to read register %#02x: %d\n",
143 			reg, error);
144 		return error;
145 	}
146 
147 	return val;
148 }
149 
150 static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
151 {
152 	int error;
153 
154 	error = regmap_write(ts->regmap, reg, val);
155 	if (error) {
156 		dev_err(ts->dev,
157 			"failed to write %#04x to register %#02x: %d\n",
158 			val, reg, error);
159 		return error;
160 	}
161 
162 	return 0;
163 }
164 
165 static int ad7879_report(struct ad7879 *ts)
166 {
167 	struct input_dev *input_dev = ts->input;
168 	unsigned Rt;
169 	u16 x, y, z1, z2;
170 
171 	x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT;
172 	y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT;
173 	z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
174 	z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;
175 
176 	if (ts->swap_xy)
177 		swap(x, y);
178 
179 	/*
180 	 * The samples processed here are already preprocessed by the AD7879.
181 	 * The preprocessing function consists of a median and an averaging
182 	 * filter.  The combination of these two techniques provides a robust
183 	 * solution, discarding the spurious noise in the signal and keeping
184 	 * only the data of interest.  The size of both filters is
185 	 * programmable. (dev.platform_data, see linux/platform_data/ad7879.h)
186 	 * Other user-programmable conversion controls include variable
187 	 * acquisition time, and first conversion delay. Up to 16 averages can
188 	 * be taken per conversion.
189 	 */
190 
191 	if (likely(x && z1)) {
192 		/* compute touch pressure resistance using equation #1 */
193 		Rt = (z2 - z1) * x * ts->x_plate_ohms;
194 		Rt /= z1;
195 		Rt = (Rt + 2047) >> 12;
196 
197 		/*
198 		 * Sample found inconsistent, pressure is beyond
199 		 * the maximum. Don't report it to user space.
200 		 */
201 		if (Rt > input_abs_get_max(input_dev, ABS_PRESSURE))
202 			return -EINVAL;
203 
204 		/*
205 		 * Note that we delay reporting events by one sample.
206 		 * This is done to avoid reporting last sample of the
207 		 * touch sequence, which may be incomplete if finger
208 		 * leaves the surface before last reading is taken.
209 		 */
210 		if (timer_pending(&ts->timer)) {
211 			/* Touch continues */
212 			input_report_key(input_dev, BTN_TOUCH, 1);
213 			input_report_abs(input_dev, ABS_X, ts->x);
214 			input_report_abs(input_dev, ABS_Y, ts->y);
215 			input_report_abs(input_dev, ABS_PRESSURE, ts->Rt);
216 			input_sync(input_dev);
217 		}
218 
219 		ts->x = x;
220 		ts->y = y;
221 		ts->Rt = Rt;
222 
223 		return 0;
224 	}
225 
226 	return -EINVAL;
227 }
228 
229 static void ad7879_ts_event_release(struct ad7879 *ts)
230 {
231 	struct input_dev *input_dev = ts->input;
232 
233 	input_report_abs(input_dev, ABS_PRESSURE, 0);
234 	input_report_key(input_dev, BTN_TOUCH, 0);
235 	input_sync(input_dev);
236 }
237 
238 static void ad7879_timer(struct timer_list *t)
239 {
240 	struct ad7879 *ts = from_timer(ts, t, timer);
241 
242 	ad7879_ts_event_release(ts);
243 }
244 
245 static irqreturn_t ad7879_irq(int irq, void *handle)
246 {
247 	struct ad7879 *ts = handle;
248 	int error;
249 
250 	error = regmap_bulk_read(ts->regmap, AD7879_REG_XPLUS,
251 				 ts->conversion_data, AD7879_NR_SENSE);
252 	if (error)
253 		dev_err_ratelimited(ts->dev, "failed to read %#02x: %d\n",
254 				    AD7879_REG_XPLUS, error);
255 	else if (!ad7879_report(ts))
256 		mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
257 
258 	return IRQ_HANDLED;
259 }
260 
261 static void __ad7879_enable(struct ad7879 *ts)
262 {
263 	ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
264 	ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
265 	ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);
266 
267 	enable_irq(ts->irq);
268 }
269 
270 static void __ad7879_disable(struct ad7879 *ts)
271 {
272 	u16 reg = (ts->cmd_crtl2 & ~AD7879_PM(-1)) |
273 		AD7879_PM(AD7879_PM_SHUTDOWN);
274 	disable_irq(ts->irq);
275 
276 	if (del_timer_sync(&ts->timer))
277 		ad7879_ts_event_release(ts);
278 
279 	ad7879_write(ts, AD7879_REG_CTRL2, reg);
280 }
281 
282 
283 static int ad7879_open(struct input_dev *input)
284 {
285 	struct ad7879 *ts = input_get_drvdata(input);
286 
287 	/* protected by input->mutex */
288 	if (!ts->disabled && !ts->suspended)
289 		__ad7879_enable(ts);
290 
291 	return 0;
292 }
293 
294 static void ad7879_close(struct input_dev *input)
295 {
296 	struct ad7879 *ts = input_get_drvdata(input);
297 
298 	/* protected by input->mutex */
299 	if (!ts->disabled && !ts->suspended)
300 		__ad7879_disable(ts);
301 }
302 
303 static int __maybe_unused ad7879_suspend(struct device *dev)
304 {
305 	struct ad7879 *ts = dev_get_drvdata(dev);
306 
307 	mutex_lock(&ts->input->mutex);
308 
309 	if (!ts->suspended && !ts->disabled && input_device_enabled(ts->input))
310 		__ad7879_disable(ts);
311 
312 	ts->suspended = true;
313 
314 	mutex_unlock(&ts->input->mutex);
315 
316 	return 0;
317 }
318 
319 static int __maybe_unused ad7879_resume(struct device *dev)
320 {
321 	struct ad7879 *ts = dev_get_drvdata(dev);
322 
323 	mutex_lock(&ts->input->mutex);
324 
325 	if (ts->suspended && !ts->disabled && input_device_enabled(ts->input))
326 		__ad7879_enable(ts);
327 
328 	ts->suspended = false;
329 
330 	mutex_unlock(&ts->input->mutex);
331 
332 	return 0;
333 }
334 
335 SIMPLE_DEV_PM_OPS(ad7879_pm_ops, ad7879_suspend, ad7879_resume);
336 EXPORT_SYMBOL(ad7879_pm_ops);
337 
338 static void ad7879_toggle(struct ad7879 *ts, bool disable)
339 {
340 	mutex_lock(&ts->input->mutex);
341 
342 	if (!ts->suspended && input_device_enabled(ts->input)) {
343 
344 		if (disable) {
345 			if (ts->disabled)
346 				__ad7879_enable(ts);
347 		} else {
348 			if (!ts->disabled)
349 				__ad7879_disable(ts);
350 		}
351 	}
352 
353 	ts->disabled = disable;
354 
355 	mutex_unlock(&ts->input->mutex);
356 }
357 
358 static ssize_t ad7879_disable_show(struct device *dev,
359 				     struct device_attribute *attr, char *buf)
360 {
361 	struct ad7879 *ts = dev_get_drvdata(dev);
362 
363 	return sprintf(buf, "%u\n", ts->disabled);
364 }
365 
366 static ssize_t ad7879_disable_store(struct device *dev,
367 				     struct device_attribute *attr,
368 				     const char *buf, size_t count)
369 {
370 	struct ad7879 *ts = dev_get_drvdata(dev);
371 	unsigned int val;
372 	int error;
373 
374 	error = kstrtouint(buf, 10, &val);
375 	if (error)
376 		return error;
377 
378 	ad7879_toggle(ts, val);
379 
380 	return count;
381 }
382 
383 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);
384 
385 static struct attribute *ad7879_attributes[] = {
386 	&dev_attr_disable.attr,
387 	NULL
388 };
389 
390 static const struct attribute_group ad7879_attr_group = {
391 	.attrs = ad7879_attributes,
392 };
393 
394 #ifdef CONFIG_GPIOLIB
395 static int ad7879_gpio_direction_input(struct gpio_chip *chip,
396 					unsigned gpio)
397 {
398 	struct ad7879 *ts = gpiochip_get_data(chip);
399 	int err;
400 
401 	mutex_lock(&ts->mutex);
402 	ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
403 	err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
404 	mutex_unlock(&ts->mutex);
405 
406 	return err;
407 }
408 
409 static int ad7879_gpio_direction_output(struct gpio_chip *chip,
410 					unsigned gpio, int level)
411 {
412 	struct ad7879 *ts = gpiochip_get_data(chip);
413 	int err;
414 
415 	mutex_lock(&ts->mutex);
416 	ts->cmd_crtl2 &= ~AD7879_GPIODIR;
417 	ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
418 	if (level)
419 		ts->cmd_crtl2 |= AD7879_GPIO_DATA;
420 	else
421 		ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
422 
423 	err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
424 	mutex_unlock(&ts->mutex);
425 
426 	return err;
427 }
428 
429 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
430 {
431 	struct ad7879 *ts = gpiochip_get_data(chip);
432 	u16 val;
433 
434 	mutex_lock(&ts->mutex);
435 	val = ad7879_read(ts, AD7879_REG_CTRL2);
436 	mutex_unlock(&ts->mutex);
437 
438 	return !!(val & AD7879_GPIO_DATA);
439 }
440 
441 static void ad7879_gpio_set_value(struct gpio_chip *chip,
442 				  unsigned gpio, int value)
443 {
444 	struct ad7879 *ts = gpiochip_get_data(chip);
445 
446 	mutex_lock(&ts->mutex);
447 	if (value)
448 		ts->cmd_crtl2 |= AD7879_GPIO_DATA;
449 	else
450 		ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
451 
452 	ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
453 	mutex_unlock(&ts->mutex);
454 }
455 
456 static int ad7879_gpio_add(struct ad7879 *ts)
457 {
458 	int ret = 0;
459 
460 	mutex_init(&ts->mutex);
461 
462 	/* Do not create a chip unless flagged for it */
463 	if (!device_property_read_bool(ts->dev, "gpio-controller"))
464 		return 0;
465 
466 	ts->gc.direction_input = ad7879_gpio_direction_input;
467 	ts->gc.direction_output = ad7879_gpio_direction_output;
468 	ts->gc.get = ad7879_gpio_get_value;
469 	ts->gc.set = ad7879_gpio_set_value;
470 	ts->gc.can_sleep = 1;
471 	ts->gc.base = -1;
472 	ts->gc.ngpio = 1;
473 	ts->gc.label = "AD7879-GPIO";
474 	ts->gc.owner = THIS_MODULE;
475 	ts->gc.parent = ts->dev;
476 
477 	ret = devm_gpiochip_add_data(ts->dev, &ts->gc, ts);
478 	if (ret)
479 		dev_err(ts->dev, "failed to register gpio %d\n",
480 			ts->gc.base);
481 
482 	return ret;
483 }
484 #else
485 static int ad7879_gpio_add(struct ad7879 *ts)
486 {
487 	return 0;
488 }
489 #endif
490 
491 static int ad7879_parse_dt(struct device *dev, struct ad7879 *ts)
492 {
493 	int err;
494 	u32 tmp;
495 
496 	err = device_property_read_u32(dev, "adi,resistance-plate-x", &tmp);
497 	if (err) {
498 		dev_err(dev, "failed to get resistance-plate-x property\n");
499 		return err;
500 	}
501 	ts->x_plate_ohms = (u16)tmp;
502 
503 	device_property_read_u8(dev, "adi,first-conversion-delay",
504 				&ts->first_conversion_delay);
505 	device_property_read_u8(dev, "adi,acquisition-time",
506 				&ts->acquisition_time);
507 	device_property_read_u8(dev, "adi,median-filter-size", &ts->median);
508 	device_property_read_u8(dev, "adi,averaging", &ts->averaging);
509 	device_property_read_u8(dev, "adi,conversion-interval",
510 				&ts->pen_down_acc_interval);
511 
512 	ts->swap_xy = device_property_read_bool(dev, "touchscreen-swapped-x-y");
513 
514 	return 0;
515 }
516 
517 int ad7879_probe(struct device *dev, struct regmap *regmap,
518 		 int irq, u16 bustype, u8 devid)
519 {
520 	struct ad7879 *ts;
521 	struct input_dev *input_dev;
522 	int err;
523 	u16 revid;
524 
525 	if (irq <= 0) {
526 		dev_err(dev, "No IRQ specified\n");
527 		return -EINVAL;
528 	}
529 
530 	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
531 	if (!ts)
532 		return -ENOMEM;
533 
534 	err = ad7879_parse_dt(dev, ts);
535 	if (err)
536 		return err;
537 
538 	input_dev = devm_input_allocate_device(dev);
539 	if (!input_dev) {
540 		dev_err(dev, "Failed to allocate input device\n");
541 		return -ENOMEM;
542 	}
543 
544 	ts->dev = dev;
545 	ts->input = input_dev;
546 	ts->irq = irq;
547 	ts->regmap = regmap;
548 
549 	timer_setup(&ts->timer, ad7879_timer, 0);
550 	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
551 
552 	input_dev->name = "AD7879 Touchscreen";
553 	input_dev->phys = ts->phys;
554 	input_dev->dev.parent = dev;
555 	input_dev->id.bustype = bustype;
556 
557 	input_dev->open = ad7879_open;
558 	input_dev->close = ad7879_close;
559 
560 	input_set_drvdata(input_dev, ts);
561 
562 	input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
563 
564 	input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
565 	input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
566 	input_set_capability(input_dev, EV_ABS, ABS_PRESSURE);
567 	touchscreen_parse_properties(input_dev, false, NULL);
568 	if (!input_abs_get_max(input_dev, ABS_PRESSURE)) {
569 		dev_err(dev, "Touchscreen pressure is not specified\n");
570 		return -EINVAL;
571 	}
572 
573 	err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
574 	if (err < 0) {
575 		dev_err(dev, "Failed to write %s\n", input_dev->name);
576 		return err;
577 	}
578 
579 	revid = ad7879_read(ts, AD7879_REG_REVID);
580 	input_dev->id.product = (revid & 0xff);
581 	input_dev->id.version = revid >> 8;
582 	if (input_dev->id.product != devid) {
583 		dev_err(dev, "Failed to probe %s (%x vs %x)\n",
584 			input_dev->name, devid, revid);
585 		return -ENODEV;
586 	}
587 
588 	ts->cmd_crtl3 = AD7879_YPLUS_BIT |
589 			AD7879_XPLUS_BIT |
590 			AD7879_Z2_BIT |
591 			AD7879_Z1_BIT |
592 			AD7879_TEMPMASK_BIT |
593 			AD7879_AUXVBATMASK_BIT |
594 			AD7879_GPIOALERTMASK_BIT;
595 
596 	ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
597 			AD7879_AVG(ts->averaging) |
598 			AD7879_MFS(ts->median) |
599 			AD7879_FCD(ts->first_conversion_delay);
600 
601 	ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
602 			AD7879_ACQ(ts->acquisition_time) |
603 			AD7879_TMR(ts->pen_down_acc_interval);
604 
605 	err = devm_request_threaded_irq(dev, ts->irq, NULL, ad7879_irq,
606 					IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
607 					dev_name(dev), ts);
608 	if (err) {
609 		dev_err(dev, "Failed to request IRQ: %d\n", err);
610 		return err;
611 	}
612 
613 	__ad7879_disable(ts);
614 
615 	err = devm_device_add_group(dev, &ad7879_attr_group);
616 	if (err)
617 		return err;
618 
619 	err = ad7879_gpio_add(ts);
620 	if (err)
621 		return err;
622 
623 	err = input_register_device(input_dev);
624 	if (err)
625 		return err;
626 
627 	dev_set_drvdata(dev, ts);
628 
629 	return 0;
630 }
631 EXPORT_SYMBOL(ad7879_probe);
632 
633 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
634 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
635 MODULE_LICENSE("GPL");
636