Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6.git] / drivers / input / touchscreen / ad7879.c
1 /*
2  * Copyright (C) 2008-2009 Michael Hennerich, Analog Devices Inc.
3  *
4  * Description: AD7879/AD7889 based touchscreen, and GPIO driver
5  *              (I2C/SPI Interface)
6  *
7  * Bugs:        Enter bugs at http://blackfin.uclinux.org/
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, see the file COPYING, or write
21  * to the Free Software Foundation, Inc.,
22  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
23  *
24  * History:
25  * Copyright (c) 2005 David Brownell
26  * Copyright (c) 2006 Nokia Corporation
27  * Various changes: Imre Deak <imre.deak@nokia.com>
28  *
29  * Using code from:
30  *  - corgi_ts.c
31  *      Copyright (C) 2004-2005 Richard Purdie
32  *  - omap_ts.[hc], ads7846.h, ts_osk.c
33  *      Copyright (C) 2002 MontaVista Software
34  *      Copyright (C) 2004 Texas Instruments
35  *      Copyright (C) 2005 Dirk Behme
36  *  - ad7877.c
37  *      Copyright (C) 2006-2008 Analog Devices Inc.
38  */
39
40 #include <linux/device.h>
41 #include <linux/init.h>
42 #include <linux/delay.h>
43 #include <linux/input.h>
44 #include <linux/interrupt.h>
45 #include <linux/irq.h>
46 #include <linux/slab.h>
47 #include <linux/workqueue.h>
48 #include <linux/spi/spi.h>
49 #include <linux/i2c.h>
50 #include <linux/gpio.h>
51
52 #include <linux/spi/ad7879.h>
53
54 #define AD7879_REG_ZEROS                0
55 #define AD7879_REG_CTRL1                1
56 #define AD7879_REG_CTRL2                2
57 #define AD7879_REG_CTRL3                3
58 #define AD7879_REG_AUX1HIGH             4
59 #define AD7879_REG_AUX1LOW              5
60 #define AD7879_REG_TEMP1HIGH            6
61 #define AD7879_REG_TEMP1LOW             7
62 #define AD7879_REG_XPLUS                8
63 #define AD7879_REG_YPLUS                9
64 #define AD7879_REG_Z1                   10
65 #define AD7879_REG_Z2                   11
66 #define AD7879_REG_AUXVBAT              12
67 #define AD7879_REG_TEMP                 13
68 #define AD7879_REG_REVID                14
69
70 /* Control REG 1 */
71 #define AD7879_TMR(x)                   ((x & 0xFF) << 0)
72 #define AD7879_ACQ(x)                   ((x & 0x3) << 8)
73 #define AD7879_MODE_NOC                 (0 << 10)       /* Do not convert */
74 #define AD7879_MODE_SCC                 (1 << 10)       /* Single channel conversion */
75 #define AD7879_MODE_SEQ0                (2 << 10)       /* Sequence 0 in Slave Mode */
76 #define AD7879_MODE_SEQ1                (3 << 10)       /* Sequence 1 in Master Mode */
77 #define AD7879_MODE_INT                 (1 << 15)       /* PENIRQ disabled INT enabled */
78
79 /* Control REG 2 */
80 #define AD7879_FCD(x)                   ((x & 0x3) << 0)
81 #define AD7879_RESET                    (1 << 4)
82 #define AD7879_MFS(x)                   ((x & 0x3) << 5)
83 #define AD7879_AVG(x)                   ((x & 0x3) << 7)
84 #define AD7879_SER                      (1 << 9)        /* non-differential */
85 #define AD7879_DFR                      (0 << 9)        /* differential */
86 #define AD7879_GPIOPOL                  (1 << 10)
87 #define AD7879_GPIODIR                  (1 << 11)
88 #define AD7879_GPIO_DATA                (1 << 12)
89 #define AD7879_GPIO_EN                  (1 << 13)
90 #define AD7879_PM(x)                    ((x & 0x3) << 14)
91 #define AD7879_PM_SHUTDOWN              (0)
92 #define AD7879_PM_DYN                   (1)
93 #define AD7879_PM_FULLON                (2)
94
95 /* Control REG 3 */
96 #define AD7879_TEMPMASK_BIT             (1<<15)
97 #define AD7879_AUXVBATMASK_BIT          (1<<14)
98 #define AD7879_INTMODE_BIT              (1<<13)
99 #define AD7879_GPIOALERTMASK_BIT        (1<<12)
100 #define AD7879_AUXLOW_BIT               (1<<11)
101 #define AD7879_AUXHIGH_BIT              (1<<10)
102 #define AD7879_TEMPLOW_BIT              (1<<9)
103 #define AD7879_TEMPHIGH_BIT             (1<<8)
104 #define AD7879_YPLUS_BIT                (1<<7)
105 #define AD7879_XPLUS_BIT                (1<<6)
106 #define AD7879_Z1_BIT                   (1<<5)
107 #define AD7879_Z2_BIT                   (1<<4)
108 #define AD7879_AUX_BIT                  (1<<3)
109 #define AD7879_VBAT_BIT                 (1<<2)
110 #define AD7879_TEMP_BIT                 (1<<1)
111
112 enum {
113         AD7879_SEQ_XPOS  = 0,
114         AD7879_SEQ_YPOS  = 1,
115         AD7879_SEQ_Z1    = 2,
116         AD7879_SEQ_Z2    = 3,
117         AD7879_NR_SENSE  = 4,
118 };
119
120 #define MAX_12BIT                       ((1<<12)-1)
121 #define TS_PEN_UP_TIMEOUT               msecs_to_jiffies(50)
122
123 #if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
124 #define AD7879_DEVID            0x7A
125 typedef struct spi_device       bus_device;
126 #elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
127 #define AD7879_DEVID            0x79
128 typedef struct i2c_client       bus_device;
129 #endif
130
131 struct ad7879 {
132         bus_device              *bus;
133         struct input_dev        *input;
134         struct work_struct      work;
135         struct timer_list       timer;
136 #ifdef CONFIG_GPIOLIB
137         struct gpio_chip        gc;
138 #endif
139         struct mutex            mutex;
140         unsigned                disabled:1;     /* P: mutex */
141
142 #if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
143         struct spi_message      msg;
144         struct spi_transfer     xfer[AD7879_NR_SENSE + 1];
145         u16                     cmd;
146 #endif
147         u16                     conversion_data[AD7879_NR_SENSE];
148         char                    phys[32];
149         u8                      first_conversion_delay;
150         u8                      acquisition_time;
151         u8                      averaging;
152         u8                      pen_down_acc_interval;
153         u8                      median;
154         u16                     x_plate_ohms;
155         u16                     pressure_max;
156         u16                     cmd_crtl1;
157         u16                     cmd_crtl2;
158         u16                     cmd_crtl3;
159 };
160
161 static int ad7879_read(bus_device *, u8);
162 static int ad7879_write(bus_device *, u8, u16);
163 static void ad7879_collect(struct ad7879 *);
164
165 static void ad7879_report(struct ad7879 *ts)
166 {
167         struct input_dev *input_dev = ts->input;
168         unsigned Rt;
169         u16 x, y, z1, z2;
170
171         x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT;
172         y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT;
173         z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
174         z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;
175
176         /*
177          * The samples processed here are already preprocessed by the AD7879.
178          * The preprocessing function consists of a median and an averaging filter.
179          * The combination of these two techniques provides a robust solution,
180          * discarding the spurious noise in the signal and keeping only the data of interest.
181          * The size of both filters is programmable. (dev.platform_data, see linux/spi/ad7879.h)
182          * Other user-programmable conversion controls include variable acquisition time,
183          * and first conversion delay. Up to 16 averages can be taken per conversion.
184          */
185
186         if (likely(x && z1)) {
187                 /* compute touch pressure resistance using equation #1 */
188                 Rt = (z2 - z1) * x * ts->x_plate_ohms;
189                 Rt /= z1;
190                 Rt = (Rt + 2047) >> 12;
191
192                 input_report_abs(input_dev, ABS_X, x);
193                 input_report_abs(input_dev, ABS_Y, y);
194                 input_report_abs(input_dev, ABS_PRESSURE, Rt);
195                 input_sync(input_dev);
196         }
197 }
198
199 static void ad7879_work(struct work_struct *work)
200 {
201         struct ad7879 *ts = container_of(work, struct ad7879, work);
202
203         /* use keventd context to read the result registers */
204         ad7879_collect(ts);
205         ad7879_report(ts);
206         mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
207 }
208
209 static void ad7879_ts_event_release(struct ad7879 *ts)
210 {
211         struct input_dev *input_dev = ts->input;
212
213         input_report_abs(input_dev, ABS_PRESSURE, 0);
214         input_sync(input_dev);
215 }
216
217 static void ad7879_timer(unsigned long handle)
218 {
219         struct ad7879 *ts = (void *)handle;
220
221         ad7879_ts_event_release(ts);
222 }
223
224 static irqreturn_t ad7879_irq(int irq, void *handle)
225 {
226         struct ad7879 *ts = handle;
227
228         /* The repeated conversion sequencer controlled by TMR kicked off too fast.
229          * We ignore the last and process the sample sequence currently in the queue.
230          * It can't be older than 9.4ms
231          */
232
233         if (!work_pending(&ts->work))
234                 schedule_work(&ts->work);
235
236         return IRQ_HANDLED;
237 }
238
239 static void ad7879_setup(struct ad7879 *ts)
240 {
241         ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
242         ad7879_write(ts->bus, AD7879_REG_CTRL3, ts->cmd_crtl3);
243         ad7879_write(ts->bus, AD7879_REG_CTRL1, ts->cmd_crtl1);
244 }
245
246 static void ad7879_disable(struct ad7879 *ts)
247 {
248         mutex_lock(&ts->mutex);
249
250         if (!ts->disabled) {
251
252                 ts->disabled = 1;
253                 disable_irq(ts->bus->irq);
254
255                 cancel_work_sync(&ts->work);
256
257                 if (del_timer_sync(&ts->timer))
258                         ad7879_ts_event_release(ts);
259
260                 ad7879_write(ts->bus, AD7879_REG_CTRL2,
261                              AD7879_PM(AD7879_PM_SHUTDOWN));
262         }
263
264         mutex_unlock(&ts->mutex);
265 }
266
267 static void ad7879_enable(struct ad7879 *ts)
268 {
269         mutex_lock(&ts->mutex);
270
271         if (ts->disabled) {
272                 ad7879_setup(ts);
273                 ts->disabled = 0;
274                 enable_irq(ts->bus->irq);
275         }
276
277         mutex_unlock(&ts->mutex);
278 }
279
280 static ssize_t ad7879_disable_show(struct device *dev,
281                                      struct device_attribute *attr, char *buf)
282 {
283         struct ad7879 *ts = dev_get_drvdata(dev);
284
285         return sprintf(buf, "%u\n", ts->disabled);
286 }
287
288 static ssize_t ad7879_disable_store(struct device *dev,
289                                      struct device_attribute *attr,
290                                      const char *buf, size_t count)
291 {
292         struct ad7879 *ts = dev_get_drvdata(dev);
293         unsigned long val;
294         int error;
295
296         error = strict_strtoul(buf, 10, &val);
297         if (error)
298                 return error;
299
300         if (val)
301                 ad7879_disable(ts);
302         else
303                 ad7879_enable(ts);
304
305         return count;
306 }
307
308 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);
309
310 static struct attribute *ad7879_attributes[] = {
311         &dev_attr_disable.attr,
312         NULL
313 };
314
315 static const struct attribute_group ad7879_attr_group = {
316         .attrs = ad7879_attributes,
317 };
318
319 #ifdef CONFIG_GPIOLIB
320 static int ad7879_gpio_direction_input(struct gpio_chip *chip,
321                                         unsigned gpio)
322 {
323         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
324         int err;
325
326         mutex_lock(&ts->mutex);
327         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
328         err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
329         mutex_unlock(&ts->mutex);
330
331         return err;
332 }
333
334 static int ad7879_gpio_direction_output(struct gpio_chip *chip,
335                                         unsigned gpio, int level)
336 {
337         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
338         int err;
339
340         mutex_lock(&ts->mutex);
341         ts->cmd_crtl2 &= ~AD7879_GPIODIR;
342         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
343         if (level)
344                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
345         else
346                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
347
348         err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
349         mutex_unlock(&ts->mutex);
350
351         return err;
352 }
353
354 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
355 {
356         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
357         u16 val;
358
359         mutex_lock(&ts->mutex);
360         val = ad7879_read(ts->bus, AD7879_REG_CTRL2);
361         mutex_unlock(&ts->mutex);
362
363         return !!(val & AD7879_GPIO_DATA);
364 }
365
366 static void ad7879_gpio_set_value(struct gpio_chip *chip,
367                                   unsigned gpio, int value)
368 {
369         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
370
371         mutex_lock(&ts->mutex);
372         if (value)
373                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
374         else
375                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
376
377         ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
378         mutex_unlock(&ts->mutex);
379 }
380
381 static int __devinit ad7879_gpio_add(struct device *dev)
382 {
383         struct ad7879 *ts = dev_get_drvdata(dev);
384         struct ad7879_platform_data *pdata = dev->platform_data;
385         int ret = 0;
386
387         if (pdata->gpio_export) {
388                 ts->gc.direction_input = ad7879_gpio_direction_input;
389                 ts->gc.direction_output = ad7879_gpio_direction_output;
390                 ts->gc.get = ad7879_gpio_get_value;
391                 ts->gc.set = ad7879_gpio_set_value;
392                 ts->gc.can_sleep = 1;
393                 ts->gc.base = pdata->gpio_base;
394                 ts->gc.ngpio = 1;
395                 ts->gc.label = "AD7879-GPIO";
396                 ts->gc.owner = THIS_MODULE;
397                 ts->gc.dev = dev;
398
399                 ret = gpiochip_add(&ts->gc);
400                 if (ret)
401                         dev_err(dev, "failed to register gpio %d\n",
402                                 ts->gc.base);
403         }
404
405         return ret;
406 }
407
408 /*
409  * We mark ad7879_gpio_remove inline so there is a chance the code
410  * gets discarded when not needed. We can't do __devinit/__devexit
411  * markup since it is used in both probe and remove methods.
412  */
413 static inline void ad7879_gpio_remove(struct device *dev)
414 {
415         struct ad7879 *ts = dev_get_drvdata(dev);
416         struct ad7879_platform_data *pdata = dev->platform_data;
417         int ret;
418
419         if (pdata->gpio_export) {
420                 ret = gpiochip_remove(&ts->gc);
421                 if (ret)
422                         dev_err(dev, "failed to remove gpio %d\n",
423                                 ts->gc.base);
424         }
425 }
426 #else
427 static inline int ad7879_gpio_add(struct device *dev)
428 {
429         return 0;
430 }
431
432 static inline void ad7879_gpio_remove(struct device *dev)
433 {
434 }
435 #endif
436
437 static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
438 {
439         struct input_dev *input_dev;
440         struct ad7879_platform_data *pdata = bus->dev.platform_data;
441         int err;
442         u16 revid;
443
444         if (!bus->irq) {
445                 dev_err(&bus->dev, "no IRQ?\n");
446                 return -ENODEV;
447         }
448
449         if (!pdata) {
450                 dev_err(&bus->dev, "no platform data?\n");
451                 return -ENODEV;
452         }
453
454         input_dev = input_allocate_device();
455         if (!input_dev)
456                 return -ENOMEM;
457
458         ts->input = input_dev;
459
460         setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
461         INIT_WORK(&ts->work, ad7879_work);
462         mutex_init(&ts->mutex);
463
464         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
465         ts->pressure_max = pdata->pressure_max ? : ~0;
466
467         ts->first_conversion_delay = pdata->first_conversion_delay;
468         ts->acquisition_time = pdata->acquisition_time;
469         ts->averaging = pdata->averaging;
470         ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
471         ts->median = pdata->median;
472
473         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&bus->dev));
474
475         input_dev->name = "AD7879 Touchscreen";
476         input_dev->phys = ts->phys;
477         input_dev->dev.parent = &bus->dev;
478
479         __set_bit(EV_ABS, input_dev->evbit);
480         __set_bit(ABS_X, input_dev->absbit);
481         __set_bit(ABS_Y, input_dev->absbit);
482         __set_bit(ABS_PRESSURE, input_dev->absbit);
483
484         input_set_abs_params(input_dev, ABS_X,
485                         pdata->x_min ? : 0,
486                         pdata->x_max ? : MAX_12BIT,
487                         0, 0);
488         input_set_abs_params(input_dev, ABS_Y,
489                         pdata->y_min ? : 0,
490                         pdata->y_max ? : MAX_12BIT,
491                         0, 0);
492         input_set_abs_params(input_dev, ABS_PRESSURE,
493                         pdata->pressure_min, pdata->pressure_max, 0, 0);
494
495         err = ad7879_write(bus, AD7879_REG_CTRL2, AD7879_RESET);
496
497         if (err < 0) {
498                 dev_err(&bus->dev, "Failed to write %s\n", input_dev->name);
499                 goto err_free_mem;
500         }
501
502         revid = ad7879_read(bus, AD7879_REG_REVID);
503
504         if ((revid & 0xFF) != AD7879_DEVID) {
505                 dev_err(&bus->dev, "Failed to probe %s\n", input_dev->name);
506                 err = -ENODEV;
507                 goto err_free_mem;
508         }
509
510         ts->cmd_crtl3 = AD7879_YPLUS_BIT |
511                         AD7879_XPLUS_BIT |
512                         AD7879_Z2_BIT |
513                         AD7879_Z1_BIT |
514                         AD7879_TEMPMASK_BIT |
515                         AD7879_AUXVBATMASK_BIT |
516                         AD7879_GPIOALERTMASK_BIT;
517
518         ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
519                         AD7879_AVG(ts->averaging) |
520                         AD7879_MFS(ts->median) |
521                         AD7879_FCD(ts->first_conversion_delay);
522
523         ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
524                         AD7879_ACQ(ts->acquisition_time) |
525                         AD7879_TMR(ts->pen_down_acc_interval);
526
527         ad7879_setup(ts);
528
529         err = request_irq(bus->irq, ad7879_irq,
530                           IRQF_TRIGGER_FALLING, bus->dev.driver->name, ts);
531
532         if (err) {
533                 dev_err(&bus->dev, "irq %d busy?\n", bus->irq);
534                 goto err_free_mem;
535         }
536
537         err = sysfs_create_group(&bus->dev.kobj, &ad7879_attr_group);
538         if (err)
539                 goto err_free_irq;
540
541         err = ad7879_gpio_add(&bus->dev);
542         if (err)
543                 goto err_remove_attr;
544
545         err = input_register_device(input_dev);
546         if (err)
547                 goto err_remove_gpio;
548
549         dev_info(&bus->dev, "Rev.%d touchscreen, irq %d\n",
550                  revid >> 8, bus->irq);
551
552         return 0;
553
554 err_remove_gpio:
555         ad7879_gpio_remove(&bus->dev);
556 err_remove_attr:
557         sysfs_remove_group(&bus->dev.kobj, &ad7879_attr_group);
558 err_free_irq:
559         free_irq(bus->irq, ts);
560 err_free_mem:
561         input_free_device(input_dev);
562
563         return err;
564 }
565
566 static int __devexit ad7879_destroy(bus_device *bus, struct ad7879 *ts)
567 {
568         ad7879_gpio_remove(&bus->dev);
569         ad7879_disable(ts);
570         sysfs_remove_group(&ts->bus->dev.kobj, &ad7879_attr_group);
571         free_irq(ts->bus->irq, ts);
572         input_unregister_device(ts->input);
573         dev_dbg(&bus->dev, "unregistered touchscreen\n");
574
575         return 0;
576 }
577
578 #ifdef CONFIG_PM
579 static int ad7879_suspend(bus_device *bus, pm_message_t message)
580 {
581         struct ad7879 *ts = dev_get_drvdata(&bus->dev);
582
583         ad7879_disable(ts);
584
585         return 0;
586 }
587
588 static int ad7879_resume(bus_device *bus)
589 {
590         struct ad7879 *ts = dev_get_drvdata(&bus->dev);
591
592         ad7879_enable(ts);
593
594         return 0;
595 }
596 #else
597 #define ad7879_suspend NULL
598 #define ad7879_resume  NULL
599 #endif
600
601 #if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
602 #define MAX_SPI_FREQ_HZ         5000000
603 #define AD7879_CMD_MAGIC        0xE000
604 #define AD7879_CMD_READ         (1 << 10)
605 #define AD7879_WRITECMD(reg)    (AD7879_CMD_MAGIC | (reg & 0xF))
606 #define AD7879_READCMD(reg)     (AD7879_CMD_MAGIC | AD7879_CMD_READ | (reg & 0xF))
607
608 struct ser_req {
609         u16                     command;
610         u16                     data;
611         struct spi_message      msg;
612         struct spi_transfer     xfer[2];
613 };
614
615 /*
616  * ad7879_read/write are only used for initial setup and for sysfs controls.
617  * The main traffic is done in ad7879_collect().
618  */
619
620 static int ad7879_read(struct spi_device *spi, u8 reg)
621 {
622         struct ser_req *req;
623         int status, ret;
624
625         req = kzalloc(sizeof *req, GFP_KERNEL);
626         if (!req)
627                 return -ENOMEM;
628
629         spi_message_init(&req->msg);
630
631         req->command = (u16) AD7879_READCMD(reg);
632         req->xfer[0].tx_buf = &req->command;
633         req->xfer[0].len = 2;
634
635         req->xfer[1].rx_buf = &req->data;
636         req->xfer[1].len = 2;
637
638         spi_message_add_tail(&req->xfer[0], &req->msg);
639         spi_message_add_tail(&req->xfer[1], &req->msg);
640
641         status = spi_sync(spi, &req->msg);
642         ret = status ? : req->data;
643
644         kfree(req);
645
646         return ret;
647 }
648
649 static int ad7879_write(struct spi_device *spi, u8 reg, u16 val)
650 {
651         struct ser_req *req;
652         int status;
653
654         req = kzalloc(sizeof *req, GFP_KERNEL);
655         if (!req)
656                 return -ENOMEM;
657
658         spi_message_init(&req->msg);
659
660         req->command = (u16) AD7879_WRITECMD(reg);
661         req->xfer[0].tx_buf = &req->command;
662         req->xfer[0].len = 2;
663
664         req->data = val;
665         req->xfer[1].tx_buf = &req->data;
666         req->xfer[1].len = 2;
667
668         spi_message_add_tail(&req->xfer[0], &req->msg);
669         spi_message_add_tail(&req->xfer[1], &req->msg);
670
671         status = spi_sync(spi, &req->msg);
672
673         kfree(req);
674
675         return status;
676 }
677
678 static void ad7879_collect(struct ad7879 *ts)
679 {
680         int status = spi_sync(ts->bus, &ts->msg);
681
682         if (status)
683                 dev_err(&ts->bus->dev, "spi_sync --> %d\n", status);
684 }
685
686 static void ad7879_setup_ts_def_msg(struct ad7879 *ts)
687 {
688         struct spi_message *m;
689         int i;
690
691         ts->cmd = (u16) AD7879_READCMD(AD7879_REG_XPLUS);
692
693         m = &ts->msg;
694         spi_message_init(m);
695         ts->xfer[0].tx_buf = &ts->cmd;
696         ts->xfer[0].len = 2;
697
698         spi_message_add_tail(&ts->xfer[0], m);
699
700         for (i = 0; i < AD7879_NR_SENSE; i++) {
701                 ts->xfer[i + 1].rx_buf = &ts->conversion_data[i];
702                 ts->xfer[i + 1].len = 2;
703                 spi_message_add_tail(&ts->xfer[i + 1], m);
704         }
705 }
706
707 static int __devinit ad7879_probe(struct spi_device *spi)
708 {
709         struct ad7879 *ts;
710         int error;
711
712         /* don't exceed max specified SPI CLK frequency */
713         if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
714                 dev_err(&spi->dev, "SPI CLK %d Hz?\n", spi->max_speed_hz);
715                 return -EINVAL;
716         }
717
718         ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
719         if (!ts)
720                 return -ENOMEM;
721
722         dev_set_drvdata(&spi->dev, ts);
723         ts->bus = spi;
724
725         ad7879_setup_ts_def_msg(ts);
726
727         error = ad7879_construct(spi, ts);
728         if (error) {
729                 dev_set_drvdata(&spi->dev, NULL);
730                 kfree(ts);
731         }
732
733         return error;
734 }
735
736 static int __devexit ad7879_remove(struct spi_device *spi)
737 {
738         struct ad7879 *ts = dev_get_drvdata(&spi->dev);
739
740         ad7879_destroy(spi, ts);
741         dev_set_drvdata(&spi->dev, NULL);
742         kfree(ts);
743
744         return 0;
745 }
746
747 static struct spi_driver ad7879_driver = {
748         .driver = {
749                 .name   = "ad7879",
750                 .bus    = &spi_bus_type,
751                 .owner  = THIS_MODULE,
752         },
753         .probe          = ad7879_probe,
754         .remove         = __devexit_p(ad7879_remove),
755         .suspend        = ad7879_suspend,
756         .resume         = ad7879_resume,
757 };
758
759 static int __init ad7879_init(void)
760 {
761         return spi_register_driver(&ad7879_driver);
762 }
763 module_init(ad7879_init);
764
765 static void __exit ad7879_exit(void)
766 {
767         spi_unregister_driver(&ad7879_driver);
768 }
769 module_exit(ad7879_exit);
770
771 #elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
772
773 /* All registers are word-sized.
774  * AD7879 uses a high-byte first convention.
775  */
776 static int ad7879_read(struct i2c_client *client, u8 reg)
777 {
778         return swab16(i2c_smbus_read_word_data(client, reg));
779 }
780
781 static int ad7879_write(struct i2c_client *client, u8 reg, u16 val)
782 {
783         return i2c_smbus_write_word_data(client, reg, swab16(val));
784 }
785
786 static void ad7879_collect(struct ad7879 *ts)
787 {
788         int i;
789
790         for (i = 0; i < AD7879_NR_SENSE; i++)
791                 ts->conversion_data[i] = ad7879_read(ts->bus,
792                                                      AD7879_REG_XPLUS + i);
793 }
794
795 static int __devinit ad7879_probe(struct i2c_client *client,
796                                         const struct i2c_device_id *id)
797 {
798         struct ad7879 *ts;
799         int error;
800
801         if (!i2c_check_functionality(client->adapter,
802                                         I2C_FUNC_SMBUS_WORD_DATA)) {
803                 dev_err(&client->dev, "SMBUS Word Data not Supported\n");
804                 return -EIO;
805         }
806
807         ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
808         if (!ts)
809                 return -ENOMEM;
810
811         i2c_set_clientdata(client, ts);
812         ts->bus = client;
813
814         error = ad7879_construct(client, ts);
815         if (error) {
816                 i2c_set_clientdata(client, NULL);
817                 kfree(ts);
818         }
819
820         return error;
821 }
822
823 static int __devexit ad7879_remove(struct i2c_client *client)
824 {
825         struct ad7879 *ts = dev_get_drvdata(&client->dev);
826
827         ad7879_destroy(client, ts);
828         i2c_set_clientdata(client, NULL);
829         kfree(ts);
830
831         return 0;
832 }
833
834 static const struct i2c_device_id ad7879_id[] = {
835         { "ad7879", 0 },
836         { "ad7889", 0 },
837         { }
838 };
839 MODULE_DEVICE_TABLE(i2c, ad7879_id);
840
841 static struct i2c_driver ad7879_driver = {
842         .driver = {
843                 .name   = "ad7879",
844                 .owner  = THIS_MODULE,
845         },
846         .probe          = ad7879_probe,
847         .remove         = __devexit_p(ad7879_remove),
848         .suspend        = ad7879_suspend,
849         .resume         = ad7879_resume,
850         .id_table       = ad7879_id,
851 };
852
853 static int __init ad7879_init(void)
854 {
855         return i2c_add_driver(&ad7879_driver);
856 }
857 module_init(ad7879_init);
858
859 static void __exit ad7879_exit(void)
860 {
861         i2c_del_driver(&ad7879_driver);
862 }
863 module_exit(ad7879_exit);
864 #endif
865
866 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
867 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
868 MODULE_LICENSE("GPL");
869 MODULE_ALIAS("spi:ad7879");