drivers/input/touchscreen/wdt87xx_i2c.c

   1 /*
   2  * Weida HiTech WDT87xx TouchScreen I2C driver
   3  *
   4  * Copyright (c) 2015  Weida Hi-Tech Co., Ltd.
   5  * HN Chen <[email protected]>
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  */
  11
  12 #include <linux/i2c.h>
  13 #include <linux/input.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/delay.h>
  16 #include <linux/irq.h>
  17 #include <linux/io.h>
  18 #include <linux/module.h>
  19 #include <linux/slab.h>
  20 #include <linux/firmware.h>
  21 #include <linux/input/mt.h>
  22 #include <linux/acpi.h>
  23 #include <asm/unaligned.h>
  24
  25 #define WDT87XX_NAME            "wdt87xx_i2c"
  26 #define WDT87XX_FW_NAME         "wdt87xx_fw.bin"
  27 #define WDT87XX_CFG_NAME        "wdt87xx_cfg.bin"
  28
  29 #define MODE_ACTIVE                     0x01
  30 #define MODE_READY                      0x02
  31 #define MODE_IDLE                       0x03
  32 #define MODE_SLEEP                      0x04
  33 #define MODE_STOP                       0xFF
  34
  35 #define WDT_MAX_FINGER                  10
  36 #define WDT_RAW_BUF_COUNT               54
  37 #define WDT_V1_RAW_BUF_COUNT            74
  38 #define WDT_FIRMWARE_ID                 0xa9e368f5
  39
  40 #define PG_SIZE                         0x1000
  41 #define MAX_RETRIES                     3
  42
  43 #define MAX_UNIT_AXIS                   0x7FFF
  44
  45 #define PKT_READ_SIZE                   72
  46 #define PKT_WRITE_SIZE                  80
  47
  48 /* the finger definition of the report event */
  49 #define FINGER_EV_OFFSET_ID             0
  50 #define FINGER_EV_OFFSET_X              1
  51 #define FINGER_EV_OFFSET_Y              3
  52 #define FINGER_EV_SIZE                  5
  53
  54 #define FINGER_EV_V1_OFFSET_ID          0
  55 #define FINGER_EV_V1_OFFSET_W           1
  56 #define FINGER_EV_V1_OFFSET_P           2
  57 #define FINGER_EV_V1_OFFSET_X           3
  58 #define FINGER_EV_V1_OFFSET_Y           5
  59 #define FINGER_EV_V1_SIZE               7
  60
  61 /* The definition of a report packet */
  62 #define TOUCH_PK_OFFSET_REPORT_ID       0
  63 #define TOUCH_PK_OFFSET_EVENT           1
  64 #define TOUCH_PK_OFFSET_SCAN_TIME       51
  65 #define TOUCH_PK_OFFSET_FNGR_NUM        53
  66
  67 #define TOUCH_PK_V1_OFFSET_REPORT_ID    0
  68 #define TOUCH_PK_V1_OFFSET_EVENT        1
  69 #define TOUCH_PK_V1_OFFSET_SCAN_TIME    71
  70 #define TOUCH_PK_V1_OFFSET_FNGR_NUM     73
  71
  72 /* The definition of the controller parameters */
  73 #define CTL_PARAM_OFFSET_FW_ID          0
  74 #define CTL_PARAM_OFFSET_PLAT_ID        2
  75 #define CTL_PARAM_OFFSET_XMLS_ID1       4
  76 #define CTL_PARAM_OFFSET_XMLS_ID2       6
  77 #define CTL_PARAM_OFFSET_PHY_CH_X       8
  78 #define CTL_PARAM_OFFSET_PHY_CH_Y       10
  79 #define CTL_PARAM_OFFSET_PHY_X0         12
  80 #define CTL_PARAM_OFFSET_PHY_X1         14
  81 #define CTL_PARAM_OFFSET_PHY_Y0         16
  82 #define CTL_PARAM_OFFSET_PHY_Y1         18
  83 #define CTL_PARAM_OFFSET_PHY_W          22
  84 #define CTL_PARAM_OFFSET_PHY_H          24
  85 #define CTL_PARAM_OFFSET_FACTOR         32
  86
  87 /* The definition of the device descriptor */
  88 #define WDT_GD_DEVICE                   1
  89 #define DEV_DESC_OFFSET_VID             8
  90 #define DEV_DESC_OFFSET_PID             10
  91
  92 /* Communication commands */
  93 #define PACKET_SIZE                     56
  94 #define VND_REQ_READ                    0x06
  95 #define VND_READ_DATA                   0x07
  96 #define VND_REQ_WRITE                   0x08
  97
  98 #define VND_CMD_START                   0x00
  99 #define VND_CMD_STOP                    0x01
 100 #define VND_CMD_RESET                   0x09
 101
 102 #define VND_CMD_ERASE                   0x1A
 103
 104 #define VND_GET_CHECKSUM                0x66
 105
 106 #define VND_SET_DATA                    0x83
 107 #define VND_SET_COMMAND_DATA            0x84
 108 #define VND_SET_CHECKSUM_CALC           0x86
 109 #define VND_SET_CHECKSUM_LENGTH         0x87
 110
 111 #define VND_CMD_SFLCK                   0xFC
 112 #define VND_CMD_SFUNL                   0xFD
 113
 114 #define CMD_SFLCK_KEY                   0xC39B
 115 #define CMD_SFUNL_KEY                   0x95DA
 116
 117 #define STRIDX_PLATFORM_ID              0x80
 118 #define STRIDX_PARAMETERS               0x81
 119
 120 #define CMD_BUF_SIZE                    8
 121 #define PKT_BUF_SIZE                    64
 122
 123 /* The definition of the command packet */
 124 #define CMD_REPORT_ID_OFFSET            0x0
 125 #define CMD_TYPE_OFFSET                 0x1
 126 #define CMD_INDEX_OFFSET                0x2
 127 #define CMD_KEY_OFFSET                  0x3
 128 #define CMD_LENGTH_OFFSET               0x4
 129 #define CMD_DATA_OFFSET                 0x8
 130
 131 /* The definition of firmware chunk tags */
 132 #define FOURCC_ID_RIFF                  0x46464952
 133 #define FOURCC_ID_WHIF                  0x46494857
 134 #define FOURCC_ID_FRMT                  0x544D5246
 135 #define FOURCC_ID_FRWR                  0x52575246
 136 #define FOURCC_ID_CNFG                  0x47464E43
 137
 138 #define CHUNK_ID_FRMT                   FOURCC_ID_FRMT
 139 #define CHUNK_ID_FRWR                   FOURCC_ID_FRWR
 140 #define CHUNK_ID_CNFG                   FOURCC_ID_CNFG
 141
 142 #define FW_FOURCC1_OFFSET               0
 143 #define FW_SIZE_OFFSET                  4
 144 #define FW_FOURCC2_OFFSET               8
 145 #define FW_PAYLOAD_OFFSET               40
 146
 147 #define FW_CHUNK_ID_OFFSET              0
 148 #define FW_CHUNK_SIZE_OFFSET            4
 149 #define FW_CHUNK_TGT_START_OFFSET       8
 150 #define FW_CHUNK_PAYLOAD_LEN_OFFSET     12
 151 #define FW_CHUNK_SRC_START_OFFSET       16
 152 #define FW_CHUNK_VERSION_OFFSET         20
 153 #define FW_CHUNK_ATTR_OFFSET            24
 154 #define FW_CHUNK_PAYLOAD_OFFSET         32
 155
 156 /* Controller requires minimum 300us between commands */
 157 #define WDT_COMMAND_DELAY_MS            2
 158 #define WDT_FLASH_WRITE_DELAY_MS        4
 159 #define WDT_FLASH_ERASE_DELAY_MS        200
 160 #define WDT_FW_RESET_TIME               2500
 161
 162 struct wdt87xx_sys_param {
 163         u16     fw_id;
 164         u16     plat_id;
 165         u16     xmls_id1;
 166         u16     xmls_id2;
 167         u16     phy_ch_x;
 168         u16     phy_ch_y;
 169         u16     phy_w;
 170         u16     phy_h;
 171         u16     scaling_factor;
 172         u32     max_x;
 173         u32     max_y;
 174         u16     vendor_id;
 175         u16     product_id;
 176 };
 177
 178 struct wdt87xx_data {
 179         struct i2c_client               *client;
 180         struct input_dev                *input;
 181         /* Mutex for fw update to prevent concurrent access */
 182         struct mutex                    fw_mutex;
 183         struct wdt87xx_sys_param        param;
 184         u8                              phys[32];
 185 };
 186
 187 static int wdt87xx_i2c_xfer(struct i2c_client *client,
 188                             void *txdata, size_t txlen,
 189                             void *rxdata, size_t rxlen)
 190 {
 191         struct i2c_msg msgs[] = {
 192                 {
 193                         .addr   = client->addr,
 194                         .flags  = 0,
 195                         .len    = txlen,
 196                         .buf    = txdata,
 197                 },
 198                 {
 199                         .addr   = client->addr,
 200                         .flags  = I2C_M_RD,
 201                         .len    = rxlen,
 202                         .buf    = rxdata,
 203                 },
 204         };
 205         int error;
 206         int ret;
 207
 208         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 209         if (ret != ARRAY_SIZE(msgs)) {
 210                 error = ret < 0 ? ret : -EIO;
 211                 dev_err(&client->dev, "%s: i2c transfer failed: %d\n",
 212                         __func__, error);
 213                 return error;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int wdt87xx_get_desc(struct i2c_client *client, u8 desc_idx,
 220                             u8 *buf, size_t len)
 221 {
 222         u8 tx_buf[] = { 0x22, 0x00, 0x10, 0x0E, 0x23, 0x00 };
 223         int error;
 224
 225         tx_buf[2] |= desc_idx & 0xF;
 226
 227         error = wdt87xx_i2c_xfer(client, tx_buf, sizeof(tx_buf),
 228                                  buf, len);
 229         if (error) {
 230                 dev_err(&client->dev, "get desc failed: %d\n", error);
 231                 return error;
 232         }
 233
 234         if (buf[0] != len) {
 235                 dev_err(&client->dev, "unexpected response to get desc: %d\n",
 236                         buf[0]);
 237                 return -EINVAL;
 238         }
 239
 240         mdelay(WDT_COMMAND_DELAY_MS);
 241
 242         return 0;
 243 }
 244
 245 static int wdt87xx_get_string(struct i2c_client *client, u8 str_idx,
 246                               u8 *buf, size_t len)
 247 {
 248         u8 tx_buf[] = { 0x22, 0x00, 0x13, 0x0E, str_idx, 0x23, 0x00 };
 249         u8 rx_buf[PKT_WRITE_SIZE];
 250         size_t rx_len = len + 2;
 251         int error;
 252
 253         if (rx_len > sizeof(rx_buf))
 254                 return -EINVAL;
 255
 256         error = wdt87xx_i2c_xfer(client, tx_buf, sizeof(tx_buf),
 257                                  rx_buf, rx_len);
 258         if (error) {
 259                 dev_err(&client->dev, "get string failed: %d\n", error);
 260                 return error;
 261         }
 262
 263         if (rx_buf[1] != 0x03) {
 264                 dev_err(&client->dev, "unexpected response to get string: %d\n",
 265                         rx_buf[1]);
 266                 return -EINVAL;
 267         }
 268
 269         rx_len = min_t(size_t, len, rx_buf[0]);
 270         memcpy(buf, &rx_buf[2], rx_len);
 271
 272         mdelay(WDT_COMMAND_DELAY_MS);
 273
 274         return 0;
 275 }
 276
 277 static int wdt87xx_get_feature(struct i2c_client *client,
 278                                u8 *buf, size_t buf_size)
 279 {
 280         u8 tx_buf[8];
 281         u8 rx_buf[PKT_WRITE_SIZE];
 282         size_t tx_len = 0;
 283         size_t rx_len = buf_size + 2;
 284         int error;
 285
 286         if (rx_len > sizeof(rx_buf))
 287                 return -EINVAL;
 288
 289         /* Get feature command packet */
 290         tx_buf[tx_len++] = 0x22;
 291         tx_buf[tx_len++] = 0x00;
 292         if (buf[CMD_REPORT_ID_OFFSET] > 0xF) {
 293                 tx_buf[tx_len++] = 0x30;
 294                 tx_buf[tx_len++] = 0x02;
 295                 tx_buf[tx_len++] = buf[CMD_REPORT_ID_OFFSET];
 296         } else {
 297                 tx_buf[tx_len++] = 0x30 | buf[CMD_REPORT_ID_OFFSET];
 298                 tx_buf[tx_len++] = 0x02;
 299         }
 300         tx_buf[tx_len++] = 0x23;
 301         tx_buf[tx_len++] = 0x00;
 302
 303         error = wdt87xx_i2c_xfer(client, tx_buf, tx_len, rx_buf, rx_len);
 304         if (error) {
 305                 dev_err(&client->dev, "get feature failed: %d\n", error);
 306                 return error;
 307         }
 308
 309         rx_len = min_t(size_t, buf_size, get_unaligned_le16(rx_buf));
 310         memcpy(buf, &rx_buf[2], rx_len);
 311
 312         mdelay(WDT_COMMAND_DELAY_MS);
 313
 314         return 0;
 315 }
 316
 317 static int wdt87xx_set_feature(struct i2c_client *client,
 318                                const u8 *buf, size_t buf_size)
 319 {
 320         u8 tx_buf[PKT_WRITE_SIZE];
 321         int tx_len = 0;
 322         int error;
 323
 324         /* Set feature command packet */
 325         tx_buf[tx_len++] = 0x22;
 326         tx_buf[tx_len++] = 0x00;
 327         if (buf[CMD_REPORT_ID_OFFSET] > 0xF) {
 328                 tx_buf[tx_len++] = 0x30;
 329                 tx_buf[tx_len++] = 0x03;
 330                 tx_buf[tx_len++] = buf[CMD_REPORT_ID_OFFSET];
 331         } else {
 332                 tx_buf[tx_len++] = 0x30 | buf[CMD_REPORT_ID_OFFSET];
 333                 tx_buf[tx_len++] = 0x03;
 334         }
 335         tx_buf[tx_len++] = 0x23;
 336         tx_buf[tx_len++] = 0x00;
 337         tx_buf[tx_len++] = (buf_size & 0xFF);
 338         tx_buf[tx_len++] = ((buf_size & 0xFF00) >> 8);
 339
 340         if (tx_len + buf_size > sizeof(tx_buf))
 341                 return -EINVAL;
 342
 343         memcpy(&tx_buf[tx_len], buf, buf_size);
 344         tx_len += buf_size;
 345
 346         error = i2c_master_send(client, tx_buf, tx_len);
 347         if (error < 0) {
 348                 dev_err(&client->dev, "set feature failed: %d\n", error);
 349                 return error;
 350         }
 351
 352         mdelay(WDT_COMMAND_DELAY_MS);
 353
 354         return 0;
 355 }
 356
 357 static int wdt87xx_send_command(struct i2c_client *client, int cmd, int value)
 358 {
 359         u8 cmd_buf[CMD_BUF_SIZE];
 360
 361         /* Set the command packet */
 362         cmd_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_WRITE;
 363         cmd_buf[CMD_TYPE_OFFSET] = VND_SET_COMMAND_DATA;
 364         put_unaligned_le16((u16)cmd, &cmd_buf[CMD_INDEX_OFFSET]);
 365
 366         switch (cmd) {
 367         case VND_CMD_START:
 368         case VND_CMD_STOP:
 369         case VND_CMD_RESET:
 370                 /* Mode selector */
 371                 put_unaligned_le32((value & 0xFF), &cmd_buf[CMD_LENGTH_OFFSET]);
 372                 break;
 373
 374         case VND_CMD_SFLCK:
 375                 put_unaligned_le16(CMD_SFLCK_KEY, &cmd_buf[CMD_KEY_OFFSET]);
 376                 break;
 377
 378         case VND_CMD_SFUNL:
 379                 put_unaligned_le16(CMD_SFUNL_KEY, &cmd_buf[CMD_KEY_OFFSET]);
 380                 break;
 381
 382         case VND_CMD_ERASE:
 383         case VND_SET_CHECKSUM_CALC:
 384         case VND_SET_CHECKSUM_LENGTH:
 385                 put_unaligned_le32(value, &cmd_buf[CMD_KEY_OFFSET]);
 386                 break;
 387
 388         default:
 389                 cmd_buf[CMD_REPORT_ID_OFFSET] = 0;
 390                 dev_err(&client->dev, "Invalid command: %d\n", cmd);
 391                 return -EINVAL;
 392         }
 393
 394         return wdt87xx_set_feature(client, cmd_buf, sizeof(cmd_buf));
 395 }
 396
 397 static int wdt87xx_sw_reset(struct i2c_client *client)
 398 {
 399         int error;
 400
 401         dev_dbg(&client->dev, "resetting device now\n");
 402
 403         error = wdt87xx_send_command(client, VND_CMD_RESET, 0);
 404         if (error) {
 405                 dev_err(&client->dev, "reset failed\n");
 406                 return error;
 407         }
 408
 409         /* Wait the device to be ready */
 410         msleep(WDT_FW_RESET_TIME);
 411
 412         return 0;
 413 }
 414
 415 static const void *wdt87xx_get_fw_chunk(const struct firmware *fw, u32 id)
 416 {
 417         size_t pos = FW_PAYLOAD_OFFSET;
 418         u32 chunk_id, chunk_size;
 419
 420         while (pos < fw->size) {
 421                 chunk_id = get_unaligned_le32(fw->data +
 422                                               pos + FW_CHUNK_ID_OFFSET);
 423                 if (chunk_id == id)
 424                         return fw->data + pos;
 425
 426                 chunk_size = get_unaligned_le32(fw->data +
 427                                                 pos + FW_CHUNK_SIZE_OFFSET);
 428                 pos += chunk_size + 2 * sizeof(u32); /* chunk ID + size */
 429         }
 430
 431         return NULL;
 432 }
 433
 434 static int wdt87xx_get_sysparam(struct i2c_client *client,
 435                                 struct wdt87xx_sys_param *param)
 436 {
 437         u8 buf[PKT_READ_SIZE];
 438         int error;
 439
 440         error = wdt87xx_get_desc(client, WDT_GD_DEVICE, buf, 18);
 441         if (error) {
 442                 dev_err(&client->dev, "failed to get device desc\n");
 443                 return error;
 444         }
 445
 446         param->vendor_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_VID);
 447         param->product_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_PID);
 448
 449         error = wdt87xx_get_string(client, STRIDX_PARAMETERS, buf, 34);
 450         if (error) {
 451                 dev_err(&client->dev, "failed to get parameters\n");
 452                 return error;
 453         }
 454
 455         param->xmls_id1 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID1);
 456         param->xmls_id2 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID2);
 457         param->phy_ch_x = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_CH_X);
 458         param->phy_ch_y = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_CH_Y);
 459         param->phy_w = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_W) / 10;
 460         param->phy_h = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_H) / 10;
 461
 462         /* Get the scaling factor of pixel to logical coordinate */
 463         param->scaling_factor =
 464                         get_unaligned_le16(buf + CTL_PARAM_OFFSET_FACTOR);
 465
 466         param->max_x = MAX_UNIT_AXIS;
 467         param->max_y = DIV_ROUND_CLOSEST(MAX_UNIT_AXIS * param->phy_h,
 468                                          param->phy_w);
 469
 470         error = wdt87xx_get_string(client, STRIDX_PLATFORM_ID, buf, 8);
 471         if (error) {
 472                 dev_err(&client->dev, "failed to get platform id\n");
 473                 return error;
 474         }
 475
 476         param->plat_id = buf[1];
 477
 478         buf[0] = 0xf2;
 479         error = wdt87xx_get_feature(client, buf, 16);
 480         if (error) {
 481                 dev_err(&client->dev, "failed to get firmware id\n");
 482                 return error;
 483         }
 484
 485         if (buf[0] != 0xf2) {
 486                 dev_err(&client->dev, "wrong id of fw response: 0x%x\n",
 487                         buf[0]);
 488                 return -EINVAL;
 489         }
 490
 491         param->fw_id = get_unaligned_le16(&buf[1]);
 492
 493         dev_info(&client->dev,
 494                  "fw_id: 0x%x, plat_id: 0x%x, xml_id1: %04x, xml_id2: %04x\n",
 495                  param->fw_id, param->plat_id,
 496                  param->xmls_id1, param->xmls_id2);
 497
 498         return 0;
 499 }
 500
 501 static int wdt87xx_validate_firmware(struct wdt87xx_data *wdt,
 502                                      const struct firmware *fw)
 503 {
 504         const void *fw_chunk;
 505         u32 data1, data2;
 506         u32 size;
 507         u8 fw_chip_id;
 508         u8 chip_id;
 509
 510         data1 = get_unaligned_le32(fw->data + FW_FOURCC1_OFFSET);
 511         data2 = get_unaligned_le32(fw->data + FW_FOURCC2_OFFSET);
 512         if (data1 != FOURCC_ID_RIFF || data2 != FOURCC_ID_WHIF) {
 513                 dev_err(&wdt->client->dev, "check fw tag failed\n");
 514                 return -EINVAL;
 515         }
 516
 517         size = get_unaligned_le32(fw->data + FW_SIZE_OFFSET);
 518         if (size != fw->size) {
 519                 dev_err(&wdt->client->dev,
 520                         "fw size mismatch: expected %d, actual %zu\n",
 521                         size, fw->size);
 522                 return -EINVAL;
 523         }
 524
 525         /*
 526          * Get the chip_id from the firmware. Make sure that it is the
 527          * right controller to do the firmware and config update.
 528          */
 529         fw_chunk = wdt87xx_get_fw_chunk(fw, CHUNK_ID_FRWR);
 530         if (!fw_chunk) {
 531                 dev_err(&wdt->client->dev,
 532                         "unable to locate firmware chunk\n");
 533                 return -EINVAL;
 534         }
 535
 536         fw_chip_id = (get_unaligned_le32(fw_chunk +
 537                                          FW_CHUNK_VERSION_OFFSET) >> 12) & 0xF;
 538         chip_id = (wdt->param.fw_id >> 12) & 0xF;
 539
 540         if (fw_chip_id != chip_id) {
 541                 dev_err(&wdt->client->dev,
 542                         "fw version mismatch: fw %d vs. chip %d\n",
 543                         fw_chip_id, chip_id);
 544                 return -ENODEV;
 545         }
 546
 547         return 0;
 548 }
 549
 550 static int wdt87xx_validate_fw_chunk(const void *data, int id)
 551 {
 552         if (id == CHUNK_ID_FRWR) {
 553                 u32 fw_id;
 554
 555                 fw_id = get_unaligned_le32(data + FW_CHUNK_PAYLOAD_OFFSET);
 556                 if (fw_id != WDT_FIRMWARE_ID)
 557                         return -EINVAL;
 558         }
 559
 560         return 0;
 561 }
 562
 563 static int wdt87xx_write_data(struct i2c_client *client, const char *data,
 564                               u32 address, int length)
 565 {
 566         u16 packet_size;
 567         int count = 0;
 568         int error;
 569         u8 pkt_buf[PKT_BUF_SIZE];
 570
 571         /* Address and length should be 4 bytes aligned */
 572         if ((address & 0x3) != 0 || (length & 0x3) != 0) {
 573                 dev_err(&client->dev,
 574                         "addr & len must be 4 bytes aligned %x, %x\n",
 575                         address, length);
 576                 return -EINVAL;
 577         }
 578
 579         while (length) {
 580                 packet_size = min(length, PACKET_SIZE);
 581
 582                 pkt_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_WRITE;
 583                 pkt_buf[CMD_TYPE_OFFSET] = VND_SET_DATA;
 584                 put_unaligned_le16(packet_size, &pkt_buf[CMD_INDEX_OFFSET]);
 585                 put_unaligned_le32(address, &pkt_buf[CMD_LENGTH_OFFSET]);
 586                 memcpy(&pkt_buf[CMD_DATA_OFFSET], data, packet_size);
 587
 588                 error = wdt87xx_set_feature(client, pkt_buf, sizeof(pkt_buf));
 589                 if (error)
 590                         return error;
 591
 592                 length -= packet_size;
 593                 data += packet_size;
 594                 address += packet_size;
 595
 596                 /* Wait for the controller to finish the write */
 597                 mdelay(WDT_FLASH_WRITE_DELAY_MS);
 598
 599                 if ((++count % 32) == 0) {
 600                         /* Delay for fw to clear watch dog */
 601                         msleep(20);
 602                 }
 603         }
 604
 605         return 0;
 606 }
 607
 608 static u16 misr(u16 cur_value, u8 new_value)
 609 {
 610         u32 a, b;
 611         u32 bit0;
 612         u32 y;
 613
 614         a = cur_value;
 615         b = new_value;
 616         bit0 = a ^ (b & 1);
 617         bit0 ^= a >> 1;
 618         bit0 ^= a >> 2;
 619         bit0 ^= a >> 4;
 620         bit0 ^= a >> 5;
 621         bit0 ^= a >> 7;
 622         bit0 ^= a >> 11;
 623         bit0 ^= a >> 15;
 624         y = (a << 1) ^ b;
 625         y = (y & ~1) | (bit0 & 1);
 626
 627         return (u16)y;
 628 }
 629
 630 static u16 wdt87xx_calculate_checksum(const u8 *data, size_t length)
 631 {
 632         u16 checksum = 0;
 633         size_t i;
 634
 635         for (i = 0; i < length; i++)
 636                 checksum = misr(checksum, data[i]);
 637
 638         return checksum;
 639 }
 640
 641 static int wdt87xx_get_checksum(struct i2c_client *client, u16 *checksum,
 642                                 u32 address, int length)
 643 {
 644         int error;
 645         int time_delay;
 646         u8 pkt_buf[PKT_BUF_SIZE];
 647         u8 cmd_buf[CMD_BUF_SIZE];
 648
 649         error = wdt87xx_send_command(client, VND_SET_CHECKSUM_LENGTH, length);
 650         if (error) {
 651                 dev_err(&client->dev, "failed to set checksum length\n");
 652                 return error;
 653         }
 654
 655         error = wdt87xx_send_command(client, VND_SET_CHECKSUM_CALC, address);
 656         if (error) {
 657                 dev_err(&client->dev, "failed to set checksum address\n");
 658                 return error;
 659         }
 660
 661         /* Wait the operation to complete */
 662         time_delay = DIV_ROUND_UP(length, 1024);
 663         msleep(time_delay * 30);
 664
 665         memset(cmd_buf, 0, sizeof(cmd_buf));
 666         cmd_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_READ;
 667         cmd_buf[CMD_TYPE_OFFSET] = VND_GET_CHECKSUM;
 668         error = wdt87xx_set_feature(client, cmd_buf, sizeof(cmd_buf));
 669         if (error) {
 670                 dev_err(&client->dev, "failed to request checksum\n");
 671                 return error;
 672         }
 673
 674         memset(pkt_buf, 0, sizeof(pkt_buf));
 675         pkt_buf[CMD_REPORT_ID_OFFSET] = VND_READ_DATA;
 676         error = wdt87xx_get_feature(client, pkt_buf, sizeof(pkt_buf));
 677         if (error) {
 678                 dev_err(&client->dev, "failed to read checksum\n");
 679                 return error;
 680         }
 681
 682         *checksum = get_unaligned_le16(&pkt_buf[CMD_DATA_OFFSET]);
 683         return 0;
 684 }
 685
 686 static int wdt87xx_write_firmware(struct i2c_client *client, const void *chunk)
 687 {
 688         u32 start_addr = get_unaligned_le32(chunk + FW_CHUNK_TGT_START_OFFSET);
 689         u32 size = get_unaligned_le32(chunk + FW_CHUNK_PAYLOAD_LEN_OFFSET);
 690         const void *data = chunk + FW_CHUNK_PAYLOAD_OFFSET;
 691         int error;
 692         int err1;
 693         int page_size;
 694         int retry = 0;
 695         u16 device_checksum, firmware_checksum;
 696
 697         dev_dbg(&client->dev, "start 4k page program\n");
 698
 699         error = wdt87xx_send_command(client, VND_CMD_STOP, MODE_STOP);
 700         if (error) {
 701                 dev_err(&client->dev, "stop report mode failed\n");
 702                 return error;
 703         }
 704
 705         error = wdt87xx_send_command(client, VND_CMD_SFUNL, 0);
 706         if (error) {
 707                 dev_err(&client->dev, "unlock failed\n");
 708                 goto out_enable_reporting;
 709         }
 710
 711         mdelay(10);
 712
 713         while (size) {
 714                 dev_dbg(&client->dev, "%s: %x, %x\n", __func__,
 715                         start_addr, size);
 716
 717                 page_size = min_t(u32, size, PG_SIZE);
 718                 size -= page_size;
 719
 720                 for (retry = 0; retry < MAX_RETRIES; retry++) {
 721                         error = wdt87xx_send_command(client, VND_CMD_ERASE,
 722                                                      start_addr);
 723                         if (error) {
 724                                 dev_err(&client->dev,
 725                                         "erase failed at %#08x\n", start_addr);
 726                                 break;
 727                         }
 728
 729                         msleep(WDT_FLASH_ERASE_DELAY_MS);
 730
 731                         error = wdt87xx_write_data(client, data, start_addr,
 732                                                    page_size);
 733                         if (error) {
 734                                 dev_err(&client->dev,
 735                                         "write failed at %#08x (%d bytes)\n",
 736                                         start_addr, page_size);
 737                                 break;
 738                         }
 739
 740                         error = wdt87xx_get_checksum(client, &device_checksum,
 741                                                      start_addr, page_size);
 742                         if (error) {
 743                                 dev_err(&client->dev,
 744                                         "failed to retrieve checksum for %#08x (len: %d)\n",
 745                                         start_addr, page_size);
 746                                 break;
 747                         }
 748
 749                         firmware_checksum =
 750                                 wdt87xx_calculate_checksum(data, page_size);
 751
 752                         if (device_checksum == firmware_checksum)
 753                                 break;
 754
 755                         dev_err(&client->dev,
 756                                 "checksum fail: %d vs %d, retry %d\n",
 757                                 device_checksum, firmware_checksum, retry);
 758                 }
 759
 760                 if (retry == MAX_RETRIES) {
 761                         dev_err(&client->dev, "page write failed\n");
 762                         error = -EIO;
 763                         goto out_lock_device;
 764                 }
 765
 766                 start_addr = start_addr + page_size;
 767                 data = data + page_size;
 768         }
 769
 770 out_lock_device:
 771         err1 = wdt87xx_send_command(client, VND_CMD_SFLCK, 0);
 772         if (err1)
 773                 dev_err(&client->dev, "lock failed\n");
 774
 775         mdelay(10);
 776
 777 out_enable_reporting:
 778         err1 = wdt87xx_send_command(client, VND_CMD_START, 0);
 779         if (err1)
 780                 dev_err(&client->dev, "start to report failed\n");
 781
 782         return error ? error : err1;
 783 }
 784
 785 static int wdt87xx_load_chunk(struct i2c_client *client,
 786                               const struct firmware *fw, u32 ck_id)
 787 {
 788         const void *chunk;
 789         int error;
 790
 791         chunk = wdt87xx_get_fw_chunk(fw, ck_id);
 792         if (!chunk) {
 793                 dev_err(&client->dev, "unable to locate chunk (type %d)\n",
 794                         ck_id);
 795                 return -EINVAL;
 796         }
 797
 798         error = wdt87xx_validate_fw_chunk(chunk, ck_id);
 799         if (error) {
 800                 dev_err(&client->dev, "invalid chunk (type %d): %d\n",
 801                         ck_id, error);
 802                 return error;
 803         }
 804
 805         error = wdt87xx_write_firmware(client, chunk);
 806         if (error) {
 807                 dev_err(&client->dev,
 808                         "failed to write fw chunk (type %d): %d\n",
 809                         ck_id, error);
 810                 return error;
 811         }
 812
 813         return 0;
 814 }
 815
 816 static int wdt87xx_do_update_firmware(struct i2c_client *client,
 817                                       const struct firmware *fw,
 818                                       unsigned int chunk_id)
 819 {
 820         struct wdt87xx_data *wdt = i2c_get_clientdata(client);
 821         int error;
 822
 823         error = wdt87xx_validate_firmware(wdt, fw);
 824         if (error)
 825                 return error;
 826
 827         error = mutex_lock_interruptible(&wdt->fw_mutex);
 828         if (error)
 829                 return error;
 830
 831         disable_irq(client->irq);
 832
 833         error = wdt87xx_load_chunk(client, fw, chunk_id);
 834         if (error) {
 835                 dev_err(&client->dev,
 836                         "firmware load failed (type: %d): %d\n",
 837                         chunk_id, error);
 838                 goto out;
 839         }
 840
 841         error = wdt87xx_sw_reset(client);
 842         if (error) {
 843                 dev_err(&client->dev, "soft reset failed: %d\n", error);
 844                 goto out;
 845         }
 846
 847         /* Refresh the parameters */
 848         error = wdt87xx_get_sysparam(client, &wdt->param);
 849         if (error)
 850                 dev_err(&client->dev,
 851                         "failed to refresh system parameters: %d\n", error);
 852 out:
 853         enable_irq(client->irq);
 854         mutex_unlock(&wdt->fw_mutex);
 855
 856         return error ? error : 0;
 857 }
 858
 859 static int wdt87xx_update_firmware(struct device *dev,
 860                                    const char *fw_name, unsigned int chunk_id)
 861 {
 862         struct i2c_client *client = to_i2c_client(dev);
 863         const struct firmware *fw;
 864         int error;
 865
 866         error = request_firmware(&fw, fw_name, dev);
 867         if (error) {
 868                 dev_err(&client->dev, "unable to retrieve firmware %s: %d\n",
 869                         fw_name, error);
 870                 return error;
 871         }
 872
 873         error = wdt87xx_do_update_firmware(client, fw, chunk_id);
 874
 875         release_firmware(fw);
 876
 877         return error ? error : 0;
 878 }
 879
 880 static ssize_t config_csum_show(struct device *dev,
 881                                 struct device_attribute *attr, char *buf)
 882 {
 883         struct i2c_client *client = to_i2c_client(dev);
 884         struct wdt87xx_data *wdt = i2c_get_clientdata(client);
 885         u32 cfg_csum;
 886
 887         cfg_csum = wdt->param.xmls_id1;
 888         cfg_csum = (cfg_csum << 16) | wdt->param.xmls_id2;
 889
 890         return scnprintf(buf, PAGE_SIZE, "%x\n", cfg_csum);
 891 }
 892
 893 static ssize_t fw_version_show(struct device *dev,
 894                                struct device_attribute *attr, char *buf)
 895 {
 896         struct i2c_client *client = to_i2c_client(dev);
 897         struct wdt87xx_data *wdt = i2c_get_clientdata(client);
 898
 899         return scnprintf(buf, PAGE_SIZE, "%x\n", wdt->param.fw_id);
 900 }
 901
 902 static ssize_t plat_id_show(struct device *dev,
 903                             struct device_attribute *attr, char *buf)
 904 {
 905         struct i2c_client *client = to_i2c_client(dev);
 906         struct wdt87xx_data *wdt = i2c_get_clientdata(client);
 907
 908         return scnprintf(buf, PAGE_SIZE, "%x\n", wdt->param.plat_id);
 909 }
 910
 911 static ssize_t update_config_store(struct device *dev,
 912                                    struct device_attribute *attr,
 913                                    const char *buf, size_t count)
 914 {
 915         int error;
 916
 917         error = wdt87xx_update_firmware(dev, WDT87XX_CFG_NAME, CHUNK_ID_CNFG);
 918
 919         return error ? error : count;
 920 }
 921
 922 static ssize_t update_fw_store(struct device *dev,
 923                                struct device_attribute *attr,
 924                                const char *buf, size_t count)
 925 {
 926         int error;
 927
 928         error = wdt87xx_update_firmware(dev, WDT87XX_FW_NAME, CHUNK_ID_FRWR);
 929
 930         return error ? error : count;
 931 }
 932
 933 static DEVICE_ATTR_RO(config_csum);
 934 static DEVICE_ATTR_RO(fw_version);
 935 static DEVICE_ATTR_RO(plat_id);
 936 static DEVICE_ATTR_WO(update_config);
 937 static DEVICE_ATTR_WO(update_fw);
 938
 939 static struct attribute *wdt87xx_attrs[] = {
 940         &dev_attr_config_csum.attr,
 941         &dev_attr_fw_version.attr,
 942         &dev_attr_plat_id.attr,
 943         &dev_attr_update_config.attr,
 944         &dev_attr_update_fw.attr,
 945         NULL
 946 };
 947
 948 static const struct attribute_group wdt87xx_attr_group = {
 949         .attrs = wdt87xx_attrs,
 950 };
 951
 952 static void wdt87xx_report_contact(struct input_dev *input,
 953                                    struct wdt87xx_sys_param *param,
 954                                    u8 *buf)
 955 {
 956         int finger_id;
 957         u32 x, y, w;
 958         u8 p;
 959
 960         finger_id = (buf[FINGER_EV_V1_OFFSET_ID] >> 3) - 1;
 961         if (finger_id < 0)
 962                 return;
 963
 964         /* Check if this is an active contact */
 965         if (!(buf[FINGER_EV_V1_OFFSET_ID] & 0x1))
 966                 return;
 967
 968         w = buf[FINGER_EV_V1_OFFSET_W];
 969         w *= param->scaling_factor;
 970
 971         p = buf[FINGER_EV_V1_OFFSET_P];
 972
 973         x = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_X);
 974
 975         y = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_Y);
 976         y = DIV_ROUND_CLOSEST(y * param->phy_h, param->phy_w);
 977
 978         /* Refuse incorrect coordinates */
 979         if (x > param->max_x || y > param->max_y)
 980                 return;
 981
 982         dev_dbg(input->dev.parent, "tip on (%d), x(%d), y(%d)\n",
 983                 finger_id, x, y);
 984
 985         input_mt_slot(input, finger_id);
 986         input_mt_report_slot_state(input, MT_TOOL_FINGER, 1);
 987         input_report_abs(input, ABS_MT_TOUCH_MAJOR, w);
 988         input_report_abs(input, ABS_MT_PRESSURE, p);
 989         input_report_abs(input, ABS_MT_POSITION_X, x);
 990         input_report_abs(input, ABS_MT_POSITION_Y, y);
 991 }
 992
 993 static irqreturn_t wdt87xx_ts_interrupt(int irq, void *dev_id)
 994 {
 995         struct wdt87xx_data *wdt = dev_id;
 996         struct i2c_client *client = wdt->client;
 997         int i, fingers;
 998         int error;
 999         u8 raw_buf[WDT_V1_RAW_BUF_COUNT] = {0};
1000
1001         error = i2c_master_recv(client, raw_buf, WDT_V1_RAW_BUF_COUNT);
1002         if (error < 0) {
1003                 dev_err(&client->dev, "read v1 raw data failed: %d\n", error);
1004                 goto irq_exit;
1005         }
1006
1007         fingers = raw_buf[TOUCH_PK_V1_OFFSET_FNGR_NUM];
1008         if (!fingers)
1009                 goto irq_exit;
1010
1011         for (i = 0; i < WDT_MAX_FINGER; i++)
1012                 wdt87xx_report_contact(wdt->input,
1013                                        &wdt->param,
1014                                        &raw_buf[TOUCH_PK_V1_OFFSET_EVENT +
1015                                                 i * FINGER_EV_V1_SIZE]);
1016
1017         input_mt_sync_frame(wdt->input);
1018         input_sync(wdt->input);
1019
1020 irq_exit:
1021         return IRQ_HANDLED;
1022 }
1023
1024 static int wdt87xx_ts_create_input_device(struct wdt87xx_data *wdt)
1025 {
1026         struct device *dev = &wdt->client->dev;
1027         struct input_dev *input;
1028         unsigned int res = DIV_ROUND_CLOSEST(MAX_UNIT_AXIS, wdt->param.phy_w);
1029         int error;
1030
1031         input = devm_input_allocate_device(dev);
1032         if (!input) {
1033                 dev_err(dev, "failed to allocate input device\n");
1034                 return -ENOMEM;
1035         }
1036         wdt->input = input;
1037
1038         input->name = "WDT87xx Touchscreen";
1039         input->id.bustype = BUS_I2C;
1040         input->id.vendor = wdt->param.vendor_id;
1041         input->id.product = wdt->param.product_id;
1042         input->phys = wdt->phys;
1043
1044         input_set_abs_params(input, ABS_MT_POSITION_X, 0,
1045                              wdt->param.max_x, 0, 0);
1046         input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
1047                              wdt->param.max_y, 0, 0);
1048         input_abs_set_res(input, ABS_MT_POSITION_X, res);
1049         input_abs_set_res(input, ABS_MT_POSITION_Y, res);
1050
1051         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR,
1052                              0, wdt->param.max_x, 0, 0);
1053         input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xFF, 0, 0);
1054
1055         input_mt_init_slots(input, WDT_MAX_FINGER,
1056                             INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1057
1058         error = input_register_device(input);
1059         if (error) {
1060                 dev_err(dev, "failed to register input device: %d\n", error);
1061                 return error;
1062         }
1063
1064         return 0;
1065 }
1066
1067 static int wdt87xx_ts_probe(struct i2c_client *client)
1068 {
1069         struct wdt87xx_data *wdt;
1070         int error;
1071
1072         dev_dbg(&client->dev, "adapter=%d, client irq: %d\n",
1073                 client->adapter->nr, client->irq);
1074
1075         /* Check if the I2C function is ok in this adaptor */
1076         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
1077                 return -ENXIO;
1078
1079         wdt = devm_kzalloc(&client->dev, sizeof(*wdt), GFP_KERNEL);
1080         if (!wdt)
1081                 return -ENOMEM;
1082
1083         wdt->client = client;
1084         mutex_init(&wdt->fw_mutex);
1085         i2c_set_clientdata(client, wdt);
1086
1087         snprintf(wdt->phys, sizeof(wdt->phys), "i2c-%u-%04x/input0",
1088                  client->adapter->nr, client->addr);
1089
1090         error = wdt87xx_get_sysparam(client, &wdt->param);
1091         if (error)
1092                 return error;
1093
1094         error = wdt87xx_ts_create_input_device(wdt);
1095         if (error)
1096                 return error;
1097
1098         error = devm_request_threaded_irq(&client->dev, client->irq,
1099                                           NULL, wdt87xx_ts_interrupt,
1100                                           IRQF_ONESHOT,
1101                                           client->name, wdt);
1102         if (error) {
1103                 dev_err(&client->dev, "request irq failed: %d\n", error);
1104                 return error;
1105         }
1106
1107         error = devm_device_add_group(&client->dev, &wdt87xx_attr_group);
1108         if (error) {
1109                 dev_err(&client->dev, "create sysfs failed: %d\n", error);
1110                 return error;
1111         }
1112
1113         return 0;
1114 }
1115
1116 static int wdt87xx_suspend(struct device *dev)
1117 {
1118         struct i2c_client *client = to_i2c_client(dev);
1119         int error;
1120
1121         disable_irq(client->irq);
1122
1123         error = wdt87xx_send_command(client, VND_CMD_STOP, MODE_IDLE);
1124         if (error) {
1125                 enable_irq(client->irq);
1126                 dev_err(&client->dev,
1127                         "failed to stop device when suspending: %d\n",
1128                         error);
1129                 return error;
1130         }
1131
1132         return 0;
1133 }
1134
1135 static int wdt87xx_resume(struct device *dev)
1136 {
1137         struct i2c_client *client = to_i2c_client(dev);
1138         int error;
1139
1140         /*
1141          * The chip may have been reset while system is resuming,
1142          * give it some time to settle.
1143          */
1144         msleep(100);
1145
1146         error = wdt87xx_send_command(client, VND_CMD_START, 0);
1147         if (error)
1148                 dev_err(&client->dev,
1149                         "failed to start device when resuming: %d\n",
1150                         error);
1151
1152         enable_irq(client->irq);
1153
1154         return 0;
1155 }
1156
1157 static DEFINE_SIMPLE_DEV_PM_OPS(wdt87xx_pm_ops, wdt87xx_suspend, wdt87xx_resume);
1158
1159 static const struct i2c_device_id wdt87xx_dev_id[] = {
1160         { WDT87XX_NAME, 0 },
1161         { }
1162 };
1163 MODULE_DEVICE_TABLE(i2c, wdt87xx_dev_id);
1164
1165 static const struct acpi_device_id wdt87xx_acpi_id[] = {
1166         { "WDHT0001", 0 },
1167         { }
1168 };
1169 MODULE_DEVICE_TABLE(acpi, wdt87xx_acpi_id);
1170
1171 static struct i2c_driver wdt87xx_driver = {
1172         .probe          = wdt87xx_ts_probe,
1173         .id_table       = wdt87xx_dev_id,
1174         .driver = {
1175                 .name   = WDT87XX_NAME,
1176                 .pm     = pm_sleep_ptr(&wdt87xx_pm_ops),
1177                 .acpi_match_table = ACPI_PTR(wdt87xx_acpi_id),
1178         },
1179 };
1180 module_i2c_driver(wdt87xx_driver);
1181
1182 MODULE_AUTHOR("HN Chen <[email protected]>");
1183 MODULE_DESCRIPTION("WeidaHiTech WDT87XX Touchscreen driver");
1184 MODULE_LICENSE("GPL");