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