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