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