drivers/input/touchscreen/melfas_mip4.c

   1 /*
   2  * MELFAS MIP4 Touchscreen
   3  *
   4  * Copyright (C) 2016 MELFAS Inc.
   5  *
   6  * Author : Sangwon Jee <jeesw@melfas.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/acpi.h>
  20 #include <linux/delay.h>
  21 #include <linux/firmware.h>
  22 #include <linux/gpio/consumer.h>
  23 #include <linux/i2c.h>
  24 #include <linux/input.h>
  25 #include <linux/input/mt.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/module.h>
  28 #include <linux/of.h>
  29 #include <linux/slab.h>
  30 #include <asm/unaligned.h>
  31
  32 #define MIP4_DEVICE_NAME        "mip4_ts"
  33
  34 /*****************************************************************
  35  * Protocol
  36  * Version : MIP 4.0 Rev 4.6
  37  *****************************************************************/
  38
  39 /* Address */
  40 #define MIP4_R0_BOOT                            0x00
  41 #define MIP4_R1_BOOT_MODE                       0x01
  42 #define MIP4_R1_BOOT_BUF_ADDR                   0x10
  43 #define MIP4_R1_BOOT_STATUS                     0x20
  44 #define MIP4_R1_BOOT_CMD                        0x30
  45 #define MIP4_R1_BOOT_TARGET_ADDR                0x40
  46 #define MIP4_R1_BOOT_SIZE                       0x44
  47
  48 #define MIP4_R0_INFO                            0x01
  49 #define MIP4_R1_INFO_PRODUCT_NAME               0x00
  50 #define MIP4_R1_INFO_RESOLUTION_X               0x10
  51 #define MIP4_R1_INFO_RESOLUTION_Y               0x12
  52 #define MIP4_R1_INFO_NODE_NUM_X                 0x14
  53 #define MIP4_R1_INFO_NODE_NUM_Y                 0x15
  54 #define MIP4_R1_INFO_KEY_NUM                    0x16
  55 #define MIP4_R1_INFO_PRESSURE_NUM               0x17
  56 #define MIP4_R1_INFO_LENGTH_X                   0x18
  57 #define MIP4_R1_INFO_LENGTH_Y                   0x1A
  58 #define MIP4_R1_INFO_PPM_X                      0x1C
  59 #define MIP4_R1_INFO_PPM_Y                      0x1D
  60 #define MIP4_R1_INFO_VERSION_BOOT               0x20
  61 #define MIP4_R1_INFO_VERSION_CORE               0x22
  62 #define MIP4_R1_INFO_VERSION_APP                0x24
  63 #define MIP4_R1_INFO_VERSION_PARAM              0x26
  64 #define MIP4_R1_INFO_SECT_BOOT_START            0x30
  65 #define MIP4_R1_INFO_SECT_BOOT_END              0x31
  66 #define MIP4_R1_INFO_SECT_CORE_START            0x32
  67 #define MIP4_R1_INFO_SECT_CORE_END              0x33
  68 #define MIP4_R1_INFO_SECT_APP_START             0x34
  69 #define MIP4_R1_INFO_SECT_APP_END               0x35
  70 #define MIP4_R1_INFO_SECT_PARAM_START           0x36
  71 #define MIP4_R1_INFO_SECT_PARAM_END             0x37
  72 #define MIP4_R1_INFO_BUILD_DATE                 0x40
  73 #define MIP4_R1_INFO_BUILD_TIME                 0x44
  74 #define MIP4_R1_INFO_CHECKSUM_PRECALC           0x48
  75 #define MIP4_R1_INFO_CHECKSUM_REALTIME          0x4A
  76 #define MIP4_R1_INFO_PROTOCOL_NAME              0x50
  77 #define MIP4_R1_INFO_PROTOCOL_VERSION           0x58
  78 #define MIP4_R1_INFO_IC_ID                      0x70
  79 #define MIP4_R1_INFO_IC_NAME                    0x71
  80 #define MIP4_R1_INFO_IC_VENDOR_ID               0x75
  81 #define MIP4_R1_INFO_IC_HW_CATEGORY             0x77
  82 #define MIP4_R1_INFO_CONTACT_THD_SCR            0x78
  83 #define MIP4_R1_INFO_CONTACT_THD_KEY            0x7A
  84
  85 #define MIP4_R0_EVENT                           0x02
  86 #define MIP4_R1_EVENT_SUPPORTED_FUNC            0x00
  87 #define MIP4_R1_EVENT_FORMAT                    0x04
  88 #define MIP4_R1_EVENT_SIZE                      0x06
  89 #define MIP4_R1_EVENT_PACKET_INFO               0x10
  90 #define MIP4_R1_EVENT_PACKET_DATA               0x11
  91
  92 #define MIP4_R0_CTRL                            0x06
  93 #define MIP4_R1_CTRL_READY_STATUS               0x00
  94 #define MIP4_R1_CTRL_EVENT_READY                0x01
  95 #define MIP4_R1_CTRL_MODE                       0x10
  96 #define MIP4_R1_CTRL_EVENT_TRIGGER_TYPE         0x11
  97 #define MIP4_R1_CTRL_RECALIBRATE                0x12
  98 #define MIP4_R1_CTRL_POWER_STATE                0x13
  99 #define MIP4_R1_CTRL_GESTURE_TYPE               0x14
 100 #define MIP4_R1_CTRL_DISABLE_ESD_ALERT          0x18
 101 #define MIP4_R1_CTRL_CHARGER_MODE               0x19
 102 #define MIP4_R1_CTRL_HIGH_SENS_MODE             0x1A
 103 #define MIP4_R1_CTRL_WINDOW_MODE                0x1B
 104 #define MIP4_R1_CTRL_PALM_REJECTION             0x1C
 105 #define MIP4_R1_CTRL_EDGE_CORRECTION            0x1D
 106 #define MIP4_R1_CTRL_ENTER_GLOVE_MODE           0x1E
 107 #define MIP4_R1_CTRL_I2C_ON_LPM                 0x1F
 108 #define MIP4_R1_CTRL_GESTURE_DEBUG              0x20
 109 #define MIP4_R1_CTRL_PALM_EVENT                 0x22
 110 #define MIP4_R1_CTRL_PROXIMITY_SENSING          0x23
 111
 112 /* Value */
 113 #define MIP4_BOOT_MODE_BOOT                     0x01
 114 #define MIP4_BOOT_MODE_APP                      0x02
 115
 116 #define MIP4_BOOT_STATUS_BUSY                   0x05
 117 #define MIP4_BOOT_STATUS_ERROR                  0x0E
 118 #define MIP4_BOOT_STATUS_DONE                   0xA0
 119
 120 #define MIP4_BOOT_CMD_MASS_ERASE                0x15
 121 #define MIP4_BOOT_CMD_PROGRAM                   0x54
 122 #define MIP4_BOOT_CMD_ERASE                     0x8F
 123 #define MIP4_BOOT_CMD_WRITE                     0xA5
 124 #define MIP4_BOOT_CMD_READ                      0xC2
 125
 126 #define MIP4_EVENT_INPUT_TYPE_KEY               0
 127 #define MIP4_EVENT_INPUT_TYPE_SCREEN            1
 128 #define MIP4_EVENT_INPUT_TYPE_PROXIMITY         2
 129
 130 #define I2C_RETRY_COUNT                         3       /* 2~ */
 131
 132 #define MIP4_BUF_SIZE                           128
 133 #define MIP4_MAX_FINGERS                        10
 134 #define MIP4_MAX_KEYS                           4
 135
 136 #define MIP4_TOUCH_MAJOR_MIN                    0
 137 #define MIP4_TOUCH_MAJOR_MAX                    255
 138 #define MIP4_TOUCH_MINOR_MIN                    0
 139 #define MIP4_TOUCH_MINOR_MAX                    255
 140 #define MIP4_PRESSURE_MIN                       0
 141 #define MIP4_PRESSURE_MAX                       255
 142
 143 #define MIP4_FW_NAME                    "melfas_mip4.fw"
 144 #define MIP4_FW_UPDATE_DEBUG            0       /* 0 (default) or 1 */
 145
 146 struct mip4_fw_version {
 147         u16 boot;
 148         u16 core;
 149         u16 app;
 150         u16 param;
 151 };
 152
 153 struct mip4_ts {
 154         struct i2c_client *client;
 155         struct input_dev *input;
 156         struct gpio_desc *gpio_ce;
 157
 158         char phys[32];
 159         char product_name[16];
 160
 161         unsigned int max_x;
 162         unsigned int max_y;
 163         u8 node_x;
 164         u8 node_y;
 165         u8 node_key;
 166         unsigned int ppm_x;
 167         unsigned int ppm_y;
 168
 169         struct mip4_fw_version fw_version;
 170
 171         unsigned int event_size;
 172         unsigned int event_format;
 173
 174         unsigned int key_num;
 175         unsigned short key_code[MIP4_MAX_KEYS];
 176
 177         bool wake_irq_enabled;
 178
 179         u8 buf[MIP4_BUF_SIZE];
 180 };
 181
 182 static int mip4_i2c_xfer(struct mip4_ts *ts,
 183                          char *write_buf, unsigned int write_len,
 184                          char *read_buf, unsigned int read_len)
 185 {
 186         struct i2c_msg msg[] = {
 187                 {
 188                         .addr = ts->client->addr,
 189                         .flags = 0,
 190                         .buf = write_buf,
 191                         .len = write_len,
 192                 }, {
 193                         .addr = ts->client->addr,
 194                         .flags = I2C_M_RD,
 195                         .buf = read_buf,
 196                         .len = read_len,
 197                 },
 198         };
 199         int retry = I2C_RETRY_COUNT;
 200         int res;
 201         int error;
 202
 203         do {
 204                 res = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 205                 if (res == ARRAY_SIZE(msg))
 206                         return 0;
 207
 208                 error = res < 0 ? res : -EIO;
 209                 dev_err(&ts->client->dev,
 210                         "%s - i2c_transfer failed: %d (%d)\n",
 211                         __func__, error, res);
 212         } while (--retry);
 213
 214         return error;
 215 }
 216
 217 static void mip4_parse_fw_version(const u8 *buf, struct mip4_fw_version *v)
 218 {
 219         v->boot  = get_unaligned_le16(buf + 0);
 220         v->core  = get_unaligned_le16(buf + 2);
 221         v->app   = get_unaligned_le16(buf + 4);
 222         v->param = get_unaligned_le16(buf + 6);
 223 }
 224
 225 /*
 226  * Read chip firmware version
 227  */
 228 static int mip4_get_fw_version(struct mip4_ts *ts)
 229 {
 230         u8 cmd[] = { MIP4_R0_INFO, MIP4_R1_INFO_VERSION_BOOT };
 231         u8 buf[sizeof(ts->fw_version)];
 232         int error;
 233
 234         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, sizeof(buf));
 235         if (error) {
 236                 memset(&ts->fw_version, 0xff, sizeof(ts->fw_version));
 237                 return error;
 238         }
 239
 240         mip4_parse_fw_version(buf, &ts->fw_version);
 241
 242         return 0;
 243 }
 244
 245 /*
 246  * Fetch device characteristics
 247  */
 248 static int mip4_query_device(struct mip4_ts *ts)
 249 {
 250         int error;
 251         u8 cmd[2];
 252         u8 buf[14];
 253
 254         /* Product name */
 255         cmd[0] = MIP4_R0_INFO;
 256         cmd[1] = MIP4_R1_INFO_PRODUCT_NAME;
 257         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd),
 258                               ts->product_name, sizeof(ts->product_name));
 259         if (error)
 260                 dev_warn(&ts->client->dev,
 261                          "Failed to retrieve product name: %d\n", error);
 262         else
 263                 dev_dbg(&ts->client->dev, "product name: %.*s\n",
 264                         (int)sizeof(ts->product_name), ts->product_name);
 265
 266         /* Firmware version */
 267         error = mip4_get_fw_version(ts);
 268         if (error)
 269                 dev_warn(&ts->client->dev,
 270                         "Failed to retrieve FW version: %d\n", error);
 271         else
 272                 dev_dbg(&ts->client->dev, "F/W Version: %04X %04X %04X %04X\n",
 273                          ts->fw_version.boot, ts->fw_version.core,
 274                          ts->fw_version.app, ts->fw_version.param);
 275
 276         /* Resolution */
 277         cmd[0] = MIP4_R0_INFO;
 278         cmd[1] = MIP4_R1_INFO_RESOLUTION_X;
 279         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, 14);
 280         if (error) {
 281                 dev_warn(&ts->client->dev,
 282                          "Failed to retrieve touchscreen parameters: %d\n",
 283                          error);
 284         } else {
 285                 ts->max_x = get_unaligned_le16(&buf[0]);
 286                 ts->max_y = get_unaligned_le16(&buf[2]);
 287                 dev_dbg(&ts->client->dev, "max_x: %d, max_y: %d\n",
 288                         ts->max_x, ts->max_y);
 289
 290                 ts->node_x = buf[4];
 291                 ts->node_y = buf[5];
 292                 ts->node_key = buf[6];
 293                 dev_dbg(&ts->client->dev,
 294                         "node_x: %d, node_y: %d, node_key: %d\n",
 295                         ts->node_x, ts->node_y, ts->node_key);
 296
 297                 ts->ppm_x = buf[12];
 298                 ts->ppm_y = buf[13];
 299                 dev_dbg(&ts->client->dev, "ppm_x: %d, ppm_y: %d\n",
 300                         ts->ppm_x, ts->ppm_y);
 301
 302                 /* Key ts */
 303                 if (ts->node_key > 0)
 304                         ts->key_num = ts->node_key;
 305         }
 306
 307         /* Protocol */
 308         cmd[0] = MIP4_R0_EVENT;
 309         cmd[1] = MIP4_R1_EVENT_SUPPORTED_FUNC;
 310         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, 7);
 311         if (error) {
 312                 dev_warn(&ts->client->dev,
 313                         "Failed to retrieve device type: %d\n", error);
 314                 ts->event_format = 0xff;
 315         } else {
 316                 ts->event_format = get_unaligned_le16(&buf[4]);
 317                 ts->event_size = buf[6];
 318                 dev_dbg(&ts->client->dev, "event_format: %d, event_size: %d\n",
 319                         ts->event_format, ts->event_size);
 320
 321                 if (ts->event_format == 2 || ts->event_format > 3)
 322                         dev_warn(&ts->client->dev,
 323                                  "Unknown event format %d\n", ts->event_format);
 324         }
 325
 326         return 0;
 327 }
 328
 329 static int mip4_power_on(struct mip4_ts *ts)
 330 {
 331         if (ts->gpio_ce) {
 332                 gpiod_set_value_cansleep(ts->gpio_ce, 1);
 333
 334                 /* Booting delay : 200~300ms */
 335                 usleep_range(200 * 1000, 300 * 1000);
 336         }
 337
 338         return 0;
 339 }
 340
 341 static void mip4_power_off(struct mip4_ts *ts)
 342 {
 343         if (ts->gpio_ce)
 344                 gpiod_set_value_cansleep(ts->gpio_ce, 0);
 345 }
 346
 347 /*
 348  * Clear touch input event status
 349  */
 350 static void mip4_clear_input(struct mip4_ts *ts)
 351 {
 352         int i;
 353
 354         /* Screen */
 355         for (i = 0; i < MIP4_MAX_FINGERS; i++) {
 356                 input_mt_slot(ts->input, i);
 357                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 0);
 358         }
 359
 360         /* Keys */
 361         for (i = 0; i < ts->key_num; i++)
 362                 input_report_key(ts->input, ts->key_code[i], 0);
 363
 364         input_sync(ts->input);
 365 }
 366
 367 static int mip4_enable(struct mip4_ts *ts)
 368 {
 369         int error;
 370
 371         error = mip4_power_on(ts);
 372         if (error)
 373                 return error;
 374
 375         enable_irq(ts->client->irq);
 376
 377         return 0;
 378 }
 379
 380 static void mip4_disable(struct mip4_ts *ts)
 381 {
 382         disable_irq(ts->client->irq);
 383
 384         mip4_power_off(ts);
 385
 386         mip4_clear_input(ts);
 387 }
 388
 389 /*****************************************************************
 390  * Input handling
 391  *****************************************************************/
 392
 393 static void mip4_report_keys(struct mip4_ts *ts, u8 *packet)
 394 {
 395         u8 key;
 396         bool down;
 397
 398         switch (ts->event_format) {
 399         case 0:
 400         case 1:
 401                 key = packet[0] & 0x0F;
 402                 down = packet[0] & 0x80;
 403                 break;
 404
 405         case 3:
 406         default:
 407                 key = packet[0] & 0x0F;
 408                 down = packet[1] & 0x01;
 409                 break;
 410         }
 411
 412         /* Report key event */
 413         if (key >= 1 && key <= ts->key_num) {
 414                 unsigned short keycode = ts->key_code[key - 1];
 415
 416                 dev_dbg(&ts->client->dev,
 417                         "Key - ID: %d, keycode: %d, state: %d\n",
 418                         key, keycode, down);
 419
 420                 input_event(ts->input, EV_MSC, MSC_SCAN, keycode);
 421                 input_report_key(ts->input, keycode, down);
 422
 423         } else {
 424                 dev_err(&ts->client->dev, "Unknown key: %d\n", key);
 425         }
 426 }
 427
 428 static void mip4_report_touch(struct mip4_ts *ts, u8 *packet)
 429 {
 430         int id;
 431         bool hover;
 432         bool palm;
 433         bool state;
 434         u16 x, y;
 435         u8 pressure_stage = 0;
 436         u8 pressure;
 437         u8 size;
 438         u8 touch_major;
 439         u8 touch_minor;
 440
 441         switch (ts->event_format) {
 442         case 0:
 443         case 1:
 444                 /* Touch only */
 445                 state = packet[0] & BIT(7);
 446                 hover = packet[0] & BIT(5);
 447                 palm = packet[0] & BIT(4);
 448                 id = (packet[0] & 0x0F) - 1;
 449                 x = ((packet[1] & 0x0F) << 8) | packet[2];
 450                 y = (((packet[1] >> 4) & 0x0F) << 8) |
 451                         packet[3];
 452                 pressure = packet[4];
 453                 size = packet[5];
 454                 if (ts->event_format == 0) {
 455                         touch_major = packet[5];
 456                         touch_minor = packet[5];
 457                 } else {
 458                         touch_major = packet[6];
 459                         touch_minor = packet[7];
 460                 }
 461                 break;
 462
 463         case 3:
 464         default:
 465                 /* Touch + Force(Pressure) */
 466                 id = (packet[0] & 0x0F) - 1;
 467                 hover = packet[1] & BIT(2);
 468                 palm = packet[1] & BIT(1);
 469                 state = packet[1] & BIT(0);
 470                 x = ((packet[2] & 0x0F) << 8) | packet[3];
 471                 y = (((packet[2] >> 4) & 0x0F) << 8) |
 472                         packet[4];
 473                 size = packet[6];
 474                 pressure_stage = (packet[7] & 0xF0) >> 4;
 475                 pressure = ((packet[7] & 0x0F) << 8) |
 476                         packet[8];
 477                 touch_major = packet[9];
 478                 touch_minor = packet[10];
 479                 break;
 480         }
 481
 482         dev_dbg(&ts->client->dev,
 483                 "Screen - Slot: %d State: %d X: %04d Y: %04d Z: %d\n",
 484                 id, state, x, y, pressure);
 485
 486         if (unlikely(id < 0 || id >= MIP4_MAX_FINGERS)) {
 487                 dev_err(&ts->client->dev, "Screen - invalid slot ID: %d\n", id);
 488         } else if (state) {
 489                 /* Press or Move event */
 490                 input_mt_slot(ts->input, id);
 491                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
 492                 input_report_abs(ts->input, ABS_MT_POSITION_X, x);
 493                 input_report_abs(ts->input, ABS_MT_POSITION_Y, y);
 494                 input_report_abs(ts->input, ABS_MT_PRESSURE, pressure);
 495                 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, touch_major);
 496                 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, touch_minor);
 497         } else {
 498                 /* Release event */
 499                 input_mt_slot(ts->input, id);
 500                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 0);
 501         }
 502
 503         input_mt_sync_frame(ts->input);
 504 }
 505
 506 static int mip4_handle_packet(struct mip4_ts *ts, u8 *packet)
 507 {
 508         u8 type;
 509
 510         switch (ts->event_format) {
 511         case 0:
 512         case 1:
 513                 type = (packet[0] & 0x40) >> 6;
 514                 break;
 515
 516         case 3:
 517                 type = (packet[0] & 0xF0) >> 4;
 518                 break;
 519
 520         default:
 521                 /* Should not happen unless we have corrupted firmware */
 522                 return -EINVAL;
 523         }
 524
 525         dev_dbg(&ts->client->dev, "Type: %d\n", type);
 526
 527         /* Report input event */
 528         switch (type) {
 529         case MIP4_EVENT_INPUT_TYPE_KEY:
 530                 mip4_report_keys(ts, packet);
 531                 break;
 532
 533         case MIP4_EVENT_INPUT_TYPE_SCREEN:
 534                 mip4_report_touch(ts, packet);
 535                 break;
 536
 537         default:
 538                 dev_err(&ts->client->dev, "Unknown event type: %d\n", type);
 539                 break;
 540         }
 541
 542         return 0;
 543 }
 544
 545 static irqreturn_t mip4_interrupt(int irq, void *dev_id)
 546 {
 547         struct mip4_ts *ts = dev_id;
 548         struct i2c_client *client = ts->client;
 549         unsigned int i;
 550         int error;
 551         u8 cmd[2];
 552         u8 size;
 553         bool alert;
 554
 555         /* Read packet info */
 556         cmd[0] = MIP4_R0_EVENT;
 557         cmd[1] = MIP4_R1_EVENT_PACKET_INFO;
 558         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), ts->buf, 1);
 559         if (error) {
 560                 dev_err(&client->dev,
 561                         "Failed to read packet info: %d\n", error);
 562                 goto out;
 563         }
 564
 565         size = ts->buf[0] & 0x7F;
 566         alert = ts->buf[0] & BIT(7);
 567         dev_dbg(&client->dev, "packet size: %d, alert: %d\n", size, alert);
 568
 569         /* Check size */
 570         if (!size) {
 571                 dev_err(&client->dev, "Empty packet\n");
 572                 goto out;
 573         }
 574
 575         /* Read packet data */
 576         cmd[0] = MIP4_R0_EVENT;
 577         cmd[1] = MIP4_R1_EVENT_PACKET_DATA;
 578         error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), ts->buf, size);
 579         if (error) {
 580                 dev_err(&client->dev,
 581                         "Failed to read packet data: %d\n", error);
 582                 goto out;
 583         }
 584
 585         if (alert) {
 586                 dev_dbg(&client->dev, "Alert: %d\n", ts->buf[0]);
 587         } else {
 588                 for (i = 0; i < size; i += ts->event_size) {
 589                         error = mip4_handle_packet(ts, &ts->buf[i]);
 590                         if (error)
 591                                 break;
 592                 }
 593
 594                 input_sync(ts->input);
 595         }
 596
 597 out:
 598         return IRQ_HANDLED;
 599 }
 600
 601 static int mip4_input_open(struct input_dev *dev)
 602 {
 603         struct mip4_ts *ts = input_get_drvdata(dev);
 604
 605         return mip4_enable(ts);
 606 }
 607
 608 static void mip4_input_close(struct input_dev *dev)
 609 {
 610         struct mip4_ts *ts = input_get_drvdata(dev);
 611
 612         mip4_disable(ts);
 613 }
 614
 615 /*****************************************************************
 616  * Firmware update
 617  *****************************************************************/
 618
 619 /* Firmware Info */
 620 #define MIP4_BL_PAGE_SIZE               512     /* 512 */
 621 #define MIP4_BL_PACKET_SIZE             512     /* 512, 256, 128, 64, ... */
 622
 623 /*
 624  * Firmware binary tail info
 625  */
 626
 627 struct mip4_bin_tail {
 628         u8 tail_mark[4];
 629         u8 chip_name[4];
 630
 631         __le32 bin_start_addr;
 632         __le32 bin_length;
 633
 634         __le16 ver_boot;
 635         __le16 ver_core;
 636         __le16 ver_app;
 637         __le16 ver_param;
 638
 639         u8 boot_start;
 640         u8 boot_end;
 641         u8 core_start;
 642         u8 core_end;
 643         u8 app_start;
 644         u8 app_end;
 645         u8 param_start;
 646         u8 param_end;
 647
 648         u8 checksum_type;
 649         u8 hw_category;
 650
 651         __le16 param_id;
 652         __le32 param_length;
 653         __le32 build_date;
 654         __le32 build_time;
 655
 656         __le32 reserved1;
 657         __le32 reserved2;
 658         __le16 reserved3;
 659         __le16 tail_size;
 660         __le32 crc;
 661 } __packed;
 662
 663 #define MIP4_BIN_TAIL_MARK      "MBT\001"
 664 #define MIP4_BIN_TAIL_SIZE      (sizeof(struct mip4_bin_tail))
 665
 666 /*
 667 * Bootloader - Read status
 668 */
 669 static int mip4_bl_read_status(struct mip4_ts *ts)
 670 {
 671         u8 cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_STATUS };
 672         u8 result;
 673         struct i2c_msg msg[] = {
 674                 {
 675                         .addr = ts->client->addr,
 676                         .flags = 0,
 677                         .buf = cmd,
 678                         .len = sizeof(cmd),
 679                 }, {
 680                         .addr = ts->client->addr,
 681                         .flags = I2C_M_RD,
 682                         .buf = &result,
 683                         .len = sizeof(result),
 684                 },
 685         };
 686         int ret;
 687         int error;
 688         int retry = 1000;
 689
 690         do {
 691                 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 692                 if (ret != ARRAY_SIZE(msg)) {
 693                         error = ret < 0 ? ret : -EIO;
 694                         dev_err(&ts->client->dev,
 695                                 "Failed to read bootloader status: %d\n",
 696                                 error);
 697                         return error;
 698                 }
 699
 700                 switch (result) {
 701                 case MIP4_BOOT_STATUS_DONE:
 702                         dev_dbg(&ts->client->dev, "%s - done\n", __func__);
 703                         return 0;
 704
 705                 case MIP4_BOOT_STATUS_ERROR:
 706                         dev_err(&ts->client->dev, "Bootloader failure\n");
 707                         return -EIO;
 708
 709                 case MIP4_BOOT_STATUS_BUSY:
 710                         dev_dbg(&ts->client->dev, "%s - Busy\n", __func__);
 711                         error = -EBUSY;
 712                         break;
 713
 714                 default:
 715                         dev_err(&ts->client->dev,
 716                                 "Unexpected bootloader status: %#02x\n",
 717                                 result);
 718                         error = -EINVAL;
 719                         break;
 720                 }
 721
 722                 usleep_range(1000, 2000);
 723         } while (--retry);
 724
 725         return error;
 726 }
 727
 728 /*
 729 * Bootloader - Change mode
 730 */
 731 static int mip4_bl_change_mode(struct mip4_ts *ts, u8 mode)
 732 {
 733         u8 mode_chg_cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_MODE, mode };
 734         u8 mode_read_cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_MODE };
 735         u8 result;
 736         struct i2c_msg msg[] = {
 737                 {
 738                         .addr = ts->client->addr,
 739                         .flags = 0,
 740                         .buf = mode_read_cmd,
 741                         .len = sizeof(mode_read_cmd),
 742                 }, {
 743                         .addr = ts->client->addr,
 744                         .flags = I2C_M_RD,
 745                         .buf = &result,
 746                         .len = sizeof(result),
 747                 },
 748         };
 749         int retry = 10;
 750         int ret;
 751         int error;
 752
 753         do {
 754                 /* Send mode change command */
 755                 ret = i2c_master_send(ts->client,
 756                                       mode_chg_cmd, sizeof(mode_chg_cmd));
 757                 if (ret != sizeof(mode_chg_cmd)) {
 758                         error = ret < 0 ? ret : -EIO;
 759                         dev_err(&ts->client->dev,
 760                                 "Failed to send %d mode change: %d (%d)\n",
 761                                 mode, error, ret);
 762                         return error;
 763                 }
 764
 765                 dev_dbg(&ts->client->dev,
 766                         "Sent mode change request (mode: %d)\n", mode);
 767
 768                 /* Wait */
 769                 msleep(1000);
 770
 771                 /* Verify target mode */
 772                 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 773                 if (ret != ARRAY_SIZE(msg)) {
 774                         error = ret < 0 ? ret : -EIO;
 775                         dev_err(&ts->client->dev,
 776                                 "Failed to read device mode: %d\n", error);
 777                         return error;
 778                 }
 779
 780                 dev_dbg(&ts->client->dev,
 781                         "Current device mode: %d, want: %d\n", result, mode);
 782
 783                 if (result == mode)
 784                         return 0;
 785
 786         } while (--retry);
 787
 788         return -EIO;
 789 }
 790
 791 /*
 792  * Bootloader - Start bootloader mode
 793  */
 794 static int mip4_bl_enter(struct mip4_ts *ts)
 795 {
 796         return mip4_bl_change_mode(ts, MIP4_BOOT_MODE_BOOT);
 797 }
 798
 799 /*
 800  * Bootloader - Exit bootloader mode
 801  */
 802 static int mip4_bl_exit(struct mip4_ts *ts)
 803 {
 804         return mip4_bl_change_mode(ts, MIP4_BOOT_MODE_APP);
 805 }
 806
 807 static int mip4_bl_get_address(struct mip4_ts *ts, u16 *buf_addr)
 808 {
 809         u8 cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_BUF_ADDR };
 810         u8 result[sizeof(u16)];
 811         struct i2c_msg msg[] = {
 812                 {
 813                         .addr = ts->client->addr,
 814                         .flags = 0,
 815                         .buf = cmd,
 816                         .len = sizeof(cmd),
 817                 }, {
 818                         .addr = ts->client->addr,
 819                         .flags = I2C_M_RD,
 820                         .buf = result,
 821                         .len = sizeof(result),
 822                 },
 823         };
 824         int ret;
 825         int error;
 826
 827         ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 828         if (ret != ARRAY_SIZE(msg)) {
 829                 error = ret < 0 ? ret : -EIO;
 830                 dev_err(&ts->client->dev,
 831                         "Failed to retrieve bootloader buffer address: %d\n",
 832                         error);
 833                 return error;
 834         }
 835
 836         *buf_addr = get_unaligned_le16(result);
 837         dev_dbg(&ts->client->dev,
 838                 "Bootloader buffer address %#04x\n", *buf_addr);
 839
 840         return 0;
 841 }
 842
 843 static int mip4_bl_program_page(struct mip4_ts *ts, int offset,
 844                                 const u8 *data, int length, u16 buf_addr)
 845 {
 846         u8 cmd[6];
 847         u8 *data_buf;
 848         u16 buf_offset;
 849         int ret;
 850         int error;
 851
 852         dev_dbg(&ts->client->dev, "Writing page @%#06x (%d)\n",
 853                 offset, length);
 854
 855         if (length > MIP4_BL_PAGE_SIZE || length % MIP4_BL_PACKET_SIZE) {
 856                 dev_err(&ts->client->dev,
 857                         "Invalid page length: %d\n", length);
 858                 return -EINVAL;
 859         }
 860
 861         data_buf = kmalloc(2 + MIP4_BL_PACKET_SIZE, GFP_KERNEL);
 862         if (!data_buf)
 863                 return -ENOMEM;
 864
 865         /* Addr */
 866         cmd[0] = MIP4_R0_BOOT;
 867         cmd[1] = MIP4_R1_BOOT_TARGET_ADDR;
 868         put_unaligned_le32(offset, &cmd[2]);
 869         ret = i2c_master_send(ts->client, cmd, 6);
 870         if (ret != 6) {
 871                 error = ret < 0 ? ret : -EIO;
 872                 dev_err(&ts->client->dev,
 873                         "Failed to send write page address: %d\n", error);
 874                 goto out;
 875         }
 876
 877         /* Size */
 878         cmd[0] = MIP4_R0_BOOT;
 879         cmd[1] = MIP4_R1_BOOT_SIZE;
 880         put_unaligned_le32(length, &cmd[2]);
 881         ret = i2c_master_send(ts->client, cmd, 6);
 882         if (ret != 6) {
 883                 error = ret < 0 ? ret : -EIO;
 884                 dev_err(&ts->client->dev,
 885                         "Failed to send write page size: %d\n", error);
 886                 goto out;
 887         }
 888
 889         /* Data */
 890         for (buf_offset = 0;
 891              buf_offset < length;
 892              buf_offset += MIP4_BL_PACKET_SIZE) {
 893                 dev_dbg(&ts->client->dev,
 894                         "writing chunk at %#04x (size %d)\n",
 895                         buf_offset, MIP4_BL_PACKET_SIZE);
 896                 put_unaligned_be16(buf_addr + buf_offset, data_buf);
 897                 memcpy(&data_buf[2], &data[buf_offset], MIP4_BL_PACKET_SIZE);
 898                 ret = i2c_master_send(ts->client,
 899                                       data_buf, 2 + MIP4_BL_PACKET_SIZE);
 900                 if (ret != 2 + MIP4_BL_PACKET_SIZE) {
 901                         error = ret < 0 ? ret : -EIO;
 902                         dev_err(&ts->client->dev,
 903                                 "Failed to read chunk at %#04x (size %d): %d\n",
 904                                 buf_offset, MIP4_BL_PACKET_SIZE, error);
 905                         goto out;
 906                 }
 907         }
 908
 909         /* Command */
 910         cmd[0] = MIP4_R0_BOOT;
 911         cmd[1] = MIP4_R1_BOOT_CMD;
 912         cmd[2] = MIP4_BOOT_CMD_PROGRAM;
 913         ret = i2c_master_send(ts->client, cmd, 3);
 914         if (ret != 3) {
 915                 error = ret < 0 ? ret : -EIO;
 916                 dev_err(&ts->client->dev,
 917                         "Failed to send 'write' command: %d\n", error);
 918                 goto out;
 919         }
 920
 921         /* Status */
 922         error = mip4_bl_read_status(ts);
 923
 924 out:
 925         kfree(data_buf);
 926         return error ? error : 0;
 927 }
 928
 929 static int mip4_bl_verify_page(struct mip4_ts *ts, int offset,
 930                                const u8 *data, int length, int buf_addr)
 931 {
 932         u8 cmd[8];
 933         u8 *read_buf;
 934         int buf_offset;
 935         struct i2c_msg msg[] = {
 936                 {
 937                         .addr = ts->client->addr,
 938                         .flags = 0,
 939                         .buf = cmd,
 940                         .len = 2,
 941                 }, {
 942                         .addr = ts->client->addr,
 943                         .flags = I2C_M_RD,
 944                         .len = MIP4_BL_PACKET_SIZE,
 945                 },
 946         };
 947         int ret;
 948         int error;
 949
 950         dev_dbg(&ts->client->dev, "Validating page @%#06x (%d)\n",
 951                 offset, length);
 952
 953         /* Addr */
 954         cmd[0] = MIP4_R0_BOOT;
 955         cmd[1] = MIP4_R1_BOOT_TARGET_ADDR;
 956         put_unaligned_le32(offset, &cmd[2]);
 957         ret = i2c_master_send(ts->client, cmd, 6);
 958         if (ret != 6) {
 959                 error = ret < 0 ? ret : -EIO;
 960                 dev_err(&ts->client->dev,
 961                         "Failed to send read page address: %d\n", error);
 962                 return error;
 963         }
 964
 965         /* Size */
 966         cmd[0] = MIP4_R0_BOOT;
 967         cmd[1] = MIP4_R1_BOOT_SIZE;
 968         put_unaligned_le32(length, &cmd[2]);
 969         ret = i2c_master_send(ts->client, cmd, 6);
 970         if (ret != 6) {
 971                 error = ret < 0 ? ret : -EIO;
 972                 dev_err(&ts->client->dev,
 973                         "Failed to send read page size: %d\n", error);
 974                 return error;
 975         }
 976
 977         /* Command */
 978         cmd[0] = MIP4_R0_BOOT;
 979         cmd[1] = MIP4_R1_BOOT_CMD;
 980         cmd[2] = MIP4_BOOT_CMD_READ;
 981         ret = i2c_master_send(ts->client, cmd, 3);
 982         if (ret != 3) {
 983                 error = ret < 0 ? ret : -EIO;
 984                 dev_err(&ts->client->dev,
 985                         "Failed to send 'read' command: %d\n", error);
 986                 return error;
 987         }
 988
 989         /* Status */
 990         error = mip4_bl_read_status(ts);
 991         if (error)
 992                 return error;
 993
 994         /* Read */
 995         msg[1].buf = read_buf = kmalloc(MIP4_BL_PACKET_SIZE, GFP_KERNEL);
 996         if (!read_buf)
 997                 return -ENOMEM;
 998
 999         for (buf_offset = 0;
1000              buf_offset < length;
1001              buf_offset += MIP4_BL_PACKET_SIZE) {
1002                 dev_dbg(&ts->client->dev,
1003                         "reading chunk at %#04x (size %d)\n",
1004                         buf_offset, MIP4_BL_PACKET_SIZE);
1005                 put_unaligned_be16(buf_addr + buf_offset, cmd);
1006                 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
1007                 if (ret != ARRAY_SIZE(msg)) {
1008                         error = ret < 0 ? ret : -EIO;
1009                         dev_err(&ts->client->dev,
1010                                 "Failed to read chunk at %#04x (size %d): %d\n",
1011                                 buf_offset, MIP4_BL_PACKET_SIZE, error);
1012                         break;
1013                 }
1014
1015                 if (memcmp(&data[buf_offset], read_buf, MIP4_BL_PACKET_SIZE)) {
1016                         dev_err(&ts->client->dev,
1017                                 "Failed to validate chunk at %#04x (size %d)\n",
1018                                 buf_offset, MIP4_BL_PACKET_SIZE);
1019 #if MIP4_FW_UPDATE_DEBUG
1020                         print_hex_dump(KERN_DEBUG,
1021                                        MIP4_DEVICE_NAME " F/W File: ",
1022                                        DUMP_PREFIX_OFFSET, 16, 1,
1023                                        data + offset, MIP4_BL_PACKET_SIZE,
1024                                        false);
1025                         print_hex_dump(KERN_DEBUG,
1026                                        MIP4_DEVICE_NAME " F/W Chip: ",
1027                                        DUMP_PREFIX_OFFSET, 16, 1,
1028                                        read_buf, MIP4_BL_PAGE_SIZE, false);
1029 #endif
1030                         error = -EINVAL;
1031                         break;
1032                 }
1033         }
1034
1035         kfree(read_buf);
1036         return error ? error : 0;
1037 }
1038
1039 /*
1040  * Flash chip firmware
1041  */
1042 static int mip4_flash_fw(struct mip4_ts *ts,
1043                          const u8 *fw_data, u32 fw_size, u32 fw_offset)
1044 {
1045         struct i2c_client *client = ts->client;
1046         int offset;
1047         u16 buf_addr;
1048         int error, error2;
1049
1050         /* Enter bootloader mode */
1051         dev_dbg(&client->dev, "Entering bootloader mode\n");
1052
1053         error = mip4_bl_enter(ts);
1054         if (error) {
1055                 dev_err(&client->dev,
1056                         "Failed to enter bootloader mode: %d\n",
1057                         error);
1058                 return error;
1059         }
1060
1061         /* Read info */
1062         error = mip4_bl_get_address(ts, &buf_addr);
1063         if (error)
1064                 goto exit_bl;
1065
1066         /* Program & Verify */
1067         dev_dbg(&client->dev,
1068                 "Program & Verify, page size: %d, packet size: %d\n",
1069                 MIP4_BL_PAGE_SIZE, MIP4_BL_PACKET_SIZE);
1070
1071         for (offset = fw_offset;
1072              offset < fw_offset + fw_size;
1073              offset += MIP4_BL_PAGE_SIZE) {
1074                 /* Program */
1075                 error = mip4_bl_program_page(ts, offset, fw_data + offset,
1076                                              MIP4_BL_PAGE_SIZE, buf_addr);
1077                 if (error)
1078                         break;
1079
1080                 /* Verify */
1081                 error = mip4_bl_verify_page(ts, offset, fw_data + offset,
1082                                             MIP4_BL_PAGE_SIZE, buf_addr);
1083                 if (error)
1084                         break;
1085         }
1086
1087 exit_bl:
1088         /* Exit bootloader mode */
1089         dev_dbg(&client->dev, "Exiting bootloader mode\n");
1090
1091         error2 = mip4_bl_exit(ts);
1092         if (error2) {
1093                 dev_err(&client->dev,
1094                         "Failed to exit bootloader mode: %d\n", error2);
1095                 if (!error)
1096                         error = error2;
1097         }
1098
1099         /* Reset chip */
1100         mip4_power_off(ts);
1101         mip4_power_on(ts);
1102
1103         mip4_query_device(ts);
1104
1105         /* Refresh device parameters */
1106         input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->max_x, 0, 0);
1107         input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->max_y, 0, 0);
1108         input_set_abs_params(ts->input, ABS_X, 0, ts->max_x, 0, 0);
1109         input_set_abs_params(ts->input, ABS_Y, 0, ts->max_y, 0, 0);
1110         input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->ppm_x);
1111         input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->ppm_y);
1112         input_abs_set_res(ts->input, ABS_X, ts->ppm_x);
1113         input_abs_set_res(ts->input, ABS_Y, ts->ppm_y);
1114
1115         return error ? error : 0;
1116 }
1117
1118 static int mip4_parse_firmware(struct mip4_ts *ts, const struct firmware *fw,
1119                                u32 *fw_offset_start, u32 *fw_size,
1120                                const struct mip4_bin_tail **pfw_info)
1121 {
1122         const struct mip4_bin_tail *fw_info;
1123         struct mip4_fw_version fw_version;
1124         u16 tail_size;
1125
1126         if (fw->size < MIP4_BIN_TAIL_SIZE) {
1127                 dev_err(&ts->client->dev,
1128                         "Invalid firmware, size mismatch (tail %zd vs %zd)\n",
1129                         MIP4_BIN_TAIL_SIZE, fw->size);
1130                 return -EINVAL;
1131         }
1132
1133         fw_info = (const void *)&fw->data[fw->size - MIP4_BIN_TAIL_SIZE];
1134
1135 #if MIP4_FW_UPDATE_DEBUG
1136         print_hex_dump(KERN_ERR, MIP4_DEVICE_NAME " Bin Info: ",
1137                        DUMP_PREFIX_OFFSET, 16, 1, *fw_info, tail_size, false);
1138 #endif
1139
1140         tail_size = get_unaligned_le16(&fw_info->tail_size);
1141         if (tail_size != MIP4_BIN_TAIL_SIZE) {
1142                 dev_err(&ts->client->dev,
1143                         "wrong tail size: %d (expected %zd)\n",
1144                         tail_size, MIP4_BIN_TAIL_SIZE);
1145                 return -EINVAL;
1146         }
1147
1148         /* Check bin format */
1149         if (memcmp(fw_info->tail_mark, MIP4_BIN_TAIL_MARK,
1150                    sizeof(fw_info->tail_mark))) {
1151                 dev_err(&ts->client->dev,
1152                         "unable to locate tail marker (%*ph vs %*ph)\n",
1153                         (int)sizeof(fw_info->tail_mark), fw_info->tail_mark,
1154                         (int)sizeof(fw_info->tail_mark), MIP4_BIN_TAIL_MARK);
1155                 return -EINVAL;
1156         }
1157
1158         *fw_offset_start = get_unaligned_le32(&fw_info->bin_start_addr);
1159         *fw_size = get_unaligned_le32(&fw_info->bin_length);
1160
1161         dev_dbg(&ts->client->dev,
1162                 "F/W Data offset: %#08x, size: %d\n",
1163                 *fw_offset_start, *fw_size);
1164
1165         if (*fw_size % MIP4_BL_PAGE_SIZE) {
1166                 dev_err(&ts->client->dev,
1167                         "encoded fw length %d is not multiple of pages (%d)\n",
1168                         *fw_size, MIP4_BL_PAGE_SIZE);
1169                 return -EINVAL;
1170         }
1171
1172         if (fw->size != *fw_offset_start + *fw_size) {
1173                 dev_err(&ts->client->dev,
1174                         "Wrong firmware size, expected %d bytes, got %zd\n",
1175                         *fw_offset_start + *fw_size, fw->size);
1176                 return -EINVAL;
1177         }
1178
1179         mip4_parse_fw_version((const u8 *)&fw_info->ver_boot, &fw_version);
1180
1181         dev_dbg(&ts->client->dev,
1182                 "F/W file version %04X %04X %04X %04X\n",
1183                 fw_version.boot, fw_version.core,
1184                 fw_version.app, fw_version.param);
1185
1186         dev_dbg(&ts->client->dev, "F/W chip version: %04X %04X %04X %04X\n",
1187                  ts->fw_version.boot, ts->fw_version.core,
1188                  ts->fw_version.app, ts->fw_version.param);
1189
1190         /* Check F/W type */
1191         if (fw_version.boot != 0xEEEE && fw_version.boot != 0xFFFF &&
1192             fw_version.core == 0xEEEE &&
1193             fw_version.app == 0xEEEE &&
1194             fw_version.param == 0xEEEE) {
1195                 dev_dbg(&ts->client->dev, "F/W type: Bootloader\n");
1196         } else if (fw_version.boot == 0xEEEE &&
1197                    fw_version.core != 0xEEEE && fw_version.core != 0xFFFF &&
1198                    fw_version.app != 0xEEEE && fw_version.app != 0xFFFF &&
1199                    fw_version.param != 0xEEEE && fw_version.param != 0xFFFF) {
1200                 dev_dbg(&ts->client->dev, "F/W type: Main\n");
1201         } else {
1202                 dev_err(&ts->client->dev, "Wrong firmware type\n");
1203                 return -EINVAL;
1204         }
1205
1206         return 0;
1207 }
1208
1209 static int mip4_execute_fw_update(struct mip4_ts *ts, const struct firmware *fw)
1210 {
1211         const struct mip4_bin_tail *fw_info;
1212         u32 fw_start_offset;
1213         u32 fw_size;
1214         int retires = 3;
1215         int error;
1216
1217         error = mip4_parse_firmware(ts, fw,
1218                                     &fw_start_offset, &fw_size, &fw_info);
1219         if (error)
1220                 return error;
1221
1222         if (ts->input->users) {
1223                 disable_irq(ts->client->irq);
1224         } else {
1225                 error = mip4_power_on(ts);
1226                 if (error)
1227                         return error;
1228         }
1229
1230         /* Update firmware */
1231         do {
1232                 error = mip4_flash_fw(ts, fw->data, fw_size, fw_start_offset);
1233                 if (!error)
1234                         break;
1235         } while (--retires);
1236
1237         if (error)
1238                 dev_err(&ts->client->dev,
1239                         "Failed to flash firmware: %d\n", error);
1240
1241         /* Enable IRQ */
1242         if (ts->input->users)
1243                 enable_irq(ts->client->irq);
1244         else
1245                 mip4_power_off(ts);
1246
1247         return error ? error : 0;
1248 }
1249
1250 static ssize_t mip4_sysfs_fw_update(struct device *dev,
1251                                     struct device_attribute *attr,
1252                                     const char *buf, size_t count)
1253 {
1254         struct i2c_client *client = to_i2c_client(dev);
1255         struct mip4_ts *ts = i2c_get_clientdata(client);
1256         const struct firmware *fw;
1257         int error;
1258
1259         error = request_firmware(&fw, MIP4_FW_NAME, dev);
1260         if (error) {
1261                 dev_err(&ts->client->dev,
1262                         "Failed to retrieve firmware %s: %d\n",
1263                         MIP4_FW_NAME, error);
1264                 return error;
1265         }
1266
1267         /*
1268          * Take input mutex to prevent racing with itself and also with
1269          * userspace opening and closing the device and also suspend/resume
1270          * transitions.
1271          */
1272         mutex_lock(&ts->input->mutex);
1273
1274         error = mip4_execute_fw_update(ts, fw);
1275
1276         mutex_unlock(&ts->input->mutex);
1277
1278         release_firmware(fw);
1279
1280         if (error) {
1281                 dev_err(&ts->client->dev,
1282                         "Firmware update failed: %d\n", error);
1283                 return error;
1284         }
1285
1286         return count;
1287 }
1288
1289 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mip4_sysfs_fw_update);
1290
1291 static ssize_t mip4_sysfs_read_fw_version(struct device *dev,
1292                                           struct device_attribute *attr,
1293                                           char *buf)
1294 {
1295         struct i2c_client *client = to_i2c_client(dev);
1296         struct mip4_ts *ts = i2c_get_clientdata(client);
1297         size_t count;
1298
1299         /* Take lock to prevent racing with firmware update */
1300         mutex_lock(&ts->input->mutex);
1301
1302         count = snprintf(buf, PAGE_SIZE, "%04X %04X %04X %04X\n",
1303                          ts->fw_version.boot, ts->fw_version.core,
1304                          ts->fw_version.app, ts->fw_version.param);
1305
1306         mutex_unlock(&ts->input->mutex);
1307
1308         return count;
1309 }
1310
1311 static DEVICE_ATTR(fw_version, S_IRUGO, mip4_sysfs_read_fw_version, NULL);
1312
1313 static struct attribute *mip4_attrs[] = {
1314         &dev_attr_fw_version.attr,
1315         &dev_attr_update_fw.attr,
1316         NULL,
1317 };
1318
1319 static const struct attribute_group mip4_attr_group = {
1320         .attrs = mip4_attrs,
1321 };
1322
1323 static void mip4_sysfs_remove(void *_data)
1324 {
1325         struct mip4_ts *ts = _data;
1326
1327         sysfs_remove_group(&ts->client->dev.kobj, &mip4_attr_group);
1328 }
1329
1330 static int mip4_probe(struct i2c_client *client, const struct i2c_device_id *id)
1331 {
1332         struct mip4_ts *ts;
1333         struct input_dev *input;
1334         int error;
1335
1336         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1337                 dev_err(&client->dev, "Not supported I2C adapter\n");
1338                 return -ENXIO;
1339         }
1340
1341         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1342         if (!ts)
1343                 return -ENOMEM;
1344
1345         input = devm_input_allocate_device(&client->dev);
1346         if (!input)
1347                 return -ENOMEM;
1348
1349         ts->client = client;
1350         ts->input = input;
1351
1352         snprintf(ts->phys, sizeof(ts->phys),
1353                  "%s/input0", dev_name(&client->dev));
1354
1355         ts->gpio_ce = devm_gpiod_get_optional(&client->dev,
1356                                               "ce", GPIOD_OUT_LOW);
1357         if (IS_ERR(ts->gpio_ce)) {
1358                 error = PTR_ERR(ts->gpio_ce);
1359                 if (error != EPROBE_DEFER)
1360                         dev_err(&client->dev,
1361                                 "Failed to get gpio: %d\n", error);
1362                 return error;
1363         }
1364
1365         error = mip4_power_on(ts);
1366         if (error)
1367                 return error;
1368         error = mip4_query_device(ts);
1369         mip4_power_off(ts);
1370         if (error)
1371                 return error;
1372
1373         input->name = "MELFAS MIP4 Touchscreen";
1374         input->phys = ts->phys;
1375
1376         input->id.bustype = BUS_I2C;
1377         input->id.vendor = 0x13c5;
1378
1379         input->open = mip4_input_open;
1380         input->close = mip4_input_close;
1381
1382         input_set_drvdata(input, ts);
1383
1384         input->keycode = ts->key_code;
1385         input->keycodesize = sizeof(*ts->key_code);
1386         input->keycodemax = ts->key_num;
1387
1388         input_set_abs_params(input, ABS_MT_POSITION_X, 0, ts->max_x, 0, 0);
1389         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, ts->max_y, 0, 0);
1390         input_set_abs_params(input, ABS_MT_PRESSURE,
1391                              MIP4_PRESSURE_MIN, MIP4_PRESSURE_MAX, 0, 0);
1392         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR,
1393                              MIP4_TOUCH_MAJOR_MIN, MIP4_TOUCH_MAJOR_MAX, 0, 0);
1394         input_set_abs_params(input, ABS_MT_TOUCH_MINOR,
1395                              MIP4_TOUCH_MINOR_MIN, MIP4_TOUCH_MINOR_MAX, 0, 0);
1396         input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->ppm_x);
1397         input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->ppm_y);
1398
1399         error = input_mt_init_slots(input, MIP4_MAX_FINGERS, INPUT_MT_DIRECT);
1400         if (error)
1401                 return error;
1402
1403         i2c_set_clientdata(client, ts);
1404
1405         error = devm_request_threaded_irq(&client->dev, client->irq,
1406                                           NULL, mip4_interrupt,
1407                                           IRQF_ONESHOT, MIP4_DEVICE_NAME, ts);
1408         if (error) {
1409                 dev_err(&client->dev,
1410                         "Failed to request interrupt %d: %d\n",
1411                         client->irq, error);
1412                 return error;
1413         }
1414
1415         disable_irq(client->irq);
1416
1417         error = input_register_device(input);
1418         if (error) {
1419                 dev_err(&client->dev,
1420                         "Failed to register input device: %d\n", error);
1421                 return error;
1422         }
1423
1424         error = sysfs_create_group(&client->dev.kobj, &mip4_attr_group);
1425         if (error) {
1426                 dev_err(&client->dev,
1427                         "Failed to create sysfs attribute group: %d\n", error);
1428                 return error;
1429         }
1430
1431         error = devm_add_action(&client->dev, mip4_sysfs_remove, ts);
1432         if (error) {
1433                 mip4_sysfs_remove(ts);
1434                 dev_err(&client->dev,
1435                         "Failed to install sysfs remoce action: %d\n", error);
1436                 return error;
1437         }
1438
1439         return 0;
1440 }
1441
1442 static int __maybe_unused mip4_suspend(struct device *dev)
1443 {
1444         struct i2c_client *client = to_i2c_client(dev);
1445         struct mip4_ts *ts = i2c_get_clientdata(client);
1446         struct input_dev *input = ts->input;
1447
1448         mutex_lock(&input->mutex);
1449
1450         if (device_may_wakeup(dev))
1451                 ts->wake_irq_enabled = enable_irq_wake(client->irq) == 0;
1452         else if (input->users)
1453                 mip4_disable(ts);
1454
1455         mutex_unlock(&input->mutex);
1456
1457         return 0;
1458 }
1459
1460 static int __maybe_unused mip4_resume(struct device *dev)
1461 {
1462         struct i2c_client *client = to_i2c_client(dev);
1463         struct mip4_ts *ts = i2c_get_clientdata(client);
1464         struct input_dev *input = ts->input;
1465
1466         mutex_lock(&input->mutex);
1467
1468         if (ts->wake_irq_enabled)
1469                 disable_irq_wake(client->irq);
1470         else if (input->users)
1471                 mip4_enable(ts);
1472
1473         mutex_unlock(&input->mutex);
1474
1475         return 0;
1476 }
1477
1478 static SIMPLE_DEV_PM_OPS(mip4_pm_ops, mip4_suspend, mip4_resume);
1479
1480 #ifdef CONFIG_OF
1481 static const struct of_device_id mip4_of_match[] = {
1482         { .compatible = "melfas,"MIP4_DEVICE_NAME, },
1483         { },
1484 };
1485 MODULE_DEVICE_TABLE(of, mip4_of_match);
1486 #endif
1487
1488 #ifdef CONFIG_ACPI
1489 static const struct acpi_device_id mip4_acpi_match[] = {
1490         { "MLFS0000", 0},
1491         { },
1492 };
1493 MODULE_DEVICE_TABLE(acpi, mip4_acpi_match);
1494 #endif
1495
1496 static const struct i2c_device_id mip4_i2c_ids[] = {
1497         { MIP4_DEVICE_NAME, 0 },
1498         { },
1499 };
1500 MODULE_DEVICE_TABLE(i2c, mip4_i2c_ids);
1501
1502 static struct i2c_driver mip4_driver = {
1503         .id_table = mip4_i2c_ids,
1504         .probe = mip4_probe,
1505         .driver = {
1506                 .name = MIP4_DEVICE_NAME,
1507                 .of_match_table = of_match_ptr(mip4_of_match),
1508                 .acpi_match_table = ACPI_PTR(mip4_acpi_match),
1509                 .pm = &mip4_pm_ops,
1510         },
1511 };
1512 module_i2c_driver(mip4_driver);
1513
1514 MODULE_DESCRIPTION("MELFAS MIP4 Touchscreen");
1515 MODULE_VERSION("2016.03.03");
1516 MODULE_AUTHOR("Sangwon Jee <jeesw@melfas.com>");
1517 MODULE_LICENSE("GPL");