1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ADS7846 based touchscreen and sensor driver
4  *
5  * Copyright (c) 2005 David Brownell
6  * Copyright (c) 2006 Nokia Corporation
7  * Various changes: Imre Deak <imre.deak@nokia.com>
8  *
9  * Using code from:
10  *  - corgi_ts.c
11  *	Copyright (C) 2004-2005 Richard Purdie
12  *  - omap_ts.[hc], ads7846.h, ts_osk.c
13  *	Copyright (C) 2002 MontaVista Software
14  *	Copyright (C) 2004 Texas Instruments
15  *	Copyright (C) 2005 Dirk Behme
16  */
17 #include <linux/types.h>
18 #include <linux/hwmon.h>
19 #include <linux/err.h>
20 #include <linux/sched.h>
21 #include <linux/delay.h>
22 #include <linux/input.h>
23 #include <linux/input/touchscreen.h>
24 #include <linux/interrupt.h>
25 #include <linux/slab.h>
26 #include <linux/pm.h>
27 #include <linux/of.h>
28 #include <linux/of_gpio.h>
29 #include <linux/of_device.h>
30 #include <linux/gpio.h>
31 #include <linux/spi/spi.h>
32 #include <linux/spi/ads7846.h>
33 #include <linux/regulator/consumer.h>
34 #include <linux/module.h>
35 #include <asm/irq.h>
36 
37 /*
38  * This code has been heavily tested on a Nokia 770, and lightly
39  * tested on other ads7846 devices (OSK/Mistral, Lubbock, Spitz).
40  * TSC2046 is just newer ads7846 silicon.
41  * Support for ads7843 tested on Atmel at91sam926x-EK.
42  * Support for ads7845 has only been stubbed in.
43  * Support for Analog Devices AD7873 and AD7843 tested.
44  *
45  * IRQ handling needs a workaround because of a shortcoming in handling
46  * edge triggered IRQs on some platforms like the OMAP1/2. These
47  * platforms don't handle the ARM lazy IRQ disabling properly, thus we
48  * have to maintain our own SW IRQ disabled status. This should be
49  * removed as soon as the affected platform's IRQ handling is fixed.
50  *
51  * App note sbaa036 talks in more detail about accurate sampling...
52  * that ought to help in situations like LCDs inducing noise (which
53  * can also be helped by using synch signals) and more generally.
54  * This driver tries to utilize the measures described in the app
55  * note. The strength of filtering can be set in the board-* specific
56  * files.
57  */
58 
59 #define TS_POLL_DELAY	1	/* ms delay before the first sample */
60 #define TS_POLL_PERIOD	5	/* ms delay between samples */
61 
62 /* this driver doesn't aim at the peak continuous sample rate */
63 #define	SAMPLE_BITS	(8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
64 
65 struct ts_event {
66 	/*
67 	 * For portability, we can't read 12 bit values using SPI (which
68 	 * would make the controller deliver them as native byte order u16
69 	 * with msbs zeroed).  Instead, we read them as two 8-bit values,
70 	 * *** WHICH NEED BYTESWAPPING *** and range adjustment.
71 	 */
72 	u16	x;
73 	u16	y;
74 	u16	z1, z2;
75 	bool	ignore;
76 	u8	x_buf[3];
77 	u8	y_buf[3];
78 };
79 
80 /*
81  * We allocate this separately to avoid cache line sharing issues when
82  * driver is used with DMA-based SPI controllers (like atmel_spi) on
83  * systems where main memory is not DMA-coherent (most non-x86 boards).
84  */
85 struct ads7846_packet {
86 	u8			read_x, read_y, read_z1, read_z2, pwrdown;
87 	u16			dummy;		/* for the pwrdown read */
88 	struct ts_event		tc;
89 	/* for ads7845 with mpc5121 psc spi we use 3-byte buffers */
90 	u8			read_x_cmd[3], read_y_cmd[3], pwrdown_cmd[3];
91 };
92 
93 struct ads7846 {
94 	struct input_dev	*input;
95 	char			phys[32];
96 	char			name[32];
97 
98 	struct spi_device	*spi;
99 	struct regulator	*reg;
100 
101 #if IS_ENABLED(CONFIG_HWMON)
102 	struct device		*hwmon;
103 #endif
104 
105 	u16			model;
106 	u16			vref_mv;
107 	u16			vref_delay_usecs;
108 	u16			x_plate_ohms;
109 	u16			pressure_max;
110 
111 	bool			swap_xy;
112 	bool			use_internal;
113 
114 	struct ads7846_packet	*packet;
115 
116 	struct spi_transfer	xfer[18];
117 	struct spi_message	msg[5];
118 	int			msg_count;
119 	wait_queue_head_t	wait;
120 
121 	bool			pendown;
122 
123 	int			read_cnt;
124 	int			read_rep;
125 	int			last_read;
126 
127 	u16			debounce_max;
128 	u16			debounce_tol;
129 	u16			debounce_rep;
130 
131 	u16			penirq_recheck_delay_usecs;
132 
133 	struct touchscreen_properties core_prop;
134 
135 	struct mutex		lock;
136 	bool			stopped;	/* P: lock */
137 	bool			disabled;	/* P: lock */
138 	bool			suspended;	/* P: lock */
139 
140 	int			(*filter)(void *data, int data_idx, int *val);
141 	void			*filter_data;
142 	void			(*filter_cleanup)(void *data);
143 	int			(*get_pendown_state)(void);
144 	int			gpio_pendown;
145 
146 	void			(*wait_for_sync)(void);
147 };
148 
149 /* leave chip selected when we're done, for quicker re-select? */
150 #if	0
151 #define	CS_CHANGE(xfer)	((xfer).cs_change = 1)
152 #else
153 #define	CS_CHANGE(xfer)	((xfer).cs_change = 0)
154 #endif
155 
156 /*--------------------------------------------------------------------------*/
157 
158 /* The ADS7846 has touchscreen and other sensors.
159  * Earlier ads784x chips are somewhat compatible.
160  */
161 #define	ADS_START		(1 << 7)
162 #define	ADS_A2A1A0_d_y		(1 << 4)	/* differential */
163 #define	ADS_A2A1A0_d_z1		(3 << 4)	/* differential */
164 #define	ADS_A2A1A0_d_z2		(4 << 4)	/* differential */
165 #define	ADS_A2A1A0_d_x		(5 << 4)	/* differential */
166 #define	ADS_A2A1A0_temp0	(0 << 4)	/* non-differential */
167 #define	ADS_A2A1A0_vbatt	(2 << 4)	/* non-differential */
168 #define	ADS_A2A1A0_vaux		(6 << 4)	/* non-differential */
169 #define	ADS_A2A1A0_temp1	(7 << 4)	/* non-differential */
170 #define	ADS_8_BIT		(1 << 3)
171 #define	ADS_12_BIT		(0 << 3)
172 #define	ADS_SER			(1 << 2)	/* non-differential */
173 #define	ADS_DFR			(0 << 2)	/* differential */
174 #define	ADS_PD10_PDOWN		(0 << 0)	/* low power mode + penirq */
175 #define	ADS_PD10_ADC_ON		(1 << 0)	/* ADC on */
176 #define	ADS_PD10_REF_ON		(2 << 0)	/* vREF on + penirq */
177 #define	ADS_PD10_ALL_ON		(3 << 0)	/* ADC + vREF on */
178 
179 #define	MAX_12BIT	((1<<12)-1)
180 
181 /* leave ADC powered up (disables penirq) between differential samples */
182 #define	READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
183 	| ADS_12_BIT | ADS_DFR | \
184 	(adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
185 
186 #define	READ_Y(vref)	(READ_12BIT_DFR(y,  1, vref))
187 #define	READ_Z1(vref)	(READ_12BIT_DFR(z1, 1, vref))
188 #define	READ_Z2(vref)	(READ_12BIT_DFR(z2, 1, vref))
189 
190 #define	READ_X(vref)	(READ_12BIT_DFR(x,  1, vref))
191 #define	PWRDOWN		(READ_12BIT_DFR(y,  0, 0))	/* LAST */
192 
193 /* single-ended samples need to first power up reference voltage;
194  * we leave both ADC and VREF powered
195  */
196 #define	READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
197 	| ADS_12_BIT | ADS_SER)
198 
199 #define	REF_ON	(READ_12BIT_DFR(x, 1, 1))
200 #define	REF_OFF	(READ_12BIT_DFR(y, 0, 0))
201 
202 /* Must be called with ts->lock held */
203 static void ads7846_stop(struct ads7846 *ts)
204 {
205 	if (!ts->disabled && !ts->suspended) {
206 		/* Signal IRQ thread to stop polling and disable the handler. */
207 		ts->stopped = true;
208 		mb();
209 		wake_up(&ts->wait);
210 		disable_irq(ts->spi->irq);
211 	}
212 }
213 
214 /* Must be called with ts->lock held */
215 static void ads7846_restart(struct ads7846 *ts)
216 {
217 	if (!ts->disabled && !ts->suspended) {
218 		/* Tell IRQ thread that it may poll the device. */
219 		ts->stopped = false;
220 		mb();
221 		enable_irq(ts->spi->irq);
222 	}
223 }
224 
225 /* Must be called with ts->lock held */
226 static void __ads7846_disable(struct ads7846 *ts)
227 {
228 	ads7846_stop(ts);
229 	regulator_disable(ts->reg);
230 
231 	/*
232 	 * We know the chip's in low power mode since we always
233 	 * leave it that way after every request
234 	 */
235 }
236 
237 /* Must be called with ts->lock held */
238 static void __ads7846_enable(struct ads7846 *ts)
239 {
240 	int error;
241 
242 	error = regulator_enable(ts->reg);
243 	if (error != 0)
244 		dev_err(&ts->spi->dev, "Failed to enable supply: %d\n", error);
245 
246 	ads7846_restart(ts);
247 }
248 
249 static void ads7846_disable(struct ads7846 *ts)
250 {
251 	mutex_lock(&ts->lock);
252 
253 	if (!ts->disabled) {
254 
255 		if  (!ts->suspended)
256 			__ads7846_disable(ts);
257 
258 		ts->disabled = true;
259 	}
260 
261 	mutex_unlock(&ts->lock);
262 }
263 
264 static void ads7846_enable(struct ads7846 *ts)
265 {
266 	mutex_lock(&ts->lock);
267 
268 	if (ts->disabled) {
269 
270 		ts->disabled = false;
271 
272 		if (!ts->suspended)
273 			__ads7846_enable(ts);
274 	}
275 
276 	mutex_unlock(&ts->lock);
277 }
278 
279 /*--------------------------------------------------------------------------*/
280 
281 /*
282  * Non-touchscreen sensors only use single-ended conversions.
283  * The range is GND..vREF. The ads7843 and ads7835 must use external vREF;
284  * ads7846 lets that pin be unconnected, to use internal vREF.
285  */
286 
287 struct ser_req {
288 	u8			ref_on;
289 	u8			command;
290 	u8			ref_off;
291 	u16			scratch;
292 	struct spi_message	msg;
293 	struct spi_transfer	xfer[6];
294 	/*
295 	 * DMA (thus cache coherency maintenance) requires the
296 	 * transfer buffers to live in their own cache lines.
297 	 */
298 	__be16 sample ____cacheline_aligned;
299 };
300 
301 struct ads7845_ser_req {
302 	u8			command[3];
303 	struct spi_message	msg;
304 	struct spi_transfer	xfer[2];
305 	/*
306 	 * DMA (thus cache coherency maintenance) requires the
307 	 * transfer buffers to live in their own cache lines.
308 	 */
309 	u8 sample[3] ____cacheline_aligned;
310 };
311 
312 static int ads7846_read12_ser(struct device *dev, unsigned command)
313 {
314 	struct spi_device *spi = to_spi_device(dev);
315 	struct ads7846 *ts = dev_get_drvdata(dev);
316 	struct ser_req *req;
317 	int status;
318 
319 	req = kzalloc(sizeof *req, GFP_KERNEL);
320 	if (!req)
321 		return -ENOMEM;
322 
323 	spi_message_init(&req->msg);
324 
325 	/* maybe turn on internal vREF, and let it settle */
326 	if (ts->use_internal) {
327 		req->ref_on = REF_ON;
328 		req->xfer[0].tx_buf = &req->ref_on;
329 		req->xfer[0].len = 1;
330 		spi_message_add_tail(&req->xfer[0], &req->msg);
331 
332 		req->xfer[1].rx_buf = &req->scratch;
333 		req->xfer[1].len = 2;
334 
335 		/* for 1uF, settle for 800 usec; no cap, 100 usec.  */
336 		req->xfer[1].delay.value = ts->vref_delay_usecs;
337 		req->xfer[1].delay.unit = SPI_DELAY_UNIT_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 
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 = be16_to_cpu(*((u16 *)&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  */
443 static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
444 {
445 	return v;
446 }
447 
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 
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 
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 const struct attribute_group ads7846_attr_group = {
504 	.attrs = ads7846_attributes,
505 	.is_visible = ads7846_is_visible,
506 };
507 __ATTRIBUTE_GROUPS(ads7846_attr);
508 
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 
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
545 static inline int ads784x_hwmon_register(struct spi_device *spi,
546 					 struct ads7846 *ts)
547 {
548 	return 0;
549 }
550 
551 static inline void ads784x_hwmon_unregister(struct spi_device *spi,
552 					    struct ads7846 *ts)
553 {
554 }
555 #endif
556 
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 
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 
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 const struct attribute_group ads784x_attr_group = {
604 	.attrs = ads784x_attributes,
605 };
606 
607 /*--------------------------------------------------------------------------*/
608 
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 
617 static void null_wait_for_sync(void)
618 {
619 }
620 
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 
663 static int ads7846_no_filter(void *ads, int data_idx, int *val)
664 {
665 	return ADS7846_FILTER_OK;
666 }
667 
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 
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 
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 
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 *= x;
790 		Rt *= ts->x_plate_ohms;
791 		Rt /= z1;
792 		Rt = (Rt + 2047) >> 12;
793 	} else {
794 		Rt = 0;
795 	}
796 
797 	/*
798 	 * Sample found inconsistent by debouncing or pressure is beyond
799 	 * the maximum. Don't report it to user space, repeat at least
800 	 * once more the measurement
801 	 */
802 	if (packet->tc.ignore || Rt > ts->pressure_max) {
803 		dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n",
804 			 packet->tc.ignore, Rt);
805 		return;
806 	}
807 
808 	/*
809 	 * Maybe check the pendown state before reporting. This discards
810 	 * false readings when the pen is lifted.
811 	 */
812 	if (ts->penirq_recheck_delay_usecs) {
813 		udelay(ts->penirq_recheck_delay_usecs);
814 		if (!get_pendown_state(ts))
815 			Rt = 0;
816 	}
817 
818 	/*
819 	 * NOTE: We can't rely on the pressure to determine the pen down
820 	 * state, even this controller has a pressure sensor. The pressure
821 	 * value can fluctuate for quite a while after lifting the pen and
822 	 * in some cases may not even settle at the expected value.
823 	 *
824 	 * The only safe way to check for the pen up condition is in the
825 	 * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
826 	 */
827 	if (Rt) {
828 		struct input_dev *input = ts->input;
829 
830 		if (!ts->pendown) {
831 			input_report_key(input, BTN_TOUCH, 1);
832 			ts->pendown = true;
833 			dev_vdbg(&ts->spi->dev, "DOWN\n");
834 		}
835 
836 		touchscreen_report_pos(input, &ts->core_prop, x, y, false);
837 		input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt);
838 
839 		input_sync(input);
840 		dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
841 	}
842 }
843 
844 static irqreturn_t ads7846_hard_irq(int irq, void *handle)
845 {
846 	struct ads7846 *ts = handle;
847 
848 	return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
849 }
850 
851 
852 static irqreturn_t ads7846_irq(int irq, void *handle)
853 {
854 	struct ads7846 *ts = handle;
855 
856 	/* Start with a small delay before checking pendown state */
857 	msleep(TS_POLL_DELAY);
858 
859 	while (!ts->stopped && get_pendown_state(ts)) {
860 
861 		/* pen is down, continue with the measurement */
862 		ads7846_read_state(ts);
863 
864 		if (!ts->stopped)
865 			ads7846_report_state(ts);
866 
867 		wait_event_timeout(ts->wait, ts->stopped,
868 				   msecs_to_jiffies(TS_POLL_PERIOD));
869 	}
870 
871 	if (ts->pendown && !ts->stopped) {
872 		struct input_dev *input = ts->input;
873 
874 		input_report_key(input, BTN_TOUCH, 0);
875 		input_report_abs(input, ABS_PRESSURE, 0);
876 		input_sync(input);
877 
878 		ts->pendown = false;
879 		dev_vdbg(&ts->spi->dev, "UP\n");
880 	}
881 
882 	return IRQ_HANDLED;
883 }
884 
885 static int __maybe_unused ads7846_suspend(struct device *dev)
886 {
887 	struct ads7846 *ts = dev_get_drvdata(dev);
888 
889 	mutex_lock(&ts->lock);
890 
891 	if (!ts->suspended) {
892 
893 		if (!ts->disabled)
894 			__ads7846_disable(ts);
895 
896 		if (device_may_wakeup(&ts->spi->dev))
897 			enable_irq_wake(ts->spi->irq);
898 
899 		ts->suspended = true;
900 	}
901 
902 	mutex_unlock(&ts->lock);
903 
904 	return 0;
905 }
906 
907 static int __maybe_unused ads7846_resume(struct device *dev)
908 {
909 	struct ads7846 *ts = dev_get_drvdata(dev);
910 
911 	mutex_lock(&ts->lock);
912 
913 	if (ts->suspended) {
914 
915 		ts->suspended = false;
916 
917 		if (device_may_wakeup(&ts->spi->dev))
918 			disable_irq_wake(ts->spi->irq);
919 
920 		if (!ts->disabled)
921 			__ads7846_enable(ts);
922 	}
923 
924 	mutex_unlock(&ts->lock);
925 
926 	return 0;
927 }
928 
929 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
930 
931 static int ads7846_setup_pendown(struct spi_device *spi,
932 				 struct ads7846 *ts,
933 				 const struct ads7846_platform_data *pdata)
934 {
935 	int err;
936 
937 	/*
938 	 * REVISIT when the irq can be triggered active-low, or if for some
939 	 * reason the touchscreen isn't hooked up, we don't need to access
940 	 * the pendown state.
941 	 */
942 
943 	if (pdata->get_pendown_state) {
944 		ts->get_pendown_state = pdata->get_pendown_state;
945 	} else if (gpio_is_valid(pdata->gpio_pendown)) {
946 
947 		err = gpio_request_one(pdata->gpio_pendown, GPIOF_IN,
948 				       "ads7846_pendown");
949 		if (err) {
950 			dev_err(&spi->dev,
951 				"failed to request/setup pendown GPIO%d: %d\n",
952 				pdata->gpio_pendown, err);
953 			return err;
954 		}
955 
956 		ts->gpio_pendown = pdata->gpio_pendown;
957 
958 		if (pdata->gpio_pendown_debounce)
959 			gpio_set_debounce(pdata->gpio_pendown,
960 					  pdata->gpio_pendown_debounce);
961 	} else {
962 		dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
963 		return -EINVAL;
964 	}
965 
966 	return 0;
967 }
968 
969 /*
970  * Set up the transfers to read touchscreen state; this assumes we
971  * use formula #2 for pressure, not #3.
972  */
973 static void ads7846_setup_spi_msg(struct ads7846 *ts,
974 				  const struct ads7846_platform_data *pdata)
975 {
976 	struct spi_message *m = &ts->msg[0];
977 	struct spi_transfer *x = ts->xfer;
978 	struct ads7846_packet *packet = ts->packet;
979 	int vref = pdata->keep_vref_on;
980 
981 	if (ts->model == 7873) {
982 		/*
983 		 * The AD7873 is almost identical to the ADS7846
984 		 * keep VREF off during differential/ratiometric
985 		 * conversion modes.
986 		 */
987 		ts->model = 7846;
988 		vref = 0;
989 	}
990 
991 	ts->msg_count = 1;
992 	spi_message_init(m);
993 	m->context = ts;
994 
995 	if (ts->model == 7845) {
996 		packet->read_y_cmd[0] = READ_Y(vref);
997 		packet->read_y_cmd[1] = 0;
998 		packet->read_y_cmd[2] = 0;
999 		x->tx_buf = &packet->read_y_cmd[0];
1000 		x->rx_buf = &packet->tc.y_buf[0];
1001 		x->len = 3;
1002 		spi_message_add_tail(x, m);
1003 	} else {
1004 		/* y- still on; turn on only y+ (and ADC) */
1005 		packet->read_y = READ_Y(vref);
1006 		x->tx_buf = &packet->read_y;
1007 		x->len = 1;
1008 		spi_message_add_tail(x, m);
1009 
1010 		x++;
1011 		x->rx_buf = &packet->tc.y;
1012 		x->len = 2;
1013 		spi_message_add_tail(x, m);
1014 	}
1015 
1016 	/*
1017 	 * The first sample after switching drivers can be low quality;
1018 	 * optionally discard it, using a second one after the signals
1019 	 * have had enough time to stabilize.
1020 	 */
1021 	if (pdata->settle_delay_usecs) {
1022 		x->delay.value = pdata->settle_delay_usecs;
1023 		x->delay.unit = SPI_DELAY_UNIT_USECS;
1024 
1025 		x++;
1026 		x->tx_buf = &packet->read_y;
1027 		x->len = 1;
1028 		spi_message_add_tail(x, m);
1029 
1030 		x++;
1031 		x->rx_buf = &packet->tc.y;
1032 		x->len = 2;
1033 		spi_message_add_tail(x, m);
1034 	}
1035 
1036 	ts->msg_count++;
1037 	m++;
1038 	spi_message_init(m);
1039 	m->context = ts;
1040 
1041 	if (ts->model == 7845) {
1042 		x++;
1043 		packet->read_x_cmd[0] = READ_X(vref);
1044 		packet->read_x_cmd[1] = 0;
1045 		packet->read_x_cmd[2] = 0;
1046 		x->tx_buf = &packet->read_x_cmd[0];
1047 		x->rx_buf = &packet->tc.x_buf[0];
1048 		x->len = 3;
1049 		spi_message_add_tail(x, m);
1050 	} else {
1051 		/* turn y- off, x+ on, then leave in lowpower */
1052 		x++;
1053 		packet->read_x = READ_X(vref);
1054 		x->tx_buf = &packet->read_x;
1055 		x->len = 1;
1056 		spi_message_add_tail(x, m);
1057 
1058 		x++;
1059 		x->rx_buf = &packet->tc.x;
1060 		x->len = 2;
1061 		spi_message_add_tail(x, m);
1062 	}
1063 
1064 	/* ... maybe discard first sample ... */
1065 	if (pdata->settle_delay_usecs) {
1066 		x->delay.value = pdata->settle_delay_usecs;
1067 		x->delay.unit = SPI_DELAY_UNIT_USECS;
1068 
1069 		x++;
1070 		x->tx_buf = &packet->read_x;
1071 		x->len = 1;
1072 		spi_message_add_tail(x, m);
1073 
1074 		x++;
1075 		x->rx_buf = &packet->tc.x;
1076 		x->len = 2;
1077 		spi_message_add_tail(x, m);
1078 	}
1079 
1080 	/* turn y+ off, x- on; we'll use formula #2 */
1081 	if (ts->model == 7846) {
1082 		ts->msg_count++;
1083 		m++;
1084 		spi_message_init(m);
1085 		m->context = ts;
1086 
1087 		x++;
1088 		packet->read_z1 = READ_Z1(vref);
1089 		x->tx_buf = &packet->read_z1;
1090 		x->len = 1;
1091 		spi_message_add_tail(x, m);
1092 
1093 		x++;
1094 		x->rx_buf = &packet->tc.z1;
1095 		x->len = 2;
1096 		spi_message_add_tail(x, m);
1097 
1098 		/* ... maybe discard first sample ... */
1099 		if (pdata->settle_delay_usecs) {
1100 			x->delay.value = pdata->settle_delay_usecs;
1101 			x->delay.unit = SPI_DELAY_UNIT_USECS;
1102 
1103 			x++;
1104 			x->tx_buf = &packet->read_z1;
1105 			x->len = 1;
1106 			spi_message_add_tail(x, m);
1107 
1108 			x++;
1109 			x->rx_buf = &packet->tc.z1;
1110 			x->len = 2;
1111 			spi_message_add_tail(x, m);
1112 		}
1113 
1114 		ts->msg_count++;
1115 		m++;
1116 		spi_message_init(m);
1117 		m->context = ts;
1118 
1119 		x++;
1120 		packet->read_z2 = READ_Z2(vref);
1121 		x->tx_buf = &packet->read_z2;
1122 		x->len = 1;
1123 		spi_message_add_tail(x, m);
1124 
1125 		x++;
1126 		x->rx_buf = &packet->tc.z2;
1127 		x->len = 2;
1128 		spi_message_add_tail(x, m);
1129 
1130 		/* ... maybe discard first sample ... */
1131 		if (pdata->settle_delay_usecs) {
1132 			x->delay.value = pdata->settle_delay_usecs;
1133 			x->delay.unit = SPI_DELAY_UNIT_USECS;
1134 
1135 			x++;
1136 			x->tx_buf = &packet->read_z2;
1137 			x->len = 1;
1138 			spi_message_add_tail(x, m);
1139 
1140 			x++;
1141 			x->rx_buf = &packet->tc.z2;
1142 			x->len = 2;
1143 			spi_message_add_tail(x, m);
1144 		}
1145 	}
1146 
1147 	/* power down */
1148 	ts->msg_count++;
1149 	m++;
1150 	spi_message_init(m);
1151 	m->context = ts;
1152 
1153 	if (ts->model == 7845) {
1154 		x++;
1155 		packet->pwrdown_cmd[0] = PWRDOWN;
1156 		packet->pwrdown_cmd[1] = 0;
1157 		packet->pwrdown_cmd[2] = 0;
1158 		x->tx_buf = &packet->pwrdown_cmd[0];
1159 		x->len = 3;
1160 	} else {
1161 		x++;
1162 		packet->pwrdown = PWRDOWN;
1163 		x->tx_buf = &packet->pwrdown;
1164 		x->len = 1;
1165 		spi_message_add_tail(x, m);
1166 
1167 		x++;
1168 		x->rx_buf = &packet->dummy;
1169 		x->len = 2;
1170 	}
1171 
1172 	CS_CHANGE(*x);
1173 	spi_message_add_tail(x, m);
1174 }
1175 
1176 #ifdef CONFIG_OF
1177 static const struct of_device_id ads7846_dt_ids[] = {
1178 	{ .compatible = "ti,tsc2046",	.data = (void *) 7846 },
1179 	{ .compatible = "ti,ads7843",	.data = (void *) 7843 },
1180 	{ .compatible = "ti,ads7845",	.data = (void *) 7845 },
1181 	{ .compatible = "ti,ads7846",	.data = (void *) 7846 },
1182 	{ .compatible = "ti,ads7873",	.data = (void *) 7873 },
1183 	{ }
1184 };
1185 MODULE_DEVICE_TABLE(of, ads7846_dt_ids);
1186 
1187 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1188 {
1189 	struct ads7846_platform_data *pdata;
1190 	struct device_node *node = dev->of_node;
1191 	const struct of_device_id *match;
1192 	u32 value;
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 	/*
1232 	 * touchscreen-max-pressure gets parsed during
1233 	 * touchscreen_parse_properties()
1234 	 */
1235 	of_property_read_u16(node, "ti,pressure-min", &pdata->pressure_min);
1236 	if (!of_property_read_u32(node, "touchscreen-min-pressure", &value))
1237 		pdata->pressure_min = (u16) value;
1238 	of_property_read_u16(node, "ti,pressure-max", &pdata->pressure_max);
1239 
1240 	of_property_read_u16(node, "ti,debounce-max", &pdata->debounce_max);
1241 	if (!of_property_read_u32(node, "touchscreen-average-samples", &value))
1242 		pdata->debounce_max = (u16) value;
1243 	of_property_read_u16(node, "ti,debounce-tol", &pdata->debounce_tol);
1244 	of_property_read_u16(node, "ti,debounce-rep", &pdata->debounce_rep);
1245 
1246 	of_property_read_u32(node, "ti,pendown-gpio-debounce",
1247 			     &pdata->gpio_pendown_debounce);
1248 
1249 	pdata->wakeup = of_property_read_bool(node, "wakeup-source") ||
1250 			of_property_read_bool(node, "linux,wakeup");
1251 
1252 	pdata->gpio_pendown = of_get_named_gpio(dev->of_node, "pendown-gpio", 0);
1253 
1254 	return pdata;
1255 }
1256 #else
1257 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1258 {
1259 	dev_err(dev, "no platform data defined\n");
1260 	return ERR_PTR(-EINVAL);
1261 }
1262 #endif
1263 
1264 static int ads7846_probe(struct spi_device *spi)
1265 {
1266 	const struct ads7846_platform_data *pdata;
1267 	struct ads7846 *ts;
1268 	struct ads7846_packet *packet;
1269 	struct input_dev *input_dev;
1270 	unsigned long irq_flags;
1271 	int err;
1272 
1273 	if (!spi->irq) {
1274 		dev_dbg(&spi->dev, "no IRQ?\n");
1275 		return -EINVAL;
1276 	}
1277 
1278 	/* don't exceed max specified sample rate */
1279 	if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
1280 		dev_err(&spi->dev, "f(sample) %d KHz?\n",
1281 				(spi->max_speed_hz/SAMPLE_BITS)/1000);
1282 		return -EINVAL;
1283 	}
1284 
1285 	/*
1286 	 * We'd set TX word size 8 bits and RX word size to 13 bits ... except
1287 	 * that even if the hardware can do that, the SPI controller driver
1288 	 * may not.  So we stick to very-portable 8 bit words, both RX and TX.
1289 	 */
1290 	spi->bits_per_word = 8;
1291 	spi->mode = SPI_MODE_0;
1292 	err = spi_setup(spi);
1293 	if (err < 0)
1294 		return err;
1295 
1296 	ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
1297 	packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
1298 	input_dev = input_allocate_device();
1299 	if (!ts || !packet || !input_dev) {
1300 		err = -ENOMEM;
1301 		goto err_free_mem;
1302 	}
1303 
1304 	spi_set_drvdata(spi, ts);
1305 
1306 	ts->packet = packet;
1307 	ts->spi = spi;
1308 	ts->input = input_dev;
1309 
1310 	mutex_init(&ts->lock);
1311 	init_waitqueue_head(&ts->wait);
1312 
1313 	pdata = dev_get_platdata(&spi->dev);
1314 	if (!pdata) {
1315 		pdata = ads7846_probe_dt(&spi->dev);
1316 		if (IS_ERR(pdata)) {
1317 			err = PTR_ERR(pdata);
1318 			goto err_free_mem;
1319 		}
1320 	}
1321 
1322 	ts->model = pdata->model ? : 7846;
1323 	ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
1324 	ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
1325 	ts->vref_mv = pdata->vref_mv;
1326 
1327 	if (pdata->filter != NULL) {
1328 		if (pdata->filter_init != NULL) {
1329 			err = pdata->filter_init(pdata, &ts->filter_data);
1330 			if (err < 0)
1331 				goto err_free_mem;
1332 		}
1333 		ts->filter = pdata->filter;
1334 		ts->filter_cleanup = pdata->filter_cleanup;
1335 	} else if (pdata->debounce_max) {
1336 		ts->debounce_max = pdata->debounce_max;
1337 		if (ts->debounce_max < 2)
1338 			ts->debounce_max = 2;
1339 		ts->debounce_tol = pdata->debounce_tol;
1340 		ts->debounce_rep = pdata->debounce_rep;
1341 		ts->filter = ads7846_debounce_filter;
1342 		ts->filter_data = ts;
1343 	} else {
1344 		ts->filter = ads7846_no_filter;
1345 	}
1346 
1347 	err = ads7846_setup_pendown(spi, ts, pdata);
1348 	if (err)
1349 		goto err_cleanup_filter;
1350 
1351 	if (pdata->penirq_recheck_delay_usecs)
1352 		ts->penirq_recheck_delay_usecs =
1353 				pdata->penirq_recheck_delay_usecs;
1354 
1355 	ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
1356 
1357 	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
1358 	snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
1359 
1360 	input_dev->name = ts->name;
1361 	input_dev->phys = ts->phys;
1362 	input_dev->dev.parent = &spi->dev;
1363 
1364 	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1365 	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
1366 	input_set_abs_params(input_dev, ABS_X,
1367 			pdata->x_min ? : 0,
1368 			pdata->x_max ? : MAX_12BIT,
1369 			0, 0);
1370 	input_set_abs_params(input_dev, ABS_Y,
1371 			pdata->y_min ? : 0,
1372 			pdata->y_max ? : MAX_12BIT,
1373 			0, 0);
1374 	input_set_abs_params(input_dev, ABS_PRESSURE,
1375 			pdata->pressure_min, pdata->pressure_max, 0, 0);
1376 
1377 	/*
1378 	 * Parse common framework properties. Must be done here to ensure the
1379 	 * correct behaviour in case of using the legacy vendor bindings. The
1380 	 * general binding value overrides the vendor specific one.
1381 	 */
1382 	touchscreen_parse_properties(ts->input, false, &ts->core_prop);
1383 	ts->pressure_max = input_abs_get_max(input_dev, ABS_PRESSURE) ? : ~0;
1384 
1385 	/*
1386 	 * Check if legacy ti,swap-xy binding is used instead of
1387 	 * touchscreen-swapped-x-y
1388 	 */
1389 	if (!ts->core_prop.swap_x_y && pdata->swap_xy) {
1390 		swap(input_dev->absinfo[ABS_X], input_dev->absinfo[ABS_Y]);
1391 		ts->core_prop.swap_x_y = true;
1392 	}
1393 
1394 	ads7846_setup_spi_msg(ts, pdata);
1395 
1396 	ts->reg = regulator_get(&spi->dev, "vcc");
1397 	if (IS_ERR(ts->reg)) {
1398 		err = PTR_ERR(ts->reg);
1399 		dev_err(&spi->dev, "unable to get regulator: %d\n", err);
1400 		goto err_free_gpio;
1401 	}
1402 
1403 	err = regulator_enable(ts->reg);
1404 	if (err) {
1405 		dev_err(&spi->dev, "unable to enable regulator: %d\n", err);
1406 		goto err_put_regulator;
1407 	}
1408 
1409 	irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
1410 	irq_flags |= IRQF_ONESHOT;
1411 
1412 	err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq,
1413 				   irq_flags, spi->dev.driver->name, ts);
1414 	if (err && !pdata->irq_flags) {
1415 		dev_info(&spi->dev,
1416 			"trying pin change workaround on irq %d\n", spi->irq);
1417 		irq_flags |= IRQF_TRIGGER_RISING;
1418 		err = request_threaded_irq(spi->irq,
1419 				  ads7846_hard_irq, ads7846_irq,
1420 				  irq_flags, spi->dev.driver->name, ts);
1421 	}
1422 
1423 	if (err) {
1424 		dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
1425 		goto err_disable_regulator;
1426 	}
1427 
1428 	err = ads784x_hwmon_register(spi, ts);
1429 	if (err)
1430 		goto err_free_irq;
1431 
1432 	dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
1433 
1434 	/*
1435 	 * Take a first sample, leaving nPENIRQ active and vREF off; avoid
1436 	 * the touchscreen, in case it's not connected.
1437 	 */
1438 	if (ts->model == 7845)
1439 		ads7845_read12_ser(&spi->dev, PWRDOWN);
1440 	else
1441 		(void) ads7846_read12_ser(&spi->dev, READ_12BIT_SER(vaux));
1442 
1443 	err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
1444 	if (err)
1445 		goto err_remove_hwmon;
1446 
1447 	err = input_register_device(input_dev);
1448 	if (err)
1449 		goto err_remove_attr_group;
1450 
1451 	device_init_wakeup(&spi->dev, pdata->wakeup);
1452 
1453 	/*
1454 	 * If device does not carry platform data we must have allocated it
1455 	 * when parsing DT data.
1456 	 */
1457 	if (!dev_get_platdata(&spi->dev))
1458 		devm_kfree(&spi->dev, (void *)pdata);
1459 
1460 	return 0;
1461 
1462  err_remove_attr_group:
1463 	sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1464  err_remove_hwmon:
1465 	ads784x_hwmon_unregister(spi, ts);
1466  err_free_irq:
1467 	free_irq(spi->irq, ts);
1468  err_disable_regulator:
1469 	regulator_disable(ts->reg);
1470  err_put_regulator:
1471 	regulator_put(ts->reg);
1472  err_free_gpio:
1473 	if (!ts->get_pendown_state)
1474 		gpio_free(ts->gpio_pendown);
1475  err_cleanup_filter:
1476 	if (ts->filter_cleanup)
1477 		ts->filter_cleanup(ts->filter_data);
1478  err_free_mem:
1479 	input_free_device(input_dev);
1480 	kfree(packet);
1481 	kfree(ts);
1482 	return err;
1483 }
1484 
1485 static int ads7846_remove(struct spi_device *spi)
1486 {
1487 	struct ads7846 *ts = spi_get_drvdata(spi);
1488 
1489 	sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1490 
1491 	ads7846_disable(ts);
1492 	free_irq(ts->spi->irq, ts);
1493 
1494 	input_unregister_device(ts->input);
1495 
1496 	ads784x_hwmon_unregister(spi, ts);
1497 
1498 	regulator_put(ts->reg);
1499 
1500 	if (!ts->get_pendown_state) {
1501 		/*
1502 		 * If we are not using specialized pendown method we must
1503 		 * have been relying on gpio we set up ourselves.
1504 		 */
1505 		gpio_free(ts->gpio_pendown);
1506 	}
1507 
1508 	if (ts->filter_cleanup)
1509 		ts->filter_cleanup(ts->filter_data);
1510 
1511 	kfree(ts->packet);
1512 	kfree(ts);
1513 
1514 	dev_dbg(&spi->dev, "unregistered touchscreen\n");
1515 
1516 	return 0;
1517 }
1518 
1519 static struct spi_driver ads7846_driver = {
1520 	.driver = {
1521 		.name	= "ads7846",
1522 		.pm	= &ads7846_pm,
1523 		.of_match_table = of_match_ptr(ads7846_dt_ids),
1524 	},
1525 	.probe		= ads7846_probe,
1526 	.remove		= ads7846_remove,
1527 };
1528 
1529 module_spi_driver(ads7846_driver);
1530 
1531 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1532 MODULE_LICENSE("GPL");
1533 MODULE_ALIAS("spi:ads7846");
1534