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.6
   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.6"
  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_VAILDPAGE_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 elan_tp_data *data = dev_get_drvdata(dev);
 438         const struct firmware *fw;
 439         int error;
 440         const u8 *fw_signature;
 441         static const u8 signature[] = {0xAA, 0x55, 0xCC, 0x33, 0xFF, 0xFF};
 442
 443         error = request_firmware(&fw, ETP_FW_NAME, dev);
 444         if (error) {
 445                 dev_err(dev, "cannot load firmware %s: %d\n",
 446                         ETP_FW_NAME, error);
 447                 return error;
 448         }
 449
 450         /* Firmware file must match signature data */
 451         fw_signature = &fw->data[ETP_FW_SIGNATURE_ADDRESS];
 452         if (memcmp(fw_signature, signature, sizeof(signature)) != 0) {
 453                 dev_err(dev, "signature mismatch (expected %*ph, got %*ph)\n",
 454                         (int)sizeof(signature), signature,
 455                         (int)sizeof(signature), fw_signature);
 456                 error = -EBADF;
 457                 goto out_release_fw;
 458         }
 459
 460         error = mutex_lock_interruptible(&data->sysfs_mutex);
 461         if (error)
 462                 goto out_release_fw;
 463
 464         error = elan_update_firmware(data, fw);
 465
 466         mutex_unlock(&data->sysfs_mutex);
 467
 468 out_release_fw:
 469         release_firmware(fw);
 470         return error ?: count;
 471 }
 472
 473 static ssize_t calibrate_store(struct device *dev,
 474                                struct device_attribute *attr,
 475                                const char *buf, size_t count)
 476 {
 477         struct i2c_client *client = to_i2c_client(dev);
 478         struct elan_tp_data *data = i2c_get_clientdata(client);
 479         int tries = 20;
 480         int retval;
 481         int error;
 482         u8 val[3];
 483
 484         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 485         if (retval)
 486                 return retval;
 487
 488         disable_irq(client->irq);
 489
 490         data->mode |= ETP_ENABLE_CALIBRATE;
 491         retval = data->ops->set_mode(client, data->mode);
 492         if (retval) {
 493                 dev_err(dev, "failed to enable calibration mode: %d\n",
 494                         retval);
 495                 goto out;
 496         }
 497
 498         retval = data->ops->calibrate(client);
 499         if (retval) {
 500                 dev_err(dev, "failed to start calibration: %d\n",
 501                         retval);
 502                 goto out_disable_calibrate;
 503         }
 504
 505         val[0] = 0xff;
 506         do {
 507                 /* Wait 250ms before checking if calibration has completed. */
 508                 msleep(250);
 509
 510                 retval = data->ops->calibrate_result(client, val);
 511                 if (retval)
 512                         dev_err(dev, "failed to check calibration result: %d\n",
 513                                 retval);
 514                 else if (val[0] == 0)
 515                         break; /* calibration done */
 516
 517         } while (--tries);
 518
 519         if (tries == 0) {
 520                 dev_err(dev, "failed to calibrate. Timeout.\n");
 521                 retval = -ETIMEDOUT;
 522         }
 523
 524 out_disable_calibrate:
 525         data->mode &= ~ETP_ENABLE_CALIBRATE;
 526         error = data->ops->set_mode(data->client, data->mode);
 527         if (error) {
 528                 dev_err(dev, "failed to disable calibration mode: %d\n",
 529                         error);
 530                 if (!retval)
 531                         retval = error;
 532         }
 533 out:
 534         enable_irq(client->irq);
 535         mutex_unlock(&data->sysfs_mutex);
 536         return retval ?: count;
 537 }
 538
 539 static ssize_t elan_sysfs_read_mode(struct device *dev,
 540                                     struct device_attribute *attr,
 541                                     char *buf)
 542 {
 543         struct i2c_client *client = to_i2c_client(dev);
 544         struct elan_tp_data *data = i2c_get_clientdata(client);
 545         int error;
 546         enum tp_mode mode;
 547
 548         error = mutex_lock_interruptible(&data->sysfs_mutex);
 549         if (error)
 550                 return error;
 551
 552         error = data->ops->iap_get_mode(data->client, &mode);
 553
 554         mutex_unlock(&data->sysfs_mutex);
 555
 556         if (error)
 557                 return error;
 558
 559         return sprintf(buf, "%d\n", (int)mode);
 560 }
 561
 562 static DEVICE_ATTR(product_id, S_IRUGO, elan_sysfs_read_product_id, NULL);
 563 static DEVICE_ATTR(firmware_version, S_IRUGO, elan_sysfs_read_fw_ver, NULL);
 564 static DEVICE_ATTR(sample_version, S_IRUGO, elan_sysfs_read_sm_ver, NULL);
 565 static DEVICE_ATTR(iap_version, S_IRUGO, elan_sysfs_read_iap_ver, NULL);
 566 static DEVICE_ATTR(fw_checksum, S_IRUGO, elan_sysfs_read_fw_checksum, NULL);
 567 static DEVICE_ATTR(mode, S_IRUGO, elan_sysfs_read_mode, NULL);
 568 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, elan_sysfs_update_fw);
 569
 570 static DEVICE_ATTR_WO(calibrate);
 571
 572 static struct attribute *elan_sysfs_entries[] = {
 573         &dev_attr_product_id.attr,
 574         &dev_attr_firmware_version.attr,
 575         &dev_attr_sample_version.attr,
 576         &dev_attr_iap_version.attr,
 577         &dev_attr_fw_checksum.attr,
 578         &dev_attr_calibrate.attr,
 579         &dev_attr_mode.attr,
 580         &dev_attr_update_fw.attr,
 581         NULL,
 582 };
 583
 584 static const struct attribute_group elan_sysfs_group = {
 585         .attrs = elan_sysfs_entries,
 586 };
 587
 588 static ssize_t acquire_store(struct device *dev, struct device_attribute *attr,
 589                              const char *buf, size_t count)
 590 {
 591         struct i2c_client *client = to_i2c_client(dev);
 592         struct elan_tp_data *data = i2c_get_clientdata(client);
 593         int error;
 594         int retval;
 595
 596         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 597         if (retval)
 598                 return retval;
 599
 600         disable_irq(client->irq);
 601
 602         data->baseline_ready = false;
 603
 604         data->mode |= ETP_ENABLE_CALIBRATE;
 605         retval = data->ops->set_mode(data->client, data->mode);
 606         if (retval) {
 607                 dev_err(dev, "Failed to enable calibration mode to get baseline: %d\n",
 608                         retval);
 609                 goto out;
 610         }
 611
 612         msleep(250);
 613
 614         retval = data->ops->get_baseline_data(data->client, true,
 615                                               &data->max_baseline);
 616         if (retval) {
 617                 dev_err(dev, "Failed to read max baseline form device: %d\n",
 618                         retval);
 619                 goto out_disable_calibrate;
 620         }
 621
 622         retval = data->ops->get_baseline_data(data->client, false,
 623                                               &data->min_baseline);
 624         if (retval) {
 625                 dev_err(dev, "Failed to read min baseline form device: %d\n",
 626                         retval);
 627                 goto out_disable_calibrate;
 628         }
 629
 630         data->baseline_ready = true;
 631
 632 out_disable_calibrate:
 633         data->mode &= ~ETP_ENABLE_CALIBRATE;
 634         error = data->ops->set_mode(data->client, data->mode);
 635         if (error) {
 636                 dev_err(dev, "Failed to disable calibration mode after acquiring baseline: %d\n",
 637                         error);
 638                 if (!retval)
 639                         retval = error;
 640         }
 641 out:
 642         enable_irq(client->irq);
 643         mutex_unlock(&data->sysfs_mutex);
 644         return retval ?: count;
 645 }
 646
 647 static ssize_t min_show(struct device *dev,
 648                         struct device_attribute *attr, char *buf)
 649 {
 650         struct i2c_client *client = to_i2c_client(dev);
 651         struct elan_tp_data *data = i2c_get_clientdata(client);
 652         int retval;
 653
 654         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 655         if (retval)
 656                 return retval;
 657
 658         if (!data->baseline_ready) {
 659                 retval = -ENODATA;
 660                 goto out;
 661         }
 662
 663         retval = snprintf(buf, PAGE_SIZE, "%d", data->min_baseline);
 664
 665 out:
 666         mutex_unlock(&data->sysfs_mutex);
 667         return retval;
 668 }
 669
 670 static ssize_t max_show(struct device *dev,
 671                         struct device_attribute *attr, char *buf)
 672 {
 673         struct i2c_client *client = to_i2c_client(dev);
 674         struct elan_tp_data *data = i2c_get_clientdata(client);
 675         int retval;
 676
 677         retval = mutex_lock_interruptible(&data->sysfs_mutex);
 678         if (retval)
 679                 return retval;
 680
 681         if (!data->baseline_ready) {
 682                 retval = -ENODATA;
 683                 goto out;
 684         }
 685
 686         retval = snprintf(buf, PAGE_SIZE, "%d", data->max_baseline);
 687
 688 out:
 689         mutex_unlock(&data->sysfs_mutex);
 690         return retval;
 691 }
 692
 693
 694 static DEVICE_ATTR_WO(acquire);
 695 static DEVICE_ATTR_RO(min);
 696 static DEVICE_ATTR_RO(max);
 697
 698 static struct attribute *elan_baseline_sysfs_entries[] = {
 699         &dev_attr_acquire.attr,
 700         &dev_attr_min.attr,
 701         &dev_attr_max.attr,
 702         NULL,
 703 };
 704
 705 static const struct attribute_group elan_baseline_sysfs_group = {
 706         .name = "baseline",
 707         .attrs = elan_baseline_sysfs_entries,
 708 };
 709
 710 static const struct attribute_group *elan_sysfs_groups[] = {
 711         &elan_sysfs_group,
 712         &elan_baseline_sysfs_group,
 713         NULL
 714 };
 715
 716 /*
 717  ******************************************************************
 718  * Elan isr functions
 719  ******************************************************************
 720  */
 721 static void elan_report_contact(struct elan_tp_data *data,
 722                                 int contact_num, bool contact_valid,
 723                                 u8 *finger_data)
 724 {
 725         struct input_dev *input = data->input;
 726         unsigned int pos_x, pos_y;
 727         unsigned int pressure, mk_x, mk_y;
 728         unsigned int area_x, area_y, major, minor, new_pressure;
 729
 730
 731         if (contact_valid) {
 732                 pos_x = ((finger_data[0] & 0xf0) << 4) |
 733                                                 finger_data[1];
 734                 pos_y = ((finger_data[0] & 0x0f) << 8) |
 735                                                 finger_data[2];
 736                 mk_x = (finger_data[3] & 0x0f);
 737                 mk_y = (finger_data[3] >> 4);
 738                 pressure = finger_data[4];
 739
 740                 if (pos_x > data->max_x || pos_y > data->max_y) {
 741                         dev_dbg(input->dev.parent,
 742                                 "[%d] x=%d y=%d over max (%d, %d)",
 743                                 contact_num, pos_x, pos_y,
 744                                 data->max_x, data->max_y);
 745                         return;
 746                 }
 747
 748                 /*
 749                  * To avoid treating large finger as palm, let's reduce the
 750                  * width x and y per trace.
 751                  */
 752                 area_x = mk_x * (data->width_x - ETP_FWIDTH_REDUCE);
 753                 area_y = mk_y * (data->width_y - ETP_FWIDTH_REDUCE);
 754
 755                 major = max(area_x, area_y);
 756                 minor = min(area_x, area_y);
 757
 758                 new_pressure = pressure + ETP_PRESSURE_OFFSET;
 759                 if (new_pressure > ETP_MAX_PRESSURE)
 760                         new_pressure = ETP_MAX_PRESSURE;
 761
 762                 input_mt_slot(input, contact_num);
 763                 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
 764                 input_report_abs(input, ABS_MT_POSITION_X, pos_x);
 765                 input_report_abs(input, ABS_MT_POSITION_Y, data->max_y - pos_y);
 766                 input_report_abs(input, ABS_MT_PRESSURE, new_pressure);
 767                 input_report_abs(input, ABS_TOOL_WIDTH, mk_x);
 768                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, major);
 769                 input_report_abs(input, ABS_MT_TOUCH_MINOR, minor);
 770         } else {
 771                 input_mt_slot(input, contact_num);
 772                 input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
 773         }
 774 }
 775
 776 static void elan_report_absolute(struct elan_tp_data *data, u8 *packet)
 777 {
 778         struct input_dev *input = data->input;
 779         u8 *finger_data = &packet[ETP_FINGER_DATA_OFFSET];
 780         int i;
 781         u8 tp_info = packet[ETP_TOUCH_INFO_OFFSET];
 782         bool contact_valid;
 783
 784         for (i = 0; i < ETP_MAX_FINGERS; i++) {
 785                 contact_valid = tp_info & (1U << (3 + i));
 786                 elan_report_contact(data, i, contact_valid, finger_data);
 787
 788                 if (contact_valid)
 789                         finger_data += ETP_FINGER_DATA_LEN;
 790         }
 791
 792         input_report_key(input, BTN_LEFT, tp_info & 0x01);
 793         input_mt_report_pointer_emulation(input, true);
 794         input_sync(input);
 795 }
 796
 797 static irqreturn_t elan_isr(int irq, void *dev_id)
 798 {
 799         struct elan_tp_data *data = dev_id;
 800         struct device *dev = &data->client->dev;
 801         int error;
 802         u8 report[ETP_MAX_REPORT_LEN];
 803
 804         /*
 805          * When device is connected to i2c bus, when all IAP page writes
 806          * complete, the driver will receive interrupt and must read
 807          * 0000 to confirm that IAP is finished.
 808         */
 809         if (data->in_fw_update) {
 810                 complete(&data->fw_completion);
 811                 goto out;
 812         }
 813
 814         error = data->ops->get_report(data->client, report);
 815         if (error)
 816                 goto out;
 817
 818         if (report[ETP_REPORT_ID_OFFSET] != ETP_REPORT_ID)
 819                 dev_err(dev, "invalid report id data (%x)\n",
 820                         report[ETP_REPORT_ID_OFFSET]);
 821         else
 822                 elan_report_absolute(data, report);
 823
 824 out:
 825         return IRQ_HANDLED;
 826 }
 827
 828 /*
 829  ******************************************************************
 830  * Elan initialization functions
 831  ******************************************************************
 832  */
 833 static int elan_setup_input_device(struct elan_tp_data *data)
 834 {
 835         struct device *dev = &data->client->dev;
 836         struct input_dev *input;
 837         unsigned int max_width = max(data->width_x, data->width_y);
 838         unsigned int min_width = min(data->width_x, data->width_y);
 839         int error;
 840
 841         input = devm_input_allocate_device(dev);
 842         if (!input)
 843                 return -ENOMEM;
 844
 845         input->name = "Elan Touchpad";
 846         input->id.bustype = BUS_I2C;
 847         input_set_drvdata(input, data);
 848
 849         error = input_mt_init_slots(input, ETP_MAX_FINGERS,
 850                                     INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
 851         if (error) {
 852                 dev_err(dev, "failed to initialize MT slots: %d\n", error);
 853                 return error;
 854         }
 855
 856         __set_bit(EV_ABS, input->evbit);
 857         __set_bit(INPUT_PROP_POINTER, input->propbit);
 858         __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 859         __set_bit(BTN_LEFT, input->keybit);
 860
 861         /* Set up ST parameters */
 862         input_set_abs_params(input, ABS_X, 0, data->max_x, 0, 0);
 863         input_set_abs_params(input, ABS_Y, 0, data->max_y, 0, 0);
 864         input_abs_set_res(input, ABS_X, data->x_res);
 865         input_abs_set_res(input, ABS_Y, data->y_res);
 866         input_set_abs_params(input, ABS_PRESSURE, 0, ETP_MAX_PRESSURE, 0, 0);
 867         input_set_abs_params(input, ABS_TOOL_WIDTH, 0, ETP_FINGER_WIDTH, 0, 0);
 868
 869         /* And MT parameters */
 870         input_set_abs_params(input, ABS_MT_POSITION_X, 0, data->max_x, 0, 0);
 871         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, data->max_y, 0, 0);
 872         input_abs_set_res(input, ABS_MT_POSITION_X, data->x_res);
 873         input_abs_set_res(input, ABS_MT_POSITION_Y, data->y_res);
 874         input_set_abs_params(input, ABS_MT_PRESSURE, 0,
 875                              ETP_MAX_PRESSURE, 0, 0);
 876         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0,
 877                              ETP_FINGER_WIDTH * max_width, 0, 0);
 878         input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0,
 879                              ETP_FINGER_WIDTH * min_width, 0, 0);
 880
 881         data->input = input;
 882
 883         return 0;
 884 }
 885
 886 static void elan_disable_regulator(void *_data)
 887 {
 888         struct elan_tp_data *data = _data;
 889
 890         regulator_disable(data->vcc);
 891 }
 892
 893 static void elan_remove_sysfs_groups(void *_data)
 894 {
 895         struct elan_tp_data *data = _data;
 896
 897         sysfs_remove_groups(&data->client->dev.kobj, elan_sysfs_groups);
 898 }
 899
 900 static int elan_probe(struct i2c_client *client,
 901                       const struct i2c_device_id *dev_id)
 902 {
 903         const struct elan_transport_ops *transport_ops;
 904         struct device *dev = &client->dev;
 905         struct elan_tp_data *data;
 906         unsigned long irqflags;
 907         int error;
 908
 909         if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C) &&
 910             i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 911                 transport_ops = &elan_i2c_ops;
 912         } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) &&
 913                    i2c_check_functionality(client->adapter,
 914                                            I2C_FUNC_SMBUS_BYTE_DATA |
 915                                                 I2C_FUNC_SMBUS_BLOCK_DATA |
 916                                                 I2C_FUNC_SMBUS_I2C_BLOCK)) {
 917                 transport_ops = &elan_smbus_ops;
 918         } else {
 919                 dev_err(dev, "not a supported I2C/SMBus adapter\n");
 920                 return -EIO;
 921         }
 922
 923         data = devm_kzalloc(&client->dev, sizeof(struct elan_tp_data),
 924                             GFP_KERNEL);
 925         if (!data)
 926                 return -ENOMEM;
 927
 928         i2c_set_clientdata(client, data);
 929
 930         data->ops = transport_ops;
 931         data->client = client;
 932         init_completion(&data->fw_completion);
 933         mutex_init(&data->sysfs_mutex);
 934
 935         data->vcc = devm_regulator_get(&client->dev, "vcc");
 936         if (IS_ERR(data->vcc)) {
 937                 error = PTR_ERR(data->vcc);
 938                 if (error != -EPROBE_DEFER)
 939                         dev_err(&client->dev,
 940                                 "Failed to get 'vcc' regulator: %d\n",
 941                                 error);
 942                 return error;
 943         }
 944
 945         error = regulator_enable(data->vcc);
 946         if (error) {
 947                 dev_err(&client->dev,
 948                         "Failed to enable regulator: %d\n", error);
 949                 return error;
 950         }
 951
 952         error = devm_add_action(&client->dev,
 953                                 elan_disable_regulator, data);
 954         if (error) {
 955                 regulator_disable(data->vcc);
 956                 dev_err(&client->dev,
 957                         "Failed to add disable regulator action: %d\n",
 958                         error);
 959                 return error;
 960         }
 961
 962         /* Initialize the touchpad. */
 963         error = elan_initialize(data);
 964         if (error)
 965                 return error;
 966
 967         error = elan_query_device_info(data);
 968         if (error)
 969                 return error;
 970
 971         error = elan_query_device_parameters(data);
 972         if (error)
 973                 return error;
 974
 975         dev_dbg(&client->dev,
 976                 "Elan Touchpad Information:\n"
 977                 "    Module product ID:  0x%04x\n"
 978                 "    Firmware Version:  0x%04x\n"
 979                 "    Sample Version:  0x%04x\n"
 980                 "    IAP Version:  0x%04x\n"
 981                 "    Max ABS X,Y:   %d,%d\n"
 982                 "    Width X,Y:   %d,%d\n"
 983                 "    Resolution X,Y:   %d,%d (dots/mm)\n",
 984                 data->product_id,
 985                 data->fw_version,
 986                 data->sm_version,
 987                 data->iap_version,
 988                 data->max_x, data->max_y,
 989                 data->width_x, data->width_y,
 990                 data->x_res, data->y_res);
 991
 992         /* Set up input device properties based on queried parameters. */
 993         error = elan_setup_input_device(data);
 994         if (error)
 995                 return error;
 996
 997         /*
 998          * Systems using device tree should set up interrupt via DTS,
 999          * the rest will use the default falling edge interrupts.
1000          */
1001         irqflags = client->dev.of_node ? 0 : IRQF_TRIGGER_FALLING;
1002
1003         error = devm_request_threaded_irq(&client->dev, client->irq,
1004                                           NULL, elan_isr,
1005                                           irqflags | IRQF_ONESHOT,
1006                                           client->name, data);
1007         if (error) {
1008                 dev_err(&client->dev, "cannot register irq=%d\n", client->irq);
1009                 return error;
1010         }
1011
1012         error = sysfs_create_groups(&client->dev.kobj, elan_sysfs_groups);
1013         if (error) {
1014                 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1015                         error);
1016                 return error;
1017         }
1018
1019         error = devm_add_action(&client->dev,
1020                                 elan_remove_sysfs_groups, data);
1021         if (error) {
1022                 elan_remove_sysfs_groups(data);
1023                 dev_err(&client->dev,
1024                         "Failed to add sysfs cleanup action: %d\n",
1025                         error);
1026                 return error;
1027         }
1028
1029         error = input_register_device(data->input);
1030         if (error) {
1031                 dev_err(&client->dev, "failed to register input device: %d\n",
1032                         error);
1033                 return error;
1034         }
1035
1036         /*
1037          * Systems using device tree should set up wakeup via DTS,
1038          * the rest will configure device as wakeup source by default.
1039          */
1040         if (!client->dev.of_node)
1041                 device_init_wakeup(&client->dev, true);
1042
1043         return 0;
1044 }
1045
1046 static int __maybe_unused elan_suspend(struct device *dev)
1047 {
1048         struct i2c_client *client = to_i2c_client(dev);
1049         struct elan_tp_data *data = i2c_get_clientdata(client);
1050         int ret;
1051
1052         /*
1053          * We are taking the mutex to make sure sysfs operations are
1054          * complete before we attempt to bring the device into low[er]
1055          * power mode.
1056          */
1057         ret = mutex_lock_interruptible(&data->sysfs_mutex);
1058         if (ret)
1059                 return ret;
1060
1061         disable_irq(client->irq);
1062
1063         if (device_may_wakeup(dev)) {
1064                 ret = elan_sleep(data);
1065                 /* Enable wake from IRQ */
1066                 data->irq_wake = (enable_irq_wake(client->irq) == 0);
1067         } else {
1068                 ret = elan_disable_power(data);
1069         }
1070
1071         mutex_unlock(&data->sysfs_mutex);
1072         return ret;
1073 }
1074
1075 static int __maybe_unused elan_resume(struct device *dev)
1076 {
1077         struct i2c_client *client = to_i2c_client(dev);
1078         struct elan_tp_data *data = i2c_get_clientdata(client);
1079         int error;
1080
1081         if (device_may_wakeup(dev) && data->irq_wake) {
1082                 disable_irq_wake(client->irq);
1083                 data->irq_wake = false;
1084         }
1085
1086         error = elan_enable_power(data);
1087         if (error)
1088                 dev_err(dev, "power up when resuming failed: %d\n", error);
1089
1090         error = elan_initialize(data);
1091         if (error)
1092                 dev_err(dev, "initialize when resuming failed: %d\n", error);
1093
1094         enable_irq(data->client->irq);
1095
1096         return 0;
1097 }
1098
1099 static SIMPLE_DEV_PM_OPS(elan_pm_ops, elan_suspend, elan_resume);
1100
1101 static const struct i2c_device_id elan_id[] = {
1102         { DRIVER_NAME, 0 },
1103         { },
1104 };
1105 MODULE_DEVICE_TABLE(i2c, elan_id);
1106
1107 #ifdef CONFIG_ACPI
1108 static const struct acpi_device_id elan_acpi_id[] = {
1109         { "ELAN0000", 0 },
1110         { }
1111 };
1112 MODULE_DEVICE_TABLE(acpi, elan_acpi_id);
1113 #endif
1114
1115 #ifdef CONFIG_OF
1116 static const struct of_device_id elan_of_match[] = {
1117         { .compatible = "elan,ekth3000" },
1118         { /* sentinel */ }
1119 };
1120 MODULE_DEVICE_TABLE(of, elan_of_match);
1121 #endif
1122
1123 static struct i2c_driver elan_driver = {
1124         .driver = {
1125                 .name   = DRIVER_NAME,
1126                 .owner  = THIS_MODULE,
1127                 .pm     = &elan_pm_ops,
1128                 .acpi_match_table = ACPI_PTR(elan_acpi_id),
1129                 .of_match_table = of_match_ptr(elan_of_match),
1130         },
1131         .probe          = elan_probe,
1132         .id_table       = elan_id,
1133 };
1134
1135 module_i2c_driver(elan_driver);
1136
1137 MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>");
1138 MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver");
1139 MODULE_LICENSE("GPL");
1140 MODULE_VERSION(ELAN_DRIVER_VERSION);