ads7846.c 27.5 KB
Newer Older
David Brownell's avatar
David Brownell committed
1 2 3 4
/*
 * ADS7846 based touchscreen and sensor driver
 *
 * Copyright (c) 2005 David Brownell
5 6
 * Copyright (c) 2006 Nokia Corporation
 * Various changes: Imre Deak <imre.deak@nokia.com>
David Brownell's avatar
David Brownell committed
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * Using code from:
 *  - corgi_ts.c
 *	Copyright (C) 2004-2005 Richard Purdie
 *  - omap_ts.[hc], ads7846.h, ts_osk.c
 *	Copyright (C) 2002 MontaVista Software
 *	Copyright (C) 2004 Texas Instruments
 *	Copyright (C) 2005 Dirk Behme
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */
20
#include <linux/hwmon.h>
David Brownell's avatar
David Brownell committed
21
#include <linux/init.h>
22
#include <linux/err.h>
David Brownell's avatar
David Brownell committed
23 24 25 26 27 28
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
29
#include <asm/irq.h>
David Brownell's avatar
David Brownell committed
30 31 32 33 34 35 36 37 38 39

#ifdef	CONFIG_ARM
#include <asm/mach-types.h>
#ifdef	CONFIG_ARCH_OMAP
#include <asm/arch/gpio.h>
#endif
#endif


/*
40 41
 * This code has been heavily tested on a Nokia 770, and lightly
 * tested on other ads7846 devices (OSK/Mistral, Lubbock).
David Brownell's avatar
David Brownell committed
42 43
 * Support for ads7843 and ads7845 has only been stubbed in.
 *
44 45 46 47 48 49
 * IRQ handling needs a workaround because of a shortcoming in handling
 * edge triggered IRQs on some platforms like the OMAP1/2. These
 * platforms don't handle the ARM lazy IRQ disabling properly, thus we
 * have to maintain our own SW IRQ disabled status. This should be
 * removed as soon as the affected platform's IRQ handling is fixed.
 *
David Brownell's avatar
David Brownell committed
50 51 52
 * app note sbaa036 talks in more detail about accurate sampling...
 * that ought to help in situations like LCDs inducing noise (which
 * can also be helped by using synch signals) and more generally.
53 54 55
 * This driver tries to utilize the measures described in the app
 * note. The strength of filtering can be set in the board-* specific
 * files.
David Brownell's avatar
David Brownell committed
56 57
 */

58 59
#define TS_POLL_DELAY	(1 * 1000000)	/* ns delay before the first sample */
#define TS_POLL_PERIOD	(5 * 1000000)	/* ns delay between samples */
David Brownell's avatar
David Brownell committed
60

61 62 63
/* this driver doesn't aim at the peak continuous sample rate */
#define	SAMPLE_BITS	(8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)

David Brownell's avatar
David Brownell committed
64 65 66
struct ts_event {
	/* For portability, we can't read 12 bit values using SPI (which
	 * would make the controller deliver them as native byteorder u16
67
	 * with msbs zeroed).  Instead, we read them as two 8-bit values,
68
	 * *** WHICH NEED BYTESWAPPING *** and range adjustment.
David Brownell's avatar
David Brownell committed
69
	 */
70 71 72
	u16	x;
	u16	y;
	u16	z1, z2;
73
	int	ignore;
David Brownell's avatar
David Brownell committed
74 75 76
};

struct ads7846 {
77
	struct input_dev	*input;
David Brownell's avatar
David Brownell committed
78 79 80
	char			phys[32];

	struct spi_device	*spi;
81 82

#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
83
	struct attribute_group	*attr_group;
84 85 86
	struct class_device	*hwmon;
#endif

David Brownell's avatar
David Brownell committed
87 88 89
	u16			model;
	u16			vref_delay_usecs;
	u16			x_plate_ohms;
90
	u16			pressure_max;
David Brownell's avatar
David Brownell committed
91

92 93
	u8			read_x, read_y, read_z1, read_z2, pwrdown;
	u16			dummy;		/* for the pwrdown read */
David Brownell's avatar
David Brownell committed
94 95
	struct ts_event		tc;

96
	struct spi_transfer	xfer[10];
97
	struct spi_message	msg[5];
98
	struct spi_message	*last_msg;
99 100
	int			msg_idx;
	int			read_cnt;
101
	int			read_rep;
102 103 104 105
	int			last_read;

	u16			debounce_max;
	u16			debounce_tol;
106
	u16			debounce_rep;
David Brownell's avatar
David Brownell committed
107 108

	spinlock_t		lock;
109
	struct hrtimer		timer;
David Brownell's avatar
David Brownell committed
110 111 112 113
	unsigned		pendown:1;	/* P: lock */
	unsigned		pending:1;	/* P: lock */
// FIXME remove "irq_disabled"
	unsigned		irq_disabled:1;	/* P: lock */
114
	unsigned		disabled:1;
115

116 117 118
	int			(*filter)(void *data, int data_idx, int *val);
	void			*filter_data;
	void			(*filter_cleanup)(void *data);
119
	int			(*get_pendown_state)(void);
David Brownell's avatar
David Brownell committed
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
};

