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