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