/* leave chip selected when we're done, for quicker re-select? */
#if	0
#define	CS_CHANGE(xfer)	((xfer).cs_change = 1)
#else
#define	CS_CHANGE(xfer)	((xfer).cs_change = 0)
#endif

/*--------------------------------------------------------------------------*/

/* The ADS7846 has touchscreen and other sensors.
 * Earlier ads784x chips are somewhat compatible.
 */
#define	ADS_START		(1 << 7)
#define	ADS_A2A1A0_d_y		(1 << 4)	/* differential */
#define	ADS_A2A1A0_d_z1		(3 << 4)	/* differential */
#define	ADS_A2A1A0_d_z2		(4 << 4)	/* differential */
#define	ADS_A2A1A0_d_x		(5 << 4)	/* differential */
#define	ADS_A2A1A0_temp0	(0 << 4)	/* non-differential */
#define	ADS_A2A1A0_vbatt	(2 << 4)	/* non-differential */
#define	ADS_A2A1A0_vaux		(6 << 4)	/* non-differential */
#define	ADS_A2A1A0_temp1	(7 << 4)	/* non-differential */
#define	ADS_8_BIT		(1 << 3)
#define	ADS_12_BIT		(0 << 3)
#define	ADS_SER			(1 << 2)	/* non-differential */
#define	ADS_DFR			(0 << 2)	/* differential */
#define	ADS_PD10_PDOWN		(0 << 0)	/* lowpower mode + penirq */
#define	ADS_PD10_ADC_ON		(1 << 0)	/* ADC on */
#define	ADS_PD10_REF_ON		(2 << 0)	/* vREF on + penirq */
#define	ADS_PD10_ALL_ON		(3 << 0)	/* ADC + vREF on */

#define	MAX_12BIT	((1<<12)-1)

/* leave ADC powered up (disables penirq) between differential samples */
155 156 157
#define	READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
	| ADS_12_BIT | ADS_DFR | \
	(adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
David Brownell's avatar
David Brownell committed
158

159 160 161
#define	READ_Y(vref)	(READ_12BIT_DFR(y,  1, vref))
#define	READ_Z1(vref)	(READ_12BIT_DFR(z1, 1, vref))
#define	READ_Z2(vref)	(READ_12BIT_DFR(z2, 1, vref))
162

163 164
#define	READ_X(vref)	(READ_12BIT_DFR(x,  1, vref))
#define	PWRDOWN		(READ_12BIT_DFR(y,  0, 0))	/* LAST */
David Brownell's avatar
David Brownell committed
165 166 167 168 169 170 171

/* single-ended samples need to first power up reference voltage;
 * we leave both ADC and VREF powered
 */
#define	READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
	| ADS_12_BIT | ADS_SER)

172 173
#define	REF_ON	(READ_12BIT_DFR(x, 1, 1))
#define	REF_OFF	(READ_12BIT_DFR(y, 0, 0))
David Brownell's avatar
David Brownell committed
174 175 176 177 178

/*--------------------------------------------------------------------------*/

/*
 * Non-touchscreen sensors only use single-ended conversions.
179 180
 * The range is GND..vREF. The ads7843 and ads7835 must use external vREF;
 * ads7846 lets that pin be unconnected, to use internal vREF.
David Brownell's avatar
David Brownell committed
181
 */
182 183 184
static unsigned vREF_mV;
module_param(vREF_mV, uint, 0);
MODULE_PARM_DESC(vREF_mV, "external vREF voltage, in milliVolts");
David Brownell's avatar
David Brownell committed
185 186

struct ser_req {
187
	u8			ref_on;
David Brownell's avatar
David Brownell committed
188
	u8			command;
189
	u8			ref_off;
David Brownell's avatar
David Brownell committed
190 191 192 193 194 195
	u16			scratch;
	__be16			sample;
	struct spi_message	msg;
	struct spi_transfer	xfer[6];
};

196 197 198
static void ads7846_enable(struct ads7846 *ts);
static void ads7846_disable(struct ads7846 *ts);

199 200 201 202 203 204
static int device_suspended(struct device *dev)
{
	struct ads7846 *ts = dev_get_drvdata(dev);
	return dev->power.power_state.event != PM_EVENT_ON || ts->disabled;
}

