drivers/staging/dream/synaptics_i2c_rmi.c

   1 /*
   2  * Support for synaptics touchscreen.
   3  *
   4  * Copyright (C) 2007 Google, Inc.
   5  * Author: Arve Hjønnevåg <arve@android.com>
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * http://www.synaptics.com/sites/default/files/511_000099_01F.pdf
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/delay.h>
  21 #ifdef CONFIG_HAS_EARLYSUSPEND
  22 #include <linux/earlysuspend.h>
  23 #endif
  24 #include <linux/hrtimer.h>
  25 #include <linux/i2c.h>
  26 #include <linux/input.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/io.h>
  29 #include <linux/platform_device.h>
  30 #include "synaptics_i2c_rmi.h"
  31
  32 static struct workqueue_struct *synaptics_wq;
  33
  34 struct synaptics_ts_data {
  35         u16 addr;
  36         struct i2c_client *client;
  37         struct input_dev *input_dev;
  38         int use_irq;
  39         struct hrtimer timer;
  40         struct work_struct  work;
  41         u16 max[2];
  42         int snap_state[2][2];
  43         int snap_down_on[2];
  44         int snap_down_off[2];
  45         int snap_up_on[2];
  46         int snap_up_off[2];
  47         int snap_down[2];
  48         int snap_up[2];
  49         u32 flags;
  50         int (*power)(int on);
  51 #ifdef CONFIG_HAS_EARLYSUSPEND
  52         struct early_suspend early_suspend;
  53 #endif
  54 };
  55
  56 static int i2c_set(struct synaptics_ts_data *ts, u8 reg, u8 val, char *msg)
  57 {
  58         int ret = i2c_smbus_write_byte_data(ts->client, reg, val);
  59         if (ret < 0)
  60                 pr_err("i2c_smbus_write_byte_data failed (%s)\n", msg);
  61         return ret;
  62 }
  63
  64 static int i2c_read(struct synaptics_ts_data *ts, u8 reg, char *msg)
  65 {
  66         int ret = i2c_smbus_read_byte_data(ts->client, reg);
  67         if (ret < 0)
  68                 pr_err("i2c_smbus_read_byte_data failed (%s)\n", msg);
  69         return ret;
  70 }
  71 #ifdef CONFIG_HAS_EARLYSUSPEND
  72 static void synaptics_ts_early_suspend(struct early_suspend *h);
  73 static void synaptics_ts_late_resume(struct early_suspend *h);
  74 #endif
  75
  76 static int synaptics_init_panel(struct synaptics_ts_data *ts)
  77 {
  78         int ret;
  79
  80         ret = i2c_set(ts, 0xff, 0x10, "set page select");
  81         if (ret == 0)
  82                 ret = i2c_set(ts, 0x41, 0x04, "set No Clip Z");
  83
  84         ret = i2c_set(ts, 0xff, 0x04, "fallback page select");
  85         ret = i2c_set(ts, 0xf0, 0x81, "select 80 reports per second");
  86         return ret;
  87 }
  88
  89 static void decode_report(struct synaptics_ts_data *ts, u8 *buf)
  90 {
  91 /*
  92  * This sensor sends two 6-byte absolute finger reports, an optional
  93  * 2-byte relative report followed by a status byte. This function
  94  * reads the two finger reports and transforms the coordinates
  95  * according the platform data so they can be aligned with the lcd
  96  * behind the touchscreen. Typically we flip the y-axis since the
  97  * sensor uses the bottom left corner as the origin, but if the sensor
  98  * is mounted upside down the platform data will request that the
  99  * x-axis should be flipped instead. The snap to inactive edge border
 100  * are used to allow tapping the edges of the screen on the G1. The
 101  * active area of the touchscreen is smaller than the lcd. When the
 102  * finger gets close the edge of the screen we snap it to the
 103  * edge. This allows ui elements at the edge of the screen to be hit,
 104  * and it prevents hitting ui elements that are not at the edge of the
 105  * screen when the finger is touching the edge.
 106  */
 107         int pos[2][2];
 108         int f, a;
 109         int base = 2;
 110         int z = buf[1];
 111         int w = buf[0] >> 4;
 112         int finger = buf[0] & 7;
 113         int finger2_pressed;
 114
 115         for (f = 0; f < 2; f++) {
 116                 u32 flip_flag = SYNAPTICS_FLIP_X;
 117                 for (a = 0; a < 2; a++) {
 118                         int p = buf[base + 1];
 119                         p |= (u16)(buf[base] & 0x1f) << 8;
 120                         if (ts->flags & flip_flag)
 121                                 p = ts->max[a] - p;
 122                         if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
 123                                 if (ts->snap_state[f][a]) {
 124                                         if (p <= ts->snap_down_off[a])
 125                                                 p = ts->snap_down[a];
 126                                         else if (p >= ts->snap_up_off[a])
 127                                                 p = ts->snap_up[a];
 128                                         else
 129                                                 ts->snap_state[f][a] = 0;
 130                                 } else {
 131                                         if (p <= ts->snap_down_on[a]) {
 132                                                 p = ts->snap_down[a];
 133                                                 ts->snap_state[f][a] = 1;
 134                                         } else if (p >= ts->snap_up_on[a]) {
 135                                                 p = ts->snap_up[a];
 136                                                 ts->snap_state[f][a] = 1;
 137                                         }
 138                                 }
 139                         }
 140                         pos[f][a] = p;
 141                         base += 2;
 142                         flip_flag <<= 1;
 143                 }
 144                 base += 2;
 145                 if (ts->flags & SYNAPTICS_SWAP_XY)
 146                         swap(pos[f][0], pos[f][1]);
 147         }
 148         if (z) {
 149                 input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
 150                 input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
 151         }
 152         input_report_abs(ts->input_dev, ABS_PRESSURE, z);
 153         input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w);
 154         input_report_key(ts->input_dev, BTN_TOUCH, finger);
 155         finger2_pressed = finger > 1 && finger != 7;
 156         input_report_key(ts->input_dev, BTN_2, finger2_pressed);
 157         if (finger2_pressed) {
 158                 input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]);
 159                 input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
 160         }
 161         input_sync(ts->input_dev);
 162 }
 163
 164 static void synaptics_ts_work_func(struct work_struct *work)
 165 {
 166         int i;
 167         int ret;
 168         int bad_data = 0;
 169         struct i2c_msg msg[2];
 170         u8 start_reg = 0;
 171         u8 buf[15];
 172         struct synaptics_ts_data *ts =
 173                 container_of(work, struct synaptics_ts_data, work);
 174
 175         msg[0].addr = ts->client->addr;
 176         msg[0].flags = 0;
 177         msg[0].len = 1;
 178         msg[0].buf = &start_reg;
 179         msg[1].addr = ts->client->addr;
 180         msg[1].flags = I2C_M_RD;
 181         msg[1].len = sizeof(buf);
 182         msg[1].buf = buf;
 183
 184         for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
 185                 ret = i2c_transfer(ts->client->adapter, msg, 2);
 186                 if (ret < 0) {
 187                         pr_err("ts_work: i2c_transfer failed\n");
 188                         bad_data = 1;
 189                         continue;
 190                 }
 191                 if ((buf[14] & 0xc0) != 0x40) {
 192                         pr_warning("synaptics_ts_work_func:"
 193                                " bad read %x %x %x %x %x %x %x %x %x"
 194                                " %x %x %x %x %x %x, ret %d\n",
 195                                buf[0], buf[1], buf[2], buf[3],
 196                                buf[4], buf[5], buf[6], buf[7],
 197                                buf[8], buf[9], buf[10], buf[11],
 198                                buf[12], buf[13], buf[14], ret);
 199                         if (bad_data)
 200                                 synaptics_init_panel(ts);
 201                         bad_data = 1;
 202                         continue;
 203                 }
 204                 bad_data = 0;
 205                 if ((buf[14] & 1) == 0)
 206                         break;
 207
 208                 decode_report(ts, buf);
 209         }
 210         if (ts->use_irq)
 211                 enable_irq(ts->client->irq);
 212 }
 213
 214 static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
 215 {
 216         struct synaptics_ts_data *ts =
 217                 container_of(timer, struct synaptics_ts_data, timer);
 218
 219         queue_work(synaptics_wq, &ts->work);
 220
 221         hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
 222         return HRTIMER_NORESTART;
 223 }
 224
 225 static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
 226 {
 227         struct synaptics_ts_data *ts = dev_id;
 228
 229         disable_irq_nosync(ts->client->irq);
 230         queue_work(synaptics_wq, &ts->work);
 231         return IRQ_HANDLED;
 232 }
 233
 234 static int detect(struct synaptics_ts_data *ts, u32 *panel_version)
 235 {
 236         int ret;
 237         int retry = 10;
 238
 239         ret = i2c_set(ts, 0xf4, 0x01, "reset device");
 240
 241         while (retry-- > 0) {
 242                 ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
 243                 if (ret >= 0)
 244                         break;
 245                 msleep(100);
 246         }
 247         if (ret < 0) {
 248                 pr_err("i2c_smbus_read_byte_data failed\n");
 249                 return ret;
 250         }
 251
 252         *panel_version = ret << 8;
 253         ret = i2c_read(ts, 0xe5, "product minor");
 254         if (ret < 0)
 255                 return ret;
 256         *panel_version |= ret;
 257
 258         ret = i2c_read(ts, 0xe3, "property");
 259         if (ret < 0)
 260                 return ret;
 261
 262         pr_info("synaptics: version %x, product property %x\n",
 263                 *panel_version, ret);
 264         return 0;
 265 }
 266
 267 static void compute_areas(struct synaptics_ts_data *ts,
 268                           struct synaptics_i2c_rmi_platform_data *pdata,
 269                           u16 max_x, u16 max_y)
 270 {
 271         int inactive_area_left;
 272         int inactive_area_right;
 273         int inactive_area_top;
 274         int inactive_area_bottom;
 275         int snap_left_on;
 276         int snap_left_off;
 277         int snap_right_on;
 278         int snap_right_off;
 279         int snap_top_on;
 280         int snap_top_off;
 281         int snap_bottom_on;
 282         int snap_bottom_off;
 283         int fuzz_x;
 284         int fuzz_y;
 285         int fuzz_p;
 286         int fuzz_w;
 287         int swapped = !!(ts->flags & SYNAPTICS_SWAP_XY);
 288
 289         inactive_area_left = pdata->inactive_left;
 290         inactive_area_right = pdata->inactive_right;
 291         inactive_area_top = pdata->inactive_top;
 292         inactive_area_bottom = pdata->inactive_bottom;
 293         snap_left_on = pdata->snap_left_on;
 294         snap_left_off = pdata->snap_left_off;
 295         snap_right_on = pdata->snap_right_on;
 296         snap_right_off = pdata->snap_right_off;
 297         snap_top_on = pdata->snap_top_on;
 298         snap_top_off = pdata->snap_top_off;
 299         snap_bottom_on = pdata->snap_bottom_on;
 300         snap_bottom_off = pdata->snap_bottom_off;
 301         fuzz_x = pdata->fuzz_x;
 302         fuzz_y = pdata->fuzz_y;
 303         fuzz_p = pdata->fuzz_p;
 304         fuzz_w = pdata->fuzz_w;
 305
 306         inactive_area_left = inactive_area_left * max_x / 0x10000;
 307         inactive_area_right = inactive_area_right * max_x / 0x10000;
 308         inactive_area_top = inactive_area_top * max_y / 0x10000;
 309         inactive_area_bottom = inactive_area_bottom * max_y / 0x10000;
 310         snap_left_on = snap_left_on * max_x / 0x10000;
 311         snap_left_off = snap_left_off * max_x / 0x10000;
 312         snap_right_on = snap_right_on * max_x / 0x10000;
 313         snap_right_off = snap_right_off * max_x / 0x10000;
 314         snap_top_on = snap_top_on * max_y / 0x10000;
 315         snap_top_off = snap_top_off * max_y / 0x10000;
 316         snap_bottom_on = snap_bottom_on * max_y / 0x10000;
 317         snap_bottom_off = snap_bottom_off * max_y / 0x10000;
 318         fuzz_x = fuzz_x * max_x / 0x10000;
 319         fuzz_y = fuzz_y * max_y / 0x10000;
 320
 321
 322         ts->snap_down[swapped] = -inactive_area_left;
 323         ts->snap_up[swapped] = max_x + inactive_area_right;
 324         ts->snap_down[!swapped] = -inactive_area_top;
 325         ts->snap_up[!swapped] = max_y + inactive_area_bottom;
 326         ts->snap_down_on[swapped] = snap_left_on;
 327         ts->snap_down_off[swapped] = snap_left_off;
 328         ts->snap_up_on[swapped] = max_x - snap_right_on;
 329         ts->snap_up_off[swapped] = max_x - snap_right_off;
 330         ts->snap_down_on[!swapped] = snap_top_on;
 331         ts->snap_down_off[!swapped] = snap_top_off;
 332         ts->snap_up_on[!swapped] = max_y - snap_bottom_on;
 333         ts->snap_up_off[!swapped] = max_y - snap_bottom_off;
 334         pr_info("synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y);
 335         pr_info("synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
 336                inactive_area_left, inactive_area_right,
 337                inactive_area_top, inactive_area_bottom);
 338         pr_info("synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
 339                snap_left_on, snap_left_off, snap_right_on, snap_right_off,
 340                snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off);
 341
 342         input_set_abs_params(ts->input_dev, ABS_X,
 343                              -inactive_area_left, max_x + inactive_area_right,
 344                              fuzz_x, 0);
 345         input_set_abs_params(ts->input_dev, ABS_Y,
 346                              -inactive_area_top, max_y + inactive_area_bottom,
 347                              fuzz_y, 0);
 348         input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
 349         input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0);
 350         input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left,
 351                              max_x + inactive_area_right, fuzz_x, 0);
 352         input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top,
 353                              max_y + inactive_area_bottom, fuzz_y, 0);
 354 }
 355
 356 static struct synaptics_i2c_rmi_platform_data fake_pdata;
 357
 358 static int __devinit synaptics_ts_probe(
 359         struct i2c_client *client, const struct i2c_device_id *id)
 360 {
 361         struct synaptics_ts_data *ts;
 362         u8 buf0[4];
 363         u8 buf1[8];
 364         struct i2c_msg msg[2];
 365         int ret = 0;
 366         struct synaptics_i2c_rmi_platform_data *pdata;
 367         u32 panel_version = 0;
 368         u16 max_x, max_y;
 369
 370         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 371                 pr_err("synaptics_ts_probe: need I2C_FUNC_I2C\n");
 372                 ret = -ENODEV;
 373                 goto err_check_functionality_failed;
 374         }
 375
 376         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
 377                 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
 378                 ret = -ENODEV;
 379                 goto err_check_functionality_failed;
 380         }
 381
 382         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
 383                 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
 384                 ret = -ENODEV;
 385                 goto err_check_functionality_failed;
 386         }
 387
 388         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 389         if (ts == NULL) {
 390                 ret = -ENOMEM;
 391                 goto err_alloc_data_failed;
 392         }
 393         INIT_WORK(&ts->work, synaptics_ts_work_func);
 394         ts->client = client;
 395         i2c_set_clientdata(client, ts);
 396         pdata = client->dev.platform_data;
 397         if (pdata)
 398                 ts->power = pdata->power;
 399         else
 400                 pdata = &fake_pdata;
 401
 402         if (ts->power) {
 403                 ret = ts->power(1);
 404                 if (ret < 0) {
 405                         pr_err("synaptics_ts_probe power on failed\n");
 406                         goto err_power_failed;
 407                 }
 408         }
 409
 410         ret = detect(ts, &panel_version);
 411         if (ret)
 412                 goto err_detect_failed;
 413
 414         while (pdata->version > panel_version)
 415                 pdata++;
 416         ts->flags = pdata->flags;
 417
 418         ret = i2c_read(ts, 0xf0, "device control");
 419         if (ret < 0)
 420                 goto err_detect_failed;
 421         pr_info("synaptics: device control %x\n", ret);
 422
 423         ret = i2c_read(ts, 0xf1, "interrupt enable");
 424         if (ret < 0)
 425                 goto err_detect_failed;
 426         pr_info("synaptics_ts_probe: interrupt enable %x\n", ret);
 427
 428         ret = i2c_set(ts, 0xf1, 0, "disable interrupt");
 429         if (ret < 0)
 430                 goto err_detect_failed;
 431
 432         msg[0].addr = ts->client->addr;
 433         msg[0].flags = 0;
 434         msg[0].len = 1;
 435         msg[0].buf = buf0;
 436         buf0[0] = 0xe0;
 437         msg[1].addr = ts->client->addr;
 438         msg[1].flags = I2C_M_RD;
 439         msg[1].len = 8;
 440         msg[1].buf = buf1;
 441         ret = i2c_transfer(ts->client->adapter, msg, 2);
 442         if (ret < 0) {
 443                 pr_err("i2c_transfer failed\n");
 444                 goto err_detect_failed;
 445         }
 446         pr_info("synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n",
 447                buf1[0], buf1[1], buf1[2], buf1[3],
 448                buf1[4], buf1[5], buf1[6], buf1[7]);
 449
 450         ret = i2c_set(ts, 0xff, 0x10, "page select = 0x10");
 451         if (ret < 0)
 452                 goto err_detect_failed;
 453
 454         ret = i2c_smbus_read_word_data(ts->client, 0x04);
 455         if (ret < 0) {
 456                 pr_err("i2c_smbus_read_word_data failed\n");
 457                 goto err_detect_failed;
 458         }
 459         ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
 460         ret = i2c_smbus_read_word_data(ts->client, 0x06);
 461         if (ret < 0) {
 462                 pr_err("i2c_smbus_read_word_data failed\n");
 463                 goto err_detect_failed;
 464         }
 465         ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
 466         if (ts->flags & SYNAPTICS_SWAP_XY)
 467                 swap(max_x, max_y);
 468
 469         /* will also switch back to page 0x04 */
 470         ret = synaptics_init_panel(ts);
 471         if (ret < 0) {
 472                 pr_err("synaptics_init_panel failed\n");
 473                 goto err_detect_failed;
 474         }
 475
 476         ts->input_dev = input_allocate_device();
 477         if (ts->input_dev == NULL) {
 478                 ret = -ENOMEM;
 479                 pr_err("synaptics: Failed to allocate input device\n");
 480                 goto err_input_dev_alloc_failed;
 481         }
 482         ts->input_dev->name = "synaptics-rmi-touchscreen";
 483         ts->input_dev->phys = "msm/input0";
 484         ts->input_dev->id.bustype = BUS_I2C;
 485
 486         __set_bit(EV_SYN, ts->input_dev->evbit);
 487         __set_bit(EV_KEY, ts->input_dev->evbit);
 488         __set_bit(BTN_TOUCH, ts->input_dev->keybit);
 489         __set_bit(BTN_2, ts->input_dev->keybit);
 490         __set_bit(EV_ABS, ts->input_dev->evbit);
 491
 492         compute_areas(ts, pdata, max_x, max_y);
 493
 494
 495         ret = input_register_device(ts->input_dev);
 496         if (ret) {
 497                 pr_err("synaptics: Unable to register %s input device\n",
 498                        ts->input_dev->name);
 499                 goto err_input_register_device_failed;
 500         }
 501         if (client->irq) {
 502                 ret = request_irq(client->irq, synaptics_ts_irq_handler,
 503                                   0, client->name, ts);
 504                 if (ret == 0) {
 505                         ret = i2c_set(ts, 0xf1, 0x01, "enable abs int");
 506                         if (ret)
 507                                 free_irq(client->irq, ts);
 508                 }
 509                 if (ret == 0)
 510                         ts->use_irq = 1;
 511                 else
 512                         dev_err(&client->dev, "request_irq failed\n");
 513         }
 514         if (!ts->use_irq) {
 515                 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 516                 ts->timer.function = synaptics_ts_timer_func;
 517                 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
 518         }
 519 #ifdef CONFIG_HAS_EARLYSUSPEND
 520         ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
 521         ts->early_suspend.suspend = synaptics_ts_early_suspend;
 522         ts->early_suspend.resume = synaptics_ts_late_resume;
 523         register_early_suspend(&ts->early_suspend);
 524 #endif
 525
 526         pr_info("synaptics: Start touchscreen %s in %s mode\n",
 527                 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
 528
 529         return 0;
 530
 531 err_input_register_device_failed:
 532         input_free_device(ts->input_dev);
 533
 534 err_input_dev_alloc_failed:
 535 err_detect_failed:
 536 err_power_failed:
 537         kfree(ts);
 538 err_alloc_data_failed:
 539 err_check_functionality_failed:
 540         return ret;
 541 }
 542
 543 static int synaptics_ts_remove(struct i2c_client *client)
 544 {
 545         struct synaptics_ts_data *ts = i2c_get_clientdata(client);
 546 #ifdef CONFIG_HAS_EARLYSUSPEND
 547         unregister_early_suspend(&ts->early_suspend);
 548 #endif
 549         if (ts->use_irq)
 550                 free_irq(client->irq, ts);
 551         else
 552                 hrtimer_cancel(&ts->timer);
 553         input_unregister_device(ts->input_dev);
 554         kfree(ts);
 555         return 0;
 556 }
 557
 558 #ifdef CONFIG_PM
 559 static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
 560 {
 561         int ret;
 562         struct synaptics_ts_data *ts = i2c_get_clientdata(client);
 563
 564         if (ts->use_irq)
 565                 disable_irq(client->irq);
 566         else
 567                 hrtimer_cancel(&ts->timer);
 568         ret = cancel_work_sync(&ts->work);
 569         if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
 570                 enable_irq(client->irq);
 571         i2c_set(ts, 0xf1, 0, "disable interrupt");
 572         i2c_set(ts, 0xf0, 0x86, "deep sleep");
 573
 574         if (ts->power) {
 575                 ret = ts->power(0);
 576                 if (ret < 0)
 577                         pr_err("synaptics_ts_suspend power off failed\n");
 578         }
 579         return 0;
 580 }
 581
 582 static int synaptics_ts_resume(struct i2c_client *client)
 583 {
 584         int ret;
 585         struct synaptics_ts_data *ts = i2c_get_clientdata(client);
 586
 587         if (ts->power) {
 588                 ret = ts->power(1);
 589                 if (ret < 0)
 590                         pr_err("synaptics_ts_resume power on failed\n");
 591         }
 592
 593         synaptics_init_panel(ts);
 594
 595         if (ts->use_irq) {
 596                 enable_irq(client->irq);
 597                 i2c_set(ts, 0xf1, 0x01, "enable abs int");
 598         } else
 599                 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
 600
 601         return 0;
 602 }
 603
 604 #ifdef CONFIG_HAS_EARLYSUSPEND
 605 static void synaptics_ts_early_suspend(struct early_suspend *h)
 606 {
 607         struct synaptics_ts_data *ts;
 608         ts = container_of(h, struct synaptics_ts_data, early_suspend);
 609         synaptics_ts_suspend(ts->client, PMSG_SUSPEND);
 610 }
 611
 612 static void synaptics_ts_late_resume(struct early_suspend *h)
 613 {
 614         struct synaptics_ts_data *ts;
 615         ts = container_of(h, struct synaptics_ts_data, early_suspend);
 616         synaptics_ts_resume(ts->client);
 617 }
 618 #endif
 619 #else
 620 #define synaptics_ts_suspend NULL
 621 #define synaptics_ts_resume NULL
 622 #endif
 623
 624
 625
 626 static const struct i2c_device_id synaptics_ts_id[] = {
 627         { SYNAPTICS_I2C_RMI_NAME, 0 },
 628         { }
 629 };
 630
 631 static struct i2c_driver synaptics_ts_driver = {
 632         .probe          = synaptics_ts_probe,
 633         .remove         = synaptics_ts_remove,
 634 #ifndef CONFIG_HAS_EARLYSUSPEND
 635         .suspend        = synaptics_ts_suspend,
 636         .resume         = synaptics_ts_resume,
 637 #endif
 638         .id_table       = synaptics_ts_id,
 639         .driver = {
 640                 .name   = SYNAPTICS_I2C_RMI_NAME,
 641         },
 642 };
 643
 644 static int __devinit synaptics_ts_init(void)
 645 {
 646         synaptics_wq = create_singlethread_workqueue("synaptics_wq");
 647         if (!synaptics_wq)
 648                 return -ENOMEM;
 649         return i2c_add_driver(&synaptics_ts_driver);
 650 }
 651
 652 static void __exit synaptics_ts_exit(void)
 653 {
 654         i2c_del_driver(&synaptics_ts_driver);
 655         if (synaptics_wq)
 656                 destroy_workqueue(synaptics_wq);
 657 }
 658
 659 module_init(synaptics_ts_init);
 660 module_exit(synaptics_ts_exit);
 661
 662 MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
 663 MODULE_LICENSE("GPL");
 664 MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");