Merge master.kernel.org:/pub/scm/linux/kernel/git/lethal/genesis-2.6
[linux-3.10.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         spin_lock_irq(&ts->lock);
819
820         ts->is_suspended = 1;
821         ads7846_disable(ts);
822
823         spin_unlock_irq(&ts->lock);
824
825         if (device_may_wakeup(&ts->spi->dev))
826                 enable_irq_wake(ts->spi->irq);
827
828         return 0;
829
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
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         return 0;
847 }
848
849 static int __devinit setup_pendown(struct spi_device *spi, struct ads7846 *ts)
850 {
851         struct ads7846_platform_data *pdata = spi->dev.platform_data;
852         int err;
853
854         /* REVISIT when the irq can be triggered active-low, or if for some
855          * reason the touchscreen isn't hooked up, we don't need to access
856          * the pendown state.
857          */
858         if (!pdata->get_pendown_state && !gpio_is_valid(pdata->gpio_pendown)) {
859                 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
860                 return -EINVAL;
861         }
862
863         if (pdata->get_pendown_state) {
864                 ts->get_pendown_state = pdata->get_pendown_state;
865                 return 0;
866         }
867
868         err = gpio_request(pdata->gpio_pendown, "ads7846_pendown");
869         if (err) {
870                 dev_err(&spi->dev, "failed to request pendown GPIO%d\n",
871                                 pdata->gpio_pendown);
872                 return err;
873         }
874
875         ts->gpio_pendown = pdata->gpio_pendown;
876         return 0;
877 }
878
879 static int __devinit ads7846_probe(struct spi_device *spi)
880 {
881         struct ads7846                  *ts;
882         struct ads7846_packet           *packet;
883         struct input_dev                *input_dev;
884         struct ads7846_platform_data    *pdata = spi->dev.platform_data;
885         struct spi_message              *m;
886         struct spi_transfer             *x;
887         int                             vref;
888         int                             err;
889
890         if (!spi->irq) {
891                 dev_dbg(&spi->dev, "no IRQ?\n");
892                 return -ENODEV;
893         }
894
895         if (!pdata) {
896                 dev_dbg(&spi->dev, "no platform data?\n");
897                 return -ENODEV;
898         }
899
900         /* don't exceed max specified sample rate */
901         if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
902                 dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
903                                 (spi->max_speed_hz/SAMPLE_BITS)/1000);
904                 return -EINVAL;
905         }
906
907         /* We'd set TX wordsize 8 bits and RX wordsize to 13 bits ... except
908          * that even if the hardware can do that, the SPI controller driver
909          * may not.  So we stick to very-portable 8 bit words, both RX and TX.
910          */
911         spi->bits_per_word = 8;
912         spi->mode = SPI_MODE_0;
913         err = spi_setup(spi);
914         if (err < 0)
915                 return err;
916
917         ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
918         packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
919         input_dev = input_allocate_device();
920         if (!ts || !packet || !input_dev) {
921                 err = -ENOMEM;
922                 goto err_free_mem;
923         }
924
925         dev_set_drvdata(&spi->dev, ts);
926
927         ts->packet = packet;
928         ts->spi = spi;
929         ts->input = input_dev;
930         ts->vref_mv = pdata->vref_mv;
931         ts->swap_xy = pdata->swap_xy;
932
933         hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
934         ts->timer.function = ads7846_timer;
935
936         spin_lock_init(&ts->lock);
937
938         ts->model = pdata->model ? : 7846;
939         ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
940         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
941         ts->pressure_max = pdata->pressure_max ? : ~0;
942
943         if (pdata->filter != NULL) {
944                 if (pdata->filter_init != NULL) {
945                         err = pdata->filter_init(pdata, &ts->filter_data);
946                         if (err < 0)
947                                 goto err_free_mem;
948                 }
949                 ts->filter = pdata->filter;
950                 ts->filter_cleanup = pdata->filter_cleanup;
951         } else if (pdata->debounce_max) {
952                 ts->debounce_max = pdata->debounce_max;
953                 if (ts->debounce_max < 2)
954                         ts->debounce_max = 2;
955                 ts->debounce_tol = pdata->debounce_tol;
956                 ts->debounce_rep = pdata->debounce_rep;
957                 ts->filter = ads7846_debounce;
958                 ts->filter_data = ts;
959         } else
960                 ts->filter = ads7846_no_filter;
961
962         err = setup_pendown(spi, ts);
963         if (err)
964                 goto err_cleanup_filter;
965
966         if (pdata->penirq_recheck_delay_usecs)
967                 ts->penirq_recheck_delay_usecs =
968                                 pdata->penirq_recheck_delay_usecs;
969
970         ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
971
972         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
973         snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
974
975         input_dev->name = ts->name;
976         input_dev->phys = ts->phys;
977         input_dev->dev.parent = &spi->dev;
978
979         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
980         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
981         input_set_abs_params(input_dev, ABS_X,
982                         pdata->x_min ? : 0,
983                         pdata->x_max ? : MAX_12BIT,
984                         0, 0);
985         input_set_abs_params(input_dev, ABS_Y,
986                         pdata->y_min ? : 0,
987                         pdata->y_max ? : MAX_12BIT,
988                         0, 0);
989         input_set_abs_params(input_dev, ABS_PRESSURE,
990                         pdata->pressure_min, pdata->pressure_max, 0, 0);
991
992         vref = pdata->keep_vref_on;
993
994         if (ts->model == 7873) {
995                 /* The AD7873 is almost identical to the ADS7846
996                  * keep VREF off during differential/ratiometric
997                  * conversion modes
998                  */
999                 ts->model = 7846;
1000                 vref = 0;
1001         }
1002
1003         /* set up the transfers to read touchscreen state; this assumes we
1004          * use formula #2 for pressure, not #3.
1005          */
1006         m = &ts->msg[0];
1007         x = ts->xfer;
1008
1009         spi_message_init(m);
1010
1011         /* y- still on; turn on only y+ (and ADC) */
1012         packet->read_y = READ_Y(vref);
1013         x->tx_buf = &packet->read_y;
1014         x->len = 1;
1015         spi_message_add_tail(x, m);
1016
1017         x++;
1018         x->rx_buf = &packet->tc.y;
1019         x->len = 2;
1020         spi_message_add_tail(x, m);
1021
1022         /* the first sample after switching drivers can be low quality;
1023          * optionally discard it, using a second one after the signals
1024          * have had enough time to stabilize.
1025          */
1026         if (pdata->settle_delay_usecs) {
1027                 x->delay_usecs = pdata->settle_delay_usecs;
1028
1029                 x++;
1030                 x->tx_buf = &packet->read_y;
1031                 x->len = 1;
1032                 spi_message_add_tail(x, m);
1033
1034                 x++;
1035                 x->rx_buf = &packet->tc.y;
1036                 x->len = 2;
1037                 spi_message_add_tail(x, m);
1038         }
1039
1040         m->complete = ads7846_rx_val;
1041         m->context = ts;
1042
1043         m++;
1044         spi_message_init(m);
1045
1046         /* turn y- off, x+ on, then leave in lowpower */
1047         x++;
1048         packet->read_x = READ_X(vref);
1049         x->tx_buf = &packet->read_x;
1050         x->len = 1;
1051         spi_message_add_tail(x, m);
1052
1053         x++;
1054         x->rx_buf = &packet->tc.x;
1055         x->len = 2;
1056         spi_message_add_tail(x, m);
1057
1058         /* ... maybe discard first sample ... */
1059         if (pdata->settle_delay_usecs) {
1060                 x->delay_usecs = pdata->settle_delay_usecs;
1061
1062                 x++;
1063                 x->tx_buf = &packet->read_x;
1064                 x->len = 1;
1065                 spi_message_add_tail(x, m);
1066
1067                 x++;
1068                 x->rx_buf = &packet->tc.x;
1069                 x->len = 2;
1070                 spi_message_add_tail(x, m);
1071         }
1072
1073         m->complete = ads7846_rx_val;
1074         m->context = ts;
1075
1076         /* turn y+ off, x- on; we'll use formula #2 */
1077         if (ts->model == 7846) {
1078                 m++;
1079                 spi_message_init(m);
1080
1081                 x++;
1082                 packet->read_z1 = READ_Z1(vref);
1083                 x->tx_buf = &packet->read_z1;
1084                 x->len = 1;
1085                 spi_message_add_tail(x, m);
1086
1087                 x++;
1088                 x->rx_buf = &packet->tc.z1;
1089                 x->len = 2;
1090                 spi_message_add_tail(x, m);
1091
1092                 /* ... maybe discard first sample ... */
1093                 if (pdata->settle_delay_usecs) {
1094                         x->delay_usecs = pdata->settle_delay_usecs;
1095
1096                         x++;
1097                         x->tx_buf = &packet->read_z1;
1098                         x->len = 1;
1099                         spi_message_add_tail(x, m);
1100
1101                         x++;
1102                         x->rx_buf = &packet->tc.z1;
1103                         x->len = 2;
1104                         spi_message_add_tail(x, m);
1105                 }
1106
1107                 m->complete = ads7846_rx_val;
1108                 m->context = ts;
1109
1110                 m++;
1111                 spi_message_init(m);
1112
1113                 x++;
1114                 packet->read_z2 = READ_Z2(vref);
1115                 x->tx_buf = &packet->read_z2;
1116                 x->len = 1;
1117                 spi_message_add_tail(x, m);
1118
1119                 x++;
1120                 x->rx_buf = &packet->tc.z2;
1121                 x->len = 2;
1122                 spi_message_add_tail(x, m);
1123
1124                 /* ... maybe discard first sample ... */
1125                 if (pdata->settle_delay_usecs) {
1126                         x->delay_usecs = pdata->settle_delay_usecs;
1127
1128                         x++;
1129                         x->tx_buf = &packet->read_z2;
1130                         x->len = 1;
1131                         spi_message_add_tail(x, m);
1132
1133                         x++;
1134                         x->rx_buf = &packet->tc.z2;
1135                         x->len = 2;
1136                         spi_message_add_tail(x, m);
1137                 }
1138
1139                 m->complete = ads7846_rx_val;
1140                 m->context = ts;
1141         }
1142
1143         /* power down */
1144         m++;
1145         spi_message_init(m);
1146
1147         x++;
1148         packet->pwrdown = PWRDOWN;
1149         x->tx_buf = &packet->pwrdown;
1150         x->len = 1;
1151         spi_message_add_tail(x, m);
1152
1153         x++;
1154         x->rx_buf = &packet->dummy;
1155         x->len = 2;
1156         CS_CHANGE(*x);
1157         spi_message_add_tail(x, m);
1158
1159         m->complete = ads7846_rx;
1160         m->context = ts;
1161
1162         ts->last_msg = m;
1163
1164         ts->reg = regulator_get(&spi->dev, "vcc");
1165         if (IS_ERR(ts->reg)) {
1166                 dev_err(&spi->dev, "unable to get regulator: %ld\n",
1167                         PTR_ERR(ts->reg));
1168                 goto err_free_gpio;
1169         }
1170
1171         err = regulator_enable(ts->reg);
1172         if (err) {
1173                 dev_err(&spi->dev, "unable to enable regulator: %d\n", err);
1174                 goto err_put_regulator;
1175         }
1176
1177         if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
1178                         spi->dev.driver->name, ts)) {
1179                 dev_info(&spi->dev,
1180                         "trying pin change workaround on irq %d\n", spi->irq);
1181                 err = request_irq(spi->irq, ads7846_irq,
1182                                   IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
1183                                   spi->dev.driver->name, ts);
1184                 if (err) {
1185                         dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
1186                         goto err_disable_regulator;
1187                 }
1188         }
1189
1190         err = ads784x_hwmon_register(spi, ts);
1191         if (err)
1192                 goto err_free_irq;
1193
1194         dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
1195
1196         /* take a first sample, leaving nPENIRQ active and vREF off; avoid
1197          * the touchscreen, in case it's not connected.
1198          */
1199         (void) ads7846_read12_ser(&spi->dev,
1200                           READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
1201
1202         err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
1203         if (err)
1204                 goto err_remove_hwmon;
1205
1206         err = input_register_device(input_dev);
1207         if (err)
1208                 goto err_remove_attr_group;
1209
1210         device_init_wakeup(&spi->dev, pdata->wakeup);
1211
1212         return 0;
1213
1214  err_remove_attr_group:
1215         sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1216  err_remove_hwmon:
1217         ads784x_hwmon_unregister(spi, ts);
1218  err_free_irq:
1219         free_irq(spi->irq, ts);
1220  err_disable_regulator:
1221         regulator_disable(ts->reg);
1222  err_put_regulator:
1223         regulator_put(ts->reg);
1224  err_free_gpio:
1225         if (ts->gpio_pendown != -1)
1226                 gpio_free(ts->gpio_pendown);
1227  err_cleanup_filter:
1228         if (ts->filter_cleanup)
1229                 ts->filter_cleanup(ts->filter_data);
1230  err_free_mem:
1231         input_free_device(input_dev);
1232         kfree(packet);
1233         kfree(ts);
1234         return err;
1235 }
1236
1237 static int __devexit ads7846_remove(struct spi_device *spi)
1238 {
1239         struct ads7846          *ts = dev_get_drvdata(&spi->dev);
1240
1241         device_init_wakeup(&spi->dev, false);
1242
1243         ads784x_hwmon_unregister(spi, ts);
1244         input_unregister_device(ts->input);
1245
1246         ads7846_suspend(spi, PMSG_SUSPEND);
1247
1248         sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1249
1250         free_irq(ts->spi->irq, ts);
1251         /* suspend left the IRQ disabled */
1252         enable_irq(ts->spi->irq);
1253
1254         regulator_disable(ts->reg);
1255         regulator_put(ts->reg);
1256
1257         if (ts->gpio_pendown != -1)
1258                 gpio_free(ts->gpio_pendown);
1259
1260         if (ts->filter_cleanup)
1261                 ts->filter_cleanup(ts->filter_data);
1262
1263         kfree(ts->packet);
1264         kfree(ts);
1265
1266         dev_dbg(&spi->dev, "unregistered touchscreen\n");
1267         return 0;
1268 }
1269
1270 static struct spi_driver ads7846_driver = {
1271         .driver = {
1272                 .name   = "ads7846",
1273                 .bus    = &spi_bus_type,
1274                 .owner  = THIS_MODULE,
1275         },
1276         .probe          = ads7846_probe,
1277         .remove         = __devexit_p(ads7846_remove),
1278         .suspend        = ads7846_suspend,
1279         .resume         = ads7846_resume,
1280 };
1281
1282 static int __init ads7846_init(void)
1283 {
1284         return spi_register_driver(&ads7846_driver);
1285 }
1286 module_init(ads7846_init);
1287
1288 static void __exit ads7846_exit(void)
1289 {
1290         spi_unregister_driver(&ads7846_driver);
1291 }
1292 module_exit(ads7846_exit);
1293
1294 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1295 MODULE_LICENSE("GPL");
1296 MODULE_ALIAS("spi:ads7846");