xref: /openbmc/linux/drivers/input/touchscreen/tsc2005.c (revision b88aa494c27552e6fa94e4abaa5ea4f9b2f170a8)
1 /*
2  * TSC2005 touchscreen driver
3  *
4  * Copyright (C) 2006-2010 Nokia Corporation
5  *
6  * Author: Lauri Leukkunen <lauri.leukkunen@nokia.com>
7  * based on TSC2301 driver by Klaus K. Pedersen <klaus.k.pedersen@nokia.com>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  *
23  */
24 
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/input.h>
28 #include <linux/interrupt.h>
29 #include <linux/delay.h>
30 #include <linux/pm.h>
31 #include <linux/spi/spi.h>
32 #include <linux/spi/tsc2005.h>
33 
34 /*
35  * The touchscreen interface operates as follows:
36  *
37  * 1) Pen is pressed against the touchscreen.
38  * 2) TSC2005 performs AD conversion.
39  * 3) After the conversion is done TSC2005 drives DAV line down.
40  * 4) GPIO IRQ is received and tsc2005_irq_thread() is scheduled.
41  * 5) tsc2005_irq_thread() queues up an spi transfer to fetch the x, y, z1, z2
42  *    values.
43  * 6) tsc2005_irq_thread() reports coordinates to input layer and sets up
44  *    tsc2005_penup_timer() to be called after TSC2005_PENUP_TIME_MS (40ms).
45  * 7) When the penup timer expires, there have not been touch or DAV interrupts
46  *    during the last 40ms which means the pen has been lifted.
47  *
48  * ESD recovery via a hardware reset is done if the TSC2005 doesn't respond
49  * after a configurable period (in ms) of activity. If esd_timeout is 0, the
50  * watchdog is disabled.
51  */
52 
53 /* control byte 1 */
54 #define TSC2005_CMD			0x80
55 #define TSC2005_CMD_NORMAL		0x00
56 #define TSC2005_CMD_STOP		0x01
57 #define TSC2005_CMD_12BIT		0x04
58 
59 /* control byte 0 */
60 #define TSC2005_REG_READ		0x0001
61 #define TSC2005_REG_PND0		0x0002
62 #define TSC2005_REG_X			0x0000
63 #define TSC2005_REG_Y			0x0008
64 #define TSC2005_REG_Z1			0x0010
65 #define TSC2005_REG_Z2			0x0018
66 #define TSC2005_REG_TEMP_HIGH		0x0050
67 #define TSC2005_REG_CFR0		0x0060
68 #define TSC2005_REG_CFR1		0x0068
69 #define TSC2005_REG_CFR2		0x0070
70 
71 /* configuration register 0 */
72 #define TSC2005_CFR0_PRECHARGE_276US	0x0040
73 #define TSC2005_CFR0_STABTIME_1MS	0x0300
74 #define TSC2005_CFR0_CLOCK_1MHZ		0x1000
75 #define TSC2005_CFR0_RESOLUTION12	0x2000
76 #define TSC2005_CFR0_PENMODE		0x8000
77 #define TSC2005_CFR0_INITVALUE		(TSC2005_CFR0_STABTIME_1MS    | \
78 					 TSC2005_CFR0_CLOCK_1MHZ      | \
79 					 TSC2005_CFR0_RESOLUTION12    | \
80 					 TSC2005_CFR0_PRECHARGE_276US | \
81 					 TSC2005_CFR0_PENMODE)
82 
83 /* bits common to both read and write of configuration register 0 */
84 #define	TSC2005_CFR0_RW_MASK		0x3fff
85 
86 /* configuration register 1 */
87 #define TSC2005_CFR1_BATCHDELAY_4MS	0x0003
88 #define TSC2005_CFR1_INITVALUE		TSC2005_CFR1_BATCHDELAY_4MS
89 
90 /* configuration register 2 */
91 #define TSC2005_CFR2_MAVE_Z		0x0004
92 #define TSC2005_CFR2_MAVE_Y		0x0008
93 #define TSC2005_CFR2_MAVE_X		0x0010
94 #define TSC2005_CFR2_AVG_7		0x0800
95 #define TSC2005_CFR2_MEDIUM_15		0x3000
96 #define TSC2005_CFR2_INITVALUE		(TSC2005_CFR2_MAVE_X	| \
97 					 TSC2005_CFR2_MAVE_Y	| \
98 					 TSC2005_CFR2_MAVE_Z	| \
99 					 TSC2005_CFR2_MEDIUM_15	| \
100 					 TSC2005_CFR2_AVG_7)
101 
102 #define MAX_12BIT			0xfff
103 #define TSC2005_SPI_MAX_SPEED_HZ	10000000
104 #define TSC2005_PENUP_TIME_MS		40
105 
106 struct tsc2005_spi_rd {
107 	struct spi_transfer	spi_xfer;
108 	u32			spi_tx;
109 	u32			spi_rx;
110 };
111 
112 struct tsc2005 {
113 	struct spi_device	*spi;
114 
115 	struct spi_message      spi_read_msg;
116 	struct tsc2005_spi_rd	spi_x;
117 	struct tsc2005_spi_rd	spi_y;
118 	struct tsc2005_spi_rd	spi_z1;
119 	struct tsc2005_spi_rd	spi_z2;
120 
121 	struct input_dev	*idev;
122 	char			phys[32];
123 
124 	struct mutex		mutex;
125 
126 	/* raw copy of previous x,y,z */
127 	int			in_x;
128 	int			in_y;
129 	int                     in_z1;
130 	int			in_z2;
131 
132 	struct timer_list	penup_timer;
133 	struct work_struct	penup_work;
134 
135 	unsigned int		esd_timeout;
136 	struct timer_list	esd_timer;
137 	struct work_struct	esd_work;
138 
139 	unsigned int		x_plate_ohm;
140 
141 	bool			disabled;
142 	unsigned int		disable_depth;
143 	unsigned int		pen_down;
144 
145 	void			(*set_reset)(bool enable);
146 };
147 
148 static void tsc2005_cmd(struct tsc2005 *ts, u8 cmd)
149 {
150 	u8 tx;
151 	struct spi_message msg;
152 	struct spi_transfer xfer = { 0 };
153 
154 	tx = TSC2005_CMD | TSC2005_CMD_12BIT | cmd;
155 
156 	xfer.tx_buf = &tx;
157 	xfer.rx_buf = NULL;
158 	xfer.len = 1;
159 	xfer.bits_per_word = 8;
160 
161 	spi_message_init(&msg);
162 	spi_message_add_tail(&xfer, &msg);
163 	spi_sync(ts->spi, &msg);
164 }
165 
166 static void tsc2005_write(struct tsc2005 *ts, u8 reg, u16 value)
167 {
168 	u32 tx;
169 	struct spi_message msg;
170 	struct spi_transfer xfer = { 0 };
171 
172 	tx = (reg | TSC2005_REG_PND0) << 16;
173 	tx |= value;
174 
175 	xfer.tx_buf = &tx;
176 	xfer.rx_buf = NULL;
177 	xfer.len = 4;
178 	xfer.bits_per_word = 24;
179 
180 	spi_message_init(&msg);
181 	spi_message_add_tail(&xfer, &msg);
182 	spi_sync(ts->spi, &msg);
183 }
184 
185 static void tsc2005_setup_read(struct tsc2005_spi_rd *rd, u8 reg, bool last)
186 {
187 	rd->spi_tx		   = (reg | TSC2005_REG_READ) << 16;
188 	rd->spi_xfer.tx_buf	   = &rd->spi_tx;
189 	rd->spi_xfer.rx_buf	   = &rd->spi_rx;
190 	rd->spi_xfer.len	   = 4;
191 	rd->spi_xfer.bits_per_word = 24;
192 	rd->spi_xfer.cs_change	   = !last;
193 }
194 
195 static void tsc2005_read(struct tsc2005 *ts, u8 reg, u16 *value)
196 {
197 	struct spi_message msg;
198 	struct tsc2005_spi_rd spi_rd = { { 0 }, 0, 0 };
199 
200 	tsc2005_setup_read(&spi_rd, reg, 1);
201 
202 	spi_message_init(&msg);
203 	spi_message_add_tail(&spi_rd.spi_xfer, &msg);
204 	spi_sync(ts->spi, &msg);
205 	*value = spi_rd.spi_rx;
206 }
207 
208 static void tsc2005_update_pen_state(struct tsc2005 *ts,
209 				     int x, int y, int pressure)
210 {
211 	if (pressure) {
212 		input_report_abs(ts->idev, ABS_X, x);
213 		input_report_abs(ts->idev, ABS_Y, y);
214 		input_report_abs(ts->idev, ABS_PRESSURE, pressure);
215 		if (!ts->pen_down) {
216 			input_report_key(ts->idev, BTN_TOUCH, !!pressure);
217 			ts->pen_down = 1;
218 		}
219 	} else {
220 		input_report_abs(ts->idev, ABS_PRESSURE, 0);
221 		if (ts->pen_down) {
222 			input_report_key(ts->idev, BTN_TOUCH, 0);
223 			ts->pen_down = 0;
224 		}
225 	}
226 	input_sync(ts->idev);
227 	dev_dbg(&ts->spi->dev, "point(%4d,%4d), pressure (%4d)\n", x, y,
228 		pressure);
229 }
230 
231 static irqreturn_t tsc2005_irq_handler(int irq, void *dev_id)
232 {
233 	struct tsc2005 *ts = dev_id;
234 
235 	/* update the penup timer only if it's pending */
236 	mod_timer_pending(&ts->penup_timer,
237 			  jiffies + msecs_to_jiffies(TSC2005_PENUP_TIME_MS));
238 
239 	return IRQ_WAKE_THREAD;
240 }
241 
242 static irqreturn_t tsc2005_irq_thread(int irq, void *_ts)
243 {
244 	struct tsc2005 *ts = _ts;
245 	unsigned int pressure;
246 	u32 x;
247 	u32 y;
248 	u32 z1;
249 	u32 z2;
250 
251 	mutex_lock(&ts->mutex);
252 
253 	if (unlikely(ts->disable_depth))
254 		goto out;
255 
256 	/* read the coordinates */
257 	spi_sync(ts->spi, &ts->spi_read_msg);
258 	x = ts->spi_x.spi_rx;
259 	y = ts->spi_y.spi_rx;
260 	z1 = ts->spi_z1.spi_rx;
261 	z2 = ts->spi_z2.spi_rx;
262 
263 	/* validate position */
264 	if (unlikely(x > MAX_12BIT || y > MAX_12BIT))
265 		goto out;
266 
267 	/* skip coords if the pressure components are out of range */
268 	if (unlikely(z1 == 0 || z2 > MAX_12BIT || z1 >= z2))
269 		goto out;
270 
271        /* skip point if this is a pen down with the exact same values as
272 	* the value before pen-up - that implies SPI fed us stale data
273 	*/
274 	if (!ts->pen_down &&
275 	ts->in_x == x &&
276 	ts->in_y == y &&
277 	ts->in_z1 == z1 &&
278 	ts->in_z2 == z2)
279 		goto out;
280 
281 	/* At this point we are happy we have a valid and useful reading.
282 	* Remember it for later comparisons. We may now begin downsampling
283 	*/
284 	ts->in_x = x;
285 	ts->in_y = y;
286 	ts->in_z1 = z1;
287 	ts->in_z2 = z2;
288 
289 	/* compute touch pressure resistance using equation #1 */
290 	pressure = x * (z2 - z1) / z1;
291 	pressure = pressure * ts->x_plate_ohm / 4096;
292 	if (unlikely(pressure > MAX_12BIT))
293 		goto out;
294 
295 	tsc2005_update_pen_state(ts, x, y, pressure);
296 
297 	/* set the penup timer */
298 	mod_timer(&ts->penup_timer,
299 		  jiffies + msecs_to_jiffies(TSC2005_PENUP_TIME_MS));
300 
301 	if (!ts->esd_timeout)
302 		goto out;
303 
304 	/* update the watchdog timer */
305 	mod_timer(&ts->esd_timer,
306 		  round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));
307 
308 out:
309 	mutex_unlock(&ts->mutex);
310 	return IRQ_HANDLED;
311 }
312 
313 static void tsc2005_penup_timer(unsigned long data)
314 {
315 	struct tsc2005 *ts = (struct tsc2005 *)data;
316 
317 	schedule_work(&ts->penup_work);
318 }
319 
320 static void tsc2005_penup_work(struct work_struct *work)
321 {
322 	struct tsc2005 *ts = container_of(work, struct tsc2005, penup_work);
323 
324 	mutex_lock(&ts->mutex);
325 	tsc2005_update_pen_state(ts, 0, 0, 0);
326 	mutex_unlock(&ts->mutex);
327 }
328 
329 static void tsc2005_start_scan(struct tsc2005 *ts)
330 {
331 	tsc2005_write(ts, TSC2005_REG_CFR0, TSC2005_CFR0_INITVALUE);
332 	tsc2005_write(ts, TSC2005_REG_CFR1, TSC2005_CFR1_INITVALUE);
333 	tsc2005_write(ts, TSC2005_REG_CFR2, TSC2005_CFR2_INITVALUE);
334 	tsc2005_cmd(ts, TSC2005_CMD_NORMAL);
335 }
336 
337 static void tsc2005_stop_scan(struct tsc2005 *ts)
338 {
339 	tsc2005_cmd(ts, TSC2005_CMD_STOP);
340 }
341 
342 /* must be called with mutex held */
343 static void tsc2005_disable(struct tsc2005 *ts)
344 {
345 	if (ts->disable_depth++ != 0)
346 		return;
347 	disable_irq(ts->spi->irq);
348 	if (ts->esd_timeout)
349 		del_timer_sync(&ts->esd_timer);
350 	del_timer_sync(&ts->penup_timer);
351 	tsc2005_stop_scan(ts);
352 }
353 
354 /* must be called with mutex held */
355 static void tsc2005_enable(struct tsc2005 *ts)
356 {
357 	if (--ts->disable_depth != 0)
358 		return;
359 	tsc2005_start_scan(ts);
360 	enable_irq(ts->spi->irq);
361 	if (!ts->esd_timeout)
362 		return;
363 	mod_timer(&ts->esd_timer,
364 		  round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));
365 }
366 
367 static ssize_t tsc2005_disable_show(struct device *dev,
368 				    struct device_attribute *attr, char *buf)
369 {
370 	struct spi_device *spi = to_spi_device(dev);
371 	struct tsc2005 *ts = spi_get_drvdata(spi);
372 
373 	return sprintf(buf, "%u\n", ts->disabled);
374 }
375 
376 static ssize_t tsc2005_disable_store(struct device *dev,
377 				     struct device_attribute *attr,
378 				     const char *buf, size_t count)
379 {
380 	struct spi_device *spi = to_spi_device(dev);
381 	struct tsc2005 *ts = spi_get_drvdata(spi);
382 	unsigned long res;
383 	int i;
384 
385 	if (strict_strtoul(buf, 10, &res) < 0)
386 		return -EINVAL;
387 	i = res ? 1 : 0;
388 
389 	mutex_lock(&ts->mutex);
390 	if (i == ts->disabled)
391 		goto out;
392 	ts->disabled = i;
393 	if (i)
394 		tsc2005_disable(ts);
395 	else
396 		tsc2005_enable(ts);
397 out:
398 	mutex_unlock(&ts->mutex);
399 	return count;
400 }
401 static DEVICE_ATTR(disable, 0664, tsc2005_disable_show, tsc2005_disable_store);
402 
403 static ssize_t tsc2005_selftest_show(struct device *dev,
404 				     struct device_attribute *attr,
405 				     char *buf)
406 {
407 	struct spi_device *spi = to_spi_device(dev);
408 	struct tsc2005 *ts = spi_get_drvdata(spi);
409 	u16 temp_high;
410 	u16 temp_high_orig;
411 	u16 temp_high_test;
412 	unsigned int result;
413 
414 	if (!ts->set_reset) {
415 		dev_warn(&ts->spi->dev,
416 			 "unable to selftest: no reset function\n");
417 		result = 0;
418 		goto out;
419 	}
420 
421 	mutex_lock(&ts->mutex);
422 
423 	/*
424 	 * Test TSC2005 communications via temp high register.
425 	 */
426 	tsc2005_disable(ts);
427 	result = 1;
428 	tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high_orig);
429 	temp_high_test = (temp_high_orig - 1) & MAX_12BIT;
430 	tsc2005_write(ts, TSC2005_REG_TEMP_HIGH, temp_high_test);
431 	tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high);
432 	if (temp_high != temp_high_test) {
433 		dev_warn(dev, "selftest failed: %d != %d\n",
434 			 temp_high, temp_high_test);
435 		result = 0;
436 	}
437 
438 	/* hardware reset */
439 	ts->set_reset(0);
440 	usleep_range(100, 500); /* only 10us required */
441 	ts->set_reset(1);
442 	tsc2005_enable(ts);
443 
444 	/* test that the reset really happened */
445 	tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high);
446 	if (temp_high != temp_high_orig) {
447 		dev_warn(dev, "selftest failed after reset: %d != %d\n",
448 			 temp_high, temp_high_orig);
449 		result = 0;
450 	}
451 
452 	mutex_unlock(&ts->mutex);
453 
454 out:
455 	return sprintf(buf, "%u\n", result);
456 }
457 static DEVICE_ATTR(selftest, S_IRUGO, tsc2005_selftest_show, NULL);
458 
459 static void tsc2005_esd_timer(unsigned long data)
460 {
461 	struct tsc2005 *ts = (struct tsc2005 *)data;
462 
463 	schedule_work(&ts->esd_work);
464 }
465 
466 static void tsc2005_esd_work(struct work_struct *work)
467 {
468 	struct tsc2005 *ts = container_of(work, struct tsc2005, esd_work);
469 	u16 r;
470 
471 	mutex_lock(&ts->mutex);
472 
473 	if (ts->disable_depth)
474 		goto out;
475 
476 	/*
477 	 * If we cannot read our known value from configuration register 0 then
478 	 * reset the controller as if from power-up and start scanning again.
479 	 */
480 	tsc2005_read(ts, TSC2005_REG_CFR0, &r);
481 	if ((r ^ TSC2005_CFR0_INITVALUE) & TSC2005_CFR0_RW_MASK) {
482 		dev_info(&ts->spi->dev, "TSC2005 not responding - resetting\n");
483 		ts->set_reset(0);
484 		tsc2005_update_pen_state(ts, 0, 0, 0);
485 		usleep_range(100, 500); /* only 10us required */
486 		ts->set_reset(1);
487 		tsc2005_start_scan(ts);
488 	}
489 
490 	/* re-arm the watchdog */
491 	mod_timer(&ts->esd_timer,
492 		  round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));
493 
494 out:
495 	mutex_unlock(&ts->mutex);
496 }
497 
498 static void __devinit tsc2005_setup_spi_xfer(struct tsc2005 *ts)
499 {
500 	tsc2005_setup_read(&ts->spi_x, TSC2005_REG_X, 0);
501 	tsc2005_setup_read(&ts->spi_y, TSC2005_REG_Y, 0);
502 	tsc2005_setup_read(&ts->spi_z1, TSC2005_REG_Z1, 0);
503 	tsc2005_setup_read(&ts->spi_z2, TSC2005_REG_Z2, 1);
504 
505 	spi_message_init(&ts->spi_read_msg);
506 	spi_message_add_tail(&ts->spi_x.spi_xfer, &ts->spi_read_msg);
507 	spi_message_add_tail(&ts->spi_y.spi_xfer, &ts->spi_read_msg);
508 	spi_message_add_tail(&ts->spi_z1.spi_xfer, &ts->spi_read_msg);
509 	spi_message_add_tail(&ts->spi_z2.spi_xfer, &ts->spi_read_msg);
510 }
511 
512 static struct attribute *tsc2005_attrs[] = {
513 	&dev_attr_disable.attr,
514 	&dev_attr_selftest.attr,
515 	NULL
516 };
517 
518 static struct attribute_group tsc2005_attr_group = {
519 	.attrs = tsc2005_attrs,
520 };
521 
522 static int __devinit tsc2005_setup(struct tsc2005 *ts,
523 				   struct tsc2005_platform_data *pdata)
524 {
525 	int r;
526 	int fudge_x;
527 	int fudge_y;
528 	int fudge_p;
529 	int p_max;
530 	int x_max;
531 	int y_max;
532 
533 	mutex_init(&ts->mutex);
534 
535 	tsc2005_setup_spi_xfer(ts);
536 
537 	init_timer(&ts->penup_timer);
538 	setup_timer(&ts->penup_timer, tsc2005_penup_timer, (unsigned long)ts);
539 	INIT_WORK(&ts->penup_work, tsc2005_penup_work);
540 
541 	fudge_x		= pdata->ts_x_fudge	   ? : 4;
542 	fudge_y		= pdata->ts_y_fudge	   ? : 8;
543 	fudge_p		= pdata->ts_pressure_fudge ? : 2;
544 	x_max		= pdata->ts_x_max	   ? : MAX_12BIT;
545 	y_max		= pdata->ts_y_max	   ? : MAX_12BIT;
546 	p_max		= pdata->ts_pressure_max   ? : MAX_12BIT;
547 	ts->x_plate_ohm	= pdata->ts_x_plate_ohm	   ? : 280;
548 	ts->esd_timeout	= pdata->esd_timeout_ms;
549 	ts->set_reset	= pdata->set_reset;
550 
551 	ts->idev = input_allocate_device();
552 	if (ts->idev == NULL)
553 		return -ENOMEM;
554 	ts->idev->name = "TSC2005 touchscreen";
555 	snprintf(ts->phys, sizeof(ts->phys), "%s/input-ts",
556 		 dev_name(&ts->spi->dev));
557 	ts->idev->phys = ts->phys;
558 	ts->idev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
559 	ts->idev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
560 	ts->idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
561 
562 	input_set_abs_params(ts->idev, ABS_X, 0, x_max, fudge_x, 0);
563 	input_set_abs_params(ts->idev, ABS_Y, 0, y_max, fudge_y, 0);
564 	input_set_abs_params(ts->idev, ABS_PRESSURE, 0, p_max, fudge_p, 0);
565 
566 	r = request_threaded_irq(ts->spi->irq, tsc2005_irq_handler,
567 				 tsc2005_irq_thread, IRQF_TRIGGER_RISING,
568 				 "tsc2005", ts);
569 	if (r) {
570 		dev_err(&ts->spi->dev, "request_threaded_irq(): %d\n", r);
571 		goto err1;
572 	}
573 	set_irq_wake(ts->spi->irq, 1);
574 
575 	r = input_register_device(ts->idev);
576 	if (r) {
577 		dev_err(&ts->spi->dev, "input_register_device(): %d\n", r);
578 		goto err2;
579 	}
580 
581 	r = sysfs_create_group(&ts->spi->dev.kobj, &tsc2005_attr_group);
582 	if (r)
583 		dev_warn(&ts->spi->dev, "sysfs entry creation failed: %d\n", r);
584 
585 	tsc2005_start_scan(ts);
586 
587 	if (!ts->esd_timeout || !ts->set_reset)
588 		goto done;
589 
590 	/* start the optional ESD watchdog */
591 	setup_timer(&ts->esd_timer, tsc2005_esd_timer, (unsigned long)ts);
592 	INIT_WORK(&ts->esd_work, tsc2005_esd_work);
593 	mod_timer(&ts->esd_timer,
594 		  round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));
595 
596 done:
597 	return 0;
598 
599 err2:
600 	free_irq(ts->spi->irq, ts);
601 
602 err1:
603 	input_free_device(ts->idev);
604 	return r;
605 }
606 
607 static int __devinit tsc2005_probe(struct spi_device *spi)
608 {
609 	struct tsc2005_platform_data *pdata = spi->dev.platform_data;
610 	struct tsc2005 *ts;
611 	int r;
612 
613 	if (spi->irq < 0) {
614 		dev_dbg(&spi->dev, "no irq\n");
615 		return -ENODEV;
616 	}
617 
618 	if (!pdata) {
619 		dev_dbg(&spi->dev, "no platform data\n");
620 		return -ENODEV;
621 	}
622 
623 	ts = kzalloc(sizeof(*ts), GFP_KERNEL);
624 	if (ts == NULL)
625 		return -ENOMEM;
626 
627 	spi_set_drvdata(spi, ts);
628 	ts->spi = spi;
629 	spi->dev.power.power_state = PMSG_ON;
630 	spi->mode = SPI_MODE_0;
631 	spi->bits_per_word = 8;
632 	if (!spi->max_speed_hz)
633 		spi->max_speed_hz = TSC2005_SPI_MAX_SPEED_HZ;
634 	spi_setup(spi);
635 
636 	r = tsc2005_setup(ts, pdata);
637 	if (r)
638 		kfree(ts);
639 	return r;
640 }
641 
642 static int __devexit tsc2005_remove(struct spi_device *spi)
643 {
644 	struct tsc2005 *ts = spi_get_drvdata(spi);
645 
646 	mutex_lock(&ts->mutex);
647 	tsc2005_disable(ts);
648 	mutex_unlock(&ts->mutex);
649 
650 	if (ts->esd_timeout)
651 		del_timer_sync(&ts->esd_timer);
652 	del_timer_sync(&ts->penup_timer);
653 
654 	flush_work(&ts->esd_work);
655 	flush_work(&ts->penup_work);
656 
657 	sysfs_remove_group(&ts->spi->dev.kobj, &tsc2005_attr_group);
658 	free_irq(ts->spi->irq, ts);
659 	input_unregister_device(ts->idev);
660 	kfree(ts);
661 
662 	return 0;
663 }
664 
665 #ifdef CONFIG_PM_SLEEP
666 static int tsc2005_suspend(struct device *dev)
667 {
668 	struct spi_device *spi = to_spi_device(dev);
669 	struct tsc2005 *ts = spi_get_drvdata(spi);
670 
671 	mutex_lock(&ts->mutex);
672 	tsc2005_disable(ts);
673 	mutex_unlock(&ts->mutex);
674 
675 	return 0;
676 }
677 
678 static int tsc2005_resume(struct device *dev)
679 {
680 	struct spi_device *spi = to_spi_device(dev);
681 	struct tsc2005 *ts = spi_get_drvdata(spi);
682 
683 	mutex_lock(&ts->mutex);
684 	tsc2005_enable(ts);
685 	mutex_unlock(&ts->mutex);
686 
687 	return 0;
688 }
689 #endif
690 
691 static SIMPLE_DEV_PM_OPS(tsc2005_pm_ops, tsc2005_suspend, tsc2005_resume);
692 
693 static struct spi_driver tsc2005_driver = {
694 	.driver	= {
695 		.name	= "tsc2005",
696 		.owner	= THIS_MODULE,
697 		.pm	= &tsc2005_pm_ops,
698 	},
699 	.probe	= tsc2005_probe,
700 	.remove	= __devexit_p(tsc2005_remove),
701 };
702 
703 static int __init tsc2005_init(void)
704 {
705 	return spi_register_driver(&tsc2005_driver);
706 }
707 module_init(tsc2005_init);
708 
709 static void __exit tsc2005_exit(void)
710 {
711 	spi_unregister_driver(&tsc2005_driver);
712 }
713 module_exit(tsc2005_exit);
714 
715 MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>");
716 MODULE_DESCRIPTION("TSC2005 Touchscreen Driver");
717 MODULE_LICENSE("GPL");
718