drivers/input/touchscreen/raydium_i2c_ts.c

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