David Brownell's avatar
David Brownell committed
205 206 207 208
static int ads7846_read12_ser(struct device *dev, unsigned command)
{
	struct spi_device	*spi = to_spi_device(dev);
	struct ads7846		*ts = dev_get_drvdata(dev);
209
	struct ser_req		*req = kzalloc(sizeof *req, GFP_KERNEL);
David Brownell's avatar
David Brownell committed
210 211
	int			status;
	int			sample;
212
	int			use_internal;
David Brownell's avatar
David Brownell committed
213 214 215 216

	if (!req)
		return -ENOMEM;

217
	spi_message_init(&req->msg);
218

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
	/* FIXME boards with ads7846 might use external vref instead ... */
	use_internal = (ts->model == 7846);

	/* maybe turn on internal vREF, and let it settle */
	if (use_internal) {
		req->ref_on = REF_ON;
		req->xfer[0].tx_buf = &req->ref_on;
		req->xfer[0].len = 1;
		spi_message_add_tail(&req->xfer[0], &req->msg);

		req->xfer[1].rx_buf = &req->scratch;
		req->xfer[1].len = 2;

		/* for 1uF, settle for 800 usec; no cap, 100 usec.  */
		req->xfer[1].delay_usecs = ts->vref_delay_usecs;
		spi_message_add_tail(&req->xfer[1], &req->msg);
	}
David Brownell's avatar
David Brownell committed
236 237 238 239 240

	/* take sample */
	req->command = (u8) command;
	req->xfer[2].tx_buf = &req->command;
	req->xfer[2].len = 1;
241 242
	spi_message_add_tail(&req->xfer[2], &req->msg);

David Brownell's avatar
David Brownell committed
243 244
	req->xfer[3].rx_buf = &req->sample;
	req->xfer[3].len = 2;
245
	spi_message_add_tail(&req->xfer[3], &req->msg);
David Brownell's avatar
David Brownell committed
246 247 248

	/* REVISIT:  take a few more samples, and compare ... */

249 250 251 252 253 254 255 256 257 258 259 260
	/* maybe off internal vREF */
	if (use_internal) {
		req->ref_off = REF_OFF;
		req->xfer[4].tx_buf = &req->ref_off;
		req->xfer[4].len = 1;
		spi_message_add_tail(&req->xfer[4], &req->msg);

		req->xfer[5].rx_buf = &req->scratch;
		req->xfer[5].len = 2;
		CS_CHANGE(req->xfer[5]);
		spi_message_add_tail(&req->xfer[5], &req->msg);
	}
David Brownell's avatar
David Brownell committed
261

262
	ts->irq_disabled = 1;
David Brownell's avatar
David Brownell committed
263 264
	disable_irq(spi->irq);
	status = spi_sync(spi, &req->msg);
265
	ts->irq_disabled = 0;
David Brownell's avatar
David Brownell committed
266 267 268 269
	enable_irq(spi->irq);

	if (req->msg.status)
		status = req->msg.status;
270 271

	/* on-wire is a must-ignore bit, a BE12 value, then padding */
David Brownell's avatar
David Brownell committed
272
	sample = be16_to_cpu(req->sample);
273 274
	sample = sample >> 3;
	sample &= 0x0fff;
David Brownell's avatar
David Brownell committed
275

276
	kfree(req);
David Brownell's avatar
David Brownell committed
277 278 279
	return status ? status : sample;
}

280 281 282
#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)

#define SHOW(name, var, adjust) static ssize_t \
David Brownell's avatar
David Brownell committed
283 284
name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
{ \
285
	struct ads7846 *ts = dev_get_drvdata(dev); \
David Brownell's avatar
David Brownell committed
286
	ssize_t v = ads7846_read12_ser(dev, \
287
			READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \
David Brownell's avatar
David Brownell committed
288 289
	if (v < 0) \
		return v; \
290
	return sprintf(buf, "%u\n", adjust(ts, v)); \
David Brownell's avatar
David Brownell committed
291 292 293
} \
static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);

294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442

/* Sysfs conventions report temperatures in millidegrees Celcius.
 * ADS7846 could use the low-accuracy two-sample scheme, but can't do the high
 * accuracy scheme without calibration data.  For now we won't try either;
 * userspace sees raw sensor values, and must scale/calibrate appropriately.
 */
static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
{
	return v;
}

SHOW(temp0, temp0, null_adjust)		/* temp1_input */
SHOW(temp1, temp1, null_adjust)		/* temp2_input */


/* sysfs conventions report voltages in millivolts.  We can convert voltages
 * if we know vREF.  userspace may need to scale vAUX to match the board's
 * external resistors; we assume that vBATT only uses the internal ones.
 */
static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
{
	unsigned retval = v;

	/* external resistors may scale vAUX into 0..vREF */
	retval *= vREF_mV;
	retval = retval >> 12;
	return retval;
}

static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
{
	unsigned retval = vaux_adjust(ts, v);

	/* ads7846 has a resistor ladder to scale this signal down */
	if (ts->model == 7846)
		retval *= 4;
	return retval;
}

SHOW(in0_input, vaux, vaux_adjust)
SHOW(in1_input, vbatt, vbatt_adjust)


