linux/drivers/input/touchscreen/raydium_i2c_ts.c
<<
>>
Prefs
   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
  85enum raydium_bl_cmd {
  86        BL_HEADER = 0,
  87        BL_PAGE_STR,
  88        BL_PKG_IDX,
  89        BL_DATA_STR,
  90};
  91
  92enum raydium_bl_ack {
  93        RAYDIUM_ACK_NULL = 0,
  94        RAYDIUM_WAIT_READY,
  95        RAYDIUM_PATH_READY,
  96};
  97
  98enum raydium_boot_mode {
  99        RAYDIUM_TS_MAIN = 0,
 100        RAYDIUM_TS_BLDR,
 101};
 102
 103/* Response to RM_CMD_DATA_BANK request */
 104struct raydium_data_info {
 105        __le32 data_bank_addr;
 106        u8 pkg_size;
 107        u8 tp_info_size;
 108};
 109
 110struct 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 */
 124struct 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
 148static 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
 182static 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
 207static 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
 235static 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
 249static 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
 266static 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
 320static 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
 340static 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
 376static 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
 417static 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
 444static 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
 472static 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
 498static 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
 513static 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
 529static 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
 545static 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
 566static 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
 582static 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
 619static 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
 630static 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
 751static 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
 791out_enable_irq:
 792        enable_irq(client->irq);
 793        msleep(100);
 794
 795        release_firmware(fw);
 796
 797out_free_fw_file:
 798        kfree(fw_file);
 799
 800        return error;
 801}
 802
 803static 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
 836static 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
 862out:
 863        return IRQ_HANDLED;
 864}
 865
 866static 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
 875static 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
 884static 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
 896static 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
 915static 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
 937static DEVICE_ATTR(fw_version, S_IRUGO, raydium_i2c_fw_ver_show, NULL);
 938static DEVICE_ATTR(hw_version, S_IRUGO, raydium_i2c_hw_ver_show, NULL);
 939static DEVICE_ATTR(boot_mode, S_IRUGO, raydium_i2c_boot_mode_show, NULL);
 940static DEVICE_ATTR(update_fw, S_IWUSR, NULL, raydium_i2c_update_fw_store);
 941static DEVICE_ATTR(calibrate, S_IWUSR, NULL, raydium_i2c_calibrate_store);
 942
 943static 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
 952static const struct attribute_group raydium_i2c_attribute_group = {
 953        .attrs = raydium_i2c_attributes,
 954};
 955
 956static 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
 982release_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
 993static 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
1004static 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
1137static 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
1149static 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
1171static 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
1190static SIMPLE_DEV_PM_OPS(raydium_i2c_pm_ops,
1191                         raydium_i2c_suspend, raydium_i2c_resume);
1192
1193static const struct i2c_device_id raydium_i2c_id[] = {
1194        { "raydium_i2c" , 0 },
1195        { "rm32380", 0 },
1196        { /* sentinel */ }
1197};
1198MODULE_DEVICE_TABLE(i2c, raydium_i2c_id);
1199
1200#ifdef CONFIG_ACPI
1201static const struct acpi_device_id raydium_acpi_id[] = {
1202        { "RAYD0001", 0 },
1203        { /* sentinel */ }
1204};
1205MODULE_DEVICE_TABLE(acpi, raydium_acpi_id);
1206#endif
1207
1208#ifdef CONFIG_OF
1209static const struct of_device_id raydium_of_match[] = {
1210        { .compatible = "raydium,rm32380", },
1211        { /* sentinel */ }
1212};
1213MODULE_DEVICE_TABLE(of, raydium_of_match);
1214#endif
1215
1216static 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};
1226module_i2c_driver(raydium_i2c_driver);
1227
1228MODULE_AUTHOR("Raydium");
1229MODULE_DESCRIPTION("Raydium I2c Touchscreen driver");
1230MODULE_LICENSE("GPL v2");
1231