drivers/input/touchscreen/synaptics_i2c_rmi.c

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