drivers/input/touchscreen/atmel_mxt_ts.c

   1 /*
   2  * Atmel maXTouch Touchscreen driver
   3  *
   4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
   5  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/delay.h>
  17 #include <linux/firmware.h>
  18 #include <linux/i2c.h>
  19 #include <linux/i2c/atmel_mxt_ts.h>
  20 #include <linux/input/mt.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/slab.h>
  23
  24 /* Version */
  25 #define MXT_VER_20              20
  26 #define MXT_VER_21              21
  27 #define MXT_VER_22              22
  28
  29 /* Slave addresses */
  30 #define MXT_APP_LOW             0x4a
  31 #define MXT_APP_HIGH            0x4b
  32 #define MXT_BOOT_LOW            0x24
  33 #define MXT_BOOT_HIGH           0x25
  34
  35 /* Firmware */
  36 #define MXT_FW_NAME             "maxtouch.fw"
  37
  38 /* Registers */
  39 #define MXT_INFO                0x00
  40 #define MXT_FAMILY_ID           0x00
  41 #define MXT_VARIANT_ID          0x01
  42 #define MXT_VERSION             0x02
  43 #define MXT_BUILD               0x03
  44 #define MXT_MATRIX_X_SIZE       0x04
  45 #define MXT_MATRIX_Y_SIZE       0x05
  46 #define MXT_OBJECT_NUM          0x06
  47 #define MXT_OBJECT_START        0x07
  48
  49 #define MXT_OBJECT_SIZE         6
  50
  51 /* Object types */
  52 #define MXT_DEBUG_DIAGNOSTIC_T37        37
  53 #define MXT_GEN_MESSAGE_T5              5
  54 #define MXT_GEN_COMMAND_T6              6
  55 #define MXT_GEN_POWER_T7                7
  56 #define MXT_GEN_ACQUIRE_T8              8
  57 #define MXT_GEN_DATASOURCE_T53          53
  58 #define MXT_TOUCH_MULTI_T9              9
  59 #define MXT_TOUCH_KEYARRAY_T15          15
  60 #define MXT_TOUCH_PROXIMITY_T23         23
  61 #define MXT_TOUCH_PROXKEY_T52           52
  62 #define MXT_PROCI_GRIPFACE_T20          20
  63 #define MXT_PROCG_NOISE_T22             22
  64 #define MXT_PROCI_ONETOUCH_T24          24
  65 #define MXT_PROCI_TWOTOUCH_T27          27
  66 #define MXT_PROCI_GRIP_T40              40
  67 #define MXT_PROCI_PALM_T41              41
  68 #define MXT_PROCI_TOUCHSUPPRESSION_T42  42
  69 #define MXT_PROCI_STYLUS_T47            47
  70 #define MXT_PROCG_NOISESUPPRESSION_T48  48
  71 #define MXT_SPT_COMMSCONFIG_T18         18
  72 #define MXT_SPT_GPIOPWM_T19             19
  73 #define MXT_SPT_SELFTEST_T25            25
  74 #define MXT_SPT_CTECONFIG_T28           28
  75 #define MXT_SPT_USERDATA_T38            38
  76 #define MXT_SPT_DIGITIZER_T43           43
  77 #define MXT_SPT_MESSAGECOUNT_T44        44
  78 #define MXT_SPT_CTECONFIG_T46           46
  79
  80 /* MXT_GEN_COMMAND_T6 field */
  81 #define MXT_COMMAND_RESET       0
  82 #define MXT_COMMAND_BACKUPNV    1
  83 #define MXT_COMMAND_CALIBRATE   2
  84 #define MXT_COMMAND_REPORTALL   3
  85 #define MXT_COMMAND_DIAGNOSTIC  5
  86
  87 /* MXT_GEN_POWER_T7 field */
  88 #define MXT_POWER_IDLEACQINT    0
  89 #define MXT_POWER_ACTVACQINT    1
  90 #define MXT_POWER_ACTV2IDLETO   2
  91
  92 /* MXT_GEN_ACQUIRE_T8 field */
  93 #define MXT_ACQUIRE_CHRGTIME    0
  94 #define MXT_ACQUIRE_TCHDRIFT    2
  95 #define MXT_ACQUIRE_DRIFTST     3
  96 #define MXT_ACQUIRE_TCHAUTOCAL  4
  97 #define MXT_ACQUIRE_SYNC        5
  98 #define MXT_ACQUIRE_ATCHCALST   6
  99 #define MXT_ACQUIRE_ATCHCALSTHR 7
 100
 101 /* MXT_TOUCH_MULTI_T9 field */
 102 #define MXT_TOUCH_CTRL          0
 103 #define MXT_TOUCH_XORIGIN       1
 104 #define MXT_TOUCH_YORIGIN       2
 105 #define MXT_TOUCH_XSIZE         3
 106 #define MXT_TOUCH_YSIZE         4
 107 #define MXT_TOUCH_BLEN          6
 108 #define MXT_TOUCH_TCHTHR        7
 109 #define MXT_TOUCH_TCHDI         8
 110 #define MXT_TOUCH_ORIENT        9
 111 #define MXT_TOUCH_MOVHYSTI      11
 112 #define MXT_TOUCH_MOVHYSTN      12
 113 #define MXT_TOUCH_NUMTOUCH      14
 114 #define MXT_TOUCH_MRGHYST       15
 115 #define MXT_TOUCH_MRGTHR        16
 116 #define MXT_TOUCH_AMPHYST       17
 117 #define MXT_TOUCH_XRANGE_LSB    18
 118 #define MXT_TOUCH_XRANGE_MSB    19
 119 #define MXT_TOUCH_YRANGE_LSB    20
 120 #define MXT_TOUCH_YRANGE_MSB    21
 121 #define MXT_TOUCH_XLOCLIP       22
 122 #define MXT_TOUCH_XHICLIP       23
 123 #define MXT_TOUCH_YLOCLIP       24
 124 #define MXT_TOUCH_YHICLIP       25
 125 #define MXT_TOUCH_XEDGECTRL     26
 126 #define MXT_TOUCH_XEDGEDIST     27
 127 #define MXT_TOUCH_YEDGECTRL     28
 128 #define MXT_TOUCH_YEDGEDIST     29
 129 #define MXT_TOUCH_JUMPLIMIT     30
 130
 131 /* MXT_PROCI_GRIPFACE_T20 field */
 132 #define MXT_GRIPFACE_CTRL       0
 133 #define MXT_GRIPFACE_XLOGRIP    1
 134 #define MXT_GRIPFACE_XHIGRIP    2
 135 #define MXT_GRIPFACE_YLOGRIP    3
 136 #define MXT_GRIPFACE_YHIGRIP    4
 137 #define MXT_GRIPFACE_MAXTCHS    5
 138 #define MXT_GRIPFACE_SZTHR1     7
 139 #define MXT_GRIPFACE_SZTHR2     8
 140 #define MXT_GRIPFACE_SHPTHR1    9
 141 #define MXT_GRIPFACE_SHPTHR2    10
 142 #define MXT_GRIPFACE_SUPEXTTO   11
 143
 144 /* MXT_PROCI_NOISE field */
 145 #define MXT_NOISE_CTRL          0
 146 #define MXT_NOISE_OUTFLEN       1
 147 #define MXT_NOISE_GCAFUL_LSB    3
 148 #define MXT_NOISE_GCAFUL_MSB    4
 149 #define MXT_NOISE_GCAFLL_LSB    5
 150 #define MXT_NOISE_GCAFLL_MSB    6
 151 #define MXT_NOISE_ACTVGCAFVALID 7
 152 #define MXT_NOISE_NOISETHR      8
 153 #define MXT_NOISE_FREQHOPSCALE  10
 154 #define MXT_NOISE_FREQ0         11
 155 #define MXT_NOISE_FREQ1         12
 156 #define MXT_NOISE_FREQ2         13
 157 #define MXT_NOISE_FREQ3         14
 158 #define MXT_NOISE_FREQ4         15
 159 #define MXT_NOISE_IDLEGCAFVALID 16
 160
 161 /* MXT_SPT_COMMSCONFIG_T18 */
 162 #define MXT_COMMS_CTRL          0
 163 #define MXT_COMMS_CMD           1
 164
 165 /* MXT_SPT_CTECONFIG_T28 field */
 166 #define MXT_CTE_CTRL            0
 167 #define MXT_CTE_CMD             1
 168 #define MXT_CTE_MODE            2
 169 #define MXT_CTE_IDLEGCAFDEPTH   3
 170 #define MXT_CTE_ACTVGCAFDEPTH   4
 171 #define MXT_CTE_VOLTAGE         5
 172
 173 #define MXT_VOLTAGE_DEFAULT     2700000
 174 #define MXT_VOLTAGE_STEP        10000
 175
 176 /* Define for MXT_GEN_COMMAND_T6 */
 177 #define MXT_BOOT_VALUE          0xa5
 178 #define MXT_BACKUP_VALUE        0x55
 179 #define MXT_BACKUP_TIME         25      /* msec */
 180 #define MXT_RESET_TIME          65      /* msec */
 181
 182 #define MXT_FWRESET_TIME        175     /* msec */
 183
 184 /* Command to unlock bootloader */
 185 #define MXT_UNLOCK_CMD_MSB      0xaa
 186 #define MXT_UNLOCK_CMD_LSB      0xdc
 187
 188 /* Bootloader mode status */
 189 #define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
 190 #define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
 191 #define MXT_FRAME_CRC_CHECK     0x02
 192 #define MXT_FRAME_CRC_FAIL      0x03
 193 #define MXT_FRAME_CRC_PASS      0x04
 194 #define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
 195 #define MXT_BOOT_STATUS_MASK    0x3f
 196
 197 /* Touch status */
 198 #define MXT_UNGRIP              (1 << 0)
 199 #define MXT_SUPPRESS            (1 << 1)
 200 #define MXT_AMP                 (1 << 2)
 201 #define MXT_VECTOR              (1 << 3)
 202 #define MXT_MOVE                (1 << 4)
 203 #define MXT_RELEASE             (1 << 5)
 204 #define MXT_PRESS               (1 << 6)
 205 #define MXT_DETECT              (1 << 7)
 206
 207 /* Touch orient bits */
 208 #define MXT_XY_SWITCH           (1 << 0)
 209 #define MXT_X_INVERT            (1 << 1)
 210 #define MXT_Y_INVERT            (1 << 2)
 211
 212 /* Touchscreen absolute values */
 213 #define MXT_MAX_AREA            0xff
 214
 215 struct mxt_info {
 216         u8 family_id;
 217         u8 variant_id;
 218         u8 version;
 219         u8 build;
 220         u8 matrix_xsize;
 221         u8 matrix_ysize;
 222         u8 object_num;
 223 };
 224
 225 struct mxt_object {
 226         u8 type;
 227         u16 start_address;
 228         u8 size;                /* Size of each instance - 1 */
 229         u8 instances;           /* Number of instances - 1 */
 230         u8 num_report_ids;
 231 } __packed;
 232
 233 struct mxt_message {
 234         u8 reportid;
 235         u8 message[7];
 236 };
 237
 238 /* Each client has this additional data */
 239 struct mxt_data {
 240         struct i2c_client *client;
 241         struct input_dev *input_dev;
 242         char phys[64];          /* device physical location */
 243         const struct mxt_platform_data *pdata;
 244         struct mxt_object *object_table;
 245         struct mxt_info info;
 246         unsigned int irq;
 247         unsigned int max_x;
 248         unsigned int max_y;
 249
 250         /* Cached parameters from object table */
 251         u8 T6_reportid;
 252         u8 T9_reportid_min;
 253         u8 T9_reportid_max;
 254 };
 255
 256 static bool mxt_object_readable(unsigned int type)
 257 {
 258         switch (type) {
 259         case MXT_GEN_COMMAND_T6:
 260         case MXT_GEN_POWER_T7:
 261         case MXT_GEN_ACQUIRE_T8:
 262         case MXT_GEN_DATASOURCE_T53:
 263         case MXT_TOUCH_MULTI_T9:
 264         case MXT_TOUCH_KEYARRAY_T15:
 265         case MXT_TOUCH_PROXIMITY_T23:
 266         case MXT_TOUCH_PROXKEY_T52:
 267         case MXT_PROCI_GRIPFACE_T20:
 268         case MXT_PROCG_NOISE_T22:
 269         case MXT_PROCI_ONETOUCH_T24:
 270         case MXT_PROCI_TWOTOUCH_T27:
 271         case MXT_PROCI_GRIP_T40:
 272         case MXT_PROCI_PALM_T41:
 273         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 274         case MXT_PROCI_STYLUS_T47:
 275         case MXT_PROCG_NOISESUPPRESSION_T48:
 276         case MXT_SPT_COMMSCONFIG_T18:
 277         case MXT_SPT_GPIOPWM_T19:
 278         case MXT_SPT_SELFTEST_T25:
 279         case MXT_SPT_CTECONFIG_T28:
 280         case MXT_SPT_USERDATA_T38:
 281         case MXT_SPT_DIGITIZER_T43:
 282         case MXT_SPT_CTECONFIG_T46:
 283                 return true;
 284         default:
 285                 return false;
 286         }
 287 }
 288
 289 static bool mxt_object_writable(unsigned int type)
 290 {
 291         switch (type) {
 292         case MXT_GEN_COMMAND_T6:
 293         case MXT_GEN_POWER_T7:
 294         case MXT_GEN_ACQUIRE_T8:
 295         case MXT_TOUCH_MULTI_T9:
 296         case MXT_TOUCH_KEYARRAY_T15:
 297         case MXT_TOUCH_PROXIMITY_T23:
 298         case MXT_TOUCH_PROXKEY_T52:
 299         case MXT_PROCI_GRIPFACE_T20:
 300         case MXT_PROCG_NOISE_T22:
 301         case MXT_PROCI_ONETOUCH_T24:
 302         case MXT_PROCI_TWOTOUCH_T27:
 303         case MXT_PROCI_GRIP_T40:
 304         case MXT_PROCI_PALM_T41:
 305         case MXT_PROCI_TOUCHSUPPRESSION_T42:
 306         case MXT_PROCI_STYLUS_T47:
 307         case MXT_PROCG_NOISESUPPRESSION_T48:
 308         case MXT_SPT_COMMSCONFIG_T18:
 309         case MXT_SPT_GPIOPWM_T19:
 310         case MXT_SPT_SELFTEST_T25:
 311         case MXT_SPT_CTECONFIG_T28:
 312         case MXT_SPT_DIGITIZER_T43:
 313         case MXT_SPT_CTECONFIG_T46:
 314                 return true;
 315         default:
 316                 return false;
 317         }
 318 }
 319
 320 static void mxt_dump_message(struct device *dev,
 321                              struct mxt_message *message)
 322 {
 323         dev_dbg(dev, "reportid: %u\tmessage: %*ph\n",
 324                 message->reportid, 7, message->message);
 325 }
 326
 327 static int mxt_check_bootloader(struct i2c_client *client,
 328                                      unsigned int state)
 329 {
 330         u8 val;
 331
 332 recheck:
 333         if (i2c_master_recv(client, &val, 1) != 1) {
 334                 dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
 335                 return -EIO;
 336         }
 337
 338         switch (state) {
 339         case MXT_WAITING_BOOTLOAD_CMD:
 340         case MXT_WAITING_FRAME_DATA:
 341                 val &= ~MXT_BOOT_STATUS_MASK;
 342                 break;
 343         case MXT_FRAME_CRC_PASS:
 344                 if (val == MXT_FRAME_CRC_CHECK)
 345                         goto recheck;
 346                 break;
 347         default:
 348                 return -EINVAL;
 349         }
 350
 351         if (val != state) {
 352                 dev_err(&client->dev, "Unvalid bootloader mode state\n");
 353                 return -EINVAL;
 354         }
 355
 356         return 0;
 357 }
 358
 359 static int mxt_unlock_bootloader(struct i2c_client *client)
 360 {
 361         u8 buf[2];
 362
 363         buf[0] = MXT_UNLOCK_CMD_LSB;
 364         buf[1] = MXT_UNLOCK_CMD_MSB;
 365
 366         if (i2c_master_send(client, buf, 2) != 2) {
 367                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 368                 return -EIO;
 369         }
 370
 371         return 0;
 372 }
 373
 374 static int mxt_fw_write(struct i2c_client *client,
 375                              const u8 *data, unsigned int frame_size)
 376 {
 377         if (i2c_master_send(client, data, frame_size) != frame_size) {
 378                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
 379                 return -EIO;
 380         }
 381
 382         return 0;
 383 }
 384
 385 static int __mxt_read_reg(struct i2c_client *client,
 386                                u16 reg, u16 len, void *val)
 387 {
 388         struct i2c_msg xfer[2];
 389         u8 buf[2];
 390         int ret;
 391
 392         buf[0] = reg & 0xff;
 393         buf[1] = (reg >> 8) & 0xff;
 394
 395         /* Write register */
 396         xfer[0].addr = client->addr;
 397         xfer[0].flags = 0;
 398         xfer[0].len = 2;
 399         xfer[0].buf = buf;
 400
 401         /* Read data */
 402         xfer[1].addr = client->addr;
 403         xfer[1].flags = I2C_M_RD;
 404         xfer[1].len = len;
 405         xfer[1].buf = val;
 406
 407         ret = i2c_transfer(client->adapter, xfer, 2);
 408         if (ret == 2) {
 409                 ret = 0;
 410         } else {
 411                 if (ret >= 0)
 412                         ret = -EIO;
 413                 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
 414                         __func__, ret);
 415         }
 416
 417         return ret;
 418 }
 419
 420 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
 421 {
 422         return __mxt_read_reg(client, reg, 1, val);
 423 }
 424
 425 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 426                            const void *val)
 427 {
 428         u8 *buf;
 429         size_t count;
 430         int ret;
 431
 432         count = len + 2;
 433         buf = kmalloc(count, GFP_KERNEL);
 434         if (!buf)
 435                 return -ENOMEM;
 436
 437         buf[0] = reg & 0xff;
 438         buf[1] = (reg >> 8) & 0xff;
 439         memcpy(&buf[2], val, len);
 440
 441         ret = i2c_master_send(client, buf, count);
 442         if (ret == count) {
 443                 ret = 0;
 444         } else {
 445                 if (ret >= 0)
 446                         ret = -EIO;
 447                 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
 448                         __func__, ret);
 449         }
 450
 451         kfree(buf);
 452         return ret;
 453 }
 454
 455 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 456 {
 457         return __mxt_write_reg(client, reg, 1, &val);
 458 }
 459
 460 static struct mxt_object *
 461 mxt_get_object(struct mxt_data *data, u8 type)
 462 {
 463         struct mxt_object *object;
 464         int i;
 465
 466         for (i = 0; i < data->info.object_num; i++) {
 467                 object = data->object_table + i;
 468                 if (object->type == type)
 469                         return object;
 470         }
 471
 472         dev_err(&data->client->dev, "Invalid object type\n");
 473         return NULL;
 474 }
 475
 476 static int mxt_read_message(struct mxt_data *data,
 477                                  struct mxt_message *message)
 478 {
 479         struct mxt_object *object;
 480         u16 reg;
 481
 482         object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
 483         if (!object)
 484                 return -EINVAL;
 485
 486         reg = object->start_address;
 487         return __mxt_read_reg(data->client, reg,
 488                         sizeof(struct mxt_message), message);
 489 }
 490
 491 static int mxt_write_object(struct mxt_data *data,
 492                                  u8 type, u8 offset, u8 val)
 493 {
 494         struct mxt_object *object;
 495         u16 reg;
 496
 497         object = mxt_get_object(data, type);
 498         if (!object || offset >= object->size + 1)
 499                 return -EINVAL;
 500
 501         reg = object->start_address;
 502         return mxt_write_reg(data->client, reg + offset, val);
 503 }
 504
 505 static void mxt_input_touchevent(struct mxt_data *data,
 506                                       struct mxt_message *message, int id)
 507 {
 508         struct device *dev = &data->client->dev;
 509         u8 status = message->message[0];
 510         struct input_dev *input_dev = data->input_dev;
 511         int x;
 512         int y;
 513         int area;
 514         int pressure;
 515
 516         x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
 517         y = (message->message[2] << 4) | ((message->message[3] & 0xf));
 518         if (data->max_x < 1024)
 519                 x = x >> 2;
 520         if (data->max_y < 1024)
 521                 y = y >> 2;
 522
 523         area = message->message[4];
 524         pressure = message->message[5];
 525
 526         dev_dbg(dev,
 527                 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
 528                 id,
 529                 (status & MXT_DETECT) ? 'D' : '.',
 530                 (status & MXT_PRESS) ? 'P' : '.',
 531                 (status & MXT_RELEASE) ? 'R' : '.',
 532                 (status & MXT_MOVE) ? 'M' : '.',
 533                 (status & MXT_VECTOR) ? 'V' : '.',
 534                 (status & MXT_AMP) ? 'A' : '.',
 535                 (status & MXT_SUPPRESS) ? 'S' : '.',
 536                 (status & MXT_UNGRIP) ? 'U' : '.',
 537                 x, y, area, pressure);
 538
 539         input_mt_slot(input_dev, id);
 540         input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
 541                                    status & MXT_DETECT);
 542
 543         if (status & MXT_DETECT) {
 544                 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 545                 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 546                 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
 547                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 548         }
 549 }
 550
 551 static unsigned mxt_extract_T6_csum(const u8 *csum)
 552 {
 553         return csum[0] | (csum[1] << 8) | (csum[2] << 16);
 554 }
 555
 556 static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
 557 {
 558         u8 id = msg->reportid;
 559         return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
 560 }
 561
 562 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
 563 {
 564         struct mxt_data *data = dev_id;
 565         struct mxt_message message;
 566         const u8 *payload = &message.message[0];
 567         struct device *dev = &data->client->dev;
 568         u8 reportid;
 569         bool update_input = false;
 570
 571         do {
 572                 if (mxt_read_message(data, &message)) {
 573                         dev_err(dev, "Failed to read message\n");
 574                         goto end;
 575                 }
 576
 577                 reportid = message.reportid;
 578
 579                 if (reportid == data->T6_reportid) {
 580                         u8 status = payload[0];
 581                         unsigned csum = mxt_extract_T6_csum(&payload[1]);
 582                         dev_dbg(dev, "Status: %02x Config Checksum: %06x\n",
 583                                 status, csum);
 584                 } else if (mxt_is_T9_message(data, &message)) {
 585                         int id = reportid - data->T9_reportid_min;
 586                         mxt_input_touchevent(data, &message, id);
 587                         update_input = true;
 588                 } else {
 589                         mxt_dump_message(dev, &message);
 590                 }
 591         } while (reportid != 0xff);
 592
 593         if (update_input) {
 594                 input_mt_report_pointer_emulation(data->input_dev, false);
 595                 input_sync(data->input_dev);
 596         }
 597
 598 end:
 599         return IRQ_HANDLED;
 600 }
 601
 602 static int mxt_check_reg_init(struct mxt_data *data)
 603 {
 604         const struct mxt_platform_data *pdata = data->pdata;
 605         struct mxt_object *object;
 606         struct device *dev = &data->client->dev;
 607         int index = 0;
 608         int i, size;
 609         int ret;
 610
 611         if (!pdata->config) {
 612                 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
 613                 return 0;
 614         }
 615
 616         for (i = 0; i < data->info.object_num; i++) {
 617                 object = data->object_table + i;
 618
 619                 if (!mxt_object_writable(object->type))
 620                         continue;
 621
 622                 size = (object->size + 1) * (object->instances + 1);
 623                 if (index + size > pdata->config_length) {
 624                         dev_err(dev, "Not enough config data!\n");
 625                         return -EINVAL;
 626                 }
 627
 628                 ret = __mxt_write_reg(data->client, object->start_address,
 629                                 size, &pdata->config[index]);
 630                 if (ret)
 631                         return ret;
 632                 index += size;
 633         }
 634
 635         return 0;
 636 }
 637
 638 static int mxt_make_highchg(struct mxt_data *data)
 639 {
 640         struct device *dev = &data->client->dev;
 641         struct mxt_message message;
 642         int count = 10;
 643         int error;
 644
 645         /* Read dummy message to make high CHG pin */
 646         do {
 647                 error = mxt_read_message(data, &message);
 648                 if (error)
 649                         return error;
 650         } while (message.reportid != 0xff && --count);
 651
 652         if (!count) {
 653                 dev_err(dev, "CHG pin isn't cleared\n");
 654                 return -EBUSY;
 655         }
 656
 657         return 0;
 658 }
 659
 660 static void mxt_handle_pdata(struct mxt_data *data)
 661 {
 662         const struct mxt_platform_data *pdata = data->pdata;
 663         u8 voltage;
 664
 665         /* Set touchscreen lines */
 666         mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE,
 667                         pdata->x_line);
 668         mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE,
 669                         pdata->y_line);
 670
 671         /* Set touchscreen orient */
 672         mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
 673                         pdata->orient);
 674
 675         /* Set touchscreen burst length */
 676         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 677                         MXT_TOUCH_BLEN, pdata->blen);
 678
 679         /* Set touchscreen threshold */
 680         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 681                         MXT_TOUCH_TCHTHR, pdata->threshold);
 682
 683         /* Set touchscreen resolution */
 684         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 685                         MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
 686         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 687                         MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
 688         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 689                         MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
 690         mxt_write_object(data, MXT_TOUCH_MULTI_T9,
 691                         MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
 692
 693         /* Set touchscreen voltage */
 694         if (pdata->voltage) {
 695                 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
 696                         voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
 697                                 MXT_VOLTAGE_STEP;
 698                         voltage = 0xff - voltage + 1;
 699                 } else
 700                         voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
 701                                 MXT_VOLTAGE_STEP;
 702
 703                 mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
 704                                 MXT_CTE_VOLTAGE, voltage);
 705         }
 706 }
 707
 708 static int mxt_get_info(struct mxt_data *data)
 709 {
 710         struct i2c_client *client = data->client;
 711         struct mxt_info *info = &data->info;
 712         int error;
 713
 714         /* Read 7-byte info block starting at address 0 */
 715         error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
 716         if (error)
 717                 return error;
 718
 719         return 0;
 720 }
 721
 722 static int mxt_get_object_table(struct mxt_data *data)
 723 {
 724         struct i2c_client *client = data->client;
 725         size_t table_size;
 726         int error;
 727         int i;
 728         u8 reportid;
 729
 730         table_size = data->info.object_num * sizeof(struct mxt_object);
 731         error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
 732                         data->object_table);
 733         if (error)
 734                 return error;
 735
 736         /* Valid Report IDs start counting from 1 */
 737         reportid = 1;
 738         for (i = 0; i < data->info.object_num; i++) {
 739                 struct mxt_object *object = data->object_table + i;
 740                 u8 min_id, max_id;
 741
 742                 le16_to_cpus(&object->start_address);
 743
 744                 if (object->num_report_ids) {
 745                         min_id = reportid;
 746                         reportid += object->num_report_ids *
 747                                         (object->instances + 1);
 748                         max_id = reportid - 1;
 749                 } else {
 750                         min_id = 0;
 751                         max_id = 0;
 752                 }
 753
 754                 dev_dbg(&data->client->dev,
 755                         "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
 756                         object->type, object->start_address, object->size + 1,
 757                         object->instances + 1, min_id, max_id);
 758
 759                 switch (object->type) {
 760                 case MXT_GEN_COMMAND_T6:
 761                         data->T6_reportid = min_id;
 762                         break;
 763                 case MXT_TOUCH_MULTI_T9:
 764                         data->T9_reportid_min = min_id;
 765                         data->T9_reportid_max = max_id;
 766                         break;
 767                 }
 768         }
 769
 770         return 0;
 771 }
 772
 773 static void mxt_free_object_table(struct mxt_data *data)
 774 {
 775         kfree(data->object_table);
 776         data->object_table = NULL;
 777         data->T6_reportid = 0;
 778         data->T9_reportid_min = 0;
 779         data->T9_reportid_max = 0;
 780
 781 }
 782
 783 static int mxt_initialize(struct mxt_data *data)
 784 {
 785         struct i2c_client *client = data->client;
 786         struct mxt_info *info = &data->info;
 787         int error;
 788         u8 val;
 789
 790         error = mxt_get_info(data);
 791         if (error)
 792                 return error;
 793
 794         data->object_table = kcalloc(info->object_num,
 795                                      sizeof(struct mxt_object),
 796                                      GFP_KERNEL);
 797         if (!data->object_table) {
 798                 dev_err(&client->dev, "Failed to allocate memory\n");
 799                 return -ENOMEM;
 800         }
 801
 802         /* Get object table information */
 803         error = mxt_get_object_table(data);
 804         if (error)
 805                 goto err_free_object_table;
 806
 807         /* Check register init values */
 808         error = mxt_check_reg_init(data);
 809         if (error)
 810                 goto err_free_object_table;
 811
 812         mxt_handle_pdata(data);
 813
 814         /* Backup to memory */
 815         mxt_write_object(data, MXT_GEN_COMMAND_T6,
 816                         MXT_COMMAND_BACKUPNV,
 817                         MXT_BACKUP_VALUE);
 818         msleep(MXT_BACKUP_TIME);
 819
 820         /* Soft reset */
 821         mxt_write_object(data, MXT_GEN_COMMAND_T6,
 822                         MXT_COMMAND_RESET, 1);
 823         msleep(MXT_RESET_TIME);
 824
 825         /* Update matrix size at info struct */
 826         error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
 827         if (error)
 828                 goto err_free_object_table;
 829         info->matrix_xsize = val;
 830
 831         error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
 832         if (error)
 833                 goto err_free_object_table;
 834         info->matrix_ysize = val;
 835
 836         dev_info(&client->dev,
 837                         "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
 838                         info->family_id, info->variant_id, info->version >> 4,
 839                         info->version & 0xf, info->build);
 840
 841         dev_info(&client->dev,
 842                         "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
 843                         info->matrix_xsize, info->matrix_ysize,
 844                         info->object_num);
 845
 846         return 0;
 847
 848 err_free_object_table:
 849         mxt_free_object_table(data);
 850         return error;
 851 }
 852
 853 static void mxt_calc_resolution(struct mxt_data *data)
 854 {
 855         unsigned int max_x = data->pdata->x_size - 1;
 856         unsigned int max_y = data->pdata->y_size - 1;
 857
 858         if (data->pdata->orient & MXT_XY_SWITCH) {
 859                 data->max_x = max_y;
 860                 data->max_y = max_x;
 861         } else {
 862                 data->max_x = max_x;
 863                 data->max_y = max_y;
 864         }
 865 }
 866
 867 /* Firmware Version is returned as Major.Minor.Build */
 868 static ssize_t mxt_fw_version_show(struct device *dev,
 869                                    struct device_attribute *attr, char *buf)
 870 {
 871         struct mxt_data *data = dev_get_drvdata(dev);
 872         struct mxt_info *info = &data->info;
 873         return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
 874                          info->version >> 4, info->version & 0xf, info->build);
 875 }
 876
 877 /* Hardware Version is returned as FamilyID.VariantID */
 878 static ssize_t mxt_hw_version_show(struct device *dev,
 879                                    struct device_attribute *attr, char *buf)
 880 {
 881         struct mxt_data *data = dev_get_drvdata(dev);
 882         struct mxt_info *info = &data->info;
 883         return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
 884                          info->family_id, info->variant_id);
 885 }
 886
 887 static ssize_t mxt_show_instance(char *buf, int count,
 888                                  struct mxt_object *object, int instance,
 889                                  const u8 *val)
 890 {
 891         int i;
 892
 893         if (object->instances > 0)
 894                 count += scnprintf(buf + count, PAGE_SIZE - count,
 895                                    "Instance %u\n", instance);
 896
 897         for (i = 0; i < object->size + 1; i++)
 898                 count += scnprintf(buf + count, PAGE_SIZE - count,
 899                                 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
 900         count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
 901
 902         return count;
 903 }
 904
 905 static ssize_t mxt_object_show(struct device *dev,
 906                                     struct device_attribute *attr, char *buf)
 907 {
 908         struct mxt_data *data = dev_get_drvdata(dev);
 909         struct mxt_object *object;
 910         int count = 0;
 911         int i, j;
 912         int error;
 913         u8 *obuf;
 914
 915         /* Pre-allocate buffer large enough to hold max sized object. */
 916         obuf = kmalloc(256, GFP_KERNEL);
 917         if (!obuf)
 918                 return -ENOMEM;
 919
 920         error = 0;
 921         for (i = 0; i < data->info.object_num; i++) {
 922                 object = data->object_table + i;
 923
 924                 if (!mxt_object_readable(object->type))
 925                         continue;
 926
 927                 count += scnprintf(buf + count, PAGE_SIZE - count,
 928                                 "T%u:\n", object->type);
 929
 930                 for (j = 0; j < object->instances + 1; j++) {
 931                         u16 size = object->size + 1;
 932                         u16 addr = object->start_address + j * size;
 933
 934                         error = __mxt_read_reg(data->client, addr, size, obuf);
 935                         if (error)
 936                                 goto done;
 937
 938                         count = mxt_show_instance(buf, count, object, j, obuf);
 939                 }
 940         }
 941
 942 done:
 943         kfree(obuf);
 944         return error ?: count;
 945 }
 946
 947 static int mxt_load_fw(struct device *dev, const char *fn)
 948 {
 949         struct mxt_data *data = dev_get_drvdata(dev);
 950         struct i2c_client *client = data->client;
 951         const struct firmware *fw = NULL;
 952         unsigned int frame_size;
 953         unsigned int pos = 0;
 954         int ret;
 955
 956         ret = request_firmware(&fw, fn, dev);
 957         if (ret) {
 958                 dev_err(dev, "Unable to open firmware %s\n", fn);
 959                 return ret;
 960         }
 961
 962         /* Change to the bootloader mode */
 963         mxt_write_object(data, MXT_GEN_COMMAND_T6,
 964                         MXT_COMMAND_RESET, MXT_BOOT_VALUE);
 965         msleep(MXT_RESET_TIME);
 966
 967         /* Change to slave address of bootloader */
 968         if (client->addr == MXT_APP_LOW)
 969                 client->addr = MXT_BOOT_LOW;
 970         else
 971                 client->addr = MXT_BOOT_HIGH;
 972
 973         ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
 974         if (ret)
 975                 goto out;
 976
 977         /* Unlock bootloader */
 978         mxt_unlock_bootloader(client);
 979
 980         while (pos < fw->size) {
 981                 ret = mxt_check_bootloader(client,
 982                                                 MXT_WAITING_FRAME_DATA);
 983                 if (ret)
 984                         goto out;
 985
 986                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
 987
 988                 /* We should add 2 at frame size as the the firmware data is not
 989                  * included the CRC bytes.
 990                  */
 991                 frame_size += 2;
 992
 993                 /* Write one frame to device */
 994                 mxt_fw_write(client, fw->data + pos, frame_size);
 995
 996                 ret = mxt_check_bootloader(client,
 997                                                 MXT_FRAME_CRC_PASS);
 998                 if (ret)
 999                         goto out;
1000
1001                 pos += frame_size;
1002
1003                 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
1004         }
1005
1006 out:
1007         release_firmware(fw);
1008
1009         /* Change to slave address of application */
1010         if (client->addr == MXT_BOOT_LOW)
1011                 client->addr = MXT_APP_LOW;
1012         else
1013                 client->addr = MXT_APP_HIGH;
1014
1015         return ret;
1016 }
1017
1018 static ssize_t mxt_update_fw_store(struct device *dev,
1019                                         struct device_attribute *attr,
1020                                         const char *buf, size_t count)
1021 {
1022         struct mxt_data *data = dev_get_drvdata(dev);
1023         int error;
1024
1025         disable_irq(data->irq);
1026
1027         error = mxt_load_fw(dev, MXT_FW_NAME);
1028         if (error) {
1029                 dev_err(dev, "The firmware update failed(%d)\n", error);
1030                 count = error;
1031         } else {
1032                 dev_dbg(dev, "The firmware update succeeded\n");
1033
1034                 /* Wait for reset */
1035                 msleep(MXT_FWRESET_TIME);
1036
1037                 mxt_free_object_table(data);
1038
1039                 mxt_initialize(data);
1040         }
1041
1042         enable_irq(data->irq);
1043
1044         error = mxt_make_highchg(data);
1045         if (error)
1046                 return error;
1047
1048         return count;
1049 }
1050
1051 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1052 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1053 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1054 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1055
1056 static struct attribute *mxt_attrs[] = {
1057         &dev_attr_fw_version.attr,
1058         &dev_attr_hw_version.attr,
1059         &dev_attr_object.attr,
1060         &dev_attr_update_fw.attr,
1061         NULL
1062 };
1063
1064 static const struct attribute_group mxt_attr_group = {
1065         .attrs = mxt_attrs,
1066 };
1067
1068 static void mxt_start(struct mxt_data *data)
1069 {
1070         /* Touch enable */
1071         mxt_write_object(data,
1072                         MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
1073 }
1074
1075 static void mxt_stop(struct mxt_data *data)
1076 {
1077         /* Touch disable */
1078         mxt_write_object(data,
1079                         MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1080 }
1081
1082 static int mxt_input_open(struct input_dev *dev)
1083 {
1084         struct mxt_data *data = input_get_drvdata(dev);
1085
1086         mxt_start(data);
1087
1088         return 0;
1089 }
1090
1091 static void mxt_input_close(struct input_dev *dev)
1092 {
1093         struct mxt_data *data = input_get_drvdata(dev);
1094
1095         mxt_stop(data);
1096 }
1097
1098 static int mxt_probe(struct i2c_client *client,
1099                 const struct i2c_device_id *id)
1100 {
1101         const struct mxt_platform_data *pdata = client->dev.platform_data;
1102         struct mxt_data *data;
1103         struct input_dev *input_dev;
1104         int error;
1105         unsigned int num_mt_slots;
1106
1107         if (!pdata)
1108                 return -EINVAL;
1109
1110         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1111         input_dev = input_allocate_device();
1112         if (!data || !input_dev) {
1113                 dev_err(&client->dev, "Failed to allocate memory\n");
1114                 error = -ENOMEM;
1115                 goto err_free_mem;
1116         }
1117
1118         input_dev->name = "Atmel maXTouch Touchscreen";
1119         snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1120                  client->adapter->nr, client->addr);
1121         input_dev->phys = data->phys;
1122
1123         input_dev->id.bustype = BUS_I2C;
1124         input_dev->dev.parent = &client->dev;
1125         input_dev->open = mxt_input_open;
1126         input_dev->close = mxt_input_close;
1127
1128         data->client = client;
1129         data->input_dev = input_dev;
1130         data->pdata = pdata;
1131         data->irq = client->irq;
1132
1133         mxt_calc_resolution(data);
1134
1135         error = mxt_initialize(data);
1136         if (error)
1137                 goto err_free_mem;
1138
1139         __set_bit(EV_ABS, input_dev->evbit);
1140         __set_bit(EV_KEY, input_dev->evbit);
1141         __set_bit(BTN_TOUCH, input_dev->keybit);
1142
1143         /* For single touch */
1144         input_set_abs_params(input_dev, ABS_X,
1145                              0, data->max_x, 0, 0);
1146         input_set_abs_params(input_dev, ABS_Y,
1147                              0, data->max_y, 0, 0);
1148         input_set_abs_params(input_dev, ABS_PRESSURE,
1149                              0, 255, 0, 0);
1150
1151         /* For multi touch */
1152         num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1153         error = input_mt_init_slots(input_dev, num_mt_slots, 0);
1154         if (error)
1155                 goto err_free_object;
1156         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1157                              0, MXT_MAX_AREA, 0, 0);
1158         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1159                              0, data->max_x, 0, 0);
1160         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1161                              0, data->max_y, 0, 0);
1162         input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1163                              0, 255, 0, 0);
1164
1165         input_set_drvdata(input_dev, data);
1166         i2c_set_clientdata(client, data);
1167
1168         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1169                                      pdata->irqflags | IRQF_ONESHOT,
1170                                      client->name, data);
1171         if (error) {
1172                 dev_err(&client->dev, "Failed to register interrupt\n");
1173                 goto err_free_object;
1174         }
1175
1176         error = mxt_make_highchg(data);
1177         if (error)
1178                 goto err_free_irq;
1179
1180         error = input_register_device(input_dev);
1181         if (error)
1182                 goto err_free_irq;
1183
1184         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1185         if (error)
1186                 goto err_unregister_device;
1187
1188         return 0;
1189
1190 err_unregister_device:
1191         input_unregister_device(input_dev);
1192         input_dev = NULL;
1193 err_free_irq:
1194         free_irq(client->irq, data);
1195 err_free_object:
1196         kfree(data->object_table);
1197 err_free_mem:
1198         input_free_device(input_dev);
1199         kfree(data);
1200         return error;
1201 }
1202
1203 static int mxt_remove(struct i2c_client *client)
1204 {
1205         struct mxt_data *data = i2c_get_clientdata(client);
1206
1207         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1208         free_irq(data->irq, data);
1209         input_unregister_device(data->input_dev);
1210         kfree(data->object_table);
1211         kfree(data);
1212
1213         return 0;
1214 }
1215
1216 #ifdef CONFIG_PM_SLEEP
1217 static int mxt_suspend(struct device *dev)
1218 {
1219         struct i2c_client *client = to_i2c_client(dev);
1220         struct mxt_data *data = i2c_get_clientdata(client);
1221         struct input_dev *input_dev = data->input_dev;
1222
1223         mutex_lock(&input_dev->mutex);
1224
1225         if (input_dev->users)
1226                 mxt_stop(data);
1227
1228         mutex_unlock(&input_dev->mutex);
1229
1230         return 0;
1231 }
1232
1233 static int mxt_resume(struct device *dev)
1234 {
1235         struct i2c_client *client = to_i2c_client(dev);
1236         struct mxt_data *data = i2c_get_clientdata(client);
1237         struct input_dev *input_dev = data->input_dev;
1238
1239         /* Soft reset */
1240         mxt_write_object(data, MXT_GEN_COMMAND_T6,
1241                         MXT_COMMAND_RESET, 1);
1242
1243         msleep(MXT_RESET_TIME);
1244
1245         mutex_lock(&input_dev->mutex);
1246
1247         if (input_dev->users)
1248                 mxt_start(data);
1249
1250         mutex_unlock(&input_dev->mutex);
1251
1252         return 0;
1253 }
1254 #endif
1255
1256 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1257
1258 static const struct i2c_device_id mxt_id[] = {
1259         { "qt602240_ts", 0 },
1260         { "atmel_mxt_ts", 0 },
1261         { "mXT224", 0 },
1262         { }
1263 };
1264 MODULE_DEVICE_TABLE(i2c, mxt_id);
1265
1266 static struct i2c_driver mxt_driver = {
1267         .driver = {
1268                 .name   = "atmel_mxt_ts",
1269                 .owner  = THIS_MODULE,
1270                 .pm     = &mxt_pm_ops,
1271         },
1272         .probe          = mxt_probe,
1273         .remove         = mxt_remove,
1274         .id_table       = mxt_id,
1275 };
1276
1277 module_i2c_driver(mxt_driver);
1278
1279 /* Module information */
1280 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1281 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1282 MODULE_LICENSE("GPL");