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(map: ts->regmap, reg, val: &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(map: 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(dev: 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(timer: &ts->timer)) { |
211 | /* Touch continues */ |
212 | input_report_key(dev: input_dev, BTN_TOUCH, value: 1); |
213 | input_report_abs(dev: input_dev, ABS_X, value: ts->x); |
214 | input_report_abs(dev: input_dev, ABS_Y, value: ts->y); |
215 | input_report_abs(dev: input_dev, ABS_PRESSURE, value: ts->Rt); |
216 | input_sync(dev: 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(dev: input_dev, ABS_PRESSURE, value: 0); |
234 | input_report_key(dev: input_dev, BTN_TOUCH, value: 0); |
235 | input_sync(dev: 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(map: ts->regmap, AD7879_REG_XPLUS, |
251 | val: ts->conversion_data, val_count: 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(timer: &ts->timer, expires: 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, val: ts->cmd_crtl2); |
264 | ad7879_write(ts, AD7879_REG_CTRL3, val: ts->cmd_crtl3); |
265 | ad7879_write(ts, AD7879_REG_CTRL1, val: ts->cmd_crtl1); |
266 | |
267 | enable_irq(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(irq: ts->irq); |
275 | |
276 | if (del_timer_sync(timer: &ts->timer)) |
277 | ad7879_ts_event_release(ts); |
278 | |
279 | ad7879_write(ts, AD7879_REG_CTRL2, val: reg); |
280 | } |
281 | |
282 | |
283 | static int ad7879_open(struct input_dev *input) |
284 | { |
285 | struct ad7879 *ts = input_get_drvdata(dev: 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(dev: 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(dev: ts->input)) |
310 | __ad7879_disable(ts); |
311 | |
312 | ts->suspended = true; |
313 | |
314 | mutex_unlock(lock: &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(dev: ts->input)) |
326 | __ad7879_enable(ts); |
327 | |
328 | ts->suspended = false; |
329 | |
330 | mutex_unlock(lock: &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(dev: 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(lock: &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, fmt: "%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(s: buf, base: 10, res: &val); |
375 | if (error) |
376 | return error; |
377 | |
378 | ad7879_toggle(ts, disable: 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(gc: 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, val: ts->cmd_crtl2); |
404 | mutex_unlock(lock: &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(gc: 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, val: ts->cmd_crtl2); |
424 | mutex_unlock(lock: &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(gc: chip); |
432 | u16 val; |
433 | |
434 | mutex_lock(&ts->mutex); |
435 | val = ad7879_read(ts, AD7879_REG_CTRL2); |
436 | mutex_unlock(lock: &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(gc: 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, val: ts->cmd_crtl2); |
453 | mutex_unlock(lock: &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(dev: ts->dev, propname: "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, propname: "adi,resistance-plate-x" , val: &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, propname: "adi,first-conversion-delay" , |
504 | val: &ts->first_conversion_delay); |
505 | device_property_read_u8(dev, propname: "adi,acquisition-time" , |
506 | val: &ts->acquisition_time); |
507 | device_property_read_u8(dev, propname: "adi,median-filter-size" , val: &ts->median); |
508 | device_property_read_u8(dev, propname: "adi,averaging" , val: &ts->averaging); |
509 | device_property_read_u8(dev, propname: "adi,conversion-interval" , |
510 | val: &ts->pen_down_acc_interval); |
511 | |
512 | ts->swap_xy = device_property_read_bool(dev, propname: "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, size: 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(buf: ts->phys, size: sizeof(ts->phys), fmt: "%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(dev: input_dev, data: ts); |
561 | |
562 | input_set_capability(dev: input_dev, EV_KEY, BTN_TOUCH); |
563 | |
564 | input_set_abs_params(dev: input_dev, ABS_X, min: 0, MAX_12BIT, fuzz: 0, flat: 0); |
565 | input_set_abs_params(dev: input_dev, ABS_Y, min: 0, MAX_12BIT, fuzz: 0, flat: 0); |
566 | input_set_capability(dev: input_dev, EV_ABS, ABS_PRESSURE); |
567 | touchscreen_parse_properties(input: input_dev, multitouch: false, NULL); |
568 | if (!input_abs_get_max(dev: 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, irq: ts->irq, NULL, thread_fn: ad7879_irq, |
606 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
607 | devname: dev_name(dev), dev_id: 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, grp: &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, data: 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 | |