1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2006-2008 Michael Hennerich, Analog Devices Inc.
4  *
5  * Description:	AD7877 based touchscreen, sensor (ADCs), DAC and GPIO driver
6  * Based on:	ads7846.c
7  *
8  * Bugs:        Enter bugs at http://blackfin.uclinux.org/
9  *
10  * History:
11  * Copyright (c) 2005 David Brownell
12  * Copyright (c) 2006 Nokia Corporation
13  * Various changes: Imre Deak <imre.deak@nokia.com>
14  *
15  * Using code from:
16  *  - corgi_ts.c
17  *	Copyright (C) 2004-2005 Richard Purdie
18  *  - omap_ts.[hc], ads7846.h, ts_osk.c
19  *	Copyright (C) 2002 MontaVista Software
20  *	Copyright (C) 2004 Texas Instruments
21  *	Copyright (C) 2005 Dirk Behme
22  */
23 
24 
25 #include <linux/device.h>
26 #include <linux/delay.h>
27 #include <linux/input.h>
28 #include <linux/interrupt.h>
29 #include <linux/pm.h>
30 #include <linux/slab.h>
31 #include <linux/spi/spi.h>
32 #include <linux/spi/ad7877.h>
33 #include <linux/module.h>
34 #include <asm/irq.h>
35 
36 #define	TS_PEN_UP_TIMEOUT	msecs_to_jiffies(100)
37 
38 #define MAX_SPI_FREQ_HZ			20000000
39 #define	MAX_12BIT			((1<<12)-1)
40 
41 #define AD7877_REG_ZEROS			0
42 #define AD7877_REG_CTRL1			1
43 #define AD7877_REG_CTRL2			2
44 #define AD7877_REG_ALERT			3
45 #define AD7877_REG_AUX1HIGH			4
46 #define AD7877_REG_AUX1LOW			5
47 #define AD7877_REG_BAT1HIGH			6
48 #define AD7877_REG_BAT1LOW			7
49 #define AD7877_REG_BAT2HIGH			8
50 #define AD7877_REG_BAT2LOW			9
51 #define AD7877_REG_TEMP1HIGH			10
52 #define AD7877_REG_TEMP1LOW			11
53 #define AD7877_REG_SEQ0				12
54 #define AD7877_REG_SEQ1				13
55 #define AD7877_REG_DAC				14
56 #define AD7877_REG_NONE1			15
57 #define AD7877_REG_EXTWRITE			15
58 #define AD7877_REG_XPLUS			16
59 #define AD7877_REG_YPLUS			17
60 #define AD7877_REG_Z2				18
61 #define AD7877_REG_aux1				19
62 #define AD7877_REG_aux2				20
63 #define AD7877_REG_aux3				21
64 #define AD7877_REG_bat1				22
65 #define AD7877_REG_bat2				23
66 #define AD7877_REG_temp1			24
67 #define AD7877_REG_temp2			25
68 #define AD7877_REG_Z1				26
69 #define AD7877_REG_GPIOCTRL1			27
70 #define AD7877_REG_GPIOCTRL2			28
71 #define AD7877_REG_GPIODATA			29
72 #define AD7877_REG_NONE2			30
73 #define AD7877_REG_NONE3			31
74 
75 #define AD7877_SEQ_YPLUS_BIT			(1<<11)
76 #define AD7877_SEQ_XPLUS_BIT			(1<<10)
77 #define AD7877_SEQ_Z2_BIT			(1<<9)
78 #define AD7877_SEQ_AUX1_BIT			(1<<8)
79 #define AD7877_SEQ_AUX2_BIT			(1<<7)
80 #define AD7877_SEQ_AUX3_BIT			(1<<6)
81 #define AD7877_SEQ_BAT1_BIT			(1<<5)
82 #define AD7877_SEQ_BAT2_BIT			(1<<4)
83 #define AD7877_SEQ_TEMP1_BIT			(1<<3)
84 #define AD7877_SEQ_TEMP2_BIT			(1<<2)
85 #define AD7877_SEQ_Z1_BIT			(1<<1)
86 
87 enum {
88 	AD7877_SEQ_YPOS  = 0,
89 	AD7877_SEQ_XPOS  = 1,
90 	AD7877_SEQ_Z2    = 2,
91 	AD7877_SEQ_AUX1  = 3,
92 	AD7877_SEQ_AUX2  = 4,
93 	AD7877_SEQ_AUX3  = 5,
94 	AD7877_SEQ_BAT1  = 6,
95 	AD7877_SEQ_BAT2  = 7,
96 	AD7877_SEQ_TEMP1 = 8,
97 	AD7877_SEQ_TEMP2 = 9,
98 	AD7877_SEQ_Z1    = 10,
99 	AD7877_NR_SENSE  = 11,
100 };
101 
102 /* DAC Register Default RANGE 0 to Vcc, Volatge Mode, DAC On */
103 #define AD7877_DAC_CONF			0x1
104 
105 /* If gpio3 is set AUX3/GPIO3 acts as GPIO Output */
106 #define AD7877_EXTW_GPIO_3_CONF		0x1C4
107 #define AD7877_EXTW_GPIO_DATA		0x200
108 
109 /* Control REG 2 */
110 #define AD7877_TMR(x)			((x & 0x3) << 0)
111 #define AD7877_REF(x)			((x & 0x1) << 2)
112 #define AD7877_POL(x)			((x & 0x1) << 3)
113 #define AD7877_FCD(x)			((x & 0x3) << 4)
114 #define AD7877_PM(x)			((x & 0x3) << 6)
115 #define AD7877_ACQ(x)			((x & 0x3) << 8)
116 #define AD7877_AVG(x)			((x & 0x3) << 10)
117 
118 /* Control REG 1 */
119 #define	AD7877_SER			(1 << 11)	/* non-differential */
120 #define	AD7877_DFR			(0 << 11)	/* differential */
121 
122 #define AD7877_MODE_NOC  (0)	/* Do not convert */
123 #define AD7877_MODE_SCC  (1)	/* Single channel conversion */
124 #define AD7877_MODE_SEQ0 (2)	/* Sequence 0 in Slave Mode */
125 #define AD7877_MODE_SEQ1 (3)	/* Sequence 1 in Master Mode */
126 
127 #define AD7877_CHANADD(x)		((x&0xF)<<7)
128 #define AD7877_READADD(x)		((x)<<2)
129 #define AD7877_WRITEADD(x)		((x)<<12)
130 
131 #define AD7877_READ_CHAN(x) (AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_SER | \
132 		AD7877_MODE_SCC | AD7877_CHANADD(AD7877_REG_ ## x) | \
133 		AD7877_READADD(AD7877_REG_ ## x))
134 
135 #define AD7877_MM_SEQUENCE (AD7877_SEQ_YPLUS_BIT | AD7877_SEQ_XPLUS_BIT | \
136 		AD7877_SEQ_Z2_BIT | AD7877_SEQ_Z1_BIT)
137 
138 /*
139  * Non-touchscreen sensors only use single-ended conversions.
140  */
141 
142 struct ser_req {
143 	u16			reset;
144 	u16			ref_on;
145 	u16			command;
146 	struct spi_message	msg;
147 	struct spi_transfer	xfer[6];
148 
149 	/*
150 	 * DMA (thus cache coherency maintenance) requires the
151 	 * transfer buffers to live in their own cache lines.
152 	 */
153 	u16 sample ____cacheline_aligned;
154 };
155 
156 struct ad7877 {
157 	struct input_dev	*input;
158 	char			phys[32];
159 
160 	struct spi_device	*spi;
161 	u16			model;
162 	u16			vref_delay_usecs;
163 	u16			x_plate_ohms;
164 	u16			pressure_max;
165 
166 	u16			cmd_crtl1;
167 	u16			cmd_crtl2;
168 	u16			cmd_dummy;
169 	u16			dac;
170 
171 	u8			stopacq_polarity;
172 	u8			first_conversion_delay;
173 	u8			acquisition_time;
174 	u8			averaging;
175 	u8			pen_down_acc_interval;
176 
177 	struct spi_transfer	xfer[AD7877_NR_SENSE + 2];
178 	struct spi_message	msg;
179 
180 	struct mutex		mutex;
181 	bool			disabled;	/* P: mutex */
182 	bool			gpio3;		/* P: mutex */
183 	bool			gpio4;		/* P: mutex */
184 
185 	spinlock_t		lock;
186 	struct timer_list	timer;		/* P: lock */
187 
188 	/*
189 	 * DMA (thus cache coherency maintenance) requires the
190 	 * transfer buffers to live in their own cache lines.
191 	 */
192 	u16 conversion_data[AD7877_NR_SENSE] ____cacheline_aligned;
193 };
194 
195 static bool gpio3;
196 module_param(gpio3, bool, 0);
197 MODULE_PARM_DESC(gpio3, "If gpio3 is set to 1 AUX3 acts as GPIO3");
198 
199 static int ad7877_read(struct spi_device *spi, u16 reg)
200 {
201 	struct ser_req *req;
202 	int status, ret;
203 
204 	req = kzalloc(sizeof *req, GFP_KERNEL);
205 	if (!req)
206 		return -ENOMEM;
207 
208 	spi_message_init(&req->msg);
209 
210 	req->command = (u16) (AD7877_WRITEADD(AD7877_REG_CTRL1) |
211 			AD7877_READADD(reg));
212 	req->xfer[0].tx_buf = &req->command;
213 	req->xfer[0].len = 2;
214 	req->xfer[0].cs_change = 1;
215 
216 	req->xfer[1].rx_buf = &req->sample;
217 	req->xfer[1].len = 2;
218 
219 	spi_message_add_tail(&req->xfer[0], &req->msg);
220 	spi_message_add_tail(&req->xfer[1], &req->msg);
221 
222 	status = spi_sync(spi, &req->msg);
223 	ret = status ? : req->sample;
224 
225 	kfree(req);
226 
227 	return ret;
228 }
229 
230 static int ad7877_write(struct spi_device *spi, u16 reg, u16 val)
231 {
232 	struct ser_req *req;
233 	int status;
234 
235 	req = kzalloc(sizeof *req, GFP_KERNEL);
236 	if (!req)
237 		return -ENOMEM;
238 
239 	spi_message_init(&req->msg);
240 
241 	req->command = (u16) (AD7877_WRITEADD(reg) | (val & MAX_12BIT));
242 	req->xfer[0].tx_buf = &req->command;
243 	req->xfer[0].len = 2;
244 
245 	spi_message_add_tail(&req->xfer[0], &req->msg);
246 
247 	status = spi_sync(spi, &req->msg);
248 
249 	kfree(req);
250 
251 	return status;
252 }
253 
254 static int ad7877_read_adc(struct spi_device *spi, unsigned command)
255 {
256 	struct ad7877 *ts = spi_get_drvdata(spi);
257 	struct ser_req *req;
258 	int status;
259 	int sample;
260 	int i;
261 
262 	req = kzalloc(sizeof *req, GFP_KERNEL);
263 	if (!req)
264 		return -ENOMEM;
265 
266 	spi_message_init(&req->msg);
267 
268 	/* activate reference, so it has time to settle; */
269 	req->ref_on = AD7877_WRITEADD(AD7877_REG_CTRL2) |
270 			 AD7877_POL(ts->stopacq_polarity) |
271 			 AD7877_AVG(0) | AD7877_PM(2) | AD7877_TMR(0) |
272 			 AD7877_ACQ(ts->acquisition_time) | AD7877_FCD(0);
273 
274 	req->reset = AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_MODE_NOC;
275 
276 	req->command = (u16) command;
277 
278 	req->xfer[0].tx_buf = &req->reset;
279 	req->xfer[0].len = 2;
280 	req->xfer[0].cs_change = 1;
281 
282 	req->xfer[1].tx_buf = &req->ref_on;
283 	req->xfer[1].len = 2;
284 	req->xfer[1].delay.value = ts->vref_delay_usecs;
285 	req->xfer[1].delay.unit = SPI_DELAY_UNIT_USECS;
286 	req->xfer[1].cs_change = 1;
287 
288 	req->xfer[2].tx_buf = &req->command;
289 	req->xfer[2].len = 2;
290 	req->xfer[2].delay.value = ts->vref_delay_usecs;
291 	req->xfer[2].delay.unit = SPI_DELAY_UNIT_USECS;
292 	req->xfer[2].cs_change = 1;
293 
294 	req->xfer[3].rx_buf = &req->sample;
295 	req->xfer[3].len = 2;
296 	req->xfer[3].cs_change = 1;
297 
298 	req->xfer[4].tx_buf = &ts->cmd_crtl2;	/*REF OFF*/
299 	req->xfer[4].len = 2;
300 	req->xfer[4].cs_change = 1;
301 
302 	req->xfer[5].tx_buf = &ts->cmd_crtl1;	/*DEFAULT*/
303 	req->xfer[5].len = 2;
304 
305 	/* group all the transfers together, so we can't interfere with
306 	 * reading touchscreen state; disable penirq while sampling
307 	 */
308 	for (i = 0; i < 6; i++)
309 		spi_message_add_tail(&req->xfer[i], &req->msg);
310 
311 	status = spi_sync(spi, &req->msg);
312 	sample = req->sample;
313 
314 	kfree(req);
315 
316 	return status ? : sample;
317 }
318 
319 static int ad7877_process_data(struct ad7877 *ts)
320 {
321 	struct input_dev *input_dev = ts->input;
322 	unsigned Rt;
323 	u16 x, y, z1, z2;
324 
325 	x = ts->conversion_data[AD7877_SEQ_XPOS] & MAX_12BIT;
326 	y = ts->conversion_data[AD7877_SEQ_YPOS] & MAX_12BIT;
327 	z1 = ts->conversion_data[AD7877_SEQ_Z1] & MAX_12BIT;
328 	z2 = ts->conversion_data[AD7877_SEQ_Z2] & MAX_12BIT;
329 
330 	/*
331 	 * The samples processed here are already preprocessed by the AD7877.
332 	 * The preprocessing function consists of an averaging filter.
333 	 * The combination of 'first conversion delay' and averaging provides a robust solution,
334 	 * discarding the spurious noise in the signal and keeping only the data of interest.
335 	 * The size of the averaging filter is programmable. (dev.platform_data, see linux/spi/ad7877.h)
336 	 * Other user-programmable conversion controls include variable acquisition time,
337 	 * and first conversion delay. Up to 16 averages can be taken per conversion.
338 	 */
339 
340 	if (likely(x && z1)) {
341 		/* compute touch pressure resistance using equation #1 */
342 		Rt = (z2 - z1) * x * ts->x_plate_ohms;
343 		Rt /= z1;
344 		Rt = (Rt + 2047) >> 12;
345 
346 		/*
347 		 * Sample found inconsistent, pressure is beyond
348 		 * the maximum. Don't report it to user space.
349 		 */
350 		if (Rt > ts->pressure_max)
351 			return -EINVAL;
352 
353 		if (!timer_pending(&ts->timer))
354 			input_report_key(input_dev, BTN_TOUCH, 1);
355 
356 		input_report_abs(input_dev, ABS_X, x);
357 		input_report_abs(input_dev, ABS_Y, y);
358 		input_report_abs(input_dev, ABS_PRESSURE, Rt);
359 		input_sync(input_dev);
360 
361 		return 0;
362 	}
363 
364 	return -EINVAL;
365 }
366 
367 static inline void ad7877_ts_event_release(struct ad7877 *ts)
368 {
369 	struct input_dev *input_dev = ts->input;
370 
371 	input_report_abs(input_dev, ABS_PRESSURE, 0);
372 	input_report_key(input_dev, BTN_TOUCH, 0);
373 	input_sync(input_dev);
374 }
375 
376 static void ad7877_timer(struct timer_list *t)
377 {
378 	struct ad7877 *ts = from_timer(ts, t, timer);
379 	unsigned long flags;
380 
381 	spin_lock_irqsave(&ts->lock, flags);
382 	ad7877_ts_event_release(ts);
383 	spin_unlock_irqrestore(&ts->lock, flags);
384 }
385 
386 static irqreturn_t ad7877_irq(int irq, void *handle)
387 {
388 	struct ad7877 *ts = handle;
389 	unsigned long flags;
390 	int error;
391 
392 	error = spi_sync(ts->spi, &ts->msg);
393 	if (error) {
394 		dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
395 		goto out;
396 	}
397 
398 	spin_lock_irqsave(&ts->lock, flags);
399 	error = ad7877_process_data(ts);
400 	if (!error)
401 		mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
402 	spin_unlock_irqrestore(&ts->lock, flags);
403 
404 out:
405 	return IRQ_HANDLED;
406 }
407 
408 static void ad7877_disable(void *data)
409 {
410 	struct ad7877 *ts = data;
411 
412 	mutex_lock(&ts->mutex);
413 
414 	if (!ts->disabled) {
415 		ts->disabled = true;
416 		disable_irq(ts->spi->irq);
417 
418 		if (del_timer_sync(&ts->timer))
419 			ad7877_ts_event_release(ts);
420 	}
421 
422 	/*
423 	 * We know the chip's in lowpower mode since we always
424 	 * leave it that way after every request
425 	 */
426 
427 	mutex_unlock(&ts->mutex);
428 }
429 
430 static void ad7877_enable(struct ad7877 *ts)
431 {
432 	mutex_lock(&ts->mutex);
433 
434 	if (ts->disabled) {
435 		ts->disabled = false;
436 		enable_irq(ts->spi->irq);
437 	}
438 
439 	mutex_unlock(&ts->mutex);
440 }
441 
442 #define SHOW(name) static ssize_t \
443 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
444 { \
445 	struct ad7877 *ts = dev_get_drvdata(dev); \
446 	ssize_t v = ad7877_read_adc(ts->spi, \
447 			AD7877_READ_CHAN(name)); \
448 	if (v < 0) \
449 		return v; \
450 	return sprintf(buf, "%u\n", (unsigned) v); \
451 } \
452 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
453 
454 SHOW(aux1)
455 SHOW(aux2)
456 SHOW(aux3)
457 SHOW(bat1)
458 SHOW(bat2)
459 SHOW(temp1)
460 SHOW(temp2)
461 
462 static ssize_t ad7877_disable_show(struct device *dev,
463 				     struct device_attribute *attr, char *buf)
464 {
465 	struct ad7877 *ts = dev_get_drvdata(dev);
466 
467 	return sprintf(buf, "%u\n", ts->disabled);
468 }
469 
470 static ssize_t ad7877_disable_store(struct device *dev,
471 				     struct device_attribute *attr,
472 				     const char *buf, size_t count)
473 {
474 	struct ad7877 *ts = dev_get_drvdata(dev);
475 	unsigned int val;
476 	int error;
477 
478 	error = kstrtouint(buf, 10, &val);
479 	if (error)
480 		return error;
481 
482 	if (val)
483 		ad7877_disable(ts);
484 	else
485 		ad7877_enable(ts);
486 
487 	return count;
488 }
489 
490 static DEVICE_ATTR(disable, 0664, ad7877_disable_show, ad7877_disable_store);
491 
492 static ssize_t ad7877_dac_show(struct device *dev,
493 				     struct device_attribute *attr, char *buf)
494 {
495 	struct ad7877 *ts = dev_get_drvdata(dev);
496 
497 	return sprintf(buf, "%u\n", ts->dac);
498 }
499 
500 static ssize_t ad7877_dac_store(struct device *dev,
501 				     struct device_attribute *attr,
502 				     const char *buf, size_t count)
503 {
504 	struct ad7877 *ts = dev_get_drvdata(dev);
505 	unsigned int val;
506 	int error;
507 
508 	error = kstrtouint(buf, 10, &val);
509 	if (error)
510 		return error;
511 
512 	mutex_lock(&ts->mutex);
513 	ts->dac = val & 0xFF;
514 	ad7877_write(ts->spi, AD7877_REG_DAC, (ts->dac << 4) | AD7877_DAC_CONF);
515 	mutex_unlock(&ts->mutex);
516 
517 	return count;
518 }
519 
520 static DEVICE_ATTR(dac, 0664, ad7877_dac_show, ad7877_dac_store);
521 
522 static ssize_t ad7877_gpio3_show(struct device *dev,
523 				     struct device_attribute *attr, char *buf)
524 {
525 	struct ad7877 *ts = dev_get_drvdata(dev);
526 
527 	return sprintf(buf, "%u\n", ts->gpio3);
528 }
529 
530 static ssize_t ad7877_gpio3_store(struct device *dev,
531 				     struct device_attribute *attr,
532 				     const char *buf, size_t count)
533 {
534 	struct ad7877 *ts = dev_get_drvdata(dev);
535 	unsigned int val;
536 	int error;
537 
538 	error = kstrtouint(buf, 10, &val);
539 	if (error)
540 		return error;
541 
542 	mutex_lock(&ts->mutex);
543 	ts->gpio3 = !!val;
544 	ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA |
545 		 (ts->gpio4 << 4) | (ts->gpio3 << 5));
546 	mutex_unlock(&ts->mutex);
547 
548 	return count;
549 }
550 
551 static DEVICE_ATTR(gpio3, 0664, ad7877_gpio3_show, ad7877_gpio3_store);
552 
553 static ssize_t ad7877_gpio4_show(struct device *dev,
554 				     struct device_attribute *attr, char *buf)
555 {
556 	struct ad7877 *ts = dev_get_drvdata(dev);
557 
558 	return sprintf(buf, "%u\n", ts->gpio4);
559 }
560 
561 static ssize_t ad7877_gpio4_store(struct device *dev,
562 				     struct device_attribute *attr,
563 				     const char *buf, size_t count)
564 {
565 	struct ad7877 *ts = dev_get_drvdata(dev);
566 	unsigned int val;
567 	int error;
568 
569 	error = kstrtouint(buf, 10, &val);
570 	if (error)
571 		return error;
572 
573 	mutex_lock(&ts->mutex);
574 	ts->gpio4 = !!val;
575 	ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA |
576 		     (ts->gpio4 << 4) | (ts->gpio3 << 5));
577 	mutex_unlock(&ts->mutex);
578 
579 	return count;
580 }
581 
582 static DEVICE_ATTR(gpio4, 0664, ad7877_gpio4_show, ad7877_gpio4_store);
583 
584 static struct attribute *ad7877_attributes[] = {
585 	&dev_attr_temp1.attr,
586 	&dev_attr_temp2.attr,
587 	&dev_attr_aux1.attr,
588 	&dev_attr_aux2.attr,
589 	&dev_attr_aux3.attr,
590 	&dev_attr_bat1.attr,
591 	&dev_attr_bat2.attr,
592 	&dev_attr_disable.attr,
593 	&dev_attr_dac.attr,
594 	&dev_attr_gpio3.attr,
595 	&dev_attr_gpio4.attr,
596 	NULL
597 };
598 
599 static umode_t ad7877_attr_is_visible(struct kobject *kobj,
600 				     struct attribute *attr, int n)
601 {
602 	umode_t mode = attr->mode;
603 
604 	if (attr == &dev_attr_aux3.attr) {
605 		if (gpio3)
606 			mode = 0;
607 	} else if (attr == &dev_attr_gpio3.attr) {
608 		if (!gpio3)
609 			mode = 0;
610 	}
611 
612 	return mode;
613 }
614 
615 static const struct attribute_group ad7877_attr_group = {
616 	.is_visible	= ad7877_attr_is_visible,
617 	.attrs		= ad7877_attributes,
618 };
619 
620 static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts)
621 {
622 	struct spi_message *m;
623 	int i;
624 
625 	ts->cmd_crtl2 = AD7877_WRITEADD(AD7877_REG_CTRL2) |
626 			AD7877_POL(ts->stopacq_polarity) |
627 			AD7877_AVG(ts->averaging) | AD7877_PM(1) |
628 			AD7877_TMR(ts->pen_down_acc_interval) |
629 			AD7877_ACQ(ts->acquisition_time) |
630 			AD7877_FCD(ts->first_conversion_delay);
631 
632 	ad7877_write(spi, AD7877_REG_CTRL2, ts->cmd_crtl2);
633 
634 	ts->cmd_crtl1 = AD7877_WRITEADD(AD7877_REG_CTRL1) |
635 			AD7877_READADD(AD7877_REG_XPLUS-1) |
636 			AD7877_MODE_SEQ1 | AD7877_DFR;
637 
638 	ad7877_write(spi, AD7877_REG_CTRL1, ts->cmd_crtl1);
639 
640 	ts->cmd_dummy = 0;
641 
642 	m = &ts->msg;
643 
644 	spi_message_init(m);
645 
646 	m->context = ts;
647 
648 	ts->xfer[0].tx_buf = &ts->cmd_crtl1;
649 	ts->xfer[0].len = 2;
650 	ts->xfer[0].cs_change = 1;
651 
652 	spi_message_add_tail(&ts->xfer[0], m);
653 
654 	ts->xfer[1].tx_buf = &ts->cmd_dummy; /* Send ZERO */
655 	ts->xfer[1].len = 2;
656 	ts->xfer[1].cs_change = 1;
657 
658 	spi_message_add_tail(&ts->xfer[1], m);
659 
660 	for (i = 0; i < AD7877_NR_SENSE; i++) {
661 		ts->xfer[i + 2].rx_buf = &ts->conversion_data[AD7877_SEQ_YPOS + i];
662 		ts->xfer[i + 2].len = 2;
663 		if (i < (AD7877_NR_SENSE - 1))
664 			ts->xfer[i + 2].cs_change = 1;
665 		spi_message_add_tail(&ts->xfer[i + 2], m);
666 	}
667 }
668 
669 static int ad7877_probe(struct spi_device *spi)
670 {
671 	struct ad7877			*ts;
672 	struct input_dev		*input_dev;
673 	struct ad7877_platform_data	*pdata = dev_get_platdata(&spi->dev);
674 	int				err;
675 	u16				verify;
676 
677 	if (!spi->irq) {
678 		dev_dbg(&spi->dev, "no IRQ?\n");
679 		return -ENODEV;
680 	}
681 
682 	if (!pdata) {
683 		dev_dbg(&spi->dev, "no platform data?\n");
684 		return -ENODEV;
685 	}
686 
687 	/* don't exceed max specified SPI CLK frequency */
688 	if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
689 		dev_dbg(&spi->dev, "SPI CLK %d Hz?\n",spi->max_speed_hz);
690 		return -EINVAL;
691 	}
692 
693 	spi->bits_per_word = 16;
694 	err = spi_setup(spi);
695 	if (err) {
696 		dev_dbg(&spi->dev, "spi master doesn't support 16 bits/word\n");
697 		return err;
698 	}
699 
700 	ts = devm_kzalloc(&spi->dev, sizeof(struct ad7877), GFP_KERNEL);
701 	if (!ts)
702 		return -ENOMEM;
703 
704 	input_dev = devm_input_allocate_device(&spi->dev);
705 	if (!input_dev)
706 		return -ENOMEM;
707 
708 	err = devm_add_action_or_reset(&spi->dev, ad7877_disable, ts);
709 	if (err)
710 		return err;
711 
712 	spi_set_drvdata(spi, ts);
713 	ts->spi = spi;
714 	ts->input = input_dev;
715 
716 	timer_setup(&ts->timer, ad7877_timer, 0);
717 	mutex_init(&ts->mutex);
718 	spin_lock_init(&ts->lock);
719 
720 	ts->model = pdata->model ? : 7877;
721 	ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
722 	ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
723 	ts->pressure_max = pdata->pressure_max ? : ~0;
724 
725 	ts->stopacq_polarity = pdata->stopacq_polarity;
726 	ts->first_conversion_delay = pdata->first_conversion_delay;
727 	ts->acquisition_time = pdata->acquisition_time;
728 	ts->averaging = pdata->averaging;
729 	ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
730 
731 	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
732 
733 	input_dev->name = "AD7877 Touchscreen";
734 	input_dev->phys = ts->phys;
735 	input_dev->dev.parent = &spi->dev;
736 
737 	__set_bit(EV_KEY, input_dev->evbit);
738 	__set_bit(BTN_TOUCH, input_dev->keybit);
739 	__set_bit(EV_ABS, input_dev->evbit);
740 	__set_bit(ABS_X, input_dev->absbit);
741 	__set_bit(ABS_Y, input_dev->absbit);
742 	__set_bit(ABS_PRESSURE, input_dev->absbit);
743 
744 	input_set_abs_params(input_dev, ABS_X,
745 			pdata->x_min ? : 0,
746 			pdata->x_max ? : MAX_12BIT,
747 			0, 0);
748 	input_set_abs_params(input_dev, ABS_Y,
749 			pdata->y_min ? : 0,
750 			pdata->y_max ? : MAX_12BIT,
751 			0, 0);
752 	input_set_abs_params(input_dev, ABS_PRESSURE,
753 			pdata->pressure_min, pdata->pressure_max, 0, 0);
754 
755 	ad7877_write(spi, AD7877_REG_SEQ1, AD7877_MM_SEQUENCE);
756 
757 	verify = ad7877_read(spi, AD7877_REG_SEQ1);
758 
759 	if (verify != AD7877_MM_SEQUENCE) {
760 		dev_err(&spi->dev, "%s: Failed to probe %s\n",
761 			dev_name(&spi->dev), input_dev->name);
762 		return -ENODEV;
763 	}
764 
765 	if (gpio3)
766 		ad7877_write(spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_3_CONF);
767 
768 	ad7877_setup_ts_def_msg(spi, ts);
769 
770 	/* Request AD7877 /DAV GPIO interrupt */
771 
772 	err = devm_request_threaded_irq(&spi->dev, spi->irq, NULL, ad7877_irq,
773 					IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
774 					spi->dev.driver->name, ts);
775 	if (err) {
776 		dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
777 		return err;
778 	}
779 
780 	err = devm_device_add_group(&spi->dev, &ad7877_attr_group);
781 	if (err)
782 		return err;
783 
784 	err = input_register_device(input_dev);
785 	if (err)
786 		return err;
787 
788 	return 0;
789 }
790 
791 static int __maybe_unused ad7877_suspend(struct device *dev)
792 {
793 	struct ad7877 *ts = dev_get_drvdata(dev);
794 
795 	ad7877_disable(ts);
796 
797 	return 0;
798 }
799 
800 static int __maybe_unused ad7877_resume(struct device *dev)
801 {
802 	struct ad7877 *ts = dev_get_drvdata(dev);
803 
804 	ad7877_enable(ts);
805 
806 	return 0;
807 }
808 
809 static SIMPLE_DEV_PM_OPS(ad7877_pm, ad7877_suspend, ad7877_resume);
810 
811 static struct spi_driver ad7877_driver = {
812 	.driver = {
813 		.name	= "ad7877",
814 		.pm	= &ad7877_pm,
815 	},
816 	.probe		= ad7877_probe,
817 };
818 
819 module_spi_driver(ad7877_driver);
820 
821 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
822 MODULE_DESCRIPTION("AD7877 touchscreen Driver");
823 MODULE_LICENSE("GPL");
824 MODULE_ALIAS("spi:ad7877");
825