static struct attribute *ads7846_attributes[] = {
	&dev_attr_temp0.attr,
	&dev_attr_temp1.attr,
	&dev_attr_in0_input.attr,
	&dev_attr_in1_input.attr,
	NULL,
};

static struct attribute_group ads7846_attr_group = {
	.attrs = ads7846_attributes,
};

static struct attribute *ads7843_attributes[] = {
	&dev_attr_in0_input.attr,
	&dev_attr_in1_input.attr,
	NULL,
};

static struct attribute_group ads7843_attr_group = {
	.attrs = ads7843_attributes,
};

static struct attribute *ads7845_attributes[] = {
	&dev_attr_in0_input.attr,
	NULL,
};

static struct attribute_group ads7845_attr_group = {
	.attrs = ads7845_attributes,
};

static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
{
	struct class_device *hwmon;
	int err;

	/* hwmon sensors need a reference voltage */
	switch (ts->model) {
	case 7846:
		if (!vREF_mV) {
			dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
			vREF_mV = 2500;
		}
		break;
	case 7845:
	case 7843:
		if (!vREF_mV) {
			dev_warn(&spi->dev,
				"external vREF for ADS%d not specified\n",
				ts->model);
			return 0;
		}
		break;
	}

	/* different chips have different sensor groups */
	switch (ts->model) {
	case 7846:
		ts->attr_group = &ads7846_attr_group;
		break;
	case 7845:
		ts->attr_group = &ads7845_attr_group;
		break;
	case 7843:
		ts->attr_group = &ads7843_attr_group;
		break;
	default:
		dev_dbg(&spi->dev, "ADS%d not recognized\n", ts->model);
		return 0;
	}

	err = sysfs_create_group(&spi->dev.kobj, ts->attr_group);
	if (err)
		return err;

	hwmon = hwmon_device_register(&spi->dev);
	if (IS_ERR(hwmon)) {
		sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
		return PTR_ERR(hwmon);
	}

	ts->hwmon = hwmon;
	return 0;
}

static void ads784x_hwmon_unregister(struct spi_device *spi,
				     struct ads7846 *ts)
{
	if (ts->hwmon) {
		sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
		hwmon_device_unregister(ts->hwmon);
	}
}

#else
static inline int ads784x_hwmon_register(struct spi_device *spi,
					 struct ads7846 *ts)
{
	return 0;
}

static inline void ads784x_hwmon_unregister(struct spi_device *spi,
					    struct ads7846 *ts)
{
}
#endif
David Brownell's avatar
David Brownell committed
443

444 445
static int is_pen_down(struct device *dev)
{
446
	struct ads7846	*ts = dev_get_drvdata(dev);
447 448 449 450 451 452 453 454 455 456 457 458

	return ts->pendown;
}

static ssize_t ads7846_pen_down_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%u\n", is_pen_down(dev));
}

static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);

459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
static ssize_t ads7846_disable_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct ads7846	*ts = dev_get_drvdata(dev);

	return sprintf(buf, "%u\n", ts->disabled);
}

static ssize_t ads7846_disable_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct ads7846 *ts = dev_get_drvdata(dev);
	char *endp;
	int i;

	i = simple_strtoul(buf, &endp, 10);
	spin_lock_irq(&ts->lock);

	if (i)
		ads7846_disable(ts);
	else
		ads7846_enable(ts);

	spin_unlock_irq(&ts->lock);

	return count;
}

static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);

490
static struct attribute *ads784x_attributes[] = {
491 492 493 494 495
	&dev_attr_pen_down.attr,
	&dev_attr_disable.attr,
	NULL,
};

496 497
static struct attribute_group ads784x_attr_group = {
	.attrs = ads784x_attributes,
498 499
};

David Brownell's avatar
David Brownell committed
500 501 502 503 504 505 506 507 508 509 510 511
/*--------------------------------------------------------------------------*/

/*
 * PENIRQ only kicks the timer.  The timer only reissues the SPI transfer,
 * to retrieve touchscreen status.
 *
 * The SPI transfer completion callback does the real work.  It reports
 * touchscreen events and reactivates the timer (or IRQ) as appropriate.
 */

