drivers/staging/cptm1217/clearpad_tm1217.c

   1 /*
   2  * clearpad_tm1217.c - Touch Screen driver for Synaptics Clearpad
   3  * TM1217 controller
   4  *
   5  * Copyright (C) 2008 Intel Corp
   6  *
   7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   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; version 2 of the License.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; ifnot, write to the Free Software Foundation, Inc.,
  20  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21  *
  22  * Questions/Comments/Bug fixes to Ramesh Agarwal (ramesh.agarwal@intel.com)
  23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/kernel.h>
  28 #include <linux/input.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/io.h>
  31 #include <linux/i2c.h>
  32 #include <linux/timer.h>
  33 #include <linux/gpio.h>
  34 #include <linux/hrtimer.h>
  35 #include <linux/kthread.h>
  36 #include <linux/delay.h>
  37 #include <linux/slab.h>
  38 #include "cp_tm1217.h"
  39
  40 #define CPTM1217_DEVICE_NAME            "cptm1217"
  41 #define CPTM1217_DRIVER_NAME            CPTM1217_DEVICE_NAME
  42
  43 #define MAX_TOUCH_SUPPORTED             2
  44 #define TOUCH_SUPPORTED                 1
  45 #define SAMPLING_FREQ                   80      /* Frequency in HZ */
  46 #define DELAY_BTWIN_SAMPLE              (1000 / SAMPLING_FREQ)
  47 #define WAIT_FOR_RESPONSE               5       /* 5msec just works */
  48 #define MAX_RETRIES                     5       /* As above */
  49 #define INCREMENTAL_DELAY               5       /* As above */
  50
  51 /* Regster Definitions */
  52 #define TMA1217_DEV_STATUS              0x13    /* Device Status */
  53 #define TMA1217_INT_STATUS              0x14    /* Interrupt Status */
  54
  55 /* Controller can detect up to 2 possible finger touches.
  56  * Each finger touch provides  12 bit X Y co-ordinates, the values are split
  57  * across 2 registers, and an 8 bit  Z value */
  58 #define TMA1217_FINGER_STATE            0x18 /* Finger State */
  59 #define TMA1217_FINGER1_X_HIGHER8       0x19 /* Higher 8 bit of X coordinate */
  60 #define TMA1217_FINGER1_Y_HIGHER8       0x1A /* Higher 8 bit of Y coordinate */
  61 #define TMA1217_FINGER1_XY_LOWER4       0x1B /* Lower 4 bits of X and Y */
  62 #define TMA1217_FINGER1_Z_VALUE         0x1D /* 8 bit Z value for finger 1 */
  63 #define TMA1217_FINGER2_X_HIGHER8       0x1E /* Higher 8 bit of X coordinate */
  64 #define TMA1217_FINGER2_Y_HIGHER8       0x1F /* Higher 8 bit of Y coordinate */
  65 #define TMA1217_FINGER2_XY_LOWER4       0x20 /* Lower 4 bits of X and Y */
  66 #define TMA1217_FINGER2_Z_VALUE         0x22 /* 8 bit Z value for finger 2 */
  67 #define TMA1217_DEVICE_CTRL             0x23 /* Device Control */
  68 #define TMA1217_INTERRUPT_ENABLE        0x24 /* Interrupt Enable */
  69 #define TMA1217_REPORT_MODE             0x2B /* Reporting Mode */
  70 #define TMA1217_MAX_X_LOWER8            0x31 /* Bit 0-7 for Max X */
  71 #define TMA1217_MAX_X_HIGHER4           0x32 /* Bit 8-11 for Max X */
  72 #define TMA1217_MAX_Y_LOWER8            0x33 /* Bit 0-7 for Max Y */
  73 #define TMA1217_MAX_Y_HIGHER4           0x34 /* Bit 8-11 for Max Y */
  74 #define TMA1217_DEVICE_CMD_RESET        0x67 /* Device CMD reg for reset */
  75 #define TMA1217_DEVICE_CMD_REZERO       0x69 /* Device CMD reg for rezero */
  76
  77 #define TMA1217_MANUFACTURER_ID         0x73 /* Manufacturer Id */
  78 #define TMA1217_PRODUCT_FAMILY          0x75 /* Product Family */
  79 #define TMA1217_FIRMWARE_REVISION       0x76 /* Firmware Revision */
  80 #define TMA1217_SERIAL_NO_HIGH          0x7C /* Bit 8-15 of device serial no. */
  81 #define TMA1217_SERIAL_NO_LOW           0x7D /* Bit 0-7 of device serial no. */
  82 #define TMA1217_PRODUCT_ID_START        0x7E /* Start address for 10 byte ID */
  83 #define TMA1217_DEVICE_CAPABILITY       0x8B /* Reporting capability */
  84
  85
  86 /*
  87  * The touch position structure.
  88  */
  89 struct touch_state {
  90         int     x;
  91         int     y;
  92         bool button;
  93 };
  94
  95 /* Device Specific info given by the controller */
  96 struct cp_dev_info {
  97         u16     maxX;
  98         u16     maxY;
  99 };
 100
 101 /* Vendor related info given by the controller */
 102 struct cp_vendor_info {
 103         u8      vendor_id;
 104         u8      product_family;
 105         u8      firmware_rev;
 106         u16     serial_no;
 107 };
 108
 109 /*
 110  * Private structure to store the device details
 111  */
 112 struct cp_tm1217_device {
 113         struct i2c_client       *client;
 114         struct device           *dev;
 115         struct cp_vendor_info   vinfo;
 116         struct cp_dev_info      dinfo;
 117         struct input_dev_info {
 118                 char                    phys[32];
 119                 char                    name[128];
 120                 struct input_dev        *input;
 121                 struct touch_state      touch;
 122         } cp_input_info[MAX_TOUCH_SUPPORTED];
 123
 124         int     thread_running;
 125         struct mutex    thread_mutex;
 126
 127         int gpio;
 128 };
 129
 130
 131 /* The following functions are used to read/write registers on the device
 132  * as per the RMI prorocol. Technically, a page select should be written
 133  * before doing read/write but since the register offsets are below 0xFF
 134  * we can use the default value of page which is 0x00
 135  */
 136 static int cp_tm1217_read(struct cp_tm1217_device *ts,
 137                                 u8 *req, int size)
 138 {
 139         int i, retval;
 140
 141         /* Send the address */
 142         retval = i2c_master_send(ts->client, &req[0], 1);
 143         if (retval != 1) {
 144                 dev_err(ts->dev, "cp_tm1217: I2C send failed\n");
 145                 return retval;
 146         }
 147         msleep(WAIT_FOR_RESPONSE);
 148         for (i = 0; i < MAX_RETRIES; i++) {
 149                 retval = i2c_master_recv(ts->client, &req[1], size);
 150                 if (retval == size) {
 151                         break;
 152                 } else {
 153                         msleep(INCREMENTAL_DELAY);
 154                         dev_dbg(ts->dev, "cp_tm1217: Retry count is %d\n", i);
 155                 }
 156         }
 157         if (retval != size)
 158                 dev_err(ts->dev, "cp_tm1217: Read from device failed\n");
 159
 160         return retval;
 161 }
 162
 163 static int cp_tm1217_write(struct cp_tm1217_device *ts,
 164                                 u8 *req, int size)
 165 {
 166         int retval;
 167
 168         /* Send the address and the data to be written */
 169         retval = i2c_master_send(ts->client, &req[0], size + 1);
 170         if (retval != size + 1) {
 171                 dev_err(ts->dev, "cp_tm1217: I2C write  failed: %d\n", retval);
 172                 return retval;
 173         }
 174         /* Wait for the write to complete. TBD why this is required */
 175         msleep(WAIT_FOR_RESPONSE);
 176
 177         return size;
 178 }
 179
 180 static int cp_tm1217_mask_interrupt(struct cp_tm1217_device *ts)
 181 {
 182         u8 req[2];
 183         int retval;
 184
 185         req[0] = TMA1217_INTERRUPT_ENABLE;
 186         req[1] = 0x0;
 187         retval = cp_tm1217_write(ts, req, 1);
 188         if (retval != 1)
 189                 return -EIO;
 190
 191         return 0;
 192 }
 193
 194 static int cp_tm1217_unmask_interrupt(struct cp_tm1217_device *ts)
 195 {
 196         u8 req[2];
 197         int retval;
 198
 199         req[0] = TMA1217_INTERRUPT_ENABLE;
 200         req[1] = 0xa;
 201         retval = cp_tm1217_write(ts, req, 1);
 202         if (retval != 1)
 203                 return -EIO;
 204
 205         return 0;
 206 }
 207
 208 static void process_touch(struct cp_tm1217_device *ts, int index)
 209 {
 210         int retval;
 211         struct input_dev_info *input_info =
 212                 (struct input_dev_info *)&ts->cp_input_info[index];
 213         u8 xy_data[6];
 214
 215         if (index == 0)
 216                 xy_data[0] = TMA1217_FINGER1_X_HIGHER8;
 217         else
 218                 xy_data[0] = TMA1217_FINGER2_X_HIGHER8;
 219
 220         retval = cp_tm1217_read(ts, xy_data, 5);
 221         if (retval < 5) {
 222                 dev_err(ts->dev, "cp_tm1217: XY read from device failed\n");
 223                 return;
 224         }
 225
 226         /* Note: Currently not using the Z values but may be requried in
 227            the future. */
 228         input_info->touch.x = (xy_data[1] << 4)
 229                                         | (xy_data[3] & 0x0F);
 230         input_info->touch.y = (xy_data[2] << 4)
 231                                         | ((xy_data[3] & 0xF0) >> 4);
 232         input_report_abs(input_info->input, ABS_X, input_info->touch.x);
 233         input_report_abs(input_info->input, ABS_Y, input_info->touch.y);
 234         input_sync(input_info->input);
 235 }
 236
 237 static void cp_tm1217_get_data(struct cp_tm1217_device *ts)
 238 {
 239         u8 req[2];
 240         int retval, i, finger_touched = 0;
 241
 242         do {
 243                 req[0] = TMA1217_FINGER_STATE;
 244                 retval = cp_tm1217_read(ts, req, 1);
 245                 if (retval != 1) {
 246                         dev_err(ts->dev,
 247                                 "cp_tm1217: Read from device failed\n");
 248                         continue;
 249                 }
 250                 finger_touched = 0;
 251                 /* Start sampling until the pressure is below
 252                   threshold */
 253                 for (i = 0; i < TOUCH_SUPPORTED; i++) {
 254                         if (req[1] & 0x3) {
 255                                 finger_touched++;
 256                                 if (ts->cp_input_info[i].touch.button == 0) {
 257                                         /* send the button touch event */
 258                                         input_report_key(
 259                                                 ts->cp_input_info[i].input,
 260                                                 BTN_TOUCH, 1);
 261                                         ts->cp_input_info[i].touch.button = 1;
 262                                 }
 263                                 process_touch(ts, i);
 264                         } else {
 265                                 if (ts->cp_input_info[i].touch.button == 1) {
 266                                         /* send the button release event */
 267                                         input_report_key(
 268                                                 ts->cp_input_info[i].input,
 269                                                 BTN_TOUCH, 0);
 270                                         input_sync(ts->cp_input_info[i].input);
 271                                         ts->cp_input_info[i].touch.button = 0;
 272                                 }
 273                         }
 274                         req[1] = req[1] >> 2;
 275                 }
 276                 msleep(DELAY_BTWIN_SAMPLE);
 277         } while (finger_touched > 0);
 278 }
 279
 280 static irqreturn_t cp_tm1217_sample_thread(int irq, void *handle)
 281 {
 282         struct cp_tm1217_device *ts = (struct cp_tm1217_device *) handle;
 283         u8 req[2];
 284         int retval;
 285
 286         /* Chedk if another thread is already running */
 287         mutex_lock(&ts->thread_mutex);
 288         if (ts->thread_running == 1) {
 289                 mutex_unlock(&ts->thread_mutex);
 290                 return IRQ_HANDLED;
 291         } else {
 292                 ts->thread_running = 1;
 293                 mutex_unlock(&ts->thread_mutex);
 294         }
 295
 296         /* Mask the interrupts */
 297         retval = cp_tm1217_mask_interrupt(ts);
 298
 299         /* Read the Interrupt Status register to find the cause of the
 300            Interrupt */
 301         req[0] = TMA1217_INT_STATUS;
 302         retval = cp_tm1217_read(ts, req, 1);
 303         if (retval != 1)
 304                 goto exit_thread;
 305
 306         if (!(req[1] & 0x8))
 307                 goto exit_thread;
 308
 309         cp_tm1217_get_data(ts);
 310
 311 exit_thread:
 312         /* Unmask the interrupts before going to sleep */
 313         retval = cp_tm1217_unmask_interrupt(ts);
 314
 315         mutex_lock(&ts->thread_mutex);
 316         ts->thread_running = 0;
 317         mutex_unlock(&ts->thread_mutex);
 318
 319         return IRQ_HANDLED;
 320 }
 321
 322 static int cp_tm1217_init_data(struct cp_tm1217_device *ts)
 323 {
 324         int retval;
 325         u8      req[2];
 326
 327         /* Read the vendor id/ fw revision etc. Ignoring return check as this
 328            is non critical info  */
 329         req[0] = TMA1217_MANUFACTURER_ID;
 330         retval = cp_tm1217_read(ts, req, 1);
 331         ts->vinfo.vendor_id = req[1];
 332
 333         req[0] = TMA1217_PRODUCT_FAMILY;
 334         retval = cp_tm1217_read(ts, req, 1);
 335         ts->vinfo.product_family = req[1];
 336
 337         req[0] = TMA1217_FIRMWARE_REVISION;
 338         retval = cp_tm1217_read(ts, req, 1);
 339         ts->vinfo.firmware_rev = req[1];
 340
 341         req[0] = TMA1217_SERIAL_NO_HIGH;
 342         retval = cp_tm1217_read(ts, req, 1);
 343         ts->vinfo.serial_no = (req[1] << 8);
 344
 345         req[0] = TMA1217_SERIAL_NO_LOW;
 346         retval = cp_tm1217_read(ts, req, 1);
 347         ts->vinfo.serial_no = ts->vinfo.serial_no | req[1];
 348
 349         req[0] = TMA1217_MAX_X_HIGHER4;
 350         retval = cp_tm1217_read(ts, req, 1);
 351         ts->dinfo.maxX = (req[1] & 0xF) << 8;
 352
 353         req[0] = TMA1217_MAX_X_LOWER8;
 354         retval = cp_tm1217_read(ts, req, 1);
 355         ts->dinfo.maxX = ts->dinfo.maxX | req[1];
 356
 357         req[0] = TMA1217_MAX_Y_HIGHER4;
 358         retval = cp_tm1217_read(ts, req, 1);
 359         ts->dinfo.maxY = (req[1] & 0xF) << 8;
 360
 361         req[0] = TMA1217_MAX_Y_LOWER8;
 362         retval = cp_tm1217_read(ts, req, 1);
 363         ts->dinfo.maxY = ts->dinfo.maxY | req[1];
 364
 365         return 0;
 366
 367 }
 368
 369 /*
 370  *      Set up a GPIO for use as the interrupt. We can't simply do this at
 371  *      boot time because the GPIO drivers themselves may not be around at
 372  *      boot/firmware set up time to do the work. Instead defer it to driver
 373  *      detection.
 374  */
 375
 376 static int cp_tm1217_setup_gpio_irq(struct cp_tm1217_device *ts)
 377 {
 378         int retval;
 379
 380         /* Hook up the irq handler */
 381         retval = gpio_request(ts->gpio, "cp_tm1217_touch");
 382         if (retval < 0) {
 383                 dev_err(ts->dev, "cp_tm1217: GPIO request failed error %d\n",
 384                                                                 retval);
 385                 return retval;
 386         }
 387
 388         retval = gpio_direction_input(ts->gpio);
 389         if (retval < 0) {
 390                 dev_err(ts->dev,
 391                 "cp_tm1217: GPIO direction configuration failed, error %d\n",
 392                                                                 retval);
 393                 gpio_free(ts->gpio);
 394                 return retval;
 395         }
 396
 397         retval = gpio_to_irq(ts->gpio);
 398         if (retval < 0) {
 399                 dev_err(ts->dev,
 400                         "cp_tm1217: GPIO to IRQ failed, error %d\n", retval);
 401                 gpio_free(ts->gpio);
 402         }
 403         dev_dbg(ts->dev,
 404                 "cp_tm1217: Got IRQ number is %d for GPIO %d\n",
 405                 retval, ts->gpio);
 406         return retval;
 407 }
 408
 409 static int cp_tm1217_probe(struct i2c_client *client,
 410                         const struct i2c_device_id *id)
 411 {
 412         struct cp_tm1217_device *ts;
 413         struct input_dev *input_dev;
 414         struct input_dev_info   *input_info;
 415         struct cp_tm1217_platform_data *pdata;
 416         u8 req[2];
 417         int i, retval;
 418
 419         /* No pdata is fine - we then use "normal" IRQ mode */
 420
 421         pdata = client->dev.platform_data;
 422
 423         ts = kzalloc(sizeof(struct cp_tm1217_device), GFP_KERNEL);
 424         if (!ts)
 425                 return -ENOMEM;
 426
 427         ts->client = client;
 428         ts->dev = &client->dev;
 429         i2c_set_clientdata(client, ts);
 430
 431         ts->thread_running = 0;
 432         mutex_init(&ts->thread_mutex);
 433
 434         /* Reset the Controller */
 435         req[0] = TMA1217_DEVICE_CMD_RESET;
 436         req[1] = 0x1;
 437         retval = cp_tm1217_write(ts, req, 1);
 438         if (retval != 1) {
 439                 dev_err(ts->dev, "cp_tm1217: Controller reset failed\n");
 440                 kfree(ts);
 441                 return -EIO;
 442         }
 443
 444         /* Clear up the interrupt status from reset. */
 445         req[0] = TMA1217_INT_STATUS;
 446         retval = cp_tm1217_read(ts, req, 1);
 447
 448         /* Mask all the interrupts */
 449         retval = cp_tm1217_mask_interrupt(ts);
 450
 451         /* Read the controller information */
 452         cp_tm1217_init_data(ts);
 453
 454         /* The following code will register multiple event devices when
 455            multi-pointer is enabled, the code has not been tested
 456            with MPX */
 457         for (i = 0; i < TOUCH_SUPPORTED; i++) {
 458                 input_dev = input_allocate_device();
 459                 if (input_dev == NULL) {
 460                         retval = -ENOMEM;
 461                         goto fail;
 462                 }
 463                 input_info = &ts->cp_input_info[i];
 464                 snprintf(input_info->name, sizeof(input_info->name),
 465                         "cp_tm1217_touchscreen_%d", i);
 466                 input_dev->name = input_info->name;
 467                 snprintf(input_info->phys, sizeof(input_info->phys),
 468                         "%s/input%d", dev_name(&client->dev), i);
 469
 470                 input_dev->phys = input_info->phys;
 471                 input_dev->id.bustype = BUS_I2C;
 472
 473                 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 474                 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 475
 476                 input_set_abs_params(input_dev, ABS_X, 0, ts->dinfo.maxX, 0, 0);
 477                 input_set_abs_params(input_dev, ABS_Y, 0, ts->dinfo.maxY, 0, 0);
 478
 479                 retval = input_register_device(input_dev);
 480                 if (retval) {
 481                         dev_err(ts->dev,
 482                                 "Input dev registration failed for %s\n",
 483                                         input_dev->name);
 484                         input_free_device(input_dev);
 485                         goto fail;
 486                 }
 487                 input_info->input = input_dev;
 488         }
 489
 490         /* Setup the reporting mode to send an interrupt only when
 491            finger arrives or departs. */
 492         req[0] = TMA1217_REPORT_MODE;
 493         req[1] = 0x02;
 494         retval = cp_tm1217_write(ts, req, 1);
 495
 496         /* Setup the device to no sleep mode for now and make it configured */
 497         req[0] = TMA1217_DEVICE_CTRL;
 498         req[1] = 0x84;
 499         retval = cp_tm1217_write(ts, req, 1);
 500
 501         /* Check for the status of the device */
 502         req[0] = TMA1217_DEV_STATUS;
 503         retval = cp_tm1217_read(ts, req, 1);
 504         if (req[1] != 0) {
 505                 dev_err(ts->dev,
 506                         "cp_tm1217: Device Status 0x%x != 0: config failed\n",
 507                         req[1]);
 508
 509                 retval = -EIO;
 510                 goto fail;
 511         }
 512
 513         if (pdata && pdata->gpio) {
 514                 ts->gpio = pdata->gpio;
 515                 retval = cp_tm1217_setup_gpio_irq(ts);
 516         } else
 517                 retval = client->irq;
 518
 519         if (retval < 0) {
 520                 dev_err(ts->dev, "cp_tm1217: GPIO request failed error %d\n",
 521                                                                 retval);
 522                 goto fail;
 523         }
 524
 525         client->irq = retval;
 526
 527
 528         retval = request_threaded_irq(client->irq,
 529                 NULL, cp_tm1217_sample_thread,
 530                 IRQF_TRIGGER_FALLING, "cp_tm1217_touch", ts);
 531         if (retval < 0) {
 532                 dev_err(ts->dev, "cp_tm1217: Request IRQ error %d\n", retval);
 533                 goto fail_gpio;
 534         }
 535
 536         /* Unmask the interrupts */
 537         retval = cp_tm1217_unmask_interrupt(ts);
 538         if (retval == 0)
 539                 return 0;
 540
 541         free_irq(client->irq, ts);
 542 fail_gpio:
 543         if (ts->gpio)
 544                 gpio_free(ts->gpio);
 545 fail:
 546         /* Clean up before returning failure */
 547         for (i = 0; i < TOUCH_SUPPORTED; i++) {
 548                 if (ts->cp_input_info[i].input)
 549                         input_unregister_device(ts->cp_input_info[i].input);
 550         }
 551         kfree(ts);
 552         return retval;
 553
 554 }
 555
 556 #ifdef CONFIG_PM_SLEEP
 557
 558 /*
 559  * cp_tm1217 suspend
 560  *
 561  */
 562 static int cp_tm1217_suspend(struct device *dev)
 563 {
 564         struct i2c_client *client = to_i2c_client(dev);
 565         struct cp_tm1217_device *ts = i2c_get_clientdata(client);
 566         u8 req[2];
 567         int retval;
 568
 569         /* Put the controller to sleep */
 570         req[0] = TMA1217_DEVICE_CTRL;
 571         retval = cp_tm1217_read(ts, req, 1);
 572         req[1] = (req[1] & 0xF8) | 0x1;
 573         retval = cp_tm1217_write(ts, req, 1);
 574
 575         if (device_may_wakeup(&client->dev))
 576                 enable_irq_wake(client->irq);
 577
 578         return 0;
 579 }
 580
 581 /*
 582  * cp_tm1217_resume
 583  *
 584  */
 585 static int cp_tm1217_resume(struct device *dev)
 586 {
 587         struct i2c_client *client = to_i2c_client(dev);
 588         struct cp_tm1217_device *ts = i2c_get_clientdata(client);
 589         u8 req[2];
 590         int retval;
 591
 592         /* Take the controller out of sleep */
 593         req[0] = TMA1217_DEVICE_CTRL;
 594         retval = cp_tm1217_read(ts, req, 1);
 595         req[1] = (req[1] & 0xF8) | 0x4;
 596         retval = cp_tm1217_write(ts, req, 1);
 597
 598         /* Restore the register settings sinc the power to the
 599            could have been cut off */
 600
 601         /* Setup the reporting mode to send an interrupt only when
 602            finger arrives or departs. */
 603         req[0] = TMA1217_REPORT_MODE;
 604         req[1] = 0x02;
 605         retval = cp_tm1217_write(ts, req, 1);
 606
 607         /* Setup the device to no sleep mode for now and make it configured */
 608         req[0] = TMA1217_DEVICE_CTRL;
 609         req[1] = 0x84;
 610         retval = cp_tm1217_write(ts, req, 1);
 611
 612         /* Setup the interrupt mask */
 613         retval = cp_tm1217_unmask_interrupt(ts);
 614
 615         if (device_may_wakeup(&client->dev))
 616                 disable_irq_wake(client->irq);
 617
 618         return 0;
 619 }
 620
 621 #endif
 622
 623 static SIMPLE_DEV_PM_OPS(cp_tm1217_pm_ops, cp_tm1217_suspend,
 624         cp_tm1217_resume);
 625
 626 /*
 627  * cp_tm1217_remove
 628  *
 629  */
 630 static int cp_tm1217_remove(struct i2c_client *client)
 631 {
 632         struct cp_tm1217_device *ts = i2c_get_clientdata(client);
 633         int i;
 634
 635         free_irq(client->irq, ts);
 636         if (ts->gpio)
 637                 gpio_free(ts->gpio);
 638         for (i = 0; i < TOUCH_SUPPORTED; i++)
 639                 input_unregister_device(ts->cp_input_info[i].input);
 640         kfree(ts);
 641         return 0;
 642 }
 643
 644 static struct i2c_device_id cp_tm1217_idtable[] = {
 645         { CPTM1217_DEVICE_NAME, 0 },
 646         { }
 647 };
 648
 649 MODULE_DEVICE_TABLE(i2c, cp_tm1217_idtable);
 650
 651 static struct i2c_driver cp_tm1217_driver = {
 652         .driver = {
 653                 .owner  = THIS_MODULE,
 654                 .name   = CPTM1217_DRIVER_NAME,
 655                 .pm     = &cp_tm1217_pm_ops,
 656         },
 657         .id_table       = cp_tm1217_idtable,
 658         .probe          = cp_tm1217_probe,
 659         .remove         = cp_tm1217_remove,
 660 };
 661
 662 module_i2c_driver(cp_tm1217_driver);
 663
 664 MODULE_AUTHOR("Ramesh Agarwal <ramesh.agarwal@intel.com>");
 665 MODULE_DESCRIPTION("Synaptics TM1217 TouchScreen Driver");
 666 MODULE_LICENSE("GPL v2");