drivers/input/touchscreen/tsc2005.c

   1 /*
   2  * TSC2005 touchscreen driver
   3  *
   4  * Copyright (C) 2006-2008 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/gpio.h>
  31 #include <linux/spi/spi.h>
  32
  33 #include <linux/spi/tsc2005.h>
  34
  35 /**
  36  * The touchscreen interface operates as follows:
  37  *
  38  * Initialize:
  39  *    Request access to GPIO103 (DAV)
  40  *    tsc2005_dav_irq_handler will trigger when DAV line goes down
  41  *
  42  *  1) Pen is pressed against touchscreeen
  43  *  2) TSC2005 performs AD conversion
  44  *  3) After the conversion is done TSC2005 drives DAV line down
  45  *  4) GPIO IRQ is received and tsc2005_dav_irq_handler is called
  46  *  5) tsc2005_ts_irq_handler queues up an spi transfer to fetch
  47  *     the x, y, z1, z2 values
  48  *  6) tsc2005_ts_rx() reports coordinates to input layer and
  49  *     sets up tsc2005_ts_timer() to be called after TSC2005_TS_SCAN_TIME
  50  *  7)  When the penup_timer expires, there have not been DAV interrupts
  51  *     during the last 20ms which means the pen has been lifted.
  52  */
  53
  54 #define TSC2005_VDD_LOWER_27
  55
  56 #ifdef TSC2005_VDD_LOWER_27
  57 #define TSC2005_HZ     (10000000)
  58 #else
  59 #define TSC2005_HZ     (25000000)
  60 #endif
  61
  62 #define TSC2005_CMD     (0x80)
  63 #define TSC2005_REG     (0x00)
  64
  65 #define TSC2005_CMD_STOP        (1)
  66 #define TSC2005_CMD_10BIT       (0 << 2)
  67 #define TSC2005_CMD_12BIT       (1 << 2)
  68
  69 #define TSC2005_CMD_SCAN_XYZZ   (0 << 3)
  70 #define TSC2005_CMD_SCAN_XY     (1 << 3)
  71 #define TSC2005_CMD_SCAN_X      (2 << 3)
  72 #define TSC2005_CMD_SCAN_Y      (3 << 3)
  73 #define TSC2005_CMD_SCAN_ZZ     (4 << 3)
  74 #define TSC2005_CMD_AUX_SINGLE  (5 << 3)
  75 #define TSC2005_CMD_TEMP1       (6 << 3)
  76 #define TSC2005_CMD_TEMP2       (7 << 3)
  77 #define TSC2005_CMD_AUX_CONT    (8 << 3)
  78 #define TSC2005_CMD_TEST_X_CONN (9 << 3)
  79 #define TSC2005_CMD_TEST_Y_CONN (10 << 3)
  80 /* command 11 reserved */
  81 #define TSC2005_CMD_TEST_SHORT  (12 << 3)
  82 #define TSC2005_CMD_DRIVE_XX    (13 << 3)
  83 #define TSC2005_CMD_DRIVE_YY    (14 << 3)
  84 #define TSC2005_CMD_DRIVE_YX    (15 << 3)
  85
  86 #define TSC2005_REG_X           (0 << 3)
  87 #define TSC2005_REG_Y           (1 << 3)
  88 #define TSC2005_REG_Z1          (2 << 3)
  89 #define TSC2005_REG_Z2          (3 << 3)
  90 #define TSC2005_REG_AUX         (4 << 3)
  91 #define TSC2005_REG_TEMP1       (5 << 3)
  92 #define TSC2005_REG_TEMP2       (6 << 3)
  93 #define TSC2005_REG_STATUS      (7 << 3)
  94 #define TSC2005_REG_AUX_HIGH    (8 << 3)
  95 #define TSC2005_REG_AUX_LOW     (9 << 3)
  96 #define TSC2005_REG_TEMP_HIGH   (10 << 3)
  97 #define TSC2005_REG_TEMP_LOW    (11 << 3)
  98 #define TSC2005_REG_CFR0        (12 << 3)
  99 #define TSC2005_REG_CFR1        (13 << 3)
 100 #define TSC2005_REG_CFR2        (14 << 3)
 101 #define TSC2005_REG_FUNCTION    (15 << 3)
 102
 103 #define TSC2005_REG_PND0        (1 << 1)
 104 #define TSC2005_REG_READ        (0x01)
 105 #define TSC2005_REG_WRITE       (0x00)
 106
 107
 108 #define TSC2005_CFR0_LONGSAMPLING       (1)
 109 #define TSC2005_CFR0_DETECTINWAIT       (1 << 1)
 110 #define TSC2005_CFR0_SENSETIME_32US     (0)
 111 #define TSC2005_CFR0_SENSETIME_96US     (1 << 2)
 112 #define TSC2005_CFR0_SENSETIME_544US    (1 << 3)
 113 #define TSC2005_CFR0_SENSETIME_2080US   (1 << 4)
 114 #define TSC2005_CFR0_SENSETIME_2656US   (0x001C)
 115 #define TSC2005_CFR0_PRECHARGE_20US     (0x0000)
 116 #define TSC2005_CFR0_PRECHARGE_84US     (0x0020)
 117 #define TSC2005_CFR0_PRECHARGE_276US    (0x0040)
 118 #define TSC2005_CFR0_PRECHARGE_1044US   (0x0080)
 119 #define TSC2005_CFR0_PRECHARGE_1364US   (0x00E0)
 120 #define TSC2005_CFR0_STABTIME_0US       (0x0000)
 121 #define TSC2005_CFR0_STABTIME_100US     (0x0100)
 122 #define TSC2005_CFR0_STABTIME_500US     (0x0200)
 123 #define TSC2005_CFR0_STABTIME_1MS       (0x0300)
 124 #define TSC2005_CFR0_STABTIME_5MS       (0x0400)
 125 #define TSC2005_CFR0_STABTIME_100MS     (0x0700)
 126 #define TSC2005_CFR0_CLOCK_4MHZ         (0x0000)
 127 #define TSC2005_CFR0_CLOCK_2MHZ         (0x0800)
 128 #define TSC2005_CFR0_CLOCK_1MHZ         (0x1000)
 129 #define TSC2005_CFR0_RESOLUTION12       (0x2000)
 130 #define TSC2005_CFR0_STATUS             (0x4000)
 131 #define TSC2005_CFR0_PENMODE            (0x8000)
 132
 133 #define TSC2005_CFR0_INITVALUE  (TSC2005_CFR0_STABTIME_1MS  |   \
 134                                  TSC2005_CFR0_CLOCK_1MHZ    |   \
 135                                  TSC2005_CFR0_RESOLUTION12  |   \
 136                                  TSC2005_CFR0_PRECHARGE_276US | \
 137                                  TSC2005_CFR0_PENMODE)
 138
 139 #define TSC2005_CFR1_BATCHDELAY_0MS     (0x0000)
 140 #define TSC2005_CFR1_BATCHDELAY_1MS     (0x0001)
 141 #define TSC2005_CFR1_BATCHDELAY_2MS     (0x0002)
 142 #define TSC2005_CFR1_BATCHDELAY_4MS     (0x0003)
 143 #define TSC2005_CFR1_BATCHDELAY_10MS    (0x0004)
 144 #define TSC2005_CFR1_BATCHDELAY_20MS    (0x0005)
 145 #define TSC2005_CFR1_BATCHDELAY_40MS    (0x0006)
 146 #define TSC2005_CFR1_BATCHDELAY_100MS   (0x0007)
 147
 148 #define TSC2005_CFR1_INITVALUE  (TSC2005_CFR1_BATCHDELAY_2MS)
 149
 150 #define TSC2005_CFR2_MAVE_TEMP  (0x0001)
 151 #define TSC2005_CFR2_MAVE_AUX   (0x0002)
 152 #define TSC2005_CFR2_MAVE_Z     (0x0004)
 153 #define TSC2005_CFR2_MAVE_Y     (0x0008)
 154 #define TSC2005_CFR2_MAVE_X     (0x0010)
 155 #define TSC2005_CFR2_AVG_1      (0x0000)
 156 #define TSC2005_CFR2_AVG_3      (0x0400)
 157 #define TSC2005_CFR2_AVG_7      (0x0800)
 158 #define TSC2005_CFR2_MEDIUM_1   (0x0000)
 159 #define TSC2005_CFR2_MEDIUM_3   (0x1000)
 160 #define TSC2005_CFR2_MEDIUM_7   (0x2000)
 161 #define TSC2005_CFR2_MEDIUM_15  (0x3000)
 162
 163 #define TSC2005_CFR2_IRQ_DAV    (0x4000)
 164 #define TSC2005_CFR2_IRQ_PEN    (0x8000)
 165 #define TSC2005_CFR2_IRQ_PENDAV (0x0000)
 166
 167 #define TSC2005_CFR2_INITVALUE  (TSC2005_CFR2_IRQ_DAV   |       \
 168                                  TSC2005_CFR2_MAVE_X    |       \
 169                                  TSC2005_CFR2_MAVE_Y    |       \
 170                                  TSC2005_CFR2_MAVE_Z    |       \
 171                                  TSC2005_CFR2_MEDIUM_15 |       \
 172                                  TSC2005_CFR2_AVG_7)
 173
 174 #define MAX_12BIT                                       ((1 << 12) - 1)
 175 #define TS_SAMPLES                                      4
 176 #define TS_RECT_SIZE                                    8
 177 #define TSC2005_TS_PENUP_TIME                           20
 178
 179 static const u32 tsc2005_read_reg[] = {
 180         (TSC2005_REG | TSC2005_REG_X | TSC2005_REG_READ) << 16,
 181         (TSC2005_REG | TSC2005_REG_Y | TSC2005_REG_READ) << 16,
 182         (TSC2005_REG | TSC2005_REG_Z1 | TSC2005_REG_READ) << 16,
 183         (TSC2005_REG | TSC2005_REG_Z2 | TSC2005_REG_READ) << 16,
 184 };
 185 #define NUM_READ_REGS   (sizeof(tsc2005_read_reg)/sizeof(tsc2005_read_reg[0]))
 186
 187 struct tsc2005 {
 188         struct spi_device       *spi;
 189
 190         struct input_dev        *idev;
 191         char                    phys[32];
 192         struct timer_list       penup_timer;
 193         spinlock_t              lock;
 194         struct mutex            mutex;
 195
 196         struct spi_message      read_msg;
 197         struct spi_transfer     read_xfer[NUM_READ_REGS];
 198         u32                     data[NUM_READ_REGS];
 199
 200         /* previous x,y,z */
 201         int                     x;
 202         int                     y;
 203         int                     p;
 204         /* average accumulators for each component */
 205         int                     sample_cnt;
 206         int                     avg_x;
 207         int                     avg_y;
 208         int                     avg_z1;
 209         int                     avg_z2;
 210         /* configuration */
 211         int                     x_plate_ohm;
 212         int                     hw_avg_max;
 213         int                     stab_time;
 214         int                     p_max;
 215         int                     touch_pressure;
 216         int                     irq;
 217         s16                     dav_gpio;
 218         /* status */
 219         u8                      sample_sent;
 220         u8                      pen_down;
 221         u8                      disabled;
 222         u8                      disable_depth;
 223         u8                      spi_active;
 224 };
 225
 226 static void tsc2005_cmd(struct tsc2005 *ts, u8 cmd)
 227 {
 228         u16 data = TSC2005_CMD | TSC2005_CMD_12BIT | cmd;
 229         struct spi_message msg;
 230         struct spi_transfer xfer = { 0 };
 231
 232         xfer.tx_buf = &data;
 233         xfer.rx_buf = NULL;
 234         xfer.len = 1;
 235         xfer.bits_per_word = 8;
 236
 237         spi_message_init(&msg);
 238         spi_message_add_tail(&xfer, &msg);
 239         spi_sync(ts->spi, &msg);
 240 }
 241
 242 static void tsc2005_write(struct tsc2005 *ts, u8 reg, u16 value)
 243 {
 244         u32 tx;
 245         struct spi_message msg;
 246         struct spi_transfer xfer = { 0 };
 247
 248         tx = (TSC2005_REG | reg | TSC2005_REG_PND0 |
 249                TSC2005_REG_WRITE) << 16;
 250         tx |= value;
 251
 252         xfer.tx_buf = &tx;
 253         xfer.rx_buf = NULL;
 254         xfer.len = 4;
 255         xfer.bits_per_word = 24;
 256
 257         spi_message_init(&msg);
 258         spi_message_add_tail(&xfer, &msg);
 259         spi_sync(ts->spi, &msg);
 260 }
 261
 262 static void tsc2005_ts_update_pen_state(struct tsc2005 *ts,
 263                                         int x, int y, int pressure)
 264 {
 265         if (pressure) {
 266                 input_report_abs(ts->idev, ABS_X, x);
 267                 input_report_abs(ts->idev, ABS_Y, y);
 268                 input_report_abs(ts->idev, ABS_PRESSURE, pressure);
 269                 if (!ts->pen_down) {
 270                         input_report_key(ts->idev, BTN_TOUCH, 1);
 271                         ts->pen_down = 1;
 272                 }
 273         } else {
 274                 input_report_abs(ts->idev, ABS_PRESSURE, 0);
 275                 if (ts->pen_down) {
 276                         input_report_key(ts->idev, BTN_TOUCH, 0);
 277                         ts->pen_down = 0;
 278                 }
 279         }
 280
 281         input_sync(ts->idev);
 282 }
 283
 284 /*
 285  * This function is called by the SPI framework after the coordinates
 286  * have been read from TSC2005
 287  */
 288 static void tsc2005_ts_rx(void *arg)
 289 {
 290         struct tsc2005 *ts = arg;
 291         unsigned long flags;
 292         int inside_rect, pressure_limit;
 293         int x, y, z1, z2, pressure;
 294
 295         spin_lock_irqsave(&ts->lock, flags);
 296
 297         x = ts->data[0];
 298         y = ts->data[1];
 299         z1 = ts->data[2];
 300         z2 = ts->data[3];
 301
 302         /* validate pressure and position */
 303         if (x > MAX_12BIT || y > MAX_12BIT)
 304                 goto out;
 305
 306         /* skip coords if the pressure-components are out of range */
 307         if (z1 < 100 || z2 > 4000)
 308                 goto out;
 309
 310         /* don't run average on the "pen down" event */
 311         if (ts->sample_sent) {
 312                 ts->avg_x += x;
 313                 ts->avg_y += y;
 314                 ts->avg_z1 += z1;
 315                 ts->avg_z2 += z2;
 316
 317                 if (++ts->sample_cnt < TS_SAMPLES)
 318                         goto out;
 319
 320                 x = ts->avg_x / TS_SAMPLES;
 321                 y = ts->avg_y / TS_SAMPLES;
 322                 z1 = ts->avg_z1 / TS_SAMPLES;
 323                 z2 = ts->avg_z2 / TS_SAMPLES;
 324         }
 325
 326         ts->sample_cnt = 0;
 327         ts->avg_x = 0;
 328         ts->avg_y = 0;
 329         ts->avg_z1 = 0;
 330         ts->avg_z2 = 0;
 331
 332         if (z1) {
 333                 pressure = x * (z2 - z1) / z1;
 334                 pressure = pressure * ts->x_plate_ohm / 4096;
 335         } else
 336                 goto out;
 337
 338         pressure_limit = ts->sample_sent? ts->p_max: ts->touch_pressure;
 339         if (pressure > pressure_limit)
 340                 goto out;
 341
 342         /* discard the event if it still is within the previous rect - unless
 343          * if the pressure is harder, but then use previous x,y position */
 344         inside_rect = (ts->sample_sent &&
 345                 x > (int)ts->x - TS_RECT_SIZE &&
 346                 x < (int)ts->x + TS_RECT_SIZE &&
 347                 y > (int)ts->y - TS_RECT_SIZE &&
 348                 y < (int)ts->y + TS_RECT_SIZE);
 349         if (inside_rect)
 350                 x = ts->x, y = ts->y;
 351
 352         if (!inside_rect || pressure < ts->p) {
 353                 tsc2005_ts_update_pen_state(ts, x, y, pressure);
 354                 ts->sample_sent = 1;
 355                 ts->x = x;
 356                 ts->y = y;
 357                 ts->p = pressure;
 358         }
 359 out:
 360         ts->spi_active = 0;
 361         spin_unlock_irqrestore(&ts->lock, flags);
 362
 363         /* kick pen up timer - to make sure it expires again(!) */
 364         if (ts->sample_sent)
 365                 mod_timer(&ts->penup_timer,
 366                           jiffies + msecs_to_jiffies(TSC2005_TS_PENUP_TIME));
 367 }
 368
 369 static void tsc2005_ts_penup_timer_handler(unsigned long data)
 370 {
 371         struct tsc2005 *ts = (struct tsc2005 *)data;
 372
 373         if (ts->sample_sent) {
 374                 tsc2005_ts_update_pen_state(ts, 0, 0, 0);
 375                 ts->sample_sent = 0;
 376         }
 377 }
 378
 379 /*
 380  * This interrupt is called when pen is down and coordinates are
 381  * available. That is indicated by a falling edge on DAV line.
 382  */
 383 static irqreturn_t tsc2005_ts_irq_handler(int irq, void *dev_id)
 384 {
 385         struct tsc2005 *ts = dev_id;
 386         int r;
 387
 388         if (ts->spi_active)
 389                 return IRQ_HANDLED;
 390
 391         ts->spi_active = 1;
 392         r = spi_async(ts->spi, &ts->read_msg);
 393         if (r)
 394                 dev_err(&ts->spi->dev, "ts: spi_async() failed");
 395
 396         /* kick pen up timer */
 397         mod_timer(&ts->penup_timer,
 398                   jiffies + msecs_to_jiffies(TSC2005_TS_PENUP_TIME));
 399
 400         return IRQ_HANDLED;
 401 }
 402
 403 static void tsc2005_ts_setup_spi_xfer(struct tsc2005 *ts)
 404 {
 405         struct spi_message *m = &ts->read_msg;
 406         struct spi_transfer *x = &ts->read_xfer[0];
 407         int i;
 408
 409         spi_message_init(m);
 410
 411         for (i = 0; i < NUM_READ_REGS; i++, x++) {
 412                 x->tx_buf = &tsc2005_read_reg[i];
 413                 x->rx_buf = &ts->data[i];
 414                 x->len = 4;
 415                 x->bits_per_word = 24;
 416                 x->cs_change = i < (NUM_READ_REGS - 1);
 417                 spi_message_add_tail(x, m);
 418         }
 419
 420         m->complete = tsc2005_ts_rx;
 421         m->context = ts;
 422 }
 423
 424 static ssize_t tsc2005_ts_pen_down_show(struct device *dev,
 425                                         struct device_attribute *attr,
 426                                         char *buf)
 427 {
 428         struct tsc2005 *tsc = dev_get_drvdata(dev);
 429
 430         return sprintf(buf, "%u\n", tsc->pen_down);
 431 }
 432
 433 static DEVICE_ATTR(pen_down, S_IRUGO, tsc2005_ts_pen_down_show, NULL);
 434
 435 static int tsc2005_configure(struct tsc2005 *tsc, int flags)
 436 {
 437         tsc2005_write(tsc, TSC2005_REG_CFR0, TSC2005_CFR0_INITVALUE);
 438         tsc2005_write(tsc, TSC2005_REG_CFR1, TSC2005_CFR1_INITVALUE);
 439         tsc2005_write(tsc, TSC2005_REG_CFR2, TSC2005_CFR2_INITVALUE);
 440         tsc2005_cmd(tsc, flags);
 441
 442         return 0;
 443 }
 444
 445 static void tsc2005_start_scan(struct tsc2005 *tsc)
 446 {
 447         tsc2005_configure(tsc, TSC2005_CMD_SCAN_XYZZ);
 448 }
 449
 450 static void tsc2005_stop_scan(struct tsc2005 *tsc)
 451 {
 452         tsc2005_cmd(tsc, TSC2005_CMD_STOP);
 453 }
 454
 455 /* Must be called with mutex held */
 456 static void tsc2005_disable(struct tsc2005 *ts)
 457 {
 458         if (ts->disable_depth++ != 0)
 459                 return;
 460
 461         disable_irq(ts->irq);
 462
 463         /* wait until penup timer expire normally */
 464         do {
 465                 msleep(4);
 466         } while (ts->sample_sent);
 467
 468         tsc2005_stop_scan(ts);
 469 }
 470
 471 static void tsc2005_enable(struct tsc2005 *ts)
 472 {
 473         if (--ts->disable_depth != 0)
 474                 return;
 475
 476         enable_irq(ts->irq);
 477
 478         tsc2005_start_scan(ts);
 479 }
 480
 481 static ssize_t tsc2005_disable_show(struct device *dev,
 482                                     struct device_attribute *attr, char *buf)
 483 {
 484         struct tsc2005 *ts = dev_get_drvdata(dev);
 485
 486         return sprintf(buf, "%u\n", ts->disabled);
 487 }
 488
 489 static ssize_t tsc2005_disable_store(struct device *dev,
 490                                      struct device_attribute *attr,
 491                                      const char *buf, size_t count)
 492 {
 493         struct tsc2005          *tsc = dev_get_drvdata(dev);
 494         unsigned long res;
 495         int i;
 496
 497         i = strict_strtoul(buf, 10, &res);
 498         i = i ? 1 : 0;
 499
 500         mutex_lock(&tsc->mutex);
 501         if (i == tsc->disabled)
 502                 goto out;
 503         tsc->disabled = i;
 504
 505         if (i)
 506                 tsc2005_disable(tsc);
 507         else
 508                 tsc2005_enable(tsc);
 509 out:
 510         mutex_unlock(&tsc->mutex);
 511         return count;
 512 }
 513
 514 static DEVICE_ATTR(disable_ts, 0664, tsc2005_disable_show,
 515                    tsc2005_disable_store);
 516
 517
 518 static int __devinit tsc2005_ts_init(struct tsc2005 *ts,
 519                                      struct tsc2005_platform_data *pdata)
 520 {
 521         struct input_dev *idev;
 522         int dav_gpio, r;
 523         int x_max, y_max;
 524         int x_fudge, y_fudge, p_fudge;
 525
 526         if (pdata->dav_gpio < 0) {
 527                 dev_err(&ts->spi->dev, "need DAV GPIO");
 528                 return -EINVAL;
 529         }
 530         dav_gpio = pdata->dav_gpio;
 531         ts->dav_gpio = dav_gpio;
 532         dev_dbg(&ts->spi->dev, "TSC2005: DAV GPIO = %d\n", dav_gpio);
 533
 534         r = gpio_request(dav_gpio, "TSC2005 dav");
 535         if (r < 0) {
 536                 dev_err(&ts->spi->dev, "unable to get DAV GPIO");
 537                 goto err1;
 538         }
 539         gpio_direction_input(dav_gpio);
 540         ts->irq = gpio_to_irq(dav_gpio);
 541         dev_dbg(&ts->spi->dev, "TSC2005: DAV IRQ = %d\n", ts->irq);
 542
 543         init_timer(&ts->penup_timer);
 544         setup_timer(&ts->penup_timer, tsc2005_ts_penup_timer_handler,
 545                         (unsigned long)ts);
 546
 547         spin_lock_init(&ts->lock);
 548         mutex_init(&ts->mutex);
 549
 550         ts->x_plate_ohm         = pdata->ts_x_plate_ohm ? : 280;
 551         ts->hw_avg_max          = pdata->ts_hw_avg;
 552         ts->stab_time           = pdata->ts_stab_time;
 553         x_max                   = pdata->ts_x_max ? : 4096;
 554         x_fudge                 = pdata->ts_x_fudge ? : 4;
 555         y_max                   = pdata->ts_y_max ? : 4096;
 556         y_fudge                 = pdata->ts_y_fudge ? : 8;
 557         ts->p_max               = pdata->ts_pressure_max ? : MAX_12BIT;
 558         ts->touch_pressure      = pdata->ts_touch_pressure ? : ts->p_max;
 559         p_fudge                 = pdata->ts_pressure_fudge ? : 2;
 560
 561         idev = input_allocate_device();
 562         if (idev == NULL) {
 563                 r = -ENOMEM;
 564                 goto err2;
 565         }
 566
 567         idev->name = "TSC2005 touchscreen";
 568         snprintf(ts->phys, sizeof(ts->phys), "%s/input-ts",
 569                  dev_name(&ts->spi->dev));
 570         idev->phys = ts->phys;
 571
 572         idev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
 573         idev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
 574         ts->idev = idev;
 575
 576         tsc2005_ts_setup_spi_xfer(ts);
 577
 578         input_set_abs_params(idev, ABS_X, 0, x_max, x_fudge, 0);
 579         input_set_abs_params(idev, ABS_Y, 0, y_max, y_fudge, 0);
 580         input_set_abs_params(idev, ABS_PRESSURE, 0, ts->p_max, p_fudge, 0);
 581
 582         tsc2005_start_scan(ts);
 583
 584         r = request_irq(ts->irq, tsc2005_ts_irq_handler,
 585                         IRQF_TRIGGER_FALLING | IRQF_DISABLED |
 586                         IRQF_SAMPLE_RANDOM, "tsc2005", ts);
 587         if (r < 0) {
 588                 dev_err(&ts->spi->dev, "unable to get DAV IRQ");
 589                 goto err3;
 590         }
 591
 592         set_irq_wake(ts->irq, 1);
 593
 594         r = input_register_device(idev);
 595         if (r < 0) {
 596                 dev_err(&ts->spi->dev, "can't register touchscreen device\n");
 597                 goto err4;
 598         }
 599
 600         /* We can tolerate these failing */
 601         if (device_create_file(&ts->spi->dev, &dev_attr_pen_down));
 602         if (device_create_file(&ts->spi->dev, &dev_attr_disable_ts));
 603
 604         return 0;
 605 err4:
 606         free_irq(ts->irq, ts);
 607 err3:
 608         tsc2005_stop_scan(ts);
 609         input_free_device(idev);
 610 err2:
 611         gpio_free(dav_gpio);
 612 err1:
 613         return r;
 614 }
 615
 616 static int __devinit tsc2005_probe(struct spi_device *spi)
 617 {
 618         struct tsc2005                  *tsc;
 619         struct tsc2005_platform_data    *pdata = spi->dev.platform_data;
 620         int r;
 621
 622         if (!pdata) {
 623                 dev_dbg(&spi->dev, "no platform data?\n");
 624                 return -ENODEV;
 625         }
 626
 627         tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
 628         if (tsc == NULL)
 629                 return -ENOMEM;
 630
 631         dev_set_drvdata(&spi->dev, tsc);
 632         tsc->spi = spi;
 633         spi->dev.power.power_state = PMSG_ON;
 634
 635         spi->mode = SPI_MODE_0;
 636         spi->bits_per_word = 8;
 637         /* The max speed might've been defined by the board-specific
 638          * struct */
 639         if (!spi->max_speed_hz)
 640                 spi->max_speed_hz = TSC2005_HZ;
 641
 642         spi_setup(spi);
 643
 644         r = tsc2005_ts_init(tsc, pdata);
 645         if (r)
 646                 goto err1;
 647
 648         return 0;
 649
 650 err1:
 651         kfree(tsc);
 652         return r;
 653 }
 654
 655 static int __devexit tsc2005_remove(struct spi_device *spi)
 656 {
 657         struct tsc2005 *ts = dev_get_drvdata(&spi->dev);
 658
 659         mutex_lock(&ts->mutex);
 660         tsc2005_disable(ts);
 661         mutex_unlock(&ts->mutex);
 662
 663         device_remove_file(&ts->spi->dev, &dev_attr_disable_ts);
 664         device_remove_file(&ts->spi->dev, &dev_attr_pen_down);
 665
 666         free_irq(ts->irq, ts);
 667         input_unregister_device(ts->idev);
 668
 669         gpio_free(ts->dav_gpio);
 670         kfree(ts);
 671
 672         return 0;
 673 }
 674
 675 #ifdef CONFIG_PM
 676 static int tsc2005_suspend(struct spi_device *spi, pm_message_t mesg)
 677 {
 678         struct tsc2005 *ts = dev_get_drvdata(&spi->dev);
 679
 680         mutex_lock(&ts->mutex);
 681         tsc2005_disable(ts);
 682         mutex_unlock(&ts->mutex);
 683
 684         return 0;
 685 }
 686
 687 static int tsc2005_resume(struct spi_device *spi)
 688 {
 689         struct tsc2005 *ts = dev_get_drvdata(&spi->dev);
 690
 691         mutex_lock(&ts->mutex);
 692         tsc2005_enable(ts);
 693         mutex_unlock(&ts->mutex);
 694
 695         return 0;
 696 }
 697 #endif
 698
 699 static struct spi_driver tsc2005_driver = {
 700         .driver = {
 701                 .name = "tsc2005",
 702                 .owner = THIS_MODULE,
 703         },
 704 #ifdef CONFIG_PM
 705         .suspend = tsc2005_suspend,
 706         .resume = tsc2005_resume,
 707 #endif
 708         .probe = tsc2005_probe,
 709         .remove = __devexit_p(tsc2005_remove),
 710 };
 711
 712 static int __init tsc2005_init(void)
 713 {
 714         printk(KERN_INFO "TSC2005 driver initializing\n");
 715
 716         return spi_register_driver(&tsc2005_driver);
 717 }
 718 module_init(tsc2005_init);
 719
 720 static void __exit tsc2005_exit(void)
 721 {
 722         spi_unregister_driver(&tsc2005_driver);
 723 }
 724 module_exit(tsc2005_exit);
 725
 726 MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>");
 727 MODULE_LICENSE("GPL");
 728 MODULE_ALIAS("platform:tsc2005");