static void ads7846_rx(void *ads)
{
512 513 514
	struct ads7846		*ts = ads;
	unsigned		Rt;
	u16			x, y, z1, z2;
David Brownell's avatar
David Brownell committed
515

516 517
	/* ads7846_rx_val() did in-place conversion (including byteswap) from
	 * on-the-wire format as part of debouncing to get stable readings.
David Brownell's avatar
David Brownell committed
518
	 */
519 520 521 522
	x = ts->tc.x;
	y = ts->tc.y;
	z1 = ts->tc.z1;
	z2 = ts->tc.z2;
David Brownell's avatar
David Brownell committed
523 524 525 526 527

	/* range filtering */
	if (x == MAX_12BIT)
		x = 0;

528
	if (likely(x && z1)) {
David Brownell's avatar
David Brownell committed
529 530 531 532 533 534 535 536 537 538
		/* compute touch pressure resistance using equation #2 */
		Rt = z2;
		Rt -= z1;
		Rt *= x;
		Rt *= ts->x_plate_ohms;
		Rt /= z1;
		Rt = (Rt + 2047) >> 12;
	} else
		Rt = 0;

539
	/* Sample found inconsistent by debouncing or pressure is beyond
540 541 542
	 * the maximum. Don't report it to user space, repeat at least
	 * once more the measurement
	 */
543
	if (ts->tc.ignore || Rt > ts->pressure_max) {
544 545 546 547
#ifdef VERBOSE
		pr_debug("%s: ignored %d pressure %d\n",
			ts->spi->dev.bus_id, ts->tc.ignore, Rt);
#endif
548
		hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
549
			      HRTIMER_MODE_REL);
550 551 552
		return;
	}

553 554 555 556
	/* NOTE: We can't rely on the pressure to determine the pen down
	 * state, even this controller has a pressure sensor.  The pressure
	 * value can fluctuate for quite a while after lifting the pen and
	 * in some cases may not even settle at the expected value.
David Brownell's avatar
David Brownell committed
557
	 *
558 559
	 * The only safe way to check for the pen up condition is in the
	 * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
David Brownell's avatar
David Brownell committed
560 561
	 */
	if (Rt) {
562
		struct input_dev *input = ts->input;
563

564 565 566 567 568
		if (!ts->pendown) {
			input_report_key(input, BTN_TOUCH, 1);
			ts->pendown = 1;
#ifdef VERBOSE
			dev_dbg(&ts->spi->dev, "DOWN\n");
David Brownell's avatar
David Brownell committed
569
#endif
570 571 572 573
		}
		input_report_abs(input, ABS_X, x);
		input_report_abs(input, ABS_Y, y);
		input_report_abs(input, ABS_PRESSURE, Rt);
David Brownell's avatar
David Brownell committed
574

575 576 577 578 579
		input_sync(input);
#ifdef VERBOSE
		dev_dbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
#endif
	}
David Brownell's avatar
David Brownell committed
580

581 582
	hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
			HRTIMER_MODE_REL);
David Brownell's avatar
David Brownell committed
583 584
}

585
static int ads7846_debounce(void *ads, int data_idx, int *val)
586 587 588
{
	struct ads7846		*ts = ads;

589 590 591
	if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
		/* Start over collecting consistent readings. */
		ts->read_rep = 0;
592 593 594
		/* Repeat it, if this was the first read or the read
		 * wasn't consistent enough. */
		if (ts->read_cnt < ts->debounce_max) {
595
			ts->last_read = *val;
596
			ts->read_cnt++;
597
			return ADS7846_FILTER_REPEAT;
598 599 600 601 602 603 604
		} else {
			/* Maximum number of debouncing reached and still
			 * not enough number of consistent readings. Abort
			 * the whole sample, repeat it in the next sampling
			 * period.
			 */
			ts->read_cnt = 0;
605
			return ADS7846_FILTER_IGNORE;
606
		}
607
	} else {
608 609 610 611 612
		if (++ts->read_rep > ts->debounce_rep) {
			/* Got a good reading for this coordinate,
			 * go for the next one. */
			ts->read_cnt = 0;
			ts->read_rep = 0;
613 614
			return ADS7846_FILTER_OK;
		} else {
615 616
			/* Read more values that are consistent. */
			ts->read_cnt++;
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
			return ADS7846_FILTER_REPEAT;
		}
	}
}

static int ads7846_no_filter(void *ads, int data_idx, int *val)
{
	return ADS7846_FILTER_OK;
}

static void ads7846_rx_val(void *ads)
{
	struct ads7846 *ts = ads;
	struct spi_message *m;
	struct spi_transfer *t;
	u16 *rx_val;
	int val;
	int action;
	int status;

	m = &ts->msg[ts->msg_idx];
	t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
	rx_val = t->rx_buf;

	/* adjust:  on-wire is a must-ignore bit, a BE12 value, then padding;
	 * built from two 8 bit values written msb-first.
	 */
	val = be16_to_cpu(*rx_val) >> 3;

	action = ts->filter(ts->filter_data, ts->msg_idx, &val);
	switch (action) {
	case ADS7846_FILTER_REPEAT:
		break;
	case ADS7846_FILTER_IGNORE:
		ts->tc.ignore = 1;
		/* Last message will contain ads7846_rx() as the
		 * completion function.
		 */
		m = ts->last_msg;
		break;
	case ADS7846_FILTER_OK:
		*rx_val = val;
		ts->tc.ignore = 0;
		m = &ts->msg[++ts->msg_idx];
		break;
	default:
		BUG();
664 665 666 667 668 669 670
	}
	status = spi_async(ts->spi, m);
	if (status)
		dev_err(&ts->spi->dev, "spi_async --> %d\n",
				status);
}

