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