drivers/input/touchscreen/atmel_mxt_ts.c

   1 /*
   2  * Atmel maXTouch Touchscreen driver
   3  *
   4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
   5  * Copyright (C) 2011-2014 Atmel Corporation
   6  * Copyright (C) 2012 Google, Inc.
   7  *
   8  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  *
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/completion.h>
  20 #include <linux/delay.h>
  21 #include <linux/firmware.h>
  22 #include <linux/i2c.h>
  23 #include <linux/i2c/atmel_mxt_ts.h>
  24 #include <linux/input/mt.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/of.h>
  27 #include <linux/slab.h>
  28
  29 /* Version */
  30 #define MXT_VER_20              20
  31 #define MXT_VER_21              21
  32 #define MXT_VER_22              22
  33
  34 /* Firmware files */
  35 #define MXT_FW_NAME             "maxtouch.fw"
  36 #define MXT_CFG_NAME            "maxtouch.cfg"
  37 #define MXT_CFG_MAGIC           "OBP_RAW V1"
  38
  39 /* Registers */
  40 #define MXT_INFO                0x00
  41 #define MXT_FAMILY_ID           0x00
  42 #define MXT_VARIANT_ID          0x01
  43 #define MXT_VERSION             0x02
  44 #define MXT_BUILD               0x03
  45 #define MXT_MATRIX_X_SIZE       0x04
  46 #define MXT_MATRIX_Y_SIZE       0x05
  47 #define MXT_OBJECT_NUM          0x06
  48 #define MXT_OBJECT_START        0x07
  49
  50 #define MXT_OBJECT_SIZE         6
  51 #define MXT_INFO_CHECKSUM_SIZE  3
  52 #define MXT_MAX_BLOCK_WRITE     256
  53
  54 /* Object types */
  55 #define MXT_DEBUG_DIAGNOSTIC_T37        37
  56 #define MXT_GEN_MESSAGE_T5              5
  57 #define MXT_GEN_COMMAND_T6              6
  58 #define MXT_GEN_POWER_T7                7
  59 #define MXT_GEN_ACQUIRE_T8              8
  60 #define MXT_GEN_DATASOURCE_T53          53
  61 #define MXT_TOUCH_MULTI_T9              9
  62 #define MXT_TOUCH_KEYARRAY_T15          15
  63 #define MXT_TOUCH_PROXIMITY_T23         23
  64 #define MXT_TOUCH_PROXKEY_T52           52
  65 #define MXT_PROCI_GRIPFACE_T20          20
  66 #define MXT_PROCG_NOISE_T22             22
  67 #define MXT_PROCI_ONETOUCH_T24          24
  68 #define MXT_PROCI_TWOTOUCH_T27          27
  69 #define MXT_PROCI_GRIP_T40              40
  70 #define MXT_PROCI_PALM_T41              41
  71 #define MXT_PROCI_TOUCHSUPPRESSION_T42  42
  72 #define MXT_PROCI_STYLUS_T47            47
  73 #define MXT_PROCG_NOISESUPPRESSION_T48  48
  74 #define MXT_SPT_COMMSCONFIG_T18         18
  75 #define MXT_SPT_GPIOPWM_T19             19
  76 #define MXT_SPT_SELFTEST_T25            25
  77 #define MXT_SPT_CTECONFIG_T28           28
  78 #define MXT_SPT_USERDATA_T38            38
  79 #define MXT_SPT_DIGITIZER_T43           43
  80 #define MXT_SPT_MESSAGECOUNT_T44        44
  81 #define MXT_SPT_CTECONFIG_T46           46
  82
  83 /* MXT_GEN_MESSAGE_T5 object */
  84 #define MXT_RPTID_NOMSG         0xff
  85
  86 /* MXT_GEN_COMMAND_T6 field */
  87 #define MXT_COMMAND_RESET       0
  88 #define MXT_COMMAND_BACKUPNV    1
  89 #define MXT_COMMAND_CALIBRATE   2
  90 #define MXT_COMMAND_REPORTALL   3
  91 #define MXT_COMMAND_DIAGNOSTIC  5
  92
  93 /* Define for T6 status byte */
  94 #define MXT_T6_STATUS_RESET     (1 << 7)
  95 #define MXT_T6_STATUS_OFL       (1 << 6)
  96 #define MXT_T6_STATUS_SIGERR    (1 << 5)
  97 #define MXT_T6_STATUS_CAL       (1 << 4)
  98 #define MXT_T6_STATUS_CFGERR    (1 << 3)
  99 #define MXT_T6_STATUS_COMSERR   (1 << 2)
 100
 101 /* MXT_GEN_POWER_T7 field */
 102 #define MXT_POWER_IDLEACQINT    0
 103 #define MXT_POWER_ACTVACQINT    1
 104 #define MXT_POWER_ACTV2IDLETO   2
 105
 106 /* MXT_GEN_ACQUIRE_T8 field */
 107 #define MXT_ACQUIRE_CHRGTIME    0
 108 #define MXT_ACQUIRE_TCHDRIFT    2
 109 #define MXT_ACQUIRE_DRIFTST     3
 110 #define MXT_ACQUIRE_TCHAUTOCAL  4
 111 #define MXT_ACQUIRE_SYNC        5
 112 #define MXT_ACQUIRE_ATCHCALST   6
 113 #define MXT_ACQUIRE_ATCHCALSTHR 7
 114
 115 /* MXT_TOUCH_MULTI_T9 field */
 116 #define MXT_TOUCH_CTRL          0
 117 #define MXT_T9_ORIENT           9
 118 #define MXT_T9_RANGE            18
 119
 120 /* MXT_TOUCH_MULTI_T9 status */
 121 #define MXT_T9_UNGRIP           (1 << 0)
 122 #define MXT_T9_SUPPRESS         (1 << 1)
 123 #define MXT_T9_AMP              (1 << 2)
 124 #define MXT_T9_VECTOR           (1 << 3)
 125 #define MXT_T9_MOVE             (1 << 4)
 126 #define MXT_T9_RELEASE          (1 << 5)
 127 #define MXT_T9_PRESS            (1 << 6)
 128 #define MXT_T9_DETECT           (1 << 7)
 129
 130 struct t9_range {
 131         u16 x;
 132         u16 y;
 133 } __packed;
 134
 135 /* MXT_TOUCH_MULTI_T9 orient */
 136 #define MXT_T9_ORIENT_SWITCH    (1 << 0)
 137
 138 /* MXT_PROCI_GRIPFACE_T20 field */
 139 #define MXT_GRIPFACE_CTRL       0
 140 #define MXT_GRIPFACE_XLOGRIP    1
 141 #define MXT_GRIPFACE_XHIGRIP    2
 142 #define MXT_GRIPFACE_YLOGRIP    3
 143 #define MXT_GRIPFACE_YHIGRIP    4
 144 #define MXT_GRIPFACE_MAXTCHS    5
 145 #define MXT_GRIPFACE_SZTHR1     7
 146 #define MXT_GRIPFACE_SZTHR2     8
 147 #define MXT_GRIPFACE_SHPTHR1    9
 148 #define MXT_GRIPFACE_SHPTHR2    10
 149 #define MXT_GRIPFACE_SUPEXTTO   11
 150
 151 /* MXT_PROCI_NOISE field */
 152 #define MXT_NOISE_CTRL          0
 153 #define MXT_NOISE_OUTFLEN       1
 154 #define MXT_NOISE_GCAFUL_LSB    3
 155 #define MXT_NOISE_GCAFUL_MSB    4
 156 #define MXT_NOISE_GCAFLL_LSB    5
 157 #define MXT_NOISE_GCAFLL_MSB    6
 158 #define MXT_NOISE_ACTVGCAFVALID 7
 159 #define MXT_NOISE_NOISETHR      8
 160 #define MXT_NOISE_FREQHOPSCALE  10
 161 #define MXT_NOISE_FREQ0         11
 162 #define MXT_NOISE_FREQ1         12
 163 #define MXT_NOISE_FREQ2         13
 164 #define MXT_NOISE_FREQ3         14
 165 #define MXT_NOISE_FREQ4         15
 166 #define MXT_NOISE_IDLEGCAFVALID 16
 167
 168 /* MXT_SPT_COMMSCONFIG_T18 */
 169 #define MXT_COMMS_CTRL          0
 170 #define MXT_COMMS_CMD           1
 171
 172 /* MXT_SPT_CTECONFIG_T28 field */
 173 #define MXT_CTE_CTRL            0
 174 #define MXT_CTE_CMD             1
 175 #define MXT_CTE_MODE            2
 176 #define MXT_CTE_IDLEGCAFDEPTH   3
 177 #define MXT_CTE_ACTVGCAFDEPTH   4
 178 #define MXT_CTE_VOLTAGE         5
 179
 180 #define MXT_VOLTAGE_DEFAULT     2700000
 181 #define MXT_VOLTAGE_STEP        10000
 182
 183 /* Define for MXT_GEN_COMMAND_T6 */
 184 #define MXT_BOOT_VALUE          0xa5
 185 #define MXT_RESET_VALUE         0x01
 186 #define MXT_BACKUP_VALUE        0x55
 187
 188 /* Delay times */
 189 #define MXT_BACKUP_TIME         50      /* msec */
 190 #define MXT_RESET_TIME          200     /* msec */
 191 #define MXT_RESET_TIMEOUT       3000    /* msec */
 192 #define MXT_CRC_TIMEOUT         1000    /* msec */
 193 #define MXT_FW_RESET_TIME       3000    /* msec */
 194 #define MXT_FW_CHG_TIMEOUT      300     /* msec */
 195
 196 /* Command to unlock bootloader */
 197 #define MXT_UNLOCK_CMD_MSB      0xaa
 198 #define MXT_UNLOCK_CMD_LSB      0xdc
 199
 200 /* Bootloader mode status */
 201 #define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
 202 #define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
 203 #define MXT_FRAME_CRC_CHECK     0x02
 204 #define MXT_FRAME_CRC_FAIL      0x03
 205 #define MXT_FRAME_CRC_PASS      0x04
 206 #define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
 207 #define MXT_BOOT_STATUS_MASK    0x3f
 208 #define MXT_BOOT_EXTENDED_ID    (1 << 5)
 209 #define MXT_BOOT_ID_MASK        0x1f
 210
 211 /* Touchscreen absolute values */
 212 #define MXT_MAX_AREA            0xff
 213
 214 #define MXT_PIXELS_PER_MM       20
 215
 216 struct mxt_info {
 217         u8 family_id;
 218         u8 variant_id;
 219         u8 version;
 220         u8 build;
 221         u8 matrix_xsize;
 222         u8 matrix_ysize;
 223         u8 object_num;
 224 };
 225
 226 struct mxt_object {
 227         u8 type;
 228         u16 start_address;
 229         u8 size_minus_one;
 230         u8 instances_minus_one;
 231         u8 num_report_ids;
 232 } __packed;
 233
 234 /* Each client has this additional data */
 235 struct mxt_data {
 236         struct i2c_client *client;
 237         struct input_dev *input_dev;
 238         char phys[64];          /* device physical location */
 239         const struct mxt_platform_data *pdata;
 240         struct mxt_object *object_table;
 241         struct mxt_info info;
 242         unsigned int irq;
 243         unsigned int max_x;
 244         unsigned int max_y;
 245         bool in_bootloader;
 246         u16 mem_size;
 247         u32 config_crc;
 248         u32 info_crc;
 249         u8 bootloader_addr;
 250         u8 *msg_buf;
 251         u8 t6_status;
 252
 253         /* Cached parameters from object table */
 254         u8 T5_msg_size;
 255         u8 T6_reportid;
 256         u16 T6_address;
 257         u16 T7_address;
 258         u8 T9_reportid_min;
 259         u8 T9_reportid_max;
 260         u8 T19_reportid;
 261
 262         /* for fw update in bootloader */
 263         struct completion bl_completion;
 264
 265         /* for reset handling */
 266         struct completion reset_completion;
 267
 268         /* for config update handling */
 269         struct completion crc_completion;
 270 };
 271
 272 static size_t mxt_obj_size(const struct mxt_object *obj)
 273 {
 274         return obj->size_minus_one + 1;
 275 }
 276
 277 static size_t mxt_obj_instances(const struct mxt_object *obj)
 278 {
 279         return obj->instances_minus_one + 1;
 280 }
 281
 282 static bool mxt_object_readable(unsigned int type)
 283 {
 284         switch (type) {
 285         case MXT_GEN_COMMAND_T6:
 286         case MXT_GEN_POWER_T7:
 287         case MXT_GEN_ACQUIRE_T8:
 288         case MXT_GEN_DATASOURCE_T53:
 289         case MXT_TOUCH_MULTI_T9:
 290         case MXT_TOUCH_KEYARRAY_T15:
 291         case MXT_TOUCH_PROXIMITY_T23:
 292         case MXT_TOUCH_PROXKEY_T52:
 293         case MXT_PROCI_GRIPFACE_T20:
 294         case MXT_PROCG_NOISE_T22:
 295         case MXT_PROCI_ONETOUCH_T24:
 296         case MXT_PROCI_TWOTOUCH_T27:
 297         case MXT_PROCI_GRIP_T40:
 298         case MXT_PROCI_PALM_T41:
 299         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 300         case MXT_PROCI_STYLUS_T47:
 301         case MXT_PROCG_NOISESUPPRESSION_T48:
 302         case MXT_SPT_COMMSCONFIG_T18:
 303         case MXT_SPT_GPIOPWM_T19:
 304         case MXT_SPT_SELFTEST_T25:
 305         case MXT_SPT_CTECONFIG_T28:
 306         case MXT_SPT_USERDATA_T38:
 307         case MXT_SPT_DIGITIZER_T43:
 308         case MXT_SPT_CTECONFIG_T46:
 309                 return true;
 310         default:
 311                 return false;
 312         }
 313 }
 314
 315 static void mxt_dump_message(struct mxt_data *data, u8 *message)
 316 {
 317         dev_dbg(&data->client->dev, "message: %*ph\n",
 318                 data->T5_msg_size, message);
 319 }
 320
 321 static int mxt_wait_for_completion(struct mxt_data *data,
 322                                    struct completion *comp,
 323                                    unsigned int timeout_ms)
 324 {
 325         struct device *dev = &data->client->dev;
 326         unsigned long timeout = msecs_to_jiffies(timeout_ms);
 327         long ret;
 328
 329         ret = wait_for_completion_interruptible_timeout(comp, timeout);
 330         if (ret < 0) {
 331                 return ret;
 332         } else if (ret == 0) {
 333                 dev_err(dev, "Wait for completion timed out.\n");
 334                 return -ETIMEDOUT;
 335         }
 336         return 0;
 337 }
 338
 339 static int mxt_bootloader_read(struct mxt_data *data,
 340                                u8 *val, unsigned int count)
 341 {
 342         int ret;
 343         struct i2c_msg msg;
 344
 345         msg.addr = data->bootloader_addr;
 346         msg.flags = data->client->flags & I2C_M_TEN;
 347         msg.flags |= I2C_M_RD;
 348         msg.len = count;
 349         msg.buf = val;
 350
 351         ret = i2c_transfer(data->client->adapter, &msg, 1);
 352
 353         if (ret == 1) {
 354                 ret = 0;
 355         } else {
 356                 ret = ret < 0 ? ret : -EIO;
 357                 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
 358                         __func__, ret);
 359         }
 360
 361         return ret;
 362 }
 363
 364 static int mxt_bootloader_write(struct mxt_data *data,
 365                                 const u8 * const val, unsigned int count)
 366 {
 367         int ret;
 368         struct i2c_msg msg;
 369
 370         msg.addr = data->bootloader_addr;
 371         msg.flags = data->client->flags & I2C_M_TEN;
 372         msg.len = count;
 373         msg.buf = (u8 *)val;
 374
 375         ret = i2c_transfer(data->client->adapter, &msg, 1);
 376         if (ret == 1) {
 377                 ret = 0;
 378         } else {
 379                 ret = ret < 0 ? ret : -EIO;
 380                 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
 381                         __func__, ret);
 382         }
 383
 384         return ret;
 385 }
 386
 387 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
 388 {
 389         u8 appmode = data->client->addr;
 390         u8 bootloader;
 391
 392         switch (appmode) {
 393         case 0x4a:
 394         case 0x4b:
 395                 /* Chips after 1664S use different scheme */
 396                 if (retry || data->info.family_id >= 0xa2) {
 397                         bootloader = appmode - 0x24;
 398                         break;
 399                 }
 400                 /* Fall through for normal case */
 401         case 0x4c:
 402         case 0x4d:
 403         case 0x5a:
 404         case 0x5b:
 405                 bootloader = appmode - 0x26;
 406                 break;
 407         default:
 408                 dev_err(&data->client->dev,
 409                         "Appmode i2c address 0x%02x not found\n",
 410                         appmode);
 411                 return -EINVAL;
 412         }
 413
 414         data->bootloader_addr = bootloader;
 415         return 0;
 416 }
 417
 418 static int mxt_probe_bootloader(struct mxt_data *data, bool retry)
 419 {
 420         struct device *dev = &data->client->dev;
 421         int ret;
 422         u8 val;
 423         bool crc_failure;
 424
 425         ret = mxt_lookup_bootloader_address(data, retry);
 426         if (ret)
 427                 return ret;
 428
 429         ret = mxt_bootloader_read(data, &val, 1);
 430         if (ret)
 431                 return ret;
 432
 433         /* Check app crc fail mode */
 434         crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
 435
 436         dev_err(dev, "Detected bootloader, status:%02X%s\n",
 437                         val, crc_failure ? ", APP_CRC_FAIL" : "");
 438
 439         return 0;
 440 }
 441
 442 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
 443 {
 444         struct device *dev = &data->client->dev;
 445         u8 buf[3];
 446
 447         if (val & MXT_BOOT_EXTENDED_ID) {
 448                 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
 449                         dev_err(dev, "%s: i2c failure\n", __func__);
 450                         return val;
 451                 }
 452
 453                 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
 454
 455                 return buf[0];
 456         } else {
 457                 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
 458
 459                 return val;
 460         }
 461 }
 462
 463 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
 464                                 bool wait)
 465 {
 466         struct device *dev = &data->client->dev;
 467         u8 val;
 468         int ret;
 469
 470 recheck:
 471         if (wait) {
 472                 /*
 473                  * In application update mode, the interrupt
 474                  * line signals state transitions. We must wait for the
 475                  * CHG assertion before reading the status byte.
 476                  * Once the status byte has been read, the line is deasserted.
 477                  */
 478                 ret = mxt_wait_for_completion(data, &data->bl_completion,
 479                                               MXT_FW_CHG_TIMEOUT);
 480                 if (ret) {
 481                         /*
 482                          * TODO: handle -ERESTARTSYS better by terminating
 483                          * fw update process before returning to userspace
 484                          * by writing length 0x000 to device (iff we are in
 485                          * WAITING_FRAME_DATA state).
 486                          */
 487                         dev_err(dev, "Update wait error %d\n", ret);
 488                         return ret;
 489                 }
 490         }
 491
 492         ret = mxt_bootloader_read(data, &val, 1);
 493         if (ret)
 494                 return ret;
 495
 496         if (state == MXT_WAITING_BOOTLOAD_CMD)
 497                 val = mxt_get_bootloader_version(data, val);
 498
 499         switch (state) {
 500         case MXT_WAITING_BOOTLOAD_CMD:
 501         case MXT_WAITING_FRAME_DATA:
 502         case MXT_APP_CRC_FAIL:
 503                 val &= ~MXT_BOOT_STATUS_MASK;
 504                 break;
 505         case MXT_FRAME_CRC_PASS:
 506                 if (val == MXT_FRAME_CRC_CHECK) {
 507                         goto recheck;
 508                 } else if (val == MXT_FRAME_CRC_FAIL) {
 509                         dev_err(dev, "Bootloader CRC fail\n");
 510                         return -EINVAL;
 511                 }
 512                 break;
 513         default:
 514                 return -EINVAL;
 515         }
 516
 517         if (val != state) {
 518                 dev_err(dev, "Invalid bootloader state %02X != %02X\n",
 519                         val, state);
 520                 return -EINVAL;
 521         }
 522
 523         return 0;
 524 }
 525
 526 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
 527 {
 528         int ret;
 529         u8 buf[2];
 530
 531         if (unlock) {
 532                 buf[0] = MXT_UNLOCK_CMD_LSB;
 533                 buf[1] = MXT_UNLOCK_CMD_MSB;
 534         } else {
 535                 buf[0] = 0x01;
 536                 buf[1] = 0x01;
 537         }
 538
 539         ret = mxt_bootloader_write(data, buf, 2);
 540         if (ret)
 541                 return ret;
 542
 543         return 0;
 544 }
 545
 546 static int __mxt_read_reg(struct i2c_client *client,
 547                                u16 reg, u16 len, void *val)
 548 {
 549         struct i2c_msg xfer[2];
 550         u8 buf[2];
 551         int ret;
 552
 553         buf[0] = reg & 0xff;
 554         buf[1] = (reg >> 8) & 0xff;
 555
 556         /* Write register */
 557         xfer[0].addr = client->addr;
 558         xfer[0].flags = 0;
 559         xfer[0].len = 2;
 560         xfer[0].buf = buf;
 561
 562         /* Read data */
 563         xfer[1].addr = client->addr;
 564         xfer[1].flags = I2C_M_RD;
 565         xfer[1].len = len;
 566         xfer[1].buf = val;
 567
 568         ret = i2c_transfer(client->adapter, xfer, 2);
 569         if (ret == 2) {
 570                 ret = 0;
 571         } else {
 572                 if (ret >= 0)
 573                         ret = -EIO;
 574                 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
 575                         __func__, ret);
 576         }
 577
 578         return ret;
 579 }
 580
 581 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 582                            const void *val)
 583 {
 584         u8 *buf;
 585         size_t count;
 586         int ret;
 587
 588         count = len + 2;
 589         buf = kmalloc(count, GFP_KERNEL);
 590         if (!buf)
 591                 return -ENOMEM;
 592
 593         buf[0] = reg & 0xff;
 594         buf[1] = (reg >> 8) & 0xff;
 595         memcpy(&buf[2], val, len);
 596
 597         ret = i2c_master_send(client, buf, count);
 598         if (ret == count) {
 599                 ret = 0;
 600         } else {
 601                 if (ret >= 0)
 602                         ret = -EIO;
 603                 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
 604                         __func__, ret);
 605         }
 606
 607         kfree(buf);
 608         return ret;
 609 }
 610
 611 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 612 {
 613         return __mxt_write_reg(client, reg, 1, &val);
 614 }
 615
 616 static struct mxt_object *
 617 mxt_get_object(struct mxt_data *data, u8 type)
 618 {
 619         struct mxt_object *object;
 620         int i;
 621
 622         for (i = 0; i < data->info.object_num; i++) {
 623                 object = data->object_table + i;
 624                 if (object->type == type)
 625                         return object;
 626         }
 627
 628         dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
 629         return NULL;
 630 }
 631
 632 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
 633 {
 634         struct device *dev = &data->client->dev;
 635         u8 status = msg[1];
 636         u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
 637
 638         complete(&data->crc_completion);
 639
 640         if (crc != data->config_crc) {
 641                 data->config_crc = crc;
 642                 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
 643         }
 644
 645         /* Detect reset */
 646         if (status & MXT_T6_STATUS_RESET)
 647                 complete(&data->reset_completion);
 648
 649         /* Output debug if status has changed */
 650         if (status != data->t6_status)
 651                 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
 652                         status,
 653                         status == 0 ? " OK" : "",
 654                         status & MXT_T6_STATUS_RESET ? " RESET" : "",
 655                         status & MXT_T6_STATUS_OFL ? " OFL" : "",
 656                         status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
 657                         status & MXT_T6_STATUS_CAL ? " CAL" : "",
 658                         status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
 659                         status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
 660
 661         /* Save current status */
 662         data->t6_status = status;
 663 }
 664
 665 static int mxt_read_message(struct mxt_data *data, u8 *message)
 666 {
 667         struct mxt_object *object;
 668         u16 reg;
 669
 670         object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
 671         if (!object)
 672                 return -EINVAL;
 673
 674         reg = object->start_address;
 675         return __mxt_read_reg(data->client, reg,
 676                         data->T5_msg_size, message);
 677 }
 678
 679 static int mxt_write_object(struct mxt_data *data,
 680                                  u8 type, u8 offset, u8 val)
 681 {
 682         struct mxt_object *object;
 683         u16 reg;
 684
 685         object = mxt_get_object(data, type);
 686         if (!object || offset >= mxt_obj_size(object))
 687                 return -EINVAL;
 688
 689         reg = object->start_address;
 690         return mxt_write_reg(data->client, reg + offset, val);
 691 }
 692
 693 static void mxt_input_button(struct mxt_data *data, u8 *message)
 694 {
 695         struct input_dev *input = data->input_dev;
 696         const struct mxt_platform_data *pdata = data->pdata;
 697         bool button;
 698         int i;
 699
 700         /* Active-low switch */
 701         for (i = 0; i < pdata->t19_num_keys; i++) {
 702                 if (pdata->t19_keymap[i] == KEY_RESERVED)
 703                         continue;
 704                 button = !(message[1] & (1 << i));
 705                 input_report_key(input, pdata->t19_keymap[i], button);
 706         }
 707 }
 708
 709 static void mxt_input_sync(struct mxt_data *data)
 710 {
 711         input_mt_report_pointer_emulation(data->input_dev,
 712                                           data->pdata->t19_num_keys);
 713         input_sync(data->input_dev);
 714 }
 715
 716 static void mxt_input_touchevent(struct mxt_data *data, u8 *message)
 717 {
 718         struct device *dev = &data->client->dev;
 719         struct input_dev *input_dev = data->input_dev;
 720         int id;
 721         u8 status;
 722         int x;
 723         int y;
 724         int area;
 725         int amplitude;
 726
 727         id = message[0] - data->T9_reportid_min;
 728         status = message[1];
 729         x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
 730         y = (message[3] << 4) | ((message[4] & 0xf));
 731
 732         /* Handle 10/12 bit switching */
 733         if (data->max_x < 1024)
 734                 x >>= 2;
 735         if (data->max_y < 1024)
 736                 y >>= 2;
 737
 738         area = message[5];
 739         amplitude = message[6];
 740
 741         dev_dbg(dev,
 742                 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
 743                 id,
 744                 (status & MXT_T9_DETECT) ? 'D' : '.',
 745                 (status & MXT_T9_PRESS) ? 'P' : '.',
 746                 (status & MXT_T9_RELEASE) ? 'R' : '.',
 747                 (status & MXT_T9_MOVE) ? 'M' : '.',
 748                 (status & MXT_T9_VECTOR) ? 'V' : '.',
 749                 (status & MXT_T9_AMP) ? 'A' : '.',
 750                 (status & MXT_T9_SUPPRESS) ? 'S' : '.',
 751                 (status & MXT_T9_UNGRIP) ? 'U' : '.',
 752                 x, y, area, amplitude);
 753
 754         input_mt_slot(input_dev, id);
 755
 756         if (status & MXT_T9_DETECT) {
 757                 /*
 758                  * Multiple bits may be set if the host is slow to read
 759                  * the status messages, indicating all the events that
 760                  * have happened.
 761                  */
 762                 if (status & MXT_T9_RELEASE) {
 763                         input_mt_report_slot_state(input_dev,
 764                                                    MT_TOOL_FINGER, 0);
 765                         mxt_input_sync(data);
 766                 }
 767
 768                 /* Touch active */
 769                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
 770                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 771                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 772                 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 773                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 774         } else {
 775                 /* Touch no longer active, close out slot */
 776                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
 777         }
 778 }
 779
 780 static bool mxt_is_T9_message(struct mxt_data *data, u8 *msg)
 781 {
 782         u8 id = msg[0];
 783         return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
 784 }
 785
 786 static irqreturn_t mxt_process_messages_until_invalid(struct mxt_data *data)
 787 {
 788         u8 *message = &data->msg_buf[0];
 789         struct device *dev = &data->client->dev;
 790         u8 reportid;
 791         bool update_input = false;
 792
 793         do {
 794                 if (mxt_read_message(data, message)) {
 795                         dev_err(dev, "Failed to read message\n");
 796                         return IRQ_NONE;
 797                 }
 798
 799                 reportid = message[0];
 800
 801                 if (reportid == data->T6_reportid) {
 802                         mxt_proc_t6_messages(data, message);
 803                 } else if (!data->input_dev) {
 804                         /*
 805                          * do not report events if input device
 806                          * is not yet registered
 807                          */
 808                         mxt_dump_message(data, message);
 809                 } else if (mxt_is_T9_message(data, message)) {
 810                         mxt_input_touchevent(data, message);
 811                         update_input = true;
 812                 } else if (reportid == data->T19_reportid) {
 813                         mxt_input_button(data, message);
 814                         update_input = true;
 815                 } else {
 816                         mxt_dump_message(data, message);
 817                 }
 818         } while (reportid != MXT_RPTID_NOMSG);
 819
 820         if (update_input)
 821                 mxt_input_sync(data);
 822
 823         return IRQ_HANDLED;
 824 }
 825
 826 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 827 {
 828         struct mxt_data *data = dev_id;
 829
 830         if (data->in_bootloader) {
 831                 /* bootloader state transition completion */
 832                 complete(&data->bl_completion);
 833                 return IRQ_HANDLED;
 834         }
 835
 836         if (!data->object_table)
 837                 return IRQ_HANDLED;
 838
 839         return mxt_process_messages_until_invalid(data);
 840 }
 841
 842 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
 843                           u8 value, bool wait)
 844 {
 845         u16 reg;
 846         u8 command_register;
 847         int timeout_counter = 0;
 848         int ret;
 849
 850         reg = data->T6_address + cmd_offset;
 851
 852         ret = mxt_write_reg(data->client, reg, value);
 853         if (ret)
 854                 return ret;
 855
 856         if (!wait)
 857                 return 0;
 858
 859         do {
 860                 msleep(20);
 861                 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
 862                 if (ret)
 863                         return ret;
 864         } while (command_register != 0 && timeout_counter++ <= 100);
 865
 866         if (timeout_counter > 100) {
 867                 dev_err(&data->client->dev, "Command failed!\n");
 868                 return -EIO;
 869         }
 870
 871         return 0;
 872 }
 873
 874 static int mxt_soft_reset(struct mxt_data *data)
 875 {
 876         struct device *dev = &data->client->dev;
 877         int ret = 0;
 878
 879         dev_info(dev, "Resetting chip\n");
 880
 881         reinit_completion(&data->reset_completion);
 882
 883         ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
 884         if (ret)
 885                 return ret;
 886
 887         ret = mxt_wait_for_completion(data, &data->reset_completion,
 888                                       MXT_RESET_TIMEOUT);
 889         if (ret)
 890                 return ret;
 891
 892         return 0;
 893 }
 894
 895 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
 896 {
 897         /*
 898          * On failure, CRC is set to 0 and config will always be
 899          * downloaded.
 900          */
 901         data->config_crc = 0;
 902         reinit_completion(&data->crc_completion);
 903
 904         mxt_t6_command(data, cmd, value, true);
 905
 906         /*
 907          * Wait for crc message. On failure, CRC is set to 0 and config will
 908          * always be downloaded.
 909          */
 910         mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
 911 }
 912
 913 static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
 914 {
 915         static const unsigned int crcpoly = 0x80001B;
 916         u32 result;
 917         u32 data_word;
 918
 919         data_word = (secondbyte << 8) | firstbyte;
 920         result = ((*crc << 1) ^ data_word);
 921
 922         if (result & 0x1000000)
 923                 result ^= crcpoly;
 924
 925         *crc = result;
 926 }
 927
 928 static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
 929 {
 930         u32 crc = 0;
 931         u8 *ptr = base + start_off;
 932         u8 *last_val = base + end_off - 1;
 933
 934         if (end_off < start_off)
 935                 return -EINVAL;
 936
 937         while (ptr < last_val) {
 938                 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
 939                 ptr += 2;
 940         }
 941
 942         /* if len is odd, fill the last byte with 0 */
 943         if (ptr == last_val)
 944                 mxt_calc_crc24(&crc, *ptr, 0);
 945
 946         /* Mask to 24-bit */
 947         crc &= 0x00FFFFFF;
 948
 949         return crc;
 950 }
 951
 952 /*
 953  * mxt_update_cfg - download configuration to chip
 954  *
 955  * Atmel Raw Config File Format
 956  *
 957  * The first four lines of the raw config file contain:
 958  *  1) Version
 959  *  2) Chip ID Information (first 7 bytes of device memory)
 960  *  3) Chip Information Block 24-bit CRC Checksum
 961  *  4) Chip Configuration 24-bit CRC Checksum
 962  *
 963  * The rest of the file consists of one line per object instance:
 964  *   <TYPE> <INSTANCE> <SIZE> <CONTENTS>
 965  *
 966  *   <TYPE> - 2-byte object type as hex
 967  *   <INSTANCE> - 2-byte object instance number as hex
 968  *   <SIZE> - 2-byte object size as hex
 969  *   <CONTENTS> - array of <SIZE> 1-byte hex values
 970  */
 971 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
 972 {
 973         struct device *dev = &data->client->dev;
 974         struct mxt_info cfg_info;
 975         struct mxt_object *object;
 976         int ret;
 977         int offset;
 978         int data_pos;
 979         int byte_offset;
 980         int i;
 981         int cfg_start_ofs;
 982         u32 info_crc, config_crc, calculated_crc;
 983         u8 *config_mem;
 984         size_t config_mem_size;
 985         unsigned int type, instance, size;
 986         u8 val;
 987         u16 reg;
 988
 989         mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
 990
 991         if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
 992                 dev_err(dev, "Unrecognised config file\n");
 993                 ret = -EINVAL;
 994                 goto release;
 995         }
 996
 997         data_pos = strlen(MXT_CFG_MAGIC);
 998
 999         /* Load information block and check */
