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