xref: /openbmc/linux/drivers/input/touchscreen/ad7879.c (revision cdd38c5f1ce4398ec58fec95904b75824daab7b5)
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  
ad7879_read(struct ad7879 * ts,u8 reg)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  
ad7879_write(struct ad7879 * ts,u8 reg,u16 val)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  
ad7879_report(struct ad7879 * ts)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  
ad7879_ts_event_release(struct ad7879 * ts)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  
ad7879_timer(struct timer_list * t)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  
ad7879_irq(int irq,void * handle)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  
__ad7879_enable(struct ad7879 * ts)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  
__ad7879_disable(struct ad7879 * ts)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  
ad7879_open(struct input_dev * input)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  
ad7879_close(struct input_dev * input)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  
ad7879_suspend(struct device * dev)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  
ad7879_resume(struct device * dev)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  
ad7879_toggle(struct ad7879 * ts,bool disable)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  
ad7879_disable_show(struct device * dev,struct device_attribute * attr,char * buf)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  
ad7879_disable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ad7879_gpio_direction_input(struct gpio_chip * chip,unsigned gpio)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  
ad7879_gpio_direction_output(struct gpio_chip * chip,unsigned gpio,int level)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  
ad7879_gpio_get_value(struct gpio_chip * chip,unsigned gpio)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  
ad7879_gpio_set_value(struct gpio_chip * chip,unsigned gpio,int value)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  
ad7879_gpio_add(struct ad7879 * ts)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
ad7879_gpio_add(struct ad7879 * ts)485  static int ad7879_gpio_add(struct ad7879 *ts)
486  {
487  	return 0;
488  }
489  #endif
490  
ad7879_parse_dt(struct device * dev,struct ad7879 * ts)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  
ad7879_probe(struct device * dev,struct regmap * regmap,int irq,u16 bustype,u8 devid)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