1 /* 2 * Copyright (C) 2004 IBM Corporation 3 * Copyright (C) 2014 Intel Corporation 4 * 5 * Authors: 6 * Leendert van Doorn <leendert@watson.ibm.com> 7 * Dave Safford <safford@watson.ibm.com> 8 * Reiner Sailer <sailer@watson.ibm.com> 9 * Kylene Hall <kjhall@us.ibm.com> 10 * 11 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 12 * 13 * Device driver for TCG/TCPA TPM (trusted platform module). 14 * Specifications at www.trustedcomputinggroup.org 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License as 18 * published by the Free Software Foundation, version 2 of the 19 * License. 20 * 21 * Note, the TPM chip is not interrupt driven (only polling) 22 * and can have very long timeouts (minutes!). Hence the unusual 23 * calls to msleep. 24 * 25 */ 26 27 #include <linux/poll.h> 28 #include <linux/slab.h> 29 #include <linux/mutex.h> 30 #include <linux/spinlock.h> 31 #include <linux/freezer.h> 32 #include <linux/pm_runtime.h> 33 34 #include "tpm.h" 35 #include "tpm_eventlog.h" 36 37 #define TPM_MAX_ORDINAL 243 38 #define TSC_MAX_ORDINAL 12 39 #define TPM_PROTECTED_COMMAND 0x00 40 #define TPM_CONNECTION_COMMAND 0x40 41 42 /* 43 * Bug workaround - some TPM's don't flush the most 44 * recently changed pcr on suspend, so force the flush 45 * with an extend to the selected _unused_ non-volatile pcr. 46 */ 47 static int tpm_suspend_pcr; 48 module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644); 49 MODULE_PARM_DESC(suspend_pcr, 50 "PCR to use for dummy writes to faciltate flush on suspend."); 51 52 /* 53 * Array with one entry per ordinal defining the maximum amount 54 * of time the chip could take to return the result. The ordinal 55 * designation of short, medium or long is defined in a table in 56 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The 57 * values of the SHORT, MEDIUM, and LONG durations are retrieved 58 * from the chip during initialization with a call to tpm_get_timeouts. 59 */ 60 static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = { 61 TPM_UNDEFINED, /* 0 */ 62 TPM_UNDEFINED, 63 TPM_UNDEFINED, 64 TPM_UNDEFINED, 65 TPM_UNDEFINED, 66 TPM_UNDEFINED, /* 5 */ 67 TPM_UNDEFINED, 68 TPM_UNDEFINED, 69 TPM_UNDEFINED, 70 TPM_UNDEFINED, 71 TPM_SHORT, /* 10 */ 72 TPM_SHORT, 73 TPM_MEDIUM, 74 TPM_LONG, 75 TPM_LONG, 76 TPM_MEDIUM, /* 15 */ 77 TPM_SHORT, 78 TPM_SHORT, 79 TPM_MEDIUM, 80 TPM_LONG, 81 TPM_SHORT, /* 20 */ 82 TPM_SHORT, 83 TPM_MEDIUM, 84 TPM_MEDIUM, 85 TPM_MEDIUM, 86 TPM_SHORT, /* 25 */ 87 TPM_SHORT, 88 TPM_MEDIUM, 89 TPM_SHORT, 90 TPM_SHORT, 91 TPM_MEDIUM, /* 30 */ 92 TPM_LONG, 93 TPM_MEDIUM, 94 TPM_SHORT, 95 TPM_SHORT, 96 TPM_SHORT, /* 35 */ 97 TPM_MEDIUM, 98 TPM_MEDIUM, 99 TPM_UNDEFINED, 100 TPM_UNDEFINED, 101 TPM_MEDIUM, /* 40 */ 102 TPM_LONG, 103 TPM_MEDIUM, 104 TPM_SHORT, 105 TPM_SHORT, 106 TPM_SHORT, /* 45 */ 107 TPM_SHORT, 108 TPM_SHORT, 109 TPM_SHORT, 110 TPM_LONG, 111 TPM_MEDIUM, /* 50 */ 112 TPM_MEDIUM, 113 TPM_UNDEFINED, 114 TPM_UNDEFINED, 115 TPM_UNDEFINED, 116 TPM_UNDEFINED, /* 55 */ 117 TPM_UNDEFINED, 118 TPM_UNDEFINED, 119 TPM_UNDEFINED, 120 TPM_UNDEFINED, 121 TPM_MEDIUM, /* 60 */ 122 TPM_MEDIUM, 123 TPM_MEDIUM, 124 TPM_SHORT, 125 TPM_SHORT, 126 TPM_MEDIUM, /* 65 */ 127 TPM_UNDEFINED, 128 TPM_UNDEFINED, 129 TPM_UNDEFINED, 130 TPM_UNDEFINED, 131 TPM_SHORT, /* 70 */ 132 TPM_SHORT, 133 TPM_UNDEFINED, 134 TPM_UNDEFINED, 135 TPM_UNDEFINED, 136 TPM_UNDEFINED, /* 75 */ 137 TPM_UNDEFINED, 138 TPM_UNDEFINED, 139 TPM_UNDEFINED, 140 TPM_UNDEFINED, 141 TPM_LONG, /* 80 */ 142 TPM_UNDEFINED, 143 TPM_MEDIUM, 144 TPM_LONG, 145 TPM_SHORT, 146 TPM_UNDEFINED, /* 85 */ 147 TPM_UNDEFINED, 148 TPM_UNDEFINED, 149 TPM_UNDEFINED, 150 TPM_UNDEFINED, 151 TPM_SHORT, /* 90 */ 152 TPM_SHORT, 153 TPM_SHORT, 154 TPM_SHORT, 155 TPM_SHORT, 156 TPM_UNDEFINED, /* 95 */ 157 TPM_UNDEFINED, 158 TPM_UNDEFINED, 159 TPM_UNDEFINED, 160 TPM_UNDEFINED, 161 TPM_MEDIUM, /* 100 */ 162 TPM_SHORT, 163 TPM_SHORT, 164 TPM_UNDEFINED, 165 TPM_UNDEFINED, 166 TPM_UNDEFINED, /* 105 */ 167 TPM_UNDEFINED, 168 TPM_UNDEFINED, 169 TPM_UNDEFINED, 170 TPM_UNDEFINED, 171 TPM_SHORT, /* 110 */ 172 TPM_SHORT, 173 TPM_SHORT, 174 TPM_SHORT, 175 TPM_SHORT, 176 TPM_SHORT, /* 115 */ 177 TPM_SHORT, 178 TPM_SHORT, 179 TPM_UNDEFINED, 180 TPM_UNDEFINED, 181 TPM_LONG, /* 120 */ 182 TPM_LONG, 183 TPM_MEDIUM, 184 TPM_UNDEFINED, 185 TPM_SHORT, 186 TPM_SHORT, /* 125 */ 187 TPM_SHORT, 188 TPM_LONG, 189 TPM_SHORT, 190 TPM_SHORT, 191 TPM_SHORT, /* 130 */ 192 TPM_MEDIUM, 193 TPM_UNDEFINED, 194 TPM_SHORT, 195 TPM_MEDIUM, 196 TPM_UNDEFINED, /* 135 */ 197 TPM_UNDEFINED, 198 TPM_UNDEFINED, 199 TPM_UNDEFINED, 200 TPM_UNDEFINED, 201 TPM_SHORT, /* 140 */ 202 TPM_SHORT, 203 TPM_UNDEFINED, 204 TPM_UNDEFINED, 205 TPM_UNDEFINED, 206 TPM_UNDEFINED, /* 145 */ 207 TPM_UNDEFINED, 208 TPM_UNDEFINED, 209 TPM_UNDEFINED, 210 TPM_UNDEFINED, 211 TPM_SHORT, /* 150 */ 212 TPM_MEDIUM, 213 TPM_MEDIUM, 214 TPM_SHORT, 215 TPM_SHORT, 216 TPM_UNDEFINED, /* 155 */ 217 TPM_UNDEFINED, 218 TPM_UNDEFINED, 219 TPM_UNDEFINED, 220 TPM_UNDEFINED, 221 TPM_SHORT, /* 160 */ 222 TPM_SHORT, 223 TPM_SHORT, 224 TPM_SHORT, 225 TPM_UNDEFINED, 226 TPM_UNDEFINED, /* 165 */ 227 TPM_UNDEFINED, 228 TPM_UNDEFINED, 229 TPM_UNDEFINED, 230 TPM_UNDEFINED, 231 TPM_LONG, /* 170 */ 232 TPM_UNDEFINED, 233 TPM_UNDEFINED, 234 TPM_UNDEFINED, 235 TPM_UNDEFINED, 236 TPM_UNDEFINED, /* 175 */ 237 TPM_UNDEFINED, 238 TPM_UNDEFINED, 239 TPM_UNDEFINED, 240 TPM_UNDEFINED, 241 TPM_MEDIUM, /* 180 */ 242 TPM_SHORT, 243 TPM_MEDIUM, 244 TPM_MEDIUM, 245 TPM_MEDIUM, 246 TPM_MEDIUM, /* 185 */ 247 TPM_SHORT, 248 TPM_UNDEFINED, 249 TPM_UNDEFINED, 250 TPM_UNDEFINED, 251 TPM_UNDEFINED, /* 190 */ 252 TPM_UNDEFINED, 253 TPM_UNDEFINED, 254 TPM_UNDEFINED, 255 TPM_UNDEFINED, 256 TPM_UNDEFINED, /* 195 */ 257 TPM_UNDEFINED, 258 TPM_UNDEFINED, 259 TPM_UNDEFINED, 260 TPM_UNDEFINED, 261 TPM_SHORT, /* 200 */ 262 TPM_UNDEFINED, 263 TPM_UNDEFINED, 264 TPM_UNDEFINED, 265 TPM_SHORT, 266 TPM_SHORT, /* 205 */ 267 TPM_SHORT, 268 TPM_SHORT, 269 TPM_SHORT, 270 TPM_SHORT, 271 TPM_MEDIUM, /* 210 */ 272 TPM_UNDEFINED, 273 TPM_MEDIUM, 274 TPM_MEDIUM, 275 TPM_MEDIUM, 276 TPM_UNDEFINED, /* 215 */ 277 TPM_MEDIUM, 278 TPM_UNDEFINED, 279 TPM_UNDEFINED, 280 TPM_SHORT, 281 TPM_SHORT, /* 220 */ 282 TPM_SHORT, 283 TPM_SHORT, 284 TPM_SHORT, 285 TPM_SHORT, 286 TPM_UNDEFINED, /* 225 */ 287 TPM_UNDEFINED, 288 TPM_UNDEFINED, 289 TPM_UNDEFINED, 290 TPM_UNDEFINED, 291 TPM_SHORT, /* 230 */ 292 TPM_LONG, 293 TPM_MEDIUM, 294 TPM_UNDEFINED, 295 TPM_UNDEFINED, 296 TPM_UNDEFINED, /* 235 */ 297 TPM_UNDEFINED, 298 TPM_UNDEFINED, 299 TPM_UNDEFINED, 300 TPM_UNDEFINED, 301 TPM_SHORT, /* 240 */ 302 TPM_UNDEFINED, 303 TPM_MEDIUM, 304 }; 305 306 /* 307 * Returns max number of jiffies to wait 308 */ 309 unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, 310 u32 ordinal) 311 { 312 int duration_idx = TPM_UNDEFINED; 313 int duration = 0; 314 315 /* 316 * We only have a duration table for protected commands, where the upper 317 * 16 bits are 0. For the few other ordinals the fallback will be used. 318 */ 319 if (ordinal < TPM_MAX_ORDINAL) 320 duration_idx = tpm_ordinal_duration[ordinal]; 321 322 if (duration_idx != TPM_UNDEFINED) 323 duration = chip->duration[duration_idx]; 324 if (duration <= 0) 325 return 2 * 60 * HZ; 326 else 327 return duration; 328 } 329 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration); 330 331 /* 332 * Internal kernel interface to transmit TPM commands 333 */ 334 ssize_t tpm_transmit(struct tpm_chip *chip, const u8 *buf, size_t bufsiz, 335 unsigned int flags) 336 { 337 ssize_t rc; 338 u32 count, ordinal; 339 unsigned long stop; 340 341 if (bufsiz < TPM_HEADER_SIZE) 342 return -EINVAL; 343 344 if (bufsiz > TPM_BUFSIZE) 345 bufsiz = TPM_BUFSIZE; 346 347 count = be32_to_cpu(*((__be32 *) (buf + 2))); 348 ordinal = be32_to_cpu(*((__be32 *) (buf + 6))); 349 if (count == 0) 350 return -ENODATA; 351 if (count > bufsiz) { 352 dev_err(&chip->dev, 353 "invalid count value %x %zx\n", count, bufsiz); 354 return -E2BIG; 355 } 356 357 if (!(flags & TPM_TRANSMIT_UNLOCKED)) 358 mutex_lock(&chip->tpm_mutex); 359 360 if (chip->dev.parent) 361 pm_runtime_get_sync(chip->dev.parent); 362 363 rc = chip->ops->send(chip, (u8 *) buf, count); 364 if (rc < 0) { 365 dev_err(&chip->dev, 366 "tpm_transmit: tpm_send: error %zd\n", rc); 367 goto out; 368 } 369 370 if (chip->flags & TPM_CHIP_FLAG_IRQ) 371 goto out_recv; 372 373 if (chip->flags & TPM_CHIP_FLAG_TPM2) 374 stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal); 375 else 376 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal); 377 do { 378 u8 status = chip->ops->status(chip); 379 if ((status & chip->ops->req_complete_mask) == 380 chip->ops->req_complete_val) 381 goto out_recv; 382 383 if (chip->ops->req_canceled(chip, status)) { 384 dev_err(&chip->dev, "Operation Canceled\n"); 385 rc = -ECANCELED; 386 goto out; 387 } 388 389 msleep(TPM_TIMEOUT); /* CHECK */ 390 rmb(); 391 } while (time_before(jiffies, stop)); 392 393 chip->ops->cancel(chip); 394 dev_err(&chip->dev, "Operation Timed out\n"); 395 rc = -ETIME; 396 goto out; 397 398 out_recv: 399 rc = chip->ops->recv(chip, (u8 *) buf, bufsiz); 400 if (rc < 0) 401 dev_err(&chip->dev, 402 "tpm_transmit: tpm_recv: error %zd\n", rc); 403 out: 404 if (chip->dev.parent) 405 pm_runtime_put_sync(chip->dev.parent); 406 407 if (!(flags & TPM_TRANSMIT_UNLOCKED)) 408 mutex_unlock(&chip->tpm_mutex); 409 return rc; 410 } 411 412 #define TPM_DIGEST_SIZE 20 413 #define TPM_RET_CODE_IDX 6 414 415 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, const void *cmd, 416 int len, unsigned int flags, const char *desc) 417 { 418 const struct tpm_output_header *header; 419 int err; 420 421 len = tpm_transmit(chip, (const u8 *)cmd, len, flags); 422 if (len < 0) 423 return len; 424 else if (len < TPM_HEADER_SIZE) 425 return -EFAULT; 426 427 header = cmd; 428 429 err = be32_to_cpu(header->return_code); 430 if (err != 0 && desc) 431 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err, 432 desc); 433 434 return err; 435 } 436 437 #define TPM_INTERNAL_RESULT_SIZE 200 438 #define TPM_ORD_GET_CAP cpu_to_be32(101) 439 #define TPM_ORD_GET_RANDOM cpu_to_be32(70) 440 441 static const struct tpm_input_header tpm_getcap_header = { 442 .tag = TPM_TAG_RQU_COMMAND, 443 .length = cpu_to_be32(22), 444 .ordinal = TPM_ORD_GET_CAP 445 }; 446 447 ssize_t tpm_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap, 448 const char *desc) 449 { 450 struct tpm_cmd_t tpm_cmd; 451 int rc; 452 453 tpm_cmd.header.in = tpm_getcap_header; 454 if (subcap_id == TPM_CAP_VERSION_1_1 || 455 subcap_id == TPM_CAP_VERSION_1_2) { 456 tpm_cmd.params.getcap_in.cap = cpu_to_be32(subcap_id); 457 /*subcap field not necessary */ 458 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0); 459 tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32)); 460 } else { 461 if (subcap_id == TPM_CAP_FLAG_PERM || 462 subcap_id == TPM_CAP_FLAG_VOL) 463 tpm_cmd.params.getcap_in.cap = 464 cpu_to_be32(TPM_CAP_FLAG); 465 else 466 tpm_cmd.params.getcap_in.cap = 467 cpu_to_be32(TPM_CAP_PROP); 468 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); 469 tpm_cmd.params.getcap_in.subcap = cpu_to_be32(subcap_id); 470 } 471 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 0, 472 desc); 473 if (!rc) 474 *cap = tpm_cmd.params.getcap_out.cap; 475 return rc; 476 } 477 EXPORT_SYMBOL_GPL(tpm_getcap); 478 479 #define TPM_ORD_STARTUP cpu_to_be32(153) 480 #define TPM_ST_CLEAR cpu_to_be16(1) 481 #define TPM_ST_STATE cpu_to_be16(2) 482 #define TPM_ST_DEACTIVATED cpu_to_be16(3) 483 static const struct tpm_input_header tpm_startup_header = { 484 .tag = TPM_TAG_RQU_COMMAND, 485 .length = cpu_to_be32(12), 486 .ordinal = TPM_ORD_STARTUP 487 }; 488 489 static int tpm_startup(struct tpm_chip *chip, __be16 startup_type) 490 { 491 struct tpm_cmd_t start_cmd; 492 start_cmd.header.in = tpm_startup_header; 493 494 start_cmd.params.startup_in.startup_type = startup_type; 495 return tpm_transmit_cmd(chip, &start_cmd, TPM_INTERNAL_RESULT_SIZE, 0, 496 "attempting to start the TPM"); 497 } 498 499 int tpm_get_timeouts(struct tpm_chip *chip) 500 { 501 cap_t cap; 502 unsigned long new_timeout[4]; 503 unsigned long old_timeout[4]; 504 ssize_t rc; 505 506 if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS) 507 return 0; 508 509 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 510 /* Fixed timeouts for TPM2 */ 511 chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A); 512 chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B); 513 chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C); 514 chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D); 515 chip->duration[TPM_SHORT] = 516 msecs_to_jiffies(TPM2_DURATION_SHORT); 517 chip->duration[TPM_MEDIUM] = 518 msecs_to_jiffies(TPM2_DURATION_MEDIUM); 519 chip->duration[TPM_LONG] = 520 msecs_to_jiffies(TPM2_DURATION_LONG); 521 522 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS; 523 return 0; 524 } 525 526 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, 527 "attempting to determine the timeouts"); 528 if (rc == TPM_ERR_INVALID_POSTINIT) { 529 /* The TPM is not started, we are the first to talk to it. 530 Execute a startup command. */ 531 dev_info(&chip->dev, "Issuing TPM_STARTUP\n"); 532 if (tpm_startup(chip, TPM_ST_CLEAR)) 533 return rc; 534 535 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, 536 "attempting to determine the timeouts"); 537 } 538 if (rc) 539 return rc; 540 541 old_timeout[0] = be32_to_cpu(cap.timeout.a); 542 old_timeout[1] = be32_to_cpu(cap.timeout.b); 543 old_timeout[2] = be32_to_cpu(cap.timeout.c); 544 old_timeout[3] = be32_to_cpu(cap.timeout.d); 545 memcpy(new_timeout, old_timeout, sizeof(new_timeout)); 546 547 /* 548 * Provide ability for vendor overrides of timeout values in case 549 * of misreporting. 550 */ 551 if (chip->ops->update_timeouts != NULL) 552 chip->timeout_adjusted = 553 chip->ops->update_timeouts(chip, new_timeout); 554 555 if (!chip->timeout_adjusted) { 556 /* Don't overwrite default if value is 0 */ 557 if (new_timeout[0] != 0 && new_timeout[0] < 1000) { 558 int i; 559 560 /* timeouts in msec rather usec */ 561 for (i = 0; i != ARRAY_SIZE(new_timeout); i++) 562 new_timeout[i] *= 1000; 563 chip->timeout_adjusted = true; 564 } 565 } 566 567 /* Report adjusted timeouts */ 568 if (chip->timeout_adjusted) { 569 dev_info(&chip->dev, 570 HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n", 571 old_timeout[0], new_timeout[0], 572 old_timeout[1], new_timeout[1], 573 old_timeout[2], new_timeout[2], 574 old_timeout[3], new_timeout[3]); 575 } 576 577 chip->timeout_a = usecs_to_jiffies(new_timeout[0]); 578 chip->timeout_b = usecs_to_jiffies(new_timeout[1]); 579 chip->timeout_c = usecs_to_jiffies(new_timeout[2]); 580 chip->timeout_d = usecs_to_jiffies(new_timeout[3]); 581 582 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap, 583 "attempting to determine the durations"); 584 if (rc) 585 return rc; 586 587 chip->duration[TPM_SHORT] = 588 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short)); 589 chip->duration[TPM_MEDIUM] = 590 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium)); 591 chip->duration[TPM_LONG] = 592 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long)); 593 594 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above 595 * value wrong and apparently reports msecs rather than usecs. So we 596 * fix up the resulting too-small TPM_SHORT value to make things work. 597 * We also scale the TPM_MEDIUM and -_LONG values by 1000. 598 */ 599 if (chip->duration[TPM_SHORT] < (HZ / 100)) { 600 chip->duration[TPM_SHORT] = HZ; 601 chip->duration[TPM_MEDIUM] *= 1000; 602 chip->duration[TPM_LONG] *= 1000; 603 chip->duration_adjusted = true; 604 dev_info(&chip->dev, "Adjusting TPM timeout parameters."); 605 } 606 607 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS; 608 return 0; 609 } 610 EXPORT_SYMBOL_GPL(tpm_get_timeouts); 611 612 #define TPM_ORD_CONTINUE_SELFTEST 83 613 #define CONTINUE_SELFTEST_RESULT_SIZE 10 614 615 static const struct tpm_input_header continue_selftest_header = { 616 .tag = TPM_TAG_RQU_COMMAND, 617 .length = cpu_to_be32(10), 618 .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST), 619 }; 620 621 /** 622 * tpm_continue_selftest -- run TPM's selftest 623 * @chip: TPM chip to use 624 * 625 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing 626 * a TPM error code. 627 */ 628 static int tpm_continue_selftest(struct tpm_chip *chip) 629 { 630 int rc; 631 struct tpm_cmd_t cmd; 632 633 cmd.header.in = continue_selftest_header; 634 rc = tpm_transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE, 0, 635 "continue selftest"); 636 return rc; 637 } 638 639 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21) 640 #define READ_PCR_RESULT_SIZE 30 641 static const struct tpm_input_header pcrread_header = { 642 .tag = TPM_TAG_RQU_COMMAND, 643 .length = cpu_to_be32(14), 644 .ordinal = TPM_ORDINAL_PCRREAD 645 }; 646 647 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf) 648 { 649 int rc; 650 struct tpm_cmd_t cmd; 651 652 cmd.header.in = pcrread_header; 653 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx); 654 rc = tpm_transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE, 0, 655 "attempting to read a pcr value"); 656 657 if (rc == 0) 658 memcpy(res_buf, cmd.params.pcrread_out.pcr_result, 659 TPM_DIGEST_SIZE); 660 return rc; 661 } 662 663 /** 664 * tpm_is_tpm2 - is the chip a TPM2 chip? 665 * @chip_num: tpm idx # or ANY 666 * 667 * Returns < 0 on error, and 1 or 0 on success depending whether the chip 668 * is a TPM2 chip. 669 */ 670 int tpm_is_tpm2(u32 chip_num) 671 { 672 struct tpm_chip *chip; 673 int rc; 674 675 chip = tpm_chip_find_get(chip_num); 676 if (chip == NULL) 677 return -ENODEV; 678 679 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0; 680 681 tpm_put_ops(chip); 682 683 return rc; 684 } 685 EXPORT_SYMBOL_GPL(tpm_is_tpm2); 686 687 /** 688 * tpm_pcr_read - read a pcr value 689 * @chip_num: tpm idx # or ANY 690 * @pcr_idx: pcr idx to retrieve 691 * @res_buf: TPM_PCR value 692 * size of res_buf is 20 bytes (or NULL if you don't care) 693 * 694 * The TPM driver should be built-in, but for whatever reason it 695 * isn't, protect against the chip disappearing, by incrementing 696 * the module usage count. 697 */ 698 int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf) 699 { 700 struct tpm_chip *chip; 701 int rc; 702 703 chip = tpm_chip_find_get(chip_num); 704 if (chip == NULL) 705 return -ENODEV; 706 if (chip->flags & TPM_CHIP_FLAG_TPM2) 707 rc = tpm2_pcr_read(chip, pcr_idx, res_buf); 708 else 709 rc = tpm_pcr_read_dev(chip, pcr_idx, res_buf); 710 tpm_put_ops(chip); 711 return rc; 712 } 713 EXPORT_SYMBOL_GPL(tpm_pcr_read); 714 715 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20) 716 #define EXTEND_PCR_RESULT_SIZE 34 717 static const struct tpm_input_header pcrextend_header = { 718 .tag = TPM_TAG_RQU_COMMAND, 719 .length = cpu_to_be32(34), 720 .ordinal = TPM_ORD_PCR_EXTEND 721 }; 722 723 /** 724 * tpm_pcr_extend - extend pcr value with hash 725 * @chip_num: tpm idx # or AN& 726 * @pcr_idx: pcr idx to extend 727 * @hash: hash value used to extend pcr value 728 * 729 * The TPM driver should be built-in, but for whatever reason it 730 * isn't, protect against the chip disappearing, by incrementing 731 * the module usage count. 732 */ 733 int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash) 734 { 735 struct tpm_cmd_t cmd; 736 int rc; 737 struct tpm_chip *chip; 738 739 chip = tpm_chip_find_get(chip_num); 740 if (chip == NULL) 741 return -ENODEV; 742 743 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 744 rc = tpm2_pcr_extend(chip, pcr_idx, hash); 745 tpm_put_ops(chip); 746 return rc; 747 } 748 749 cmd.header.in = pcrextend_header; 750 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx); 751 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE); 752 rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 0, 753 "attempting extend a PCR value"); 754 755 tpm_put_ops(chip); 756 return rc; 757 } 758 EXPORT_SYMBOL_GPL(tpm_pcr_extend); 759 760 /** 761 * tpm_do_selftest - have the TPM continue its selftest and wait until it 762 * can receive further commands 763 * @chip: TPM chip to use 764 * 765 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing 766 * a TPM error code. 767 */ 768 int tpm_do_selftest(struct tpm_chip *chip) 769 { 770 int rc; 771 unsigned int loops; 772 unsigned int delay_msec = 100; 773 unsigned long duration; 774 u8 dummy[TPM_DIGEST_SIZE]; 775 776 duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST); 777 778 loops = jiffies_to_msecs(duration) / delay_msec; 779 780 rc = tpm_continue_selftest(chip); 781 /* This may fail if there was no TPM driver during a suspend/resume 782 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST) 783 */ 784 if (rc) 785 return rc; 786 787 do { 788 /* Attempt to read a PCR value */ 789 rc = tpm_pcr_read_dev(chip, 0, dummy); 790 791 /* Some buggy TPMs will not respond to tpm_tis_ready() for 792 * around 300ms while the self test is ongoing, keep trying 793 * until the self test duration expires. */ 794 if (rc == -ETIME) { 795 dev_info( 796 &chip->dev, HW_ERR 797 "TPM command timed out during continue self test"); 798 msleep(delay_msec); 799 continue; 800 } 801 802 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) { 803 dev_info(&chip->dev, 804 "TPM is disabled/deactivated (0x%X)\n", rc); 805 /* TPM is disabled and/or deactivated; driver can 806 * proceed and TPM does handle commands for 807 * suspend/resume correctly 808 */ 809 return 0; 810 } 811 if (rc != TPM_WARN_DOING_SELFTEST) 812 return rc; 813 msleep(delay_msec); 814 } while (--loops > 0); 815 816 return rc; 817 } 818 EXPORT_SYMBOL_GPL(tpm_do_selftest); 819 820 /** 821 * tpm1_auto_startup - Perform the standard automatic TPM initialization 822 * sequence 823 * @chip: TPM chip to use 824 * 825 * Returns 0 on success, < 0 in case of fatal error. 826 */ 827 int tpm1_auto_startup(struct tpm_chip *chip) 828 { 829 int rc; 830 831 rc = tpm_get_timeouts(chip); 832 if (rc) 833 goto out; 834 rc = tpm_do_selftest(chip); 835 if (rc) { 836 dev_err(&chip->dev, "TPM self test failed\n"); 837 goto out; 838 } 839 840 return rc; 841 out: 842 if (rc > 0) 843 rc = -ENODEV; 844 return rc; 845 } 846 847 int tpm_send(u32 chip_num, void *cmd, size_t buflen) 848 { 849 struct tpm_chip *chip; 850 int rc; 851 852 chip = tpm_chip_find_get(chip_num); 853 if (chip == NULL) 854 return -ENODEV; 855 856 rc = tpm_transmit_cmd(chip, cmd, buflen, 0, "attempting tpm_cmd"); 857 858 tpm_put_ops(chip); 859 return rc; 860 } 861 EXPORT_SYMBOL_GPL(tpm_send); 862 863 static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask, 864 bool check_cancel, bool *canceled) 865 { 866 u8 status = chip->ops->status(chip); 867 868 *canceled = false; 869 if ((status & mask) == mask) 870 return true; 871 if (check_cancel && chip->ops->req_canceled(chip, status)) { 872 *canceled = true; 873 return true; 874 } 875 return false; 876 } 877 878 int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, 879 wait_queue_head_t *queue, bool check_cancel) 880 { 881 unsigned long stop; 882 long rc; 883 u8 status; 884 bool canceled = false; 885 886 /* check current status */ 887 status = chip->ops->status(chip); 888 if ((status & mask) == mask) 889 return 0; 890 891 stop = jiffies + timeout; 892 893 if (chip->flags & TPM_CHIP_FLAG_IRQ) { 894 again: 895 timeout = stop - jiffies; 896 if ((long)timeout <= 0) 897 return -ETIME; 898 rc = wait_event_interruptible_timeout(*queue, 899 wait_for_tpm_stat_cond(chip, mask, check_cancel, 900 &canceled), 901 timeout); 902 if (rc > 0) { 903 if (canceled) 904 return -ECANCELED; 905 return 0; 906 } 907 if (rc == -ERESTARTSYS && freezing(current)) { 908 clear_thread_flag(TIF_SIGPENDING); 909 goto again; 910 } 911 } else { 912 do { 913 msleep(TPM_TIMEOUT); 914 status = chip->ops->status(chip); 915 if ((status & mask) == mask) 916 return 0; 917 } while (time_before(jiffies, stop)); 918 } 919 return -ETIME; 920 } 921 EXPORT_SYMBOL_GPL(wait_for_tpm_stat); 922 923 #define TPM_ORD_SAVESTATE cpu_to_be32(152) 924 #define SAVESTATE_RESULT_SIZE 10 925 926 static const struct tpm_input_header savestate_header = { 927 .tag = TPM_TAG_RQU_COMMAND, 928 .length = cpu_to_be32(10), 929 .ordinal = TPM_ORD_SAVESTATE 930 }; 931 932 /* 933 * We are about to suspend. Save the TPM state 934 * so that it can be restored. 935 */ 936 int tpm_pm_suspend(struct device *dev) 937 { 938 struct tpm_chip *chip = dev_get_drvdata(dev); 939 struct tpm_cmd_t cmd; 940 int rc, try; 941 942 u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 }; 943 944 if (chip == NULL) 945 return -ENODEV; 946 947 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 948 tpm2_shutdown(chip, TPM2_SU_STATE); 949 return 0; 950 } 951 952 /* for buggy tpm, flush pcrs with extend to selected dummy */ 953 if (tpm_suspend_pcr) { 954 cmd.header.in = pcrextend_header; 955 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr); 956 memcpy(cmd.params.pcrextend_in.hash, dummy_hash, 957 TPM_DIGEST_SIZE); 958 rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 0, 959 "extending dummy pcr before suspend"); 960 } 961 962 /* now do the actual savestate */ 963 for (try = 0; try < TPM_RETRY; try++) { 964 cmd.header.in = savestate_header; 965 rc = tpm_transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE, 0, 966 NULL); 967 968 /* 969 * If the TPM indicates that it is too busy to respond to 970 * this command then retry before giving up. It can take 971 * several seconds for this TPM to be ready. 972 * 973 * This can happen if the TPM has already been sent the 974 * SaveState command before the driver has loaded. TCG 1.2 975 * specification states that any communication after SaveState 976 * may cause the TPM to invalidate previously saved state. 977 */ 978 if (rc != TPM_WARN_RETRY) 979 break; 980 msleep(TPM_TIMEOUT_RETRY); 981 } 982 983 if (rc) 984 dev_err(&chip->dev, 985 "Error (%d) sending savestate before suspend\n", rc); 986 else if (try > 0) 987 dev_warn(&chip->dev, "TPM savestate took %dms\n", 988 try * TPM_TIMEOUT_RETRY); 989 990 return rc; 991 } 992 EXPORT_SYMBOL_GPL(tpm_pm_suspend); 993 994 /* 995 * Resume from a power safe. The BIOS already restored 996 * the TPM state. 997 */ 998 int tpm_pm_resume(struct device *dev) 999 { 1000 struct tpm_chip *chip = dev_get_drvdata(dev); 1001 1002 if (chip == NULL) 1003 return -ENODEV; 1004 1005 return 0; 1006 } 1007 EXPORT_SYMBOL_GPL(tpm_pm_resume); 1008 1009 #define TPM_GETRANDOM_RESULT_SIZE 18 1010 static const struct tpm_input_header tpm_getrandom_header = { 1011 .tag = TPM_TAG_RQU_COMMAND, 1012 .length = cpu_to_be32(14), 1013 .ordinal = TPM_ORD_GET_RANDOM 1014 }; 1015 1016 /** 1017 * tpm_get_random() - Get random bytes from the tpm's RNG 1018 * @chip_num: A specific chip number for the request or TPM_ANY_NUM 1019 * @out: destination buffer for the random bytes 1020 * @max: the max number of bytes to write to @out 1021 * 1022 * Returns < 0 on error and the number of bytes read on success 1023 */ 1024 int tpm_get_random(u32 chip_num, u8 *out, size_t max) 1025 { 1026 struct tpm_chip *chip; 1027 struct tpm_cmd_t tpm_cmd; 1028 u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA); 1029 int err, total = 0, retries = 5; 1030 u8 *dest = out; 1031 1032 if (!out || !num_bytes || max > TPM_MAX_RNG_DATA) 1033 return -EINVAL; 1034 1035 chip = tpm_chip_find_get(chip_num); 1036 if (chip == NULL) 1037 return -ENODEV; 1038 1039 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 1040 err = tpm2_get_random(chip, out, max); 1041 tpm_put_ops(chip); 1042 return err; 1043 } 1044 1045 do { 1046 tpm_cmd.header.in = tpm_getrandom_header; 1047 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes); 1048 1049 err = tpm_transmit_cmd(chip, &tpm_cmd, 1050 TPM_GETRANDOM_RESULT_SIZE + num_bytes, 1051 0, "attempting get random"); 1052 if (err) 1053 break; 1054 1055 recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len); 1056 memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd); 1057 1058 dest += recd; 1059 total += recd; 1060 num_bytes -= recd; 1061 } while (retries-- && total < max); 1062 1063 tpm_put_ops(chip); 1064 return total ? total : -EIO; 1065 } 1066 EXPORT_SYMBOL_GPL(tpm_get_random); 1067 1068 /** 1069 * tpm_seal_trusted() - seal a trusted key 1070 * @chip_num: A specific chip number for the request or TPM_ANY_NUM 1071 * @options: authentication values and other options 1072 * @payload: the key data in clear and encrypted form 1073 * 1074 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips 1075 * are supported. 1076 */ 1077 int tpm_seal_trusted(u32 chip_num, struct trusted_key_payload *payload, 1078 struct trusted_key_options *options) 1079 { 1080 struct tpm_chip *chip; 1081 int rc; 1082 1083 chip = tpm_chip_find_get(chip_num); 1084 if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2)) 1085 return -ENODEV; 1086 1087 rc = tpm2_seal_trusted(chip, payload, options); 1088 1089 tpm_put_ops(chip); 1090 return rc; 1091 } 1092 EXPORT_SYMBOL_GPL(tpm_seal_trusted); 1093 1094 /** 1095 * tpm_unseal_trusted() - unseal a trusted key 1096 * @chip_num: A specific chip number for the request or TPM_ANY_NUM 1097 * @options: authentication values and other options 1098 * @payload: the key data in clear and encrypted form 1099 * 1100 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips 1101 * are supported. 1102 */ 1103 int tpm_unseal_trusted(u32 chip_num, struct trusted_key_payload *payload, 1104 struct trusted_key_options *options) 1105 { 1106 struct tpm_chip *chip; 1107 int rc; 1108 1109 chip = tpm_chip_find_get(chip_num); 1110 if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2)) 1111 return -ENODEV; 1112 1113 rc = tpm2_unseal_trusted(chip, payload, options); 1114 1115 tpm_put_ops(chip); 1116 1117 return rc; 1118 } 1119 EXPORT_SYMBOL_GPL(tpm_unseal_trusted); 1120 1121 static int __init tpm_init(void) 1122 { 1123 int rc; 1124 1125 tpm_class = class_create(THIS_MODULE, "tpm"); 1126 if (IS_ERR(tpm_class)) { 1127 pr_err("couldn't create tpm class\n"); 1128 return PTR_ERR(tpm_class); 1129 } 1130 1131 rc = alloc_chrdev_region(&tpm_devt, 0, TPM_NUM_DEVICES, "tpm"); 1132 if (rc < 0) { 1133 pr_err("tpm: failed to allocate char dev region\n"); 1134 class_destroy(tpm_class); 1135 return rc; 1136 } 1137 1138 return 0; 1139 } 1140 1141 static void __exit tpm_exit(void) 1142 { 1143 idr_destroy(&dev_nums_idr); 1144 class_destroy(tpm_class); 1145 unregister_chrdev_region(tpm_devt, TPM_NUM_DEVICES); 1146 } 1147 1148 subsys_initcall(tpm_init); 1149 module_exit(tpm_exit); 1150 1151 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); 1152 MODULE_DESCRIPTION("TPM Driver"); 1153 MODULE_VERSION("2.0"); 1154 MODULE_LICENSE("GPL"); 1155