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