drivers/input/touchscreen/hideep.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012-2017 Hideep, Inc.
   4  */
   5
   6 #include <linux/module.h>
   7 #include <linux/of.h>
   8 #include <linux/firmware.h>
   9 #include <linux/delay.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/i2c.h>
  12 #include <linux/acpi.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/regmap.h>
  15 #include <linux/sysfs.h>
  16 #include <linux/input.h>
  17 #include <linux/input/mt.h>
  18 #include <linux/input/touchscreen.h>
  19 #include <linux/regulator/consumer.h>
  20 #include <asm/unaligned.h>
  21
  22 #define HIDEEP_TS_NAME                  "HiDeep Touchscreen"
  23 #define HIDEEP_I2C_NAME                 "hideep_ts"
  24
  25 #define HIDEEP_MT_MAX                   10
  26 #define HIDEEP_KEY_MAX                  3
  27
  28 /* count(2) + touch data(100) + key data(6) */
  29 #define HIDEEP_MAX_EVENT                108UL
  30
  31 #define HIDEEP_TOUCH_EVENT_INDEX        2
  32 #define HIDEEP_KEY_EVENT_INDEX          102
  33
  34 /* Touch & key event */
  35 #define HIDEEP_EVENT_ADDR               0x240
  36
  37 /* command list */
  38 #define HIDEEP_RESET_CMD                0x9800
  39
  40 /* event bit */
  41 #define HIDEEP_MT_RELEASED              BIT(4)
  42 #define HIDEEP_KEY_PRESSED              BIT(7)
  43 #define HIDEEP_KEY_FIRST_PRESSED        BIT(8)
  44 #define HIDEEP_KEY_PRESSED_MASK         (HIDEEP_KEY_PRESSED | \
  45                                          HIDEEP_KEY_FIRST_PRESSED)
  46
  47 #define HIDEEP_KEY_IDX_MASK             0x0f
  48
  49 /* For NVM */
  50 #define HIDEEP_YRAM_BASE                0x40000000
  51 #define HIDEEP_PERIPHERAL_BASE          0x50000000
  52 #define HIDEEP_ESI_BASE                 (HIDEEP_PERIPHERAL_BASE + 0x00000000)
  53 #define HIDEEP_FLASH_BASE               (HIDEEP_PERIPHERAL_BASE + 0x01000000)
  54 #define HIDEEP_SYSCON_BASE              (HIDEEP_PERIPHERAL_BASE + 0x02000000)
  55
  56 #define HIDEEP_SYSCON_MOD_CON           (HIDEEP_SYSCON_BASE + 0x0000)
  57 #define HIDEEP_SYSCON_SPC_CON           (HIDEEP_SYSCON_BASE + 0x0004)
  58 #define HIDEEP_SYSCON_CLK_CON           (HIDEEP_SYSCON_BASE + 0x0008)
  59 #define HIDEEP_SYSCON_CLK_ENA           (HIDEEP_SYSCON_BASE + 0x000C)
  60 #define HIDEEP_SYSCON_RST_CON           (HIDEEP_SYSCON_BASE + 0x0010)
  61 #define HIDEEP_SYSCON_WDT_CON           (HIDEEP_SYSCON_BASE + 0x0014)
  62 #define HIDEEP_SYSCON_WDT_CNT           (HIDEEP_SYSCON_BASE + 0x0018)
  63 #define HIDEEP_SYSCON_PWR_CON           (HIDEEP_SYSCON_BASE + 0x0020)
  64 #define HIDEEP_SYSCON_PGM_ID            (HIDEEP_SYSCON_BASE + 0x00F4)
  65
  66 #define HIDEEP_FLASH_CON                (HIDEEP_FLASH_BASE + 0x0000)
  67 #define HIDEEP_FLASH_STA                (HIDEEP_FLASH_BASE + 0x0004)
  68 #define HIDEEP_FLASH_CFG                (HIDEEP_FLASH_BASE + 0x0008)
  69 #define HIDEEP_FLASH_TIM                (HIDEEP_FLASH_BASE + 0x000C)
  70 #define HIDEEP_FLASH_CACHE_CFG          (HIDEEP_FLASH_BASE + 0x0010)
  71 #define HIDEEP_FLASH_PIO_SIG            (HIDEEP_FLASH_BASE + 0x400000)
  72
  73 #define HIDEEP_ESI_TX_INVALID           (HIDEEP_ESI_BASE + 0x0008)
  74
  75 #define HIDEEP_PERASE                   0x00040000
  76 #define HIDEEP_WRONLY                   0x00100000
  77
  78 #define HIDEEP_NVM_MASK_OFS             0x0000000C
  79 #define HIDEEP_NVM_DEFAULT_PAGE         0
  80 #define HIDEEP_NVM_SFR_WPAGE            1
  81 #define HIDEEP_NVM_SFR_RPAGE            2
  82
  83 #define HIDEEP_PIO_SIG                  0x00400000
  84 #define HIDEEP_PROT_MODE                0x03400000
  85
  86 #define HIDEEP_NVM_PAGE_SIZE            128
  87
  88 #define HIDEEP_DWZ_INFO                 0x000002C0
  89
  90 struct hideep_event {
  91         __le16 x;
  92         __le16 y;
  93         __le16 z;
  94         u8 w;
  95         u8 flag;
  96         u8 type;
  97         u8 index;
  98 };
  99
 100 struct dwz_info {
 101         __be32 code_start;
 102         u8 code_crc[12];
 103
 104         __be32 c_code_start;
 105         __be16 gen_ver;
 106         __be16 c_code_len;
 107
 108         __be32 vr_start;
 109         __be16 rsv0;
 110         __be16 vr_len;
 111
 112         __be32 ft_start;
 113         __be16 vr_version;
 114         __be16 ft_len;
 115
 116         __be16 core_ver;
 117         __be16 boot_ver;
 118
 119         __be16 release_ver;
 120         __be16 custom_ver;
 121
 122         u8 factory_id;
 123         u8 panel_type;
 124         u8 model_name[6];
 125
 126         __be16 extra_option;
 127         __be16 product_code;
 128
 129         __be16 vendor_id;
 130         __be16 product_id;
 131 };
 132
 133 struct pgm_packet {
 134         struct {
 135                 u8 unused[3];
 136                 u8 len;
 137                 __be32 addr;
 138         } header;
 139         __be32 payload[HIDEEP_NVM_PAGE_SIZE / sizeof(__be32)];
 140 };
 141
 142 #define HIDEEP_XFER_BUF_SIZE    sizeof(struct pgm_packet)
 143
 144 struct hideep_ts {
 145         struct i2c_client *client;
 146         struct input_dev *input_dev;
 147         struct regmap *reg;
 148
 149         struct touchscreen_properties prop;
 150
 151         struct gpio_desc *reset_gpio;
 152
 153         struct regulator *vcc_vdd;
 154         struct regulator *vcc_vid;
 155
 156         struct mutex dev_mutex;
 157
 158         u32 tch_count;
 159         u32 lpm_count;
 160
 161         /*
 162          * Data buffer to read packet from the device (contacts and key
 163          * states). We align it on double-word boundary to keep word-sized
 164          * fields in contact data and double-word-sized fields in program
 165          * packet aligned.
 166          */
 167         u8 xfer_buf[HIDEEP_XFER_BUF_SIZE] __aligned(4);
 168
 169         int key_num;
 170         u32 key_codes[HIDEEP_KEY_MAX];
 171
 172         struct dwz_info dwz_info;
 173
 174         unsigned int fw_size;
 175         u32 nvm_mask;
 176 };
 177
 178 static int hideep_pgm_w_mem(struct hideep_ts *ts, u32 addr,
 179                             const __be32 *data, size_t count)
 180 {
 181         struct pgm_packet *packet = (void *)ts->xfer_buf;
 182         size_t len = count * sizeof(*data);
 183         struct i2c_msg msg = {
 184                 .addr   = ts->client->addr,
 185                 .len    = len + sizeof(packet->header.len) +
 186                                 sizeof(packet->header.addr),
 187                 .buf    = &packet->header.len,
 188         };
 189         int ret;
 190
 191         if (len > HIDEEP_NVM_PAGE_SIZE)
 192                 return -EINVAL;
 193
 194         packet->header.len = 0x80 | (count - 1);
 195         packet->header.addr = cpu_to_be32(addr);
 196         memcpy(packet->payload, data, len);
 197
 198         ret = i2c_transfer(ts->client->adapter, &msg, 1);
 199         if (ret != 1)
 200                 return ret < 0 ? ret : -EIO;
 201
 202         return 0;
 203 }
 204
 205 static int hideep_pgm_r_mem(struct hideep_ts *ts, u32 addr,
 206                             __be32 *data, size_t count)
 207 {
 208         struct pgm_packet *packet = (void *)ts->xfer_buf;
 209         size_t len = count * sizeof(*data);
 210         struct i2c_msg msg[] = {
 211                 {
 212                         .addr   = ts->client->addr,
 213                         .len    = sizeof(packet->header.len) +
 214                                         sizeof(packet->header.addr),
 215                         .buf    = &packet->header.len,
 216                 },
 217                 {
 218                         .addr   = ts->client->addr,
 219                         .flags  = I2C_M_RD,
 220                         .len    = len,
 221                         .buf    = (u8 *)data,
 222                 },
 223         };
 224         int ret;
 225
 226         if (len > HIDEEP_NVM_PAGE_SIZE)
 227                 return -EINVAL;
 228
 229         packet->header.len = count - 1;
 230         packet->header.addr = cpu_to_be32(addr);
 231
 232         ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 233         if (ret != ARRAY_SIZE(msg))
 234                 return ret < 0 ? ret : -EIO;
 235
 236         return 0;
 237 }
 238
 239 static int hideep_pgm_r_reg(struct hideep_ts *ts, u32 addr, u32 *val)
 240 {
 241         __be32 data;
 242         int error;
 243
 244         error = hideep_pgm_r_mem(ts, addr, &data, 1);
 245         if (error) {
 246                 dev_err(&ts->client->dev,
 247                         "read of register %#08x failed: %d\n",
 248                         addr, error);
 249                 return error;
 250         }
 251
 252         *val = be32_to_cpu(data);
 253         return 0;
 254 }
 255
 256 static int hideep_pgm_w_reg(struct hideep_ts *ts, u32 addr, u32 val)
 257 {
 258         __be32 data = cpu_to_be32(val);
 259         int error;
 260
 261         error = hideep_pgm_w_mem(ts, addr, &data, 1);
 262         if (error) {
 263                 dev_err(&ts->client->dev,
 264                         "write to register %#08x (%#08x) failed: %d\n",
 265                         addr, val, error);
 266                 return error;
 267         }
 268
 269         return 0;
 270 }
 271
 272 #define SW_RESET_IN_PGM(clk)                                    \
 273 {                                                               \
 274         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CNT, (clk));     \
 275         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CON, 0x03);      \
 276         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CON, 0x01);      \
 277 }
 278
 279 #define SET_FLASH_PIO(ce)                                       \
 280         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CON,                  \
 281                          0x01 | ((ce) << 1))
 282
 283 #define SET_PIO_SIG(x, y)                                       \
 284         hideep_pgm_w_reg(ts, HIDEEP_FLASH_PIO_SIG + (x), (y))
 285
 286 #define SET_FLASH_HWCONTROL()                                   \
 287         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CON, 0x00)
 288
 289 #define NVM_W_SFR(x, y)                                         \
 290 {                                                               \
 291         SET_FLASH_PIO(1);                                       \
 292         SET_PIO_SIG(x, y);                                      \
 293         SET_FLASH_PIO(0);                                       \
 294 }
 295
 296 static void hideep_pgm_set(struct hideep_ts *ts)
 297 {
 298         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CON, 0x00);
 299         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_SPC_CON, 0x00);
 300         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_CLK_ENA, 0xFF);
 301         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_CLK_CON, 0x01);
 302         hideep_pgm_w_reg(ts, HIDEEP_SYSCON_PWR_CON, 0x01);
 303         hideep_pgm_w_reg(ts, HIDEEP_FLASH_TIM, 0x03);
 304         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CACHE_CFG, 0x00);
 305 }
 306
 307 static int hideep_pgm_get_pattern(struct hideep_ts *ts, u32 *pattern)
 308 {
 309         u16 p1 = 0xAF39;
 310         u16 p2 = 0xDF9D;
 311         int error;
 312
 313         error = regmap_bulk_write(ts->reg, p1, &p2, 1);
 314         if (error) {
 315                 dev_err(&ts->client->dev,
 316                         "%s: regmap_bulk_write() failed with %d\n",
 317                         __func__, error);
 318                 return error;
 319         }
 320
 321         usleep_range(1000, 1100);
 322
 323         /* flush invalid Tx load register */
 324         error = hideep_pgm_w_reg(ts, HIDEEP_ESI_TX_INVALID, 0x01);
 325         if (error)
 326                 return error;
 327
 328         error = hideep_pgm_r_reg(ts, HIDEEP_SYSCON_PGM_ID, pattern);
 329         if (error)
 330                 return error;
 331
 332         return 0;
 333 }
 334
 335 static int hideep_enter_pgm(struct hideep_ts *ts)
 336 {
 337         int retry_count = 10;
 338         u32 pattern;
 339         int error;
 340
 341         while (retry_count--) {
 342                 error = hideep_pgm_get_pattern(ts, &pattern);
 343                 if (error) {
 344                         dev_err(&ts->client->dev,
 345                                 "hideep_pgm_get_pattern failed: %d\n", error);
 346                 } else if (pattern != 0x39AF9DDF) {
 347                         dev_err(&ts->client->dev, "%s: bad pattern: %#08x\n",
 348                                 __func__, pattern);
 349                 } else {
 350                         dev_dbg(&ts->client->dev, "found magic code");
 351
 352                         hideep_pgm_set(ts);
 353                         usleep_range(1000, 1100);
 354
 355                         return 0;
 356                 }
 357         }
 358
 359         dev_err(&ts->client->dev, "failed to  enter pgm mode\n");
 360         SW_RESET_IN_PGM(1000);
 361         return -EIO;
 362 }
 363
 364 static int hideep_nvm_unlock(struct hideep_ts *ts)
 365 {
 366         u32 unmask_code;
 367         int error;
 368
 369         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_SFR_RPAGE);
 370         error = hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code);
 371         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE);
 372         if (error)
 373                 return error;
 374
 375         /* make it unprotected code */
 376         unmask_code &= ~HIDEEP_PROT_MODE;
 377
 378         /* compare unmask code */
 379         if (unmask_code != ts->nvm_mask)
 380                 dev_warn(&ts->client->dev,
 381                          "read mask code different %#08x vs %#08x",
 382                          unmask_code, ts->nvm_mask);
 383
 384         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_SFR_WPAGE);
 385         SET_FLASH_PIO(0);
 386
 387         NVM_W_SFR(HIDEEP_NVM_MASK_OFS, ts->nvm_mask);
 388         SET_FLASH_HWCONTROL();
 389         hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE);
 390
 391         return 0;
 392 }
 393
 394 static int hideep_check_status(struct hideep_ts *ts)
 395 {
 396         int time_out = 100;
 397         int status;
 398         int error;
 399
 400         while (time_out--) {
 401                 error = hideep_pgm_r_reg(ts, HIDEEP_FLASH_STA, &status);
 402                 if (!error && status)
 403                         return 0;
 404
 405                 usleep_range(1000, 1100);
 406         }
 407
 408         return -ETIMEDOUT;
 409 }
 410
 411 static int hideep_program_page(struct hideep_ts *ts, u32 addr,
 412                                const __be32 *ucode, size_t xfer_count)
 413 {
 414         u32 val;
 415         int error;
 416
 417         error = hideep_check_status(ts);
 418         if (error)
 419                 return -EBUSY;
 420
 421         addr &= ~(HIDEEP_NVM_PAGE_SIZE - 1);
 422
 423         SET_FLASH_PIO(0);
 424         SET_FLASH_PIO(1);
 425
 426         /* erase page */
 427         SET_PIO_SIG(HIDEEP_PERASE | addr, 0xFFFFFFFF);
 428
 429         SET_FLASH_PIO(0);
 430
 431         error = hideep_check_status(ts);
 432         if (error)
 433                 return -EBUSY;
 434
 435         /* write page */
 436         SET_FLASH_PIO(1);
 437
 438         val = be32_to_cpu(ucode[0]);
 439         SET_PIO_SIG(HIDEEP_WRONLY | addr, val);
 440
 441         hideep_pgm_w_mem(ts, HIDEEP_FLASH_PIO_SIG | HIDEEP_WRONLY,
 442                          ucode, xfer_count);
 443
 444         val = be32_to_cpu(ucode[xfer_count - 1]);
 445         SET_PIO_SIG(124, val);
 446
 447         SET_FLASH_PIO(0);
 448
 449         usleep_range(1000, 1100);
 450
 451         error = hideep_check_status(ts);
 452         if (error)
 453                 return -EBUSY;
 454
 455         SET_FLASH_HWCONTROL();
 456
 457         return 0;
 458 }
 459
 460 static int hideep_program_nvm(struct hideep_ts *ts,
 461                               const __be32 *ucode, size_t ucode_len)
 462 {
 463         struct pgm_packet *packet_r = (void *)ts->xfer_buf;
 464         __be32 *current_ucode = packet_r->payload;
 465         size_t xfer_len;
 466         size_t xfer_count;
 467         u32 addr = 0;
 468         int error;
 469
 470        error = hideep_nvm_unlock(ts);
 471        if (error)
 472                return error;
 473
 474         while (ucode_len > 0) {
 475                 xfer_len = min_t(size_t, ucode_len, HIDEEP_NVM_PAGE_SIZE);
 476                 xfer_count = xfer_len / sizeof(*ucode);
 477
 478                 error = hideep_pgm_r_mem(ts, 0x00000000 + addr,
 479                                          current_ucode, xfer_count);
 480                 if (error) {
 481                         dev_err(&ts->client->dev,
 482                                 "%s: failed to read page at offset %#08x: %d\n",
 483                                 __func__, addr, error);
 484                         return error;
 485                 }
 486
 487                 /* See if the page needs updating */
 488                 if (memcmp(ucode, current_ucode, xfer_len)) {
 489                         error = hideep_program_page(ts, addr,
 490                                                     ucode, xfer_count);
 491                         if (error) {
 492                                 dev_err(&ts->client->dev,
 493                                         "%s: iwrite failure @%#08x: %d\n",
 494                                         __func__, addr, error);
 495                                 return error;
 496                         }
 497
 498                         usleep_range(1000, 1100);
 499                 }
 500
 501                 ucode += xfer_count;
 502                 addr += xfer_len;
 503                 ucode_len -= xfer_len;
 504         }
 505
 506         return 0;
 507 }
 508
 509 static int hideep_verify_nvm(struct hideep_ts *ts,
 510                              const __be32 *ucode, size_t ucode_len)
 511 {
 512         struct pgm_packet *packet_r = (void *)ts->xfer_buf;
 513         __be32 *current_ucode = packet_r->payload;
 514         size_t xfer_len;
 515         size_t xfer_count;
 516         u32 addr = 0;
 517         int i;
 518         int error;
 519
 520         while (ucode_len > 0) {
 521                 xfer_len = min_t(size_t, ucode_len, HIDEEP_NVM_PAGE_SIZE);
 522                 xfer_count = xfer_len / sizeof(*ucode);
 523
 524                 error = hideep_pgm_r_mem(ts, 0x00000000 + addr,
 525                                          current_ucode, xfer_count);
 526                 if (error) {
 527                         dev_err(&ts->client->dev,
 528                                 "%s: failed to read page at offset %#08x: %d\n",
 529                                 __func__, addr, error);
 530                         return error;
 531                 }
 532
 533                 if (memcmp(ucode, current_ucode, xfer_len)) {
 534                         const u8 *ucode_bytes = (const u8 *)ucode;
 535                         const u8 *current_bytes = (const u8 *)current_ucode;
 536
 537                         for (i = 0; i < xfer_len; i++)
 538                                 if (ucode_bytes[i] != current_bytes[i])
 539                                         dev_err(&ts->client->dev,
 540                                                 "%s: mismatch @%#08x: (%#02x vs %#02x)\n",
 541                                                 __func__, addr + i,
 542                                                 ucode_bytes[i],
 543                                                 current_bytes[i]);
 544
 545                         return -EIO;
 546                 }
 547
 548                 ucode += xfer_count;
 549                 addr += xfer_len;
 550                 ucode_len -= xfer_len;
 551         }
 552
 553         return 0;
 554 }
 555
 556 static int hideep_load_dwz(struct hideep_ts *ts)
 557 {
 558         u16 product_code;
 559         int error;
 560
 561         error = hideep_enter_pgm(ts);
 562         if (error)
 563                 return error;
 564
 565         msleep(50);
 566
 567         error = hideep_pgm_r_mem(ts, HIDEEP_DWZ_INFO,
 568                                  (void *)&ts->dwz_info,
 569                                  sizeof(ts->dwz_info) / sizeof(__be32));
 570
 571         SW_RESET_IN_PGM(10);
 572         msleep(50);
 573
 574         if (error) {
 575                 dev_err(&ts->client->dev,
 576                         "failed to fetch DWZ data: %d\n", error);
 577                 return error;
 578         }
 579
 580         product_code = be16_to_cpu(ts->dwz_info.product_code);
 581
 582         switch (product_code & 0xF0) {
 583         case 0x40:
 584                 dev_dbg(&ts->client->dev, "used crimson IC");
 585                 ts->fw_size = 1024 * 48;
 586                 ts->nvm_mask = 0x00310000;
 587                 break;
 588         case 0x60:
 589                 dev_dbg(&ts->client->dev, "used lime IC");
 590                 ts->fw_size = 1024 * 64;
 591                 ts->nvm_mask = 0x0030027B;
 592                 break;
 593         default:
 594                 dev_err(&ts->client->dev, "product code is wrong: %#04x",
 595                         product_code);
 596                 return -EINVAL;
 597         }
 598
 599         dev_dbg(&ts->client->dev, "firmware release version: %#04x",
 600                 be16_to_cpu(ts->dwz_info.release_ver));
 601
 602         return 0;
 603 }
 604
 605 static int hideep_flash_firmware(struct hideep_ts *ts,
 606                                  const __be32 *ucode, size_t ucode_len)
 607 {
 608         int retry_cnt = 3;
 609         int error;
 610
 611         while (retry_cnt--) {
 612                 error = hideep_program_nvm(ts, ucode, ucode_len);
 613                 if (!error) {
 614                         error = hideep_verify_nvm(ts, ucode, ucode_len);
 615                         if (!error)
 616                                 return 0;
 617                 }
 618         }
 619
 620         return error;
 621 }
 622
 623 static int hideep_update_firmware(struct hideep_ts *ts,
 624                                   const __be32 *ucode, size_t ucode_len)
 625 {
 626         int error, error2;
 627
 628         dev_dbg(&ts->client->dev, "starting firmware update");
 629
 630         /* enter program mode */
 631         error = hideep_enter_pgm(ts);
 632         if (error)
 633                 return error;
 634
 635         error = hideep_flash_firmware(ts, ucode, ucode_len);
 636         if (error)
 637                 dev_err(&ts->client->dev,
 638                         "firmware update failed: %d\n", error);
 639         else
 640                 dev_dbg(&ts->client->dev, "firmware updated successfully\n");
 641
 642         SW_RESET_IN_PGM(1000);
 643
 644         error2 = hideep_load_dwz(ts);
 645         if (error2)
 646                 dev_err(&ts->client->dev,
 647                         "failed to load dwz after firmware update: %d\n",
 648                         error2);
 649
 650         return error ?: error2;
 651 }
 652
 653 static int hideep_power_on(struct hideep_ts *ts)
 654 {
 655         int error = 0;
 656
 657         error = regulator_enable(ts->vcc_vdd);
 658         if (error)
 659                 dev_err(&ts->client->dev,
 660                         "failed to enable 'vdd' regulator: %d", error);
 661
 662         usleep_range(999, 1000);
 663
 664         error = regulator_enable(ts->vcc_vid);
 665         if (error)
 666                 dev_err(&ts->client->dev,
 667                         "failed to enable 'vcc_vid' regulator: %d",
 668                         error);
 669
 670         msleep(30);
 671
 672         if (ts->reset_gpio) {
 673                 gpiod_set_value_cansleep(ts->reset_gpio, 0);
 674         } else {
 675                 error = regmap_write(ts->reg, HIDEEP_RESET_CMD, 0x01);
 676                 if (error)
 677                         dev_err(&ts->client->dev,
 678                                 "failed to send 'reset' command: %d\n", error);
 679         }
 680
 681         msleep(50);
 682
 683         return error;
 684 }
 685
 686 static void hideep_power_off(void *data)
 687 {
 688         struct hideep_ts *ts = data;
 689
 690         if (ts->reset_gpio)
 691                 gpiod_set_value(ts->reset_gpio, 1);
 692
 693         regulator_disable(ts->vcc_vid);
 694         regulator_disable(ts->vcc_vdd);
 695 }
 696
 697 #define __GET_MT_TOOL_TYPE(type) ((type) == 0x01 ? MT_TOOL_FINGER : MT_TOOL_PEN)
 698
 699 static void hideep_report_slot(struct input_dev *input,
 700                                const struct hideep_event *event)
 701 {
 702         input_mt_slot(input, event->index & 0x0f);
 703         input_mt_report_slot_state(input,
 704                                    __GET_MT_TOOL_TYPE(event->type),
 705                                    !(event->flag & HIDEEP_MT_RELEASED));
 706         if (!(event->flag & HIDEEP_MT_RELEASED)) {
 707                 input_report_abs(input, ABS_MT_POSITION_X,
 708                                  le16_to_cpup(&event->x));
 709                 input_report_abs(input, ABS_MT_POSITION_Y,
 710                                  le16_to_cpup(&event->y));
 711                 input_report_abs(input, ABS_MT_PRESSURE,
 712                                  le16_to_cpup(&event->z));
 713                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, event->w);
 714         }
 715 }
 716
 717 static void hideep_parse_and_report(struct hideep_ts *ts)
 718 {
 719         const struct hideep_event *events =
 720                         (void *)&ts->xfer_buf[HIDEEP_TOUCH_EVENT_INDEX];
 721         const u8 *keys = &ts->xfer_buf[HIDEEP_KEY_EVENT_INDEX];
 722         int touch_count = ts->xfer_buf[0];
 723         int key_count = ts->xfer_buf[1] & 0x0f;
 724         int lpm_count = ts->xfer_buf[1] & 0xf0;
 725         int i;
 726
 727         /* get touch event count */
 728         dev_dbg(&ts->client->dev, "mt = %d, key = %d, lpm = %02x",
 729                 touch_count, key_count, lpm_count);
 730
 731         touch_count = min(touch_count, HIDEEP_MT_MAX);
 732         for (i = 0; i < touch_count; i++)
 733                 hideep_report_slot(ts->input_dev, events + i);
 734
 735         key_count = min(key_count, HIDEEP_KEY_MAX);
 736         for (i = 0; i < key_count; i++) {
 737                 u8 key_data = keys[i * 2];
 738
 739                 input_report_key(ts->input_dev,
 740                                  ts->key_codes[key_data & HIDEEP_KEY_IDX_MASK],
 741                                  key_data & HIDEEP_KEY_PRESSED_MASK);
 742         }
 743
 744         input_mt_sync_frame(ts->input_dev);
 745         input_sync(ts->input_dev);
 746 }
 747
 748 static irqreturn_t hideep_irq(int irq, void *handle)
 749 {
 750         struct hideep_ts *ts = handle;
 751         int error;
 752
 753         BUILD_BUG_ON(HIDEEP_MAX_EVENT > HIDEEP_XFER_BUF_SIZE);
 754
 755         error = regmap_bulk_read(ts->reg, HIDEEP_EVENT_ADDR,
 756                                  ts->xfer_buf, HIDEEP_MAX_EVENT / 2);
 757         if (error) {
 758                 dev_err(&ts->client->dev, "failed to read events: %d\n", error);
 759                 goto out;
 760         }
 761
 762         hideep_parse_and_report(ts);
 763
 764 out:
 765         return IRQ_HANDLED;
 766 }
 767
 768 static int hideep_get_axis_info(struct hideep_ts *ts)
 769 {
 770         __le16 val[2];
 771         int error;
 772
 773         error = regmap_bulk_read(ts->reg, 0x28, val, ARRAY_SIZE(val));
 774         if (error)
 775                 return error;
 776
 777         ts->prop.max_x = le16_to_cpup(val);
 778         ts->prop.max_y = le16_to_cpup(val + 1);
 779
 780         dev_dbg(&ts->client->dev, "X: %d, Y: %d",
 781                 ts->prop.max_x, ts->prop.max_y);
 782
 783         return 0;
 784 }
 785
 786 static int hideep_init_input(struct hideep_ts *ts)
 787 {
 788         struct device *dev = &ts->client->dev;
 789         int i;
 790         int error;
 791
 792         ts->input_dev = devm_input_allocate_device(dev);
 793         if (!ts->input_dev) {
 794                 dev_err(dev, "failed to allocate input device\n");
 795                 return -ENOMEM;
 796         }
 797
 798         ts->input_dev->name = HIDEEP_TS_NAME;
 799         ts->input_dev->id.bustype = BUS_I2C;
 800         input_set_drvdata(ts->input_dev, ts);
 801
 802         input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X);
 803         input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y);
 804         input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 65535, 0, 0);
 805         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 806         input_set_abs_params(ts->input_dev, ABS_MT_TOOL_TYPE,
 807                              0, MT_TOOL_MAX, 0, 0);
 808         touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
 809
 810         if (ts->prop.max_x == 0 || ts->prop.max_y == 0) {
 811                 error = hideep_get_axis_info(ts);
 812                 if (error)
 813                         return error;
 814         }
 815
 816         error = input_mt_init_slots(ts->input_dev, HIDEEP_MT_MAX,
 817                                     INPUT_MT_DIRECT);
 818         if (error)
 819                 return error;
 820
 821         ts->key_num = device_property_count_u32(dev, "linux,keycodes");
 822         if (ts->key_num > HIDEEP_KEY_MAX) {
 823                 dev_err(dev, "too many keys defined: %d\n",
 824                         ts->key_num);
 825                 return -EINVAL;
 826         }
 827
 828         if (ts->key_num <= 0) {
 829                 dev_dbg(dev,
 830                         "missing or malformed 'linux,keycodes' property\n");
 831         } else {
 832                 error = device_property_read_u32_array(dev, "linux,keycodes",
 833                                                        ts->key_codes,
 834                                                        ts->key_num);
 835                 if (error) {
 836                         dev_dbg(dev, "failed to read keymap: %d", error);
 837                         return error;
 838                 }
 839
 840                 if (ts->key_num) {
 841                         ts->input_dev->keycode = ts->key_codes;
 842                         ts->input_dev->keycodesize = sizeof(ts->key_codes[0]);
 843                         ts->input_dev->keycodemax = ts->key_num;
 844
 845                         for (i = 0; i < ts->key_num; i++)
 846                                 input_set_capability(ts->input_dev, EV_KEY,
 847                                         ts->key_codes[i]);
 848                 }
 849         }
 850
 851         error = input_register_device(ts->input_dev);
 852         if (error) {
 853                 dev_err(dev, "failed to register input device: %d", error);
 854                 return error;
 855         }
 856
 857         return 0;
 858 }
 859
 860 static ssize_t hideep_update_fw(struct device *dev,
 861                                 struct device_attribute *attr,
 862                                 const char *buf, size_t count)
 863 {
 864         struct i2c_client *client = to_i2c_client(dev);
 865         struct hideep_ts *ts = i2c_get_clientdata(client);
 866         const struct firmware *fw_entry;
 867         char *fw_name;
 868         int mode;
 869         int error;
 870
 871         error = kstrtoint(buf, 0, &mode);
 872         if (error)
 873                 return error;
 874
 875         fw_name = kasprintf(GFP_KERNEL, "hideep_ts_%04x.bin",
 876                             be16_to_cpu(ts->dwz_info.product_id));
 877         if (!fw_name)
 878                 return -ENOMEM;
 879
 880         error = request_firmware(&fw_entry, fw_name, dev);
 881         if (error) {
 882                 dev_err(dev, "failed to request firmware %s: %d",
 883                         fw_name, error);
 884                 goto out_free_fw_name;
 885         }
 886
 887         if (fw_entry->size % sizeof(__be32)) {
 888                 dev_err(dev, "invalid firmware size %zu\n", fw_entry->size);
 889                 error = -EINVAL;
 890                 goto out_release_fw;
 891         }
 892
 893         if (fw_entry->size > ts->fw_size) {
 894                 dev_err(dev, "fw size (%zu) is too big (memory size %d)\n",
 895                         fw_entry->size, ts->fw_size);
 896                 error = -EFBIG;
 897                 goto out_release_fw;
 898         }
 899
 900         mutex_lock(&ts->dev_mutex);
 901         disable_irq(client->irq);
 902
 903         error = hideep_update_firmware(ts, (const __be32 *)fw_entry->data,
 904                                        fw_entry->size);
 905
 906         enable_irq(client->irq);
 907         mutex_unlock(&ts->dev_mutex);
 908
 909 out_release_fw:
 910         release_firmware(fw_entry);
 911 out_free_fw_name:
 912         kfree(fw_name);
 913
 914         return error ?: count;
 915 }
 916
 917 static ssize_t hideep_fw_version_show(struct device *dev,
 918                                       struct device_attribute *attr, char *buf)
 919 {
 920         struct i2c_client *client = to_i2c_client(dev);
 921         struct hideep_ts *ts = i2c_get_clientdata(client);
 922         ssize_t len;
 923
 924         mutex_lock(&ts->dev_mutex);
 925         len = scnprintf(buf, PAGE_SIZE, "%04x\n",
 926                         be16_to_cpu(ts->dwz_info.release_ver));
 927         mutex_unlock(&ts->dev_mutex);
 928
 929         return len;
 930 }
 931
 932 static ssize_t hideep_product_id_show(struct device *dev,
 933                                       struct device_attribute *attr, char *buf)
 934 {
 935         struct i2c_client *client = to_i2c_client(dev);
 936         struct hideep_ts *ts = i2c_get_clientdata(client);
 937         ssize_t len;
 938
 939         mutex_lock(&ts->dev_mutex);
 940         len = scnprintf(buf, PAGE_SIZE, "%04x\n",
 941                         be16_to_cpu(ts->dwz_info.product_id));
 942         mutex_unlock(&ts->dev_mutex);
 943
 944         return len;
 945 }
 946
 947 static DEVICE_ATTR(version, 0664, hideep_fw_version_show, NULL);
 948 static DEVICE_ATTR(product_id, 0664, hideep_product_id_show, NULL);
 949 static DEVICE_ATTR(update_fw, 0664, NULL, hideep_update_fw);
 950
 951 static struct attribute *hideep_ts_sysfs_entries[] = {
 952         &dev_attr_version.attr,
 953         &dev_attr_product_id.attr,
 954         &dev_attr_update_fw.attr,
 955         NULL,
 956 };
 957
 958 static const struct attribute_group hideep_ts_attr_group = {
 959         .attrs = hideep_ts_sysfs_entries,
 960 };
 961
 962 static int __maybe_unused hideep_suspend(struct device *dev)
 963 {
 964         struct i2c_client *client = to_i2c_client(dev);
 965         struct hideep_ts *ts = i2c_get_clientdata(client);
 966
 967         disable_irq(client->irq);
 968         hideep_power_off(ts);
 969
 970         return 0;
 971 }
 972
 973 static int __maybe_unused hideep_resume(struct device *dev)
 974 {
 975         struct i2c_client *client = to_i2c_client(dev);
 976         struct hideep_ts *ts = i2c_get_clientdata(client);
 977         int error;
 978
 979         error = hideep_power_on(ts);
 980         if (error) {
 981                 dev_err(&client->dev, "power on failed");
 982                 return error;
 983         }
 984
 985         enable_irq(client->irq);
 986
 987         return 0;
 988 }
 989
 990 static SIMPLE_DEV_PM_OPS(hideep_pm_ops, hideep_suspend, hideep_resume);
 991
 992 static const struct regmap_config hideep_regmap_config = {
 993         .reg_bits = 16,
 994         .reg_format_endian = REGMAP_ENDIAN_LITTLE,
 995         .val_bits = 16,
 996         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 997         .max_register = 0xffff,
 998 };
 999
