1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * AD7879/AD7889 based touchscreen and GPIO driver
5 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
8 * Copyright (c) 2005 David Brownell
9 * Copyright (c) 2006 Nokia Corporation
10 * Various changes: Imre Deak <imre.deak@nokia.com>
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
20 * Copyright (C) 2006-2008 Analog Devices Inc.
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>
33 #include <linux/input/touchscreen.h>
34 #include <linux/module.h>
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
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 */
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)
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)
103 #define MAX_12BIT ((1<<12)-1)
104 #define TS_PEN_UP_TIMEOUT msecs_to_jiffies(50)
107 struct regmap
*regmap
;
109 struct input_dev
*input
;
110 struct timer_list timer
;
111 #ifdef CONFIG_GPIOLIB
116 bool disabled
; /* P: input->mutex */
117 bool suspended
; /* P: input->mutex */
119 u16 conversion_data
[AD7879_NR_SENSE
];
121 u8 first_conversion_delay
;
124 u8 pen_down_acc_interval
;
135 static int ad7879_read(struct ad7879
*ts
, u8 reg
)
140 error
= regmap_read(ts
->regmap
, reg
, &val
);
142 dev_err(ts
->dev
, "failed to read register %#02x: %d\n",
150 static int ad7879_write(struct ad7879
*ts
, u8 reg
, u16 val
)
154 error
= regmap_write(ts
->regmap
, reg
, val
);
157 "failed to write %#04x to register %#02x: %d\n",
165 static int ad7879_report(struct ad7879
*ts
)
167 struct input_dev
*input_dev
= ts
->input
;
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
;
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.
191 if (likely(x
&& z1
)) {
192 /* compute touch pressure resistance using equation #1 */
193 Rt
= (z2
- z1
) * x
* ts
->x_plate_ohms
;
195 Rt
= (Rt
+ 2047) >> 12;
198 * Sample found inconsistent, pressure is beyond
199 * the maximum. Don't report it to user space.
201 if (Rt
> input_abs_get_max(input_dev
, ABS_PRESSURE
))
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.
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
);
229 static void ad7879_ts_event_release(struct ad7879
*ts
)
231 struct input_dev
*input_dev
= ts
->input
;
233 input_report_abs(input_dev
, ABS_PRESSURE
, 0);
234 input_report_key(input_dev
, BTN_TOUCH
, 0);
235 input_sync(input_dev
);
238 static void ad7879_timer(struct timer_list
*t
)
240 struct ad7879
*ts
= from_timer(ts
, t
, timer
);
242 ad7879_ts_event_release(ts
);
245 static irqreturn_t
ad7879_irq(int irq
, void *handle
)
247 struct ad7879
*ts
= handle
;
250 error
= regmap_bulk_read(ts
->regmap
, AD7879_REG_XPLUS
,
251 ts
->conversion_data
, AD7879_NR_SENSE
);
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
);
261 static void __ad7879_enable(struct ad7879
*ts
)
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
);
270 static void __ad7879_disable(struct ad7879
*ts
)
272 u16 reg
= (ts
->cmd_crtl2
& ~AD7879_PM(-1)) |
273 AD7879_PM(AD7879_PM_SHUTDOWN
);
274 disable_irq(ts
->irq
);
276 if (del_timer_sync(&ts
->timer
))
277 ad7879_ts_event_release(ts
);
279 ad7879_write(ts
, AD7879_REG_CTRL2
, reg
);
283 static int ad7879_open(struct input_dev
*input
)
285 struct ad7879
*ts
= input_get_drvdata(input
);
287 /* protected by input->mutex */
288 if (!ts
->disabled
&& !ts
->suspended
)
294 static void ad7879_close(struct input_dev
*input
)
296 struct ad7879
*ts
= input_get_drvdata(input
);
298 /* protected by input->mutex */
299 if (!ts
->disabled
&& !ts
->suspended
)
300 __ad7879_disable(ts
);
303 static int __maybe_unused
ad7879_suspend(struct device
*dev
)
305 struct ad7879
*ts
= dev_get_drvdata(dev
);
307 mutex_lock(&ts
->input
->mutex
);
309 if (!ts
->suspended
&& !ts
->disabled
&& input_device_enabled(ts
->input
))
310 __ad7879_disable(ts
);
312 ts
->suspended
= true;
314 mutex_unlock(&ts
->input
->mutex
);
319 static int __maybe_unused
ad7879_resume(struct device
*dev
)
321 struct ad7879
*ts
= dev_get_drvdata(dev
);
323 mutex_lock(&ts
->input
->mutex
);
325 if (ts
->suspended
&& !ts
->disabled
&& input_device_enabled(ts
->input
))
328 ts
->suspended
= false;
330 mutex_unlock(&ts
->input
->mutex
);
335 SIMPLE_DEV_PM_OPS(ad7879_pm_ops
, ad7879_suspend
, ad7879_resume
);
336 EXPORT_SYMBOL(ad7879_pm_ops
);
338 static void ad7879_toggle(struct ad7879
*ts
, bool disable
)
340 mutex_lock(&ts
->input
->mutex
);
342 if (!ts
->suspended
&& input_device_enabled(ts
->input
)) {
349 __ad7879_disable(ts
);
353 ts
->disabled
= disable
;
355 mutex_unlock(&ts
->input
->mutex
);
358 static ssize_t
ad7879_disable_show(struct device
*dev
,
359 struct device_attribute
*attr
, char *buf
)
361 struct ad7879
*ts
= dev_get_drvdata(dev
);
363 return sprintf(buf
, "%u\n", ts
->disabled
);
366 static ssize_t
ad7879_disable_store(struct device
*dev
,
367 struct device_attribute
*attr
,
368 const char *buf
, size_t count
)
370 struct ad7879
*ts
= dev_get_drvdata(dev
);
374 error
= kstrtouint(buf
, 10, &val
);
378 ad7879_toggle(ts
, val
);
383 static DEVICE_ATTR(disable
, 0664, ad7879_disable_show
, ad7879_disable_store
);
385 static struct attribute
*ad7879_attributes
[] = {
386 &dev_attr_disable
.attr
,
390 static const struct attribute_group ad7879_attr_group
= {
391 .attrs
= ad7879_attributes
,
394 #ifdef CONFIG_GPIOLIB
395 static int ad7879_gpio_direction_input(struct gpio_chip
*chip
,
398 struct ad7879
*ts
= gpiochip_get_data(chip
);
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
);
409 static int ad7879_gpio_direction_output(struct gpio_chip
*chip
,
410 unsigned gpio
, int level
)
412 struct ad7879
*ts
= gpiochip_get_data(chip
);
415 mutex_lock(&ts
->mutex
);
416 ts
->cmd_crtl2
&= ~AD7879_GPIODIR
;
417 ts
->cmd_crtl2
|= AD7879_GPIO_EN
| AD7879_GPIOPOL
;
419 ts
->cmd_crtl2
|= AD7879_GPIO_DATA
;
421 ts
->cmd_crtl2
&= ~AD7879_GPIO_DATA
;
423 err
= ad7879_write(ts
, AD7879_REG_CTRL2
, ts
->cmd_crtl2
);
424 mutex_unlock(&ts
->mutex
);
429 static int ad7879_gpio_get_value(struct gpio_chip
*chip
, unsigned gpio
)
431 struct ad7879
*ts
= gpiochip_get_data(chip
);
434 mutex_lock(&ts
->mutex
);
435 val
= ad7879_read(ts
, AD7879_REG_CTRL2
);
436 mutex_unlock(&ts
->mutex
);
438 return !!(val
& AD7879_GPIO_DATA
);
441 static void ad7879_gpio_set_value(struct gpio_chip
*chip
,
442 unsigned gpio
, int value
)
444 struct ad7879
*ts
= gpiochip_get_data(chip
);
446 mutex_lock(&ts
->mutex
);
448 ts
->cmd_crtl2
|= AD7879_GPIO_DATA
;
450 ts
->cmd_crtl2
&= ~AD7879_GPIO_DATA
;
452 ad7879_write(ts
, AD7879_REG_CTRL2
, ts
->cmd_crtl2
);
453 mutex_unlock(&ts
->mutex
);
456 static int ad7879_gpio_add(struct ad7879
*ts
)
460 mutex_init(&ts
->mutex
);
462 /* Do not create a chip unless flagged for it */
463 if (!device_property_read_bool(ts
->dev
, "gpio-controller"))
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;
473 ts
->gc
.label
= "AD7879-GPIO";
474 ts
->gc
.owner
= THIS_MODULE
;
475 ts
->gc
.parent
= ts
->dev
;
477 ret
= devm_gpiochip_add_data(ts
->dev
, &ts
->gc
, ts
);
479 dev_err(ts
->dev
, "failed to register gpio %d\n",
485 static int ad7879_gpio_add(struct ad7879
*ts
)
491 static int ad7879_parse_dt(struct device
*dev
, struct ad7879
*ts
)
496 err
= device_property_read_u32(dev
, "adi,resistance-plate-x", &tmp
);
498 dev_err(dev
, "failed to get resistance-plate-x property\n");
501 ts
->x_plate_ohms
= (u16
)tmp
;
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
);
512 ts
->swap_xy
= device_property_read_bool(dev
, "touchscreen-swapped-x-y");
517 int ad7879_probe(struct device
*dev
, struct regmap
*regmap
,
518 int irq
, u16 bustype
, u8 devid
)
521 struct input_dev
*input_dev
;
526 dev_err(dev
, "No IRQ specified\n");
530 ts
= devm_kzalloc(dev
, sizeof(*ts
), GFP_KERNEL
);
534 err
= ad7879_parse_dt(dev
, ts
);
538 input_dev
= devm_input_allocate_device(dev
);
540 dev_err(dev
, "Failed to allocate input device\n");
545 ts
->input
= input_dev
;
549 timer_setup(&ts
->timer
, ad7879_timer
, 0);
550 snprintf(ts
->phys
, sizeof(ts
->phys
), "%s/input0", dev_name(dev
));
552 input_dev
->name
= "AD7879 Touchscreen";
553 input_dev
->phys
= ts
->phys
;
554 input_dev
->dev
.parent
= dev
;
555 input_dev
->id
.bustype
= bustype
;
557 input_dev
->open
= ad7879_open
;
558 input_dev
->close
= ad7879_close
;
560 input_set_drvdata(input_dev
, ts
);
562 input_set_capability(input_dev
, EV_KEY
, BTN_TOUCH
);
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");
573 err
= ad7879_write(ts
, AD7879_REG_CTRL2
, AD7879_RESET
);
575 dev_err(dev
, "Failed to write %s\n", input_dev
->name
);
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
);
588 ts
->cmd_crtl3
= AD7879_YPLUS_BIT
|
592 AD7879_TEMPMASK_BIT
|
593 AD7879_AUXVBATMASK_BIT
|
594 AD7879_GPIOALERTMASK_BIT
;
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
);
601 ts
->cmd_crtl1
= AD7879_MODE_INT
| AD7879_MODE_SEQ1
|
602 AD7879_ACQ(ts
->acquisition_time
) |
603 AD7879_TMR(ts
->pen_down_acc_interval
);
605 err
= devm_request_threaded_irq(dev
, ts
->irq
, NULL
, ad7879_irq
,
606 IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
,
609 dev_err(dev
, "Failed to request IRQ: %d\n", err
);
613 __ad7879_disable(ts
);
615 err
= devm_device_add_group(dev
, &ad7879_attr_group
);
619 err
= ad7879_gpio_add(ts
);
623 err
= input_register_device(input_dev
);
627 dev_set_drvdata(dev
, ts
);
631 EXPORT_SYMBOL(ad7879_probe
);
633 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
634 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
635 MODULE_LICENSE("GPL");