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/acpi.h>
  18 #include <linux/dmi.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/completion.h>
  22 #include <linux/delay.h>
  23 #include <linux/firmware.h>
  24 #include <linux/i2c.h>
  25 #include <linux/platform_data/atmel_mxt_ts.h>
  26 #include <linux/input/mt.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/of.h>
  29 #include <linux/slab.h>
  30 #include <asm/unaligned.h>
  31
  32 /* Firmware files */
  33 #define MXT_FW_NAME             "maxtouch.fw"
  34 #define MXT_CFG_NAME            "maxtouch.cfg"
  35 #define MXT_CFG_MAGIC           "OBP_RAW V1"
  36
  37 /* Registers */
  38 #define MXT_OBJECT_START        0x07
  39 #define MXT_OBJECT_SIZE         6
  40 #define MXT_INFO_CHECKSUM_SIZE  3
  41 #define MXT_MAX_BLOCK_WRITE     256
  42
  43 /* Object types */
  44 #define MXT_DEBUG_DIAGNOSTIC_T37        37
  45 #define MXT_GEN_MESSAGE_T5              5
  46 #define MXT_GEN_COMMAND_T6              6
  47 #define MXT_GEN_POWER_T7                7
  48 #define MXT_GEN_ACQUIRE_T8              8
  49 #define MXT_GEN_DATASOURCE_T53          53
  50 #define MXT_TOUCH_MULTI_T9              9
  51 #define MXT_TOUCH_KEYARRAY_T15          15
  52 #define MXT_TOUCH_PROXIMITY_T23         23
  53 #define MXT_TOUCH_PROXKEY_T52           52
  54 #define MXT_PROCI_GRIPFACE_T20          20
  55 #define MXT_PROCG_NOISE_T22             22
  56 #define MXT_PROCI_ONETOUCH_T24          24
  57 #define MXT_PROCI_TWOTOUCH_T27          27
  58 #define MXT_PROCI_GRIP_T40              40
  59 #define MXT_PROCI_PALM_T41              41
  60 #define MXT_PROCI_TOUCHSUPPRESSION_T42  42
  61 #define MXT_PROCI_STYLUS_T47            47
  62 #define MXT_PROCG_NOISESUPPRESSION_T48  48
  63 #define MXT_SPT_COMMSCONFIG_T18         18
  64 #define MXT_SPT_GPIOPWM_T19             19
  65 #define MXT_SPT_SELFTEST_T25            25
  66 #define MXT_SPT_CTECONFIG_T28           28
  67 #define MXT_SPT_USERDATA_T38            38
  68 #define MXT_SPT_DIGITIZER_T43           43
  69 #define MXT_SPT_MESSAGECOUNT_T44        44
  70 #define MXT_SPT_CTECONFIG_T46           46
  71 #define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
  72
  73 /* MXT_GEN_MESSAGE_T5 object */
  74 #define MXT_RPTID_NOMSG         0xff
  75
  76 /* MXT_GEN_COMMAND_T6 field */
  77 #define MXT_COMMAND_RESET       0
  78 #define MXT_COMMAND_BACKUPNV    1
  79 #define MXT_COMMAND_CALIBRATE   2
  80 #define MXT_COMMAND_REPORTALL   3
  81 #define MXT_COMMAND_DIAGNOSTIC  5
  82
  83 /* Define for T6 status byte */
  84 #define MXT_T6_STATUS_RESET     (1 << 7)
  85 #define MXT_T6_STATUS_OFL       (1 << 6)
  86 #define MXT_T6_STATUS_SIGERR    (1 << 5)
  87 #define MXT_T6_STATUS_CAL       (1 << 4)
  88 #define MXT_T6_STATUS_CFGERR    (1 << 3)
  89 #define MXT_T6_STATUS_COMSERR   (1 << 2)
  90
  91 /* MXT_GEN_POWER_T7 field */
  92 struct t7_config {
  93         u8 idle;
  94         u8 active;
  95 } __packed;
  96
  97 #define MXT_POWER_CFG_RUN               0
  98 #define MXT_POWER_CFG_DEEPSLEEP         1
  99
 100 /* MXT_TOUCH_MULTI_T9 field */
 101 #define MXT_T9_CTRL             0
 102 #define MXT_T9_ORIENT           9
 103 #define MXT_T9_RANGE            18
 104
 105 /* MXT_TOUCH_MULTI_T9 status */
 106 #define MXT_T9_UNGRIP           (1 << 0)
 107 #define MXT_T9_SUPPRESS         (1 << 1)
 108 #define MXT_T9_AMP              (1 << 2)
 109 #define MXT_T9_VECTOR           (1 << 3)
 110 #define MXT_T9_MOVE             (1 << 4)
 111 #define MXT_T9_RELEASE          (1 << 5)
 112 #define MXT_T9_PRESS            (1 << 6)
 113 #define MXT_T9_DETECT           (1 << 7)
 114
 115 struct t9_range {
 116         u16 x;
 117         u16 y;
 118 } __packed;
 119
 120 /* MXT_TOUCH_MULTI_T9 orient */
 121 #define MXT_T9_ORIENT_SWITCH    (1 << 0)
 122
 123 /* MXT_SPT_COMMSCONFIG_T18 */
 124 #define MXT_COMMS_CTRL          0
 125 #define MXT_COMMS_CMD           1
 126
 127 /* Define for MXT_GEN_COMMAND_T6 */
 128 #define MXT_BOOT_VALUE          0xa5
 129 #define MXT_RESET_VALUE         0x01
 130 #define MXT_BACKUP_VALUE        0x55
 131
 132 /* T100 Multiple Touch Touchscreen */
 133 #define MXT_T100_CTRL           0
 134 #define MXT_T100_CFG1           1
 135 #define MXT_T100_TCHAUX         3
 136 #define MXT_T100_XRANGE         13
 137 #define MXT_T100_YRANGE         24
 138
 139 #define MXT_T100_CFG_SWITCHXY   BIT(5)
 140
 141 #define MXT_T100_TCHAUX_VECT    BIT(0)
 142 #define MXT_T100_TCHAUX_AMPL    BIT(1)
 143 #define MXT_T100_TCHAUX_AREA    BIT(2)
 144
 145 #define MXT_T100_DETECT         BIT(7)
 146 #define MXT_T100_TYPE_MASK      0x70
 147
 148 enum t100_type {
 149         MXT_T100_TYPE_FINGER            = 1,
 150         MXT_T100_TYPE_PASSIVE_STYLUS    = 2,
 151         MXT_T100_TYPE_HOVERING_FINGER   = 4,
 152         MXT_T100_TYPE_GLOVE             = 5,
 153         MXT_T100_TYPE_LARGE_TOUCH       = 6,
 154 };
 155
 156 #define MXT_DISTANCE_ACTIVE_TOUCH       0
 157 #define MXT_DISTANCE_HOVERING           1
 158
 159 #define MXT_TOUCH_MAJOR_DEFAULT         1
 160 #define MXT_PRESSURE_DEFAULT            1
 161
 162 /* Delay times */
 163 #define MXT_BACKUP_TIME         50      /* msec */
 164 #define MXT_RESET_TIME          200     /* msec */
 165 #define MXT_RESET_TIMEOUT       3000    /* msec */
 166 #define MXT_CRC_TIMEOUT         1000    /* msec */
 167 #define MXT_FW_RESET_TIME       3000    /* msec */
 168 #define MXT_FW_CHG_TIMEOUT      300     /* msec */
 169
 170 /* Command to unlock bootloader */
 171 #define MXT_UNLOCK_CMD_MSB      0xaa
 172 #define MXT_UNLOCK_CMD_LSB      0xdc
 173
 174 /* Bootloader mode status */
 175 #define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
 176 #define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
 177 #define MXT_FRAME_CRC_CHECK     0x02
 178 #define MXT_FRAME_CRC_FAIL      0x03
 179 #define MXT_FRAME_CRC_PASS      0x04
 180 #define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
 181 #define MXT_BOOT_STATUS_MASK    0x3f
 182 #define MXT_BOOT_EXTENDED_ID    (1 << 5)
 183 #define MXT_BOOT_ID_MASK        0x1f
 184
 185 /* Touchscreen absolute values */
 186 #define MXT_MAX_AREA            0xff
 187
 188 #define MXT_PIXELS_PER_MM       20
 189
 190 struct mxt_info {
 191         u8 family_id;
 192         u8 variant_id;
 193         u8 version;
 194         u8 build;
 195         u8 matrix_xsize;
 196         u8 matrix_ysize;
 197         u8 object_num;
 198 };
 199
 200 struct mxt_object {
 201         u8 type;
 202         u16 start_address;
 203         u8 size_minus_one;
 204         u8 instances_minus_one;
 205         u8 num_report_ids;
 206 } __packed;
 207
 208 /* Each client has this additional data */
 209 struct mxt_data {
 210         struct i2c_client *client;
 211         struct input_dev *input_dev;
 212         char phys[64];          /* device physical location */
 213         const struct mxt_platform_data *pdata;
 214         struct mxt_object *object_table;
 215         struct mxt_info info;
 216         unsigned int irq;
 217         unsigned int max_x;
 218         unsigned int max_y;
 219         bool in_bootloader;
 220         u16 mem_size;
 221         u8 t100_aux_ampl;
 222         u8 t100_aux_area;
 223         u8 t100_aux_vect;
 224         u8 max_reportid;
 225         u32 config_crc;
 226         u32 info_crc;
 227         u8 bootloader_addr;
 228         u8 *msg_buf;
 229         u8 t6_status;
 230         bool update_input;
 231         u8 last_message_count;
 232         u8 num_touchids;
 233         u8 multitouch;
 234         struct t7_config t7_cfg;
 235
 236         /* Cached parameters from object table */
 237         u16 T5_address;
 238         u8 T5_msg_size;
 239         u8 T6_reportid;
 240         u16 T6_address;
 241         u16 T7_address;
 242         u8 T9_reportid_min;
 243         u8 T9_reportid_max;
 244         u8 T19_reportid;
 245         u16 T44_address;
 246         u8 T100_reportid_min;
 247         u8 T100_reportid_max;
 248
 249         /* for fw update in bootloader */
 250         struct completion bl_completion;
 251
 252         /* for reset handling */
 253         struct completion reset_completion;
 254
 255         /* for config update handling */
 256         struct completion crc_completion;
 257 };
 258
 259 static size_t mxt_obj_size(const struct mxt_object *obj)
 260 {
 261         return obj->size_minus_one + 1;
 262 }
 263
 264 static size_t mxt_obj_instances(const struct mxt_object *obj)
 265 {
 266         return obj->instances_minus_one + 1;
 267 }
 268
 269 static bool mxt_object_readable(unsigned int type)
 270 {
 271         switch (type) {
 272         case MXT_GEN_COMMAND_T6:
 273         case MXT_GEN_POWER_T7:
 274         case MXT_GEN_ACQUIRE_T8:
 275         case MXT_GEN_DATASOURCE_T53:
 276         case MXT_TOUCH_MULTI_T9:
 277         case MXT_TOUCH_KEYARRAY_T15:
 278         case MXT_TOUCH_PROXIMITY_T23:
 279         case MXT_TOUCH_PROXKEY_T52:
 280         case MXT_PROCI_GRIPFACE_T20:
 281         case MXT_PROCG_NOISE_T22:
 282         case MXT_PROCI_ONETOUCH_T24:
 283         case MXT_PROCI_TWOTOUCH_T27:
 284         case MXT_PROCI_GRIP_T40:
 285         case MXT_PROCI_PALM_T41:
 286         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 287         case MXT_PROCI_STYLUS_T47:
 288         case MXT_PROCG_NOISESUPPRESSION_T48:
 289         case MXT_SPT_COMMSCONFIG_T18:
 290         case MXT_SPT_GPIOPWM_T19:
 291         case MXT_SPT_SELFTEST_T25:
 292         case MXT_SPT_CTECONFIG_T28:
 293         case MXT_SPT_USERDATA_T38:
 294         case MXT_SPT_DIGITIZER_T43:
 295         case MXT_SPT_CTECONFIG_T46:
 296                 return true;
 297         default:
 298                 return false;
 299         }
 300 }
 301
 302 static void mxt_dump_message(struct mxt_data *data, u8 *message)
 303 {
 304         dev_dbg(&data->client->dev, "message: %*ph\n",
 305                 data->T5_msg_size, message);
 306 }
 307
 308 static int mxt_wait_for_completion(struct mxt_data *data,
 309                                    struct completion *comp,
 310                                    unsigned int timeout_ms)
 311 {
 312         struct device *dev = &data->client->dev;
 313         unsigned long timeout = msecs_to_jiffies(timeout_ms);
 314         long ret;
 315
 316         ret = wait_for_completion_interruptible_timeout(comp, timeout);
 317         if (ret < 0) {
 318                 return ret;
 319         } else if (ret == 0) {
 320                 dev_err(dev, "Wait for completion timed out.\n");
 321                 return -ETIMEDOUT;
 322         }
 323         return 0;
 324 }
 325
 326 static int mxt_bootloader_read(struct mxt_data *data,
 327                                u8 *val, unsigned int count)
 328 {
 329         int ret;
 330         struct i2c_msg msg;
 331
 332         msg.addr = data->bootloader_addr;
 333         msg.flags = data->client->flags & I2C_M_TEN;
 334         msg.flags |= I2C_M_RD;
 335         msg.len = count;
 336         msg.buf = val;
 337
 338         ret = i2c_transfer(data->client->adapter, &msg, 1);
 339         if (ret == 1) {
 340                 ret = 0;
 341         } else {
 342                 ret = ret < 0 ? ret : -EIO;
 343                 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
 344                         __func__, ret);
 345         }
 346
 347         return ret;
 348 }
 349
 350 static int mxt_bootloader_write(struct mxt_data *data,
 351                                 const u8 * const val, unsigned int count)
 352 {
 353         int ret;
 354         struct i2c_msg msg;
 355
 356         msg.addr = data->bootloader_addr;
 357         msg.flags = data->client->flags & I2C_M_TEN;
 358         msg.len = count;
 359         msg.buf = (u8 *)val;
 360
 361         ret = i2c_transfer(data->client->adapter, &msg, 1);
 362         if (ret == 1) {
 363                 ret = 0;
 364         } else {
 365                 ret = ret < 0 ? ret : -EIO;
 366                 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
 367                         __func__, ret);
 368         }
 369
 370         return ret;
 371 }
 372
 373 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
 374 {
 375         u8 appmode = data->client->addr;
 376         u8 bootloader;
 377
 378         switch (appmode) {
 379         case 0x4a:
 380         case 0x4b:
 381                 /* Chips after 1664S use different scheme */
 382                 if (retry || data->info.family_id >= 0xa2) {
 383                         bootloader = appmode - 0x24;
 384                         break;
 385                 }
 386                 /* Fall through for normal case */
 387         case 0x4c:
 388         case 0x4d:
 389         case 0x5a:
 390         case 0x5b:
 391                 bootloader = appmode - 0x26;
 392                 break;
 393
 394         default:
 395                 dev_err(&data->client->dev,
 396                         "Appmode i2c address 0x%02x not found\n",
 397                         appmode);
 398                 return -EINVAL;
 399         }
 400
 401         data->bootloader_addr = bootloader;
 402         return 0;
 403 }
 404
 405 static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
 406 {
 407         struct device *dev = &data->client->dev;
 408         int error;
 409         u8 val;
 410         bool crc_failure;
 411
 412         error = mxt_lookup_bootloader_address(data, alt_address);
 413         if (error)
 414                 return error;
 415
 416         error = mxt_bootloader_read(data, &val, 1);
 417         if (error)
 418                 return error;
 419
 420         /* Check app crc fail mode */
 421         crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
 422
 423         dev_err(dev, "Detected bootloader, status:%02X%s\n",
 424                         val, crc_failure ? ", APP_CRC_FAIL" : "");
 425
 426         return 0;
 427 }
 428
 429 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
 430 {
 431         struct device *dev = &data->client->dev;
 432         u8 buf[3];
 433
 434         if (val & MXT_BOOT_EXTENDED_ID) {
 435                 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
 436                         dev_err(dev, "%s: i2c failure\n", __func__);
 437                         return val;
 438                 }
 439
 440                 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
 441
 442                 return buf[0];
 443         } else {
 444                 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
 445
 446                 return val;
 447         }
 448 }
 449
 450 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
 451                                 bool wait)
 452 {
 453         struct device *dev = &data->client->dev;
 454         u8 val;
 455         int ret;
 456
 457 recheck:
 458         if (wait) {
 459                 /*
 460                  * In application update mode, the interrupt
 461                  * line signals state transitions. We must wait for the
 462                  * CHG assertion before reading the status byte.
 463                  * Once the status byte has been read, the line is deasserted.
 464                  */
 465                 ret = mxt_wait_for_completion(data, &data->bl_completion,
 466                                               MXT_FW_CHG_TIMEOUT);
 467                 if (ret) {
 468                         /*
 469                          * TODO: handle -ERESTARTSYS better by terminating
 470                          * fw update process before returning to userspace
 471                          * by writing length 0x000 to device (iff we are in
 472                          * WAITING_FRAME_DATA state).
 473                          */
 474                         dev_err(dev, "Update wait error %d\n", ret);
 475                         return ret;
 476                 }
 477         }
 478
 479         ret = mxt_bootloader_read(data, &val, 1);
 480         if (ret)
 481                 return ret;
 482
 483         if (state == MXT_WAITING_BOOTLOAD_CMD)
 484                 val = mxt_get_bootloader_version(data, val);
 485
 486         switch (state) {
 487         case MXT_WAITING_BOOTLOAD_CMD:
 488         case MXT_WAITING_FRAME_DATA:
 489         case MXT_APP_CRC_FAIL:
 490                 val &= ~MXT_BOOT_STATUS_MASK;
 491                 break;
 492         case MXT_FRAME_CRC_PASS:
 493                 if (val == MXT_FRAME_CRC_CHECK) {
 494                         goto recheck;
 495                 } else if (val == MXT_FRAME_CRC_FAIL) {
 496                         dev_err(dev, "Bootloader CRC fail\n");
 497                         return -EINVAL;
 498                 }
 499                 break;
 500         default:
 501                 return -EINVAL;
 502         }
 503
 504         if (val != state) {
 505                 dev_err(dev, "Invalid bootloader state %02X != %02X\n",
 506                         val, state);
 507                 return -EINVAL;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
 514 {
 515         int ret;
 516         u8 buf[2];
 517
 518         if (unlock) {
 519                 buf[0] = MXT_UNLOCK_CMD_LSB;
 520                 buf[1] = MXT_UNLOCK_CMD_MSB;
 521         } else {
 522                 buf[0] = 0x01;
 523                 buf[1] = 0x01;
 524         }
 525
 526         ret = mxt_bootloader_write(data, buf, 2);
 527         if (ret)
 528                 return ret;
 529
 530         return 0;
 531 }
 532
 533 static int __mxt_read_reg(struct i2c_client *client,
 534                                u16 reg, u16 len, void *val)
 535 {
 536         struct i2c_msg xfer[2];
 537         u8 buf[2];
 538         int ret;
 539
 540         buf[0] = reg & 0xff;
 541         buf[1] = (reg >> 8) & 0xff;
 542
 543         /* Write register */
 544         xfer[0].addr = client->addr;
 545         xfer[0].flags = 0;
 546         xfer[0].len = 2;
 547         xfer[0].buf = buf;
 548
 549         /* Read data */
 550         xfer[1].addr = client->addr;
 551         xfer[1].flags = I2C_M_RD;
 552         xfer[1].len = len;
 553         xfer[1].buf = val;
 554
 555         ret = i2c_transfer(client->adapter, xfer, 2);
 556         if (ret == 2) {
 557                 ret = 0;
 558         } else {
 559                 if (ret >= 0)
 560                         ret = -EIO;
 561                 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
 562                         __func__, ret);
 563         }
 564
 565         return ret;
 566 }
 567
 568 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 569                            const void *val)
 570 {
 571         u8 *buf;
 572         size_t count;
 573         int ret;
 574
 575         count = len + 2;
 576         buf = kmalloc(count, GFP_KERNEL);
 577         if (!buf)
 578                 return -ENOMEM;
 579
 580         buf[0] = reg & 0xff;
 581         buf[1] = (reg >> 8) & 0xff;
 582         memcpy(&buf[2], val, len);
 583
 584         ret = i2c_master_send(client, buf, count);
 585         if (ret == count) {
 586                 ret = 0;
 587         } else {
 588                 if (ret >= 0)
 589                         ret = -EIO;
 590                 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
 591                         __func__, ret);
 592         }
 593
 594         kfree(buf);
 595         return ret;
 596 }
 597
 598 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 599 {
 600         return __mxt_write_reg(client, reg, 1, &val);
 601 }
 602
 603 static struct mxt_object *
 604 mxt_get_object(struct mxt_data *data, u8 type)
 605 {
 606         struct mxt_object *object;
 607         int i;
 608
 609         for (i = 0; i < data->info.object_num; i++) {
 610                 object = data->object_table + i;
 611                 if (object->type == type)
 612                         return object;
 613         }
 614
 615         dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
 616         return NULL;
 617 }
 618
 619 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
 620 {
 621         struct device *dev = &data->client->dev;
 622         u8 status = msg[1];
 623         u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
 624
 625         complete(&data->crc_completion);
 626
 627         if (crc != data->config_crc) {
 628                 data->config_crc = crc;
 629                 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
 630         }
 631
 632         /* Detect reset */
 633         if (status & MXT_T6_STATUS_RESET)
 634                 complete(&data->reset_completion);
 635
 636         /* Output debug if status has changed */
 637         if (status != data->t6_status)
 638                 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
 639                         status,
 640                         status == 0 ? " OK" : "",
 641                         status & MXT_T6_STATUS_RESET ? " RESET" : "",
 642                         status & MXT_T6_STATUS_OFL ? " OFL" : "",
 643                         status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
 644                         status & MXT_T6_STATUS_CAL ? " CAL" : "",
 645                         status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
 646                         status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
 647
 648         /* Save current status */
 649         data->t6_status = status;
 650 }
 651
 652 static int mxt_write_object(struct mxt_data *data,
 653                                  u8 type, u8 offset, u8 val)
 654 {
 655         struct mxt_object *object;
 656         u16 reg;
 657
 658         object = mxt_get_object(data, type);
 659         if (!object || offset >= mxt_obj_size(object))
 660                 return -EINVAL;
 661
 662         reg = object->start_address;
 663         return mxt_write_reg(data->client, reg + offset, val);
 664 }
 665
 666 static void mxt_input_button(struct mxt_data *data, u8 *message)
 667 {
 668         struct input_dev *input = data->input_dev;
 669         const struct mxt_platform_data *pdata = data->pdata;
 670         int i;
 671
 672         for (i = 0; i < pdata->t19_num_keys; i++) {
 673                 if (pdata->t19_keymap[i] == KEY_RESERVED)
 674                         continue;
 675
 676                 /* Active-low switch */
 677                 input_report_key(input, pdata->t19_keymap[i],
 678                                  !(message[1] & BIT(i)));
 679         }
 680 }
 681
 682 static void mxt_input_sync(struct mxt_data *data)
 683 {
 684         input_mt_report_pointer_emulation(data->input_dev,
 685                                           data->pdata->t19_num_keys);
 686         input_sync(data->input_dev);
 687 }
 688
 689 static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
 690 {
 691         struct device *dev = &data->client->dev;
 692         struct input_dev *input_dev = data->input_dev;
 693         int id;
 694         u8 status;
 695         int x;
 696         int y;
 697         int area;
 698         int amplitude;
 699
 700         id = message[0] - data->T9_reportid_min;
 701         status = message[1];
 702         x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
 703         y = (message[3] << 4) | ((message[4] & 0xf));
 704
 705         /* Handle 10/12 bit switching */
 706         if (data->max_x < 1024)
 707                 x >>= 2;
 708         if (data->max_y < 1024)
 709                 y >>= 2;
 710
 711         area = message[5];
 712         amplitude = message[6];
 713
 714         dev_dbg(dev,
 715                 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
 716                 id,
 717                 (status & MXT_T9_DETECT) ? 'D' : '.',
 718                 (status & MXT_T9_PRESS) ? 'P' : '.',
 719                 (status & MXT_T9_RELEASE) ? 'R' : '.',
 720                 (status & MXT_T9_MOVE) ? 'M' : '.',
 721                 (status & MXT_T9_VECTOR) ? 'V' : '.',
 722                 (status & MXT_T9_AMP) ? 'A' : '.',
 723                 (status & MXT_T9_SUPPRESS) ? 'S' : '.',
 724                 (status & MXT_T9_UNGRIP) ? 'U' : '.',
 725                 x, y, area, amplitude);
 726
 727         input_mt_slot(input_dev, id);
 728
 729         if (status & MXT_T9_DETECT) {
 730                 /*
 731                  * Multiple bits may be set if the host is slow to read
 732                  * the status messages, indicating all the events that
 733                  * have happened.
 734                  */
 735                 if (status & MXT_T9_RELEASE) {
 736                         input_mt_report_slot_state(input_dev,
 737                                                    MT_TOOL_FINGER, 0);
 738                         mxt_input_sync(data);
 739                 }
 740
 741                 /* Touch active */
 742                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
 743                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 744                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 745                 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 746                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 747         } else {
 748                 /* Touch no longer active, close out slot */
 749                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
 750         }
 751
 752         data->update_input = true;
 753 }
 754
 755 static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
 756 {
 757         struct device *dev = &data->client->dev;
 758         struct input_dev *input_dev = data->input_dev;
 759         int id;
 760         u8 status;
 761         u8 type = 0;
 762         u16 x;
 763         u16 y;
 764         int distance = 0;
 765         int tool = 0;
 766         u8 major = 0;
 767         u8 pressure = 0;
 768         u8 orientation = 0;
 769
 770         id = message[0] - data->T100_reportid_min - 2;
 771
 772         /* ignore SCRSTATUS events */
 773         if (id < 0)
 774                 return;
 775
 776         status = message[1];
 777         x = get_unaligned_le16(&message[2]);
 778         y = get_unaligned_le16(&message[4]);
 779
 780         if (status & MXT_T100_DETECT) {
 781                 type = (status & MXT_T100_TYPE_MASK) >> 4;
 782
 783                 switch (type) {
 784                 case MXT_T100_TYPE_HOVERING_FINGER:
 785                         tool = MT_TOOL_FINGER;
 786                         distance = MXT_DISTANCE_HOVERING;
 787
 788                         if (data->t100_aux_vect)
 789                                 orientation = message[data->t100_aux_vect];
 790
 791                         break;
 792
 793                 case MXT_T100_TYPE_FINGER:
 794                 case MXT_T100_TYPE_GLOVE:
 795                         tool = MT_TOOL_FINGER;
 796                         distance = MXT_DISTANCE_ACTIVE_TOUCH;
 797
 798                         if (data->t100_aux_area)
 799                                 major = message[data->t100_aux_area];
 800
 801                         if (data->t100_aux_ampl)
 802                                 pressure = message[data->t100_aux_ampl];
 803
 804                         if (data->t100_aux_vect)
 805                                 orientation = message[data->t100_aux_vect];
 806
 807                         break;
 808
 809                 case MXT_T100_TYPE_PASSIVE_STYLUS:
 810                         tool = MT_TOOL_PEN;
 811
 812                         /*
 813                          * Passive stylus is reported with size zero so
 814                          * hardcode.
 815                          */
 816                         major = MXT_TOUCH_MAJOR_DEFAULT;
 817
 818                         if (data->t100_aux_ampl)
 819                                 pressure = message[data->t100_aux_ampl];
 820
 821                         break;
 822
 823                 case MXT_T100_TYPE_LARGE_TOUCH:
 824                         /* Ignore suppressed touch */
 825                         break;
 826
 827                 default:
 828                         dev_dbg(dev, "Unexpected T100 type\n");
 829                         return;
 830                 }
 831         }
 832
 833         /*
 834          * Values reported should be non-zero if tool is touching the
 835          * device
 836          */
 837         if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
 838                 pressure = MXT_PRESSURE_DEFAULT;
 839
 840         input_mt_slot(input_dev, id);
 841
 842         if (status & MXT_T100_DETECT) {
 843                 dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
 844                         id, type, x, y, major, pressure, orientation);
 845
 846                 input_mt_report_slot_state(input_dev, tool, 1);
 847                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 848                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 849                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
 850                 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
 851                 input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
 852                 input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
 853         } else {
 854                 dev_dbg(dev, "[%u] release\n", id);
 855
 856                 /* close out slot */
 857                 input_mt_report_slot_state(input_dev, 0, 0);
 858         }
 859
 860         data->update_input = true;
 861 }
 862
 863 static int mxt_proc_message(struct mxt_data *data, u8 *message)
 864 {
 865         u8 report_id = message[0];
 866
 867         if (report_id == MXT_RPTID_NOMSG)
 868                 return 0;
 869
 870         if (report_id == data->T6_reportid) {
 871                 mxt_proc_t6_messages(data, message);
 872         } else if (!data->input_dev) {
 873                 /*
 874                  * Do not report events if input device
 875                  * is not yet registered.
 876                  */
 877                 mxt_dump_message(data, message);
 878         } else if (report_id >= data->T9_reportid_min &&
 879                    report_id <= data->T9_reportid_max) {
 880                 mxt_proc_t9_message(data, message);
 881         } else if (report_id >= data->T100_reportid_min &&
 882                    report_id <= data->T100_reportid_max) {
 883                 mxt_proc_t100_message(data, message);
 884         } else if (report_id == data->T19_reportid) {
 885                 mxt_input_button(data, message);
 886                 data->update_input = true;
 887         } else {
 888                 mxt_dump_message(data, message);
 889         }
 890
 891         return 1;
 892 }
 893
 894 static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
 895 {
 896         struct device *dev = &data->client->dev;
 897         int ret;
 898         int i;
 899         u8 num_valid = 0;
 900
 901         /* Safety check for msg_buf */
 902         if (count > data->max_reportid)
 903                 return -EINVAL;
 904
 905         /* Process remaining messages if necessary */
 906         ret = __mxt_read_reg(data->client, data->T5_address,
 907                                 data->T5_msg_size * count, data->msg_buf);
 908         if (ret) {
 909                 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
 910                 return ret;
 911         }
 912
 913         for (i = 0;  i < count; i++) {
 914                 ret = mxt_proc_message(data,
 915                         data->msg_buf + data->T5_msg_size * i);
 916
 917                 if (ret == 1)
 918                         num_valid++;
 919         }
 920
 921         /* return number of messages read */
 922         return num_valid;
 923 }
 924
 925 static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
 926 {
 927         struct device *dev = &data->client->dev;
 928         int ret;
 929         u8 count, num_left;
 930
 931         /* Read T44 and T5 together */
 932         ret = __mxt_read_reg(data->client, data->T44_address,
 933                 data->T5_msg_size + 1, data->msg_buf);
 934         if (ret) {
 935                 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
 936                 return IRQ_NONE;
 937         }
 938
 939         count = data->msg_buf[0];
 940
 941         if (count == 0) {
 942                 /*
 943                  * This condition is caused by the CHG line being configured
 944                  * in Mode 0. It results in unnecessary I2C operations but it
 945                  * is benign.
 946                  */
 947                 dev_dbg(dev, "Interrupt triggered but zero messages\n");
 948                 return IRQ_NONE;
 949         } else if (count > data->max_reportid) {
 950                 dev_err(dev, "T44 count %d exceeded max report id\n", count);
 951                 count = data->max_reportid;
 952         }
 953
 954         /* Process first message */
 955         ret = mxt_proc_message(data, data->msg_buf + 1);
 956         if (ret < 0) {
 957                 dev_warn(dev, "Unexpected invalid message\n");
 958                 return IRQ_NONE;
 959         }
 960
 961         num_left = count - 1;
 962
 963         /* Process remaining messages if necessary */
 964         if (num_left) {
 965                 ret = mxt_read_and_process_messages(data, num_left);
 966                 if (ret < 0)
 967                         goto end;
 968                 else if (ret != num_left)
 969                         dev_warn(dev, "Unexpected invalid message\n");
 970         }
 971
 972 end:
 973         if (data->update_input) {
 974                 mxt_input_sync(data);
 975                 data->update_input = false;
 976         }
 977
 978         return IRQ_HANDLED;
 979 }
 980
 981 static int mxt_process_messages_until_invalid(struct mxt_data *data)
 982 {
 983         struct device *dev = &data->client->dev;
 984         int count, read;
 985         u8 tries = 2;
 986
 987         count = data->max_reportid;
 988
 989         /* Read messages until we force an invalid */
 990         do {
 991                 read = mxt_read_and_process_messages(data, count);
 992                 if (read < count)
 993                         return 0;
 994         } while (--tries);
 995
 996         if (data->update_input) {
 997                 mxt_input_sync(data);
 998                 data->update_input = false;
 999         }
1000
1001         dev_err(dev, "CHG pin isn't cleared\n");
1002         return -EBUSY;
1003 }
1004
1005 static irqreturn_t mxt_process_messages(struct mxt_data *data)
1006 {
1007         int total_handled, num_handled;
1008         u8 count = data->last_message_count;
1009
1010         if (count < 1 || count > data->max_reportid)
1011                 count = 1;
1012
1013         /* include final invalid message */
1014         total_handled = mxt_read_and_process_messages(data, count + 1);
1015         if (total_handled < 0)
1016                 return IRQ_NONE;
1017         /* if there were invalid messages, then we are done */
1018         else if (total_handled <= count)
1019                 goto update_count;
1020
1021         /* keep reading two msgs until one is invalid or reportid limit */
1022         do {
1023                 num_handled = mxt_read_and_process_messages(data, 2);
1024                 if (num_handled < 0)
1025                         return IRQ_NONE;
1026
1027                 total_handled += num_handled;
1028
1029                 if (num_handled < 2)
1030                         break;
1031         } while (total_handled < data->num_touchids);
1032
1033 update_count:
1034         data->last_message_count = total_handled;
1035
1036         if (data->update_input) {
1037                 mxt_input_sync(data);
1038                 data->update_input = false;
1039         }
1040
1041         return IRQ_HANDLED;
1042 }
1043
1044 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1045 {
1046         struct mxt_data *data = dev_id;
1047
1048         if (data->in_bootloader) {
1049                 /* bootloader state transition completion */
1050                 complete(&data->bl_completion);
1051                 return IRQ_HANDLED;
1052         }
1053
1054         if (!data->object_table)
1055                 return IRQ_HANDLED;
1056
1057         if (data->T44_address) {
1058                 return mxt_process_messages_t44(data);
1059         } else {
1060                 return mxt_process_messages(data);
1061         }
1062 }
1063
1064 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1065                           u8 value, bool wait)
1066 {
1067         u16 reg;
1068         u8 command_register;
1069         int timeout_counter = 0;
1070         int ret;
1071
1072         reg = data->T6_address + cmd_offset;
1073
1074         ret = mxt_write_reg(data->client, reg, value);
1075         if (ret)
1076                 return ret;
1077
1078         if (!wait)
1079                 return 0;
1080
1081         do {
1082                 msleep(20);
1083                 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1084                 if (ret)
1085                         return ret;
1086         } while (command_register != 0 && timeout_counter++ <= 100);
1087
1088         if (timeout_counter > 100) {
1089                 dev_err(&data->client->dev, "Command failed!\n");
1090                 return -EIO;
1091         }
1092
1093         return 0;
1094 }
1095
1096 static int mxt_soft_reset(struct mxt_data *data)
1097 {
1098         struct device *dev = &data->client->dev;
1099         int ret = 0;
1100
1101         dev_info(dev, "Resetting chip\n");
1102
1103         reinit_completion(&data->reset_completion);
1104
1105         ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1106         if (ret)
1107                 return ret;
1108
1109         ret = mxt_wait_for_completion(data, &data->reset_completion,
1110                                       MXT_RESET_TIMEOUT);
1111         if (ret)
1112                 return ret;
1113
1114         return 0;
1115 }
1116
1117 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1118 {
1119         /*
1120          * On failure, CRC is set to 0 and config will always be
1121          * downloaded.
1122          */
1123         data->config_crc = 0;
1124         reinit_completion(&data->crc_completion);
1125
1126         mxt_t6_command(data, cmd, value, true);
1127
1128         /*
1129          * Wait for crc message. On failure, CRC is set to 0 and config will
1130          * always be downloaded.
1131          */
1132         mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1133 }
1134
1135 static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1136 {
1137         static const unsigned int crcpoly = 0x80001B;
1138         u32 result;
1139         u32 data_word;
1140
1141         data_word = (secondbyte << 8) | firstbyte;
1142         result = ((*crc << 1) ^ data_word);
1143
1144         if (result & 0x1000000)
1145                 result ^= crcpoly;
1146
1147         *crc = result;
1148 }
1149
1150 static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1151 {
1152         u32 crc = 0;
1153         u8 *ptr = base + start_off;
1154         u8 *last_val = base + end_off - 1;
1155
1156         if (end_off < start_off)
1157                 return -EINVAL;
1158
1159         while (ptr < last_val) {
1160                 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1161                 ptr += 2;
1162         }
1163
1164         /* if len is odd, fill the last byte with 0 */
1165         if (ptr == last_val)
1166                 mxt_calc_crc24(&crc, *ptr, 0);
1167
1168         /* Mask to 24-bit */
1169         crc &= 0x00FFFFFF;
1170
1171         return crc;
1172 }
1173
1174 static int mxt_prepare_cfg_mem(struct mxt_data *data,
1175                                const struct firmware *cfg,
1176                                unsigned int data_pos,
1177                                unsigned int cfg_start_ofs,
1178                                u8 *config_mem,
1179                                size_t config_mem_size)
1180 {
1181         struct device *dev = &data->client->dev;
1182         struct mxt_object *object;
1183         unsigned int type, instance, size, byte_offset;
1184         int offset;
1185         int ret;
1186         int i;
1187         u16 reg;
1188         u8 val;
1189
1190         while (data_pos < cfg->size) {
1191                 /* Read type, instance, length */
1192                 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1193                              &type, &instance, &size, &offset);
1194                 if (ret == 0) {
1195                         /* EOF */
1196                         break;
1197                 } else if (ret != 3) {
1198                         dev_err(dev, "Bad format: failed to parse object\n");
1199                         return -EINVAL;
1200                 }
1201                 data_pos += offset;
1202
1203                 object = mxt_get_object(data, type);
1204                 if (!object) {
1205                         /* Skip object */
1206                         for (i = 0; i < size; i++) {
1207                                 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1208                                              &val, &offset);
1209                                 if (ret != 1) {
1210                                         dev_err(dev, "Bad format in T%d at %d\n",
1211                                                 type, i);
1212                                         return -EINVAL;
1213                                 }
1214                                 data_pos += offset;
1215                         }
1216                         continue;
1217                 }
1218
1219                 if (size > mxt_obj_size(object)) {
1220                         /*
1221                          * Either we are in fallback mode due to wrong
1222                          * config or config from a later fw version,
1223                          * or the file is corrupt or hand-edited.
1224                          */
1225                         dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1226                                  size - mxt_obj_size(object), type);
1227                 } else if (mxt_obj_size(object) > size) {
1228                         /*
1229                          * If firmware is upgraded, new bytes may be added to
1230                          * end of objects. It is generally forward compatible
1231                          * to zero these bytes - previous behaviour will be
1232                          * retained. However this does invalidate the CRC and
1233                          * will force fallback mode until the configuration is
1234                          * updated. We warn here but do nothing else - the
1235                          * malloc has zeroed the entire configuration.
1236                          */
1237                         dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1238                                  mxt_obj_size(object) - size, type);
1239                 }
1240
1241                 if (instance >= mxt_obj_instances(object)) {
1242                         dev_err(dev, "Object instances exceeded!\n");
1243                         return -EINVAL;
1244                 }
1245
1246                 reg = object->start_address + mxt_obj_size(object) * instance;
1247
1248                 for (i = 0; i < size; i++) {
1249                         ret = sscanf(cfg->data + data_pos, "%hhx%n",
1250                                      &val,
1251                                      &offset);
1252                         if (ret != 1) {
1253                                 dev_err(dev, "Bad format in T%d at %d\n",
1254                                         type, i);
1255                                 return -EINVAL;
1256                         }
1257                         data_pos += offset;
1258
1259                         if (i > mxt_obj_size(object))
1260                                 continue;
1261
1262                         byte_offset = reg + i - cfg_start_ofs;
1263
1264                         if (byte_offset >= 0 && byte_offset < config_mem_size) {
1265                                 *(config_mem + byte_offset) = val;
1266                         } else {
1267                                 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1268                                         reg, object->type, byte_offset);
1269                                 return -EINVAL;
1270                         }
1271                 }
1272         }
1273
1274         return 0;
1275 }
1276
1277 static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start,
1278                               u8 *config_mem, size_t config_mem_size)
1279 {
1280         unsigned int byte_offset = 0;
1281         int error;
1282
1283         /* Write configuration as blocks */
1284         while (byte_offset < config_mem_size) {
1285                 unsigned int size = config_mem_size - byte_offset;
1286
1287                 if (size > MXT_MAX_BLOCK_WRITE)
1288                         size = MXT_MAX_BLOCK_WRITE;
1289
1290                 error = __mxt_write_reg(data->client,
1291                                         cfg_start + byte_offset,
1292                                         size, config_mem + byte_offset);
1293                 if (error) {
1294                         dev_err(&data->client->dev,
1295                                 "Config write error, ret=%d\n", error);
1296                         return error;
1297                 }
1298
1299                 byte_offset += size;
1300         }
1301
1302         return 0;
1303 }
1304
1305 static int mxt_init_t7_power_cfg(struct mxt_data *data);
1306
1307 /*
1308  * mxt_update_cfg - download configuration to chip
1309  *
1310  * Atmel Raw Config File Format
1311  *
1312  * The first four lines of the raw config file contain:
1313  *  1) Version
1314  *  2) Chip ID Information (first 7 bytes of device memory)
1315  *  3) Chip Information Block 24-bit CRC Checksum
1316  *  4) Chip Configuration 24-bit CRC Checksum
1317  *
1318  * The rest of the file consists of one line per object instance:
1319  *   <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1320  *
1321  *   <TYPE> - 2-byte object type as hex
1322  *   <INSTANCE> - 2-byte object instance number as hex
1323  *   <SIZE> - 2-byte object size as hex
1324  *   <CONTENTS> - array of <SIZE> 1-byte hex values
1325  */
1326 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
1327 {
1328         struct device *dev = &data->client->dev;
1329         struct mxt_info cfg_info;
1330         int ret;
1331         int offset;
1332         int data_pos;
1333         int i;
1334         int cfg_start_ofs;
1335         u32 info_crc, config_crc, calculated_crc;
1336         u8 *config_mem;
1337         size_t config_mem_size;
1338
1339         mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1340
1341         if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1342                 dev_err(dev, "Unrecognised config file\n");
1343                 return -EINVAL;
1344         }
1345
1346         data_pos = strlen(MXT_CFG_MAGIC);
1347
1348         /* Load information block and check */
1349         for (i = 0; i < sizeof(struct mxt_info); i++) {
1350                 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1351                              (unsigned char *)&cfg_info + i,
1352                              &offset);
1353                 if (ret != 1) {
1354                         dev_err(dev, "Bad format\n");
1355                         return -EINVAL;
1356                 }
1357
1358                 data_pos += offset;
1359         }
1360
1361         if (cfg_info.family_id != data->info.family_id) {
1362                 dev_err(dev, "Family ID mismatch!\n");
1363                 return -EINVAL;
1364         }
1365
1366         if (cfg_info.variant_id != data->info.variant_id) {
1367                 dev_err(dev, "Variant ID mismatch!\n");
1368                 return -EINVAL;
1369         }
1370
1371         /* Read CRCs */
1372         ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1373         if (ret != 1) {
1374                 dev_err(dev, "Bad format: failed to parse Info CRC\n");
1375                 return -EINVAL;
1376         }
1377         data_pos += offset;
1378
1379         ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1380         if (ret != 1) {
1381                 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1382                 return -EINVAL;
1383         }
1384         data_pos += offset;
1385
1386         /*
1387          * The Info Block CRC is calculated over mxt_info and the object
1388          * table. If it does not match then we are trying to load the
1389          * configuration from a different chip or firmware version, so
1390          * the configuration CRC is invalid anyway.
1391          */
1392         if (info_crc == data->info_crc) {
1393                 if (config_crc == 0 || data->config_crc == 0) {
1394                         dev_info(dev, "CRC zero, attempting to apply config\n");
1395                 } else if (config_crc == data->config_crc) {
1396                         dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1397                                  data->config_crc);
1398                         return 0;
1399                 } else {
1400                         dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1401                                  data->config_crc, config_crc);
1402                 }
1403         } else {
1404                 dev_warn(dev,
1405                          "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1406                          data->info_crc, info_crc);
1407         }
1408
1409         /* Malloc memory to store configuration */
1410         cfg_start_ofs = MXT_OBJECT_START +
1411                         data->info.object_num * sizeof(struct mxt_object) +
1412                         MXT_INFO_CHECKSUM_SIZE;
1413         config_mem_size = data->mem_size - cfg_start_ofs;
1414         config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1415         if (!config_mem) {
1416                 dev_err(dev, "Failed to allocate memory\n");
1417                 return -ENOMEM;
1418         }
1419
1420         ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs,
1421                                   config_mem, config_mem_size);
1422         if (ret)
1423                 goto release_mem;
1424
1425         /* Calculate crc of the received configs (not the raw config file) */
1426         if (data->T7_address < cfg_start_ofs) {
1427                 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1428                         data->T7_address, cfg_start_ofs);
1429                 ret = 0;
1430                 goto release_mem;
1431         }
1432
1433         calculated_crc = mxt_calculate_crc(config_mem,
1434                                            data->T7_address - cfg_start_ofs,
1435                                            config_mem_size);
1436
1437         if (config_crc > 0 && config_crc != calculated_crc)
1438                 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1439                          calculated_crc, config_crc);
1440
1441         ret = mxt_upload_cfg_mem(data, cfg_start_ofs,
1442                                  config_mem, config_mem_size);
1443         if (ret)
1444                 goto release_mem;
1445
1446         mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1447
1448         ret = mxt_soft_reset(data);
1449         if (ret)
1450                 goto release_mem;
1451
1452         dev_info(dev, "Config successfully updated\n");
1453
1454         /* T7 config may have changed */
1455         mxt_init_t7_power_cfg(data);
1456
1457 release_mem:
1458         kfree(config_mem);
1459         return ret;
1460 }
1461
1462 static int mxt_acquire_irq(struct mxt_data *data)
1463 {
1464         int error;
1465
1466         enable_irq(data->irq);
1467
1468         error = mxt_process_messages_until_invalid(data);
1469         if (error)
1470                 return error;
1471
1472         return 0;
1473 }
1474
1475 static int mxt_get_info(struct mxt_data *data)
1476 {
1477         struct i2c_client *client = data->client;
1478         struct mxt_info *info = &data->info;
1479         int error;
1480
1481         /* Read 7-byte info block starting at address 0 */
1482         error = __mxt_read_reg(client, 0, sizeof(*info), info);
1483         if (error)
1484                 return error;
1485
1486         return 0;
1487 }
1488
1489 static void mxt_free_input_device(struct mxt_data *data)
1490 {
1491         if (data->input_dev) {
1492                 input_unregister_device(data->input_dev);
1493                 data->input_dev = NULL;
1494         }
1495 }
1496
1497 static void mxt_free_object_table(struct mxt_data *data)
1498 {
1499         kfree(data->object_table);
1500         data->object_table = NULL;
1501         kfree(data->msg_buf);
1502         data->msg_buf = NULL;
1503         data->T5_address = 0;
1504         data->T5_msg_size = 0;
1505         data->T6_reportid = 0;
1506         data->T7_address = 0;
1507         data->T9_reportid_min = 0;
1508         data->T9_reportid_max = 0;
1509         data->T19_reportid = 0;
1510         data->T44_address = 0;
1511         data->T100_reportid_min = 0;
1512         data->T100_reportid_max = 0;
1513         data->max_reportid = 0;
1514 }
1515
1516 static int mxt_get_object_table(struct mxt_data *data)
1517 {
1518         struct i2c_client *client = data->client;
1519         size_t table_size;
1520         struct mxt_object *object_table;
1521         int error;
1522         int i;
1523         u8 reportid;
1524         u16 end_address;
1525
1526         table_size = data->info.object_num * sizeof(struct mxt_object);
1527         object_table = kzalloc(table_size, GFP_KERNEL);
1528         if (!object_table) {
1529                 dev_err(&data->client->dev, "Failed to allocate memory\n");
1530                 return -ENOMEM;
1531         }
1532
1533         error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
1534                         object_table);
1535         if (error) {
1536                 kfree(object_table);
1537                 return error;
1538         }
1539
1540         /* Valid Report IDs start counting from 1 */
1541         reportid = 1;
1542         data->mem_size = 0;
1543         for (i = 0; i < data->info.object_num; i++) {
1544                 struct mxt_object *object = object_table + i;
1545                 u8 min_id, max_id;
1546
1547                 le16_to_cpus(&object->start_address);
1548
1549                 if (object->num_report_ids) {
1550                         min_id = reportid;
1551                         reportid += object->num_report_ids *
1552                                         mxt_obj_instances(object);
1553                         max_id = reportid - 1;
1554                 } else {
1555                         min_id = 0;
1556                         max_id = 0;
1557                 }
1558
1559                 dev_dbg(&data->client->dev,
1560                         "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1561                         object->type, object->start_address,
1562                         mxt_obj_size(object), mxt_obj_instances(object),
1563                         min_id, max_id);
1564
1565                 switch (object->type) {
1566                 case MXT_GEN_MESSAGE_T5:
1567                         if (data->info.family_id == 0x80 &&
1568                             data->info.version < 0x20) {
1569                                 /*
1570                                  * On mXT224 firmware versions prior to V2.0
1571                                  * read and discard unused CRC byte otherwise
1572                                  * DMA reads are misaligned.
1573                                  */
1574                                 data->T5_msg_size = mxt_obj_size(object);
1575                         } else {
1576                                 /* CRC not enabled, so skip last byte */
1577                                 data->T5_msg_size = mxt_obj_size(object) - 1;
1578                         }
1579                         data->T5_address = object->start_address;
1580                         break;
1581                 case MXT_GEN_COMMAND_T6:
1582                         data->T6_reportid = min_id;
1583                         data->T6_address = object->start_address;
1584                         break;
1585                 case MXT_GEN_POWER_T7:
1586                         data->T7_address = object->start_address;
1587                         break;
1588                 case MXT_TOUCH_MULTI_T9:
1589                         data->multitouch = MXT_TOUCH_MULTI_T9;
1590                         data->T9_reportid_min = min_id;
1591                         data->T9_reportid_max = max_id;
1592                         data->num_touchids = object->num_report_ids
1593                                                 * mxt_obj_instances(object);
1594                         break;
1595                 case MXT_SPT_MESSAGECOUNT_T44:
1596                         data->T44_address = object->start_address;
1597                         break;
1598                 case MXT_SPT_GPIOPWM_T19:
1599                         data->T19_reportid = min_id;
1600                         break;
1601                 case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1602                         data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1603                         data->T100_reportid_min = min_id;
1604                         data->T100_reportid_max = max_id;
1605                         /* first two report IDs reserved */
1606                         data->num_touchids = object->num_report_ids - 2;
1607                         break;
1608                 }
1609
1610                 end_address = object->start_address
1611                         + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1612
1613                 if (end_address >= data->mem_size)
1614                         data->mem_size = end_address + 1;
1615         }
1616
1617         /* Store maximum reportid */
1618         data->max_reportid = reportid;
1619
1620         /* If T44 exists, T5 position has to be directly after */
1621         if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1622                 dev_err(&client->dev, "Invalid T44 position\n");
1623                 error = -EINVAL;
1624                 goto free_object_table;
1625         }
1626
1627         data->msg_buf = kcalloc(data->max_reportid,
1628                                 data->T5_msg_size, GFP_KERNEL);
1629         if (!data->msg_buf) {
1630                 dev_err(&client->dev, "Failed to allocate message buffer\n");
1631                 error = -ENOMEM;
1632                 goto free_object_table;
1633         }
1634
1635         data->object_table = object_table;
1636
1637         return 0;
1638
1639 free_object_table:
1640         mxt_free_object_table(data);
1641         return error;
1642 }
1643
1644 static int mxt_read_t9_resolution(struct mxt_data *data)
1645 {
1646         struct i2c_client *client = data->client;
1647         int error;
1648         struct t9_range range;
1649         unsigned char orient;
1650         struct mxt_object *object;
1651
1652         object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1653         if (!object)
1654                 return -EINVAL;
1655
1656         error = __mxt_read_reg(client,
1657                                object->start_address + MXT_T9_RANGE,
1658                                sizeof(range), &range);
1659         if (error)
1660                 return error;
1661
1662         le16_to_cpus(&range.x);
1663         le16_to_cpus(&range.y);
1664
1665         error =  __mxt_read_reg(client,
1666                                 object->start_address + MXT_T9_ORIENT,
1667                                 1, &orient);
1668         if (error)
1669                 return error;
1670
1671         /* Handle default values */
1672         if (range.x == 0)
1673                 range.x = 1023;
1674
1675         if (range.y == 0)
1676                 range.y = 1023;
1677
1678         if (orient & MXT_T9_ORIENT_SWITCH) {
1679                 data->max_x = range.y;
1680                 data->max_y = range.x;
1681         } else {
1682                 data->max_x = range.x;
1683                 data->max_y = range.y;
1684         }
1685
1686         dev_dbg(&client->dev,
1687                 "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1688
1689         return 0;
1690 }
1691
1692 static int mxt_read_t100_config(struct mxt_data *data)
1693 {
1694         struct i2c_client *client = data->client;
1695         int error;
1696         struct mxt_object *object;
1697         u16 range_x, range_y;
1698         u8 cfg, tchaux;
1699         u8 aux;
1700
1701         object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1702         if (!object)
1703                 return -EINVAL;
1704
1705         error = __mxt_read_reg(client,
1706                                object->start_address + MXT_T100_XRANGE,
1707                                sizeof(range_x), &range_x);
1708         if (error)
1709                 return error;
1710
1711         le16_to_cpus(&range_x);
1712
1713         error = __mxt_read_reg(client,
1714                                object->start_address + MXT_T100_YRANGE,
1715                                sizeof(range_y), &range_y);
1716         if (error)
1717                 return error;
1718
1719         le16_to_cpus(&range_y);
1720
1721         error =  __mxt_read_reg(client,
1722                                 object->start_address + MXT_T100_CFG1,
1723                                 1, &cfg);
1724         if (error)
1725                 return error;
1726
1727         error =  __mxt_read_reg(client,
1728                                 object->start_address + MXT_T100_TCHAUX,
1729                                 1, &tchaux);
1730         if (error)
1731                 return error;
1732
1733         /* Handle default values */
1734         if (range_x == 0)
1735                 range_x = 1023;
1736
1737         if (range_y == 0)
1738                 range_y = 1023;
1739
1740         if (cfg & MXT_T100_CFG_SWITCHXY) {
1741                 data->max_x = range_y;
1742                 data->max_y = range_x;
1743         } else {
1744                 data->max_x = range_x;
1745                 data->max_y = range_y;
1746         }
1747
1748         /* allocate aux bytes */
1749         aux = 6;
1750
1751         if (tchaux & MXT_T100_TCHAUX_VECT)
1752                 data->t100_aux_vect = aux++;
1753
1754         if (tchaux & MXT_T100_TCHAUX_AMPL)
1755                 data->t100_aux_ampl = aux++;
1756
1757         if (tchaux & MXT_T100_TCHAUX_AREA)
1758                 data->t100_aux_area = aux++;
1759
1760         dev_dbg(&client->dev,
1761                 "T100 aux mappings vect:%u ampl:%u area:%u\n",
1762                 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
1763
1764         dev_info(&client->dev,
1765                  "T100 Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1766
1767         return 0;
1768 }
1769
1770 static int mxt_input_open(struct input_dev *dev);
1771 static void mxt_input_close(struct input_dev *dev);
1772
1773 static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
1774                                    struct mxt_data *data)
1775 {
1776         const struct mxt_platform_data *pdata = data->pdata;
1777         int i;
1778
1779         input_dev->name = "Atmel maXTouch Touchpad";
1780
1781         __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1782
1783         input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1784         input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1785         input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1786                           MXT_PIXELS_PER_MM);
1787         input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1788                           MXT_PIXELS_PER_MM);
1789
1790         for (i = 0; i < pdata->t19_num_keys; i++)
1791                 if (pdata->t19_keymap[i] != KEY_RESERVED)
1792                         input_set_capability(input_dev, EV_KEY,
1793                                              pdata->t19_keymap[i]);
1794 }
1795
1796 static int mxt_initialize_input_device(struct mxt_data *data)
1797 {
1798         const struct mxt_platform_data *pdata = data->pdata;
1799         struct device *dev = &data->client->dev;
1800         struct input_dev *input_dev;
1801         int error;
1802         unsigned int num_mt_slots;
1803         unsigned int mt_flags = 0;
1804
1805         switch (data->multitouch) {
1806         case MXT_TOUCH_MULTI_T9:
1807                 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1808                 error = mxt_read_t9_resolution(data);
1809                 if (error)
1810                         dev_warn(dev, "Failed to initialize T9 resolution\n");
1811                 break;
1812
1813         case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1814                 num_mt_slots = data->num_touchids;
1815                 error = mxt_read_t100_config(data);
1816                 if (error)
1817                         dev_warn(dev, "Failed to read T100 config\n");
1818                 break;
1819
1820         default:
1821                 dev_err(dev, "Invalid multitouch object\n");
1822                 return -EINVAL;
1823         }
1824
1825         input_dev = input_allocate_device();
1826         if (!input_dev) {
1827                 dev_err(dev, "Failed to allocate memory\n");
1828                 return -ENOMEM;
1829         }
1830
1831         input_dev->name = "Atmel maXTouch Touchscreen";
1832         input_dev->phys = data->phys;
1833         input_dev->id.bustype = BUS_I2C;
1834         input_dev->dev.parent = dev;
1835         input_dev->open = mxt_input_open;
1836         input_dev->close = mxt_input_close;
1837
1838         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
1839
1840         /* For single touch */
1841         input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
1842         input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
1843
1844         if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1845             (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1846              data->t100_aux_ampl)) {
1847                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
1848         }
1849
1850         /* If device has buttons we assume it is a touchpad */
1851         if (pdata->t19_num_keys) {
1852                 mxt_set_up_as_touchpad(input_dev, data);
1853                 mt_flags |= INPUT_MT_POINTER;
1854         }
1855
1856         /* For multi touch */
1857         error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1858         if (error) {
1859                 dev_err(dev, "Error %d initialising slots\n", error);
1860                 goto err_free_mem;
1861         }
1862
1863         if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
1864                 input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
1865                                      0, MT_TOOL_MAX, 0, 0);
1866                 input_set_abs_params(input_dev, ABS_MT_DISTANCE,
1867                                      MXT_DISTANCE_ACTIVE_TOUCH,
1868                                      MXT_DISTANCE_HOVERING,
1869                                      0, 0);
1870         }
1871
1872         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1873                              0, data->max_x, 0, 0);
1874         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1875                              0, data->max_y, 0, 0);
1876
1877         if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1878             (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1879              data->t100_aux_area)) {
1880                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1881                                      0, MXT_MAX_AREA, 0, 0);
1882         }
1883
1884         if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1885             (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1886              data->t100_aux_ampl)) {
1887                 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1888                                      0, 255, 0, 0);
1889         }
1890
1891         if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1892             data->t100_aux_vect) {
1893                 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1894                                      0, 255, 0, 0);
1895         }
1896
1897         if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1898             data->t100_aux_ampl) {
1899                 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1900                                      0, 255, 0, 0);
1901         }
1902
1903         if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1904             data->t100_aux_vect) {
1905                 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1906                                      0, 255, 0, 0);
1907         }
1908
1909         input_set_drvdata(input_dev, data);
1910
1911         error = input_register_device(input_dev);
1912         if (error) {
1913                 dev_err(dev, "Error %d registering input device\n", error);
1914                 goto err_free_mem;
1915         }
1916
1917         data->input_dev = input_dev;
1918
1919         return 0;
1920
1921 err_free_mem:
1922         input_free_device(input_dev);
1923         return error;
1924 }
1925
1926 static int mxt_configure_objects(struct mxt_data *data,
1927                                  const struct firmware *cfg);
1928
1929 static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1930 {
1931         mxt_configure_objects(ctx, cfg);
1932         release_firmware(cfg);
1933 }
1934
1935 static int mxt_initialize(struct mxt_data *data)
1936 {
1937         struct i2c_client *client = data->client;
1938         int recovery_attempts = 0;
1939         int error;
1940
1941         while (1) {
1942                 error = mxt_get_info(data);
1943                 if (!error)
1944                         break;
1945
1946                 /* Check bootloader state */
1947                 error = mxt_probe_bootloader(data, false);
1948                 if (error) {
1949                         dev_info(&client->dev, "Trying alternate bootloader address\n");
1950                         error = mxt_probe_bootloader(data, true);
1951                         if (error) {
1952                                 /* Chip is not in appmode or bootloader mode */
1953                                 return error;
1954                         }
1955                 }
1956
1957                 /* OK, we are in bootloader, see if we can recover */
1958                 if (++recovery_attempts > 1) {
1959                         dev_err(&client->dev, "Could not recover from bootloader mode\n");
1960                         /*
1961                          * We can reflash from this state, so do not
1962                          * abort initialization.
1963                          */
1964                         data->in_bootloader = true;
1965                         return 0;
1966                 }
1967
1968                 /* Attempt to exit bootloader into app mode */
1969                 mxt_send_bootloader_cmd(data, false);
1970                 msleep(MXT_FW_RESET_TIME);
1971         }
1972
1973         /* Get object table information */
1974         error = mxt_get_object_table(data);
1975         if (error) {
1976                 dev_err(&client->dev, "Error %d reading object table\n", error);
1977                 return error;
1978         }
1979
1980         error = mxt_acquire_irq(data);
1981         if (error)
1982                 goto err_free_object_table;
1983
1984         error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
1985                                         &client->dev, GFP_KERNEL, data,
1986                                         mxt_config_cb);
1987         if (error) {
1988                 dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
1989                         error);
1990                 goto err_free_object_table;
1991         }
1992
1993         return 0;
1994
1995 err_free_object_table:
1996         mxt_free_object_table(data);
1997         return error;
1998 }
1999
2000 static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2001 {
2002         struct device *dev = &data->client->dev;
2003         int error;
2004         struct t7_config *new_config;
2005         struct t7_config deepsleep = { .active = 0, .idle = 0 };
2006
2007         if (sleep == MXT_POWER_CFG_DEEPSLEEP)
2008                 new_config = &deepsleep;
2009         else
2010                 new_config = &data->t7_cfg;
2011
2012         error = __mxt_write_reg(data->client, data->T7_address,
2013                                 sizeof(data->t7_cfg), new_config);
2014         if (error)
2015                 return error;
2016
2017         dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
2018                 new_config->active, new_config->idle);
2019
2020         return 0;
2021 }
2022
2023 static int mxt_init_t7_power_cfg(struct mxt_data *data)
2024 {
2025         struct device *dev = &data->client->dev;
2026         int error;
2027         bool retry = false;
2028
2029 recheck:
2030         error = __mxt_read_reg(data->client, data->T7_address,
2031                                 sizeof(data->t7_cfg), &data->t7_cfg);
2032         if (error)
2033                 return error;
2034
2035         if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2036                 if (!retry) {
2037                         dev_dbg(dev, "T7 cfg zero, resetting\n");
2038                         mxt_soft_reset(data);
2039                         retry = true;
2040                         goto recheck;
2041                 } else {
2042                         dev_dbg(dev, "T7 cfg zero after reset, overriding\n");
2043                         data->t7_cfg.active = 20;
2044                         data->t7_cfg.idle = 100;
2045                         return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2046                 }
2047         }
2048
2049         dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n",
2050                 data->t7_cfg.active, data->t7_cfg.idle);
2051         return 0;
2052 }
2053
2054 static int mxt_configure_objects(struct mxt_data *data,
2055                                  const struct firmware *cfg)
2056 {
2057         struct device *dev = &data->client->dev;
2058         struct mxt_info *info = &data->info;
2059         int error;
2060
2061         error = mxt_init_t7_power_cfg(data);
2062         if (error) {
2063                 dev_err(dev, "Failed to initialize power cfg\n");
2064                 return error;
2065         }
2066
2067         if (cfg) {
2068                 error = mxt_update_cfg(data, cfg);
2069                 if (error)
2070                         dev_warn(dev, "Error %d updating config\n", error);
2071         }
2072
2073         if (data->multitouch) {
2074                 error = mxt_initialize_input_device(data);
2075                 if (error)
2076                         return error;
2077         } else {
2078                 dev_warn(dev, "No touch object detected\n");
2079         }
2080
2081         dev_info(dev,
2082                  "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
2083                  info->family_id, info->variant_id, info->version >> 4,
2084                  info->version & 0xf, info->build, info->object_num);
2085
2086         return 0;
2087 }
2088
2089 /* Firmware Version is returned as Major.Minor.Build */
2090 static ssize_t mxt_fw_version_show(struct device *dev,
2091                                    struct device_attribute *attr, char *buf)
2092 {
2093         struct mxt_data *data = dev_get_drvdata(dev);
2094         struct mxt_info *info = &data->info;
2095         return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
2096                          info->version >> 4, info->version & 0xf, info->build);
2097 }
2098
2099 /* Hardware Version is returned as FamilyID.VariantID */
2100 static ssize_t mxt_hw_version_show(struct device *dev,
2101                                    struct device_attribute *attr, char *buf)
2102 {
2103         struct mxt_data *data = dev_get_drvdata(dev);
2104         struct mxt_info *info = &data->info;
2105         return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
2106                          info->family_id, info->variant_id);
2107 }
2108
2109 static ssize_t mxt_show_instance(char *buf, int count,
2110                                  struct mxt_object *object, int instance,
2111                                  const u8 *val)
2112 {
2113         int i;
2114
2115         if (mxt_obj_instances(object) > 1)
2116                 count += scnprintf(buf + count, PAGE_SIZE - count,
2117                                    "Instance %u\n", instance);
2118
2119         for (i = 0; i < mxt_obj_size(object); i++)
2120                 count += scnprintf(buf + count, PAGE_SIZE - count,
2121                                 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
2122         count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
2123
2124         return count;
2125 }
2126
2127 static ssize_t mxt_object_show(struct device *dev,
2128                                     struct device_attribute *attr, char *buf)
2129 {
2130         struct mxt_data *data = dev_get_drvdata(dev);
2131         struct mxt_object *object;
2132         int count = 0;
2133         int i, j;
2134         int error;
2135         u8 *obuf;
2136
2137         /* Pre-allocate buffer large enough to hold max sized object. */
2138         obuf = kmalloc(256, GFP_KERNEL);
2139         if (!obuf)
2140                 return -ENOMEM;
2141
2142         error = 0;
2143         for (i = 0; i < data->info.object_num; i++) {
2144                 object = data->object_table + i;
2145
2146                 if (!mxt_object_readable(object->type))
2147                         continue;
2148
2149                 count += scnprintf(buf + count, PAGE_SIZE - count,
2150                                 "T%u:\n", object->type);
2151
2152                 for (j = 0; j < mxt_obj_instances(object); j++) {
2153                         u16 size = mxt_obj_size(object);
2154                         u16 addr = object->start_address + j * size;
2155
2156                         error = __mxt_read_reg(data->client, addr, size, obuf);
2157                         if (error)
2158                                 goto done;
2159
2160                         count = mxt_show_instance(buf, count, object, j, obuf);
2161                 }
2162         }
2163
2164 done:
2165         kfree(obuf);
2166         return error ?: count;
2167 }
2168
2169 static int mxt_check_firmware_format(struct device *dev,
2170                                      const struct firmware *fw)
2171 {
2172         unsigned int pos = 0;
2173         char c;
2174
2175         while (pos < fw->size) {
2176                 c = *(fw->data + pos);
2177
2178                 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
2179                         return 0;
2180
2181                 pos++;
2182         }
2183
2184         /*
2185          * To convert file try:
2186          * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2187          */
2188         dev_err(dev, "Aborting: firmware file must be in binary format\n");
2189
2190         return -EINVAL;
2191 }
2192
2193 static int mxt_load_fw(struct device *dev, const char *fn)
2194 {
2195         struct mxt_data *data = dev_get_drvdata(dev);
2196         const struct firmware *fw = NULL;
2197         unsigned int frame_size;
2198         unsigned int pos = 0;
2199         unsigned int retry = 0;
2200         unsigned int frame = 0;
2201         int ret;
2202
2203         ret = request_firmware(&fw, fn, dev);
2204         if (ret) {
2205                 dev_err(dev, "Unable to open firmware %s\n", fn);
2206                 return ret;
2207         }
2208
2209         /* Check for incorrect enc file */
2210         ret = mxt_check_firmware_format(dev, fw);
2211         if (ret)
2212                 goto release_firmware;
2213
2214         if (!data->in_bootloader) {
2215                 /* Change to the bootloader mode */
2216                 data->in_bootloader = true;
2217
2218                 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2219                                      MXT_BOOT_VALUE, false);
2220                 if (ret)
2221                         goto release_firmware;
2222
2223                 msleep(MXT_RESET_TIME);
2224
2225                 /* Do not need to scan since we know family ID */
2226                 ret = mxt_lookup_bootloader_address(data, 0);
2227                 if (ret)
2228                         goto release_firmware;
2229
2230                 mxt_free_input_device(data);
2231                 mxt_free_object_table(data);
2232         } else {
2233                 enable_irq(data->irq);
2234         }
2235
2236         reinit_completion(&data->bl_completion);
2237
2238         ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2239         if (ret) {
2240                 /* Bootloader may still be unlocked from previous attempt */
2241                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2242                 if (ret)
2243                         goto disable_irq;
2244         } else {
2245                 dev_info(dev, "Unlocking bootloader\n");
2246
2247                 /* Unlock bootloader */
2248                 ret = mxt_send_bootloader_cmd(data, true);
2249                 if (ret)
2250                         goto disable_irq;
2251         }
2252
2253         while (pos < fw->size) {
2254                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
2255                 if (ret)
2256                         goto disable_irq;
2257
2258                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2259
2260                 /* Take account of CRC bytes */
2261                 frame_size += 2;
2262
2263                 /* Write one frame to device */
2264                 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2265                 if (ret)
2266                         goto disable_irq;
2267
2268                 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
2269                 if (ret) {
2270                         retry++;
2271
2272                         /* Back off by 20ms per retry */
2273                         msleep(retry * 20);
2274
2275                         if (retry > 20) {
2276                                 dev_err(dev, "Retry count exceeded\n");
2277                                 goto disable_irq;
2278                         }
2279                 } else {
2280                         retry = 0;
2281                         pos += frame_size;
2282                         frame++;
2283                 }
2284
2285                 if (frame % 50 == 0)
2286                         dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
2287                                 frame, pos, fw->size);
2288         }
2289
2290         /* Wait for flash. */
2291         ret = mxt_wait_for_completion(data, &data->bl_completion,
2292                                       MXT_FW_RESET_TIME);
2293         if (ret)
2294                 goto disable_irq;
2295
2296         dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
2297
2298         /*
2299          * Wait for device to reset. Some bootloader versions do not assert
2300          * the CHG line after bootloading has finished, so ignore potential
2301          * errors.
2302          */
2303         mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
2304
2305         data->in_bootloader = false;
2306
2307 disable_irq:
2308         disable_irq(data->irq);
2309 release_firmware:
2310         release_firmware(fw);
2311         return ret;
2312 }
2313
2314 static ssize_t mxt_update_fw_store(struct device *dev,
2315                                         struct device_attribute *attr,
2316                                         const char *buf, size_t count)
2317 {
2318         struct mxt_data *data = dev_get_drvdata(dev);
2319         int error;
2320
2321         error = mxt_load_fw(dev, MXT_FW_NAME);
2322         if (error) {
2323                 dev_err(dev, "The firmware update failed(%d)\n", error);
2324                 count = error;
2325         } else {
2326                 dev_info(dev, "The firmware update succeeded\n");
2327
2328                 error = mxt_initialize(data);
2329                 if (error)
2330                         return error;
2331         }
2332
2333         return count;
2334 }
2335
2336 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
2337 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
2338 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
2339 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
2340
2341 static struct attribute *mxt_attrs[] = {
2342         &dev_attr_fw_version.attr,
2343         &dev_attr_hw_version.attr,
2344         &dev_attr_object.attr,
2345         &dev_attr_update_fw.attr,
2346         NULL
2347 };
2348
2349 static const struct attribute_group mxt_attr_group = {
2350         .attrs = mxt_attrs,
2351 };
2352
2353 static void mxt_start(struct mxt_data *data)
2354 {
2355         switch (data->pdata->suspend_mode) {
2356         case MXT_SUSPEND_T9_CTRL:
2357                 mxt_soft_reset(data);
2358
2359                 /* Touch enable */
2360                 /* 0x83 = SCANEN | RPTEN | ENABLE */
2361                 mxt_write_object(data,
2362                                 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0x83);
2363                 break;
2364
2365         case MXT_SUSPEND_DEEP_SLEEP:
2366         default:
2367                 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2368
2369                 /* Recalibrate since chip has been in deep sleep */
2370                 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
2371                 break;
2372         }
2373
2374 }
2375
2376 static void mxt_stop(struct mxt_data *data)
2377 {
2378         switch (data->pdata->suspend_mode) {
2379         case MXT_SUSPEND_T9_CTRL:
2380                 /* Touch disable */
2381                 mxt_write_object(data,
2382                                 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0);
2383                 break;
2384
2385         case MXT_SUSPEND_DEEP_SLEEP:
2386         default:
2387                 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
2388                 break;
2389         }
2390 }
2391
2392 static int mxt_input_open(struct input_dev *dev)
2393 {
2394         struct mxt_data *data = input_get_drvdata(dev);
2395
2396         mxt_start(data);
2397
2398         return 0;
2399 }
2400
2401 static void mxt_input_close(struct input_dev *dev)
2402 {
2403         struct mxt_data *data = input_get_drvdata(dev);
2404
2405         mxt_stop(data);
2406 }
2407
2408 #ifdef CONFIG_OF
2409 static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2410 {
2411         struct mxt_platform_data *pdata;
2412         struct device_node *np = client->dev.of_node;
2413         u32 *keymap;
2414         int proplen, ret;
2415
2416         if (!np)
2417                 return ERR_PTR(-ENOENT);
2418
2419         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
2420         if (!pdata)
2421                 return ERR_PTR(-ENOMEM);
2422
2423         if (of_find_property(np, "linux,gpio-keymap", &proplen)) {
2424                 pdata->t19_num_keys = proplen / sizeof(u32);
2425
2426                 keymap = devm_kzalloc(&client->dev,
2427                                 pdata->t19_num_keys * sizeof(keymap[0]),
2428                                 GFP_KERNEL);
2429                 if (!keymap)
2430                         return ERR_PTR(-ENOMEM);
2431
2432                 ret = of_property_read_u32_array(np, "linux,gpio-keymap",
2433                                                  keymap, pdata->t19_num_keys);
2434                 if (ret)
2435                         dev_warn(&client->dev,
2436                                  "Couldn't read linux,gpio-keymap: %d\n", ret);
2437
2438                 pdata->t19_keymap = keymap;
2439         }
2440
2441         pdata->suspend_mode = MXT_SUSPEND_DEEP_SLEEP;
2442
2443         return pdata;
2444 }
2445 #else
2446 static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2447 {
2448         return ERR_PTR(-ENOENT);
2449 }
2450 #endif
2451
2452 #ifdef CONFIG_ACPI
2453
2454 struct mxt_acpi_platform_data {
2455         const char *hid;
2456         struct mxt_platform_data pdata;
2457 };
2458
2459 static unsigned int samus_touchpad_buttons[] = {
2460         KEY_RESERVED,
2461         KEY_RESERVED,
2462         KEY_RESERVED,
2463         BTN_LEFT
2464 };
2465
2466 static struct mxt_acpi_platform_data samus_platform_data[] = {
2467         {
2468                 /* Touchpad */
2469                 .hid    = "ATML0000",
2470                 .pdata  = {
2471                         .t19_num_keys   = ARRAY_SIZE(samus_touchpad_buttons),
2472                         .t19_keymap     = samus_touchpad_buttons,
2473                 },
2474         },
2475         {
2476                 /* Touchscreen */
2477                 .hid    = "ATML0001",
2478         },
2479         { }
2480 };
2481
2482 static const struct dmi_system_id mxt_dmi_table[] = {
2483         {
2484                 /* 2015 Google Pixel */
2485                 .ident = "Chromebook Pixel 2",
2486                 .matches = {
2487                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
2488                         DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
2489                 },
2490                 .driver_data = samus_platform_data,
2491         },
2492         { }
2493 };
2494
2495 static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
2496 {
2497         struct acpi_device *adev;
2498         const struct dmi_system_id *system_id;
2499         const struct mxt_acpi_platform_data *acpi_pdata;
2500
2501         /*
2502          * Ignore ACPI devices representing bootloader mode.
2503          *
2504          * This is a bit of a hack: Google Chromebook BIOS creates ACPI
2505          * devices for both application and bootloader modes, but we are
2506          * interested in application mode only (if device is in bootloader
2507          * mode we'll end up switching into application anyway). So far
2508          * application mode addresses were all above 0x40, so we'll use it
2509          * as a threshold.
2510          */
2511         if (client->addr < 0x40)
2512                 return ERR_PTR(-ENXIO);
2513
2514         adev = ACPI_COMPANION(&client->dev);
2515         if (!adev)
2516                 return ERR_PTR(-ENOENT);
2517
2518         system_id = dmi_first_match(mxt_dmi_table);
2519         if (!system_id)
2520                 return ERR_PTR(-ENOENT);
2521
2522         acpi_pdata = system_id->driver_data;
2523         if (!acpi_pdata)
2524                 return ERR_PTR(-ENOENT);
2525
2526         while (acpi_pdata->hid) {
2527                 if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid))
2528                         return &acpi_pdata->pdata;
2529
2530                 acpi_pdata++;
2531         }
2532
2533         return ERR_PTR(-ENOENT);
2534 }
2535 #else
2536 static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
2537 {
2538         return ERR_PTR(-ENOENT);
2539 }
2540 #endif
2541
2542 static const struct mxt_platform_data *
2543 mxt_get_platform_data(struct i2c_client *client)
2544 {
2545         const struct mxt_platform_data *pdata;
2546
2547         pdata = dev_get_platdata(&client->dev);
2548         if (pdata)
2549                 return pdata;
2550
2551         pdata = mxt_parse_dt(client);
2552         if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
2553                 return pdata;
2554
2555         pdata = mxt_parse_acpi(client);
2556         if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
2557                 return pdata;
2558
2559         dev_err(&client->dev, "No platform data specified\n");
2560         return ERR_PTR(-EINVAL);
2561 }
2562
2563 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
2564 {
2565         struct mxt_data *data;
2566         const struct mxt_platform_data *pdata;
2567         int error;
2568
2569         pdata = mxt_get_platform_data(client);
2570         if (IS_ERR(pdata))
2571                 return PTR_ERR(pdata);
2572
2573         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
2574         if (!data) {
2575                 dev_err(&client->dev, "Failed to allocate memory\n");
2576                 return -ENOMEM;
2577         }
2578
2579         snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
2580                  client->adapter->nr, client->addr);
2581
2582         data->client = client;
2583         data->pdata = pdata;
2584         data->irq = client->irq;
2585         i2c_set_clientdata(client, data);
2586
2587         init_completion(&data->bl_completion);
2588         init_completion(&data->reset_completion);
2589         init_completion(&data->crc_completion);
2590
2591         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
2592                                      pdata->irqflags | IRQF_ONESHOT,
2593                                      client->name, data);
2594         if (error) {
2595                 dev_err(&client->dev, "Failed to register interrupt\n");
2596                 goto err_free_mem;
2597         }
2598
2599         disable_irq(client->irq);
2600
2601         error = mxt_initialize(data);
2602         if (error)
2603                 goto err_free_irq;
2604
2605         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
2606         if (error) {
2607                 dev_err(&client->dev, "Failure %d creating sysfs group\n",
2608                         error);
2609                 goto err_free_object;
2610         }
2611
2612         return 0;
2613
2614 err_free_object:
2615         mxt_free_input_device(data);
2616         mxt_free_object_table(data);
2617 err_free_irq:
2618         free_irq(client->irq, data);
2619 err_free_mem:
2620         kfree(data);
2621         return error;
2622 }
2623
2624 static int mxt_remove(struct i2c_client *client)
2625 {
2626         struct mxt_data *data = i2c_get_clientdata(client);
2627
2628         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
2629         free_irq(data->irq, data);
2630         mxt_free_input_device(data);
2631         mxt_free_object_table(data);
2632         kfree(data);
2633
2634         return 0;
2635 }
2636
2637 static int __maybe_unused mxt_suspend(struct device *dev)
2638 {
2639         struct i2c_client *client = to_i2c_client(dev);
2640         struct mxt_data *data = i2c_get_clientdata(client);
2641         struct input_dev *input_dev = data->input_dev;
2642
2643         if (!input_dev)
2644                 return 0;
2645
2646         mutex_lock(&input_dev->mutex);
2647
2648         if (input_dev->users)
2649                 mxt_stop(data);
2650
2651         mutex_unlock(&input_dev->mutex);
2652
2653         return 0;
2654 }
2655
2656 static int __maybe_unused mxt_resume(struct device *dev)
2657 {
2658         struct i2c_client *client = to_i2c_client(dev);
2659         struct mxt_data *data = i2c_get_clientdata(client);
2660         struct input_dev *input_dev = data->input_dev;
2661
2662         if (!input_dev)
2663                 return 0;
2664
2665         mutex_lock(&input_dev->mutex);
2666
2667         if (input_dev->users)
2668                 mxt_start(data);
2669
2670         mutex_unlock(&input_dev->mutex);
2671
2672         return 0;
2673 }
2674
2675 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
2676
2677 static const struct of_device_id mxt_of_match[] = {
2678         { .compatible = "atmel,maxtouch", },
2679         {},
2680 };
2681 MODULE_DEVICE_TABLE(of, mxt_of_match);
2682
2683 #ifdef CONFIG_ACPI
2684 static const struct acpi_device_id mxt_acpi_id[] = {
2685         { "ATML0000", 0 },      /* Touchpad */
2686         { "ATML0001", 0 },      /* Touchscreen */
2687         { }
2688 };
2689 MODULE_DEVICE_TABLE(acpi, mxt_acpi_id);
2690 #endif
2691
2692 static const struct i2c_device_id mxt_id[] = {
2693         { "qt602240_ts", 0 },
2694         { "atmel_mxt_ts", 0 },
2695         { "atmel_mxt_tp", 0 },
2696         { "mXT224", 0 },
2697         { }
2698 };
2699 MODULE_DEVICE_TABLE(i2c, mxt_id);
2700
2701 static struct i2c_driver mxt_driver = {
2702         .driver = {
2703                 .name   = "atmel_mxt_ts",
2704                 .of_match_table = of_match_ptr(mxt_of_match),
2705                 .acpi_match_table = ACPI_PTR(mxt_acpi_id),
2706                 .pm     = &mxt_pm_ops,
2707         },
2708         .probe          = mxt_probe,
2709         .remove         = mxt_remove,
2710         .id_table       = mxt_id,
2711 };
2712
2713 module_i2c_driver(mxt_driver);
2714
2715 /* Module information */
2716 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
2717 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
2718 MODULE_LICENSE("GPL");