drivers/input/mouse/elan_i2c_core.c

   1 /*
   2  * Elan I2C/SMBus Touchpad driver
   3  *
   4  * Copyright (c) 2013 ELAN Microelectronics Corp.
   5  *
   6  * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
   7  * Version: 1.5.5
   8  *
   9  * Based on cyapa driver:
  10  * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
  11  * copyright (c) 2011-2012 Google, Inc.
  12  *
  13  * This program is free software; you can redistribute it and/or modify it
  14  * under the terms of the GNU General Public License version 2 as published
  15  * by the Free Software Foundation.
  16  *
  17  * Trademarks are the property of their respective owners.
  18  */
  19
  20 #include <linux/acpi.h>
  21 #include <linux/delay.h>
  22 #include <linux/device.h>
  23 #include <linux/firmware.h>
  24 #include <linux/i2c.h>
  25 #include <linux/init.h>
  26 #include <linux/input/mt.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/module.h>
  29 #include <linux/slab.h>
  30 #include <linux/kernel.h>
  31 #include <linux/sched.h>
  32 #include <linux/input.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/jiffies.h>
  35 #include <linux/completion.h>
  36 #include <linux/of.h>
  37 #include <linux/regulator/consumer.h>
  38 #include <asm/unaligned.h>
  39
  40 #include "elan_i2c.h"
  41
  42 #define DRIVER_NAME             "elan_i2c"
  43 #define ELAN_DRIVER_VERSION     "1.5.5"
  44 #define ETP_PRESSURE_OFFSET     25
  45 #define ETP_MAX_PRESSURE        255
  46 #define ETP_FWIDTH_REDUCE       90
  47 #define ETP_FINGER_WIDTH        15
  48 #define ETP_RETRY_COUNT         3
  49
  50 #define ETP_MAX_FINGERS         5
  51 #define ETP_FINGER_DATA_LEN     5
  52 #define ETP_REPORT_ID           0x5D
  53 #define ETP_REPORT_ID_OFFSET    2
  54 #define ETP_TOUCH_INFO_OFFSET   3
  55 #define ETP_FINGER_DATA_OFFSET  4
  56 #define ETP_MAX_REPORT_LEN      34
  57
  58 /* The main device structure */
  59 struct elan_tp_data {
  60         struct i2c_client       *client;
  61         struct input_dev        *input;
  62         struct regulator        *vcc;
  63
  64         const struct elan_transport_ops *ops;
  65
  66         /* for fw update */
  67         struct completion       fw_completion;
  68         bool                    in_fw_update;
  69
  70         struct mutex            sysfs_mutex;
  71
  72         unsigned int            max_x;
  73         unsigned int            max_y;
  74         unsigned int            width_x;
  75         unsigned int            width_y;
  76         unsigned int            x_res;
  77         unsigned int            y_res;
  78
  79         u8                      product_id;
  80         u8                      fw_version;
  81         u8                      sm_version;
  82         u8                      iap_version;
  83         u16                     fw_checksum;
  84
  85         u8                      mode;
  86
  87         bool                    irq_wake;
  88
  89         u8                      min_baseline;
  90         u8                      max_baseline;
  91         bool                    baseline_ready;
  92 };
  93
  94 static int elan_enable_power(struct elan_tp_data *data)
  95 {
  96         int repeat = ETP_RETRY_COUNT;
  97         int error;
  98
  99         error = regulator_enable(data->vcc);
 100         if (error) {
 101                 dev_err(&data->client->dev,
 102                         "Failed to enable regulator: %d\n", error);
 103                 return error;
 104         }
 105
 106         do {
 107                 error = data->ops->power_control(data->client, true);
 108                 if (error >= 0)
 109                         return 0;
 110
 111                 msleep(30);
 112         } while (--repeat > 0);
 113
 114         return error;
 115 }
 116
 117 static int elan_disable_power(struct elan_tp_data *data)
 118 {
 119         int repeat = ETP_RETRY_COUNT;
 120         int error;
 121
 122         do {
 123                 error = data->ops->power_control(data->client, false);
 124                 if (!error) {
 125                         error = regulator_disable(data->vcc);
 126                         if (error) {
 127                                 dev_err(&data->client->dev,
 128                                         "Failed to disable regulator: %d\n",
 129                                         error);
 130                                 /* Attempt to power the chip back up */
 131                                 data->ops->power_control(data->client, true);
 132                                 break;
 133                         }
 134
 135                         return 0;
 136                 }
 137
 138                 msleep(30);
 139         } while (--repeat > 0);
 140
 141         return error;
 142 }
 143
 144 static int elan_sleep(struct elan_tp_data *data)
 145 {
 146         int repeat = ETP_RETRY_COUNT;
 147         int error;
 148
 149         do {
 150                 error = data->ops->sleep_control(data->client, true);
 151                 if (!error)
 152                         return 0;
 153
 154                 msleep(30);
 155         } while (--repeat > 0);
 156
 157         return error;
 158 }
 159
 160 static int __elan_initialize(struct elan_tp_data *data)
 161 {
 162         struct i2c_client *client = data->client;
 163         int error;
 164
 165         error = data->ops->initialize(client);
 166         if (error) {
 167                 dev_err(&client->dev, "device initialize failed: %d\n", error);
 168                 return error;
 169         }
 170
 171         data->mode |= ETP_ENABLE_ABS;
 172         error = data->ops->set_mode(client, data->mode);
 173         if (error) {
 174                 dev_err(&client->dev,
 175                         "failed to switch to absolute mode: %d\n", error);
 176                 return error;
 177         }
 178
 179         error = data->ops->sleep_control(client, false);
 180         if (error) {
 181                 dev_err(&client->dev,
 182                         "failed to wake device up: %d\n", error);
 183                 return error;
 184         }
 185
 186         return 0;
 187 }
 188
 189 static int elan_initialize(struct elan_tp_data *data)
 190 {
 191         int repeat = ETP_RETRY_COUNT;
 192         int error;
 193
 194         do {
 195                 error = __elan_initialize(data);
 196                 if (!error)
 197                         return 0;
 198
 199                 repeat--;
 200                 msleep(30);
 201         } while (--repeat > 0);
 202
 203         return error;
 204 }
 205
 206 static int elan_query_device_info(struct elan_tp_data *data)
 207 {
 208         int error;
 209
 210         error = data->ops->get_product_id(data->client, &data->product_id);
 211         if (error)
 212                 return error;
 213
 214         error = data->ops->get_version(data->client, false, &data->fw_version);
 215         if (error)
 216                 return error;
 217
 218         error = data->ops->get_checksum(data->client, false,
 219                                         &data->fw_checksum);
 220         if (error)
 221                 return error;
 222
 223         error = data->ops->get_sm_version(data->client, &data->sm_version);
 224         if (error)
 225                 return error;
 226
 227         error = data->ops->get_version(data->client, true, &data->iap_version);
 228         if (error)
 229                 return error;
 230
 231         return 0;
 232 }
 233
 234 static unsigned int elan_convert_resolution(u8 val)
 235 {
 236         /*
 237          * (value from firmware) * 10 + 790 = dpi
 238          *
 239          * We also have to convert dpi to dots/mm (*10/254 to avoid floating
 240          * point).
 241          */
 242
 243         return ((int)(char)val * 10 + 790) * 10 / 254;
 244 }
 245
 246 static int elan_query_device_parameters(struct elan_tp_data *data)
 247 {
 248         unsigned int x_traces, y_traces;
 249         u8 hw_x_res, hw_y_res;
 250         int error;
 251
 252         error = data->ops->get_max(data->client, &data->max_x, &data->max_y);
 253         if (error)
 254                 return error;
 255
 256         error = data->ops->get_num_traces(data->client, &x_traces, &y_traces);
 257         if (error)
 258                 return error;
 259
 260         data->width_x = data->max_x / x_traces;
 261         data->width_y = data->max_y / y_traces;
 262
 263         error = data->ops->get_resolution(data->client, &hw_x_res, &hw_y_res);
 264         if (error)
 265                 return error;
 266
 267         data->x_res = elan_convert_resolution(hw_x_res);
 268         data->y_res = elan_convert_resolution(hw_y_res);
 269
 270         return 0;
 271 }
 272
 273 /*
 274  **********************************************************
 275  * IAP firmware updater related routines
 276  **********************************************************
 277  */
 278 static int elan_write_fw_block(struct elan_tp_data *data,
 279                                const u8 *page, u16 checksum, int idx)
 280 {
 281         int retry = ETP_RETRY_COUNT;
 282         int error;
 283
 284         do {
 285                 error = data->ops->write_fw_block(data->client,
 286                                                   page, checksum, idx);
 287                 if (!error)
 288                         return 0;
 289
 290                 dev_dbg(&data->client->dev,
 291                         "IAP retrying page %d (error: %d)\n", idx, error);
 292         } while (--retry > 0);
 293
 294         return error;
 295 }
 296
 297 static int __elan_update_firmware(struct elan_tp_data *data,
 298                                   const struct firmware *fw)
 299 {
 300         struct i2c_client *client = data->client;
 301         struct device *dev = &client->dev;
 302         int i, j;
 303         int error;
 304         u16 iap_start_addr;
 305         u16 boot_page_count;
 306         u16 sw_checksum = 0, fw_checksum = 0;
 307
 308         error = data->ops->prepare_fw_update(client);
 309         if (error)
 310                 return error;
 311
 312         iap_start_addr = get_unaligned_le16(&fw->data[ETP_IAP_START_ADDR * 2]);
 313
 314         boot_page_count = (iap_start_addr * 2) / ETP_FW_PAGE_SIZE;
 315         for (i = boot_page_count; i < ETP_FW_PAGE_COUNT; i++) {
 316                 u16 checksum = 0;
 317                 const u8 *page = &fw->data[i * ETP_FW_PAGE_SIZE];
 318
 319                 for (j = 0; j < ETP_FW_PAGE_SIZE; j += 2)
 320                         checksum += ((page[j + 1] << 8) | page[j]);
 321
 322                 error = elan_write_fw_block(data, page, checksum, i);
 323                 if (error) {
 324                         dev_err(dev, "write page %d fail: %d\n", i, error);
 325                         return error;
 326                 }
 327
 328                 sw_checksum += checksum;
 329         }
 330
 331         /* Wait WDT reset and power on reset */
 332         msleep(600);
 333
 334         error = data->ops->finish_fw_update(client, &data->fw_completion);
 335         if (error)
 336                 return error;
 337
 338         error = data->ops->get_checksum(client, true, &fw_checksum);
 339         if (error)
 340                 return error;
 341
 342         if (sw_checksum != fw_checksum) {
 343                 dev_err(dev, "checksum diff sw=[%04X], fw=[%04X]\n",
 344                         sw_checksum, fw_checksum);
 345                 return -EIO;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int elan_update_firmware(struct elan_tp_data *data,
 352                                 const struct firmware *fw)
 353 {
 354         struct i2c_client *client = data->client;
 355         int retval;
 356
 357         dev_dbg(&client->dev, "Starting firmware update....\n");
 358
 359         disable_irq(client->irq);
 360         data->in_fw_update = true;
 361
 362         retval = __elan_update_firmware(data, fw);
 363         if (retval) {
 364                 dev_err(&client->dev, "firmware update failed: %d\n", retval);
 365                 data->ops->iap_reset(client);
 366         } else {
 367                 /* Reinitialize TP after fw is updated */
 368                 elan_initialize(data);
 369                 elan_query_device_info(data);
 370         }
 371
 372         data->in_fw_update = false;
 373         enable_irq(client->irq);
 374
 375         return retval;
 376 }
 377
 378 /*
 379  *******************************************************************
 380  * SYSFS attributes
 381  *******************************************************************
 382  */
 383 static ssize_t elan_sysfs_read_fw_checksum(struct device *dev,
 384                                            struct device_attribute *attr,
 385                                            char *buf)
 386 {
 387         struct i2c_client *client = to_i2c_client(dev);
 388         struct elan_tp_data *data = i2c_get_clientdata(client);
 389
 390         return sprintf(buf, "0x%04x\n", data->fw_checksum);
 391 }
 392
 393 static ssize_t elan_sysfs_read_product_id(struct device *dev,
 394                                          struct device_attribute *attr,
 395                                          char *buf)
 396 {
 397         struct i2c_client *client = to_i2c_client(dev);
 398         struct elan_tp_data *data = i2c_get_clientdata(client);
 399
 400         return sprintf(buf, "%d.0\n", data->product_id);
 401 }
 402
 403 static ssize_t elan_sysfs_read_fw_ver(struct device *dev,
 404                                       struct device_attribute *attr,
 405                                       char *buf)
 406 {
 407         struct i2c_client *client = to_i2c_client(dev);
 408         struct elan_tp_data *data = i2c_get_clientdata(client);
 409
 410         return sprintf(buf, "%d.0\n", data->fw_version);
 411 }
 412
 413 static ssize_t elan_sysfs_read_sm_ver(struct device *dev,
 414                                       struct device_attribute *attr,
 415                                       char *buf)
 416 {
 417         struct i2c_client *client = to_i2c_client(dev);
 418         struct elan_tp_data *data = i2c_get_clientdata(client);
 419
 420         return sprintf(buf, "%d.0\n", data->sm_version);
 421 }
 422
 423 static ssize_t elan_sysfs_read_iap_ver(struct device *dev,
 424                                        struct device_attribute *attr,
 425                                        char *buf)
 426 {
 427         struct i2c_client *client = to_i2c_client(dev);
 428         struct elan_tp_data *data = i2c_get_clientdata(client);
 429
 430         return sprintf(buf, "%d.0\n", data->iap_version);
 431 }
 432
 433 static ssize_t elan_sysfs_update_fw(struct device *dev,
 434                                     struct device_attribute *attr,
 435                                     const char *buf, size_t count)
 436 {
 437         struct i2c_client *client = to_i2c_client(dev);
 438         struct elan_tp_data *data = i2c_get_clientdata(client);
 439         const struct firmware *fw;
 440         int error;
 441
 442         error = request_firmware(&fw, ETP_FW_NAME, dev);
 443         if (error) {
 444                 dev_err(dev, "cannot load firmware %s: %d\n",
 445                         ETP_FW_NAME, error);
 446                 return error;
 447         }
 448
 449         /* Firmware must be exactly PAGE_NUM * PAGE_SIZE bytes */
 450         if (fw->size != ETP_FW_SIZE) {
 451                 dev_err(dev, "invalid firmware size = %zu, expected %d.\n",
 452                         fw->size, ETP_FW_SIZE);
 453                 error = -EBADF;
 454                 goto out_release_fw;
 455         }
 456
 457         error = mutex_lock_interruptible(&data->sysfs_mutex);
 458         if (error)
 459                 goto out_release_fw;
 460
 461         error = elan_update_firmware(data, fw);
 462
 463         mutex_unlock(&data->sysfs_mutex);
 464
 465 out_release_fw:
 466         release_firmware(fw);
 467         return error ?: count;
 468 }
 469
 470 static ssize_t calibrate_store(struct device *dev,
 471                                struct device_attribute *attr,
 472                                const char *buf, size_t count)
 473 {
 474         struct i2c_client *client = to_i2c_client(dev);
 475         struct elan_tp_data *data = i2c_get_clientdata(client);
 476         int tries = 20;
 477         int retval;
 478         int error;
 479         u8 val[3];
 480
 481         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 482         if (retval)
 483                 return retval;
 484
 485         disable_irq(client->irq);
 486
 487         data->mode |= ETP_ENABLE_CALIBRATE;
 488         retval = data->ops->set_mode(client, data->mode);
 489         if (retval) {
 490                 dev_err(dev, "failed to enable calibration mode: %d\n",
 491                         retval);
 492                 goto out;
 493         }
 494
 495         retval = data->ops->calibrate(client);
 496         if (retval) {
 497                 dev_err(dev, "failed to start calibration: %d\n",
 498                         retval);
 499                 goto out_disable_calibrate;
 500         }
 501
 502         val[0] = 0xff;
 503         do {
 504                 /* Wait 250ms before checking if calibration has completed. */
 505                 msleep(250);
 506
 507                 retval = data->ops->calibrate_result(client, val);
 508                 if (retval)
 509                         dev_err(dev, "failed to check calibration result: %d\n",
 510                                 retval);
 511                 else if (val[0] == 0)
 512                         break; /* calibration done */
 513
 514         } while (--tries);
 515
 516         if (tries == 0) {
 517                 dev_err(dev, "failed to calibrate. Timeout.\n");
 518                 retval = -ETIMEDOUT;
 519         }
 520
 521 out_disable_calibrate:
 522         data->mode &= ~ETP_ENABLE_CALIBRATE;
 523         error = data->ops->set_mode(data->client, data->mode);
 524         if (error) {
 525                 dev_err(dev, "failed to disable calibration mode: %d\n",
 526                         error);
 527                 if (!retval)
 528                         retval = error;
 529         }
 530 out:
 531         enable_irq(client->irq);
 532         mutex_unlock(&data->sysfs_mutex);
 533         return retval ?: count;
 534 }
 535
 536 static ssize_t elan_sysfs_read_mode(struct device *dev,
 537                                     struct device_attribute *attr,
 538                                     char *buf)
 539 {
 540         struct i2c_client *client = to_i2c_client(dev);
 541         struct elan_tp_data *data = i2c_get_clientdata(client);
 542         int error;
 543         enum tp_mode mode;
 544
 545         error = mutex_lock_interruptible(&data->sysfs_mutex);
 546         if (error)
 547                 return error;
 548
 549         error = data->ops->iap_get_mode(data->client, &mode);
 550
 551         mutex_unlock(&data->sysfs_mutex);
 552
 553         if (error)
 554                 return error;
 555
 556         return sprintf(buf, "%d\n", (int)mode);
 557 }
 558
 559 static DEVICE_ATTR(product_id, S_IRUGO, elan_sysfs_read_product_id, NULL);
 560 static DEVICE_ATTR(firmware_version, S_IRUGO, elan_sysfs_read_fw_ver, NULL);
 561 static DEVICE_ATTR(sample_version, S_IRUGO, elan_sysfs_read_sm_ver, NULL);
 562 static DEVICE_ATTR(iap_version, S_IRUGO, elan_sysfs_read_iap_ver, NULL);
 563 static DEVICE_ATTR(fw_checksum, S_IRUGO, elan_sysfs_read_fw_checksum, NULL);
 564 static DEVICE_ATTR(mode, S_IRUGO, elan_sysfs_read_mode, NULL);
 565 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, elan_sysfs_update_fw);
 566
 567 static DEVICE_ATTR_WO(calibrate);
 568
 569 static struct attribute *elan_sysfs_entries[] = {
 570         &dev_attr_product_id.attr,
 571         &dev_attr_firmware_version.attr,
 572         &dev_attr_sample_version.attr,
 573         &dev_attr_iap_version.attr,
 574         &dev_attr_fw_checksum.attr,
 575         &dev_attr_calibrate.attr,
 576         &dev_attr_mode.attr,
 577         &dev_attr_update_fw.attr,
 578         NULL,
 579 };
 580
 581 static const struct attribute_group elan_sysfs_group = {
 582         .attrs = elan_sysfs_entries,
 583 };
 584
 585 static ssize_t acquire_store(struct device *dev, struct device_attribute *attr,
 586                              const char *buf, size_t count)
 587 {
 588         struct i2c_client *client = to_i2c_client(dev);
 589         struct elan_tp_data *data = i2c_get_clientdata(client);
 590         int error;
 591         int retval;
 592
 593         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 594         if (retval)
 595                 return retval;
 596
 597         disable_irq(client->irq);
 598
 599         data->baseline_ready = false;
 600
 601         data->mode |= ETP_ENABLE_CALIBRATE;
 602         retval = data->ops->set_mode(data->client, data->mode);
 603         if (retval) {
 604                 dev_err(dev, "Failed to enable calibration mode to get baseline: %d\n",
 605                         retval);
 606                 goto out;
 607         }
 608
 609         msleep(250);
 610
 611         retval = data->ops->get_baseline_data(data->client, true,
 612                                               &data->max_baseline);
 613         if (retval) {
 614                 dev_err(dev, "Failed to read max baseline form device: %d\n",
 615                         retval);
 616                 goto out_disable_calibrate;
 617         }
 618
 619         retval = data->ops->get_baseline_data(data->client, false,
 620                                               &data->min_baseline);
 621         if (retval) {
 622                 dev_err(dev, "Failed to read min baseline form device: %d\n",
 623                         retval);
 624                 goto out_disable_calibrate;
 625         }
 626
 627         data->baseline_ready = true;
 628
 629 out_disable_calibrate:
 630         data->mode &= ~ETP_ENABLE_CALIBRATE;
 631         error = data->ops->set_mode(data->client, data->mode);
 632         if (error) {
 633                 dev_err(dev, "Failed to disable calibration mode after acquiring baseline: %d\n",
 634                         error);
 635                 if (!retval)
 636                         retval = error;
 637         }
 638 out:
 639         enable_irq(client->irq);
 640         mutex_unlock(&data->sysfs_mutex);
 641         return retval ?: count;
 642 }
 643
 644 static ssize_t min_show(struct device *dev,
 645                         struct device_attribute *attr, char *buf)
 646 {
 647         struct i2c_client *client = to_i2c_client(dev);
 648         struct elan_tp_data *data = i2c_get_clientdata(client);
 649         int retval;
 650
 651         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 652         if (retval)
 653                 return retval;
 654
 655         if (!data->baseline_ready) {
 656                 retval = -ENODATA;
 657                 goto out;
 658         }
 659
 660         retval = snprintf(buf, PAGE_SIZE, "%d", data->min_baseline);
 661
 662 out:
 663         mutex_unlock(&data->sysfs_mutex);
 664         return retval;
 665 }
 666
 667 static ssize_t max_show(struct device *dev,
 668                         struct device_attribute *attr, char *buf)
 669 {
 670         struct i2c_client *client = to_i2c_client(dev);
 671         struct elan_tp_data *data = i2c_get_clientdata(client);
 672         int retval;
 673
 674         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 675         if (retval)
 676                 return retval;
 677
 678         if (!data->baseline_ready) {
 679                 retval = -ENODATA;
 680                 goto out;
 681         }
 682
 683         retval = snprintf(buf, PAGE_SIZE, "%d", data->max_baseline);
 684
 685 out:
 686         mutex_unlock(&data->sysfs_mutex);
 687         return retval;
 688 }
 689
 690
 691 static DEVICE_ATTR_WO(acquire);
 692 static DEVICE_ATTR_RO(min);
 693 static DEVICE_ATTR_RO(max);
 694
 695 static struct attribute *elan_baseline_sysfs_entries[] = {
 696         &dev_attr_acquire.attr,
 697         &dev_attr_min.attr,
 698         &dev_attr_max.attr,
 699         NULL,
 700 };
 701
 702 static const struct attribute_group elan_baseline_sysfs_group = {
 703         .name = "baseline",
 704         .attrs = elan_baseline_sysfs_entries,
 705 };
 706
 707 static const struct attribute_group *elan_sysfs_groups[] = {
 708         &elan_sysfs_group,
 709         &elan_baseline_sysfs_group,
 710         NULL
 711 };
 712
 713 /*
 714  ******************************************************************
 715  * Elan isr functions
 716  ******************************************************************
 717  */
 718 static void elan_report_contact(struct elan_tp_data *data,
 719                                 int contact_num, bool contact_valid,
 720                                 u8 *finger_data)
 721 {
 722         struct input_dev *input = data->input;
 723         unsigned int pos_x, pos_y;
 724         unsigned int pressure, mk_x, mk_y;
 725         unsigned int area_x, area_y, major, minor, new_pressure;
 726
 727
 728         if (contact_valid) {
 729                 pos_x = ((finger_data[0] & 0xf0) << 4) |
 730                                                 finger_data[1];
 731                 pos_y = ((finger_data[0] & 0x0f) << 8) |
 732                                                 finger_data[2];
 733                 mk_x = (finger_data[3] & 0x0f);
 734                 mk_y = (finger_data[3] >> 4);
 735                 pressure = finger_data[4];
 736
 737                 if (pos_x > data->max_x || pos_y > data->max_y) {
 738                         dev_dbg(input->dev.parent,
 739                                 "[%d] x=%d y=%d over max (%d, %d)",
 740                                 contact_num, pos_x, pos_y,
 741                                 data->max_x, data->max_y);
 742                         return;
 743                 }
 744
 745                 /*
 746                  * To avoid treating large finger as palm, let's reduce the
 747                  * width x and y per trace.
 748                  */
 749                 area_x = mk_x * (data->width_x - ETP_FWIDTH_REDUCE);
 750                 area_y = mk_y * (data->width_y - ETP_FWIDTH_REDUCE);
 751
 752                 major = max(area_x, area_y);
 753                 minor = min(area_x, area_y);
 754
 755                 new_pressure = pressure + ETP_PRESSURE_OFFSET;
 756                 if (new_pressure > ETP_MAX_PRESSURE)
 757                         new_pressure = ETP_MAX_PRESSURE;
 758
 759                 input_mt_slot(input, contact_num);
 760                 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
 761                 input_report_abs(input, ABS_MT_POSITION_X, pos_x);
 762                 input_report_abs(input, ABS_MT_POSITION_Y, data->max_y - pos_y);
 763                 input_report_abs(input, ABS_MT_PRESSURE, new_pressure);
 764                 input_report_abs(input, ABS_TOOL_WIDTH, mk_x);
 765                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, major);
 766                 input_report_abs(input, ABS_MT_TOUCH_MINOR, minor);
 767         } else {
 768                 input_mt_slot(input, contact_num);
 769                 input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
 770         }
 771 }
 772
 773 static void elan_report_absolute(struct elan_tp_data *data, u8 *packet)
 774 {
 775         struct input_dev *input = data->input;
 776         u8 *finger_data = &packet[ETP_FINGER_DATA_OFFSET];
 777         int i;
 778         u8 tp_info = packet[ETP_TOUCH_INFO_OFFSET];
 779         bool contact_valid;
 780
 781         for (i = 0; i < ETP_MAX_FINGERS; i++) {
 782                 contact_valid = tp_info & (1U << (3 + i));
 783                 elan_report_contact(data, i, contact_valid, finger_data);
 784
 785                 if (contact_valid)
 786                         finger_data += ETP_FINGER_DATA_LEN;
 787         }
 788
 789         input_report_key(input, BTN_LEFT, tp_info & 0x01);
 790         input_mt_report_pointer_emulation(input, true);
 791         input_sync(input);
 792 }
 793
 794 static irqreturn_t elan_isr(int irq, void *dev_id)
 795 {
 796         struct elan_tp_data *data = dev_id;
 797         struct device *dev = &data->client->dev;
 798         int error;
 799         u8 report[ETP_MAX_REPORT_LEN];
 800
 801         /*
 802          * When device is connected to i2c bus, when all IAP page writes
 803          * complete, the driver will receive interrupt and must read
 804          * 0000 to confirm that IAP is finished.
 805         */
 806         if (data->in_fw_update) {
 807                 complete(&data->fw_completion);
 808                 goto out;
 809         }
 810
 811         error = data->ops->get_report(data->client, report);
 812         if (error)
 813                 goto out;
 814
 815         if (report[ETP_REPORT_ID_OFFSET] != ETP_REPORT_ID)
 816                 dev_err(dev, "invalid report id data (%x)\n",
 817                         report[ETP_REPORT_ID_OFFSET]);
 818         else
 819                 elan_report_absolute(data, report);
 820
 821 out:
 822         return IRQ_HANDLED;
 823 }
 824
 825 /*
 826  ******************************************************************
 827  * Elan initialization functions
 828  ******************************************************************
 829  */
 830 static int elan_setup_input_device(struct elan_tp_data *data)
 831 {
 832         struct device *dev = &data->client->dev;
 833         struct input_dev *input;
 834         unsigned int max_width = max(data->width_x, data->width_y);
 835         unsigned int min_width = min(data->width_x, data->width_y);
 836         int error;
 837
 838         input = devm_input_allocate_device(dev);
 839         if (!input)
 840                 return -ENOMEM;
 841
 842         input->name = "Elan Touchpad";
 843         input->id.bustype = BUS_I2C;
 844         input_set_drvdata(input, data);
 845
 846         error = input_mt_init_slots(input, ETP_MAX_FINGERS,
 847                                     INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
 848         if (error) {
 849                 dev_err(dev, "failed to initialize MT slots: %d\n", error);
 850                 return error;
 851         }
 852
 853         __set_bit(EV_ABS, input->evbit);
 854         __set_bit(INPUT_PROP_POINTER, input->propbit);
 855         __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 856         __set_bit(BTN_LEFT, input->keybit);
 857
 858         /* Set up ST parameters */
 859         input_set_abs_params(input, ABS_X, 0, data->max_x, 0, 0);
 860         input_set_abs_params(input, ABS_Y, 0, data->max_y, 0, 0);
 861         input_abs_set_res(input, ABS_X, data->x_res);
 862         input_abs_set_res(input, ABS_Y, data->y_res);
 863         input_set_abs_params(input, ABS_PRESSURE, 0, ETP_MAX_PRESSURE, 0, 0);
 864         input_set_abs_params(input, ABS_TOOL_WIDTH, 0, ETP_FINGER_WIDTH, 0, 0);
 865
 866         /* And MT parameters */
 867         input_set_abs_params(input, ABS_MT_POSITION_X, 0, data->max_x, 0, 0);
 868         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, data->max_y, 0, 0);
 869         input_abs_set_res(input, ABS_MT_POSITION_X, data->x_res);
 870         input_abs_set_res(input, ABS_MT_POSITION_Y, data->y_res);
 871         input_set_abs_params(input, ABS_MT_PRESSURE, 0,
 872                              ETP_MAX_PRESSURE, 0, 0);
 873         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0,
 874                              ETP_FINGER_WIDTH * max_width, 0, 0);
 875         input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0,
 876                              ETP_FINGER_WIDTH * min_width, 0, 0);
 877
 878         data->input = input;
 879
 880         return 0;
 881 }
 882
 883 static void elan_disable_regulator(void *_data)
 884 {
 885         struct elan_tp_data *data = _data;
 886
 887         regulator_disable(data->vcc);
 888 }
 889
 890 static void elan_remove_sysfs_groups(void *_data)
 891 {
 892         struct elan_tp_data *data = _data;
 893
 894         sysfs_remove_groups(&data->client->dev.kobj, elan_sysfs_groups);
 895 }
 896
 897 static int elan_probe(struct i2c_client *client,
 898                       const struct i2c_device_id *dev_id)
 899 {
 900         const struct elan_transport_ops *transport_ops;
 901         struct device *dev = &client->dev;
 902         struct elan_tp_data *data;
 903         unsigned long irqflags;
 904         int error;
 905
 906         if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C) &&
 907             i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 908                 transport_ops = &elan_i2c_ops;
 909         } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) &&
 910                    i2c_check_functionality(client->adapter,
 911                                            I2C_FUNC_SMBUS_BYTE_DATA |
 912                                                 I2C_FUNC_SMBUS_BLOCK_DATA |
 913                                                 I2C_FUNC_SMBUS_I2C_BLOCK)) {
 914                 transport_ops = &elan_smbus_ops;
 915         } else {
 916                 dev_err(dev, "not a supported I2C/SMBus adapter\n");
 917                 return -EIO;
 918         }
 919
 920         data = devm_kzalloc(&client->dev, sizeof(struct elan_tp_data),
 921                             GFP_KERNEL);
 922         if (!data)
 923                 return -ENOMEM;
 924
 925         i2c_set_clientdata(client, data);
 926
 927         data->ops = transport_ops;
 928         data->client = client;
 929         init_completion(&data->fw_completion);
 930         mutex_init(&data->sysfs_mutex);
 931
 932         data->vcc = devm_regulator_get(&client->dev, "vcc");
 933         if (IS_ERR(data->vcc)) {
 934                 error = PTR_ERR(data->vcc);
 935                 if (error != -EPROBE_DEFER)
 936                         dev_err(&client->dev,
 937                                 "Failed to get 'vcc' regulator: %d\n",
 938                                 error);
 939                 return error;
 940         }
 941
 942         error = regulator_enable(data->vcc);
 943         if (error) {
 944                 dev_err(&client->dev,
 945                         "Failed to enable regulator: %d\n", error);
 946                 return error;
 947         }
 948
 949         error = devm_add_action(&client->dev,
 950                                 elan_disable_regulator, data);
 951         if (error) {
 952                 regulator_disable(data->vcc);
 953                 dev_err(&client->dev,
 954                         "Failed to add disable regulator action: %d\n",
 955                         error);
 956                 return error;
 957         }
 958
 959         /* Initialize the touchpad. */
 960         error = elan_initialize(data);
 961         if (error)
 962                 return error;
 963
 964         error = elan_query_device_info(data);
 965         if (error)
 966                 return error;
 967
 968         error = elan_query_device_parameters(data);
 969         if (error)
 970                 return error;
 971
 972         dev_dbg(&client->dev,
 973                 "Elan Touchpad Information:\n"
 974                 "    Module product ID:  0x%04x\n"
 975                 "    Firmware Version:  0x%04x\n"
 976                 "    Sample Version:  0x%04x\n"
 977                 "    IAP Version:  0x%04x\n"
 978                 "    Max ABS X,Y:   %d,%d\n"
 979                 "    Width X,Y:   %d,%d\n"
 980                 "    Resolution X,Y:   %d,%d (dots/mm)\n",
 981                 data->product_id,
 982                 data->fw_version,
 983                 data->sm_version,
 984                 data->iap_version,
 985                 data->max_x, data->max_y,
 986                 data->width_x, data->width_y,
 987                 data->x_res, data->y_res);
 988
 989         /* Set up input device properties based on queried parameters. */
 990         error = elan_setup_input_device(data);
 991         if (error)
 992                 return error;
 993
 994         /*
 995          * Systems using device tree should set up interrupt via DTS,
 996          * the rest will use the default falling edge interrupts.
 997          */
 998         irqflags = client->dev.of_node ? 0 : IRQF_TRIGGER_FALLING;
 999
