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 0;
 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 0;
 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                                 "failied 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         const char *fw_file = "raydium.fw";
 756         int error;
 757
 758         error = request_firmware(&fw, fw_file, &client->dev);
 759         if (error) {
 760                 dev_err(&client->dev, "Unable to open firmware %s\n", fw_file);
 761                 return error;
 762         }
 763
 764         disable_irq(client->irq);
 765
 766         error = raydium_i2c_do_update_firmware(ts, fw);
 767         if (error) {
 768                 dev_err(&client->dev, "firmware update failed: %d\n", error);
 769                 ts->boot_mode = RAYDIUM_TS_BLDR;
 770                 goto out_enable_irq;
 771         }
 772
 773         error = raydium_i2c_initialize(ts);
 774         if (error) {
 775                 dev_err(&client->dev,
 776                         "failed to initialize device after firmware update: %d\n",
 777                         error);
 778                 ts->boot_mode = RAYDIUM_TS_BLDR;
 779                 goto out_enable_irq;
 780         }
 781
 782         ts->boot_mode = RAYDIUM_TS_MAIN;
 783
 784 out_enable_irq:
 785         enable_irq(client->irq);
 786         msleep(100);
 787
 788         release_firmware(fw);
 789
 790         return error;
 791 }
 792
 793 static void raydium_mt_event(struct raydium_data *ts)
 794 {
 795         int i;
 796
 797         for (i = 0; i < ts->report_size / ts->contact_size; i++) {
 798                 u8 *contact = &ts->report_data[ts->contact_size * i];
 799                 bool state = contact[RM_CONTACT_STATE_POS];
 800                 u8 wx, wy;
 801
 802                 input_mt_slot(ts->input, i);
 803                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, state);
 804
 805                 if (!state)
 806                         continue;
 807
 808                 input_report_abs(ts->input, ABS_MT_POSITION_X,
 809                                 get_unaligned_le16(&contact[RM_CONTACT_X_POS]));
 810                 input_report_abs(ts->input, ABS_MT_POSITION_Y,
 811                                 get_unaligned_le16(&contact[RM_CONTACT_Y_POS]));
 812                 input_report_abs(ts->input, ABS_MT_PRESSURE,
 813                                 contact[RM_CONTACT_PRESSURE_POS]);
 814
 815                 wx = contact[RM_CONTACT_WIDTH_X_POS];
 816                 wy = contact[RM_CONTACT_WIDTH_Y_POS];
 817
 818                 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, max(wx, wy));
 819                 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, min(wx, wy));
 820         }
 821
 822         input_mt_sync_frame(ts->input);
 823         input_sync(ts->input);
 824 }
 825
 826 static irqreturn_t raydium_i2c_irq(int irq, void *_dev)
 827 {
 828         struct raydium_data *ts = _dev;
 829         int error;
 830         u16 fw_crc;
 831         u16 calc_crc;
 832
 833         if (ts->boot_mode != RAYDIUM_TS_MAIN)
 834                 goto out;
 835
 836         error = raydium_i2c_read_message(ts->client, ts->data_bank_addr,
 837                                          ts->report_data, ts->pkg_size);
 838         if (error)
 839                 goto out;
 840
 841         fw_crc = get_unaligned_le16(&ts->report_data[ts->report_size]);
 842         calc_crc = raydium_calc_chksum(ts->report_data, ts->report_size);
 843         if (unlikely(fw_crc != calc_crc)) {
 844                 dev_warn(&ts->client->dev,
 845                          "%s: invalid packet crc %#04x vs %#04x\n",
 846                          __func__, calc_crc, fw_crc);
 847                 goto out;
 848         }
 849
 850         raydium_mt_event(ts);
 851
 852 out:
 853         return IRQ_HANDLED;
 854 }
 855
 856 static ssize_t raydium_i2c_fw_ver_show(struct device *dev,
 857                                        struct device_attribute *attr, char *buf)
 858 {
 859         struct i2c_client *client = to_i2c_client(dev);
 860         struct raydium_data *ts = i2c_get_clientdata(client);
 861
 862         return sprintf(buf, "%d.%d\n", ts->info.main_ver, ts->info.sub_ver);
 863 }
 864
 865 static ssize_t raydium_i2c_hw_ver_show(struct device *dev,
 866                                        struct device_attribute *attr, char *buf)
 867 {
 868         struct i2c_client *client = to_i2c_client(dev);
 869         struct raydium_data *ts = i2c_get_clientdata(client);
 870
 871         return sprintf(buf, "%#04x\n", le32_to_cpu(ts->info.hw_ver));
 872 }
 873
 874 static ssize_t raydium_i2c_boot_mode_show(struct device *dev,
 875                                           struct device_attribute *attr,
 876                                           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, "%s\n",
 882                        ts->boot_mode == RAYDIUM_TS_MAIN ?
 883                                 "Normal" : "Recovery");
 884 }
 885
 886 static ssize_t raydium_i2c_update_fw_store(struct device *dev,
 887                                            struct device_attribute *attr,
 888                                            const char *buf, size_t count)
 889 {
 890         struct i2c_client *client = to_i2c_client(dev);
 891         struct raydium_data *ts = i2c_get_clientdata(client);
 892         int error;
 893
 894         error = mutex_lock_interruptible(&ts->sysfs_mutex);
 895         if (error)
 896                 return error;
 897
 898         error = raydium_i2c_fw_update(ts);
 899
 900         mutex_unlock(&ts->sysfs_mutex);
 901
 902         return error ?: count;
 903 }
 904
 905 static ssize_t raydium_i2c_calibrate_store(struct device *dev,
 906                                            struct device_attribute *attr,
 907                                            const char *buf, size_t count)
 908 {
 909         struct i2c_client *client = to_i2c_client(dev);
 910         struct raydium_data *ts = i2c_get_clientdata(client);
 911         static const u8 cal_cmd[] = { 0x00, 0x01, 0x9E };
 912         int error;
 913
 914         error = mutex_lock_interruptible(&ts->sysfs_mutex);
 915         if (error)
 916                 return error;
 917
 918         error = raydium_i2c_write_object(client, cal_cmd, sizeof(cal_cmd),
 919                                          RAYDIUM_WAIT_READY);
 920         if (error)
 921                 dev_err(&client->dev, "calibrate command failed: %d\n", error);
 922
 923         mutex_unlock(&ts->sysfs_mutex);
 924         return error ?: count;
 925 }
 926
 927 static DEVICE_ATTR(fw_version, S_IRUGO, raydium_i2c_fw_ver_show, NULL);
 928 static DEVICE_ATTR(hw_version, S_IRUGO, raydium_i2c_hw_ver_show, NULL);
 929 static DEVICE_ATTR(boot_mode, S_IRUGO, raydium_i2c_boot_mode_show, NULL);
 930 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, raydium_i2c_update_fw_store);
 931 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, raydium_i2c_calibrate_store);
 932
 933 static struct attribute *raydium_i2c_attributes[] = {
 934         &dev_attr_update_fw.attr,
 935         &dev_attr_boot_mode.attr,
 936         &dev_attr_fw_version.attr,
 937         &dev_attr_hw_version.attr,
 938         &dev_attr_calibrate.attr,
 939         NULL
 940 };
 941
 942 static struct attribute_group raydium_i2c_attribute_group = {
 943         .attrs = raydium_i2c_attributes,
 944 };
 945
 946 static void raydium_i2c_remove_sysfs_group(void *_data)
 947 {
 948         struct raydium_data *ts = _data;
 949
 950         sysfs_remove_group(&ts->client->dev.kobj, &raydium_i2c_attribute_group);
 951 }
 952
 953 static int raydium_i2c_power_on(struct raydium_data *ts)
 954 {
 955         int error;
 956
 957         if (!ts->reset_gpio)
 958                 return 0;
 959
 960         gpiod_set_value_cansleep(ts->reset_gpio, 1);
 961
 962         error = regulator_enable(ts->avdd);
 963         if (error) {
 964                 dev_err(&ts->client->dev,
 965                         "failed to enable avdd regulator: %d\n", error);
 966                 goto release_reset_gpio;
 967         }
 968
 969         error = regulator_enable(ts->vccio);
 970         if (error) {
 971                 regulator_disable(ts->avdd);
 972                 dev_err(&ts->client->dev,
 973                         "failed to enable vccio regulator: %d\n", error);
 974                 goto release_reset_gpio;
 975         }
 976
 977         udelay(RM_POWERON_DELAY_USEC);
 978
 979 release_reset_gpio:
 980         gpiod_set_value_cansleep(ts->reset_gpio, 0);
 981
 982         if (error)
 983                 return error;
 984
 985         msleep(RM_RESET_DELAY_MSEC);
 986
 987         return 0;
 988 }
 989
 990 static void raydium_i2c_power_off(void *_data)
 991 {
 992         struct raydium_data *ts = _data;
 993
 994         if (ts->reset_gpio) {
 995                 gpiod_set_value_cansleep(ts->reset_gpio, 1);
 996                 regulator_disable(ts->vccio);
 997                 regulator_disable(ts->avdd);
 998         }
 999 }
