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