671
static enum hrtimer_restart ads7846_timer(struct hrtimer *handle)
David Brownell's avatar
David Brownell committed
672
{
673
	struct ads7846	*ts = container_of(handle, struct ads7846, timer);
David Brownell's avatar
David Brownell committed
674
	int		status = 0;
675

676 677
	spin_lock_irq(&ts->lock);

678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
	if (unlikely(!ts->get_pendown_state() ||
		     device_suspended(&ts->spi->dev))) {
		if (ts->pendown) {
			struct input_dev *input = ts->input;

			input_report_key(input, BTN_TOUCH, 0);
			input_report_abs(input, ABS_PRESSURE, 0);
			input_sync(input);

			ts->pendown = 0;
#ifdef VERBOSE
			dev_dbg(&ts->spi->dev, "UP\n");
#endif
		}

693
		/* measurement cycle ended */
694 695 696 697 698 699 700 701 702 703 704 705 706 707
		if (!device_suspended(&ts->spi->dev)) {
			ts->irq_disabled = 0;
			enable_irq(ts->spi->irq);
		}
		ts->pending = 0;
	} else {
		/* pen is still down, continue with the measurement */
		ts->msg_idx = 0;
		status = spi_async(ts->spi, &ts->msg[0]);
		if (status)
			dev_err(&ts->spi->dev, "spi_async --> %d\n", status);
	}

	spin_unlock_irq(&ts->lock);
708
	return HRTIMER_NORESTART;
709 710
}

711
static irqreturn_t ads7846_irq(int irq, void *handle)
712 713 714
{
	struct ads7846 *ts = handle;
	unsigned long flags;
David Brownell's avatar
David Brownell committed
715 716

	spin_lock_irqsave(&ts->lock, flags);
717
	if (likely(ts->get_pendown_state())) {
David Brownell's avatar
David Brownell committed
718
		if (!ts->irq_disabled) {
719 720 721 722
			/* The ARM do_simple_IRQ() dispatcher doesn't act
			 * like the other dispatchers:  it will report IRQs
			 * even after they've been disabled.  We work around
			 * that here.  (The "generic irq" framework may help...)
723
			 */
David Brownell's avatar
David Brownell committed
724 725
			ts->irq_disabled = 1;
			disable_irq(ts->spi->irq);
726
			ts->pending = 1;
727
			hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),
728
					HRTIMER_MODE_REL);
729
		}
David Brownell's avatar
David Brownell committed
730 731
	}
	spin_unlock_irqrestore(&ts->lock, flags);
732 733

	return IRQ_HANDLED;
David Brownell's avatar
David Brownell committed
734 735 736 737
}

/*--------------------------------------------------------------------------*/

738 739
/* Must be called with ts->lock held */
static void ads7846_disable(struct ads7846 *ts)
David Brownell's avatar
David Brownell committed
740
{
741 742
	if (ts->disabled)
		return;
David Brownell's avatar
David Brownell committed
743

744 745
	ts->disabled = 1;

David Brownell's avatar
David Brownell committed
746
	/* are we waiting for IRQ, or polling? */
747 748 749
	if (!ts->pending) {
		ts->irq_disabled = 1;
		disable_irq(ts->spi->irq);
David Brownell's avatar
David Brownell committed
750
	} else {
751 752
		/* the timer will run at least once more, and
		 * leave everything in a clean state, IRQ disabled
David Brownell's avatar
David Brownell committed
753
		 */
754
		while (ts->pending) {
755
			spin_unlock_irq(&ts->lock);
756
			msleep(1);
757
			spin_lock_irq(&ts->lock);
David Brownell's avatar
David Brownell committed
758 759 760 761 762 763 764
		}
	}

	/* we know the chip's in lowpower mode since we always
	 * leave it that way after every request
	 */

765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
}

/* Must be called with ts->lock held */
static void ads7846_enable(struct ads7846 *ts)
{
	if (!ts->disabled)
		return;

	ts->disabled = 0;
	ts->irq_disabled = 0;
	enable_irq(ts->spi->irq);
}

static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
{
	struct ads7846 *ts = dev_get_drvdata(&spi->dev);

	spin_lock_irq(&ts->lock);

	spi->dev.power.power_state = message;
	ads7846_disable(ts);

	spin_unlock_irq(&ts->lock);

David Brownell's avatar
David Brownell committed
789
	return 0;
790

David Brownell's avatar
David Brownell committed
791 792
}

793
static int ads7846_resume(struct spi_device *spi)
David Brownell's avatar
David Brownell committed
794
{
795
	struct ads7846 *ts = dev_get_drvdata(&spi->dev);
David Brownell's avatar
David Brownell committed
796

797 798
	spin_lock_irq(&ts->lock);

799
	spi->dev.power.power_state = PMSG_ON;
800 801 802 803
	ads7846_enable(ts);

	spin_unlock_irq(&ts->lock);

David Brownell's avatar
David Brownell committed
804 805 806
	return 0;
}

