1 /* 2 * Copyright (C) 2012,2013 Infineon Technologies 3 * 4 * Authors: 5 * Peter Huewe <peter.huewe@infineon.com> 6 * 7 * Device driver for TCG/TCPA TPM (trusted platform module). 8 * Specifications at www.trustedcomputinggroup.org 9 * 10 * This device driver implements the TPM interface as defined in 11 * the TCG TPM Interface Spec version 1.2, revision 1.0 and the 12 * Infineon I2C Protocol Stack Specification v0.20. 13 * 14 * It is based on the original tpm_tis device driver from Leendert van 15 * Dorn and Kyleen Hall. 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License as 19 * published by the Free Software Foundation, version 2 of the 20 * License. 21 * 22 * 23 */ 24 #include <linux/i2c.h> 25 #include <linux/module.h> 26 #include <linux/wait.h> 27 #include "tpm.h" 28 29 /* max. buffer size supported by our TPM */ 30 #define TPM_BUFSIZE 1260 31 32 /* max. number of iterations after I2C NAK */ 33 #define MAX_COUNT 3 34 35 #define SLEEP_DURATION_LOW 55 36 #define SLEEP_DURATION_HI 65 37 38 /* max. number of iterations after I2C NAK for 'long' commands 39 * we need this especially for sending TPM_READY, since the cleanup after the 40 * transtion to the ready state may take some time, but it is unpredictable 41 * how long it will take. 42 */ 43 #define MAX_COUNT_LONG 50 44 45 #define SLEEP_DURATION_LONG_LOW 200 46 #define SLEEP_DURATION_LONG_HI 220 47 48 /* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */ 49 #define SLEEP_DURATION_RESET_LOW 2400 50 #define SLEEP_DURATION_RESET_HI 2600 51 52 /* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */ 53 #define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000) 54 #define TPM_TIMEOUT_US_HI (TPM_TIMEOUT_US_LOW + 2000) 55 56 /* expected value for DIDVID register */ 57 #define TPM_TIS_I2C_DID_VID_9635 0xd1150b00L 58 #define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L 59 60 enum i2c_chip_type { 61 SLB9635, 62 SLB9645, 63 UNKNOWN, 64 }; 65 66 /* Structure to store I2C TPM specific stuff */ 67 struct tpm_inf_dev { 68 struct i2c_client *client; 69 int locality; 70 u8 buf[TPM_BUFSIZE + sizeof(u8)]; /* max. buffer size + addr */ 71 struct tpm_chip *chip; 72 enum i2c_chip_type chip_type; 73 unsigned int adapterlimit; 74 }; 75 76 static struct tpm_inf_dev tpm_dev; 77 78 /* 79 * iic_tpm_read() - read from TPM register 80 * @addr: register address to read from 81 * @buffer: provided by caller 82 * @len: number of bytes to read 83 * 84 * Read len bytes from TPM register and put them into 85 * buffer (little-endian format, i.e. first byte is put into buffer[0]). 86 * 87 * NOTE: TPM is big-endian for multi-byte values. Multi-byte 88 * values have to be swapped. 89 * 90 * NOTE: We can't unfortunately use the combined read/write functions 91 * provided by the i2c core as the TPM currently does not support the 92 * repeated start condition and due to it's special requirements. 93 * The i2c_smbus* functions do not work for this chip. 94 * 95 * Return -EIO on error, 0 on success. 96 */ 97 static int iic_tpm_read(u8 addr, u8 *buffer, size_t len) 98 { 99 100 struct i2c_msg msg1 = { 101 .addr = tpm_dev.client->addr, 102 .len = 1, 103 .buf = &addr 104 }; 105 struct i2c_msg msg2 = { 106 .addr = tpm_dev.client->addr, 107 .flags = I2C_M_RD, 108 .len = len, 109 .buf = buffer 110 }; 111 struct i2c_msg msgs[] = {msg1, msg2}; 112 113 int rc = 0; 114 int count; 115 unsigned int msglen = len; 116 117 /* Lock the adapter for the duration of the whole sequence. */ 118 if (!tpm_dev.client->adapter->algo->master_xfer) 119 return -EOPNOTSUPP; 120 i2c_lock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT); 121 122 if (tpm_dev.chip_type == SLB9645) { 123 /* use a combined read for newer chips 124 * unfortunately the smbus functions are not suitable due to 125 * the 32 byte limit of the smbus. 126 * retries should usually not be needed, but are kept just to 127 * be on the safe side. 128 */ 129 for (count = 0; count < MAX_COUNT; count++) { 130 rc = __i2c_transfer(tpm_dev.client->adapter, msgs, 2); 131 if (rc > 0) 132 break; /* break here to skip sleep */ 133 usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); 134 } 135 } else { 136 /* Expect to send one command message and one data message, but 137 * support looping over each or both if necessary. 138 */ 139 while (len > 0) { 140 /* slb9635 protocol should work in all cases */ 141 for (count = 0; count < MAX_COUNT; count++) { 142 rc = __i2c_transfer(tpm_dev.client->adapter, 143 &msg1, 1); 144 if (rc > 0) 145 break; /* break here to skip sleep */ 146 147 usleep_range(SLEEP_DURATION_LOW, 148 SLEEP_DURATION_HI); 149 } 150 151 if (rc <= 0) 152 goto out; 153 154 /* After the TPM has successfully received the register 155 * address it needs some time, thus we're sleeping here 156 * again, before retrieving the data 157 */ 158 for (count = 0; count < MAX_COUNT; count++) { 159 if (tpm_dev.adapterlimit) { 160 msglen = min_t(unsigned int, 161 tpm_dev.adapterlimit, 162 len); 163 msg2.len = msglen; 164 } 165 usleep_range(SLEEP_DURATION_LOW, 166 SLEEP_DURATION_HI); 167 rc = __i2c_transfer(tpm_dev.client->adapter, 168 &msg2, 1); 169 if (rc > 0) { 170 /* Since len is unsigned, make doubly 171 * sure we do not underflow it. 172 */ 173 if (msglen > len) 174 len = 0; 175 else 176 len -= msglen; 177 msg2.buf += msglen; 178 break; 179 } 180 /* If the I2C adapter rejected the request (e.g 181 * when the quirk read_max_len < len) fall back 182 * to a sane minimum value and try again. 183 */ 184 if (rc == -EOPNOTSUPP) 185 tpm_dev.adapterlimit = 186 I2C_SMBUS_BLOCK_MAX; 187 } 188 189 if (rc <= 0) 190 goto out; 191 } 192 } 193 194 out: 195 i2c_unlock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT); 196 /* take care of 'guard time' */ 197 usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); 198 199 /* __i2c_transfer returns the number of successfully transferred 200 * messages. 201 * So rc should be greater than 0 here otherwise we have an error. 202 */ 203 if (rc <= 0) 204 return -EIO; 205 206 return 0; 207 } 208 209 static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len, 210 unsigned int sleep_low, 211 unsigned int sleep_hi, u8 max_count) 212 { 213 int rc = -EIO; 214 int count; 215 216 struct i2c_msg msg1 = { 217 .addr = tpm_dev.client->addr, 218 .len = len + 1, 219 .buf = tpm_dev.buf 220 }; 221 222 if (len > TPM_BUFSIZE) 223 return -EINVAL; 224 225 if (!tpm_dev.client->adapter->algo->master_xfer) 226 return -EOPNOTSUPP; 227 i2c_lock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT); 228 229 /* prepend the 'register address' to the buffer */ 230 tpm_dev.buf[0] = addr; 231 memcpy(&(tpm_dev.buf[1]), buffer, len); 232 233 /* 234 * NOTE: We have to use these special mechanisms here and unfortunately 235 * cannot rely on the standard behavior of i2c_transfer. 236 * Even for newer chips the smbus functions are not 237 * suitable due to the 32 byte limit of the smbus. 238 */ 239 for (count = 0; count < max_count; count++) { 240 rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1); 241 if (rc > 0) 242 break; 243 usleep_range(sleep_low, sleep_hi); 244 } 245 246 i2c_unlock_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT); 247 /* take care of 'guard time' */ 248 usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); 249 250 /* __i2c_transfer returns the number of successfully transferred 251 * messages. 252 * So rc should be greater than 0 here otherwise we have an error. 253 */ 254 if (rc <= 0) 255 return -EIO; 256 257 return 0; 258 } 259 260 /* 261 * iic_tpm_write() - write to TPM register 262 * @addr: register address to write to 263 * @buffer: containing data to be written 264 * @len: number of bytes to write 265 * 266 * Write len bytes from provided buffer to TPM register (little 267 * endian format, i.e. buffer[0] is written as first byte). 268 * 269 * NOTE: TPM is big-endian for multi-byte values. Multi-byte 270 * values have to be swapped. 271 * 272 * NOTE: use this function instead of the iic_tpm_write_generic function. 273 * 274 * Return -EIO on error, 0 on success 275 */ 276 static int iic_tpm_write(u8 addr, u8 *buffer, size_t len) 277 { 278 return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LOW, 279 SLEEP_DURATION_HI, MAX_COUNT); 280 } 281 282 /* 283 * This function is needed especially for the cleanup situation after 284 * sending TPM_READY 285 * */ 286 static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len) 287 { 288 return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG_LOW, 289 SLEEP_DURATION_LONG_HI, MAX_COUNT_LONG); 290 } 291 292 enum tis_access { 293 TPM_ACCESS_VALID = 0x80, 294 TPM_ACCESS_ACTIVE_LOCALITY = 0x20, 295 TPM_ACCESS_REQUEST_PENDING = 0x04, 296 TPM_ACCESS_REQUEST_USE = 0x02, 297 }; 298 299 enum tis_status { 300 TPM_STS_VALID = 0x80, 301 TPM_STS_COMMAND_READY = 0x40, 302 TPM_STS_GO = 0x20, 303 TPM_STS_DATA_AVAIL = 0x10, 304 TPM_STS_DATA_EXPECT = 0x08, 305 }; 306 307 enum tis_defaults { 308 TIS_SHORT_TIMEOUT = 750, /* ms */ 309 TIS_LONG_TIMEOUT = 2000, /* 2 sec */ 310 }; 311 312 #define TPM_ACCESS(l) (0x0000 | ((l) << 4)) 313 #define TPM_STS(l) (0x0001 | ((l) << 4)) 314 #define TPM_DATA_FIFO(l) (0x0005 | ((l) << 4)) 315 #define TPM_DID_VID(l) (0x0006 | ((l) << 4)) 316 317 static bool check_locality(struct tpm_chip *chip, int loc) 318 { 319 u8 buf; 320 int rc; 321 322 rc = iic_tpm_read(TPM_ACCESS(loc), &buf, 1); 323 if (rc < 0) 324 return false; 325 326 if ((buf & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) == 327 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) { 328 tpm_dev.locality = loc; 329 return true; 330 } 331 332 return false; 333 } 334 335 /* implementation similar to tpm_tis */ 336 static void release_locality(struct tpm_chip *chip, int loc, int force) 337 { 338 u8 buf; 339 if (iic_tpm_read(TPM_ACCESS(loc), &buf, 1) < 0) 340 return; 341 342 if (force || (buf & (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) == 343 (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) { 344 buf = TPM_ACCESS_ACTIVE_LOCALITY; 345 iic_tpm_write(TPM_ACCESS(loc), &buf, 1); 346 } 347 } 348 349 static int request_locality(struct tpm_chip *chip, int loc) 350 { 351 unsigned long stop; 352 u8 buf = TPM_ACCESS_REQUEST_USE; 353 354 if (check_locality(chip, loc)) 355 return loc; 356 357 iic_tpm_write(TPM_ACCESS(loc), &buf, 1); 358 359 /* wait for burstcount */ 360 stop = jiffies + chip->timeout_a; 361 do { 362 if (check_locality(chip, loc)) 363 return loc; 364 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); 365 } while (time_before(jiffies, stop)); 366 367 return -ETIME; 368 } 369 370 static u8 tpm_tis_i2c_status(struct tpm_chip *chip) 371 { 372 /* NOTE: since I2C read may fail, return 0 in this case --> time-out */ 373 u8 buf = 0xFF; 374 u8 i = 0; 375 376 do { 377 if (iic_tpm_read(TPM_STS(tpm_dev.locality), &buf, 1) < 0) 378 return 0; 379 380 i++; 381 /* if locallity is set STS should not be 0xFF */ 382 } while ((buf == 0xFF) && i < 10); 383 384 return buf; 385 } 386 387 static void tpm_tis_i2c_ready(struct tpm_chip *chip) 388 { 389 /* this causes the current command to be aborted */ 390 u8 buf = TPM_STS_COMMAND_READY; 391 iic_tpm_write_long(TPM_STS(tpm_dev.locality), &buf, 1); 392 } 393 394 static ssize_t get_burstcount(struct tpm_chip *chip) 395 { 396 unsigned long stop; 397 ssize_t burstcnt; 398 u8 buf[3]; 399 400 /* wait for burstcount */ 401 /* which timeout value, spec has 2 answers (c & d) */ 402 stop = jiffies + chip->timeout_d; 403 do { 404 /* Note: STS is little endian */ 405 if (iic_tpm_read(TPM_STS(tpm_dev.locality)+1, buf, 3) < 0) 406 burstcnt = 0; 407 else 408 burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0]; 409 410 if (burstcnt) 411 return burstcnt; 412 413 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); 414 } while (time_before(jiffies, stop)); 415 return -EBUSY; 416 } 417 418 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, 419 int *status) 420 { 421 unsigned long stop; 422 423 /* check current status */ 424 *status = tpm_tis_i2c_status(chip); 425 if ((*status != 0xFF) && (*status & mask) == mask) 426 return 0; 427 428 stop = jiffies + timeout; 429 do { 430 /* since we just checked the status, give the TPM some time */ 431 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); 432 *status = tpm_tis_i2c_status(chip); 433 if ((*status & mask) == mask) 434 return 0; 435 436 } while (time_before(jiffies, stop)); 437 438 return -ETIME; 439 } 440 441 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count) 442 { 443 size_t size = 0; 444 ssize_t burstcnt; 445 u8 retries = 0; 446 int rc; 447 448 while (size < count) { 449 burstcnt = get_burstcount(chip); 450 451 /* burstcnt < 0 = TPM is busy */ 452 if (burstcnt < 0) 453 return burstcnt; 454 455 /* limit received data to max. left */ 456 if (burstcnt > (count - size)) 457 burstcnt = count - size; 458 459 rc = iic_tpm_read(TPM_DATA_FIFO(tpm_dev.locality), 460 &(buf[size]), burstcnt); 461 if (rc == 0) 462 size += burstcnt; 463 else if (rc < 0) 464 retries++; 465 466 /* avoid endless loop in case of broken HW */ 467 if (retries > MAX_COUNT_LONG) 468 return -EIO; 469 } 470 return size; 471 } 472 473 static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count) 474 { 475 int size = 0; 476 int status; 477 u32 expected; 478 479 if (count < TPM_HEADER_SIZE) { 480 size = -EIO; 481 goto out; 482 } 483 484 /* read first 10 bytes, including tag, paramsize, and result */ 485 size = recv_data(chip, buf, TPM_HEADER_SIZE); 486 if (size < TPM_HEADER_SIZE) { 487 dev_err(&chip->dev, "Unable to read header\n"); 488 goto out; 489 } 490 491 expected = be32_to_cpu(*(__be32 *)(buf + 2)); 492 if (((size_t) expected > count) || (expected < TPM_HEADER_SIZE)) { 493 size = -EIO; 494 goto out; 495 } 496 497 size += recv_data(chip, &buf[TPM_HEADER_SIZE], 498 expected - TPM_HEADER_SIZE); 499 if (size < expected) { 500 dev_err(&chip->dev, "Unable to read remainder of result\n"); 501 size = -ETIME; 502 goto out; 503 } 504 505 wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status); 506 if (status & TPM_STS_DATA_AVAIL) { /* retry? */ 507 dev_err(&chip->dev, "Error left over data\n"); 508 size = -EIO; 509 goto out; 510 } 511 512 out: 513 tpm_tis_i2c_ready(chip); 514 /* The TPM needs some time to clean up here, 515 * so we sleep rather than keeping the bus busy 516 */ 517 usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI); 518 release_locality(chip, tpm_dev.locality, 0); 519 return size; 520 } 521 522 static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len) 523 { 524 int rc, status; 525 ssize_t burstcnt; 526 size_t count = 0; 527 u8 retries = 0; 528 u8 sts = TPM_STS_GO; 529 530 if (len > TPM_BUFSIZE) 531 return -E2BIG; /* command is too long for our tpm, sorry */ 532 533 if (request_locality(chip, 0) < 0) 534 return -EBUSY; 535 536 status = tpm_tis_i2c_status(chip); 537 if ((status & TPM_STS_COMMAND_READY) == 0) { 538 tpm_tis_i2c_ready(chip); 539 if (wait_for_stat 540 (chip, TPM_STS_COMMAND_READY, 541 chip->timeout_b, &status) < 0) { 542 rc = -ETIME; 543 goto out_err; 544 } 545 } 546 547 while (count < len - 1) { 548 burstcnt = get_burstcount(chip); 549 550 /* burstcnt < 0 = TPM is busy */ 551 if (burstcnt < 0) 552 return burstcnt; 553 554 if (burstcnt > (len - 1 - count)) 555 burstcnt = len - 1 - count; 556 557 rc = iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), 558 &(buf[count]), burstcnt); 559 if (rc == 0) 560 count += burstcnt; 561 else if (rc < 0) 562 retries++; 563 564 /* avoid endless loop in case of broken HW */ 565 if (retries > MAX_COUNT_LONG) { 566 rc = -EIO; 567 goto out_err; 568 } 569 570 wait_for_stat(chip, TPM_STS_VALID, 571 chip->timeout_c, &status); 572 573 if ((status & TPM_STS_DATA_EXPECT) == 0) { 574 rc = -EIO; 575 goto out_err; 576 } 577 } 578 579 /* write last byte */ 580 iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), &(buf[count]), 1); 581 wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status); 582 if ((status & TPM_STS_DATA_EXPECT) != 0) { 583 rc = -EIO; 584 goto out_err; 585 } 586 587 /* go and do it */ 588 iic_tpm_write(TPM_STS(tpm_dev.locality), &sts, 1); 589 590 return len; 591 out_err: 592 tpm_tis_i2c_ready(chip); 593 /* The TPM needs some time to clean up here, 594 * so we sleep rather than keeping the bus busy 595 */ 596 usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI); 597 release_locality(chip, tpm_dev.locality, 0); 598 return rc; 599 } 600 601 static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status) 602 { 603 return (status == TPM_STS_COMMAND_READY); 604 } 605 606 static const struct tpm_class_ops tpm_tis_i2c = { 607 .flags = TPM_OPS_AUTO_STARTUP, 608 .status = tpm_tis_i2c_status, 609 .recv = tpm_tis_i2c_recv, 610 .send = tpm_tis_i2c_send, 611 .cancel = tpm_tis_i2c_ready, 612 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID, 613 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID, 614 .req_canceled = tpm_tis_i2c_req_canceled, 615 }; 616 617 static int tpm_tis_i2c_init(struct device *dev) 618 { 619 u32 vendor; 620 int rc = 0; 621 struct tpm_chip *chip; 622 623 chip = tpmm_chip_alloc(dev, &tpm_tis_i2c); 624 if (IS_ERR(chip)) 625 return PTR_ERR(chip); 626 627 /* Default timeouts */ 628 chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 629 chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT); 630 chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 631 chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 632 633 if (request_locality(chip, 0) != 0) { 634 dev_err(dev, "could not request locality\n"); 635 rc = -ENODEV; 636 goto out_err; 637 } 638 639 /* read four bytes from DID_VID register */ 640 if (iic_tpm_read(TPM_DID_VID(0), (u8 *)&vendor, 4) < 0) { 641 dev_err(dev, "could not read vendor id\n"); 642 rc = -EIO; 643 goto out_release; 644 } 645 646 if (vendor == TPM_TIS_I2C_DID_VID_9645) { 647 tpm_dev.chip_type = SLB9645; 648 } else if (vendor == TPM_TIS_I2C_DID_VID_9635) { 649 tpm_dev.chip_type = SLB9635; 650 } else { 651 dev_err(dev, "vendor id did not match! ID was %08x\n", vendor); 652 rc = -ENODEV; 653 goto out_release; 654 } 655 656 dev_info(dev, "1.2 TPM (device-id 0x%X)\n", vendor >> 16); 657 658 tpm_dev.chip = chip; 659 660 return tpm_chip_register(chip); 661 out_release: 662 release_locality(chip, tpm_dev.locality, 1); 663 tpm_dev.client = NULL; 664 out_err: 665 return rc; 666 } 667 668 static const struct i2c_device_id tpm_tis_i2c_table[] = { 669 {"tpm_i2c_infineon"}, 670 {"slb9635tt"}, 671 {"slb9645tt"}, 672 {}, 673 }; 674 675 MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table); 676 677 #ifdef CONFIG_OF 678 static const struct of_device_id tpm_tis_i2c_of_match[] = { 679 {.compatible = "infineon,tpm_i2c_infineon"}, 680 {.compatible = "infineon,slb9635tt"}, 681 {.compatible = "infineon,slb9645tt"}, 682 {}, 683 }; 684 MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match); 685 #endif 686 687 static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume); 688 689 static int tpm_tis_i2c_probe(struct i2c_client *client, 690 const struct i2c_device_id *id) 691 { 692 int rc; 693 struct device *dev = &(client->dev); 694 695 if (tpm_dev.client != NULL) { 696 dev_err(dev, "This driver only supports one client at a time\n"); 697 return -EBUSY; /* We only support one client */ 698 } 699 700 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 701 dev_err(dev, "no algorithms associated to the i2c bus\n"); 702 return -ENODEV; 703 } 704 705 tpm_dev.client = client; 706 rc = tpm_tis_i2c_init(&client->dev); 707 if (rc != 0) { 708 tpm_dev.client = NULL; 709 rc = -ENODEV; 710 } 711 return rc; 712 } 713 714 static int tpm_tis_i2c_remove(struct i2c_client *client) 715 { 716 struct tpm_chip *chip = tpm_dev.chip; 717 718 tpm_chip_unregister(chip); 719 release_locality(chip, tpm_dev.locality, 1); 720 tpm_dev.client = NULL; 721 722 return 0; 723 } 724 725 static struct i2c_driver tpm_tis_i2c_driver = { 726 .id_table = tpm_tis_i2c_table, 727 .probe = tpm_tis_i2c_probe, 728 .remove = tpm_tis_i2c_remove, 729 .driver = { 730 .name = "tpm_i2c_infineon", 731 .pm = &tpm_tis_i2c_ops, 732 .of_match_table = of_match_ptr(tpm_tis_i2c_of_match), 733 }, 734 }; 735 736 module_i2c_driver(tpm_tis_i2c_driver); 737 MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>"); 738 MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver"); 739 MODULE_VERSION("2.2.0"); 740 MODULE_LICENSE("GPL"); 741