1000
1001 static int raydium_i2c_probe(struct i2c_client *client,
1002                              const struct i2c_device_id *id)
1003 {
1004         union i2c_smbus_data dummy;
1005         struct raydium_data *ts;
1006         int error;
1007
1008         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1009                 dev_err(&client->dev,
1010                         "i2c check functionality error (need I2C_FUNC_I2C)\n");
1011                 return -ENXIO;
1012         }
1013
1014         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1015         if (!ts)
1016                 return -ENOMEM;
1017
1018         mutex_init(&ts->sysfs_mutex);
1019
1020         ts->client = client;
1021         i2c_set_clientdata(client, ts);
1022
1023         ts->avdd = devm_regulator_get(&client->dev, "avdd");
1024         if (IS_ERR(ts->avdd)) {
1025                 error = PTR_ERR(ts->avdd);
1026                 if (error != -EPROBE_DEFER)
1027                         dev_err(&client->dev,
1028                                 "Failed to get 'avdd' regulator: %d\n", error);
1029                 return error;
1030         }
1031
1032         ts->vccio = devm_regulator_get(&client->dev, "vccio");
1033         if (IS_ERR(ts->vccio)) {
1034                 error = PTR_ERR(ts->vccio);
1035                 if (error != -EPROBE_DEFER)
1036                         dev_err(&client->dev,
1037                                 "Failed to get 'vccio' regulator: %d\n", error);
1038                 return error;
1039         }
1040
1041         ts->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",
1042                                                  GPIOD_OUT_LOW);
1043         if (IS_ERR(ts->reset_gpio)) {
1044                 error = PTR_ERR(ts->reset_gpio);
1045                 if (error != -EPROBE_DEFER)
1046                         dev_err(&client->dev,
1047                                 "failed to get reset gpio: %d\n", error);
1048                 return error;
1049         }
1050
1051         error = raydium_i2c_power_on(ts);
1052         if (error)
1053                 return error;
1054
1055         error = devm_add_action(&client->dev, raydium_i2c_power_off, ts);
1056         if (error) {
1057                 dev_err(&client->dev,
1058                         "failed to install power off action: %d\n", error);
1059                 raydium_i2c_power_off(ts);
1060                 return error;
1061         }
1062
1063         /* Make sure there is something at this address */
1064         if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1065                            I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) {
1066                 dev_err(&client->dev, "nothing at this address\n");
1067                 return -ENXIO;
1068         }
1069
1070         error = raydium_i2c_initialize(ts);
1071         if (error) {
1072                 dev_err(&client->dev, "failed to initialize: %d\n", error);
1073                 return error;
1074         }
1075
1076         ts->report_data = devm_kmalloc(&client->dev,
1077                                        ts->pkg_size, GFP_KERNEL);
1078         if (!ts->report_data)
1079                 return -ENOMEM;
1080
1081         ts->input = devm_input_allocate_device(&client->dev);
1082         if (!ts->input) {
1083                 dev_err(&client->dev, "Failed to allocate input device\n");
1084                 return -ENOMEM;
1085         }
1086
1087         ts->input->name = "Raydium Touchscreen";
1088         ts->input->id.bustype = BUS_I2C;
1089
1090         input_set_drvdata(ts->input, ts);
1091
1092         input_set_abs_params(ts->input, ABS_MT_POSITION_X,
1093                              0, le16_to_cpu(ts->info.x_max), 0, 0);
1094         input_set_abs_params(ts->input, ABS_MT_POSITION_Y,
1095                              0, le16_to_cpu(ts->info.y_max), 0, 0);
1096         input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->info.x_res);
1097         input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->info.y_res);
1098
1099         input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1100         input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
1101
1102         error = input_mt_init_slots(ts->input, RM_MAX_TOUCH_NUM,
1103                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1104         if (error) {
1105                 dev_err(&client->dev,
1106                         "failed to initialize MT slots: %d\n", error);
1107                 return error;
1108         }
1109
1110         error = input_register_device(ts->input);
1111         if (error) {
1112                 dev_err(&client->dev,
1113                         "unable to register input device: %d\n", error);
1114                 return error;
1115         }
1116
1117         error = devm_request_threaded_irq(&client->dev, client->irq,
1118                                           NULL, raydium_i2c_irq,
1119                                           IRQF_ONESHOT, client->name, ts);
1120         if (error) {
1121                 dev_err(&client->dev, "Failed to register interrupt\n");
1122                 return error;
1123         }
1124
1125         error = sysfs_create_group(&client->dev.kobj,
1126                                    &raydium_i2c_attribute_group);
1127         if (error) {
1128                 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1129                         error);
1130                 return error;
1131         }
1132
1133         error = devm_add_action(&client->dev,
1134                                 raydium_i2c_remove_sysfs_group, ts);
1135         if (error) {
1136                 raydium_i2c_remove_sysfs_group(ts);
1137                 dev_err(&client->dev,
1138                         "Failed to add sysfs cleanup action: %d\n", error);
1139                 return error;
1140         }
1141
1142         return 0;
1143 }
1144
1145 static void __maybe_unused raydium_enter_sleep(struct i2c_client *client)
1146 {
1147         static const u8 sleep_cmd[] = { 0x5A, 0xff, 0x00, 0x0f };
1148         int error;
1149
1150         error = raydium_i2c_send(client, RM_CMD_ENTER_SLEEP,
1151                                  sleep_cmd, sizeof(sleep_cmd));
1152         if (error)
1153                 dev_err(&client->dev,
1154                         "sleep command failed: %d\n", error);
1155 }
1156
1157 static int __maybe_unused raydium_i2c_suspend(struct device *dev)
1158 {
1159         struct i2c_client *client = to_i2c_client(dev);
1160         struct raydium_data *ts = i2c_get_clientdata(client);
1161
1162         /* Sleep is not available in BLDR recovery mode */
1163         if (ts->boot_mode != RAYDIUM_TS_MAIN)
1164                 return -EBUSY;
1165
1166         disable_irq(client->irq);
1167
1168         if (device_may_wakeup(dev)) {
1169                 raydium_enter_sleep(client);
1170
1171                 ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
1172         } else {
1173                 raydium_i2c_power_off(ts);
1174         }
1175
1176         return 0;
1177 }
1178
1179 static int __maybe_unused raydium_i2c_resume(struct device *dev)
1180 {
1181         struct i2c_client *client = to_i2c_client(dev);
1182         struct raydium_data *ts = i2c_get_clientdata(client);
1183
1184         if (device_may_wakeup(dev)) {
1185                 if (ts->wake_irq_enabled)
1186                         disable_irq_wake(client->irq);
1187                 raydium_i2c_sw_reset(client);
1188         } else {
1189                 raydium_i2c_power_on(ts);
1190                 raydium_i2c_initialize(ts);
1191         }
1192
1193         enable_irq(client->irq);
1194
1195         return 0;
1196 }
1197
1198 static SIMPLE_DEV_PM_OPS(raydium_i2c_pm_ops,
1199                          raydium_i2c_suspend, raydium_i2c_resume);
1200
1201 static const struct i2c_device_id raydium_i2c_id[] = {
1202         { "raydium_i2c" , 0 },
1203         { "rm32380", 0 },
1204         { /* sentinel */ }
1205 };
1206 MODULE_DEVICE_TABLE(i2c, raydium_i2c_id);
1207
1208 #ifdef CONFIG_ACPI
1209 static const struct acpi_device_id raydium_acpi_id[] = {
1210         { "RAYD0001", 0 },
1211         { /* sentinel */ }
1212 };
1213 MODULE_DEVICE_TABLE(acpi, raydium_acpi_id);
1214 #endif
1215
1216 #ifdef CONFIG_OF
1217 static const struct of_device_id raydium_of_match[] = {
1218         { .compatible = "raydium,rm32380", },
1219         { /* sentinel */ }
1220 };
1221 MODULE_DEVICE_TABLE(of, raydium_of_match);
1222 #endif
1223
1224 static struct i2c_driver raydium_i2c_driver = {
1225         .probe = raydium_i2c_probe,
1226         .id_table = raydium_i2c_id,
1227         .driver = {
1228                 .name = "raydium_ts",
1229                 .pm = &raydium_i2c_pm_ops,
1230                 .acpi_match_table = ACPI_PTR(raydium_acpi_id),
1231                 .of_match_table = of_match_ptr(raydium_of_match),
1232         },
1233 };
1234 module_i2c_driver(raydium_i2c_driver);
1235
1236 MODULE_AUTHOR("Raydium");
1237 MODULE_DESCRIPTION("Raydium I2c Touchscreen driver");
1238 MODULE_LICENSE("GPL v2");