1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Elan I2C/SMBus Touchpad driver - I2C interface 4 * 5 * Copyright (c) 2013 ELAN Microelectronics Corp. 6 * 7 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw> 8 * 9 * Based on cyapa driver: 10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc. 11 * copyright (c) 2011-2012 Google, Inc. 12 * 13 * Trademarks are the property of their respective owners. 14 */ 15 16 #include <linux/completion.h> 17 #include <linux/delay.h> 18 #include <linux/i2c.h> 19 #include <linux/interrupt.h> 20 #include <linux/jiffies.h> 21 #include <linux/kernel.h> 22 #include <linux/slab.h> 23 #include <linux/sched.h> 24 #include <asm/unaligned.h> 25 26 #include "elan_i2c.h" 27 28 /* Elan i2c commands */ 29 #define ETP_I2C_RESET 0x0100 30 #define ETP_I2C_WAKE_UP 0x0800 31 #define ETP_I2C_SLEEP 0x0801 32 #define ETP_I2C_DESC_CMD 0x0001 33 #define ETP_I2C_REPORT_DESC_CMD 0x0002 34 #define ETP_I2C_STAND_CMD 0x0005 35 #define ETP_I2C_PATTERN_CMD 0x0100 36 #define ETP_I2C_UNIQUEID_CMD 0x0101 37 #define ETP_I2C_FW_VERSION_CMD 0x0102 38 #define ETP_I2C_IC_TYPE_CMD 0x0103 39 #define ETP_I2C_OSM_VERSION_CMD 0x0103 40 #define ETP_I2C_NSM_VERSION_CMD 0x0104 41 #define ETP_I2C_XY_TRACENUM_CMD 0x0105 42 #define ETP_I2C_MAX_X_AXIS_CMD 0x0106 43 #define ETP_I2C_MAX_Y_AXIS_CMD 0x0107 44 #define ETP_I2C_RESOLUTION_CMD 0x0108 45 #define ETP_I2C_PRESSURE_CMD 0x010A 46 #define ETP_I2C_IAP_VERSION_CMD 0x0110 47 #define ETP_I2C_IC_TYPE_P0_CMD 0x0110 48 #define ETP_I2C_IAP_VERSION_P0_CMD 0x0111 49 #define ETP_I2C_SET_CMD 0x0300 50 #define ETP_I2C_POWER_CMD 0x0307 51 #define ETP_I2C_FW_CHECKSUM_CMD 0x030F 52 #define ETP_I2C_IAP_CTRL_CMD 0x0310 53 #define ETP_I2C_IAP_CMD 0x0311 54 #define ETP_I2C_IAP_RESET_CMD 0x0314 55 #define ETP_I2C_IAP_CHECKSUM_CMD 0x0315 56 #define ETP_I2C_CALIBRATE_CMD 0x0316 57 #define ETP_I2C_MAX_BASELINE_CMD 0x0317 58 #define ETP_I2C_MIN_BASELINE_CMD 0x0318 59 #define ETP_I2C_IAP_TYPE_REG 0x0040 60 #define ETP_I2C_IAP_TYPE_CMD 0x0304 61 62 #define ETP_I2C_REPORT_LEN 34 63 #define ETP_I2C_REPORT_LEN_ID2 39 64 #define ETP_I2C_REPORT_MAX_LEN 39 65 #define ETP_I2C_DESC_LENGTH 30 66 #define ETP_I2C_REPORT_DESC_LENGTH 158 67 #define ETP_I2C_INF_LENGTH 2 68 #define ETP_I2C_IAP_PASSWORD 0x1EA5 69 #define ETP_I2C_IAP_RESET 0xF0F0 70 #define ETP_I2C_MAIN_MODE_ON (1 << 9) 71 #define ETP_I2C_IAP_REG_L 0x01 72 #define ETP_I2C_IAP_REG_H 0x06 73 74 static int elan_i2c_read_block(struct i2c_client *client, 75 u16 reg, u8 *val, u16 len) 76 { 77 __le16 buf[] = { 78 cpu_to_le16(reg), 79 }; 80 struct i2c_msg msgs[] = { 81 { 82 .addr = client->addr, 83 .flags = client->flags & I2C_M_TEN, 84 .len = sizeof(buf), 85 .buf = (u8 *)buf, 86 }, 87 { 88 .addr = client->addr, 89 .flags = (client->flags & I2C_M_TEN) | I2C_M_RD, 90 .len = len, 91 .buf = val, 92 } 93 }; 94 int ret; 95 96 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 97 return ret == ARRAY_SIZE(msgs) ? 0 : (ret < 0 ? ret : -EIO); 98 } 99 100 static int elan_i2c_read_cmd(struct i2c_client *client, u16 reg, u8 *val) 101 { 102 int retval; 103 104 retval = elan_i2c_read_block(client, reg, val, ETP_I2C_INF_LENGTH); 105 if (retval < 0) { 106 dev_err(&client->dev, "reading cmd (0x%04x) fail.\n", reg); 107 return retval; 108 } 109 110 return 0; 111 } 112 113 static int elan_i2c_write_cmd(struct i2c_client *client, u16 reg, u16 cmd) 114 { 115 __le16 buf[] = { 116 cpu_to_le16(reg), 117 cpu_to_le16(cmd), 118 }; 119 struct i2c_msg msg = { 120 .addr = client->addr, 121 .flags = client->flags & I2C_M_TEN, 122 .len = sizeof(buf), 123 .buf = (u8 *)buf, 124 }; 125 int ret; 126 127 ret = i2c_transfer(client->adapter, &msg, 1); 128 if (ret != 1) { 129 if (ret >= 0) 130 ret = -EIO; 131 dev_err(&client->dev, "writing cmd (0x%04x) failed: %d\n", 132 reg, ret); 133 return ret; 134 } 135 136 return 0; 137 } 138 139 static int elan_i2c_initialize(struct i2c_client *client) 140 { 141 struct device *dev = &client->dev; 142 int error; 143 u8 val[256]; 144 145 error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET); 146 if (error) { 147 dev_err(dev, "device reset failed: %d\n", error); 148 return error; 149 } 150 151 /* Wait for the device to reset */ 152 msleep(100); 153 154 /* get reset acknowledgement 0000 */ 155 error = i2c_master_recv(client, val, ETP_I2C_INF_LENGTH); 156 if (error < 0) { 157 dev_err(dev, "failed to read reset response: %d\n", error); 158 return error; 159 } 160 161 error = elan_i2c_read_block(client, ETP_I2C_DESC_CMD, 162 val, ETP_I2C_DESC_LENGTH); 163 if (error) { 164 dev_err(dev, "cannot get device descriptor: %d\n", error); 165 return error; 166 } 167 168 error = elan_i2c_read_block(client, ETP_I2C_REPORT_DESC_CMD, 169 val, ETP_I2C_REPORT_DESC_LENGTH); 170 if (error) { 171 dev_err(dev, "fetching report descriptor failed.: %d\n", error); 172 return error; 173 } 174 175 return 0; 176 } 177 178 static int elan_i2c_sleep_control(struct i2c_client *client, bool sleep) 179 { 180 return elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, 181 sleep ? ETP_I2C_SLEEP : ETP_I2C_WAKE_UP); 182 } 183 184 static int elan_i2c_power_control(struct i2c_client *client, bool enable) 185 { 186 u8 val[2]; 187 u16 reg; 188 int error; 189 190 error = elan_i2c_read_cmd(client, ETP_I2C_POWER_CMD, val); 191 if (error) { 192 dev_err(&client->dev, 193 "failed to read current power state: %d\n", 194 error); 195 return error; 196 } 197 198 reg = le16_to_cpup((__le16 *)val); 199 if (enable) 200 reg &= ~ETP_DISABLE_POWER; 201 else 202 reg |= ETP_DISABLE_POWER; 203 204 error = elan_i2c_write_cmd(client, ETP_I2C_POWER_CMD, reg); 205 if (error) { 206 dev_err(&client->dev, 207 "failed to write current power state: %d\n", 208 error); 209 return error; 210 } 211 212 return 0; 213 } 214 215 static int elan_i2c_set_mode(struct i2c_client *client, u8 mode) 216 { 217 return elan_i2c_write_cmd(client, ETP_I2C_SET_CMD, mode); 218 } 219 220 221 static int elan_i2c_calibrate(struct i2c_client *client) 222 { 223 return elan_i2c_write_cmd(client, ETP_I2C_CALIBRATE_CMD, 1); 224 } 225 226 static int elan_i2c_calibrate_result(struct i2c_client *client, u8 *val) 227 { 228 return elan_i2c_read_block(client, ETP_I2C_CALIBRATE_CMD, val, 1); 229 } 230 231 static int elan_i2c_get_baseline_data(struct i2c_client *client, 232 bool max_baseline, u8 *value) 233 { 234 int error; 235 u8 val[3]; 236 237 error = elan_i2c_read_cmd(client, 238 max_baseline ? ETP_I2C_MAX_BASELINE_CMD : 239 ETP_I2C_MIN_BASELINE_CMD, 240 val); 241 if (error) 242 return error; 243 244 *value = le16_to_cpup((__le16 *)val); 245 246 return 0; 247 } 248 249 static int elan_i2c_get_pattern(struct i2c_client *client, u8 *pattern) 250 { 251 int error; 252 u8 val[3]; 253 254 error = elan_i2c_read_cmd(client, ETP_I2C_PATTERN_CMD, val); 255 if (error) { 256 dev_err(&client->dev, "failed to get pattern: %d\n", error); 257 return error; 258 } 259 260 /* 261 * Not all versions of firmware implement "get pattern" command. 262 * When this command is not implemented the device will respond 263 * with 0xFF 0xFF, which we will treat as "old" pattern 0. 264 */ 265 *pattern = val[0] == 0xFF && val[1] == 0xFF ? 0 : val[1]; 266 267 return 0; 268 } 269 270 static int elan_i2c_get_version(struct i2c_client *client, 271 u8 pattern, bool iap, u8 *version) 272 { 273 int error; 274 u16 cmd; 275 u8 val[3]; 276 277 if (!iap) 278 cmd = ETP_I2C_FW_VERSION_CMD; 279 else if (pattern == 0) 280 cmd = ETP_I2C_IAP_VERSION_P0_CMD; 281 else 282 cmd = ETP_I2C_IAP_VERSION_CMD; 283 284 error = elan_i2c_read_cmd(client, cmd, val); 285 if (error) { 286 dev_err(&client->dev, "failed to get %s version: %d\n", 287 iap ? "IAP" : "FW", error); 288 return error; 289 } 290 291 if (pattern >= 0x01) 292 *version = iap ? val[1] : val[0]; 293 else 294 *version = val[0]; 295 return 0; 296 } 297 298 static int elan_i2c_get_sm_version(struct i2c_client *client, u8 pattern, 299 u16 *ic_type, u8 *version, u8 *clickpad) 300 { 301 int error; 302 u8 val[3]; 303 304 if (pattern >= 0x01) { 305 error = elan_i2c_read_cmd(client, ETP_I2C_IC_TYPE_CMD, val); 306 if (error) { 307 dev_err(&client->dev, "failed to get ic type: %d\n", 308 error); 309 return error; 310 } 311 *ic_type = be16_to_cpup((__be16 *)val); 312 313 error = elan_i2c_read_cmd(client, ETP_I2C_NSM_VERSION_CMD, 314 val); 315 if (error) { 316 dev_err(&client->dev, "failed to get SM version: %d\n", 317 error); 318 return error; 319 } 320 *version = val[1]; 321 *clickpad = val[0] & 0x10; 322 } else { 323 error = elan_i2c_read_cmd(client, ETP_I2C_OSM_VERSION_CMD, val); 324 if (error) { 325 dev_err(&client->dev, "failed to get SM version: %d\n", 326 error); 327 return error; 328 } 329 *version = val[0]; 330 331 error = elan_i2c_read_cmd(client, ETP_I2C_IC_TYPE_P0_CMD, val); 332 if (error) { 333 dev_err(&client->dev, "failed to get ic type: %d\n", 334 error); 335 return error; 336 } 337 *ic_type = val[0]; 338 339 error = elan_i2c_read_cmd(client, ETP_I2C_NSM_VERSION_CMD, 340 val); 341 if (error) { 342 dev_err(&client->dev, "failed to get SM version: %d\n", 343 error); 344 return error; 345 } 346 *clickpad = val[0] & 0x10; 347 } 348 349 return 0; 350 } 351 352 static int elan_i2c_get_product_id(struct i2c_client *client, u16 *id) 353 { 354 int error; 355 u8 val[3]; 356 357 error = elan_i2c_read_cmd(client, ETP_I2C_UNIQUEID_CMD, val); 358 if (error) { 359 dev_err(&client->dev, "failed to get product ID: %d\n", error); 360 return error; 361 } 362 363 *id = le16_to_cpup((__le16 *)val); 364 return 0; 365 } 366 367 static int elan_i2c_get_checksum(struct i2c_client *client, 368 bool iap, u16 *csum) 369 { 370 int error; 371 u8 val[3]; 372 373 error = elan_i2c_read_cmd(client, 374 iap ? ETP_I2C_IAP_CHECKSUM_CMD : 375 ETP_I2C_FW_CHECKSUM_CMD, 376 val); 377 if (error) { 378 dev_err(&client->dev, "failed to get %s checksum: %d\n", 379 iap ? "IAP" : "FW", error); 380 return error; 381 } 382 383 *csum = le16_to_cpup((__le16 *)val); 384 return 0; 385 } 386 387 static int elan_i2c_get_max(struct i2c_client *client, 388 unsigned int *max_x, unsigned int *max_y) 389 { 390 int error; 391 u8 val[3]; 392 393 error = elan_i2c_read_cmd(client, ETP_I2C_MAX_X_AXIS_CMD, val); 394 if (error) { 395 dev_err(&client->dev, "failed to get X dimension: %d\n", error); 396 return error; 397 } 398 399 *max_x = le16_to_cpup((__le16 *)val); 400 401 error = elan_i2c_read_cmd(client, ETP_I2C_MAX_Y_AXIS_CMD, val); 402 if (error) { 403 dev_err(&client->dev, "failed to get Y dimension: %d\n", error); 404 return error; 405 } 406 407 *max_y = le16_to_cpup((__le16 *)val); 408 409 return 0; 410 } 411 412 static int elan_i2c_get_resolution(struct i2c_client *client, 413 u8 *hw_res_x, u8 *hw_res_y) 414 { 415 int error; 416 u8 val[3]; 417 418 error = elan_i2c_read_cmd(client, ETP_I2C_RESOLUTION_CMD, val); 419 if (error) { 420 dev_err(&client->dev, "failed to get resolution: %d\n", error); 421 return error; 422 } 423 424 *hw_res_x = val[0]; 425 *hw_res_y = val[1]; 426 427 return 0; 428 } 429 430 static int elan_i2c_get_num_traces(struct i2c_client *client, 431 unsigned int *x_traces, 432 unsigned int *y_traces) 433 { 434 int error; 435 u8 val[3]; 436 437 error = elan_i2c_read_cmd(client, ETP_I2C_XY_TRACENUM_CMD, val); 438 if (error) { 439 dev_err(&client->dev, "failed to get trace info: %d\n", error); 440 return error; 441 } 442 443 *x_traces = val[0]; 444 *y_traces = val[1]; 445 446 return 0; 447 } 448 449 static int elan_i2c_get_pressure_adjustment(struct i2c_client *client, 450 int *adjustment) 451 { 452 int error; 453 u8 val[3]; 454 455 error = elan_i2c_read_cmd(client, ETP_I2C_PRESSURE_CMD, val); 456 if (error) { 457 dev_err(&client->dev, "failed to get pressure format: %d\n", 458 error); 459 return error; 460 } 461 462 if ((val[0] >> 4) & 0x1) 463 *adjustment = 0; 464 else 465 *adjustment = ETP_PRESSURE_OFFSET; 466 467 return 0; 468 } 469 470 static int elan_i2c_iap_get_mode(struct i2c_client *client, enum tp_mode *mode) 471 { 472 int error; 473 u16 constant; 474 u8 val[3]; 475 476 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val); 477 if (error) { 478 dev_err(&client->dev, 479 "failed to read iap control register: %d\n", 480 error); 481 return error; 482 } 483 484 constant = le16_to_cpup((__le16 *)val); 485 dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant); 486 487 *mode = (constant & ETP_I2C_MAIN_MODE_ON) ? MAIN_MODE : IAP_MODE; 488 489 return 0; 490 } 491 492 static int elan_i2c_iap_reset(struct i2c_client *client) 493 { 494 int error; 495 496 error = elan_i2c_write_cmd(client, ETP_I2C_IAP_RESET_CMD, 497 ETP_I2C_IAP_RESET); 498 if (error) { 499 dev_err(&client->dev, "cannot reset IC: %d\n", error); 500 return error; 501 } 502 503 return 0; 504 } 505 506 static int elan_i2c_set_flash_key(struct i2c_client *client) 507 { 508 int error; 509 510 error = elan_i2c_write_cmd(client, ETP_I2C_IAP_CMD, 511 ETP_I2C_IAP_PASSWORD); 512 if (error) { 513 dev_err(&client->dev, "cannot set flash key: %d\n", error); 514 return error; 515 } 516 517 return 0; 518 } 519 520 static int elan_read_write_iap_type(struct i2c_client *client) 521 { 522 int error; 523 u16 constant; 524 u8 val[3]; 525 int retry = 3; 526 527 do { 528 error = elan_i2c_write_cmd(client, ETP_I2C_IAP_TYPE_CMD, 529 ETP_I2C_IAP_TYPE_REG); 530 if (error) { 531 dev_err(&client->dev, 532 "cannot write iap type: %d\n", error); 533 return error; 534 } 535 536 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_TYPE_CMD, val); 537 if (error) { 538 dev_err(&client->dev, 539 "failed to read iap type register: %d\n", 540 error); 541 return error; 542 } 543 constant = le16_to_cpup((__le16 *)val); 544 dev_dbg(&client->dev, "iap type reg: 0x%04x\n", constant); 545 546 if (constant == ETP_I2C_IAP_TYPE_REG) 547 return 0; 548 549 } while (--retry > 0); 550 551 dev_err(&client->dev, "cannot set iap type\n"); 552 return -EIO; 553 } 554 555 static int elan_i2c_prepare_fw_update(struct i2c_client *client, u16 ic_type, 556 u8 iap_version) 557 { 558 struct device *dev = &client->dev; 559 int error; 560 enum tp_mode mode; 561 u8 val[3]; 562 u16 password; 563 564 /* Get FW in which mode (IAP_MODE/MAIN_MODE) */ 565 error = elan_i2c_iap_get_mode(client, &mode); 566 if (error) 567 return error; 568 569 if (mode == IAP_MODE) { 570 /* Reset IC */ 571 error = elan_i2c_iap_reset(client); 572 if (error) 573 return error; 574 575 msleep(30); 576 } 577 578 /* Set flash key*/ 579 error = elan_i2c_set_flash_key(client); 580 if (error) 581 return error; 582 583 /* Wait for F/W IAP initialization */ 584 msleep(mode == MAIN_MODE ? 100 : 30); 585 586 /* Check if we are in IAP mode or not */ 587 error = elan_i2c_iap_get_mode(client, &mode); 588 if (error) 589 return error; 590 591 if (mode == MAIN_MODE) { 592 dev_err(dev, "wrong mode: %d\n", mode); 593 return -EIO; 594 } 595 596 if (ic_type >= 0x0D && iap_version >= 1) { 597 error = elan_read_write_iap_type(client); 598 if (error) 599 return error; 600 } 601 602 /* Set flash key again */ 603 error = elan_i2c_set_flash_key(client); 604 if (error) 605 return error; 606 607 /* Wait for F/W IAP initialization */ 608 msleep(30); 609 610 /* read back to check we actually enabled successfully. */ 611 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CMD, val); 612 if (error) { 613 dev_err(dev, "cannot read iap password: %d\n", 614 error); 615 return error; 616 } 617 618 password = le16_to_cpup((__le16 *)val); 619 if (password != ETP_I2C_IAP_PASSWORD) { 620 dev_err(dev, "wrong iap password: 0x%X\n", password); 621 return -EIO; 622 } 623 624 return 0; 625 } 626 627 static int elan_i2c_write_fw_block(struct i2c_client *client, u16 fw_page_size, 628 const u8 *page, u16 checksum, int idx) 629 { 630 struct device *dev = &client->dev; 631 u8 *page_store; 632 u8 val[3]; 633 u16 result; 634 int ret, error; 635 636 page_store = kmalloc(fw_page_size + 4, GFP_KERNEL); 637 if (!page_store) 638 return -ENOMEM; 639 640 page_store[0] = ETP_I2C_IAP_REG_L; 641 page_store[1] = ETP_I2C_IAP_REG_H; 642 memcpy(&page_store[2], page, fw_page_size); 643 /* recode checksum at last two bytes */ 644 put_unaligned_le16(checksum, &page_store[fw_page_size + 2]); 645 646 ret = i2c_master_send(client, page_store, fw_page_size + 4); 647 if (ret != fw_page_size + 4) { 648 error = ret < 0 ? ret : -EIO; 649 dev_err(dev, "Failed to write page %d: %d\n", idx, error); 650 goto exit; 651 } 652 653 /* Wait for F/W to update one page ROM data. */ 654 msleep(fw_page_size == ETP_FW_PAGE_SIZE_512 ? 50 : 35); 655 656 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val); 657 if (error) { 658 dev_err(dev, "Failed to read IAP write result: %d\n", error); 659 goto exit; 660 } 661 662 result = le16_to_cpup((__le16 *)val); 663 if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) { 664 dev_err(dev, "IAP reports failed write: %04hx\n", 665 result); 666 error = -EIO; 667 goto exit; 668 } 669 670 exit: 671 kfree(page_store); 672 return error; 673 } 674 675 static int elan_i2c_finish_fw_update(struct i2c_client *client, 676 struct completion *completion) 677 { 678 struct device *dev = &client->dev; 679 int error = 0; 680 int len; 681 u8 buffer[ETP_I2C_REPORT_MAX_LEN]; 682 683 len = i2c_master_recv(client, buffer, ETP_I2C_REPORT_MAX_LEN); 684 if (len <= 0) { 685 error = len < 0 ? len : -EIO; 686 dev_warn(dev, "failed to read I2C data after FW WDT reset: %d (%d)\n", 687 error, len); 688 } 689 690 reinit_completion(completion); 691 enable_irq(client->irq); 692 693 error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET); 694 if (error) { 695 dev_err(dev, "device reset failed: %d\n", error); 696 } else if (!wait_for_completion_timeout(completion, 697 msecs_to_jiffies(300))) { 698 dev_err(dev, "timeout waiting for device reset\n"); 699 error = -ETIMEDOUT; 700 } 701 702 disable_irq(client->irq); 703 704 if (error) 705 return error; 706 707 len = i2c_master_recv(client, buffer, ETP_I2C_INF_LENGTH); 708 if (len != ETP_I2C_INF_LENGTH) { 709 error = len < 0 ? len : -EIO; 710 dev_err(dev, "failed to read INT signal: %d (%d)\n", 711 error, len); 712 return error; 713 } 714 715 return 0; 716 } 717 718 static int elan_i2c_get_report_features(struct i2c_client *client, u8 pattern, 719 unsigned int *features, 720 unsigned int *report_len) 721 { 722 *features = ETP_FEATURE_REPORT_MK; 723 *report_len = pattern <= 0x01 ? 724 ETP_I2C_REPORT_LEN : ETP_I2C_REPORT_LEN_ID2; 725 return 0; 726 } 727 728 static int elan_i2c_get_report(struct i2c_client *client, 729 u8 *report, unsigned int report_len) 730 { 731 int len; 732 733 len = i2c_master_recv(client, report, report_len); 734 if (len < 0) { 735 dev_err(&client->dev, "failed to read report data: %d\n", len); 736 return len; 737 } 738 739 if (len != report_len) { 740 dev_err(&client->dev, 741 "wrong report length (%d vs %d expected)\n", 742 len, report_len); 743 return -EIO; 744 } 745 746 return 0; 747 } 748 749 const struct elan_transport_ops elan_i2c_ops = { 750 .initialize = elan_i2c_initialize, 751 .sleep_control = elan_i2c_sleep_control, 752 .power_control = elan_i2c_power_control, 753 .set_mode = elan_i2c_set_mode, 754 755 .calibrate = elan_i2c_calibrate, 756 .calibrate_result = elan_i2c_calibrate_result, 757 758 .get_baseline_data = elan_i2c_get_baseline_data, 759 760 .get_version = elan_i2c_get_version, 761 .get_sm_version = elan_i2c_get_sm_version, 762 .get_product_id = elan_i2c_get_product_id, 763 .get_checksum = elan_i2c_get_checksum, 764 .get_pressure_adjustment = elan_i2c_get_pressure_adjustment, 765 766 .get_max = elan_i2c_get_max, 767 .get_resolution = elan_i2c_get_resolution, 768 .get_num_traces = elan_i2c_get_num_traces, 769 770 .iap_get_mode = elan_i2c_iap_get_mode, 771 .iap_reset = elan_i2c_iap_reset, 772 773 .prepare_fw_update = elan_i2c_prepare_fw_update, 774 .write_fw_block = elan_i2c_write_fw_block, 775 .finish_fw_update = elan_i2c_finish_fw_update, 776 777 .get_pattern = elan_i2c_get_pattern, 778 779 .get_report_features = elan_i2c_get_report_features, 780 .get_report = elan_i2c_get_report, 781 }; 782