1000         for (i = 0; i < sizeof(struct mxt_info); i++) {
1001                 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1002                              (unsigned char *)&cfg_info + i,
1003                              &offset);
1004                 if (ret != 1) {
1005                         dev_err(dev, "Bad format\n");
1006                         ret = -EINVAL;
1007                         goto release;
1008                 }
1009
1010                 data_pos += offset;
1011         }
1012
1013         if (cfg_info.family_id != data->info.family_id) {
1014                 dev_err(dev, "Family ID mismatch!\n");
1015                 ret = -EINVAL;
1016                 goto release;
1017         }
1018
1019         if (cfg_info.variant_id != data->info.variant_id) {
1020                 dev_err(dev, "Variant ID mismatch!\n");
1021                 ret = -EINVAL;
1022                 goto release;
1023         }
1024
1025         /* Read CRCs */
1026         ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1027         if (ret != 1) {
1028                 dev_err(dev, "Bad format: failed to parse Info CRC\n");
1029                 ret = -EINVAL;
1030                 goto release;
1031         }
1032         data_pos += offset;
1033
1034         ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1035         if (ret != 1) {
1036                 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1037                 ret = -EINVAL;
1038                 goto release;
1039         }
1040         data_pos += offset;
1041
1042         /*
1043          * The Info Block CRC is calculated over mxt_info and the object
1044          * table. If it does not match then we are trying to load the
1045          * configuration from a different chip or firmware version, so
1046          * the configuration CRC is invalid anyway.
1047          */
1048         if (info_crc == data->info_crc) {
1049                 if (config_crc == 0 || data->config_crc == 0) {
1050                         dev_info(dev, "CRC zero, attempting to apply config\n");
1051                 } else if (config_crc == data->config_crc) {
1052                         dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1053                                  data->config_crc);
1054                         ret = 0;
1055                         goto release;
1056                 } else {
1057                         dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1058                                  data->config_crc, config_crc);
1059                 }
1060         } else {
1061                 dev_warn(dev,
1062                          "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1063                          data->info_crc, info_crc);
1064         }
1065
1066         /* Malloc memory to store configuration */
1067         cfg_start_ofs = MXT_OBJECT_START +
1068                         data->info.object_num * sizeof(struct mxt_object) +
1069                         MXT_INFO_CHECKSUM_SIZE;
1070         config_mem_size = data->mem_size - cfg_start_ofs;
1071         config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1072         if (!config_mem) {
1073                 dev_err(dev, "Failed to allocate memory\n");
1074                 ret = -ENOMEM;
1075                 goto release;
1076         }
1077
1078         while (data_pos < cfg->size) {
1079                 /* Read type, instance, length */
1080                 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1081                              &type, &instance, &size, &offset);
1082                 if (ret == 0) {
1083                         /* EOF */
1084                         break;
1085                 } else if (ret != 3) {
1086                         dev_err(dev, "Bad format: failed to parse object\n");
1087                         ret = -EINVAL;
1088                         goto release_mem;
1089                 }
1090                 data_pos += offset;
1091
1092                 object = mxt_get_object(data, type);
1093                 if (!object) {
1094                         /* Skip object */
1095                         for (i = 0; i < size; i++) {
1096                                 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1097                                              &val,
1098                                              &offset);
1099                                 data_pos += offset;
1100                         }
1101                         continue;
1102                 }
1103
1104                 if (size > mxt_obj_size(object)) {
1105                         /*
1106                          * Either we are in fallback mode due to wrong
1107                          * config or config from a later fw version,
1108                          * or the file is corrupt or hand-edited.
1109                          */
1110                         dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1111                                  size - mxt_obj_size(object), type);
1112                 } else if (mxt_obj_size(object) > size) {
1113                         /*
1114                          * If firmware is upgraded, new bytes may be added to
1115                          * end of objects. It is generally forward compatible
1116                          * to zero these bytes - previous behaviour will be
1117                          * retained. However this does invalidate the CRC and
1118                          * will force fallback mode until the configuration is
1119                          * updated. We warn here but do nothing else - the
1120                          * malloc has zeroed the entire configuration.
1121                          */
1122                         dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1123                                  mxt_obj_size(object) - size, type);
1124                 }
1125
1126                 if (instance >= mxt_obj_instances(object)) {
1127                         dev_err(dev, "Object instances exceeded!\n");
1128                         ret = -EINVAL;
1129                         goto release_mem;
1130                 }
1131
1132                 reg = object->start_address + mxt_obj_size(object) * instance;
1133
1134                 for (i = 0; i < size; i++) {
1135                         ret = sscanf(cfg->data + data_pos, "%hhx%n",
1136                                      &val,
1137                                      &offset);
1138                         if (ret != 1) {
1139                                 dev_err(dev, "Bad format in T%d\n", type);
1140                                 ret = -EINVAL;
1141                                 goto release_mem;
1142                         }
1143                         data_pos += offset;
1144
1145                         if (i > mxt_obj_size(object))
1146                                 continue;
1147
1148                         byte_offset = reg + i - cfg_start_ofs;
1149
1150                         if ((byte_offset >= 0)
1151                             && (byte_offset <= config_mem_size)) {
1152                                 *(config_mem + byte_offset) = val;
1153                         } else {
1154                                 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1155                                         reg, object->type, byte_offset);
1156                                 ret = -EINVAL;
1157                                 goto release_mem;
1158                         }
1159                 }
1160         }
1161
1162         /* Calculate crc of the received configs (not the raw config file) */
1163         if (data->T7_address < cfg_start_ofs) {
1164                 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1165                         data->T7_address, cfg_start_ofs);
1166                 ret = 0;
1167                 goto release_mem;
1168         }
1169
1170         calculated_crc = mxt_calculate_crc(config_mem,
1171                                            data->T7_address - cfg_start_ofs,
1172                                            config_mem_size);
1173
1174         if (config_crc > 0 && (config_crc != calculated_crc))
1175                 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1176                          calculated_crc, config_crc);
1177
1178         /* Write configuration as blocks */
1179         byte_offset = 0;
1180         while (byte_offset < config_mem_size) {
1181                 size = config_mem_size - byte_offset;
1182
1183                 if (size > MXT_MAX_BLOCK_WRITE)
1184                         size = MXT_MAX_BLOCK_WRITE;
1185
1186                 ret = __mxt_write_reg(data->client,
1187                                       cfg_start_ofs + byte_offset,
1188                                       size, config_mem + byte_offset);
1189                 if (ret != 0) {
1190                         dev_err(dev, "Config write error, ret=%d\n", ret);
1191                         goto release_mem;
1192                 }
1193
1194                 byte_offset += size;
1195         }
1196
1197         mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1198
1199         ret = mxt_soft_reset(data);
1200         if (ret)
1201                 goto release_mem;
1202
1203         dev_info(dev, "Config successfully updated\n");
1204
1205 release_mem:
1206         kfree(config_mem);
1207 release:
1208         release_firmware(cfg);
1209         return ret;
1210 }
1211
1212 static int mxt_make_highchg(struct mxt_data *data)
1213 {
1214         struct device *dev = &data->client->dev;
1215         int count = 10;
1216         int error;
1217
1218         /* Read dummy message to make high CHG pin */
1219         do {
1220                 error = mxt_read_message(data, data->msg_buf);
1221                 if (error)
1222                         return error;
1223         } while (data->msg_buf[0] != MXT_RPTID_NOMSG && --count);
1224
1225         if (!count) {
1226                 dev_err(dev, "CHG pin isn't cleared\n");
1227                 return -EBUSY;
1228         }
1229
1230         return 0;
1231 }
1232
1233 static int mxt_acquire_irq(struct mxt_data *data)
1234 {
1235         int error;
1236
1237         enable_irq(data->irq);
1238
1239         error = mxt_make_highchg(data);
1240         if (error)
1241                 return error;
1242
1243         return 0;
1244 }
1245
1246 static int mxt_get_info(struct mxt_data *data)
1247 {
1248         struct i2c_client *client = data->client;
1249         struct mxt_info *info = &data->info;
1250         int error;
1251
1252         /* Read 7-byte info block starting at address 0 */
1253         error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
1254         if (error)
1255                 return error;
1256
1257         return 0;
1258 }
1259
1260 static void mxt_free_object_table(struct mxt_data *data)
1261 {
1262         input_unregister_device(data->input_dev);
1263         data->input_dev = NULL;
1264
1265         kfree(data->object_table);
1266         data->object_table = NULL;
1267         kfree(data->msg_buf);
1268         data->msg_buf = NULL;
1269         data->T5_msg_size = 0;
1270         data->T6_reportid = 0;
1271         data->T7_address = 0;
1272         data->T9_reportid_min = 0;
1273         data->T9_reportid_max = 0;
1274         data->T19_reportid = 0;
1275 }
1276
1277 static int mxt_get_object_table(struct mxt_data *data)
1278 {
1279         struct i2c_client *client = data->client;
1280         size_t table_size;
1281         struct mxt_object *object_table;
1282         int error;
1283         int i;
1284         u8 reportid;
1285         u16 end_address;
1286
1287         table_size = data->info.object_num * sizeof(struct mxt_object);
1288         object_table = kzalloc(table_size, GFP_KERNEL);
1289         if (!object_table) {
1290                 dev_err(&data->client->dev, "Failed to allocate memory\n");
1291                 return -ENOMEM;
1292         }
1293
1294         error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
1295                         object_table);
1296         if (error) {
1297                 kfree(object_table);
1298                 return error;
1299         }
1300
1301         /* Valid Report IDs start counting from 1 */
1302         reportid = 1;
1303         data->mem_size = 0;
1304         for (i = 0; i < data->info.object_num; i++) {
1305                 struct mxt_object *object = object_table + i;
1306                 u8 min_id, max_id;
1307
1308                 le16_to_cpus(&object->start_address);
1309
1310                 if (object->num_report_ids) {
1311                         min_id = reportid;
1312                         reportid += object->num_report_ids *
1313                                         mxt_obj_instances(object);
1314                         max_id = reportid - 1;
1315                 } else {
1316                         min_id = 0;
1317                         max_id = 0;
1318                 }
1319
1320                 dev_dbg(&data->client->dev,
1321                         "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1322                         object->type, object->start_address,
1323                         mxt_obj_size(object), mxt_obj_instances(object),
1324                         min_id, max_id);
1325
1326                 switch (object->type) {
1327                 case MXT_GEN_MESSAGE_T5:
1328                         /* CRC not enabled, therefore don't read last byte */
1329                         data->T5_msg_size = mxt_obj_size(object) - 1;
1330                 case MXT_GEN_COMMAND_T6:
1331                         data->T6_reportid = min_id;
1332                         data->T6_address = object->start_address;
1333                         break;
1334                 case MXT_GEN_POWER_T7:
1335                         data->T7_address = object->start_address;
1336                         break;
1337                 case MXT_TOUCH_MULTI_T9:
1338                         data->T9_reportid_min = min_id;
1339                         data->T9_reportid_max = max_id;
1340                         break;
1341                 case MXT_SPT_GPIOPWM_T19:
1342                         data->T19_reportid = min_id;
1343                         break;
1344                 }
1345
1346                 end_address = object->start_address
1347                         + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1348
1349                 if (end_address >= data->mem_size)
1350                         data->mem_size = end_address + 1;
1351         }
1352
1353         data->msg_buf = kzalloc(data->T5_msg_size, GFP_KERNEL);
1354         if (!data->msg_buf) {
1355                 dev_err(&client->dev, "Failed to allocate message buffer\n");
1356                 error = -ENOMEM;
1357                 goto free_object_table;
1358         }
1359
1360         data->object_table = object_table;
1361
1362         return 0;
1363
1364 free_object_table:
1365         mxt_free_object_table(data);
1366         return error;
1367 }
1368
1369 static int mxt_read_t9_resolution(struct mxt_data *data)
1370 {
1371         struct i2c_client *client = data->client;
1372         int error;
1373         struct t9_range range;
1374         unsigned char orient;
1375         struct mxt_object *object;
1376
1377         object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1378         if (!object)
1379                 return -EINVAL;
1380
1381         error = __mxt_read_reg(client,
1382                                object->start_address + MXT_T9_RANGE,
1383                                sizeof(range), &range);
1384         if (error)
1385                 return error;
1386
1387         le16_to_cpus(&range.x);
1388         le16_to_cpus(&range.y);
1389
1390         error =  __mxt_read_reg(client,
1391                                 object->start_address + MXT_T9_ORIENT,
1392                                 1, &orient);
1393         if (error)
1394                 return error;
1395
1396         /* Handle default values */
1397         if (range.x == 0)
1398                 range.x = 1023;
1399
1400         if (range.y == 0)
1401                 range.y = 1023;
1402
1403         if (orient & MXT_T9_ORIENT_SWITCH) {
1404                 data->max_x = range.y;
1405                 data->max_y = range.x;
1406         } else {
1407                 data->max_x = range.x;
1408                 data->max_y = range.y;
1409         }
1410
1411         dev_dbg(&client->dev,
1412                 "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1413
1414         return 0;
1415 }
1416
1417 static int mxt_input_open(struct input_dev *dev);
1418 static void mxt_input_close(struct input_dev *dev);
1419
1420 static int mxt_initialize_t9_input_device(struct mxt_data *data)
1421 {
1422         struct device *dev = &data->client->dev;
1423         const struct mxt_platform_data *pdata = data->pdata;
1424         struct input_dev *input_dev;
1425         int error;
1426         unsigned int num_mt_slots;
1427         unsigned int mt_flags = 0;
1428         int i;
1429
1430         error = mxt_read_t9_resolution(data);
1431         if (error)
1432                 dev_warn(dev, "Failed to initialize T9 resolution\n");
1433
1434         input_dev = input_allocate_device();
1435         if (!input_dev) {
1436                 dev_err(dev, "Failed to allocate memory\n");
1437                 return -ENOMEM;
1438         }
1439
1440         input_dev->name = "Atmel maXTouch Touchscreen";
1441         input_dev->phys = data->phys;
1442         input_dev->id.bustype = BUS_I2C;
1443         input_dev->dev.parent = dev;
1444         input_dev->open = mxt_input_open;
1445         input_dev->close = mxt_input_close;
1446
1447         __set_bit(EV_ABS, input_dev->evbit);
1448         __set_bit(EV_KEY, input_dev->evbit);
1449         __set_bit(BTN_TOUCH, input_dev->keybit);
1450
1451         if (pdata->t19_num_keys) {
1452                 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1453
1454                 for (i = 0; i < pdata->t19_num_keys; i++)
1455                         if (pdata->t19_keymap[i] != KEY_RESERVED)
1456                                 input_set_capability(input_dev, EV_KEY,
1457                                                      pdata->t19_keymap[i]);
1458
1459                 mt_flags |= INPUT_MT_POINTER;
1460
1461                 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1462                 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1463                 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1464                                   MXT_PIXELS_PER_MM);
1465                 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1466                                   MXT_PIXELS_PER_MM);
1467
1468                 input_dev->name = "Atmel maXTouch Touchpad";
1469         }
1470
1471         /* For single touch */
1472         input_set_abs_params(input_dev, ABS_X,
1473                              0, data->max_x, 0, 0);
1474         input_set_abs_params(input_dev, ABS_Y,
1475                              0, data->max_y, 0, 0);
1476         input_set_abs_params(input_dev, ABS_PRESSURE,
1477                              0, 255, 0, 0);
1478
1479         /* For multi touch */
1480         num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1481         error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1482         if (error) {
1483                 dev_err(dev, "Error %d initialising slots\n", error);
1484                 goto err_free_mem;
1485         }
1486
1487         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1488                              0, MXT_MAX_AREA, 0, 0);
1489         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1490                              0, data->max_x, 0, 0);
1491         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1492                              0, data->max_y, 0, 0);
1493         input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1494                              0, 255, 0, 0);
1495
1496         input_set_drvdata(input_dev, data);
1497
1498         error = input_register_device(input_dev);
1499         if (error) {
1500                 dev_err(dev, "Error %d registering input device\n", error);
1501                 goto err_free_mem;
1502         }
1503
1504         data->input_dev = input_dev;
1505
1506         return 0;
1507
1508 err_free_mem:
1509         input_free_device(input_dev);
1510         return error;
1511 }
1512
1513 static int mxt_configure_objects(struct mxt_data *data,
1514                                  const struct firmware *cfg);
1515
1516 static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1517 {
1518         mxt_configure_objects(ctx, cfg);
1519 }
1520
1521 static int mxt_initialize(struct mxt_data *data)
1522 {
1523         struct i2c_client *client = data->client;
1524         int error;
1525         bool alt_bootloader_addr = false;
1526         bool retry = false;
1527
1528 retry_info:
1529         error = mxt_get_info(data);
1530         if (error) {
1531 retry_bootloader:
1532                 error = mxt_probe_bootloader(data, alt_bootloader_addr);
1533                 if (error) {
1534                         if (alt_bootloader_addr) {
1535                                 /* Chip is not in appmode or bootloader mode */
1536                                 return error;
1537                         }
1538
1539                         dev_info(&client->dev, "Trying alternate bootloader address\n");
1540                         alt_bootloader_addr = true;
1541                         goto retry_bootloader;
1542                 } else {
1543                         if (retry) {
1544                                 dev_err(&client->dev, "Could not recover from bootloader mode\n");
1545                                 /*
1546                                  * We can reflash from this state, so do not
1547                                  * abort init
1548                                  */
1549                                 data->in_bootloader = true;
1550                                 return 0;
1551                         }
1552
1553                         /* Attempt to exit bootloader into app mode */
1554                         mxt_send_bootloader_cmd(data, false);
1555                         msleep(MXT_FW_RESET_TIME);
1556                         retry = true;
1557                         goto retry_info;
1558                 }
1559         }
1560
1561         /* Get object table information */
1562         error = mxt_get_object_table(data);
1563         if (error) {
1564                 dev_err(&client->dev, "Error %d reading object table\n", error);
1565                 return error;
1566         }
1567
1568         mxt_acquire_irq(data);
1569         if (error)
1570                 goto err_free_object_table;
1571
1572         request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
1573                                 &data->client->dev, GFP_KERNEL, data,
1574                                 mxt_config_cb);
1575
1576         return 0;
1577
1578 err_free_object_table:
1579         mxt_free_object_table(data);
1580         return error;
1581 }
1582
1583 static int mxt_configure_objects(struct mxt_data *data,
1584                                  const struct firmware *cfg)
1585 {
1586         struct device *dev = &data->client->dev;
1587         struct mxt_info *info = &data->info;
1588         int error;
1589
1590         if (cfg) {
1591                 error = mxt_update_cfg(data, cfg);
1592                 if (error)
1593                         dev_warn(dev, "Error %d updating config\n", error);
1594         }
1595
1596         error = mxt_initialize_t9_input_device(data);
1597         if (error)
1598                 return error;
1599
1600         dev_info(dev,
1601                  "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
1602                  info->family_id, info->variant_id, info->version >> 4,
1603                  info->version & 0xf, info->build, info->object_num);
1604
1605         return 0;
1606 }
1607
1608 /* Firmware Version is returned as Major.Minor.Build */
1609 static ssize_t mxt_fw_version_show(struct device *dev,
1610                                    struct device_attribute *attr, char *buf)
1611 {
1612         struct mxt_data *data = dev_get_drvdata(dev);
1613         struct mxt_info *info = &data->info;
1614         return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
1615                          info->version >> 4, info->version & 0xf, info->build);
1616 }
1617
1618 /* Hardware Version is returned as FamilyID.VariantID */
1619 static ssize_t mxt_hw_version_show(struct device *dev,
1620                                    struct device_attribute *attr, char *buf)
1621 {
1622         struct mxt_data *data = dev_get_drvdata(dev);
1623         struct mxt_info *info = &data->info;
1624         return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
1625                          info->family_id, info->variant_id);
1626 }
1627
1628 static ssize_t mxt_show_instance(char *buf, int count,
1629                                  struct mxt_object *object, int instance,
1630                                  const u8 *val)
1631 {
1632         int i;
1633
1634         if (mxt_obj_instances(object) > 1)
1635                 count += scnprintf(buf + count, PAGE_SIZE - count,
1636                                    "Instance %u\n", instance);
1637
1638         for (i = 0; i < mxt_obj_size(object); i++)
1639                 count += scnprintf(buf + count, PAGE_SIZE - count,
1640                                 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
1641         count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
1642
1643         return count;
1644 }
1645
1646 static ssize_t mxt_object_show(struct device *dev,
1647                                     struct device_attribute *attr, char *buf)
1648 {
1649         struct mxt_data *data = dev_get_drvdata(dev);
1650         struct mxt_object *object;
1651         int count = 0;
1652         int i, j;
1653         int error;
1654         u8 *obuf;
1655
1656         /* Pre-allocate buffer large enough to hold max sized object. */
1657         obuf = kmalloc(256, GFP_KERNEL);
1658         if (!obuf)
1659                 return -ENOMEM;
1660
1661         error = 0;
1662         for (i = 0; i < data->info.object_num; i++) {
1663                 object = data->object_table + i;
1664
1665                 if (!mxt_object_readable(object->type))
1666                         continue;
1667
1668                 count += scnprintf(buf + count, PAGE_SIZE - count,
1669                                 "T%u:\n", object->type);
1670
1671                 for (j = 0; j < mxt_obj_instances(object); j++) {
1672                         u16 size = mxt_obj_size(object);
1673                         u16 addr = object->start_address + j * size;
1674
1675                         error = __mxt_read_reg(data->client, addr, size, obuf);
1676                         if (error)
1677                                 goto done;
1678
1679                         count = mxt_show_instance(buf, count, object, j, obuf);
1680                 }
1681         }
1682
1683 done:
1684         kfree(obuf);
1685         return error ?: count;
1686 }
1687
1688 static int mxt_check_firmware_format(struct device *dev,
1689                                      const struct firmware *fw)
1690 {
1691         unsigned int pos = 0;
1692         char c;
1693
1694         while (pos < fw->size) {
1695                 c = *(fw->data + pos);
1696
1697                 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
1698                         return 0;
1699
1700                 pos++;
1701         }
1702
1703         /*
1704          * To convert file try:
1705          * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
1706          */
1707         dev_err(dev, "Aborting: firmware file must be in binary format\n");
1708
1709         return -EINVAL;
1710 }
1711
1712 static int mxt_load_fw(struct device *dev, const char *fn)
1713 {
1714         struct mxt_data *data = dev_get_drvdata(dev);
1715         const struct firmware *fw = NULL;
1716         unsigned int frame_size;
1717         unsigned int pos = 0;
1718         unsigned int retry = 0;
1719         unsigned int frame = 0;
1720         int ret;
1721
1722         ret = request_firmware(&fw, fn, dev);
1723         if (ret) {
1724                 dev_err(dev, "Unable to open firmware %s\n", fn);
1725                 return ret;
1726         }
1727
1728         /* Check for incorrect enc file */
1729         ret = mxt_check_firmware_format(dev, fw);
1730         if (ret)
1731                 goto release_firmware;
1732
1733         if (!data->in_bootloader) {
1734                 /* Change to the bootloader mode */
1735                 data->in_bootloader = true;
1736
1737                 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
1738                                      MXT_BOOT_VALUE, false);
1739                 if (ret)
1740                         goto release_firmware;
1741
1742                 msleep(MXT_RESET_TIME);
1743
1744                 /* Do not need to scan since we know family ID */
1745                 ret = mxt_lookup_bootloader_address(data, 0);
1746                 if (ret)
1747                         goto release_firmware;
1748         } else {
1749                 enable_irq(data->irq);
1750         }
1751
1752         mxt_free_object_table(data);
1753         reinit_completion(&data->bl_completion);
1754
1755         ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
1756         if (ret) {
1757                 /* Bootloader may still be unlocked from previous attempt */
1758                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
1759                 if (ret)
1760                         goto disable_irq;
1761         } else {
1762                 dev_info(dev, "Unlocking bootloader\n");
1763
1764                 /* Unlock bootloader */
1765                 ret = mxt_send_bootloader_cmd(data, true);
1766                 if (ret)
1767                         goto disable_irq;
1768         }
1769
1770         while (pos < fw->size) {
1771                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
1772                 if (ret)
1773                         goto disable_irq;
1774
1775                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
1776
1777                 /* Take account of CRC bytes */
1778                 frame_size += 2;
1779
1780                 /* Write one frame to device */
1781                 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
1782                 if (ret)
1783                         goto disable_irq;
1784
1785                 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
1786                 if (ret) {
1787                         retry++;
1788
1789                         /* Back off by 20ms per retry */
1790                         msleep(retry * 20);
1791
1792                         if (retry > 20) {
1793                                 dev_err(dev, "Retry count exceeded\n");
1794                                 goto disable_irq;
1795                         }
1796                 } else {
1797                         retry = 0;
1798                         pos += frame_size;
1799                         frame++;
1800                 }
1801
1802                 if (frame % 50 == 0)
1803                         dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
1804                                 frame, pos, fw->size);
1805         }
1806
1807         /* Wait for flash. */
1808         ret = mxt_wait_for_completion(data, &data->bl_completion,
1809                                       MXT_FW_RESET_TIME);
1810         if (ret)
1811                 goto disable_irq;
1812
1813         dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
1814
1815         /*
1816          * Wait for device to reset. Some bootloader versions do not assert
1817          * the CHG line after bootloading has finished, so ignore potential
1818          * errors.
1819          */
1820         mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
1821
1822         data->in_bootloader = false;
1823
1824 disable_irq:
1825         disable_irq(data->irq);
1826 release_firmware:
1827         release_firmware(fw);
1828         return ret;
1829 }
1830
1831 static ssize_t mxt_update_fw_store(struct device *dev,
1832                                         struct device_attribute *attr,
1833                                         const char *buf, size_t count)
1834 {
1835         struct mxt_data *data = dev_get_drvdata(dev);
1836         int error;
1837
1838         error = mxt_load_fw(dev, MXT_FW_NAME);
1839         if (error) {
1840                 dev_err(dev, "The firmware update failed(%d)\n", error);
1841                 count = error;
1842         } else {
1843                 dev_info(dev, "The firmware update succeeded\n");
1844
1845                 error = mxt_initialize(data);
1846                 if (error)
1847                         return error;
1848         }
1849
1850         return count;
1851 }
1852
1853 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1854 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1855 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1856 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1857
1858 static struct attribute *mxt_attrs[] = {
1859         &dev_attr_fw_version.attr,
1860         &dev_attr_hw_version.attr,
1861         &dev_attr_object.attr,
1862         &dev_attr_update_fw.attr,
1863         NULL
1864 };
1865
1866 static const struct attribute_group mxt_attr_group = {
1867         .attrs = mxt_attrs,
1868 };
1869
1870 static void mxt_start(struct mxt_data *data)
1871 {
1872         /* Touch enable */
1873         mxt_write_object(data,
1874                         MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
1875 }
1876
1877 static void mxt_stop(struct mxt_data *data)
1878 {
1879         /* Touch disable */
1880         mxt_write_object(data,
1881                         MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1882 }
1883
1884 static int mxt_input_open(struct input_dev *dev)
1885 {
1886         struct mxt_data *data = input_get_drvdata(dev);
1887
1888         mxt_start(data);
1889
1890         return 0;
1891 }
1892
1893 static void mxt_input_close(struct input_dev *dev)
1894 {
1895         struct mxt_data *data = input_get_drvdata(dev);
1896
1897         mxt_stop(data);
1898 }
1899
1900 #ifdef CONFIG_OF
1901 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
1902 {
1903         struct mxt_platform_data *pdata;
1904         u32 *keymap;
1905         u32 keycode;
1906         int proplen, i, ret;
1907
1908         if (!client->dev.of_node)
1909                 return ERR_PTR(-ENODEV);
1910
1911         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1912         if (!pdata)
1913                 return ERR_PTR(-ENOMEM);
1914
1915         if (of_find_property(client->dev.of_node, "linux,gpio-keymap",
1916                              &proplen)) {
1917                 pdata->t19_num_keys = proplen / sizeof(u32);
1918
1919                 keymap = devm_kzalloc(&client->dev,
1920                                 pdata->t19_num_keys * sizeof(keymap[0]),
1921                                 GFP_KERNEL);
1922                 if (!keymap)
1923                         return ERR_PTR(-ENOMEM);
1924
1925                 for (i = 0; i < pdata->t19_num_keys; i++) {
1926                         ret = of_property_read_u32_index(client->dev.of_node,
1927                                         "linux,gpio-keymap", i, &keycode);
1928                         if (ret)
1929                                 keycode = KEY_RESERVED;
1930
1931                         keymap[i] = keycode;
1932                 }
1933
1934                 pdata->t19_keymap = keymap;
1935         }
1936
1937         return pdata;
1938 }
1939 #else
1940 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
1941 {
1942         dev_dbg(&client->dev, "No platform data specified\n");
1943         return ERR_PTR(-EINVAL);
1944 }
1945 #endif
1946
1947 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
1948 {
1949         struct mxt_data *data;
1950         const struct mxt_platform_data *pdata;
1951         int error;
1952
1953         pdata = dev_get_platdata(&client->dev);
1954         if (!pdata) {
1955                 pdata = mxt_parse_dt(client);
1956                 if (IS_ERR(pdata))
1957                         return PTR_ERR(pdata);
1958         }
1959
1960         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1961         if (!data) {
1962                 dev_err(&client->dev, "Failed to allocate memory\n");
1963                 return -ENOMEM;
1964         }
1965
1966         snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1967                  client->adapter->nr, client->addr);
1968
1969         data->client = client;
1970         data->pdata = pdata;
1971         data->irq = client->irq;
1972         i2c_set_clientdata(client, data);
1973
1974         init_completion(&data->bl_completion);
1975         init_completion(&data->reset_completion);
1976         init_completion(&data->crc_completion);
1977
1978         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1979                                      pdata->irqflags | IRQF_ONESHOT,
1980                                      client->name, data);
1981         if (error) {
1982                 dev_err(&client->dev, "Failed to register interrupt\n");
1983                 goto err_free_mem;
1984         }
1985
1986         disable_irq(client->irq);
1987
1988         error = mxt_initialize(data);
1989         if (error)
1990                 goto err_free_irq;
1991
1992         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1993         if (error) {
1994                 dev_err(&client->dev, "Failure %d creating sysfs group\n",
1995                         error);
1996                 goto err_free_object;
1997         }
1998
1999         return 0;
2000
2001 err_free_object:
2002         mxt_free_object_table(data);
2003 err_free_irq:
2004         free_irq(client->irq, data);
2005 err_free_mem:
2006         kfree(data);
2007         return error;
2008 }
2009
2010 static int mxt_remove(struct i2c_client *client)
2011 {
2012         struct mxt_data *data = i2c_get_clientdata(client);
2013
2014         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
2015         free_irq(data->irq, data);
2016         input_unregister_device(data->input_dev);
2017         mxt_free_object_table(data);
2018         kfree(data);
2019
2020         return 0;
2021 }
2022
2023 #ifdef CONFIG_PM_SLEEP
2024 static int mxt_suspend(struct device *dev)
2025 {
2026         struct i2c_client *client = to_i2c_client(dev);
2027         struct mxt_data *data = i2c_get_clientdata(client);
2028         struct input_dev *input_dev = data->input_dev;
2029
2030         mutex_lock(&input_dev->mutex);
2031
2032         if (input_dev->users)
2033                 mxt_stop(data);
2034
2035         mutex_unlock(&input_dev->mutex);
2036
2037         return 0;
2038 }
2039
2040 static int mxt_resume(struct device *dev)
2041 {
2042         struct i2c_client *client = to_i2c_client(dev);
2043         struct mxt_data *data = i2c_get_clientdata(client);
2044         struct input_dev *input_dev = data->input_dev;
2045
2046         mxt_soft_reset(data);
2047
2048         mutex_lock(&input_dev->mutex);
2049
2050         if (input_dev->users)
2051                 mxt_start(data);
2052
2053         mutex_unlock(&input_dev->mutex);
2054
2055         return 0;
2056 }
2057 #endif
2058
2059 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
2060
2061 static const struct of_device_id mxt_of_match[] = {
2062         { .compatible = "atmel,maxtouch", },
2063         {},
2064 };
2065 MODULE_DEVICE_TABLE(of, mxt_of_match);
2066
2067 static const struct i2c_device_id mxt_id[] = {
2068         { "qt602240_ts", 0 },
2069         { "atmel_mxt_ts", 0 },
2070         { "atmel_mxt_tp", 0 },
2071         { "mXT224", 0 },
2072         { }
2073 };
2074 MODULE_DEVICE_TABLE(i2c, mxt_id);
2075
2076 static struct i2c_driver mxt_driver = {
2077         .driver = {
2078                 .name   = "atmel_mxt_ts",
2079                 .owner  = THIS_MODULE,
2080                 .of_match_table = of_match_ptr(mxt_of_match),
2081                 .pm     = &mxt_pm_ops,
2082         },
2083         .probe          = mxt_probe,
2084         .remove         = mxt_remove,
2085         .id_table       = mxt_id,
2086 };
2087
2088 module_i2c_driver(mxt_driver);
2089
2090 /* Module information */
2091 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
2092 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
2093 MODULE_LICENSE("GPL");