807
static int __devinit ads7846_probe(struct spi_device *spi)
David Brownell's avatar
David Brownell committed
808 809
{
	struct ads7846			*ts;
810
	struct input_dev		*input_dev;
811
	struct ads7846_platform_data	*pdata = spi->dev.platform_data;
812
	struct spi_message		*m;
David Brownell's avatar
David Brownell committed
813
	struct spi_transfer		*x;
814
	int				vref;
815
	int				err;
David Brownell's avatar
David Brownell committed
816 817

	if (!spi->irq) {
818
		dev_dbg(&spi->dev, "no IRQ?\n");
David Brownell's avatar
David Brownell committed
819 820 821 822
		return -ENODEV;
	}

	if (!pdata) {
823
		dev_dbg(&spi->dev, "no platform data?\n");
David Brownell's avatar
David Brownell committed
824 825 826 827
		return -ENODEV;
	}

	/* don't exceed max specified sample rate */
828
	if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
829
		dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
830
				(spi->max_speed_hz/SAMPLE_BITS)/1000);
David Brownell's avatar
David Brownell committed
831 832 833
		return -EINVAL;
	}

834 835 836 837
	/* REVISIT when the irq can be triggered active-low, or if for some
	 * reason the touchscreen isn't hooked up, we don't need to access
	 * the pendown state.
	 */
838 839 840 841 842
	if (pdata->get_pendown_state == NULL) {
		dev_dbg(&spi->dev, "no get_pendown_state function?\n");
		return -EINVAL;
	}

843 844 845
	/* We'd set TX wordsize 8 bits and RX wordsize to 13 bits ... except
	 * that even if the hardware can do that, the SPI controller driver
	 * may not.  So we stick to very-portable 8 bit words, both RX and TX.
David Brownell's avatar
David Brownell committed
846
	 */
847
	spi->bits_per_word = 8;
848 849 850 851
	spi->mode = SPI_MODE_1;
	err = spi_setup(spi);
	if (err < 0)
		return err;
David Brownell's avatar
David Brownell committed
852

853 854 855 856 857 858
	ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!ts || !input_dev) {
		err = -ENOMEM;
		goto err_free_mem;
	}
David Brownell's avatar
David Brownell committed
859

860
	dev_set_drvdata(&spi->dev, ts);
861
	spi->dev.power.power_state = PMSG_ON;
David Brownell's avatar
David Brownell committed
862 863

	ts->spi = spi;
864
	ts->input = input_dev;
David Brownell's avatar
David Brownell committed
865

866
	hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
David Brownell's avatar
David Brownell committed
867 868
	ts->timer.function = ads7846_timer;

869 870
	spin_lock_init(&ts->lock);

David Brownell's avatar
David Brownell committed
871 872 873
	ts->model = pdata->model ? : 7846;
	ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
	ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
874
	ts->pressure_max = pdata->pressure_max ? : ~0;
875 876 877 878 879 880 881 882 883 884

	if (pdata->filter != NULL) {
		if (pdata->filter_init != NULL) {
			err = pdata->filter_init(pdata, &ts->filter_data);
			if (err < 0)
				goto err_free_mem;
		}
		ts->filter = pdata->filter;
		ts->filter_cleanup = pdata->filter_cleanup;
	} else if (pdata->debounce_max) {
885
		ts->debounce_max = pdata->debounce_max;
886 887
		if (ts->debounce_max < 2)
			ts->debounce_max = 2;
888 889
		ts->debounce_tol = pdata->debounce_tol;
		ts->debounce_rep = pdata->debounce_rep;
890 891
		ts->filter = ads7846_debounce;
		ts->filter_data = ts;
892
	} else
893
		ts->filter = ads7846_no_filter;
894
	ts->get_pendown_state = pdata->get_pendown_state;
David Brownell's avatar
David Brownell committed
895

896
	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", spi->dev.bus_id);
David Brownell's avatar
David Brownell committed
897

898 899 900
	input_dev->name = "ADS784x Touchscreen";
	input_dev->phys = ts->phys;
	input_dev->cdev.dev = &spi->dev;
David Brownell's avatar
David Brownell committed
901

902 903 904
	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
	input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
	input_set_abs_params(input_dev, ABS_X,
David Brownell's avatar
David Brownell committed
905 906 907
			pdata->x_min ? : 0,
			pdata->x_max ? : MAX_12BIT,
			0, 0);
908
	input_set_abs_params(input_dev, ABS_Y,
David Brownell's avatar
David Brownell committed
909 910 911
			pdata->y_min ? : 0,
			pdata->y_max ? : MAX_12BIT,
			0, 0);
