← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/input/touchscreen/tsc2005.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

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