1000 static int hideep_probe(struct i2c_client *client,
1001                         const struct i2c_device_id *id)
1002 {
1003         struct hideep_ts *ts;
1004         int error;
1005
1006         /* check i2c bus */
1007         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1008                 dev_err(&client->dev, "check i2c device error");
1009                 return -ENODEV;
1010         }
1011
1012         if (client->irq <= 0) {
1013                 dev_err(&client->dev, "missing irq: %d\n", client->irq);
1014                 return -EINVAL;
1015         }
1016
1017         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1018         if (!ts)
1019                 return -ENOMEM;
1020
1021         ts->client = client;
1022         i2c_set_clientdata(client, ts);
1023         mutex_init(&ts->dev_mutex);
1024
1025         ts->reg = devm_regmap_init_i2c(client, &hideep_regmap_config);
1026         if (IS_ERR(ts->reg)) {
1027                 error = PTR_ERR(ts->reg);
1028                 dev_err(&client->dev,
1029                         "failed to initialize regmap: %d\n", error);
1030                 return error;
1031         }
1032
1033         ts->vcc_vdd = devm_regulator_get(&client->dev, "vdd");
1034         if (IS_ERR(ts->vcc_vdd))
1035                 return PTR_ERR(ts->vcc_vdd);
1036
1037         ts->vcc_vid = devm_regulator_get(&client->dev, "vid");
1038         if (IS_ERR(ts->vcc_vid))
1039                 return PTR_ERR(ts->vcc_vid);
1040
1041         ts->reset_gpio = devm_gpiod_get_optional(&client->dev,
1042                                                  "reset", GPIOD_OUT_HIGH);
1043         if (IS_ERR(ts->reset_gpio))
1044                 return PTR_ERR(ts->reset_gpio);
1045
1046         error = hideep_power_on(ts);
1047         if (error) {
1048                 dev_err(&client->dev, "power on failed: %d\n", error);
1049                 return error;
1050         }
1051
1052         error = devm_add_action_or_reset(&client->dev, hideep_power_off, ts);
1053         if (error)
1054                 return error;
1055
1056         error = hideep_load_dwz(ts);
1057         if (error) {
1058                 dev_err(&client->dev, "failed to load dwz: %d", error);
1059                 return error;
1060         }
1061
1062         error = hideep_init_input(ts);
1063         if (error)
1064                 return error;
1065
1066         error = devm_request_threaded_irq(&client->dev, client->irq,
1067                                           NULL, hideep_irq, IRQF_ONESHOT,
1068                                           client->name, ts);
1069         if (error) {
1070                 dev_err(&client->dev, "failed to request irq %d: %d\n",
1071                         client->irq, error);
1072                 return error;
1073         }
1074
1075         error = devm_device_add_group(&client->dev, &hideep_ts_attr_group);
1076         if (error) {
1077                 dev_err(&client->dev,
1078                         "failed to add sysfs attributes: %d\n", error);
1079                 return error;
1080         }
1081
1082         return 0;
1083 }
1084
1085 static const struct i2c_device_id hideep_i2c_id[] = {
1086         { HIDEEP_I2C_NAME, 0 },
1087         { }
1088 };
1089 MODULE_DEVICE_TABLE(i2c, hideep_i2c_id);
1090
1091 #ifdef CONFIG_ACPI
1092 static const struct acpi_device_id hideep_acpi_id[] = {
1093         { "HIDP0001", 0 },
1094         { }
1095 };
1096 MODULE_DEVICE_TABLE(acpi, hideep_acpi_id);
1097 #endif
1098
1099 #ifdef CONFIG_OF
1100 static const struct of_device_id hideep_match_table[] = {
1101         { .compatible = "hideep,hideep-ts" },
1102         { }
1103 };
1104 MODULE_DEVICE_TABLE(of, hideep_match_table);
1105 #endif
1106
1107 static struct i2c_driver hideep_driver = {
1108         .driver = {
1109                 .name                   = HIDEEP_I2C_NAME,
1110                 .of_match_table         = of_match_ptr(hideep_match_table),
1111                 .acpi_match_table       = ACPI_PTR(hideep_acpi_id),
1112                 .pm                     = &hideep_pm_ops,
1113         },
1114         .id_table       = hideep_i2c_id,
1115         .probe          = hideep_probe,
1116 };
1117
1118 module_i2c_driver(hideep_driver);
1119
1120 MODULE_DESCRIPTION("Driver for HiDeep Touchscreen Controller");
1121 MODULE_AUTHOR("anthony.kim@hideep.com");
1122 MODULE_LICENSE("GPL v2");