drivers/input/touchscreen/raydium_i2c_ts.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Raydium touchscreen I2C driver.
   4  *
   5  * Copyright (C) 2012-2014, Raydium Semiconductor Corporation.
   6  *
   7  * Raydium reserves the right to make changes without further notice
   8  * to the materials described herein. Raydium does not assume any
   9  * liability arising out of the application described herein.
  10  *
  11  * Contact Raydium Semiconductor Corporation at www.rad-ic.com
  12  */
  13
  14 #include <linux/acpi.h>
  15 #include <linux/delay.h>
  16 #include <linux/firmware.h>
  17 #include <linux/gpio/consumer.h>
  18 #include <linux/i2c.h>
  19 #include <linux/input.h>
  20 #include <linux/input/mt.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/module.h>
  23 #include <linux/of.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/slab.h>
  26 #include <asm/unaligned.h>
  27
  28 /* Slave I2C mode */
  29 #define RM_BOOT_BLDR            0x02
  30 #define RM_BOOT_MAIN            0x03
  31
  32 /* I2C bootoloader commands */
  33 #define RM_CMD_BOOT_PAGE_WRT    0x0B            /* send bl page write */
  34 #define RM_CMD_BOOT_WRT         0x11            /* send bl write */
  35 #define RM_CMD_BOOT_ACK         0x22            /* send ack*/
  36 #define RM_CMD_BOOT_CHK         0x33            /* send data check */
  37 #define RM_CMD_BOOT_READ        0x44            /* send wait bl data ready*/
  38
  39 #define RM_BOOT_RDY             0xFF            /* bl data ready */
  40
  41 /* I2C main commands */
  42 #define RM_CMD_QUERY_BANK       0x2B
  43 #define RM_CMD_DATA_BANK        0x4D
  44 #define RM_CMD_ENTER_SLEEP      0x4E
  45 #define RM_CMD_BANK_SWITCH      0xAA
  46
  47 #define RM_RESET_MSG_ADDR       0x40000004
  48
  49 #define RM_MAX_READ_SIZE        56
  50 #define RM_PACKET_CRC_SIZE      2
  51
  52 /* Touch relative info */
  53 #define RM_MAX_RETRIES          3
  54 #define RM_RETRY_DELAY_MS       20
  55 #define RM_MAX_TOUCH_NUM        10
  56 #define RM_BOOT_DELAY_MS        100
  57
  58 /* Offsets in contact data */
  59 #define RM_CONTACT_STATE_POS    0
  60 #define RM_CONTACT_X_POS        1
  61 #define RM_CONTACT_Y_POS        3
  62 #define RM_CONTACT_PRESSURE_POS 5
  63 #define RM_CONTACT_WIDTH_X_POS  6
  64 #define RM_CONTACT_WIDTH_Y_POS  7
  65
  66 /* Bootloader relative info */
  67 #define RM_BL_WRT_CMD_SIZE      3       /* bl flash wrt cmd size */
  68 #define RM_BL_WRT_PKG_SIZE      32      /* bl wrt pkg size */
  69 #define RM_BL_WRT_LEN           (RM_BL_WRT_PKG_SIZE + RM_BL_WRT_CMD_SIZE)
  70 #define RM_FW_PAGE_SIZE         128
  71 #define RM_MAX_FW_RETRIES       30
  72 #define RM_MAX_FW_SIZE          0xD000
  73
  74 #define RM_POWERON_DELAY_USEC   500
  75 #define RM_RESET_DELAY_MSEC     50
  76
  77 enum raydium_bl_cmd {
  78         BL_HEADER = 0,
  79         BL_PAGE_STR,
  80         BL_PKG_IDX,
  81         BL_DATA_STR,
  82 };
  83
  84 enum raydium_bl_ack {
  85         RAYDIUM_ACK_NULL = 0,
  86         RAYDIUM_WAIT_READY,
  87         RAYDIUM_PATH_READY,
  88 };
  89
  90 enum raydium_boot_mode {
  91         RAYDIUM_TS_MAIN = 0,
  92         RAYDIUM_TS_BLDR,
  93 };
  94
  95 /* Response to RM_CMD_DATA_BANK request */
  96 struct raydium_data_info {
  97         __le32 data_bank_addr;
  98         u8 pkg_size;
  99         u8 tp_info_size;
 100 };
 101
 102 struct raydium_info {
 103         __le32 hw_ver;          /*device version */
 104         u8 main_ver;
 105         u8 sub_ver;
 106         __le16 ft_ver;          /* test version */
 107         u8 x_num;
 108         u8 y_num;
 109         __le16 x_max;
 110         __le16 y_max;
 111         u8 x_res;               /* units/mm */
 112         u8 y_res;               /* units/mm */
 113 };
 114
 115 /* struct raydium_data - represents state of Raydium touchscreen device */
 116 struct raydium_data {
 117         struct i2c_client *client;
 118         struct input_dev *input;
 119
 120         struct regulator *avdd;
 121         struct regulator *vccio;
 122         struct gpio_desc *reset_gpio;
 123
 124         struct raydium_info info;
 125
 126         struct mutex sysfs_mutex;
 127
 128         u8 *report_data;
 129
 130         u32 data_bank_addr;
 131         u8 report_size;
 132         u8 contact_size;
 133         u8 pkg_size;
 134
 135         enum raydium_boot_mode boot_mode;
 136
 137         bool wake_irq_enabled;
 138 };
 139
 140 /*
 141  * Header to be sent for RM_CMD_BANK_SWITCH command. This is used by
 142  * raydium_i2c_{read|send} below.
 143  */
 144 struct __packed raydium_bank_switch_header {
 145         u8 cmd;
 146         __be32 be_addr;
 147 };
 148
 149 static int raydium_i2c_xfer(struct i2c_client *client, u32 addr,
 150                             struct i2c_msg *xfer, size_t xfer_count)
 151 {
 152         int ret;
 153         /*
 154          * If address is greater than 255, then RM_CMD_BANK_SWITCH needs to be
 155          * sent first. Else, skip the header i.e. xfer[0].
 156          */
 157         int xfer_start_idx = (addr > 0xff) ? 0 : 1;
 158         xfer_count -= xfer_start_idx;
 159
 160         ret = i2c_transfer(client->adapter, &xfer[xfer_start_idx], xfer_count);
 161         if (likely(ret == xfer_count))
 162                 return 0;
 163
 164         return ret < 0 ? ret : -EIO;
 165 }
 166
 167 static int raydium_i2c_send(struct i2c_client *client,
 168                             u32 addr, const void *data, size_t len)
 169 {
 170         int tries = 0;
 171         int error;
 172         u8 *tx_buf;
 173         u8 reg_addr = addr & 0xff;
 174
 175         tx_buf = kmalloc(len + 1, GFP_KERNEL);
 176         if (!tx_buf)
 177                 return -ENOMEM;
 178
 179         tx_buf[0] = reg_addr;
 180         memcpy(tx_buf + 1, data, len);
 181
 182         do {
 183                 struct raydium_bank_switch_header header = {
 184                         .cmd = RM_CMD_BANK_SWITCH,
 185                         .be_addr = cpu_to_be32(addr),
 186                 };
 187
 188                 /*
 189                  * Perform as a single i2c_transfer transaction to ensure that
 190                  * no other I2C transactions are initiated on the bus to any
 191                  * other device in between. Initiating transacations to other
 192                  * devices after RM_CMD_BANK_SWITCH is sent is known to cause
 193                  * issues. This is also why regmap infrastructure cannot be used
 194                  * for this driver. Regmap handles page(bank) switch and reads
 195                  * as separate i2c_transfer() operations. This can result in
 196                  * problems if the Raydium device is on a shared I2C bus.
 197                  */
 198                 struct i2c_msg xfer[] = {
 199                         {
 200                                 .addr = client->addr,
 201                                 .len = sizeof(header),
 202                                 .buf = (u8 *)&header,
 203                         },
 204                         {
 205                                 .addr = client->addr,
 206                                 .len = len + 1,
 207                                 .buf = tx_buf,
 208                         },
 209                 };
 210
 211                 error = raydium_i2c_xfer(client, addr, xfer, ARRAY_SIZE(xfer));
 212                 if (likely(!error))
 213                         goto out;
 214
 215                 msleep(RM_RETRY_DELAY_MS);
 216         } while (++tries < RM_MAX_RETRIES);
 217
 218         dev_err(&client->dev, "%s failed: %d\n", __func__, error);
 219 out:
 220         kfree(tx_buf);
 221         return error;
 222 }
 223
 224 static int raydium_i2c_read(struct i2c_client *client,
 225                             u32 addr, void *data, size_t len)
 226 {
 227         int error;
 228
 229         while (len) {
 230                 u8 reg_addr = addr & 0xff;
 231                 struct raydium_bank_switch_header header = {
 232                         .cmd = RM_CMD_BANK_SWITCH,
 233                         .be_addr = cpu_to_be32(addr),
 234                 };
 235                 size_t xfer_len = min_t(size_t, len, RM_MAX_READ_SIZE);
 236
 237                 /*
 238                  * Perform as a single i2c_transfer transaction to ensure that
 239                  * no other I2C transactions are initiated on the bus to any
 240                  * other device in between. Initiating transacations to other
 241                  * devices after RM_CMD_BANK_SWITCH is sent is known to cause
 242                  * issues. This is also why regmap infrastructure cannot be used
 243                  * for this driver. Regmap handles page(bank) switch and writes
 244                  * as separate i2c_transfer() operations. This can result in
 245                  * problems if the Raydium device is on a shared I2C bus.
 246                  */
 247                 struct i2c_msg xfer[] = {
 248                         {
 249                                 .addr = client->addr,
 250                                 .len = sizeof(header),
 251                                 .buf = (u8 *)&header,
 252                         },
 253                         {
 254                                 .addr = client->addr,
 255                                 .len = 1,
 256                                 .buf = &reg_addr,
 257                         },
 258                         {
 259                                 .addr = client->addr,
 260                                 .len = xfer_len,
 261                                 .buf = data,
 262                                 .flags = I2C_M_RD,
 263                         }
 264                 };
 265
 266                 error = raydium_i2c_xfer(client, addr, xfer, ARRAY_SIZE(xfer));
 267                 if (unlikely(error))
 268                         return error;
 269
 270                 len -= xfer_len;
 271                 data += xfer_len;
 272                 addr += xfer_len;
 273         }
 274
 275         return 0;
 276 }
 277
 278 static int raydium_i2c_sw_reset(struct i2c_client *client)
 279 {
 280         const u8 soft_rst_cmd = 0x01;
 281         int error;
 282
 283         error = raydium_i2c_send(client, RM_RESET_MSG_ADDR, &soft_rst_cmd,
 284                                  sizeof(soft_rst_cmd));
 285         if (error) {
 286                 dev_err(&client->dev, "software reset failed: %d\n", error);
 287                 return error;
 288         }
 289
 290         msleep(RM_RESET_DELAY_MSEC);
 291
 292         return 0;
 293 }
 294
 295 static int raydium_i2c_query_ts_info(struct raydium_data *ts)
 296 {
 297         struct i2c_client *client = ts->client;
 298         struct raydium_data_info data_info;
 299         __le32 query_bank_addr;
 300
 301         int error, retry_cnt;
 302
 303         for (retry_cnt = 0; retry_cnt < RM_MAX_RETRIES; retry_cnt++) {
 304                 error = raydium_i2c_read(client, RM_CMD_DATA_BANK,
 305                                          &data_info, sizeof(data_info));
 306                 if (error)
 307                         continue;
 308
 309                 /*
 310                  * Warn user if we already allocated memory for reports and
 311                  * then the size changed (due to firmware update?) and keep
 312                  * old size instead.
 313                  */
 314                 if (ts->report_data && ts->pkg_size != data_info.pkg_size) {
 315                         dev_warn(&client->dev,
 316                                  "report size changes, was: %d, new: %d\n",
 317                                  ts->pkg_size, data_info.pkg_size);
 318                 } else {
 319                         ts->pkg_size = data_info.pkg_size;
 320                         ts->report_size = ts->pkg_size - RM_PACKET_CRC_SIZE;
 321                 }
 322
 323                 ts->contact_size = data_info.tp_info_size;
 324                 ts->data_bank_addr = le32_to_cpu(data_info.data_bank_addr);
 325
 326                 dev_dbg(&client->dev,
 327                         "data_bank_addr: %#08x, report_size: %d, contact_size: %d\n",
 328                         ts->data_bank_addr, ts->report_size, ts->contact_size);
 329
 330                 error = raydium_i2c_read(client, RM_CMD_QUERY_BANK,
 331                                          &query_bank_addr,
 332                                          sizeof(query_bank_addr));
 333                 if (error)
 334                         continue;
 335
 336                 error = raydium_i2c_read(client, le32_to_cpu(query_bank_addr),
 337                                          &ts->info, sizeof(ts->info));
 338                 if (error)
 339                         continue;
 340
 341                 return 0;
 342         }
 343
 344         dev_err(&client->dev, "failed to query device parameters: %d\n", error);
 345         return error;
 346 }
 347
 348 static int raydium_i2c_check_fw_status(struct raydium_data *ts)
 349 {
 350         struct i2c_client *client = ts->client;
 351         static const u8 bl_ack = 0x62;
 352         static const u8 main_ack = 0x66;
 353         u8 buf[4];
 354         int error;
 355
 356         error = raydium_i2c_read(client, RM_CMD_BOOT_READ, buf, sizeof(buf));
 357         if (!error) {
 358                 if (buf[0] == bl_ack)
 359                         ts->boot_mode = RAYDIUM_TS_BLDR;
 360                 else if (buf[0] == main_ack)
 361                         ts->boot_mode = RAYDIUM_TS_MAIN;
 362                 return 0;
 363         }
 364
 365         return error;
 366 }
 367
 368 static int raydium_i2c_initialize(struct raydium_data *ts)
 369 {
 370         struct i2c_client *client = ts->client;
 371         int error, retry_cnt;
 372
 373         for (retry_cnt = 0; retry_cnt < RM_MAX_RETRIES; retry_cnt++) {
 374                 /* Wait for Hello packet */
 375                 msleep(RM_BOOT_DELAY_MS);
 376
 377                 error = raydium_i2c_check_fw_status(ts);
 378                 if (error) {
 379                         dev_err(&client->dev,
 380                                 "failed to read 'hello' packet: %d\n", error);
 381                         continue;
 382                 }
 383
 384                 if (ts->boot_mode == RAYDIUM_TS_BLDR ||
 385                     ts->boot_mode == RAYDIUM_TS_MAIN) {
 386                         break;
 387                 }
 388         }
 389
 390         if (error)
 391                 ts->boot_mode = RAYDIUM_TS_BLDR;
 392
 393         if (ts->boot_mode == RAYDIUM_TS_BLDR) {
 394                 ts->info.hw_ver = cpu_to_le32(0xffffffffUL);
 395                 ts->info.main_ver = 0xff;
 396                 ts->info.sub_ver = 0xff;
 397         } else {
 398                 raydium_i2c_query_ts_info(ts);
 399         }
 400
 401         return error;
 402 }
 403
 404 static int raydium_i2c_bl_chk_state(struct i2c_client *client,
 405                                     enum raydium_bl_ack state)
 406 {
 407         static const u8 ack_ok[] = { 0xFF, 0x39, 0x30, 0x30, 0x54 };
 408         u8 rbuf[sizeof(ack_ok)];
 409         u8 retry;
 410         int error;
 411
 412         for (retry = 0; retry < RM_MAX_FW_RETRIES; retry++) {
 413                 switch (state) {
 414                 case RAYDIUM_ACK_NULL:
 415                         return 0;
 416
 417                 case RAYDIUM_WAIT_READY:
 418                         error = raydium_i2c_read(client, RM_CMD_BOOT_CHK,
 419                                                  &rbuf[0], 1);
 420                         if (!error && rbuf[0] == RM_BOOT_RDY)
 421                                 return 0;
 422
 423                         break;
 424
 425                 case RAYDIUM_PATH_READY:
 426                         error = raydium_i2c_read(client, RM_CMD_BOOT_CHK,
 427                                                  rbuf, sizeof(rbuf));
 428                         if (!error && !memcmp(rbuf, ack_ok, sizeof(ack_ok)))
 429                                 return 0;
 430
 431                         break;
 432
 433                 default:
 434                         dev_err(&client->dev, "%s: invalid target state %d\n",
 435                                 __func__, state);
 436                         return -EINVAL;
 437                 }
 438
 439                 msleep(20);
 440         }
 441
 442         return -ETIMEDOUT;
 443 }
 444
 445 static int raydium_i2c_write_object(struct i2c_client *client,
 446                                     const void *data, size_t len,
 447                                     enum raydium_bl_ack state)
 448 {
 449         int error;
 450         static const u8 cmd[] = { 0xFF, 0x39 };
 451
 452         error = raydium_i2c_send(client, RM_CMD_BOOT_WRT, data, len);
 453         if (error) {
 454                 dev_err(&client->dev, "WRT obj command failed: %d\n",
 455                         error);
 456                 return error;
 457         }
 458
 459         error = raydium_i2c_send(client, RM_CMD_BOOT_ACK, cmd, sizeof(cmd));
 460         if (error) {
 461                 dev_err(&client->dev, "Ack obj command failed: %d\n", error);
 462                 return error;
 463         }
 464
 465         error = raydium_i2c_bl_chk_state(client, state);
 466         if (error) {
 467                 dev_err(&client->dev, "BL check state failed: %d\n", error);
 468                 return error;
 469         }
 470         return 0;
 471 }
 472
 473 static int raydium_i2c_boot_trigger(struct i2c_client *client)
 474 {
 475         static const u8 cmd[7][6] = {
 476                 { 0x08, 0x0C, 0x09, 0x00, 0x50, 0xD7 },
 477                 { 0x08, 0x04, 0x09, 0x00, 0x50, 0xA5 },
 478                 { 0x08, 0x04, 0x09, 0x00, 0x50, 0x00 },
 479                 { 0x08, 0x04, 0x09, 0x00, 0x50, 0xA5 },
 480                 { 0x08, 0x0C, 0x09, 0x00, 0x50, 0x00 },
 481                 { 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 },
 482                 { 0x02, 0xA2, 0x00, 0x00, 0x00, 0x00 },
 483         };
 484         int i;
 485         int error;
 486
 487         for (i = 0; i < 7; i++) {
 488                 error = raydium_i2c_write_object(client, cmd[i], sizeof(cmd[i]),
 489                                                  RAYDIUM_WAIT_READY);
 490                 if (error) {
 491                         dev_err(&client->dev,
 492                                 "boot trigger failed at step %d: %d\n",
 493                                 i, error);
 494                         return error;
 495                 }
 496         }
 497
 498         return 0;
 499 }
 500
 501 static int raydium_i2c_fw_trigger(struct i2c_client *client)
 502 {
 503         static const u8 cmd[5][11] = {
 504                 { 0, 0x09, 0x71, 0x0C, 0x09, 0x00, 0x50, 0xD7, 0, 0, 0 },
 505                 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0xA5, 0, 0, 0 },
 506                 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0x00, 0, 0, 0 },
 507                 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0xA5, 0, 0, 0 },
 508                 { 0, 0x09, 0x71, 0x0C, 0x09, 0x00, 0x50, 0x00, 0, 0, 0 },
 509         };
 510         int i;
 511         int error;
 512
 513         for (i = 0; i < 5; i++) {
 514                 error = raydium_i2c_write_object(client, cmd[i], sizeof(cmd[i]),
 515                                                  RAYDIUM_ACK_NULL);
 516                 if (error) {
 517                         dev_err(&client->dev,
 518                                 "fw trigger failed at step %d: %d\n",
 519                                 i, error);
 520                         return error;
 521                 }
 522         }
 523
 524         return 0;
 525 }
 526
 527 static int raydium_i2c_check_path(struct i2c_client *client)
 528 {
 529         static const u8 cmd[] = { 0x09, 0x00, 0x09, 0x00, 0x50, 0x10, 0x00 };
 530         int error;
 531
 532         error = raydium_i2c_write_object(client, cmd, sizeof(cmd),
 533                                          RAYDIUM_PATH_READY);
 534         if (error) {
 535                 dev_err(&client->dev, "check path command failed: %d\n", error);
 536                 return error;
 537         }
 538
 539         return 0;
 540 }
 541
 542 static int raydium_i2c_enter_bl(struct i2c_client *client)
 543 {
 544         static const u8 cal_cmd[] = { 0x00, 0x01, 0x52 };
 545         int error;
 546
 547         error = raydium_i2c_write_object(client, cal_cmd, sizeof(cal_cmd),
 548                                          RAYDIUM_ACK_NULL);
 549         if (error) {
 550                 dev_err(&client->dev, "enter bl command failed: %d\n", error);
 551                 return error;
 552         }
 553
 554         msleep(RM_BOOT_DELAY_MS);
 555         return 0;
 556 }
 557
 558 static int raydium_i2c_leave_bl(struct i2c_client *client)
 559 {
 560         static const u8 leave_cmd[] = { 0x05, 0x00 };
 561         int error;
 562
 563         error = raydium_i2c_write_object(client, leave_cmd, sizeof(leave_cmd),
 564                                          RAYDIUM_ACK_NULL);
 565         if (error) {
 566                 dev_err(&client->dev, "leave bl command failed: %d\n", error);
 567                 return error;
 568         }
 569
 570         msleep(RM_BOOT_DELAY_MS);
 571         return 0;
 572 }
 573
 574 static int raydium_i2c_write_checksum(struct i2c_client *client,
 575                                       size_t length, u16 checksum)
 576 {
 577         u8 checksum_cmd[] = { 0x00, 0x05, 0x6D, 0x00, 0x00, 0x00, 0x00 };
 578         int error;
 579
 580         put_unaligned_le16(length, &checksum_cmd[3]);
 581         put_unaligned_le16(checksum, &checksum_cmd[5]);
 582
 583         error = raydium_i2c_write_object(client,
 584                                          checksum_cmd, sizeof(checksum_cmd),
 585                                          RAYDIUM_ACK_NULL);
 586         if (error) {
 587                 dev_err(&client->dev, "failed to write checksum: %d\n",
 588                         error);
 589                 return error;
 590         }
 591
 592         return 0;
 593 }
 594
 595 static int raydium_i2c_disable_watch_dog(struct i2c_client *client)
 596 {
 597         static const u8 cmd[] = { 0x0A, 0xAA };
 598         int error;
 599
 600         error = raydium_i2c_write_object(client, cmd, sizeof(cmd),
 601                                          RAYDIUM_WAIT_READY);
 602         if (error) {
 603                 dev_err(&client->dev, "disable watchdog command failed: %d\n",
 604                         error);
 605                 return error;
 606         }
 607
 608         return 0;
 609 }
 610
 611 static int raydium_i2c_fw_write_page(struct i2c_client *client,
 612                                      u16 page_idx, const void *data, size_t len)
 613 {
 614         u8 buf[RM_BL_WRT_LEN];
 615         size_t xfer_len;
 616         int error;
 617         int i;
 618
 619         BUILD_BUG_ON((RM_FW_PAGE_SIZE % RM_BL_WRT_PKG_SIZE) != 0);
 620
 621         for (i = 0; i < RM_FW_PAGE_SIZE / RM_BL_WRT_PKG_SIZE; i++) {
 622                 buf[BL_HEADER] = RM_CMD_BOOT_PAGE_WRT;
 623                 buf[BL_PAGE_STR] = page_idx ? 0xff : 0;
 624                 buf[BL_PKG_IDX] = i + 1;
 625
 626                 xfer_len = min_t(size_t, len, RM_BL_WRT_PKG_SIZE);
 627                 memcpy(&buf[BL_DATA_STR], data, xfer_len);
 628                 if (len < RM_BL_WRT_PKG_SIZE)
 629                         memset(&buf[BL_DATA_STR + xfer_len], 0xff,
 630                                 RM_BL_WRT_PKG_SIZE - xfer_len);
 631
 632                 error = raydium_i2c_write_object(client, buf, RM_BL_WRT_LEN,
 633                                                  RAYDIUM_WAIT_READY);
 634                 if (error) {
 635                         dev_err(&client->dev,
 636                                 "page write command failed for page %d, chunk %d: %d\n",
 637                                 page_idx, i, error);
 638                         return error;
 639                 }
 640
 641                 data += xfer_len;
 642                 len -= xfer_len;
 643         }
 644
 645         return error;
 646 }
 647
 648 static u16 raydium_calc_chksum(const u8 *buf, u16 len)
 649 {
 650         u16 checksum = 0;
 651         u16 i;
 652
 653         for (i = 0; i < len; i++)
 654                 checksum += buf[i];
 655
 656         return checksum;
 657 }
 658
 659 static int raydium_i2c_do_update_firmware(struct raydium_data *ts,
 660                                          const struct firmware *fw)
 661 {
 662         struct i2c_client *client = ts->client;
 663         const void *data;
 664         size_t data_len;
 665         size_t len;
 666         int page_nr;
 667         int i;
 668         int error;
 669         u16 fw_checksum;
 670
 671         if (fw->size == 0 || fw->size > RM_MAX_FW_SIZE) {
 672                 dev_err(&client->dev, "Invalid firmware length\n");
 673                 return -EINVAL;
 674         }
 675
 676         error = raydium_i2c_check_fw_status(ts);
 677         if (error) {
 678                 dev_err(&client->dev, "Unable to access IC %d\n", error);
 679                 return error;
 680         }
 681
 682         if (ts->boot_mode == RAYDIUM_TS_MAIN) {
 683                 for (i = 0; i < RM_MAX_RETRIES; i++) {
 684                         error = raydium_i2c_enter_bl(client);
 685                         if (!error) {
 686                                 error = raydium_i2c_check_fw_status(ts);
 687                                 if (error) {
 688                                         dev_err(&client->dev,
 689                                                 "unable to access IC: %d\n",
 690                                                 error);
 691                                         return error;
 692                                 }
 693
 694                                 if (ts->boot_mode == RAYDIUM_TS_BLDR)
 695                                         break;
 696                         }
 697                 }
 698
 699                 if (ts->boot_mode == RAYDIUM_TS_MAIN) {
 700                         dev_err(&client->dev,
 701                                 "failed to jump to boot loader: %d\n",
 702                                 error);
 703                         return -EIO;
 704                 }
 705         }
 706
 707         error = raydium_i2c_disable_watch_dog(client);
 708         if (error)
 709                 return error;
 710
 711         error = raydium_i2c_check_path(client);
 712         if (error)
 713                 return error;
 714
 715         error = raydium_i2c_boot_trigger(client);
 716         if (error) {
 717                 dev_err(&client->dev, "send boot trigger fail: %d\n", error);
 718                 return error;
 719         }
 720
 721         msleep(RM_BOOT_DELAY_MS);
 722
 723         data = fw->data;
 724         data_len = fw->size;
 725         page_nr = 0;
 726
 727         while (data_len) {
 728                 len = min_t(size_t, data_len, RM_FW_PAGE_SIZE);
 729
 730                 error = raydium_i2c_fw_write_page(client, page_nr++, data, len);
 731                 if (error)
 732                         return error;
 733
 734                 msleep(20);
 735
 736                 data += len;
 737                 data_len -= len;
 738         }
 739
 740         error = raydium_i2c_leave_bl(client);
 741         if (error) {
 742                 dev_err(&client->dev,
 743                         "failed to leave boot loader: %d\n", error);
 744                 return error;
 745         }
 746
 747         dev_dbg(&client->dev, "left boot loader mode\n");
 748         msleep(RM_BOOT_DELAY_MS);
 749
 750         error = raydium_i2c_check_fw_status(ts);
 751         if (error) {
 752                 dev_err(&client->dev,
 753                         "failed to check fw status after write: %d\n",
 754                         error);
 755                 return error;
 756         }
 757
 758         if (ts->boot_mode != RAYDIUM_TS_MAIN) {
 759                 dev_err(&client->dev,
 760                         "failed to switch to main fw after writing firmware: %d\n",
 761                         error);
 762                 return -EINVAL;
 763         }
 764
 765         error = raydium_i2c_fw_trigger(client);
 766         if (error) {
 767                 dev_err(&client->dev, "failed to trigger fw: %d\n", error);
 768                 return error;
 769         }
 770
 771         fw_checksum = raydium_calc_chksum(fw->data, fw->size);
 772
 773         error = raydium_i2c_write_checksum(client, fw->size, fw_checksum);
 774         if (error)
 775                 return error;
 776
 777         return 0;
 778 }
 779
 780 static int raydium_i2c_fw_update(struct raydium_data *ts)
 781 {
 782         struct i2c_client *client = ts->client;
 783         const struct firmware *fw = NULL;
 784         char *fw_file;
 785         int error;
 786
 787         fw_file = kasprintf(GFP_KERNEL, "/*(DEBLOBBED)*/",
 788                             le32_to_cpu(ts->info.hw_ver));
 789         if (!fw_file)
 790                 return -ENOMEM;
 791
 792         dev_dbg(&client->dev, "firmware name: %s\n", fw_file);
 793
 794         error = reject_firmware(&fw, fw_file, &client->dev);
 795         if (error) {
 796                 dev_err(&client->dev, "Unable to open firmware %s\n", fw_file);
 797                 goto out_free_fw_file;
 798         }
 799
 800         disable_irq(client->irq);
 801
 802         error = raydium_i2c_do_update_firmware(ts, fw);
 803         if (error) {
 804                 dev_err(&client->dev, "firmware update failed: %d\n", error);
 805                 ts->boot_mode = RAYDIUM_TS_BLDR;
 806                 goto out_enable_irq;
 807         }
 808
 809         error = raydium_i2c_initialize(ts);
 810         if (error) {
 811                 dev_err(&client->dev,
 812                         "failed to initialize device after firmware update: %d\n",
 813                         error);
 814                 ts->boot_mode = RAYDIUM_TS_BLDR;
 815                 goto out_enable_irq;
 816         }
 817
 818         ts->boot_mode = RAYDIUM_TS_MAIN;
 819
 820 out_enable_irq:
 821         enable_irq(client->irq);
 822         msleep(100);
 823
 824         release_firmware(fw);
 825
 826 out_free_fw_file:
 827         kfree(fw_file);
 828
 829         return error;
 830 }
 831
 832 static void raydium_mt_event(struct raydium_data *ts)
 833 {
 834         int i;
 835
 836         for (i = 0; i < ts->report_size / ts->contact_size; i++) {
 837                 u8 *contact = &ts->report_data[ts->contact_size * i];
 838                 bool state = contact[RM_CONTACT_STATE_POS];
 839                 u8 wx, wy;
 840
 841                 input_mt_slot(ts->input, i);
 842                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, state);
 843
 844                 if (!state)
 845                         continue;
 846
 847                 input_report_abs(ts->input, ABS_MT_POSITION_X,
 848                                 get_unaligned_le16(&contact[RM_CONTACT_X_POS]));
 849                 input_report_abs(ts->input, ABS_MT_POSITION_Y,
 850                                 get_unaligned_le16(&contact[RM_CONTACT_Y_POS]));
 851                 input_report_abs(ts->input, ABS_MT_PRESSURE,
 852                                 contact[RM_CONTACT_PRESSURE_POS]);
 853
 854                 wx = contact[RM_CONTACT_WIDTH_X_POS];
 855                 wy = contact[RM_CONTACT_WIDTH_Y_POS];
 856
 857                 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, max(wx, wy));
 858                 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, min(wx, wy));
 859         }
 860
 861         input_mt_sync_frame(ts->input);
 862         input_sync(ts->input);
 863 }
 864
 865 static irqreturn_t raydium_i2c_irq(int irq, void *_dev)
 866 {
 867         struct raydium_data *ts = _dev;
 868         int error;
 869         u16 fw_crc;
 870         u16 calc_crc;
 871
 872         if (ts->boot_mode != RAYDIUM_TS_MAIN)
 873                 goto out;
 874
 875         error = raydium_i2c_read(ts->client, ts->data_bank_addr,
 876                                  ts->report_data, ts->pkg_size);
 877         if (error)
 878                 goto out;
 879
 880         fw_crc = get_unaligned_le16(&ts->report_data[ts->report_size]);
 881         calc_crc = raydium_calc_chksum(ts->report_data, ts->report_size);
 882         if (unlikely(fw_crc != calc_crc)) {
 883                 dev_warn(&ts->client->dev,
 884                          "%s: invalid packet crc %#04x vs %#04x\n",
 885                          __func__, calc_crc, fw_crc);
 886                 goto out;
 887         }
 888
 889         raydium_mt_event(ts);
 890
 891 out:
 892         return IRQ_HANDLED;
 893 }
 894
 895 static ssize_t raydium_i2c_fw_ver_show(struct device *dev,
 896                                        struct device_attribute *attr, char *buf)
 897 {
 898         struct i2c_client *client = to_i2c_client(dev);
 899         struct raydium_data *ts = i2c_get_clientdata(client);
 900
 901         return sprintf(buf, "%d.%d\n", ts->info.main_ver, ts->info.sub_ver);
 902 }
 903
 904 static ssize_t raydium_i2c_hw_ver_show(struct device *dev,
 905                                        struct device_attribute *attr, char *buf)
 906 {
 907         struct i2c_client *client = to_i2c_client(dev);
 908         struct raydium_data *ts = i2c_get_clientdata(client);
 909
 910         return sprintf(buf, "%#04x\n", le32_to_cpu(ts->info.hw_ver));
 911 }
 912
 913 static ssize_t raydium_i2c_boot_mode_show(struct device *dev,
 914                                           struct device_attribute *attr,
 915                                           char *buf)
 916 {
 917         struct i2c_client *client = to_i2c_client(dev);
 918         struct raydium_data *ts = i2c_get_clientdata(client);
 919
 920         return sprintf(buf, "%s\n",
 921                        ts->boot_mode == RAYDIUM_TS_MAIN ?
 922                                 "Normal" : "Recovery");
 923 }
 924
 925 static ssize_t raydium_i2c_update_fw_store(struct device *dev,
 926                                            struct device_attribute *attr,
 927                                            const char *buf, size_t count)
 928 {
 929         struct i2c_client *client = to_i2c_client(dev);
 930         struct raydium_data *ts = i2c_get_clientdata(client);
 931         int error;
 932
 933         error = mutex_lock_interruptible(&ts->sysfs_mutex);
 934         if (error)
 935                 return error;
 936
 937         error = raydium_i2c_fw_update(ts);
 938
 939         mutex_unlock(&ts->sysfs_mutex);
 940
 941         return error ?: count;
 942 }
 943
 944 static ssize_t raydium_i2c_calibrate_store(struct device *dev,
 945                                            struct device_attribute *attr,
 946                                            const char *buf, size_t count)
 947 {
 948         struct i2c_client *client = to_i2c_client(dev);
 949         struct raydium_data *ts = i2c_get_clientdata(client);
 950         static const u8 cal_cmd[] = { 0x00, 0x01, 0x9E };
 951         int error;
 952
 953         error = mutex_lock_interruptible(&ts->sysfs_mutex);
 954         if (error)
 955                 return error;
 956
 957         error = raydium_i2c_write_object(client, cal_cmd, sizeof(cal_cmd),
 958                                          RAYDIUM_WAIT_READY);
 959         if (error)
 960                 dev_err(&client->dev, "calibrate command failed: %d\n", error);
 961
 962         mutex_unlock(&ts->sysfs_mutex);
 963         return error ?: count;
 964 }
 965
 966 static DEVICE_ATTR(fw_version, S_IRUGO, raydium_i2c_fw_ver_show, NULL);
 967 static DEVICE_ATTR(hw_version, S_IRUGO, raydium_i2c_hw_ver_show, NULL);
 968 static DEVICE_ATTR(boot_mode, S_IRUGO, raydium_i2c_boot_mode_show, NULL);
 969 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, raydium_i2c_update_fw_store);
 970 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, raydium_i2c_calibrate_store);
 971
 972 static struct attribute *raydium_i2c_attributes[] = {
 973         &dev_attr_update_fw.attr,
 974         &dev_attr_boot_mode.attr,
 975         &dev_attr_fw_version.attr,
 976         &dev_attr_hw_version.attr,
 977         &dev_attr_calibrate.attr,
 978         NULL
 979 };
 980
 981 static const struct attribute_group raydium_i2c_attribute_group = {
 982         .attrs = raydium_i2c_attributes,
 983 };
 984
 985 static int raydium_i2c_power_on(struct raydium_data *ts)
 986 {
 987         int error;
 988
 989         if (!ts->reset_gpio)
 990                 return 0;
 991
 992         gpiod_set_value_cansleep(ts->reset_gpio, 1);
 993
 994         error = regulator_enable(ts->avdd);
 995         if (error) {
 996                 dev_err(&ts->client->dev,
 997                         "failed to enable avdd regulator: %d\n", error);
 998                 goto release_reset_gpio;
 999         }
1000
1001         error = regulator_enable(ts->vccio);
1002         if (error) {
1003                 regulator_disable(ts->avdd);
1004                 dev_err(&ts->client->dev,
1005                         "failed to enable vccio regulator: %d\n", error);
1006                 goto release_reset_gpio;
1007         }
1008
1009         udelay(RM_POWERON_DELAY_USEC);
1010
1011 release_reset_gpio:
1012         gpiod_set_value_cansleep(ts->reset_gpio, 0);
1013
1014         if (error)
1015                 return error;
1016
1017         msleep(RM_RESET_DELAY_MSEC);
1018
1019         return 0;
1020 }
1021
1022 static void raydium_i2c_power_off(void *_data)
1023 {
1024         struct raydium_data *ts = _data;
1025
1026         if (ts->reset_gpio) {
1027                 gpiod_set_value_cansleep(ts->reset_gpio, 1);
1028                 regulator_disable(ts->vccio);
1029                 regulator_disable(ts->avdd);
1030         }
1031 }
1032
1033 static int raydium_i2c_probe(struct i2c_client *client,
1034                              const struct i2c_device_id *id)
1035 {
1036         union i2c_smbus_data dummy;
1037         struct raydium_data *ts;
1038         int error;
1039
1040         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1041                 dev_err(&client->dev,
1042                         "i2c check functionality error (need I2C_FUNC_I2C)\n");
1043                 return -ENXIO;
1044         }
1045
1046         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1047         if (!ts)
1048                 return -ENOMEM;
1049
1050         mutex_init(&ts->sysfs_mutex);
1051
1052         ts->client = client;
1053         i2c_set_clientdata(client, ts);
1054
1055         ts->avdd = devm_regulator_get(&client->dev, "avdd");
1056         if (IS_ERR(ts->avdd)) {
1057                 error = PTR_ERR(ts->avdd);
1058                 if (error != -EPROBE_DEFER)
1059                         dev_err(&client->dev,
1060                                 "Failed to get 'avdd' regulator: %d\n", error);
1061                 return error;
1062         }
1063
1064         ts->vccio = devm_regulator_get(&client->dev, "vccio");
1065         if (IS_ERR(ts->vccio)) {
1066                 error = PTR_ERR(ts->vccio);
1067                 if (error != -EPROBE_DEFER)
1068                         dev_err(&client->dev,
1069                                 "Failed to get 'vccio' regulator: %d\n", error);
1070                 return error;
1071         }
1072
1073         ts->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",
1074                                                  GPIOD_OUT_LOW);
1075         if (IS_ERR(ts->reset_gpio)) {
1076                 error = PTR_ERR(ts->reset_gpio);
1077                 if (error != -EPROBE_DEFER)
1078                         dev_err(&client->dev,
1079                                 "failed to get reset gpio: %d\n", error);
1080                 return error;
1081         }
1082
1083         error = raydium_i2c_power_on(ts);
1084         if (error)
1085                 return error;
1086
1087         error = devm_add_action(&client->dev, raydium_i2c_power_off, ts);
1088         if (error) {
1089                 dev_err(&client->dev,
1090                         "failed to install power off action: %d\n", error);
1091                 raydium_i2c_power_off(ts);
1092                 return error;
1093         }
1094
1095         /* Make sure there is something at this address */
1096         if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1097                            I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) {
1098                 dev_err(&client->dev, "nothing at this address\n");
1099                 return -ENXIO;
1100         }
1101
1102         error = raydium_i2c_initialize(ts);
1103         if (error) {
1104                 dev_err(&client->dev, "failed to initialize: %d\n", error);
1105                 return error;
1106         }
1107
1108         ts->report_data = devm_kmalloc(&client->dev,
1109                                        ts->pkg_size, GFP_KERNEL);
1110         if (!ts->report_data)
1111                 return -ENOMEM;
1112
1113         ts->input = devm_input_allocate_device(&client->dev);
1114         if (!ts->input) {
1115                 dev_err(&client->dev, "Failed to allocate input device\n");
1116                 return -ENOMEM;
1117         }
1118
1119         ts->input->name = "Raydium Touchscreen";
1120         ts->input->id.bustype = BUS_I2C;
1121
1122         input_set_abs_params(ts->input, ABS_MT_POSITION_X,
1123                              0, le16_to_cpu(ts->info.x_max), 0, 0);
1124         input_set_abs_params(ts->input, ABS_MT_POSITION_Y,
1125                              0, le16_to_cpu(ts->info.y_max), 0, 0);
1126         input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->info.x_res);
1127         input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->info.y_res);
1128
1129         input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1130         input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
1131
1132         error = input_mt_init_slots(ts->input, RM_MAX_TOUCH_NUM,
1133                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1134         if (error) {
1135                 dev_err(&client->dev,
1136                         "failed to initialize MT slots: %d\n", error);
1137                 return error;
1138         }
1139
1140         error = input_register_device(ts->input);
1141         if (error) {
1142                 dev_err(&client->dev,
1143                         "unable to register input device: %d\n", error);
1144                 return error;
1145         }
1146
1147         error = devm_request_threaded_irq(&client->dev, client->irq,
1148                                           NULL, raydium_i2c_irq,
1149                                           IRQF_ONESHOT, client->name, ts);
1150         if (error) {
1151                 dev_err(&client->dev, "Failed to register interrupt\n");
1152                 return error;
1153         }
1154
1155         error = devm_device_add_group(&client->dev,
1156                                    &raydium_i2c_attribute_group);
1157         if (error) {
1158                 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1159                         error);
1160                 return error;
1161         }
1162
1163         return 0;
1164 }
1165
1166 static void __maybe_unused raydium_enter_sleep(struct i2c_client *client)
1167 {
1168         static const u8 sleep_cmd[] = { 0x5A, 0xff, 0x00, 0x0f };
1169         int error;
1170
1171         error = raydium_i2c_send(client, RM_CMD_ENTER_SLEEP,
1172                                  sleep_cmd, sizeof(sleep_cmd));
1173         if (error)
1174                 dev_err(&client->dev,
1175                         "sleep command failed: %d\n", error);
1176 }
1177
1178 static int __maybe_unused raydium_i2c_suspend(struct device *dev)
1179 {
1180         struct i2c_client *client = to_i2c_client(dev);
1181         struct raydium_data *ts = i2c_get_clientdata(client);
1182
1183         /* Sleep is not available in BLDR recovery mode */
1184         if (ts->boot_mode != RAYDIUM_TS_MAIN)
1185                 return -EBUSY;
1186
1187         disable_irq(client->irq);
1188
1189         if (device_may_wakeup(dev)) {
1190                 raydium_enter_sleep(client);
1191
1192                 ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
1193         } else {
1194                 raydium_i2c_power_off(ts);
1195         }
1196
1197         return 0;
1198 }
1199
1200 static int __maybe_unused raydium_i2c_resume(struct device *dev)
1201 {
1202         struct i2c_client *client = to_i2c_client(dev);
1203         struct raydium_data *ts = i2c_get_clientdata(client);
1204
1205         if (device_may_wakeup(dev)) {
1206                 if (ts->wake_irq_enabled)
1207                         disable_irq_wake(client->irq);
1208                 raydium_i2c_sw_reset(client);
1209         } else {
1210                 raydium_i2c_power_on(ts);
1211                 raydium_i2c_initialize(ts);
1212         }
1213
1214         enable_irq(client->irq);
1215
1216         return 0;
1217 }
1218
1219 static SIMPLE_DEV_PM_OPS(raydium_i2c_pm_ops,
1220                          raydium_i2c_suspend, raydium_i2c_resume);
1221
1222 static const struct i2c_device_id raydium_i2c_id[] = {
1223         { "raydium_i2c" , 0 },
1224         { "rm32380", 0 },
1225         { /* sentinel */ }
1226 };
1227 MODULE_DEVICE_TABLE(i2c, raydium_i2c_id);
1228
1229 #ifdef CONFIG_ACPI
1230 static const struct acpi_device_id raydium_acpi_id[] = {
1231         { "RAYD0001", 0 },
1232         { /* sentinel */ }
1233 };
1234 MODULE_DEVICE_TABLE(acpi, raydium_acpi_id);
1235 #endif
1236
1237 #ifdef CONFIG_OF
1238 static const struct of_device_id raydium_of_match[] = {
1239         { .compatible = "raydium,rm32380", },
1240         { /* sentinel */ }
1241 };
1242 MODULE_DEVICE_TABLE(of, raydium_of_match);
1243 #endif
1244
1245 static struct i2c_driver raydium_i2c_driver = {
1246         .probe = raydium_i2c_probe,
1247         .id_table = raydium_i2c_id,
1248         .driver = {
1249                 .name = "raydium_ts",
1250                 .pm = &raydium_i2c_pm_ops,
1251                 .acpi_match_table = ACPI_PTR(raydium_acpi_id),
1252                 .of_match_table = of_match_ptr(raydium_of_match),
1253         },
1254 };
1255 module_i2c_driver(raydium_i2c_driver);
1256
1257 MODULE_AUTHOR("Raydium");
1258 MODULE_DESCRIPTION("Raydium I2c Touchscreen driver");
1259 MODULE_LICENSE("GPL v2");