1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2011 Infineon Technologies 4 * 5 * Authors: 6 * Peter Huewe <huewe.external (at) infineon.com> 7 * 8 * Description: 9 * Device driver for TCG/TCPA TPM (trusted platform module). 10 * Specifications at www.trustedcomputinggroup.org 11 * 12 * This device driver implements the TPM interface as defined in 13 * the TCG TPM Interface Spec version 1.2, revision 1.0 and the 14 * Infineon I2C Protocol Stack Specification v0.20. 15 * 16 * It is based on the Linux kernel driver tpm.c from Leendert van 17 * Dorn, Dave Safford, Reiner Sailer, and Kyleen Hall. 18 * 19 * Version: 2.1.1 20 */ 21 22 #include <common.h> 23 #include <dm.h> 24 #include <fdtdec.h> 25 #include <i2c.h> 26 #include <tpm-v1.h> 27 #include <linux/errno.h> 28 #include <linux/compiler.h> 29 #include <linux/types.h> 30 #include <linux/unaligned/be_byteshift.h> 31 32 #include "tpm_tis.h" 33 #include "tpm_internal.h" 34 35 enum i2c_chip_type { 36 SLB9635, 37 SLB9645, 38 UNKNOWN, 39 }; 40 41 /* expected value for DIDVID register */ 42 #define TPM_TIS_I2C_DID_VID_9635 0x000b15d1L 43 #define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L 44 45 static const char * const chip_name[] = { 46 [SLB9635] = "slb9635tt", 47 [SLB9645] = "slb9645tt", 48 [UNKNOWN] = "unknown/fallback to slb9635", 49 }; 50 51 #define TPM_ACCESS(l) (0x0000 | ((l) << 4)) 52 #define TPM_STS(l) (0x0001 | ((l) << 4)) 53 #define TPM_DATA_FIFO(l) (0x0005 | ((l) << 4)) 54 #define TPM_DID_VID(l) (0x0006 | ((l) << 4)) 55 56 /* 57 * tpm_tis_i2c_read() - read from TPM register 58 * @addr: register address to read from 59 * @buffer: provided by caller 60 * @len: number of bytes to read 61 * 62 * Read len bytes from TPM register and put them into 63 * buffer (little-endian format, i.e. first byte is put into buffer[0]). 64 * 65 * NOTE: TPM is big-endian for multi-byte values. Multi-byte 66 * values have to be swapped. 67 * 68 * Return -EIO on error, 0 on success. 69 */ 70 static int tpm_tis_i2c_read(struct udevice *dev, u8 addr, u8 *buffer, 71 size_t len) 72 { 73 struct tpm_chip *chip = dev_get_priv(dev); 74 int rc; 75 int count; 76 uint32_t addrbuf = addr; 77 78 if ((chip->chip_type == SLB9635) || (chip->chip_type == UNKNOWN)) { 79 /* slb9635 protocol should work in both cases */ 80 for (count = 0; count < MAX_COUNT; count++) { 81 rc = dm_i2c_write(dev, 0, (uchar *)&addrbuf, 1); 82 if (rc == 0) 83 break; /* Success, break to skip sleep */ 84 udelay(SLEEP_DURATION_US); 85 } 86 if (rc) 87 return rc; 88 89 /* After the TPM has successfully received the register address 90 * it needs some time, thus we're sleeping here again, before 91 * retrieving the data 92 */ 93 for (count = 0; count < MAX_COUNT; count++) { 94 udelay(SLEEP_DURATION_US); 95 rc = dm_i2c_read(dev, 0, buffer, len); 96 if (rc == 0) 97 break; /* success, break to skip sleep */ 98 } 99 } else { 100 /* 101 * Use a combined read for newer chips. 102 * Unfortunately the smbus functions are not suitable due to 103 * the 32 byte limit of the smbus. 104 * Retries should usually not be needed, but are kept just to 105 * be safe on the safe side. 106 */ 107 for (count = 0; count < MAX_COUNT; count++) { 108 rc = dm_i2c_read(dev, addr, buffer, len); 109 if (rc == 0) 110 break; /* break here to skip sleep */ 111 udelay(SLEEP_DURATION_US); 112 } 113 } 114 115 /* Take care of 'guard time' */ 116 udelay(SLEEP_DURATION_US); 117 if (rc) 118 return rc; 119 120 return 0; 121 } 122 123 static int tpm_tis_i2c_write_generic(struct udevice *dev, u8 addr, 124 const u8 *buffer, size_t len, 125 unsigned int sleep_time_us, u8 max_count) 126 { 127 struct tpm_chip_priv *priv = dev_get_uclass_priv(dev); 128 struct tpm_chip *chip = dev_get_priv(dev); 129 int rc = 0; 130 int count; 131 132 if (chip->chip_type == SLB9635) { 133 /* Prepare send buffer to include the address */ 134 priv->buf[0] = addr; 135 memcpy(&(priv->buf[1]), buffer, len); 136 buffer = priv->buf; 137 len++; 138 addr = 0; 139 } 140 141 for (count = 0; count < max_count; count++) { 142 rc = dm_i2c_write(dev, addr, buffer, len); 143 if (rc == 0) 144 break; /* Success, break to skip sleep */ 145 udelay(sleep_time_us); 146 } 147 148 /* take care of 'guard time' */ 149 udelay(sleep_time_us); 150 if (rc) 151 return rc; 152 153 return 0; 154 } 155 156 /* 157 * tpm_tis_i2c_write() - write to TPM register 158 * @addr: register address to write to 159 * @buffer: containing data to be written 160 * @len: number of bytes to write 161 * 162 * Write len bytes from provided buffer to TPM register (little 163 * endian format, i.e. buffer[0] is written as first byte). 164 * 165 * NOTE: TPM is big-endian for multi-byte values. Multi-byte 166 * values have to be swapped. 167 * 168 * NOTE: use this function instead of the tpm_tis_i2c_write_generic function. 169 * 170 * Return -EIO on error, 0 on success 171 */ 172 static int tpm_tis_i2c_write(struct udevice *dev, u8 addr, const u8 *buffer, 173 size_t len) 174 { 175 return tpm_tis_i2c_write_generic(dev, addr, buffer, len, 176 SLEEP_DURATION_US, MAX_COUNT); 177 } 178 179 /* 180 * This function is needed especially for the cleanup situation after 181 * sending TPM_READY 182 */ 183 static int tpm_tis_i2c_write_long(struct udevice *dev, u8 addr, u8 *buffer, 184 size_t len) 185 { 186 return tpm_tis_i2c_write_generic(dev, addr, buffer, len, 187 SLEEP_DURATION_LONG_US, 188 MAX_COUNT_LONG); 189 } 190 191 static int tpm_tis_i2c_check_locality(struct udevice *dev, int loc) 192 { 193 const u8 mask = TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID; 194 struct tpm_chip *chip = dev_get_priv(dev); 195 u8 buf; 196 int rc; 197 198 rc = tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1); 199 if (rc < 0) 200 return rc; 201 202 if ((buf & mask) == mask) { 203 chip->locality = loc; 204 return loc; 205 } 206 207 return -ENOENT; 208 } 209 210 static void tpm_tis_i2c_release_locality(struct udevice *dev, int loc, 211 int force) 212 { 213 const u8 mask = TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID; 214 u8 buf; 215 216 if (tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1) < 0) 217 return; 218 219 if (force || (buf & mask) == mask) { 220 buf = TPM_ACCESS_ACTIVE_LOCALITY; 221 tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1); 222 } 223 } 224 225 static int tpm_tis_i2c_request_locality(struct udevice *dev, int loc) 226 { 227 struct tpm_chip *chip = dev_get_priv(dev); 228 unsigned long start, stop; 229 u8 buf = TPM_ACCESS_REQUEST_USE; 230 int rc; 231 232 rc = tpm_tis_i2c_check_locality(dev, loc); 233 if (rc >= 0) { 234 debug("%s: Already have locality\n", __func__); 235 return loc; /* We already have the locality */ 236 } else if (rc != -ENOENT) { 237 debug("%s: Failed to get locality: %d\n", __func__, rc); 238 return rc; 239 } 240 241 rc = tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1); 242 if (rc) { 243 debug("%s: Failed to write to TPM: %d\n", __func__, rc); 244 return rc; 245 } 246 247 /* Wait for burstcount */ 248 start = get_timer(0); 249 stop = chip->timeout_a; 250 do { 251 rc = tpm_tis_i2c_check_locality(dev, loc); 252 if (rc >= 0) { 253 debug("%s: Have locality\n", __func__); 254 return loc; 255 } else if (rc != -ENOENT) { 256 debug("%s: Failed to get locality: %d\n", __func__, rc); 257 return rc; 258 } 259 mdelay(TPM_TIMEOUT_MS); 260 } while (get_timer(start) < stop); 261 debug("%s: Timeout getting locality: %d\n", __func__, rc); 262 263 return rc; 264 } 265 266 static u8 tpm_tis_i2c_status(struct udevice *dev) 267 { 268 struct tpm_chip *chip = dev_get_priv(dev); 269 /* NOTE: Since i2c read may fail, return 0 in this case --> time-out */ 270 u8 buf; 271 272 if (tpm_tis_i2c_read(dev, TPM_STS(chip->locality), &buf, 1) < 0) 273 return 0; 274 else 275 return buf; 276 } 277 278 static int tpm_tis_i2c_ready(struct udevice *dev) 279 { 280 struct tpm_chip *chip = dev_get_priv(dev); 281 int rc; 282 283 /* This causes the current command to be aborted */ 284 u8 buf = TPM_STS_COMMAND_READY; 285 286 debug("%s\n", __func__); 287 rc = tpm_tis_i2c_write_long(dev, TPM_STS(chip->locality), &buf, 1); 288 if (rc) 289 debug("%s: rc=%d\n", __func__, rc); 290 291 return rc; 292 } 293 294 static ssize_t tpm_tis_i2c_get_burstcount(struct udevice *dev) 295 { 296 struct tpm_chip *chip = dev_get_priv(dev); 297 unsigned long start, stop; 298 ssize_t burstcnt; 299 u8 addr, buf[3]; 300 301 /* Wait for burstcount */ 302 /* XXX: Which timeout value? Spec has 2 answers (c & d) */ 303 start = get_timer(0); 304 stop = chip->timeout_d; 305 do { 306 /* Note: STS is little endian */ 307 addr = TPM_STS(chip->locality) + 1; 308 if (tpm_tis_i2c_read(dev, addr, buf, 3) < 0) 309 burstcnt = 0; 310 else 311 burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0]; 312 313 if (burstcnt) 314 return burstcnt; 315 mdelay(TPM_TIMEOUT_MS); 316 } while (get_timer(start) < stop); 317 318 return -EBUSY; 319 } 320 321 static int tpm_tis_i2c_wait_for_stat(struct udevice *dev, u8 mask, 322 unsigned long timeout, int *status) 323 { 324 unsigned long start, stop; 325 326 /* Check current status */ 327 *status = tpm_tis_i2c_status(dev); 328 if ((*status & mask) == mask) 329 return 0; 330 331 start = get_timer(0); 332 stop = timeout; 333 do { 334 mdelay(TPM_TIMEOUT_MS); 335 *status = tpm_tis_i2c_status(dev); 336 if ((*status & mask) == mask) 337 return 0; 338 } while (get_timer(start) < stop); 339 340 return -ETIMEDOUT; 341 } 342 343 static int tpm_tis_i2c_recv_data(struct udevice *dev, u8 *buf, size_t count) 344 { 345 struct tpm_chip *chip = dev_get_priv(dev); 346 size_t size = 0; 347 ssize_t burstcnt; 348 int rc; 349 350 while (size < count) { 351 burstcnt = tpm_tis_i2c_get_burstcount(dev); 352 353 /* burstcount < 0 -> tpm is busy */ 354 if (burstcnt < 0) 355 return burstcnt; 356 357 /* Limit received data to max left */ 358 if (burstcnt > (count - size)) 359 burstcnt = count - size; 360 361 rc = tpm_tis_i2c_read(dev, TPM_DATA_FIFO(chip->locality), 362 &(buf[size]), burstcnt); 363 if (rc == 0) 364 size += burstcnt; 365 } 366 367 return size; 368 } 369 370 static int tpm_tis_i2c_recv(struct udevice *dev, u8 *buf, size_t count) 371 { 372 struct tpm_chip *chip = dev_get_priv(dev); 373 int size = 0; 374 int status; 375 unsigned int expected; 376 int rc; 377 378 status = tpm_tis_i2c_status(dev); 379 if (status == TPM_STS_COMMAND_READY) 380 return -EINTR; 381 if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) != 382 (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) 383 return -EAGAIN; 384 385 debug("...got it;\n"); 386 387 /* Read first 10 bytes, including tag, paramsize, and result */ 388 size = tpm_tis_i2c_recv_data(dev, buf, TPM_HEADER_SIZE); 389 if (size < TPM_HEADER_SIZE) { 390 debug("Unable to read header\n"); 391 return size < 0 ? size : -EIO; 392 } 393 394 expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE); 395 if ((size_t)expected > count || (size_t)expected < TPM_HEADER_SIZE) { 396 debug("Error size=%x, expected=%x, count=%x\n", size, expected, 397 count); 398 return -ENOSPC; 399 } 400 401 size += tpm_tis_i2c_recv_data(dev, &buf[TPM_HEADER_SIZE], 402 expected - TPM_HEADER_SIZE); 403 if (size < expected) { 404 debug("Unable to read remainder of result\n"); 405 return -ETIMEDOUT; 406 } 407 408 rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, chip->timeout_c, 409 &status); 410 if (rc) 411 return rc; 412 if (status & TPM_STS_DATA_AVAIL) { /* Retry? */ 413 debug("Error left over data\n"); 414 return -EIO; 415 } 416 417 return size; 418 } 419 420 static int tpm_tis_i2c_send(struct udevice *dev, const u8 *buf, size_t len) 421 { 422 struct tpm_chip *chip = dev_get_priv(dev); 423 int rc, status; 424 size_t burstcnt; 425 size_t count = 0; 426 int retry = 0; 427 u8 sts = TPM_STS_GO; 428 429 debug("%s: len=%d\n", __func__, len); 430 if (len > TPM_DEV_BUFSIZE) 431 return -E2BIG; /* Command is too long for our tpm, sorry */ 432 433 if (tpm_tis_i2c_request_locality(dev, 0) < 0) 434 return -EBUSY; 435 436 status = tpm_tis_i2c_status(dev); 437 if ((status & TPM_STS_COMMAND_READY) == 0) { 438 rc = tpm_tis_i2c_ready(dev); 439 if (rc) 440 return rc; 441 rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_COMMAND_READY, 442 chip->timeout_b, &status); 443 if (rc) 444 return rc; 445 } 446 447 burstcnt = tpm_tis_i2c_get_burstcount(dev); 448 449 /* burstcount < 0 -> tpm is busy */ 450 if (burstcnt < 0) 451 return burstcnt; 452 453 while (count < len) { 454 udelay(300); 455 if (burstcnt > len - count) 456 burstcnt = len - count; 457 458 #ifdef CONFIG_TPM_TIS_I2C_BURST_LIMITATION 459 if (retry && burstcnt > CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN) 460 burstcnt = CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN; 461 #endif /* CONFIG_TPM_TIS_I2C_BURST_LIMITATION */ 462 463 rc = tpm_tis_i2c_write(dev, TPM_DATA_FIFO(chip->locality), 464 &(buf[count]), burstcnt); 465 if (rc == 0) 466 count += burstcnt; 467 else { 468 debug("%s: error\n", __func__); 469 if (retry++ > 10) 470 return -EIO; 471 rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, 472 chip->timeout_c, 473 &status); 474 if (rc) 475 return rc; 476 477 if ((status & TPM_STS_DATA_EXPECT) == 0) 478 return -EIO; 479 } 480 } 481 482 /* Go and do it */ 483 rc = tpm_tis_i2c_write(dev, TPM_STS(chip->locality), &sts, 1); 484 if (rc < 0) 485 return rc; 486 debug("%s: done, rc=%d\n", __func__, rc); 487 488 return len; 489 } 490 491 static int tpm_tis_i2c_cleanup(struct udevice *dev) 492 { 493 struct tpm_chip *chip = dev_get_priv(dev); 494 495 tpm_tis_i2c_ready(dev); 496 /* 497 * The TPM needs some time to clean up here, 498 * so we sleep rather than keeping the bus busy 499 */ 500 mdelay(2); 501 tpm_tis_i2c_release_locality(dev, chip->locality, 0); 502 503 return 0; 504 } 505 506 static int tpm_tis_i2c_init(struct udevice *dev) 507 { 508 struct tpm_chip *chip = dev_get_priv(dev); 509 u32 vendor; 510 u32 expected_did_vid; 511 int rc; 512 513 chip->is_open = 1; 514 515 /* Default timeouts - these could move to the device tree */ 516 chip->timeout_a = TIS_SHORT_TIMEOUT_MS; 517 chip->timeout_b = TIS_LONG_TIMEOUT_MS; 518 chip->timeout_c = TIS_SHORT_TIMEOUT_MS; 519 chip->timeout_d = TIS_SHORT_TIMEOUT_MS; 520 521 rc = tpm_tis_i2c_request_locality(dev, 0); 522 if (rc < 0) 523 return rc; 524 525 /* Read four bytes from DID_VID register */ 526 if (tpm_tis_i2c_read(dev, TPM_DID_VID(0), (uchar *)&vendor, 4) < 0) { 527 tpm_tis_i2c_release_locality(dev, 0, 1); 528 return -EIO; 529 } 530 531 if (chip->chip_type == SLB9635) { 532 vendor = be32_to_cpu(vendor); 533 expected_did_vid = TPM_TIS_I2C_DID_VID_9635; 534 } else { 535 /* device id and byte order has changed for newer i2c tpms */ 536 expected_did_vid = TPM_TIS_I2C_DID_VID_9645; 537 } 538 539 if (chip->chip_type != UNKNOWN && vendor != expected_did_vid) { 540 pr_err("Vendor id did not match! ID was %08x\n", vendor); 541 return -ENODEV; 542 } 543 544 chip->vend_dev = vendor; 545 debug("1.2 TPM (chip type %s device-id 0x%X)\n", 546 chip_name[chip->chip_type], vendor >> 16); 547 548 /* 549 * A timeout query to TPM can be placed here. 550 * Standard timeout values are used so far 551 */ 552 553 return 0; 554 } 555 556 static int tpm_tis_i2c_open(struct udevice *dev) 557 { 558 struct tpm_chip *chip = dev_get_priv(dev); 559 int rc; 560 561 debug("%s: start\n", __func__); 562 if (chip->is_open) 563 return -EBUSY; 564 rc = tpm_tis_i2c_init(dev); 565 if (rc < 0) 566 chip->is_open = 0; 567 568 return rc; 569 } 570 571 static int tpm_tis_i2c_close(struct udevice *dev) 572 { 573 struct tpm_chip *chip = dev_get_priv(dev); 574 575 if (chip->is_open) { 576 tpm_tis_i2c_release_locality(dev, chip->locality, 1); 577 chip->is_open = 0; 578 chip->vend_dev = 0; 579 } 580 581 return 0; 582 } 583 584 static int tpm_tis_get_desc(struct udevice *dev, char *buf, int size) 585 { 586 struct tpm_chip *chip = dev_get_priv(dev); 587 588 if (size < 50) 589 return -ENOSPC; 590 591 return snprintf(buf, size, "1.2 TPM (%s, chip type %s device-id 0x%x)", 592 chip->is_open ? "open" : "closed", 593 chip_name[chip->chip_type], 594 chip->vend_dev >> 16); 595 } 596 597 static int tpm_tis_i2c_probe(struct udevice *dev) 598 { 599 struct tpm_chip_priv *uc_priv = dev_get_uclass_priv(dev); 600 struct tpm_chip *chip = dev_get_priv(dev); 601 602 chip->chip_type = dev_get_driver_data(dev); 603 604 /* TODO: These need to be checked and tuned */ 605 uc_priv->duration_ms[TPM_SHORT] = TIS_SHORT_TIMEOUT_MS; 606 uc_priv->duration_ms[TPM_MEDIUM] = TIS_LONG_TIMEOUT_MS; 607 uc_priv->duration_ms[TPM_LONG] = TIS_LONG_TIMEOUT_MS; 608 uc_priv->retry_time_ms = TPM_TIMEOUT_MS; 609 610 return 0; 611 } 612 613 static const struct tpm_ops tpm_tis_i2c_ops = { 614 .open = tpm_tis_i2c_open, 615 .close = tpm_tis_i2c_close, 616 .get_desc = tpm_tis_get_desc, 617 .send = tpm_tis_i2c_send, 618 .recv = tpm_tis_i2c_recv, 619 .cleanup = tpm_tis_i2c_cleanup, 620 }; 621 622 static const struct udevice_id tpm_tis_i2c_ids[] = { 623 { .compatible = "infineon,slb9635tt", .data = SLB9635 }, 624 { .compatible = "infineon,slb9645tt", .data = SLB9645 }, 625 { } 626 }; 627 628 U_BOOT_DRIVER(tpm_tis_i2c) = { 629 .name = "tpm_tis_infineon", 630 .id = UCLASS_TPM, 631 .of_match = tpm_tis_i2c_ids, 632 .ops = &tpm_tis_i2c_ops, 633 .probe = tpm_tis_i2c_probe, 634 .priv_auto_alloc_size = sizeof(struct tpm_chip), 635 }; 636
