1 /*
2 * ADS7846 based touchscreen and sensor driver
3 *
4 * Copyright (c) 2005 David Brownell
5 * Copyright (c) 2006 Nokia Corporation
6 * Various changes: Imre Deak <imre.deak@nokia.com>
7 *
8 * Using code from:
9 * - corgi_ts.c
10 * Copyright (C) 2004-2005 Richard Purdie
11 * - omap_ts.[hc], ads7846.h, ts_osk.c
12 * Copyright (C) 2002 MontaVista Software
13 * Copyright (C) 2004 Texas Instruments
14 * Copyright (C) 2005 Dirk Behme
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License version 2 as
18 * published by the Free Software Foundation.
19 */
20 #include <linux/types.h>
21 #include <linux/hwmon.h>
22 #include <linux/err.h>
23 #include <linux/sched.h>
24 #include <linux/delay.h>
25 #include <linux/input.h>
26 #include <linux/interrupt.h>
27 #include <linux/slab.h>
28 #include <linux/pm.h>
29 #include <linux/of.h>
30 #include <linux/of_gpio.h>
31 #include <linux/of_device.h>
32 #include <linux/gpio.h>
33 #include <linux/spi/spi.h>
34 #include <linux/spi/ads7846.h>
35 #include <linux/regulator/consumer.h>
36 #include <linux/module.h>
37 #include <asm/irq.h>
38 #include <asm/unaligned.h>
39
40 /*
41 * This code has been heavily tested on a Nokia 770, and lightly
42 * tested on other ads7846 devices (OSK/Mistral, Lubbock, Spitz).
43 * TSC2046 is just newer ads7846 silicon.
44 * Support for ads7843 tested on Atmel at91sam926x-EK.
45 * Support for ads7845 has only been stubbed in.
46 * Support for Analog Devices AD7873 and AD7843 tested.
47 *
48 * IRQ handling needs a workaround because of a shortcoming in handling
49 * edge triggered IRQs on some platforms like the OMAP1/2. These
50 * platforms don't handle the ARM lazy IRQ disabling properly, thus we
51 * have to maintain our own SW IRQ disabled status. This should be
52 * removed as soon as the affected platform's IRQ handling is fixed.
53 *
54 * App note sbaa036 talks in more detail about accurate sampling...
55 * that ought to help in situations like LCDs inducing noise (which
56 * can also be helped by using synch signals) and more generally.
57 * This driver tries to utilize the measures described in the app
58 * note. The strength of filtering can be set in the board-* specific
59 * files.
60 */
61
62 #define TS_POLL_DELAY 1 /* ms delay before the first sample */
63 #define TS_POLL_PERIOD 5 /* ms delay between samples */
64
65 /* this driver doesn't aim at the peak continuous sample rate */
66 #define SAMPLE_BITS (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
67
68 struct ts_event {
69 /*
70 * For portability, we can't read 12 bit values using SPI (which
71 * would make the controller deliver them as native byte order u16
72 * with msbs zeroed). Instead, we read them as two 8-bit values,
73 * *** WHICH NEED BYTESWAPPING *** and range adjustment.
74 */
75 u16 x;
76 u16 y;
77 u16 z1, z2;
78 bool ignore;
79 u8 x_buf[3];
80 u8 y_buf[3];
81 };
82
83 /*
84 * We allocate this separately to avoid cache line sharing issues when
85 * driver is used with DMA-based SPI controllers (like atmel_spi) on
86 * systems where main memory is not DMA-coherent (most non-x86 boards).
87 */
88 struct ads7846_packet {
89 u8 read_x, read_y, read_z1, read_z2, pwrdown;
90 u16 dummy; /* for the pwrdown read */
91 struct ts_event tc;
92 /* for ads7845 with mpc5121 psc spi we use 3-byte buffers */
93 u8 read_x_cmd[3], read_y_cmd[3], pwrdown_cmd[3];
94 };
95
96 struct ads7846 {
97 struct input_dev *input;
98 char phys[32];
99 char name[32];
100
101 struct spi_device *spi;
102 struct regulator *reg;
103
104 #if IS_ENABLED(CONFIG_HWMON)
105 struct device *hwmon;
106 #endif
107
108 u16 model;
109 u16 vref_mv;
110 u16 vref_delay_usecs;
111 u16 x_plate_ohms;
112 u16 pressure_max;
113
114 bool swap_xy;
115 bool use_internal;
116
117 struct ads7846_packet *packet;
118
119 struct spi_transfer xfer[18];
120 struct spi_message msg[5];
121 int msg_count;
122 wait_queue_head_t wait;
123
124 bool pendown;
125
126 int read_cnt;
127 int read_rep;
128 int last_read;
129
130 u16 debounce_max;
131 u16 debounce_tol;
132 u16 debounce_rep;
133
134 u16 penirq_recheck_delay_usecs;
135
136 struct mutex lock;
137 bool stopped; /* P: lock */
138 bool disabled; /* P: lock */
139 bool suspended; /* P: lock */
140
141 int (*filter)(void *data, int data_idx, int *val);
142 void *filter_data;
143 void (*filter_cleanup)(void *data);
144 int (*get_pendown_state)(void);
145 int gpio_pendown;
146
147 void (*wait_for_sync)(void);
148 };
149
150 /* leave chip selected when we're done, for quicker re-select? */
151 #if 0
152 #define CS_CHANGE(xfer) ((xfer).cs_change = 1)
153 #else
154 #define CS_CHANGE(xfer) ((xfer).cs_change = 0)
155 #endif
156
157 /*--------------------------------------------------------------------------*/
158
159 /* The ADS7846 has touchscreen and other sensors.
160 * Earlier ads784x chips are somewhat compatible.
161 */
162 #define ADS_START (1 << 7)
163 #define ADS_A2A1A0_d_y (1 << 4) /* differential */
164 #define ADS_A2A1A0_d_z1 (3 << 4) /* differential */
165 #define ADS_A2A1A0_d_z2 (4 << 4) /* differential */
166 #define ADS_A2A1A0_d_x (5 << 4) /* differential */
167 #define ADS_A2A1A0_temp0 (0 << 4) /* non-differential */
168 #define ADS_A2A1A0_vbatt (2 << 4) /* non-differential */
169 #define ADS_A2A1A0_vaux (6 << 4) /* non-differential */
170 #define ADS_A2A1A0_temp1 (7 << 4) /* non-differential */
171 #define ADS_8_BIT (1 << 3)
172 #define ADS_12_BIT (0 << 3)
173 #define ADS_SER (1 << 2) /* non-differential */
174 #define ADS_DFR (0 << 2) /* differential */
175 #define ADS_PD10_PDOWN (0 << 0) /* low power mode + penirq */
176 #define ADS_PD10_ADC_ON (1 << 0) /* ADC on */
177 #define ADS_PD10_REF_ON (2 << 0) /* vREF on + penirq */
178 #define ADS_PD10_ALL_ON (3 << 0) /* ADC + vREF on */
179
180 #define MAX_12BIT ((1<<12)-1)
181
182 /* leave ADC powered up (disables penirq) between differential samples */
183 #define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
184 | ADS_12_BIT | ADS_DFR | \
185 (adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
186
187 #define READ_Y(vref) (READ_12BIT_DFR(y, 1, vref))
188 #define READ_Z1(vref) (READ_12BIT_DFR(z1, 1, vref))
189 #define READ_Z2(vref) (READ_12BIT_DFR(z2, 1, vref))
190
191 #define READ_X(vref) (READ_12BIT_DFR(x, 1, vref))
192 #define PWRDOWN (READ_12BIT_DFR(y, 0, 0)) /* LAST */
193
194 /* single-ended samples need to first power up reference voltage;
195 * we leave both ADC and VREF powered
196 */
197 #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
198 | ADS_12_BIT | ADS_SER)
199
200 #define REF_ON (READ_12BIT_DFR(x, 1, 1))
201 #define REF_OFF (READ_12BIT_DFR(y, 0, 0))
202
203 /* Must be called with ts->lock held */
ads7846_stop(struct ads7846 * ts)204 static void ads7846_stop(struct ads7846 *ts)
205 {
206 if (!ts->disabled && !ts->suspended) {
207 /* Signal IRQ thread to stop polling and disable the handler. */
208 ts->stopped = true;
209 mb();
210 wake_up(&ts->wait);
211 disable_irq(ts->spi->irq);
212 }
213 }
214
215 /* Must be called with ts->lock held */
ads7846_restart(struct ads7846 * ts)216 static void ads7846_restart(struct ads7846 *ts)
217 {
218 if (!ts->disabled && !ts->suspended) {
219 /* Tell IRQ thread that it may poll the device. */
220 ts->stopped = false;
221 mb();
222 enable_irq(ts->spi->irq);
223 }
224 }
225
226 /* Must be called with ts->lock held */
__ads7846_disable(struct ads7846 * ts)227 static void __ads7846_disable(struct ads7846 *ts)
228 {
229 ads7846_stop(ts);
230 regulator_disable(ts->reg);
231
232 /*
233 * We know the chip's in low power mode since we always
234 * leave it that way after every request
235 */
236 }
237
238 /* Must be called with ts->lock held */
__ads7846_enable(struct ads7846 * ts)239 static void __ads7846_enable(struct ads7846 *ts)
240 {
241 int error;
242
243 error = regulator_enable(ts->reg);
244 if (error != 0)
245 dev_err(&ts->spi->dev, "Failed to enable supply: %d\n", error);
246
247 ads7846_restart(ts);
248 }
249
ads7846_disable(struct ads7846 * ts)250 static void ads7846_disable(struct ads7846 *ts)
251 {
252 mutex_lock(&ts->lock);
253
254 if (!ts->disabled) {
255
256 if (!ts->suspended)
257 __ads7846_disable(ts);
258
259 ts->disabled = true;
260 }
261
262 mutex_unlock(&ts->lock);
263 }
264
ads7846_enable(struct ads7846 * ts)265 static void ads7846_enable(struct ads7846 *ts)
266 {
267 mutex_lock(&ts->lock);
268
269 if (ts->disabled) {
270
271 ts->disabled = false;
272
273 if (!ts->suspended)
274 __ads7846_enable(ts);
275 }
276
277 mutex_unlock(&ts->lock);
278 }
279
280 /*--------------------------------------------------------------------------*/
281
282 /*
283 * Non-touchscreen sensors only use single-ended conversions.
284 * The range is GND..vREF. The ads7843 and ads7835 must use external vREF;
285 * ads7846 lets that pin be unconnected, to use internal vREF.
286 */
287
288 struct ser_req {
289 u8 ref_on;
290 u8 command;
291 u8 ref_off;
292 u16 scratch;
293 struct spi_message msg;
294 struct spi_transfer xfer[6];
295 /*
296 * DMA (thus cache coherency maintenance) requires the
297 * transfer buffers to live in their own cache lines.
298 */
299 __be16 sample ____cacheline_aligned;
300 };
301
302 struct ads7845_ser_req {
303 u8 command[3];
304 struct spi_message msg;
305 struct spi_transfer xfer[2];
306 /*
307 * DMA (thus cache coherency maintenance) requires the
308 * transfer buffers to live in their own cache lines.
309 */
310 u8 sample[3] ____cacheline_aligned;
311 };
312
ads7846_read12_ser(struct device * dev,unsigned command)313 static int ads7846_read12_ser(struct device *dev, unsigned command)
314 {
315 struct spi_device *spi = to_spi_device(dev);
316 struct ads7846 *ts = dev_get_drvdata(dev);
317 struct ser_req *req;
318 int status;
319
320 req = kzalloc(sizeof *req, GFP_KERNEL);
321 if (!req)
322 return -ENOMEM;
323
324 spi_message_init(&req->msg);
325
326 /* maybe turn on internal vREF, and let it settle */
327 if (ts->use_internal) {
328 req->ref_on = REF_ON;
329 req->xfer[0].tx_buf = &req->ref_on;
330 req->xfer[0].len = 1;
331 spi_message_add_tail(&req->xfer[0], &req->msg);
332
333 req->xfer[1].rx_buf = &req->scratch;
334 req->xfer[1].len = 2;
335
336 /* for 1uF, settle for 800 usec; no cap, 100 usec. */
337 req->xfer[1].delay_usecs = ts->vref_delay_usecs;
338 spi_message_add_tail(&req->xfer[1], &req->msg);
339
340 /* Enable reference voltage */
341 command |= ADS_PD10_REF_ON;
342 }
343
344 /* Enable ADC in every case */
345 command |= ADS_PD10_ADC_ON;
346
347 /* take sample */
348 req->command = (u8) command;
349 req->xfer[2].tx_buf = &req->command;
350 req->xfer[2].len = 1;
351 spi_message_add_tail(&req->xfer[2], &req->msg);
352
353 req->xfer[3].rx_buf = &req->sample;
354 req->xfer[3].len = 2;
355 spi_message_add_tail(&req->xfer[3], &req->msg);
356
357 /* REVISIT: take a few more samples, and compare ... */
358
359 /* converter in low power mode & enable PENIRQ */
360 req->ref_off = PWRDOWN;
361 req->xfer[4].tx_buf = &req->ref_off;
362 req->xfer[4].len = 1;
363 spi_message_add_tail(&req->xfer[4], &req->msg);
364
365 req->xfer[5].rx_buf = &req->scratch;
366 req->xfer[5].len = 2;
367 CS_CHANGE(req->xfer[5]);
368 spi_message_add_tail(&req->xfer[5], &req->msg);
369
370 mutex_lock(&ts->lock);
371 ads7846_stop(ts);
372 status = spi_sync(spi, &req->msg);
373 ads7846_restart(ts);
374 mutex_unlock(&ts->lock);
375
376 if (status == 0) {
377 /* on-wire is a must-ignore bit, a BE12 value, then padding */
378 status = be16_to_cpu(req->sample);
379 status = status >> 3;
380 status &= 0x0fff;
381 }
382
383 kfree(req);
384 return status;
385 }
386
ads7845_read12_ser(struct device * dev,unsigned command)387 static int ads7845_read12_ser(struct device *dev, unsigned command)
388 {
389 struct spi_device *spi = to_spi_device(dev);
390 struct ads7846 *ts = dev_get_drvdata(dev);
391 struct ads7845_ser_req *req;
392 int status;
393
394 req = kzalloc(sizeof *req, GFP_KERNEL);
395 if (!req)
396 return -ENOMEM;
397
398 spi_message_init(&req->msg);
399
400 req->command[0] = (u8) command;
401 req->xfer[0].tx_buf = req->command;
402 req->xfer[0].rx_buf = req->sample;
403 req->xfer[0].len = 3;
404 spi_message_add_tail(&req->xfer[0], &req->msg);
405
406 mutex_lock(&ts->lock);
407 ads7846_stop(ts);
408 status = spi_sync(spi, &req->msg);
409 ads7846_restart(ts);
410 mutex_unlock(&ts->lock);
411
412 if (status == 0) {
413 /* BE12 value, then padding */
414 status = get_unaligned_be16(&req->sample[1]);
415 status = status >> 3;
416 status &= 0x0fff;
417 }
418
419 kfree(req);
420 return status;
421 }
422
423 #if IS_ENABLED(CONFIG_HWMON)
424
425 #define SHOW(name, var, adjust) static ssize_t \
426 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
427 { \
428 struct ads7846 *ts = dev_get_drvdata(dev); \
429 ssize_t v = ads7846_read12_ser(&ts->spi->dev, \
430 READ_12BIT_SER(var)); \
431 if (v < 0) \
432 return v; \
433 return sprintf(buf, "%u\n", adjust(ts, v)); \
434 } \
435 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
436
437
438 /* Sysfs conventions report temperatures in millidegrees Celsius.
439 * ADS7846 could use the low-accuracy two-sample scheme, but can't do the high
440 * accuracy scheme without calibration data. For now we won't try either;
441 * userspace sees raw sensor values, and must scale/calibrate appropriately.
442 */
null_adjust(struct ads7846 * ts,ssize_t v)443 static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
444 {
445 return v;
446 }
447
SHOW(temp0,temp0,null_adjust)448 SHOW(temp0, temp0, null_adjust) /* temp1_input */
449 SHOW(temp1, temp1, null_adjust) /* temp2_input */
450
451
452 /* sysfs conventions report voltages in millivolts. We can convert voltages
453 * if we know vREF. userspace may need to scale vAUX to match the board's
454 * external resistors; we assume that vBATT only uses the internal ones.
455 */
456 static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
457 {
458 unsigned retval = v;
459
460 /* external resistors may scale vAUX into 0..vREF */
461 retval *= ts->vref_mv;
462 retval = retval >> 12;
463
464 return retval;
465 }
466
vbatt_adjust(struct ads7846 * ts,ssize_t v)467 static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
468 {
469 unsigned retval = vaux_adjust(ts, v);
470
471 /* ads7846 has a resistor ladder to scale this signal down */
472 if (ts->model == 7846)
473 retval *= 4;
474
475 return retval;
476 }
477
SHOW(in0_input,vaux,vaux_adjust)478 SHOW(in0_input, vaux, vaux_adjust)
479 SHOW(in1_input, vbatt, vbatt_adjust)
480
481 static umode_t ads7846_is_visible(struct kobject *kobj, struct attribute *attr,
482 int index)
483 {
484 struct device *dev = container_of(kobj, struct device, kobj);
485 struct ads7846 *ts = dev_get_drvdata(dev);
486
487 if (ts->model == 7843 && index < 2) /* in0, in1 */
488 return 0;
489 if (ts->model == 7845 && index != 2) /* in0 */
490 return 0;
491
492 return attr->mode;
493 }
494
495 static struct attribute *ads7846_attributes[] = {
496 &dev_attr_temp0.attr, /* 0 */
497 &dev_attr_temp1.attr, /* 1 */
498 &dev_attr_in0_input.attr, /* 2 */
499 &dev_attr_in1_input.attr, /* 3 */
500 NULL,
501 };
502
503 static struct attribute_group ads7846_attr_group = {
504 .attrs = ads7846_attributes,
505 .is_visible = ads7846_is_visible,
506 };
507 __ATTRIBUTE_GROUPS(ads7846_attr);
508
ads784x_hwmon_register(struct spi_device * spi,struct ads7846 * ts)509 static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
510 {
511 /* hwmon sensors need a reference voltage */
512 switch (ts->model) {
513 case 7846:
514 if (!ts->vref_mv) {
515 dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
516 ts->vref_mv = 2500;
517 ts->use_internal = true;
518 }
519 break;
520 case 7845:
521 case 7843:
522 if (!ts->vref_mv) {
523 dev_warn(&spi->dev,
524 "external vREF for ADS%d not specified\n",
525 ts->model);
526 return 0;
527 }
528 break;
529 }
530
531 ts->hwmon = hwmon_device_register_with_groups(&spi->dev, spi->modalias,
532 ts, ads7846_attr_groups);
533
534 return PTR_ERR_OR_ZERO(ts->hwmon);
535 }
536
ads784x_hwmon_unregister(struct spi_device * spi,struct ads7846 * ts)537 static void ads784x_hwmon_unregister(struct spi_device *spi,
538 struct ads7846 *ts)
539 {
540 if (ts->hwmon)
541 hwmon_device_unregister(ts->hwmon);
542 }
543
544 #else
ads784x_hwmon_register(struct spi_device * spi,struct ads7846 * ts)545 static inline int ads784x_hwmon_register(struct spi_device *spi,
546 struct ads7846 *ts)
547 {
548 return 0;
549 }
550
ads784x_hwmon_unregister(struct spi_device * spi,struct ads7846 * ts)551 static inline void ads784x_hwmon_unregister(struct spi_device *spi,
552 struct ads7846 *ts)
553 {
554 }
555 #endif
556
ads7846_pen_down_show(struct device * dev,struct device_attribute * attr,char * buf)557 static ssize_t ads7846_pen_down_show(struct device *dev,
558 struct device_attribute *attr, char *buf)
559 {
560 struct ads7846 *ts = dev_get_drvdata(dev);
561
562 return sprintf(buf, "%u\n", ts->pendown);
563 }
564
565 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
566
ads7846_disable_show(struct device * dev,struct device_attribute * attr,char * buf)567 static ssize_t ads7846_disable_show(struct device *dev,
568 struct device_attribute *attr, char *buf)
569 {
570 struct ads7846 *ts = dev_get_drvdata(dev);
571
572 return sprintf(buf, "%u\n", ts->disabled);
573 }
574
ads7846_disable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)575 static ssize_t ads7846_disable_store(struct device *dev,
576 struct device_attribute *attr,
577 const char *buf, size_t count)
578 {
579 struct ads7846 *ts = dev_get_drvdata(dev);
580 unsigned int i;
581 int err;
582
583 err = kstrtouint(buf, 10, &i);
584 if (err)
585 return err;
586
587 if (i)
588 ads7846_disable(ts);
589 else
590 ads7846_enable(ts);
591
592 return count;
593 }
594
595 static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
596
597 static struct attribute *ads784x_attributes[] = {
598 &dev_attr_pen_down.attr,
599 &dev_attr_disable.attr,
600 NULL,
601 };
602
603 static struct attribute_group ads784x_attr_group = {
604 .attrs = ads784x_attributes,
605 };
606
607 /*--------------------------------------------------------------------------*/
608
get_pendown_state(struct ads7846 * ts)609 static int get_pendown_state(struct ads7846 *ts)
610 {
611 if (ts->get_pendown_state)
612 return ts->get_pendown_state();
613
614 return !gpio_get_value(ts->gpio_pendown);
615 }
616
null_wait_for_sync(void)617 static void null_wait_for_sync(void)
618 {
619 }
620
ads7846_debounce_filter(void * ads,int data_idx,int * val)621 static int ads7846_debounce_filter(void *ads, int data_idx, int *val)
622 {
623 struct ads7846 *ts = ads;
624
625 if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
626 /* Start over collecting consistent readings. */
627 ts->read_rep = 0;
628 /*
629 * Repeat it, if this was the first read or the read
630 * wasn't consistent enough.
631 */
632 if (ts->read_cnt < ts->debounce_max) {
633 ts->last_read = *val;
634 ts->read_cnt++;
635 return ADS7846_FILTER_REPEAT;
636 } else {
637 /*
638 * Maximum number of debouncing reached and still
639 * not enough number of consistent readings. Abort
640 * the whole sample, repeat it in the next sampling
641 * period.
642 */
643 ts->read_cnt = 0;
644 return ADS7846_FILTER_IGNORE;
645 }
646 } else {
647 if (++ts->read_rep > ts->debounce_rep) {
648 /*
649 * Got a good reading for this coordinate,
650 * go for the next one.
651 */
652 ts->read_cnt = 0;
653 ts->read_rep = 0;
654 return ADS7846_FILTER_OK;
655 } else {
656 /* Read more values that are consistent. */
657 ts->read_cnt++;
658 return ADS7846_FILTER_REPEAT;
659 }
660 }
661 }
662
ads7846_no_filter(void * ads,int data_idx,int * val)663 static int ads7846_no_filter(void *ads, int data_idx, int *val)
664 {
665 return ADS7846_FILTER_OK;
666 }
667
ads7846_get_value(struct ads7846 * ts,struct spi_message * m)668 static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m)
669 {
670 int value;
671 struct spi_transfer *t =
672 list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
673
674 if (ts->model == 7845) {
675 value = be16_to_cpup((__be16 *)&(((char *)t->rx_buf)[1]));
676 } else {
677 /*
678 * adjust: on-wire is a must-ignore bit, a BE12 value, then
679 * padding; built from two 8 bit values written msb-first.
680 */
681 value = be16_to_cpup((__be16 *)t->rx_buf);
682 }
683
684 /* enforce ADC output is 12 bits width */
685 return (value >> 3) & 0xfff;
686 }
687
ads7846_update_value(struct spi_message * m,int val)688 static void ads7846_update_value(struct spi_message *m, int val)
689 {
690 struct spi_transfer *t =
691 list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
692
693 *(u16 *)t->rx_buf = val;
694 }
695
ads7846_read_state(struct ads7846 * ts)696 static void ads7846_read_state(struct ads7846 *ts)
697 {
698 struct ads7846_packet *packet = ts->packet;
699 struct spi_message *m;
700 int msg_idx = 0;
701 int val;
702 int action;
703 int error;
704
705 while (msg_idx < ts->msg_count) {
706
707 ts->wait_for_sync();
708
709 m = &ts->msg[msg_idx];
710 error = spi_sync(ts->spi, m);
711 if (error) {
712 dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
713 packet->tc.ignore = true;
714 return;
715 }
716
717 /*
718 * Last message is power down request, no need to convert
719 * or filter the value.
720 */
721 if (msg_idx < ts->msg_count - 1) {
722
723 val = ads7846_get_value(ts, m);
724
725 action = ts->filter(ts->filter_data, msg_idx, &val);
726 switch (action) {
727 case ADS7846_FILTER_REPEAT:
728 continue;
729
730 case ADS7846_FILTER_IGNORE:
731 packet->tc.ignore = true;
732 msg_idx = ts->msg_count - 1;
733 continue;
734
735 case ADS7846_FILTER_OK:
736 ads7846_update_value(m, val);
737 packet->tc.ignore = false;
738 msg_idx++;
739 break;
740
741 default:
742 BUG();
743 }
744 } else {
745 msg_idx++;
746 }
747 }
748 }
749
ads7846_report_state(struct ads7846 * ts)750 static void ads7846_report_state(struct ads7846 *ts)
751 {
752 struct ads7846_packet *packet = ts->packet;
753 unsigned int Rt;
754 u16 x, y, z1, z2;
755
756 /*
757 * ads7846_get_value() does in-place conversion (including byte swap)
758 * from on-the-wire format as part of debouncing to get stable
759 * readings.
760 */
761 if (ts->model == 7845) {
762 x = *(u16 *)packet->tc.x_buf;
763 y = *(u16 *)packet->tc.y_buf;
764 z1 = 0;
765 z2 = 0;
766 } else {
767 x = packet->tc.x;
768 y = packet->tc.y;
769 z1 = packet->tc.z1;
770 z2 = packet->tc.z2;
771 }
772
773 /* range filtering */
774 if (x == MAX_12BIT)
775 x = 0;
776
777 if (ts->model == 7843) {
778 Rt = ts->pressure_max / 2;
779 } else if (ts->model == 7845) {
780 if (get_pendown_state(ts))
781 Rt = ts->pressure_max / 2;
782 else
783 Rt = 0;
784 dev_vdbg(&ts->spi->dev, "x/y: %d/%d, PD %d\n", x, y, Rt);
785 } else if (likely(x && z1)) {
786 /* compute touch pressure resistance using equation #2 */
787 Rt = z2;
788 Rt -= z1;
789 Rt *= ts->x_plate_ohms;
790 Rt = DIV_ROUND_CLOSEST(Rt, 16);
791 Rt *= x;
792 Rt /= z1;
793 Rt = DIV_ROUND_CLOSEST(Rt, 256);
794 } else {
795 Rt = 0;
796 }
797
798 /*
799 * Sample found inconsistent by debouncing or pressure is beyond
800 * the maximum. Don't report it to user space, repeat at least
801 * once more the measurement
802 */
803 if (packet->tc.ignore || Rt > ts->pressure_max) {
804 dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n",
805 packet->tc.ignore, Rt);
806 return;
807 }
808
809 /*
810 * Maybe check the pendown state before reporting. This discards
811 * false readings when the pen is lifted.
812 */
813 if (ts->penirq_recheck_delay_usecs) {
814 udelay(ts->penirq_recheck_delay_usecs);
815 if (!get_pendown_state(ts))
816 Rt = 0;
817 }
818
819 /*
820 * NOTE: We can't rely on the pressure to determine the pen down
821 * state, even this controller has a pressure sensor. The pressure
822 * value can fluctuate for quite a while after lifting the pen and
823 * in some cases may not even settle at the expected value.
824 *
825 * The only safe way to check for the pen up condition is in the
826 * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
827 */
828 if (Rt) {
829 struct input_dev *input = ts->input;
830
831 if (ts->swap_xy)
832 swap(x, y);
833
834 if (!ts->pendown) {
835 input_report_key(input, BTN_TOUCH, 1);
836 ts->pendown = true;
837 dev_vdbg(&ts->spi->dev, "DOWN\n");
838 }
839
840 input_report_abs(input, ABS_X, x);
841 input_report_abs(input, ABS_Y, y);
842 input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt);
843
844 input_sync(input);
845 dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
846 }
847 }
848
ads7846_hard_irq(int irq,void * handle)849 static irqreturn_t ads7846_hard_irq(int irq, void *handle)
850 {
851 struct ads7846 *ts = handle;
852
853 return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
854 }
855
856
ads7846_irq(int irq,void * handle)857 static irqreturn_t ads7846_irq(int irq, void *handle)
858 {
859 struct ads7846 *ts = handle;
860
861 /* Start with a small delay before checking pendown state */
862 msleep(TS_POLL_DELAY);
863
864 while (!ts->stopped && get_pendown_state(ts)) {
865
866 /* pen is down, continue with the measurement */
867 ads7846_read_state(ts);
868
869 if (!ts->stopped)
870 ads7846_report_state(ts);
871
872 wait_event_timeout(ts->wait, ts->stopped,
873 msecs_to_jiffies(TS_POLL_PERIOD));
874 }
875
876 if (ts->pendown) {
877 struct input_dev *input = ts->input;
878
879 input_report_key(input, BTN_TOUCH, 0);
880 input_report_abs(input, ABS_PRESSURE, 0);
881 input_sync(input);
882
883 ts->pendown = false;
884 dev_vdbg(&ts->spi->dev, "UP\n");
885 }
886
887 return IRQ_HANDLED;
888 }
889
ads7846_suspend(struct device * dev)890 static int __maybe_unused ads7846_suspend(struct device *dev)
891 {
892 struct ads7846 *ts = dev_get_drvdata(dev);
893
894 mutex_lock(&ts->lock);
895
896 if (!ts->suspended) {
897
898 if (!ts->disabled)
899 __ads7846_disable(ts);
900
901 if (device_may_wakeup(&ts->spi->dev))
902 enable_irq_wake(ts->spi->irq);
903
904 ts->suspended = true;
905 }
906
907 mutex_unlock(&ts->lock);
908
909 return 0;
910 }
911
ads7846_resume(struct device * dev)912 static int __maybe_unused ads7846_resume(struct device *dev)
913 {
914 struct ads7846 *ts = dev_get_drvdata(dev);
915
916 mutex_lock(&ts->lock);
917
918 if (ts->suspended) {
919
920 ts->suspended = false;
921
922 if (device_may_wakeup(&ts->spi->dev))
923 disable_irq_wake(ts->spi->irq);
924
925 if (!ts->disabled)
926 __ads7846_enable(ts);
927 }
928
929 mutex_unlock(&ts->lock);
930
931 return 0;
932 }
933
934 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
935
ads7846_setup_pendown(struct spi_device * spi,struct ads7846 * ts,const struct ads7846_platform_data * pdata)936 static int ads7846_setup_pendown(struct spi_device *spi,
937 struct ads7846 *ts,
938 const struct ads7846_platform_data *pdata)
939 {
940 int err;
941
942 /*
943 * REVISIT when the irq can be triggered active-low, or if for some
944 * reason the touchscreen isn't hooked up, we don't need to access
945 * the pendown state.
946 */
947
948 if (pdata->get_pendown_state) {
949 ts->get_pendown_state = pdata->get_pendown_state;
950 } else if (gpio_is_valid(pdata->gpio_pendown)) {
951
952 err = gpio_request_one(pdata->gpio_pendown, GPIOF_IN,
953 "ads7846_pendown");
954 if (err) {
955 dev_err(&spi->dev,
956 "failed to request/setup pendown GPIO%d: %d\n",
957 pdata->gpio_pendown, err);
958 return err;
959 }
960
961 ts->gpio_pendown = pdata->gpio_pendown;
962
963 if (pdata->gpio_pendown_debounce)
964 gpio_set_debounce(pdata->gpio_pendown,
965 pdata->gpio_pendown_debounce);
966 } else {
967 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
968 return -EINVAL;
969 }
970
971 return 0;
972 }
973
974 /*
975 * Set up the transfers to read touchscreen state; this assumes we
976 * use formula #2 for pressure, not #3.
977 */
ads7846_setup_spi_msg(struct ads7846 * ts,const struct ads7846_platform_data * pdata)978 static void ads7846_setup_spi_msg(struct ads7846 *ts,
979 const struct ads7846_platform_data *pdata)
980 {
981 struct spi_message *m = &ts->msg[0];
982 struct spi_transfer *x = ts->xfer;
983 struct ads7846_packet *packet = ts->packet;
984 int vref = pdata->keep_vref_on;
985
986 if (ts->model == 7873) {
987 /*
988 * The AD7873 is almost identical to the ADS7846
989 * keep VREF off during differential/ratiometric
990 * conversion modes.
991 */
992 ts->model = 7846;
993 vref = 0;
994 }
995
996 ts->msg_count = 1;
997 spi_message_init(m);
998 m->context = ts;
999
1000 if (ts->model == 7845) {
1001 packet->read_y_cmd[0] = READ_Y(vref);
1002 packet->read_y_cmd[1] = 0;
1003 packet->read_y_cmd[2] = 0;
1004 x->tx_buf = &packet->read_y_cmd[0];
1005 x->rx_buf = &packet->tc.y_buf[0];
1006 x->len = 3;
1007 spi_message_add_tail(x, m);
1008 } else {
1009 /* y- still on; turn on only y+ (and ADC) */
1010 packet->read_y = READ_Y(vref);
1011 x->tx_buf = &packet->read_y;
1012 x->len = 1;
1013 spi_message_add_tail(x, m);
1014
1015 x++;
1016 x->rx_buf = &packet->tc.y;
1017 x->len = 2;
1018 spi_message_add_tail(x, m);
1019 }
1020
1021 /*
1022 * The first sample after switching drivers can be low quality;
1023 * optionally discard it, using a second one after the signals
1024 * have had enough time to stabilize.
1025 */
1026 if (pdata->settle_delay_usecs) {
1027 x->delay_usecs = pdata->settle_delay_usecs;
1028
1029 x++;
1030 x->tx_buf = &packet->read_y;
1031 x->len = 1;
1032 spi_message_add_tail(x, m);
1033
1034 x++;
1035 x->rx_buf = &packet->tc.y;
1036 x->len = 2;
1037 spi_message_add_tail(x, m);
1038 }
1039
1040 ts->msg_count++;
1041 m++;
1042 spi_message_init(m);
1043 m->context = ts;
1044
1045 if (ts->model == 7845) {
1046 x++;
1047 packet->read_x_cmd[0] = READ_X(vref);
1048 packet->read_x_cmd[1] = 0;
1049 packet->read_x_cmd[2] = 0;
1050 x->tx_buf = &packet->read_x_cmd[0];
1051 x->rx_buf = &packet->tc.x_buf[0];
1052 x->len = 3;
1053 spi_message_add_tail(x, m);
1054 } else {
1055 /* turn y- off, x+ on, then leave in lowpower */
1056 x++;
1057 packet->read_x = READ_X(vref);
1058 x->tx_buf = &packet->read_x;
1059 x->len = 1;
1060 spi_message_add_tail(x, m);
1061
1062 x++;
1063 x->rx_buf = &packet->tc.x;
1064 x->len = 2;
1065 spi_message_add_tail(x, m);
1066 }
1067
1068 /* ... maybe discard first sample ... */
1069 if (pdata->settle_delay_usecs) {
1070 x->delay_usecs = pdata->settle_delay_usecs;
1071
1072 x++;
1073 x->tx_buf = &packet->read_x;
1074 x->len = 1;
1075 spi_message_add_tail(x, m);
1076
1077 x++;
1078 x->rx_buf = &packet->tc.x;
1079 x->len = 2;
1080 spi_message_add_tail(x, m);
1081 }
1082
1083 /* turn y+ off, x- on; we'll use formula #2 */
1084 if (ts->model == 7846) {
1085 ts->msg_count++;
1086 m++;
1087 spi_message_init(m);
1088 m->context = ts;
1089
1090 x++;
1091 packet->read_z1 = READ_Z1(vref);
1092 x->tx_buf = &packet->read_z1;
1093 x->len = 1;
1094 spi_message_add_tail(x, m);
1095
1096 x++;
1097 x->rx_buf = &packet->tc.z1;
1098 x->len = 2;
1099 spi_message_add_tail(x, m);
1100
1101 /* ... maybe discard first sample ... */
1102 if (pdata->settle_delay_usecs) {
1103 x->delay_usecs = pdata->settle_delay_usecs;
1104
1105 x++;
1106 x->tx_buf = &packet->read_z1;
1107 x->len = 1;
1108 spi_message_add_tail(x, m);
1109
1110 x++;
1111 x->rx_buf = &packet->tc.z1;
1112 x->len = 2;
1113 spi_message_add_tail(x, m);
1114 }
1115
1116 ts->msg_count++;
1117 m++;
1118 spi_message_init(m);
1119 m->context = ts;
1120
1121 x++;
1122 packet->read_z2 = READ_Z2(vref);
1123 x->tx_buf = &packet->read_z2;
1124 x->len = 1;
1125 spi_message_add_tail(x, m);
1126
1127 x++;
1128 x->rx_buf = &packet->tc.z2;
1129 x->len = 2;
1130 spi_message_add_tail(x, m);
1131
1132 /* ... maybe discard first sample ... */
1133 if (pdata->settle_delay_usecs) {
1134 x->delay_usecs = pdata->settle_delay_usecs;
1135
1136 x++;
1137 x->tx_buf = &packet->read_z2;
1138 x->len = 1;
1139 spi_message_add_tail(x, m);
1140
1141 x++;
1142 x->rx_buf = &packet->tc.z2;
1143 x->len = 2;
1144 spi_message_add_tail(x, m);
1145 }
1146 }
1147
1148 /* power down */
1149 ts->msg_count++;
1150 m++;
1151 spi_message_init(m);
1152 m->context = ts;
1153
1154 if (ts->model == 7845) {
1155 x++;
1156 packet->pwrdown_cmd[0] = PWRDOWN;
1157 packet->pwrdown_cmd[1] = 0;
1158 packet->pwrdown_cmd[2] = 0;
1159 x->tx_buf = &packet->pwrdown_cmd[0];
1160 x->len = 3;
1161 } else {
1162 x++;
1163 packet->pwrdown = PWRDOWN;
1164 x->tx_buf = &packet->pwrdown;
1165 x->len = 1;
1166 spi_message_add_tail(x, m);
1167
1168 x++;
1169 x->rx_buf = &packet->dummy;
1170 x->len = 2;
1171 }
1172
1173 CS_CHANGE(*x);
1174 spi_message_add_tail(x, m);
1175 }
1176
1177 #ifdef CONFIG_OF
1178 static const struct of_device_id ads7846_dt_ids[] = {
1179 { .compatible = "ti,tsc2046", .data = (void *) 7846 },
1180 { .compatible = "ti,ads7843", .data = (void *) 7843 },
1181 { .compatible = "ti,ads7845", .data = (void *) 7845 },
1182 { .compatible = "ti,ads7846", .data = (void *) 7846 },
1183 { .compatible = "ti,ads7873", .data = (void *) 7873 },
1184 { }
1185 };
1186 MODULE_DEVICE_TABLE(of, ads7846_dt_ids);
1187
ads7846_probe_dt(struct device * dev)1188 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1189 {
1190 struct ads7846_platform_data *pdata;
1191 struct device_node *node = dev->of_node;
1192 const struct of_device_id *match;
1193
1194 if (!node) {
1195 dev_err(dev, "Device does not have associated DT data\n");
1196 return ERR_PTR(-EINVAL);
1197 }
1198
1199 match = of_match_device(ads7846_dt_ids, dev);
1200 if (!match) {
1201 dev_err(dev, "Unknown device model\n");
1202 return ERR_PTR(-EINVAL);
1203 }
1204
1205 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1206 if (!pdata)
1207 return ERR_PTR(-ENOMEM);
1208
1209 pdata->model = (unsigned long)match->data;
1210
1211 of_property_read_u16(node, "ti,vref-delay-usecs",
1212 &pdata->vref_delay_usecs);
1213 of_property_read_u16(node, "ti,vref-mv", &pdata->vref_mv);
1214 pdata->keep_vref_on = of_property_read_bool(node, "ti,keep-vref-on");
1215
1216 pdata->swap_xy = of_property_read_bool(node, "ti,swap-xy");
1217
1218 of_property_read_u16(node, "ti,settle-delay-usec",
1219 &pdata->settle_delay_usecs);
1220 of_property_read_u16(node, "ti,penirq-recheck-delay-usecs",
1221 &pdata->penirq_recheck_delay_usecs);
1222
1223 of_property_read_u16(node, "ti,x-plate-ohms", &pdata->x_plate_ohms);
1224 of_property_read_u16(node, "ti,y-plate-ohms", &pdata->y_plate_ohms);
1225
1226 of_property_read_u16(node, "ti,x-min", &pdata->x_min);
1227 of_property_read_u16(node, "ti,y-min", &pdata->y_min);
1228 of_property_read_u16(node, "ti,x-max", &pdata->x_max);
1229 of_property_read_u16(node, "ti,y-max", &pdata->y_max);
1230
1231 of_property_read_u16(node, "ti,pressure-min", &pdata->pressure_min);
1232 of_property_read_u16(node, "ti,pressure-max", &pdata->pressure_max);
1233
1234 of_property_read_u16(node, "ti,debounce-max", &pdata->debounce_max);
1235 of_property_read_u16(node, "ti,debounce-tol", &pdata->debounce_tol);
1236 of_property_read_u16(node, "ti,debounce-rep", &pdata->debounce_rep);
1237
1238 of_property_read_u32(node, "ti,pendown-gpio-debounce",
1239 &pdata->gpio_pendown_debounce);
1240
1241 pdata->wakeup = of_property_read_bool(node, "wakeup-source") ||
1242 of_property_read_bool(node, "linux,wakeup");
1243
1244 pdata->gpio_pendown = of_get_named_gpio(dev->of_node, "pendown-gpio", 0);
1245
1246 return pdata;
1247 }
1248 #else
ads7846_probe_dt(struct device * dev)1249 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1250 {
1251 dev_err(dev, "no platform data defined\n");
1252 return ERR_PTR(-EINVAL);
1253 }
1254 #endif
1255
ads7846_probe(struct spi_device * spi)1256 static int ads7846_probe(struct spi_device *spi)
1257 {
1258 const struct ads7846_platform_data *pdata;
1259 struct ads7846 *ts;
1260 struct ads7846_packet *packet;
1261 struct input_dev *input_dev;
1262 unsigned long irq_flags;
1263 int err;
1264
1265 if (!spi->irq) {
1266 dev_dbg(&spi->dev, "no IRQ?\n");
1267 return -EINVAL;
1268 }
1269
1270 /* don't exceed max specified sample rate */
1271 if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
1272 dev_err(&spi->dev, "f(sample) %d KHz?\n",
1273 (spi->max_speed_hz/SAMPLE_BITS)/1000);
1274 return -EINVAL;
1275 }
1276
1277 /*
1278 * We'd set TX word size 8 bits and RX word size to 13 bits ... except
1279 * that even if the hardware can do that, the SPI controller driver
1280 * may not. So we stick to very-portable 8 bit words, both RX and TX.
1281 */
1282 spi->bits_per_word = 8;
1283 spi->mode = SPI_MODE_0;
1284 err = spi_setup(spi);
1285 if (err < 0)
1286 return err;
1287
1288 ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
1289 packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
1290 input_dev = input_allocate_device();
1291 if (!ts || !packet || !input_dev) {
1292 err = -ENOMEM;
1293 goto err_free_mem;
1294 }
1295
1296 spi_set_drvdata(spi, ts);
1297
1298 ts->packet = packet;
1299 ts->spi = spi;
1300 ts->input = input_dev;
1301
1302 mutex_init(&ts->lock);
1303 init_waitqueue_head(&ts->wait);
1304
1305 pdata = dev_get_platdata(&spi->dev);
1306 if (!pdata) {
1307 pdata = ads7846_probe_dt(&spi->dev);
1308 if (IS_ERR(pdata)) {
1309 err = PTR_ERR(pdata);
1310 goto err_free_mem;
1311 }
1312 }
1313
1314 ts->model = pdata->model ? : 7846;
1315 ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
1316 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
1317 ts->pressure_max = pdata->pressure_max ? : ~0;
1318
1319 ts->vref_mv = pdata->vref_mv;
1320 ts->swap_xy = pdata->swap_xy;
1321
1322 if (pdata->filter != NULL) {
1323 if (pdata->filter_init != NULL) {
1324 err = pdata->filter_init(pdata, &ts->filter_data);
1325 if (err < 0)
1326 goto err_free_mem;
1327 }
1328 ts->filter = pdata->filter;
1329 ts->filter_cleanup = pdata->filter_cleanup;
1330 } else if (pdata->debounce_max) {
1331 ts->debounce_max = pdata->debounce_max;
1332 if (ts->debounce_max < 2)
1333 ts->debounce_max = 2;
1334 ts->debounce_tol = pdata->debounce_tol;
1335 ts->debounce_rep = pdata->debounce_rep;
1336 ts->filter = ads7846_debounce_filter;
1337 ts->filter_data = ts;
1338 } else {
1339 ts->filter = ads7846_no_filter;
1340 }
1341
1342 err = ads7846_setup_pendown(spi, ts, pdata);
1343 if (err)
1344 goto err_cleanup_filter;
1345
1346 if (pdata->penirq_recheck_delay_usecs)
1347 ts->penirq_recheck_delay_usecs =
1348 pdata->penirq_recheck_delay_usecs;
1349
1350 ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
1351
1352 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
1353 snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
1354
1355 input_dev->name = ts->name;
1356 input_dev->phys = ts->phys;
1357 input_dev->dev.parent = &spi->dev;
1358
1359 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1360 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
1361 input_set_abs_params(input_dev, ABS_X,
1362 pdata->x_min ? : 0,
1363 pdata->x_max ? : MAX_12BIT,
1364 0, 0);
1365 input_set_abs_params(input_dev, ABS_Y,
1366 pdata->y_min ? : 0,
1367 pdata->y_max ? : MAX_12BIT,
1368 0, 0);
1369 input_set_abs_params(input_dev, ABS_PRESSURE,
1370 pdata->pressure_min, pdata->pressure_max, 0, 0);
1371
1372 ads7846_setup_spi_msg(ts, pdata);
1373
1374 ts->reg = regulator_get(&spi->dev, "vcc");
1375 if (IS_ERR(ts->reg)) {
1376 err = PTR_ERR(ts->reg);
1377 dev_err(&spi->dev, "unable to get regulator: %d\n", err);
1378 goto err_free_gpio;
1379 }
1380
1381 err = regulator_enable(ts->reg);
1382 if (err) {
1383 dev_err(&spi->dev, "unable to enable regulator: %d\n", err);
1384 goto err_put_regulator;
1385 }
1386
1387 irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
1388 irq_flags |= IRQF_ONESHOT;
1389
1390 err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq,
1391 irq_flags, spi->dev.driver->name, ts);
1392 if (err && !pdata->irq_flags) {
1393 dev_info(&spi->dev,
1394 "trying pin change workaround on irq %d\n", spi->irq);
1395 irq_flags |= IRQF_TRIGGER_RISING;
1396 err = request_threaded_irq(spi->irq,
1397 ads7846_hard_irq, ads7846_irq,
1398 irq_flags, spi->dev.driver->name, ts);
1399 }
1400
1401 if (err) {
1402 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
1403 goto err_disable_regulator;
1404 }
1405
1406 err = ads784x_hwmon_register(spi, ts);
1407 if (err)
1408 goto err_free_irq;
1409
1410 dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
1411
1412 /*
1413 * Take a first sample, leaving nPENIRQ active and vREF off; avoid
1414 * the touchscreen, in case it's not connected.
1415 */
1416 if (ts->model == 7845)
1417 ads7845_read12_ser(&spi->dev, PWRDOWN);
1418 else
1419 (void) ads7846_read12_ser(&spi->dev, READ_12BIT_SER(vaux));
1420
1421 err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
1422 if (err)
1423 goto err_remove_hwmon;
1424
1425 err = input_register_device(input_dev);
1426 if (err)
1427 goto err_remove_attr_group;
1428
1429 device_init_wakeup(&spi->dev, pdata->wakeup);
1430
1431 /*
1432 * If device does not carry platform data we must have allocated it
1433 * when parsing DT data.
1434 */
1435 if (!dev_get_platdata(&spi->dev))
1436 devm_kfree(&spi->dev, (void *)pdata);
1437
1438 return 0;
1439
1440 err_remove_attr_group:
1441 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1442 err_remove_hwmon:
1443 ads784x_hwmon_unregister(spi, ts);
1444 err_free_irq:
1445 free_irq(spi->irq, ts);
1446 err_disable_regulator:
1447 regulator_disable(ts->reg);
1448 err_put_regulator:
1449 regulator_put(ts->reg);
1450 err_free_gpio:
1451 if (!ts->get_pendown_state)
1452 gpio_free(ts->gpio_pendown);
1453 err_cleanup_filter:
1454 if (ts->filter_cleanup)
1455 ts->filter_cleanup(ts->filter_data);
1456 err_free_mem:
1457 input_free_device(input_dev);
1458 kfree(packet);
1459 kfree(ts);
1460 return err;
1461 }
1462
ads7846_remove(struct spi_device * spi)1463 static int ads7846_remove(struct spi_device *spi)
1464 {
1465 struct ads7846 *ts = spi_get_drvdata(spi);
1466
1467 device_init_wakeup(&spi->dev, false);
1468
1469 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1470
1471 ads7846_disable(ts);
1472 free_irq(ts->spi->irq, ts);
1473
1474 input_unregister_device(ts->input);
1475
1476 ads784x_hwmon_unregister(spi, ts);
1477
1478 regulator_disable(ts->reg);
1479 regulator_put(ts->reg);
1480
1481 if (!ts->get_pendown_state) {
1482 /*
1483 * If we are not using specialized pendown method we must
1484 * have been relying on gpio we set up ourselves.
1485 */
1486 gpio_free(ts->gpio_pendown);
1487 }
1488
1489 if (ts->filter_cleanup)
1490 ts->filter_cleanup(ts->filter_data);
1491
1492 kfree(ts->packet);
1493 kfree(ts);
1494
1495 dev_dbg(&spi->dev, "unregistered touchscreen\n");
1496
1497 return 0;
1498 }
1499
1500 static struct spi_driver ads7846_driver = {
1501 .driver = {
1502 .name = "ads7846",
1503 .pm = &ads7846_pm,
1504 .of_match_table = of_match_ptr(ads7846_dt_ids),
1505 },
1506 .probe = ads7846_probe,
1507 .remove = ads7846_remove,
1508 };
1509
1510 module_spi_driver(ads7846_driver);
1511
1512 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1513 MODULE_LICENSE("GPL");
1514 MODULE_ALIAS("spi:ads7846");
1515