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 config_csum;
 273
 274         /* Cached parameters from object table */
 275         u16 T5_address;
 276         u8 T6_reportid;
 277         u8 T9_reportid_min;
 278         u8 T9_reportid_max;
 279         u8 T19_reportid;
 280         u16 T44_address;
 281 };
 282
 283 static int mxt_initialize(struct mxt_data *data);
 284
 285 static bool mxt_object_readable(unsigned int type)
 286 {
 287         switch (type) {
 288         case MXT_GEN_COMMAND_T6:
 289         case MXT_GEN_POWER_T7:
 290         case MXT_GEN_ACQUIRE_T8:
 291         case MXT_GEN_DATASOURCE_T53:
 292         case MXT_TOUCH_MULTI_T9:
 293         case MXT_TOUCH_KEYARRAY_T15:
 294         case MXT_TOUCH_PROXIMITY_T23:
 295         case MXT_TOUCH_PROXKEY_T52:
 296         case MXT_PROCI_GRIPFACE_T20:
 297         case MXT_PROCG_NOISE_T22:
 298         case MXT_PROCI_ONETOUCH_T24:
 299         case MXT_PROCI_TWOTOUCH_T27:
 300         case MXT_PROCI_GRIP_T40:
 301         case MXT_PROCI_PALM_T41:
 302         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 303         case MXT_PROCI_STYLUS_T47:
 304         case MXT_PROCG_NOISESUPPRESSION_T48:
 305         case MXT_PROCI_ADAPTIVETHRESHOLD_T55:
 306         case MXT_PROCI_SHIELDLESS_T56:
 307         case MXT_PROCI_EXTRATOUCHSCREENDATA_T57:
 308         case MXT_PROCG_NOISESUPPRESSION_T62:
 309         case MXT_SPT_COMMSCONFIG_T18:
 310         case MXT_SPT_GPIOPWM_T19:
 311         case MXT_SPT_SELFTEST_T25:
 312         case MXT_SPT_CTECONFIG_T28:
 313         case MXT_DEBUG_DIAGNOSTIC_T37:
 314         case MXT_SPT_DIGITIZER_T43:
 315         case MXT_SPT_CTECONFIG_T46:
 316         case MXT_SPT_TIMER_T61:
 317                 return true;
 318         default:
 319                 return false;
 320         }
 321 }
 322
 323 static bool mxt_object_writable(unsigned int type)
 324 {
 325         switch (type) {
 326         case MXT_GEN_COMMAND_T6:
 327         case MXT_GEN_POWER_T7:
 328         case MXT_GEN_ACQUIRE_T8:
 329         case MXT_TOUCH_MULTI_T9:
 330         case MXT_TOUCH_KEYARRAY_T15:
 331         case MXT_TOUCH_PROXIMITY_T23:
 332         case MXT_TOUCH_PROXKEY_T52:
 333         case MXT_PROCI_GRIPFACE_T20:
 334         case MXT_PROCG_NOISE_T22:
 335         case MXT_PROCI_ONETOUCH_T24:
 336         case MXT_PROCI_TWOTOUCH_T27:
 337         case MXT_PROCI_GRIP_T40:
 338         case MXT_PROCI_PALM_T41:
 339         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 340         case MXT_PROCI_STYLUS_T47:
 341         case MXT_PROCG_NOISESUPPRESSION_T48:
 342         case MXT_PROCI_ADAPTIVETHRESHOLD_T55:
 343         case MXT_PROCI_SHIELDLESS_T56:
 344         case MXT_PROCI_EXTRATOUCHSCREENDATA_T57:
 345         case MXT_PROCG_NOISESUPPRESSION_T62:
 346         case MXT_SPT_COMMSCONFIG_T18:
 347         case MXT_SPT_GPIOPWM_T19:
 348         case MXT_SPT_SELFTEST_T25:
 349         case MXT_SPT_CTECONFIG_T28:
 350         case MXT_SPT_DIGITIZER_T43:
 351         case MXT_SPT_CTECONFIG_T46:
 352         case MXT_SPT_TIMER_T61:
 353                 return true;
 354         default:
 355                 return false;
 356         }
 357 }
 358
 359 static void mxt_dump_message(struct device *dev,
 360                              struct mxt_message *message)
 361 {
 362         dev_dbg(dev, "reportid: %u\tmessage: %02x %02x %02x %02x %02x %02x %02x\n",
 363                 message->reportid, message->message[0], message->message[1],
 364                 message->message[2], message->message[3], message->message[4],
 365                 message->message[5], message->message[6]);
 366 }
 367
 368 static int mxt_check_bootloader(struct i2c_client *client,
 369                                      unsigned int state)
 370 {
 371         u8 val;
 372
 373 recheck:
 374         if (i2c_master_recv(client, &val, 1) != 1) {
 375                 dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
 376                 return -EIO;
 377         }
 378
 379         switch (state) {
 380         case MXT_WAITING_BOOTLOAD_CMD:
 381         case MXT_WAITING_FRAME_DATA:
 382                 val &= ~MXT_BOOT_STATUS_MASK;
 383                 break;
 384         case MXT_FRAME_CRC_PASS:
 385                 if (val == MXT_FRAME_CRC_CHECK)
 386                         goto recheck;
 387                 break;
 388         default:
 389                 return -EINVAL;
 390         }
 391
 392         if (val != state) {
 393                 dev_err(&client->dev, "Unvalid bootloader mode state\n");
 394                 return -EINVAL;
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int mxt_unlock_bootloader(struct i2c_client *client)
 401 {
 402         u8 buf[2];
 403
 404         buf[0] = MXT_UNLOCK_CMD_LSB;
 405         buf[1] = MXT_UNLOCK_CMD_MSB;
 406
 407         if (i2c_master_send(client, buf, 2) != 2) {
 408                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 409                 return -EIO;
 410         }
 411
 412         return 0;
 413 }
 414
 415 static int mxt_fw_write(struct i2c_client *client,
 416                              const u8 *data, unsigned int frame_size)
 417 {
 418         if (i2c_master_send(client, data, frame_size) != frame_size) {
 419                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 420                 return -EIO;
 421         }
 422
 423         return 0;
 424 }
 425
 426 #ifdef DEBUG
 427 #define DUMP_LEN        16
 428 static void mxt_dump_xfer(struct device *dev, const char *func, u16 reg,
 429                           u16 len, const u8 *val)
 430 {
 431         /* Rough guess for string size */
 432         char str[DUMP_LEN * 3 + 2];
 433         int i;
 434         size_t n;
 435
 436         for (i = 0, n = 0; i < len; i++) {
 437                 n += snprintf(&str[n], sizeof(str) - n, "%02x ", val[i]);
 438                 if ((i + 1) % DUMP_LEN == 0 || (i + 1) == len) {
 439                         dev_dbg(dev,
 440                                 "%s(reg: %d len: %d offset: 0x%02x): %s\n",
 441                                 func, reg, len, (i / DUMP_LEN) * DUMP_LEN,
 442                                 str);
 443                         n = 0;
 444                 }
 445         }
 446 }
 447 #undef DUMP_LEN
 448 #else
 449 static void mxt_dump_xfer(struct device *dev, const char *func, u16 reg,
 450                           u16 len, const u8 *val) { }
 451 #endif
 452
 453 static int mxt_read_reg(struct i2c_client *client, u16 reg, u16 len, void *val)
 454 {
 455         struct i2c_msg xfer[2];
 456         u8 buf[2];
 457
 458         buf[0] = reg & 0xff;
 459         buf[1] = (reg >> 8) & 0xff;
 460
 461         /* Write register */
 462         xfer[0].addr = client->addr;
 463         xfer[0].flags = 0;
 464         xfer[0].len = 2;
 465         xfer[0].buf = buf;
 466
 467         /* Read data */
 468         xfer[1].addr = client->addr;
 469         xfer[1].flags = I2C_M_RD;
 470         xfer[1].len = len;
 471         xfer[1].buf = val;
 472
 473         if (i2c_transfer(client->adapter, xfer, 2) != 2) {
 474                 dev_err(&client->dev, "%s: i2c read failed\n", __func__);
 475                 return -EIO;
 476         }
 477
 478         mxt_dump_xfer(&client->dev, __func__, reg, len, val);
 479
 480         return 0;
 481 }
 482
 483 static int mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 484                          const void *val)
 485 {
 486         size_t count = 2 + len;         /* + 2-byte offset */
 487         u8 buf[count];
 488
 489         buf[0] = reg & 0xff;
 490         buf[1] = (reg >> 8) & 0xff;
 491         memcpy(&buf[2], val, len);
 492
 493         mxt_dump_xfer(&client->dev, __func__, reg, len, val);
 494
 495         if (i2c_master_send(client, buf, count) != count) {
 496                 dev_err(&client->dev, "%s: i2c write failed\n", __func__);
 497                 return -EIO;
 498         }
 499
 500         return 0;
 501 }
 502
 503 static struct mxt_object *mxt_get_object(struct mxt_data *data, u8 type)
 504 {
 505         struct mxt_object *object;
 506         int i;
 507
 508         for (i = 0; i < data->info.object_num; i++) {
 509                 object = data->object_table + i;
 510                 if (object->type == type)
 511                         return object;
 512         }
 513
 514         dev_err(&data->client->dev, "Invalid object type\n");
 515         return NULL;
 516 }
 517
 518 static int mxt_read_object(struct mxt_data *data, struct mxt_object *object,
 519                            u8 instance, void *val)
 520 {
 521         u16 addr;
 522
 523         BUG_ON(instance >= object->instances);
 524         addr = object->start_address + instance * object->size;
 525         return mxt_read_reg(data->client, addr, object->size, val);
 526 }
 527
 528 static int mxt_write_object(struct mxt_data *data, u8 type, u8 instance,
 529                             u8 offset, u8 val)
 530 {
 531         struct mxt_object *object;
 532         u16 reg;
 533
 534         object = mxt_get_object(data, type);
 535         if (!object || instance >= object->instances || offset >= object->size)
 536                 return -EINVAL;
 537
 538         reg = object->start_address + instance * object->size + offset;
 539         return mxt_write_reg(data->client, reg, 1, &val);
 540 }
 541
 542 static int mxt_read_num_messages(struct mxt_data *data, u8 *count)
 543 {
 544         /* TODO: Optimization: read first message along with message count */
 545         return mxt_read_reg(data->client, data->T44_address, 1, count);
 546 }
 547
 548 static int mxt_read_messages(struct mxt_data *data, u8 count,
 549                              struct mxt_message *messages)
 550 {
 551         return mxt_read_reg(data->client, data->T5_address,
 552                             sizeof(struct mxt_message) * count, messages);
 553 }
 554
 555 static void mxt_input_button(struct mxt_data *data, struct mxt_message *message)
 556 {
 557         struct device *dev = &data->client->dev;
 558         struct input_dev *input = data->input_dev;
 559         bool button;
 560
 561         /* Active-low switch */
 562         button = !(message->message[0] & MXT_GPIO3_MASK);
 563         input_report_key(input, BTN_LEFT, button);
 564         dev_dbg(dev, "Button state: %d\n", button);
 565 }
 566
 567 static void mxt_input_touch(struct mxt_data *data, struct mxt_message *message)
 568 {
 569         struct device *dev = &data->client->dev;
 570         struct input_dev *input_dev = data->input_dev;
 571         u8 status;
 572         int x;
 573         int y;
 574         int area;
 575         int amplitude;
 576         int vector1, vector2;
 577         int id;
 578
 579         id = message->reportid - data->T9_reportid_min;
 580
 581         status = message->message[0];
 582         x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
 583         y = (message->message[2] << 4) | ((message->message[3] & 0xf));
 584         if (data->max_x < 1024)
 585                 x >>= 2;
 586         if (data->max_y < 1024)
 587                 y >>= 2;
 588
 589         area = message->message[4];
 590         amplitude = message->message[5];
 591
 592         /* The two vector components are 4-bit signed ints (2s complement) */
 593         vector1 = (signed)((signed char)message->message[6]) >> 4;
 594         vector2 = (signed)((signed char)(message->message[6] << 4)) >> 4;
 595
 596         dev_dbg(dev,
 597                 "[%d] %c%c%c%c%c%c%c%c x: %d y: %d area: %d amp: %d vector: [%d,%d]\n",
 598                 id,
 599                 (status & MXT_DETECT) ? 'D' : '.',
 600                 (status & MXT_PRESS) ? 'P' : '.',
 601                 (status & MXT_RELEASE) ? 'R' : '.',
 602                 (status & MXT_MOVE) ? 'M' : '.',
 603                 (status & MXT_VECTOR) ? 'V' : '.',
 604                 (status & MXT_AMP) ? 'A' : '.',
 605                 (status & MXT_SUPPRESS) ? 'S' : '.',
 606                 (status & MXT_UNGRIP) ? 'U' : '.',
 607                 x, y, area, amplitude, vector1, vector2);
 608
 609         input_mt_slot(input_dev, id);
 610         input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
 611                                    status & MXT_DETECT);
 612
 613         if (status & MXT_DETECT) {
 614                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 615                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 616                 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 617                 /* TODO: This should really be sqrt(area) */
 618                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 619                 /* TODO: Use vector to report ORIENTATION & TOUCH_MINOR */
 620         }
 621 }
 622
 623 static int mxt_proc_messages(struct mxt_data *data, u8 count)
 624 {
 625         struct device *dev = &data->client->dev;
 626         struct mxt_message messages[count], *msg;
 627         int ret;
 628         bool update_input;
 629
 630         ret = mxt_read_messages(data, count, messages);
 631         if (ret) {
 632                 dev_err(dev, "Failed to read %u messages (%d).\n", count, ret);
 633                 return ret;
 634         }
 635
 636         update_input = false;
 637         for (msg = messages; msg < &messages[count]; msg++) {
 638                 mxt_dump_message(dev, msg);
 639
 640                 if (msg->reportid >= data->T9_reportid_min &&
 641                     msg->reportid <= data->T9_reportid_max) {
 642                         mxt_input_touch(data, msg);
 643                         update_input = true;
 644                 } else if (msg->reportid == data->T19_reportid) {
 645                         mxt_input_button(data, msg);
 646                         update_input = true;
 647                 } else if (msg->reportid == data->T6_reportid) {
 648                         data->config_csum = msg->message[1] |
 649                                             (msg->message[2] << 8) |
 650                                             (msg->message[3] << 16);
 651                         dev_info(dev, "Status: %02x Config Checksum: %06x\n",
 652                                  msg->message[0], data->config_csum);
 653                 }
 654         }
 655
 656         if (update_input) {
 657                 input_mt_report_pointer_emulation(data->input_dev,
 658                                                   data->is_tp);
 659                 input_sync(data->input_dev);
 660         }
 661
 662         return 0;
 663 }
 664
 665 static int mxt_handle_messages(struct mxt_data *data)
 666 {
 667         struct device *dev = &data->client->dev;
 668         int ret;
 669         u8 count;
 670
 671         ret = mxt_read_num_messages(data, &count);
 672         if (ret) {
 673                 dev_err(dev, "Failed to read message count (%d).\n", ret);
 674                 return ret;
 675         }
 676
 677         if (count > 0)
 678                 ret = mxt_proc_messages(data, count);
 679
 680         return ret;
 681 }
 682
 683 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 684 {
 685         mxt_handle_messages(dev_id);
 686         return IRQ_HANDLED;
 687 }
 688
 689 static int mxt_check_reg_init(struct mxt_data *data)
 690 {
 691         const struct mxt_platform_data *pdata = data->pdata;
 692         struct device *dev = &data->client->dev;
 693         int i, offset;
 694         int ret;
 695
 696         if (!pdata->config) {
 697                 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
 698                 return 0;
 699         }
 700
 701         for (offset = 0, i = 0; i < data->info.object_num; i++) {
 702                 struct mxt_object *object = &data->object_table[i];
 703                 size_t config_size;
 704
 705                 if (!mxt_object_writable(object->type))
 706                         continue;
 707
 708                 config_size = object->size * object->instances;
 709                 if (offset + config_size > pdata->config_length) {
 710                         dev_err(dev, "Not enough config data!\n");
 711                         return -EINVAL;
 712                 }
 713
 714                 ret = mxt_write_reg(data->client, object->start_address,
 715                                     config_size, &pdata->config[offset]);
 716                 if (ret)
 717                         return ret;
 718                 offset += config_size;
 719         }
 720
 721         return 0;
 722 }
 723
 724 static void mxt_handle_pdata(struct mxt_data *data)
 725 {
 726         const struct mxt_platform_data *pdata = data->pdata;
 727         u8 voltage;
 728
 729         /* Set touchscreen lines */
 730         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 731                          MXT_TOUCH_XSIZE, pdata->x_line);
 732         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 733                          MXT_TOUCH_YSIZE, pdata->y_line);
 734
 735         /* Set touchscreen orient */
 736         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 737                          MXT_TOUCH_ORIENT, pdata->orient);
 738
 739         /* Set touchscreen burst length */
 740         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 741                          MXT_TOUCH_BLEN, pdata->blen);
 742
 743         /* Set touchscreen threshold */
 744         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 745                          MXT_TOUCH_TCHTHR, pdata->threshold);
 746
 747         /* Set touchscreen resolution */
 748         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 749                          MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
 750         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 751                          MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
 752         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 753                          MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
 754         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0,
 755                          MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
 756
 757         /* Set touchscreen voltage */
 758         if (pdata->voltage) {
 759                 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
 760                         voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
 761                                 MXT_VOLTAGE_STEP;
 762                         voltage = 0xff - voltage + 1;
 763                 } else
 764                         voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
 765                                 MXT_VOLTAGE_STEP;
 766
 767                 mxt_write_object(data, MXT_SPT_CTECONFIG_T28, 0,
 768                                  MXT_CTE_VOLTAGE, voltage);
 769         }
 770 }
 771
 772 static int mxt_get_object_table(struct mxt_data *data)
 773 {
 774         struct i2c_client *client = data->client;
 775         struct device *dev = &client->dev;
 776         int error;
 777         int i;
 778         u8 reportid;
 779         u8 buf[data->info.object_num][MXT_OBJECT_SIZE];
 780
 781         data->object_table = kcalloc(data->info.object_num,
 782                                      sizeof(struct mxt_object), GFP_KERNEL);
 783         if (!data->object_table) {
 784                 dev_err(dev, "Failed to allocate object table\n");
 785                 return -ENOMEM;
 786         }
 787
 788         error = mxt_read_reg(client, MXT_OBJECT_START, sizeof(buf), buf);
 789         if (error)
 790                 return error;
 791
 792         /* Vaild Report IDs start counting from 1. */
 793         reportid = 1;
 794         for (i = 0; i < data->info.object_num; i++) {
 795                 struct mxt_object *object = &data->object_table[i];
 796                 u8 num_ids, min_id, max_id;
 797
 798                 object->type = buf[i][0];
 799                 object->start_address = (buf[i][2] << 8) | buf[i][1];
 800                 object->size = buf[i][3] + 1;
 801                 object->instances = buf[i][4] + 1;
 802                 object->num_report_ids = buf[i][5];
 803
 804                 num_ids = object->num_report_ids * object->instances;
 805                 min_id = num_ids ? reportid : 0;
 806                 max_id = num_ids ? reportid + num_ids - 1 : 0;
 807                 reportid += num_ids;
 808
 809                 dev_info(dev,
 810                          "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
 811                          object->type, object->start_address, object->size,
 812                          object->instances, min_id, max_id);
 813
 814                 /* Save data for objects used when processing interrupts */
 815                 switch (object->type) {
 816                 case MXT_GEN_MESSAGE_T5:
 817                         data->T5_address = object->start_address;
 818                         break;
 819                 case MXT_GEN_COMMAND_T6:
 820                         data->T6_reportid = min_id;
 821                         break;
 822                 case MXT_TOUCH_MULTI_T9:
 823                         data->T9_reportid_min = min_id;
 824                         data->T9_reportid_max = max_id;
 825                         break;
 826                 case MXT_SPT_GPIOPWM_T19:
 827                         data->T19_reportid = min_id;
 828                         break;
 829                 case MXT_SPT_MESSAGECOUNT_T44:
 830                         data->T44_address = object->start_address;
 831                         break;
 832                 }
 833         }
 834
 835         return 0;
 836 }
 837
 838 static void mxt_calc_resolution(struct mxt_data *data)
 839 {
 840         unsigned int max_x = data->pdata->x_size - 1;
 841         unsigned int max_y = data->pdata->y_size - 1;
 842
 843         if (data->pdata->orient & MXT_XY_SWITCH) {
 844                 data->max_x = max_y;
 845                 data->max_y = max_x;
 846         } else {
 847                 data->max_x = max_x;
 848                 data->max_y = max_y;
 849         }
 850 }
 851
 852 static int mxt_load_fw(struct device *dev, const char *fn)
 853 {
 854         struct mxt_data *data = dev_get_drvdata(dev);
 855         struct i2c_client *client = data->client;
 856         const struct firmware *fw = NULL;
 857         unsigned int frame_size;
 858         unsigned int pos = 0;
 859         int ret;
 860
 861         ret = request_firmware(&fw, fn, dev);
 862         if (ret) {
 863                 dev_err(dev, "Unable to open firmware %s\n", fn);
 864                 return ret;
 865         }
 866
 867         if (client->addr == MXT_BOOT_LOW || client->addr == MXT_BOOT_HIGH) {
 868                 /* already in bootloader mode. */
 869                 goto bootloader_ready;
 870         }
 871
 872         /* Change to the bootloader mode */
 873         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 874                          MXT_COMMAND_RESET, MXT_BOOT_VALUE);
 875         msleep(MXT_RESET_TIME);
 876
 877         /* Change to slave address of bootloader */
 878         if (client->addr == MXT_APP_LOW)
 879                 client->addr = MXT_BOOT_LOW;
 880         else
 881                 client->addr = MXT_BOOT_HIGH;
 882
 883 bootloader_ready:
 884         ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
 885         if (ret)
 886                 goto out;
 887
 888         /* Unlock bootloader */
 889         mxt_unlock_bootloader(client);
 890
 891         while (pos < fw->size) {
 892                 ret = mxt_check_bootloader(client,
 893                                                 MXT_WAITING_FRAME_DATA);
 894                 if (ret)
 895                         goto out;
 896
 897                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
 898
 899                 /* We should add 2 at frame size as the the firmware data is not
 900                  * included the CRC bytes.
 901                  */
 902                 frame_size += 2;
 903
 904                 /* Write one frame to device */
 905                 mxt_fw_write(client, fw->data + pos, frame_size);
 906
 907                 ret = mxt_check_bootloader(client,
 908                                                 MXT_FRAME_CRC_PASS);
 909                 if (ret)
 910                         goto out;
 911
 912                 pos += frame_size;
 913
 914                 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
 915         }
 916
 917 out:
 918         release_firmware(fw);
 919
 920         /* Change to slave address of application */
 921         if (client->addr == MXT_BOOT_LOW)
 922                 client->addr = MXT_APP_LOW;
 923         else
 924                 client->addr = MXT_APP_HIGH;
 925
 926         return ret;
 927 }
 928
 929 /**
 930  * sysfs interface
 931  **/
 932 static ssize_t mxt_backupnv_store(struct device *dev,
 933                                   struct device_attribute *attr,
 934                                   const char *buf, size_t count)
 935 {
 936         struct mxt_data *data = dev_get_drvdata(dev);
 937         int ret;
 938
 939         /* Backup non-volatile memory */
 940         ret = mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 941                                MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
 942         if (ret)
 943                 return ret;
 944         msleep(MXT_BACKUP_TIME);
 945
 946         return count;
 947 }
 948
 949 static ssize_t mxt_calibrate_store(struct device *dev,
 950                                    struct device_attribute *attr,
 951                                    const char *buf, size_t count)
 952 {
 953         struct mxt_data *data = dev_get_drvdata(dev);
 954         int ret;
 955
 956         disable_irq(data->irq);
 957
 958         /* Perform touch surface recalibration */
 959         ret = mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
 960                                MXT_COMMAND_CALIBRATE, 1);
 961         if (ret)
 962                 return ret;
 963         msleep(MXT_CAL_TIME);
 964
 965         enable_irq(data->irq);
 966
 967         return count;
 968 }
 969
 970 static ssize_t mxt_config_csum_show(struct device *dev,
 971                                     struct device_attribute *attr, char *buf)
 972 {
 973         struct mxt_data *data = dev_get_drvdata(dev);
 974         return scnprintf(buf, PAGE_SIZE, "%06x\n", data->config_csum);
 975 }
 976
 977 static ssize_t mxt_fw_version_show(struct device *dev,
 978                                struct device_attribute *attr, char *buf)
 979 {
 980         struct mxt_data *data = dev_get_drvdata(dev);
 981         struct mxt_info *info = &data->info;
 982         return scnprintf(buf, PAGE_SIZE, "%d.%d.%d\n",
 983                          info->version >> 4, info->version & 0xf, info->build);
 984 }
 985
 986 /* Hardware Version is <FamilyID>.<VariantID> */
 987 static ssize_t mxt_hw_version_show(struct device *dev,
 988                                    struct device_attribute *attr, char *buf)
 989 {
 990         struct mxt_data *data = dev_get_drvdata(dev);
 991         struct mxt_info *info = &data->info;
 992         return scnprintf(buf, PAGE_SIZE, "%d.%d\n",
 993                          info->family_id, info->variant_id);
 994 }
 995
 996 static ssize_t mxt_object_show(struct device *dev,
 997                                struct device_attribute *attr, char *buf)
 998 {
 999         struct mxt_data *data = dev_get_drvdata(dev);
1000         int count = 0;
1001         size_t i, j, k;
1002         int error = 0;
1003         u8 *obuf = NULL;
1004
1005         for (i = 0; i < data->info.object_num && count < PAGE_SIZE - 1; i++) {
1006                 struct mxt_object *object = &data->object_table[i];
1007
1008                 if (!mxt_object_readable(object->type))
1009                         continue;
1010
1011                 count += scnprintf(&buf[count], PAGE_SIZE - count,
1012                                    "\nType: %u\n", object->type);
1013
1014                 obuf = krealloc(obuf, object->size, GFP_KERNEL);
1015                 if (!obuf)
1016                         return -ENOMEM;
1017
1018                 for (j = 0; j < object->instances; j++) {
1019                         if (object->instances > 1)
1020                                 count += scnprintf(&buf[count],
1021                                                    PAGE_SIZE - count,
1022                                                    "Instance: %zu\n", j);
1023
1024                         error = mxt_read_object(data, object, j, obuf);
1025                         if (error)
1026                                 goto free_obuf;
1027
1028                         for (k = 0; k < object->size; k++)
1029                                 count += scnprintf(&buf[count],
1030                                                    PAGE_SIZE - count,
1031                                                    "\t[%2zu]: %02x (%d)\n",
1032                                                    k, obuf[k], obuf[k]);
1033                 }
1034         }
1035
1036 free_obuf:
1037         kfree(obuf);
1038         return error ?: count;
1039 }
1040
1041 static ssize_t mxt_object_store(struct device *dev,
1042                                 struct device_attribute *attr,
1043                                 const char *buf, size_t count)
1044 {
1045         struct mxt_data *data = dev_get_drvdata(dev);
1046         int ret;
1047         u32 param;
1048         u8 type, instance, offset, val;
1049
1050         ret = kstrtou32(buf, 16, &param);
1051         if (ret < 0)
1052                 return -EINVAL;
1053
1054         /*
1055          * Byte Write Command is encoded in 32-bit word: TTIIOOVV:
1056          * <Type> <Instance> <Offset> <Value>
1057          */
1058         type = (param & 0xff000000) >> 24;
1059         instance = (param & 0x00ff0000) >> 16;
1060         offset = (param & 0x0000ff00) >> 8;
1061         val = param & 0x000000ff;
1062
1063         ret = mxt_write_object(data, type, instance, offset, val);
1064         if (ret)
1065                 return ret;
1066
1067         return count;
1068 }
1069
1070 static ssize_t mxt_update_fw_store(struct device *dev,
1071                                         struct device_attribute *attr,
1072                                         const char *buf, size_t count)
1073 {
1074         struct mxt_data *data = dev_get_drvdata(dev);
1075         int error;
1076
1077         disable_irq(data->irq);
1078
1079         error = mxt_load_fw(dev, MXT_FW_NAME);
1080         if (error) {
1081                 dev_err(dev, "The firmware update failed(%d)\n", error);
1082                 count = error;
1083         } else {
1084                 dev_dbg(dev, "The firmware update succeeded\n");
1085
1086                 /* Wait for reset */
1087                 msleep(MXT_FWRESET_TIME);
1088
1089                 kfree(data->object_table);
1090                 data->object_table = NULL;
1091
1092                 mxt_initialize(data);
1093         }
1094
1095         enable_irq(data->irq);
1096
1097         error = mxt_handle_messages(data);
1098         if (error)
1099                 return error;
1100
1101         return count;
1102 }
1103
1104 static DEVICE_ATTR(backupnv, S_IWUSR, NULL, mxt_backupnv_store);
1105 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, mxt_calibrate_store);
1106 static DEVICE_ATTR(config_csum, S_IRUGO, mxt_config_csum_show, NULL);
1107 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1108 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1109 static DEVICE_ATTR(object, S_IRUGO | S_IWUSR, mxt_object_show,
1110                    mxt_object_store);
1111 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1112
1113 static struct attribute *mxt_attrs[] = {
1114         &dev_attr_backupnv.attr,
1115         &dev_attr_calibrate.attr,
1116         &dev_attr_config_csum.attr,
1117         &dev_attr_fw_version.attr,
1118         &dev_attr_hw_version.attr,
1119         &dev_attr_object.attr,
1120         &dev_attr_update_fw.attr,
1121         NULL
1122 };
1123
1124 static const struct attribute_group mxt_attr_group = {
1125         .attrs = mxt_attrs,
1126 };
1127
1128 static void mxt_start(struct mxt_data *data)
1129 {
1130         /* Touch enable */
1131         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0, MXT_TOUCH_CTRL, 0x83);
1132 }
1133
1134 static void mxt_stop(struct mxt_data *data)
1135 {
1136         /* Touch disable */
1137         mxt_write_object(data, MXT_TOUCH_MULTI_T9, 0, MXT_TOUCH_CTRL, 0);
1138 }
1139
1140 static int mxt_input_open(struct input_dev *dev)
1141 {
1142         struct mxt_data *data = input_get_drvdata(dev);
1143
1144         mxt_start(data);
1145
1146         return 0;
1147 }
1148
1149 static void mxt_input_close(struct input_dev *dev)
1150 {
1151         struct mxt_data *data = input_get_drvdata(dev);
1152
1153         mxt_stop(data);
1154 }
1155
1156 static int mxt_initialize(struct mxt_data *data)
1157 {
1158         struct i2c_client *client = data->client;
1159         struct device *dev = &client->dev;
1160         struct mxt_info *info = &data->info;
1161         int error;
1162
1163         /* Read 7-byte info block starting at address 0 */
1164         error = mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
1165         if (error)
1166                 return error;
1167
1168         /* Get object table information */
1169         error = mxt_get_object_table(data);
1170         if (error)
1171                 return error;
1172
1173         /* Check register init values */
1174         error = mxt_check_reg_init(data);
1175         if (error)
1176                 return error;
1177
1178         mxt_handle_pdata(data);
1179
1180         /* Backup to memory */
1181         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0,
1182                          MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1183         msleep(MXT_BACKUP_TIME);
1184
1185         /* Soft reset */
1186         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0, MXT_COMMAND_RESET, 1);
1187         msleep(MXT_RESET_TIME);
1188
1189         /* Update matrix size, since it may have been modified by pdata */
1190         error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, 2,
1191                              &info->matrix_xsize);
1192         if (error)
1193                 return error;
1194
1195         dev_info(dev, "Family ID: %d Variant ID: %d Major.Minor.Build: %d.%d.%d\n",
1196                  info->family_id, info->variant_id, info->version >> 4,
1197                  info->version & 0xf, info->build);
1198
1199         dev_info(dev, "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n",
1200                  info->matrix_xsize, info->matrix_ysize, info->object_num);
1201
1202         return 0;
1203 }
1204
1205 static int __devinit mxt_probe(struct i2c_client *client,
1206                 const struct i2c_device_id *id)
1207 {
1208         const struct mxt_platform_data *pdata = client->dev.platform_data;
1209         struct mxt_data *data;
1210         struct input_dev *input_dev;
1211         int error;
1212
1213         if (!pdata)
1214                 return -EINVAL;
1215
1216         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1217         input_dev = input_allocate_device();
1218         if (!data || !input_dev) {
1219                 dev_err(&client->dev, "Failed to allocate memory\n");
1220                 error = -ENOMEM;
1221                 goto err_free_mem;
1222         }
1223
1224         data->is_tp = !strcmp(id->name, "atmel_mxt_tp");
1225         input_dev->name = (data->is_tp) ? "Atmel maXTouch Touchpad" :
1226                                           "Atmel maXTouch Touchscreen";
1227         input_dev->phys = client->adapter->name;
1228         input_dev->id.bustype = BUS_I2C;
1229         input_dev->dev.parent = &client->dev;
1230         input_dev->open = mxt_input_open;
1231         input_dev->close = mxt_input_close;
1232
1233         data->client = client;
1234         data->input_dev = input_dev;
1235         data->pdata = pdata;
1236         data->irq = client->irq;
1237
1238         mxt_calc_resolution(data);
1239
1240         __set_bit(EV_ABS, input_dev->evbit);
1241         __set_bit(EV_KEY, input_dev->evbit);
1242         __set_bit(BTN_TOUCH, input_dev->keybit);
1243
1244         if (data->is_tp) {
1245                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1246                 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1247
1248                 __set_bit(BTN_LEFT, input_dev->keybit);
1249                 __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
1250                 __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
1251                 __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
1252                 __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
1253                 __set_bit(BTN_TOOL_QUINTTAP, input_dev->keybit);
1254         }
1255
1256         /* For single touch */
1257         input_set_abs_params(input_dev, ABS_X,
1258                              0, data->max_x, 0, 0);
1259         input_set_abs_params(input_dev, ABS_Y,
1260                              0, data->max_y, 0, 0);
1261         input_set_abs_params(input_dev, ABS_PRESSURE,
1262                              0, 255, 0, 0);
1263         input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1264         input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1265
1266         /* For multi touch */
1267         error = input_mt_init_slots(input_dev, MXT_MAX_FINGER);
1268         if (error)
1269                 goto err_free_mem;
1270         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1271                              0, MXT_MAX_AREA, 0, 0);
1272         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1273                              0, data->max_x, 0, 0);
1274         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1275                              0, data->max_y, 0, 0);
1276         input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1277                              0, 255, 0, 0);
1278         input_abs_set_res(input_dev, ABS_MT_POSITION_X, MXT_PIXELS_PER_MM);
1279         input_abs_set_res(input_dev, ABS_MT_POSITION_Y, MXT_PIXELS_PER_MM);
1280
1281         input_set_drvdata(input_dev, data);
1282         i2c_set_clientdata(client, data);
1283
1284         if (client->addr == MXT_APP_LOW || client->addr == MXT_APP_HIGH) {
1285                 error = mxt_initialize(data);
1286                 if (error)
1287                         goto err_free_object;
1288         } else {
1289                 dev_info(&client->dev, "device came up in bootloader mode.\n");
1290         }
1291
1292         error = request_threaded_irq(client->irq,
1293                                      NULL,
1294                                      mxt_interrupt,
1295                                      pdata->irqflags,
1296                                      client->name,
1297                                      data);
1298         if (error) {
1299                 dev_err(&client->dev, "Failed to register interrupt\n");
1300                 goto err_free_object;
1301         }
1302
1303         if (client->addr == MXT_APP_LOW || client->addr == MXT_APP_HIGH) {
1304                 error = mxt_handle_messages(data);
1305                 if (error)
1306                         goto err_free_irq;
1307         }
1308
1309         error = input_register_device(input_dev);
1310         if (error)
1311                 goto err_free_irq;
1312
1313         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1314         if (error)
1315                 dev_warn(&client->dev, "error creating sysfs entries.\n");
1316
1317         return 0;
1318
1319 err_free_irq:
1320         free_irq(client->irq, data);
1321 err_free_object:
1322         kfree(data->object_table);
1323 err_free_mem:
1324         input_free_device(input_dev);
1325         kfree(data);
1326         return error;
1327 }
1328
1329 static int __devexit mxt_remove(struct i2c_client *client)
1330 {
1331         struct mxt_data *data = i2c_get_clientdata(client);
1332
1333         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1334         free_irq(data->irq, data);
1335         input_unregister_device(data->input_dev);
1336         kfree(data->object_table);
1337         kfree(data);
1338
1339         return 0;
1340 }
1341
1342 #ifdef CONFIG_PM_SLEEP
1343 static int mxt_suspend(struct device *dev)
1344 {
1345         struct i2c_client *client = to_i2c_client(dev);
1346         struct mxt_data *data = i2c_get_clientdata(client);
1347         struct input_dev *input_dev = data->input_dev;
1348
1349         mutex_lock(&input_dev->mutex);
1350
1351         if (input_dev->users)
1352                 mxt_stop(data);
1353
1354         mutex_unlock(&input_dev->mutex);
1355
1356         return 0;
1357 }
1358
1359 static int mxt_resume(struct device *dev)
1360 {
1361         struct i2c_client *client = to_i2c_client(dev);
1362         struct mxt_data *data = i2c_get_clientdata(client);
1363         struct input_dev *input_dev = data->input_dev;
1364
1365         /* Soft reset */
1366         mxt_write_object(data, MXT_GEN_COMMAND_T6, 0, MXT_COMMAND_RESET, 1);
1367
1368         msleep(MXT_RESET_TIME);
1369
1370         mutex_lock(&input_dev->mutex);
1371
1372         if (input_dev->users)
1373                 mxt_start(data);
1374
1375         mutex_unlock(&input_dev->mutex);
1376
1377         return 0;
1378 }
1379 #endif
1380
1381 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1382
1383 static const struct i2c_device_id mxt_id[] = {
1384         { "qt602240_ts", 0 },
1385         { "atmel_mxt_ts", 0 },
1386         { "atmel_mxt_tp", 0 },
1387         { "mXT224", 0 },
1388         { }
1389 };
1390 MODULE_DEVICE_TABLE(i2c, mxt_id);
1391
1392 static struct i2c_driver mxt_driver = {
1393         .driver = {
1394                 .name   = "atmel_mxt_ts",
1395                 .owner  = THIS_MODULE,
1396                 .pm     = &mxt_pm_ops,
1397         },
1398         .probe          = mxt_probe,
1399         .remove         = __devexit_p(mxt_remove),
1400         .id_table       = mxt_id,
1401 };
1402
1403 module_i2c_driver(mxt_driver);
1404
1405 /* Module information */
1406 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1407 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1408 MODULE_LICENSE("GPL");