912
	input_set_abs_params(input_dev, ABS_PRESSURE,
David Brownell's avatar
David Brownell committed
913 914
			pdata->pressure_min, pdata->pressure_max, 0, 0);

915 916
	vref = pdata->keep_vref_on;

David Brownell's avatar
David Brownell committed
917 918 919
	/* set up the transfers to read touchscreen state; this assumes we
	 * use formula #2 for pressure, not #3.
	 */
920
	m = &ts->msg[0];
David Brownell's avatar
David Brownell committed
921 922
	x = ts->xfer;

923 924
	spi_message_init(m);

David Brownell's avatar
David Brownell committed
925
	/* y- still on; turn on only y+ (and ADC) */
926
	ts->read_y = READ_Y(vref);
927
	x->tx_buf = &ts->read_y;
David Brownell's avatar
David Brownell committed
928
	x->len = 1;
929
	spi_message_add_tail(x, m);
930

David Brownell's avatar
David Brownell committed
931 932 933
	x++;
	x->rx_buf = &ts->tc.y;
	x->len = 2;
934 935
	spi_message_add_tail(x, m);

936
	m->complete = ads7846_rx_val;
937 938 939 940 941 942 943
	m->context = ts;

	m++;
	spi_message_init(m);

	/* turn y- off, x+ on, then leave in lowpower */
	x++;
944
	ts->read_x = READ_X(vref);
945 946 947 948 949 950 951 952 953
	x->tx_buf = &ts->read_x;
	x->len = 1;
	spi_message_add_tail(x, m);

	x++;
	x->rx_buf = &ts->tc.x;
	x->len = 2;
	spi_message_add_tail(x, m);

954
	m->complete = ads7846_rx_val;
955
	m->context = ts;
David Brownell's avatar
David Brownell committed
956 957 958

	/* turn y+ off, x- on; we'll use formula #2 */
	if (ts->model == 7846) {
959 960 961
		m++;
		spi_message_init(m);

962
		x++;
963
		ts->read_z1 = READ_Z1(vref);
964
		x->tx_buf = &ts->read_z1;
David Brownell's avatar
David Brownell committed
965
		x->len = 1;
966
		spi_message_add_tail(x, m);
967

David Brownell's avatar
David Brownell committed
968 969 970
		x++;
		x->rx_buf = &ts->tc.z1;
		x->len = 2;
971 972
		spi_message_add_tail(x, m);

973
		m->complete = ads7846_rx_val;
974 975 976 977
		m->context = ts;

		m++;
		spi_message_init(m);
David Brownell's avatar
David Brownell committed
978

979
		x++;
980
		ts->read_z2 = READ_Z2(vref);
981
		x->tx_buf = &ts->read_z2;
David Brownell's avatar
David Brownell committed
982
		x->len = 1;
983
		spi_message_add_tail(x, m);
984

David Brownell's avatar
David Brownell committed
985 986 987
		x++;
		x->rx_buf = &ts->tc.z2;
		x->len = 2;
988
		spi_message_add_tail(x, m);
David Brownell's avatar
David Brownell committed
989

990
		m->complete = ads7846_rx_val;
991 992
		m->context = ts;
	}
993 994

	/* power down */
995 996 997
	m++;
	spi_message_init(m);

998 999 1000 1001
	x++;
	ts->pwrdown = PWRDOWN;
	x->tx_buf = &ts->pwrdown;
	x->len = 1;
1002
	spi_message_add_tail(x, m);
1003 1004 1005 1006

	x++;
	x->rx_buf = &ts->dummy;
	x->len = 2;
1007
	CS_CHANGE(*x);
1008
	spi_message_add_tail(x, m);
David Brownell's avatar
David Brownell committed
1009

1010 1011
	m->complete = ads7846_rx;
	m->context = ts;
David Brownell's avatar
David Brownell committed
1012

1013 1014
	ts->last_msg = m;

1015
	if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
1016
			spi->dev.driver->name, ts)) {
1017
		dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
1018
		err = -EBUSY;
1019
		goto err_cleanup_filter;
David Brownell's avatar
David Brownell committed
1020 1021
	}

1022 1023 1024 1025
	err = ads784x_hwmon_register(spi, ts);
	if (err)
		goto err_free_irq;

1026
	dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
David Brownell's avatar
David Brownell committed
1027

1028
	/* take a first sample, leaving nPENIRQ active and vREF off; avoid
David Brownell's avatar
David Brownell committed
1029 1030
	 * the touchscreen, in case it's not connected.
	 */
1031
	(void) ads7846_read12_ser(&spi->dev,
David Brownell's avatar
David Brownell committed
1032 1033
			  READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);

1034
	err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
1035
	if (err)
1036
		goto err_remove_hwmon;
1037

1038 1039
	err = input_register_device(input_dev);
	if (err)
1040
		goto err_remove_attr_group;
1041