1000         error = devm_request_threaded_irq(&client->dev, client->irq,
1001                                           NULL, elan_isr,
1002                                           irqflags | IRQF_ONESHOT,
1003                                           client->name, data);
1004         if (error) {
1005                 dev_err(&client->dev, "cannot register irq=%d\n", client->irq);
1006                 return error;
1007         }
1008
1009         error = sysfs_create_groups(&client->dev.kobj, elan_sysfs_groups);
1010         if (error) {
1011                 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1012                         error);
1013                 return error;
1014         }
1015
1016         error = devm_add_action(&client->dev,
1017                                 elan_remove_sysfs_groups, data);
1018         if (error) {
1019                 elan_remove_sysfs_groups(data);
1020                 dev_err(&client->dev,
1021                         "Failed to add sysfs cleanup action: %d\n",
1022                         error);
1023                 return error;
1024         }
1025
1026         error = input_register_device(data->input);
1027         if (error) {
1028                 dev_err(&client->dev, "failed to register input device: %d\n",
1029                         error);
1030                 return error;
1031         }
1032
1033         /*
1034          * Systems using device tree should set up wakeup via DTS,
1035          * the rest will configure device as wakeup source by default.
1036          */
1037         if (!client->dev.of_node)
1038                 device_init_wakeup(&client->dev, true);
1039
1040         return 0;
1041 }
1042
1043 static int __maybe_unused elan_suspend(struct device *dev)
1044 {
1045         struct i2c_client *client = to_i2c_client(dev);
1046         struct elan_tp_data *data = i2c_get_clientdata(client);
1047         int ret;
1048
1049         /*
1050          * We are taking the mutex to make sure sysfs operations are
1051          * complete before we attempt to bring the device into low[er]
1052          * power mode.
1053          */
1054         ret = mutex_lock_interruptible(&data->sysfs_mutex);
1055         if (ret)
1056                 return ret;
1057
1058         disable_irq(client->irq);
1059
1060         if (device_may_wakeup(dev)) {
1061                 ret = elan_sleep(data);
1062                 /* Enable wake from IRQ */
1063                 data->irq_wake = (enable_irq_wake(client->irq) == 0);
1064         } else {
1065                 ret = elan_disable_power(data);
1066         }
1067
1068         mutex_unlock(&data->sysfs_mutex);
1069         return ret;
1070 }
1071
1072 static int __maybe_unused elan_resume(struct device *dev)
1073 {
1074         struct i2c_client *client = to_i2c_client(dev);
1075         struct elan_tp_data *data = i2c_get_clientdata(client);
1076         int error;
1077
1078         if (device_may_wakeup(dev) && data->irq_wake) {
1079                 disable_irq_wake(client->irq);
1080                 data->irq_wake = false;
1081         }
1082
1083         error = elan_enable_power(data);
1084         if (error)
1085                 dev_err(dev, "power up when resuming failed: %d\n", error);
1086
1087         error = elan_initialize(data);
1088         if (error)
1089                 dev_err(dev, "initialize when resuming failed: %d\n", error);
1090
1091         enable_irq(data->client->irq);
1092
1093         return 0;
1094 }
1095
1096 static SIMPLE_DEV_PM_OPS(elan_pm_ops, elan_suspend, elan_resume);
1097
1098 static const struct i2c_device_id elan_id[] = {
1099         { DRIVER_NAME, 0 },
1100         { },
1101 };
1102 MODULE_DEVICE_TABLE(i2c, elan_id);
1103
1104 #ifdef CONFIG_ACPI
1105 static const struct acpi_device_id elan_acpi_id[] = {
1106         { "ELAN0000", 0 },
1107         { }
1108 };
1109 MODULE_DEVICE_TABLE(acpi, elan_acpi_id);
1110 #endif
1111
1112 #ifdef CONFIG_OF
1113 static const struct of_device_id elan_of_match[] = {
1114         { .compatible = "elan,ekth3000" },
1115         { /* sentinel */ }
1116 };
1117 MODULE_DEVICE_TABLE(of, elan_of_match);
1118 #endif
1119
1120 static struct i2c_driver elan_driver = {
1121         .driver = {
1122                 .name   = DRIVER_NAME,
1123                 .owner  = THIS_MODULE,
1124                 .pm     = &elan_pm_ops,
1125                 .acpi_match_table = ACPI_PTR(elan_acpi_id),
1126                 .of_match_table = of_match_ptr(elan_of_match),
1127         },
1128         .probe          = elan_probe,
1129         .id_table       = elan_id,
1130 };
1131
1132 module_i2c_driver(elan_driver);
1133
1134 MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>");
1135 MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver");
1136 MODULE_LICENSE("GPL");
1137 MODULE_VERSION(ELAN_DRIVER_VERSION);