drivers/input/touchscreen/atmel_mxt_ts.c

   1 /*
   2  * Atmel maXTouch Touchscreen driver
   3  *
   4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
   5  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/delay.h>
  17 #include <linux/firmware.h>
  18 #include <linux/i2c.h>
  19 #include <linux/i2c/atmel_mxt_ts.h>
  20 #include <linux/input/mt.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/slab.h>
  23
  24 /* Version */
  25 #define MXT_VER_20              20
  26 #define MXT_VER_21              21
  27 #define MXT_VER_22              22
  28
  29 /* Slave addresses */
  30 #define MXT_APP_LOW             0x4a
  31 #define MXT_APP_HIGH            0x4b
  32 #define MXT_BOOT_LOW            0x24
  33 #define MXT_BOOT_HIGH           0x25
  34
  35 /* Firmware */
  36 #define MXT_FW_NAME             "maxtouch.fw"
  37
  38 /* Registers */
  39 #define MXT_INFO                0x00
  40 #define MXT_FAMILY_ID           0x00
  41 #define MXT_VARIANT_ID          0x01
  42 #define MXT_VERSION             0x02
  43 #define MXT_BUILD               0x03
  44 #define MXT_MATRIX_X_SIZE       0x04
  45 #define MXT_MATRIX_Y_SIZE       0x05
  46 #define MXT_OBJECT_NUM          0x06
  47 #define MXT_OBJECT_START        0x07
  48
  49 #define MXT_OBJECT_SIZE         6
  50
  51 /* Object types */
  52 #define MXT_DEBUG_DIAGNOSTIC_T37        37
  53 #define MXT_GEN_MESSAGE_T5              5
  54 #define MXT_GEN_COMMAND_T6              6
  55 #define MXT_GEN_POWER_T7                7
  56 #define MXT_GEN_ACQUIRE_T8              8
  57 #define MXT_GEN_DATASOURCE_T53          53
  58 #define MXT_TOUCH_MULTI_T9              9
  59 #define MXT_TOUCH_KEYARRAY_T15          15
  60 #define MXT_TOUCH_PROXIMITY_T23         23
  61 #define MXT_TOUCH_PROXKEY_T52           52
  62 #define MXT_PROCI_GRIPFACE_T20          20
  63 #define MXT_PROCG_NOISE_T22             22
  64 #define MXT_PROCI_ONETOUCH_T24          24
  65 #define MXT_PROCI_TWOTOUCH_T27          27
  66 #define MXT_PROCI_GRIP_T40              40
  67 #define MXT_PROCI_PALM_T41              41
  68 #define MXT_PROCI_TOUCHSUPPRESSION_T42  42
  69 #define MXT_PROCI_STYLUS_T47            47
  70 #define MXT_PROCG_NOISESUPPRESSION_T48  48
  71 #define MXT_PROCI_ADAPTIVETHRESHOLD_T55 55
  72 #define MXT_PROCI_SHIELDLESS_T56        56
  73 #define MXT_PROCI_EXTRATOUCHSCREENDATA_T57      57
  74 #define MXT_PROCG_NOISESUPPRESSION_T62  62
  75 #define MXT_SPT_COMMSCONFIG_T18         18
  76 #define MXT_SPT_GPIOPWM_T19             19
  77 #define MXT_SPT_SELFTEST_T25            25
  78 #define MXT_SPT_CTECONFIG_T28           28
  79 #define MXT_SPT_USERDATA_T38            38
  80 #define MXT_SPT_DIGITIZER_T43           43
  81 #define MXT_SPT_MESSAGECOUNT_T44        44
  82 #define MXT_SPT_CTECONFIG_T46           46
  83 #define MXT_SPT_TIMER_T61               61
  84
  85 /* MXT_GEN_COMMAND_T6 field */
  86 #define MXT_COMMAND_RESET       0
  87 #define MXT_COMMAND_BACKUPNV    1
  88 #define MXT_COMMAND_CALIBRATE   2
  89 #define MXT_COMMAND_REPORTALL   3
  90 #define MXT_COMMAND_DIAGNOSTIC  5
  91
  92 /* MXT_GEN_POWER_T7 field */
  93 #define MXT_POWER_IDLEACQINT    0
  94 #define MXT_POWER_ACTVACQINT    1
  95 #define MXT_POWER_ACTV2IDLETO   2
  96
  97 /* MXT_GEN_ACQUIRE_T8 field */
  98 #define MXT_ACQUIRE_CHRGTIME    0
  99 #define MXT_ACQUIRE_TCHDRIFT    2
 100 #define MXT_ACQUIRE_DRIFTST     3
 101 #define MXT_ACQUIRE_TCHAUTOCAL  4
 102 #define MXT_ACQUIRE_SYNC        5
 103 #define MXT_ACQUIRE_ATCHCALST   6
 104 #define MXT_ACQUIRE_ATCHCALSTHR 7
 105
 106 /* MXT_TOUCH_MULTI_T9 field */
 107 #define MXT_TOUCH_CTRL          0
 108 #define MXT_TOUCH_XORIGIN       1
 109 #define MXT_TOUCH_YORIGIN       2
 110 #define MXT_TOUCH_XSIZE         3
 111 #define MXT_TOUCH_YSIZE         4
 112 #define MXT_TOUCH_BLEN          6
 113 #define MXT_TOUCH_TCHTHR        7
 114 #define MXT_TOUCH_TCHDI         8
 115 #define MXT_TOUCH_ORIENT        9
 116 #define MXT_TOUCH_MOVHYSTI      11
 117 #define MXT_TOUCH_MOVHYSTN      12
 118 #define MXT_TOUCH_NUMTOUCH      14
 119 #define MXT_TOUCH_MRGHYST       15
 120 #define MXT_TOUCH_MRGTHR        16
 121 #define MXT_TOUCH_AMPHYST       17
 122 #define MXT_TOUCH_XRANGE_LSB    18
 123 #define MXT_TOUCH_XRANGE_MSB    19
 124 #define MXT_TOUCH_YRANGE_LSB    20
 125 #define MXT_TOUCH_YRANGE_MSB    21
 126 #define MXT_TOUCH_XLOCLIP       22
 127 #define MXT_TOUCH_XHICLIP       23
 128 #define MXT_TOUCH_YLOCLIP       24
 129 #define MXT_TOUCH_YHICLIP       25
 130 #define MXT_TOUCH_XEDGECTRL     26
 131 #define MXT_TOUCH_XEDGEDIST     27
 132 #define MXT_TOUCH_YEDGECTRL     28
 133 #define MXT_TOUCH_YEDGEDIST     29
 134 #define MXT_TOUCH_JUMPLIMIT     30
 135
 136 /* MXT_PROCI_GRIPFACE_T20 field */
 137 #define MXT_GRIPFACE_CTRL       0
 138 #define MXT_GRIPFACE_XLOGRIP    1
 139 #define MXT_GRIPFACE_XHIGRIP    2
 140 #define MXT_GRIPFACE_YLOGRIP    3
 141 #define MXT_GRIPFACE_YHIGRIP    4
 142 #define MXT_GRIPFACE_MAXTCHS    5
 143 #define MXT_GRIPFACE_SZTHR1     7
 144 #define MXT_GRIPFACE_SZTHR2     8
 145 #define MXT_GRIPFACE_SHPTHR1    9
 146 #define MXT_GRIPFACE_SHPTHR2    10
 147 #define MXT_GRIPFACE_SUPEXTTO   11
 148
 149 /* MXT_PROCI_NOISE field */
 150 #define MXT_NOISE_CTRL          0
 151 #define MXT_NOISE_OUTFLEN       1
 152 #define MXT_NOISE_GCAFUL_LSB    3
 153 #define MXT_NOISE_GCAFUL_MSB    4
 154 #define MXT_NOISE_GCAFLL_LSB    5
 155 #define MXT_NOISE_GCAFLL_MSB    6
 156 #define MXT_NOISE_ACTVGCAFVALID 7
 157 #define MXT_NOISE_NOISETHR      8
 158 #define MXT_NOISE_FREQHOPSCALE  10
 159 #define MXT_NOISE_FREQ0         11
 160 #define MXT_NOISE_FREQ1         12
 161 #define MXT_NOISE_FREQ2         13
 162 #define MXT_NOISE_FREQ3         14
 163 #define MXT_NOISE_FREQ4         15
 164 #define MXT_NOISE_IDLEGCAFVALID 16
 165
 166 /* MXT_SPT_COMMSCONFIG_T18 */
 167 #define MXT_COMMS_CTRL          0
 168 #define MXT_COMMS_CMD           1
 169
 170 /* MXT_SPT_CTECONFIG_T28 field */
 171 #define MXT_CTE_CTRL            0
 172 #define MXT_CTE_CMD             1
 173 #define MXT_CTE_MODE            2
 174 #define MXT_CTE_IDLEGCAFDEPTH   3
 175 #define MXT_CTE_ACTVGCAFDEPTH   4
 176 #define MXT_CTE_VOLTAGE         5
 177
 178 #define MXT_VOLTAGE_DEFAULT     2700000
 179 #define MXT_VOLTAGE_STEP        10000
 180
 181 /* Define for MXT_GEN_COMMAND_T6 */
 182 #define MXT_BOOT_VALUE          0xa5
 183 #define MXT_BACKUP_VALUE        0x55
 184 #define MXT_BACKUP_TIME         270     /* msec */
 185 #define MXT_RESET_TIME          350     /* msec */
 186 #define MXT_CAL_TIME            25      /* msec */
 187
 188 #define MXT_FWRESET_TIME        175     /* msec */
 189
 190 /* MXT_SPT_GPIOPWM_T19 field */
 191 #define MXT_GPIO0_MASK          0x04
 192 #define MXT_GPIO1_MASK          0x08
 193 #define MXT_GPIO2_MASK          0x10
 194 #define MXT_GPIO3_MASK          0x20
 195
 196 /* Command to unlock bootloader */
 197 #define MXT_UNLOCK_CMD_MSB      0xaa
 198 #define MXT_UNLOCK_CMD_LSB      0xdc
 199
 200 /* Bootloader mode status */
 201 #define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
 202 #define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
 203 #define MXT_FRAME_CRC_CHECK     0x02
 204 #define MXT_FRAME_CRC_FAIL      0x03
 205 #define MXT_FRAME_CRC_PASS      0x04
 206 #define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
 207 #define MXT_BOOT_STATUS_MASK    0x3f
 208
 209 /* Touch status */
 210 #define MXT_UNGRIP              (1 << 0)
 211 #define MXT_SUPPRESS            (1 << 1)
 212 #define MXT_AMP                 (1 << 2)
 213 #define MXT_VECTOR              (1 << 3)
 214 #define MXT_MOVE                (1 << 4)
 215 #define MXT_RELEASE             (1 << 5)
 216 #define MXT_PRESS               (1 << 6)
 217 #define MXT_DETECT              (1 << 7)
 218
 219 /* Touch orient bits */
 220 #define MXT_XY_SWITCH           (1 << 0)
 221 #define MXT_X_INVERT            (1 << 1)
 222 #define MXT_Y_INVERT            (1 << 2)
 223
 224 /* Touchscreen absolute values */
 225 #define MXT_MAX_AREA            0xff
 226
 227 #define MXT_MAX_FINGER          10
 228
 229 /* For CMT (must match XRANGE/YRANGE as defined in board config */
 230 #define MXT_PIXELS_PER_MM       20
 231
 232 struct mxt_info {
 233         u8 family_id;
 234         u8 variant_id;
 235         u8 version;
 236         u8 build;
 237         u8 matrix_xsize;
 238         u8 matrix_ysize;
 239         u8 object_num;
 240 };
 241
 242 struct mxt_object {
 243         u8 type;
 244         u16 start_address;
 245         u16 size;
 246         u16 instances;
 247         u8 num_report_ids;
 248 };
 249
 250 struct mxt_message {
 251         u8 reportid;
 252         u8 message[7];
 253 };
 254
 255 /* Each client has this additional data */
 256 struct mxt_data {
 257         struct i2c_client *client;
 258         struct input_dev *input_dev;
 259         const struct mxt_platform_data *pdata;
 260         struct mxt_object *object_table;
 261         struct mxt_info info;
 262         bool is_tp;
 263
 264         unsigned int irq;
 265         unsigned int max_x;
 266         unsigned int max_y;
 267
 268         /* Cached parameters from object table */
 269         u16 T5_address;
 270         u8 T6_reportid;
 271         u8 T9_reportid_min;
 272         u8 T9_reportid_max;
 273         u8 T19_reportid;
 274         u16 T44_address;
 275 };
 276
 277 static bool mxt_object_readable(unsigned int type)
 278 {
 279         switch (type) {
 280         case MXT_GEN_COMMAND_T6:
 281         case MXT_GEN_POWER_T7:
 282         case MXT_GEN_ACQUIRE_T8:
 283         case MXT_GEN_DATASOURCE_T53:
 284         case MXT_TOUCH_MULTI_T9:
 285         case MXT_TOUCH_KEYARRAY_T15:
 286         case MXT_TOUCH_PROXIMITY_T23:
 287         case MXT_TOUCH_PROXKEY_T52:
 288         case MXT_PROCI_GRIPFACE_T20:
 289         case MXT_PROCG_NOISE_T22:
 290         case MXT_PROCI_ONETOUCH_T24:
 291         case MXT_PROCI_TWOTOUCH_T27:
 292         case MXT_PROCI_GRIP_T40:
 293         case MXT_PROCI_PALM_T41:
 294         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 295         case MXT_PROCI_STYLUS_T47:
 296         case MXT_PROCG_NOISESUPPRESSION_T48:
 297         case MXT_PROCI_ADAPTIVETHRESHOLD_T55:
 298         case MXT_PROCI_SHIELDLESS_T56:
 299         case MXT_PROCI_EXTRATOUCHSCREENDATA_T57:
 300         case MXT_PROCG_NOISESUPPRESSION_T62:
 301         case MXT_SPT_COMMSCONFIG_T18:
 302         case MXT_SPT_GPIOPWM_T19:
 303         case MXT_SPT_SELFTEST_T25:
 304         case MXT_SPT_CTECONFIG_T28:
 305         case MXT_DEBUG_DIAGNOSTIC_T37:
 306         case MXT_SPT_DIGITIZER_T43:
 307         case MXT_SPT_CTECONFIG_T46:
 308         case MXT_SPT_TIMER_T61:
 309                 return true;
 310         default:
 311                 return false;
 312         }
 313 }
 314
 315 static bool mxt_object_writable(unsigned int type)
 316 {
 317         switch (type) {
 318         case MXT_GEN_COMMAND_T6:
 319         case MXT_GEN_POWER_T7:
 320         case MXT_GEN_ACQUIRE_T8:
 321         case MXT_TOUCH_MULTI_T9:
 322         case MXT_TOUCH_KEYARRAY_T15:
 323         case MXT_TOUCH_PROXIMITY_T23:
 324         case MXT_TOUCH_PROXKEY_T52:
 325         case MXT_PROCI_GRIPFACE_T20:
 326         case MXT_PROCG_NOISE_T22:
 327         case MXT_PROCI_ONETOUCH_T24:
 328         case MXT_PROCI_TWOTOUCH_T27:
 329         case MXT_PROCI_GRIP_T40:
 330         case MXT_PROCI_PALM_T41:
 331         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 332         case MXT_PROCI_STYLUS_T47:
 333         case MXT_PROCG_NOISESUPPRESSION_T48:
 334         case MXT_PROCI_ADAPTIVETHRESHOLD_T55:
 335         case MXT_PROCI_SHIELDLESS_T56:
 336         case MXT_PROCI_EXTRATOUCHSCREENDATA_T57:
 337         case MXT_PROCG_NOISESUPPRESSION_T62:
 338         case MXT_SPT_COMMSCONFIG_T18:
 339         case MXT_SPT_GPIOPWM_T19:
 340         case MXT_SPT_SELFTEST_T25:
 341         case MXT_SPT_CTECONFIG_T28:
 342         case MXT_SPT_DIGITIZER_T43:
 343         case MXT_SPT_CTECONFIG_T46:
 344         case MXT_SPT_TIMER_T61:
 345                 return true;
 346         default:
 347                 return false;
 348         }
 349 }
 350
 351 static void mxt_dump_message(struct device *dev,
 352                              struct mxt_message *message)
 353 {
 354         dev_dbg(dev, "reportid: %u\tmessage: %02x %02x %02x %02x %02x %02x %02x\n",
 355                 message->reportid, message->message[0], message->message[1],
 356                 message->message[2], message->message[3], message->message[4],
 357                 message->message[5], message->message[6]);
 358 }
 359
 360 static int mxt_check_bootloader(struct i2c_client *client,
 361                                      unsigned int state)
 362 {
 363         u8 val;
 364
 365 recheck:
 366         if (i2c_master_recv(client, &val, 1) != 1) {
 367                 dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
 368                 return -EIO;
 369         }
 370
 371         switch (state) {
 372         case MXT_WAITING_BOOTLOAD_CMD:
 373         case MXT_WAITING_FRAME_DATA:
 374                 val &= ~MXT_BOOT_STATUS_MASK;
 375                 break;
 376         case MXT_FRAME_CRC_PASS:
 377                 if (val == MXT_FRAME_CRC_CHECK)
 378                         goto recheck;
 379                 break;
 380         default:
 381                 return -EINVAL;
 382         }
 383
 384         if (val != state) {
 385                 dev_err(&client->dev, "Unvalid bootloader mode state\n");
 386                 return -EINVAL;
 387         }
 388
 389         return 0;
 390 }
 391
 392 static int mxt_unlock_bootloader(struct i2c_client *client)
 393 {
 394         u8 buf[2];
 395
 396         buf[0] = MXT_UNLOCK_CMD_LSB;
 397         buf[1] = MXT_UNLOCK_CMD_MSB;
 398
 399         if (i2c_master_send(client, buf, 2) != 2) {
 400                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 401                 return -EIO;
 402         }
 403
 404         return 0;
 405 }
 406
 407 static int mxt_fw_write(struct i2c_client *client,
 408                              const u8 *data, unsigned int frame_size)
 409 {
 410         if (i2c_master_send(client, data, frame_size) != frame_size) {
 411                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 412                 return -EIO;
 413         }
 414
 415         return 0;
 416 }
 417
 418 #ifdef DEBUG
 419 #define DUMP_LEN        16
 420 static void mxt_dump_xfer(struct device *dev, const char *func, u16 reg,
 421                           u16 len, const u8 *val)
 422 {
 423         /* Rough guess for string size */
 424         char str[DUMP_LEN * 3 + 2];
 425         int i;
 426         size_t n;
 427
 428         for (i = 0, n = 0; i < len; i++) {
 429                 n += snprintf(&str[n], sizeof(str) - n, "%02x ", val[i]);
 430                 if ((i + 1) % DUMP_LEN == 0 || (i + 1) == len) {
 431                         dev_dbg(dev,
 432                                 "%s(reg: %d len: %d offset: 0x%02x): %s\n",
 433                                 func, reg, len, (i / DUMP_LEN) * DUMP_LEN,
 434                                 str);
 435                         n = 0;
 436                 }
 437         }
 438 }
 439 #undef DUMP_LEN
 440 #else
 441 static void mxt_dump_xfer(struct device *dev, const char *func, u16 reg,
 442                           u16 len, const u8 *val) { }
 443 #endif
 444
 445 static int mxt_read_reg(struct i2c_client *client, u16 reg, u16 len, void *val)
 446 {
 447         struct i2c_msg xfer[2];
 448         u8 buf[2];
 449
 450         buf[0] = reg & 0xff;
 451         buf[1] = (reg >> 8) & 0xff;
 452
 453         /* Write register */
 454         xfer[0].addr = client->addr;
 455         xfer[0].flags = 0;
 456         xfer[0].len = 2;
 457         xfer[0].buf = buf;
 458
 459         /* Read data */
 460         xfer[1].addr = client->addr;
 461         xfer[1].flags = I2C_M_RD;
 462         xfer[1].len = len;
 463         xfer[1].buf = val;
 464
 465         if (i2c_transfer(client->adapter, xfer, 2) != 2) {
 466                 dev_err(&client->dev, "%s: i2c read failed\n", __func__);
 467                 return -EIO;
 468         }
 469
 470         mxt_dump_xfer(&client->dev, __func__, reg, len, val);
 471
 472         return 0;
 473 }
 474
 475 static int mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 476                          const void *val)
 477 {
 478         size_t count = 2 + len;         /* + 2-byte offset */
 479         u8 buf[count];
 480
 481         buf[0] = reg & 0xff;
 482         buf[1] = (reg >> 8) & 0xff;
 483         memcpy(&buf[2], val, len);
 484
 485         mxt_dump_xfer(&client->dev, __func__, reg, len, val);
 486
 487         if (i2c_master_send(client, buf, count) != count) {
 488                 dev_err(&client->dev, "%s: i2c write failed\n", __func__);
 489                 return -EIO;
 490         }
 491
 492         return 0;
 493 }
 494
 495 static struct mxt_object *mxt_get_object(struct mxt_data *data, u8 type)
 496 {
 497         struct mxt_object *object;
 498         int i;
 499
 500         for (i = 0; i < data->info.object_num; i++) {
 501                 object = data->object_table + i;
 502                 if (object->type == type)
 503                         return object;
 504         }
 505
 506         dev_err(&data->client->dev, "Invalid object type\n");
 507         return NULL;
 508 }
 509
 510 static int mxt_read_object(struct mxt_data *data, struct mxt_object *object,
 511                            u8 instance, void *val)
 512 {
 513         u16 addr;
 514
 515         BUG_ON(instance >= object->instances);
 516         addr = object->start_address + instance * object->size;
 517         return mxt_read_reg(data->client, addr, object->size, val);
 518 }
 519
 520 static int mxt_write_object(struct mxt_data *data, u8 type, u8 instance,
 521                             u8 offset, u8 val)
 522 {
 523         struct mxt_object *object;
 524         u16 reg;
 525
 526         object = mxt_get_object(data, type);
 527         if (!object || instance >= object->instances || offset >= object->size)
 528                 return -EINVAL;
 529
 530         reg = object->start_address + instance * object->size + offset;
 531         return mxt_write_reg(data->client, reg, 1, &val);
 532 }
 533
 534 static int mxt_read_num_messages(struct mxt_data *data, u8 *count)
 535 {
 536         /* TODO: Optimization: read first message along with message count */
 537         return mxt_read_reg(data->client, data->T44_address, 1, count);
 538 }
 539
 540 static int mxt_read_messages(struct mxt_data *data, u8 count,
 541                              struct mxt_message *messages)
 542 {
 543         return mxt_read_reg(data->client, data->T5_address,
 544                             sizeof(struct mxt_message) * count, messages);
 545 }
 546
 547 static void mxt_input_button(struct mxt_data *data, struct mxt_message *message)
 548 {
 549         struct device *dev = &data->client->dev;
 550         struct input_dev *input = data->input_dev;
 551         bool button;
 552
 553         /* Active-low switch */
 554         button = !(message->message[0] & MXT_GPIO3_MASK);
 555         input_report_key(input, BTN_LEFT, button);
 556         dev_dbg(dev, "Button state: %d\n", button);
 557 }
 558
 559 static void mxt_input_touch(struct mxt_data *data, struct mxt_message *message)
 560 {
 561         struct device *dev = &data->client->dev;
 562         struct input_dev *input_dev = data->input_dev;
 563         u8 status;
 564         int x;
 565         int y;
 566         int area;
 567         int amplitude;
 568         int vector1, vector2;
 569         int id;
 570
 571         id = message->reportid - data->T9_reportid_min;
 572
 573         status = message->message[0];
 574         x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
 575         y = (message->message[2] << 4) | ((message->message[3] & 0xf));
 576         if (data->max_x < 1024)
 577                 x >>= 2;
 578         if (data->max_y < 1024)
 579                 y >>= 2;
 580
 581         area = message->message[4];
 582         amplitude = message->message[5];
 583
 584         /* The two vector components are 4-bit signed ints (2s complement) */
 585         vector1 = (signed)((signed char)message->message[6]) >> 4;
 586         vector2 = (signed)((signed char)(message->message[6] << 4)) >> 4;
 587
 588         dev_dbg(dev,
 589                 "[%d] %c%c%c%c%c%c%c%c x: %d y: %d area: %d amp: %d vector: [%d,%d]\n",
 590                 id,
 591                 (status & MXT_DETECT) ? 'D' : '.',
 592                 (status & MXT_PRESS) ? 'P' : '.',
 593                 (status & MXT_RELEASE) ? 'R' : '.',
 594                 (status & MXT_MOVE) ? 'M' : '.',
 595                 (status & MXT_VECTOR) ? 'V' : '.',
 596                 (status & MXT_AMP) ? 'A' : '.',
 597                 (status & MXT_SUPPRESS) ? 'S' : '.',
 598                 (status & MXT_UNGRIP) ? 'U' : '.',
 599                 x, y, area, amplitude, vector1, vector2);
 600
 601         input_mt_slot(input_dev, id);
 602         input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
 603                                    status & MXT_DETECT);
 604
 605         if (status & MXT_DETECT) {
 606                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 607                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 608                 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 609                 /* TODO: This should really be sqrt(area) */
 610                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 611                 /* TODO: Use vector to report ORIENTATION & TOUCH_MINOR */
 612         }
 613 }
 614
 615 static int mxt_proc_messages(struct mxt_data *data, u8 count)
 616 {
 617         struct device *dev = &data->client->dev;
 618         struct mxt_message messages[count], *msg;
 619         int ret;
 620         bool update_input;
 621
 622         ret = mxt_read_messages(data, count, messages);
 623         if (ret) {
 624                 dev_err(dev, "Failed to read %u messages (%d).\n", count, ret);
 625                 return ret;
 626         }
 627
 628         update_input = false;
 629         for (msg = messages; msg < &messages[count]; msg++) {
 630                 mxt_dump_message(dev, msg);
 631
 632                 if (msg->reportid >= data->T9_reportid_min &&
 633                     msg->reportid <= data->T9_reportid_max) {
 634                         mxt_input_touch(data, msg);
 635                         update_input = true;
 636                 } else if (msg->reportid == data->T19_reportid) {
 637                         mxt_input_button(data, msg);
 638                         update_input = true;
 639                 } else if (msg->reportid == data->T6_reportid) {
 640                         unsigned csum = msg->message[1] |
 641                                         (msg->message[2] << 8) |
 642                                         (msg->message[3] << 16);
 643                         dev_info(dev, "Status: %02x Config Checksum: %06x\n",
 644                                  msg->message[0], csum);
 645                 }
 646         }
 647
 648         if (update_input) {
 649                 input_mt_report_pointer_emulation(data->input_dev,
 650                                                   data->is_tp);
 651                 input_sync(data->input_dev);
 652         }
 653
 654         return 0;
 655 }
 656
 657 static int mxt_handle_messages(struct mxt_data *data)
 658 {
 659         struct device *dev = &data->client->dev;
 660         int ret;
 661         u8 count;
 662
 663         ret = mxt_read_num_messages(data, &count);
 664         if (ret) {
 665                 dev_err(dev, "Failed to read message count (%d).\n", ret);
 666                 return ret;
 667         }
 668
 669         if (count > 0)
 670                 ret = mxt_proc_messages(data, count);
 671
 672         return ret;
 673 }
 674
 675 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 676 {
 677         mxt_handle_messages(dev_id);
 678         return IRQ_HANDLED;
 679 }
 680
 681 static int mxt_check_reg_init(struct mxt_data *data)
 682 {
 683         const struct mxt_platform_data *pdata = data->pdata;
 684         struct device *dev = &data->client->dev;
 685         int i, offset;
 686         int ret;
 687
 688         if (!pdata->config) {
 689                 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
 690                 return 0;
 691         }
 692
 693         for (offset = 0, i = 0; i < data->info.object_num; i++) {
 694                 struct mxt_object *object = &data->object_table[i];
 695                 size_t config_size;
 696
 697                 if (!mxt_object_writable(object->type))
 698                         continue;
 699
 700                 config_size = object->size * object->instances;
 701                 if (offset + config_size > pdata->config_length) {
 702                         dev_err(dev, "Not enough config data!\n");
 703                         return -EINVAL;
 704                 }
 705
 706                 ret = mxt_write_reg(data->client, object->start_address,
 707                                     config_size, &pdata->config[offset]);
 708                 if (ret)
 709                         return ret;
 710                 offset += config_size;
 711         }
 712
 713         return 0;
 714 }
 715
 716 static void mxt_handle_pdata(struct mxt_data *data)
 717 {
 718         const struct mxt_platform_data *pdata = data->pdata;
 719         u8 voltage;
 720
 721         /* Set touchscreen lines */
 722         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 723                          MXT_TOUCH_XSIZE, pdata->x_line);
 724         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 725                          MXT_TOUCH_YSIZE, pdata->y_line);
 726
 727         /* Set touchscreen orient */
 728         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 729                          MXT_TOUCH_ORIENT, pdata->orient);
 730
 731         /* Set touchscreen burst length */
 732         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 733                          MXT_TOUCH_BLEN, pdata->blen);
 734
 735         /* Set touchscreen threshold */
 736         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 737                          MXT_TOUCH_TCHTHR, pdata->threshold);
 738
 739         /* Set touchscreen resolution */
 740         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 741                          MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
 742         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 743                          MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
 744         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 745                          MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
 746         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 747                          MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
 748
 749         /* Set touchscreen voltage */
 750         if (pdata->voltage) {
 751                 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
 752                         voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
 753                                 MXT_VOLTAGE_STEP;
 754                         voltage = 0xff - voltage + 1;
 755                 } else
 756                         voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
 757                                 MXT_VOLTAGE_STEP;
 758
 759                 mxt_write_object(data, MXT_SPT_CTECONFIG_T28, 0,
 760                                  MXT_CTE_VOLTAGE, voltage);
 761         }
 762 }
 763
 764 static int mxt_get_object_table(struct mxt_data *data)
 765 {
 766         struct i2c_client *client = data->client;
 767         struct device *dev = &client->dev;
 768         int error;
 769         int i;
 770         u8 reportid;
 771         u8 buf[data->info.object_num][MXT_OBJECT_SIZE];
 772
 773         data->object_table = kcalloc(data->info.object_num,
 774                                      sizeof(struct mxt_object), GFP_KERNEL);
 775         if (!data->object_table) {
 776                 dev_err(dev, "Failed to allocate object table\n");
 777                 return -ENOMEM;
 778         }
 779
 780         error = mxt_read_reg(client, MXT_OBJECT_START, sizeof(buf), buf);
 781         if (error)
 782                 return error;
 783
 784         /* Vaild Report IDs start counting from 1. */
 785         reportid = 1;
 786         for (i = 0; i < data->info.object_num; i++) {
 787                 struct mxt_object *object = &data->object_table[i];
 788                 u8 num_ids, min_id, max_id;
 789
 790                 object->type = buf[i][0];
 791                 object->start_address = (buf[i][2] << 8) | buf[i][1];
 792                 object->size = buf[i][3] + 1;
 793                 object->instances = buf[i][4] + 1;
 794                 object->num_report_ids = buf[i][5];
 795
 796                 num_ids = object->num_report_ids * object->instances;
 797                 min_id = num_ids ? reportid : 0;
 798                 max_id = num_ids ? reportid + num_ids - 1 : 0;
 799                 reportid += num_ids;
 800
 801                 dev_info(dev,
 802                          "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
 803                          object->type, object->start_address, object->size,
 804                          object->instances, min_id, max_id);
 805
 806                 /* Save data for objects used when processing interrupts */
 807                 switch (object->type) {
 808                 case MXT_GEN_MESSAGE_T5:
 809                         data->T5_address = object->start_address;
 810                         break;
 811                 case MXT_GEN_COMMAND_T6:
 812                         data->T6_reportid = min_id;
 813                         break;
 814                 case MXT_TOUCH_MULTI_T9:
 815                         data->T9_reportid_min = min_id;
 816                         data->T9_reportid_max = max_id;
 817                         break;
 818                 case MXT_SPT_GPIOPWM_T19:
 819                         data->T19_reportid = min_id;
 820                         break;
 821                 case MXT_SPT_MESSAGECOUNT_T44:
 822                         data->T44_address = object->start_address;
 823                         break;
 824                 }
 825         }
 826
 827         return 0;
 828 }
 829
 830 static int mxt_initialize(struct mxt_data *data)
 831 {
 832         struct i2c_client *client = data->client;
 833         struct device *dev = &client->dev;
 834         struct mxt_info *info = &data->info;
 835         int error;
 836
 837         /* Read 7-byte info block starting at address 0 */
 838         error = mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
 839         if (error)
 840                 return error;
 841
 842         /* Get object table information */
 843         error = mxt_get_object_table(data);
 844         if (error)
 845                 return error;
 846
 847         /* Check register init values */
 848         error = mxt_check_reg_init(data);
 849         if (error)
 850                 return error;
 851
 852         mxt_handle_pdata(data);
 853
 854         /* Backup to memory */
 855         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 856                          MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
 857         msleep(MXT_BACKUP_TIME);
 858
 859         /* Soft reset */
 860         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0, MXT_COMMAND_RESET, 1);
 861         msleep(MXT_RESET_TIME);
 862
 863         /* Update matrix size, since it may have been modified by pdata */
 864         error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, 2,
 865                              &info->matrix_xsize);
 866         if (error)
 867                 return error;
 868
 869         dev_info(dev, "Family ID: %d Variant ID: %d Major.Minor.Build: %d.%d.%d\n",
 870                  info->family_id, info->variant_id, info->version >> 4,
 871                  info->version & 0xf, info->build);
 872
 873         dev_info(dev, "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n",
 874                  info->matrix_xsize, info->matrix_ysize, info->object_num);
 875
 876         return 0;
 877 }
 878
 879 static void mxt_calc_resolution(struct mxt_data *data)
 880 {
 881         unsigned int max_x = data->pdata->x_size - 1;
 882         unsigned int max_y = data->pdata->y_size - 1;
 883
 884         if (data->pdata->orient & MXT_XY_SWITCH) {
 885                 data->max_x = max_y;
 886                 data->max_y = max_x;
 887         } else {
 888                 data->max_x = max_x;
 889                 data->max_y = max_y;
 890         }
 891 }
 892
 893 static int mxt_load_fw(struct device *dev, const char *fn)
 894 {
 895         struct mxt_data *data = dev_get_drvdata(dev);
 896         struct i2c_client *client = data->client;
 897         const struct firmware *fw = NULL;
 898         unsigned int frame_size;
 899         unsigned int pos = 0;
 900         int ret;
 901
 902         ret = request_firmware(&fw, fn, dev);
 903         if (ret) {
 904                 dev_err(dev, "Unable to open firmware %s\n", fn);
 905                 return ret;
 906         }
 907
 908         if (client->addr == MXT_BOOT_LOW || client->addr == MXT_BOOT_HIGH) {
 909                 /* already in bootloader mode. */
 910                 goto bootloader_ready;
 911         }
 912
 913         /* Change to the bootloader mode */
 914         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 915                          MXT_COMMAND_RESET, MXT_BOOT_VALUE);
 916         msleep(MXT_RESET_TIME);
 917
 918         /* Change to slave address of bootloader */
 919         if (client->addr == MXT_APP_LOW)
 920                 client->addr = MXT_BOOT_LOW;
 921         else
 922                 client->addr = MXT_BOOT_HIGH;
 923
 924 bootloader_ready:
 925         ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
 926         if (ret)
 927                 goto out;
 928
 929         /* Unlock bootloader */
 930         mxt_unlock_bootloader(client);
 931
 932         while (pos < fw->size) {
 933                 ret = mxt_check_bootloader(client,
 934                                                 MXT_WAITING_FRAME_DATA);
 935                 if (ret)
 936                         goto out;
 937
 938                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
 939
 940                 /* We should add 2 at frame size as the the firmware data is not
 941                  * included the CRC bytes.
 942                  */
 943                 frame_size += 2;
 944
 945                 /* Write one frame to device */
 946                 mxt_fw_write(client, fw->data + pos, frame_size);
 947
 948                 ret = mxt_check_bootloader(client,
 949                                                 MXT_FRAME_CRC_PASS);
 950                 if (ret)
 951                         goto out;
 952
 953                 pos += frame_size;
 954
 955                 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
 956         }
 957
 958 out:
 959         release_firmware(fw);
 960
 961         /* Change to slave address of application */
 962         if (client->addr == MXT_BOOT_LOW)
 963                 client->addr = MXT_APP_LOW;
 964         else
 965                 client->addr = MXT_APP_HIGH;
 966
 967         return ret;
 968 }
 969
 970 /**
 971  * sysfs interface
 972  **/
 973 static ssize_t mxt_backupnv_store(struct device *dev,
 974                                   struct device_attribute *attr,
 975                                   const char *buf, size_t count)
 976 {
 977         struct mxt_data *data = dev_get_drvdata(dev);
 978         int ret;
 979
 980         /* Backup non-volatile memory */
 981         ret = mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 982                                MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
 983         if (ret)
 984                 return ret;
 985         msleep(MXT_BACKUP_TIME);
 986
 987         return count;
 988 }
 989
 990 static ssize_t mxt_calibrate_store(struct device *dev,
 991                                    struct device_attribute *attr,
 992                                    const char *buf, size_t count)
 993 {
 994         struct mxt_data *data = dev_get_drvdata(dev);
 995         int ret;
 996
 997         disable_irq(data->irq);
 998
 999         /* Perform touch surface recalibration */
1000         ret = mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
1001                                MXT_COMMAND_CALIBRATE, 1);
1002         if (ret)
1003                 return ret;
1004         msleep(MXT_CAL_TIME);
1005
1006         enable_irq(data->irq);
1007
1008         return count;
1009 }
1010
1011 static ssize_t mxt_fw_version_show(struct device *dev,
1012                                struct device_attribute *attr, char *buf)
1013 {
1014         struct mxt_data *data = dev_get_drvdata(dev);
1015         struct mxt_info *info = &data->info;
1016         return scnprintf(buf, PAGE_SIZE,
1017                          "Family ID: %d Variant ID: %d Major.Minor.Build: %d.%d.%d\n",
1018                          info->family_id, info->variant_id,
1019                          info->version >> 4, info->version & 0xf, info->build);
1020 }
1021
1022 static ssize_t mxt_object_show(struct device *dev,
1023                                struct device_attribute *attr, char *buf)
1024 {
1025         struct mxt_data *data = dev_get_drvdata(dev);
1026         int count = 0;
1027         int i, j, k;
1028         int error;
1029
1030         for (i = 0; i < data->info.object_num; i++) {
1031                 struct mxt_object *object = &data->object_table[i];
1032
1033                 if (!mxt_object_readable(object->type))
1034                         continue;
1035
1036                 for (j = 0; j < object->instances; j++) {
1037                         u8 obuf[object->size];
1038
1039                         count += snprintf(buf + count, PAGE_SIZE - count,
1040                                           "Object[%d] Type: T%d Instance: %d/%d\n",
1041                                           i + 1, object->type, j + 1,
1042                                           object->instances);
1043                         if (count >= PAGE_SIZE)
1044                                 return PAGE_SIZE - 1;
1045
1046
1047                         error = mxt_read_object(data, object, j, obuf);
1048                         if (error)
1049                                 return error;
1050
1051                         for (k = 0; k < object->size; k++) {
1052                                 count += snprintf(buf + count,
1053                                                   PAGE_SIZE - count,
1054                                                   "\t[%2d]: %02x (%d)\n",
1055                                                   k, obuf[k], obuf[k]);
1056                                 if (count >= PAGE_SIZE)
1057                                         return PAGE_SIZE - 1;
1058                         }
1059
1060                         count += snprintf(buf + count, PAGE_SIZE - count, "\n");
1061                         if (count >= PAGE_SIZE)
1062                                 return PAGE_SIZE - 1;
1063                 }
1064         }
1065
1066         return count;
1067 }
1068
1069 static ssize_t mxt_object_store(struct device *dev,
1070                                 struct device_attribute *attr,
1071                                 const char *buf, size_t count)
1072 {
1073         struct mxt_data *data = dev_get_drvdata(dev);
1074         int ret;
1075         u32 param;
1076         u8 type, instance, offset, val;
1077
1078         ret = kstrtou32(buf, 16, &param);
1079         if (ret < 0)
1080                 return -EINVAL;
1081
1082         /*
1083          * Byte Write Command is encoded in 32-bit word: TTIIOOVV:
1084          * <Type> <Instance> <Offset> <Value>
1085          */
1086         type = (param & 0xff000000) >> 24;
1087         instance = (param & 0x00ff0000) >> 16;
1088         offset = (param & 0x0000ff00) >> 8;
1089         val = param & 0x000000ff;
1090
1091         ret = mxt_write_object(data, type, instance, offset, val);
1092         if (ret)
1093                 return ret;
1094
1095         return count;
1096 }
1097
1098 static ssize_t mxt_update_fw_store(struct device *dev,
1099                                         struct device_attribute *attr,
1100                                         const char *buf, size_t count)
1101 {
1102         struct mxt_data *data = dev_get_drvdata(dev);
1103         int error;
1104
1105         disable_irq(data->irq);
1106
1107         error = mxt_load_fw(dev, MXT_FW_NAME);
1108         if (error) {
1109                 dev_err(dev, "The firmware update failed(%d)\n", error);
1110                 count = error;
1111         } else {
1112                 dev_dbg(dev, "The firmware update succeeded\n");
1113
1114                 /* Wait for reset */
1115                 msleep(MXT_FWRESET_TIME);
1116
1117                 kfree(data->object_table);
1118                 data->object_table = NULL;
1119
1120                 mxt_initialize(data);
1121         }
1122
1123         enable_irq(data->irq);
1124
1125         error = mxt_handle_messages(data);
1126         if (error)
1127                 return error;
1128
1129         return count;
1130 }
1131
1132 static DEVICE_ATTR(backupnv, S_IWUSR, NULL, mxt_backupnv_store);
1133 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, mxt_calibrate_store);
1134 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1135 static DEVICE_ATTR(object, S_IRUGO | S_IWUSR, mxt_object_show,
1136                    mxt_object_store);
1137 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1138
1139 static struct attribute *mxt_attrs[] = {
1140         &dev_attr_backupnv.attr,
1141         &dev_attr_calibrate.attr,
1142         &dev_attr_fw_version.attr,
1143         &dev_attr_object.attr,
1144         &dev_attr_update_fw.attr,
1145         NULL
1146 };
1147
1148 static const struct attribute_group mxt_attr_group = {
1149         .attrs = mxt_attrs,
1150 };
1151
1152 static void mxt_start(struct mxt_data *data)
1153 {
1154         /* Touch enable */
1155         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0, MXT_TOUCH_CTRL, 0x83);
1156 }
1157
1158 static void mxt_stop(struct mxt_data *data)
1159 {
1160         /* Touch disable */
1161         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0, MXT_TOUCH_CTRL, 0);
1162 }
1163
1164 static int mxt_input_open(struct input_dev *dev)
1165 {
1166         struct mxt_data *data = input_get_drvdata(dev);
1167
1168         mxt_start(data);
1169
1170         return 0;
1171 }
1172
1173 static void mxt_input_close(struct input_dev *dev)
1174 {
1175         struct mxt_data *data = input_get_drvdata(dev);
1176
1177         mxt_stop(data);
1178 }
1179
1180 static int __devinit mxt_probe(struct i2c_client *client,
1181                 const struct i2c_device_id *id)
1182 {
1183         const struct mxt_platform_data *pdata = client->dev.platform_data;
1184         struct mxt_data *data;
1185         struct input_dev *input_dev;
1186         int error;
1187
1188         if (!pdata)
1189                 return -EINVAL;
1190
1191         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1192         input_dev = input_allocate_device();
1193         if (!data || !input_dev) {
1194                 dev_err(&client->dev, "Failed to allocate memory\n");
1195                 error = -ENOMEM;
1196                 goto err_free_mem;
1197         }
1198
1199         data->is_tp = !strcmp(id->name, "atmel_mxt_tp");
1200         input_dev->name = (data->is_tp) ? "Atmel maXTouch Touchpad" :
1201                                           "Atmel maXTouch Touchscreen";
1202         input_dev->phys = client->adapter->name;
1203         input_dev->id.bustype = BUS_I2C;
1204         input_dev->dev.parent = &client->dev;
1205         input_dev->open = mxt_input_open;
1206         input_dev->close = mxt_input_close;
1207
1208         data->client = client;
1209         data->input_dev = input_dev;
1210         data->pdata = pdata;
1211         data->irq = client->irq;
1212
1213         mxt_calc_resolution(data);
1214
1215         __set_bit(EV_ABS, input_dev->evbit);
1216         __set_bit(EV_KEY, input_dev->evbit);
1217         __set_bit(BTN_TOUCH, input_dev->keybit);
1218
1219         if (data->is_tp) {
1220                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1221                 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1222
1223                 __set_bit(BTN_LEFT, input_dev->keybit);
1224                 __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
1225                 __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
1226                 __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
1227                 __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
1228                 __set_bit(BTN_TOOL_QUINTTAP, input_dev->keybit);
1229         }
1230
1231         /* For single touch */
1232         input_set_abs_params(input_dev, ABS_X,
1233                              0, data->max_x, 0, 0);
1234         input_set_abs_params(input_dev, ABS_Y,
1235                              0, data->max_y, 0, 0);
1236         input_set_abs_params(input_dev, ABS_PRESSURE,
1237                              0, 255, 0, 0);
1238         input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1239         input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1240
1241         /* For multi touch */
1242         error = input_mt_init_slots(input_dev, MXT_MAX_FINGER);
1243         if (error)
1244                 goto err_free_mem;
1245         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1246                              0, MXT_MAX_AREA, 0, 0);
1247         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1248                              0, data->max_x, 0, 0);
1249         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1250                              0, data->max_y, 0, 0);
1251         input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1252                              0, 255, 0, 0);
1253         input_abs_set_res(input_dev, ABS_MT_POSITION_X, MXT_PIXELS_PER_MM);
1254         input_abs_set_res(input_dev, ABS_MT_POSITION_Y, MXT_PIXELS_PER_MM);
1255
1256         input_set_drvdata(input_dev, data);
1257         i2c_set_clientdata(client, data);
1258
1259         if (client->addr == MXT_APP_LOW || client->addr == MXT_APP_HIGH) {
1260                 error = mxt_initialize(data);
1261                 if (error)
1262                         goto err_free_object;
1263         } else {
1264                 dev_info(&client->dev, "device came up in bootloader mode.\n");
1265         }
1266
1267         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1268                         pdata->irqflags, client->dev.driver->name, data);
1269         if (error) {
1270                 dev_err(&client->dev, "Failed to register interrupt\n");
1271                 goto err_free_object;
1272         }
1273
1274         if (client->addr == MXT_APP_LOW || client->addr == MXT_APP_HIGH) {
1275                 error = mxt_handle_messages(data);
1276                 if (error)
1277                         goto err_free_irq;
1278         }
1279
1280         error = input_register_device(input_dev);
1281         if (error)
1282                 goto err_free_irq;
1283
1284         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1285         if (error)
1286                 goto err_unregister_device;
1287
1288         return 0;
1289
1290 err_unregister_device:
1291         input_unregister_device(input_dev);
1292         input_dev = NULL;
1293 err_free_irq:
1294         free_irq(client->irq, data);
1295 err_free_object:
1296         kfree(data->object_table);
1297 err_free_mem:
1298         input_free_device(input_dev);
1299         kfree(data);
1300         return error;
1301 }
1302
1303 static int __devexit mxt_remove(struct i2c_client *client)
1304 {
1305         struct mxt_data *data = i2c_get_clientdata(client);
1306
1307         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1308         free_irq(data->irq, data);
1309         input_unregister_device(data->input_dev);
1310         kfree(data->object_table);
1311         kfree(data);
1312
1313         return 0;
1314 }
1315
1316 #ifdef CONFIG_PM_SLEEP
1317 static int mxt_suspend(struct device *dev)
1318 {
1319         struct i2c_client *client = to_i2c_client(dev);
1320         struct mxt_data *data = i2c_get_clientdata(client);
1321         struct input_dev *input_dev = data->input_dev;
1322
1323         mutex_lock(&input_dev->mutex);
1324
1325         if (input_dev->users)
1326                 mxt_stop(data);
1327
1328         mutex_unlock(&input_dev->mutex);
1329
1330         return 0;
1331 }
1332
1333 static int mxt_resume(struct device *dev)
1334 {
1335         struct i2c_client *client = to_i2c_client(dev);
1336         struct mxt_data *data = i2c_get_clientdata(client);
1337         struct input_dev *input_dev = data->input_dev;
1338
1339         /* Soft reset */
1340         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0, MXT_COMMAND_RESET, 1);
1341
1342         msleep(MXT_RESET_TIME);
1343
1344         mutex_lock(&input_dev->mutex);
1345
1346         if (input_dev->users)
1347                 mxt_start(data);
1348
1349         mutex_unlock(&input_dev->mutex);
1350
1351         return 0;
1352 }
1353 #endif
1354
1355 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1356
1357 static const struct i2c_device_id mxt_id[] = {
1358         { "qt602240_ts", 0 },
1359         { "atmel_mxt_ts", 0 },
1360         { "atmel_mxt_tp", 0 },
1361         { "mXT224", 0 },
1362         { }
1363 };
1364 MODULE_DEVICE_TABLE(i2c, mxt_id);
1365
1366 static struct i2c_driver mxt_driver = {
1367         .driver = {
1368                 .name   = "atmel_mxt_ts",
1369                 .owner  = THIS_MODULE,
1370                 .pm     = &mxt_pm_ops,
1371         },
1372         .probe          = mxt_probe,
1373         .remove         = __devexit_p(mxt_remove),
1374         .id_table       = mxt_id,
1375 };
1376
1377 module_i2c_driver(mxt_driver);
1378
1379 /* Module information */
1380 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1381 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1382 MODULE_LICENSE("GPL");