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 #include <linux/tpm_eventlog.h> 34 35 #include "tpm.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 facilitate 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 static int tpm_validate_command(struct tpm_chip *chip, 332 struct tpm_space *space, 333 const u8 *cmd, 334 size_t len) 335 { 336 const struct tpm_input_header *header = (const void *)cmd; 337 int i; 338 u32 cc; 339 u32 attrs; 340 unsigned int nr_handles; 341 342 if (len < TPM_HEADER_SIZE) 343 return -EINVAL; 344 345 if (!space) 346 return 0; 347 348 if (chip->flags & TPM_CHIP_FLAG_TPM2 && chip->nr_commands) { 349 cc = be32_to_cpu(header->ordinal); 350 351 i = tpm2_find_cc(chip, cc); 352 if (i < 0) { 353 dev_dbg(&chip->dev, "0x%04X is an invalid command\n", 354 cc); 355 return -EOPNOTSUPP; 356 } 357 358 attrs = chip->cc_attrs_tbl[i]; 359 nr_handles = 360 4 * ((attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0)); 361 if (len < TPM_HEADER_SIZE + 4 * nr_handles) 362 goto err_len; 363 } 364 365 return 0; 366 err_len: 367 dev_dbg(&chip->dev, 368 "%s: insufficient command length %zu", __func__, len); 369 return -EINVAL; 370 } 371 372 /** 373 * tmp_transmit - Internal kernel interface to transmit TPM commands. 374 * 375 * @chip: TPM chip to use 376 * @buf: TPM command buffer 377 * @bufsiz: length of the TPM command buffer 378 * @flags: tpm transmit flags - bitmap 379 * 380 * Return: 381 * 0 when the operation is successful. 382 * A negative number for system errors (errno). 383 */ 384 ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space, 385 u8 *buf, size_t bufsiz, unsigned int flags) 386 { 387 struct tpm_output_header *header = (void *)buf; 388 int rc; 389 ssize_t len = 0; 390 u32 count, ordinal; 391 unsigned long stop; 392 bool need_locality; 393 394 rc = tpm_validate_command(chip, space, buf, bufsiz); 395 if (rc == -EINVAL) 396 return rc; 397 /* 398 * If the command is not implemented by the TPM, synthesize a 399 * response with a TPM2_RC_COMMAND_CODE return for user-space. 400 */ 401 if (rc == -EOPNOTSUPP) { 402 header->length = cpu_to_be32(sizeof(*header)); 403 header->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS); 404 header->return_code = cpu_to_be32(TPM2_RC_COMMAND_CODE | 405 TSS2_RESMGR_TPM_RC_LAYER); 406 return bufsiz; 407 } 408 409 if (bufsiz > TPM_BUFSIZE) 410 bufsiz = TPM_BUFSIZE; 411 412 count = be32_to_cpu(*((__be32 *) (buf + 2))); 413 ordinal = be32_to_cpu(*((__be32 *) (buf + 6))); 414 if (count == 0) 415 return -ENODATA; 416 if (count > bufsiz) { 417 dev_err(&chip->dev, 418 "invalid count value %x %zx\n", count, bufsiz); 419 return -E2BIG; 420 } 421 422 if (!(flags & TPM_TRANSMIT_UNLOCKED)) 423 mutex_lock(&chip->tpm_mutex); 424 425 if (chip->dev.parent) 426 pm_runtime_get_sync(chip->dev.parent); 427 428 if (chip->ops->clk_enable != NULL) 429 chip->ops->clk_enable(chip, true); 430 431 /* Store the decision as chip->locality will be changed. */ 432 need_locality = chip->locality == -1; 433 434 if (!(flags & TPM_TRANSMIT_RAW) && 435 need_locality && chip->ops->request_locality) { 436 rc = chip->ops->request_locality(chip, 0); 437 if (rc < 0) 438 goto out_no_locality; 439 chip->locality = rc; 440 } 441 442 rc = tpm2_prepare_space(chip, space, ordinal, buf); 443 if (rc) 444 goto out; 445 446 rc = chip->ops->send(chip, (u8 *) buf, count); 447 if (rc < 0) { 448 if (rc != -EPIPE) 449 dev_err(&chip->dev, 450 "%s: tpm_send: error %d\n", __func__, rc); 451 goto out; 452 } 453 454 if (chip->flags & TPM_CHIP_FLAG_IRQ) 455 goto out_recv; 456 457 if (chip->flags & TPM_CHIP_FLAG_TPM2) 458 stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal); 459 else 460 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal); 461 do { 462 u8 status = chip->ops->status(chip); 463 if ((status & chip->ops->req_complete_mask) == 464 chip->ops->req_complete_val) 465 goto out_recv; 466 467 if (chip->ops->req_canceled(chip, status)) { 468 dev_err(&chip->dev, "Operation Canceled\n"); 469 rc = -ECANCELED; 470 goto out; 471 } 472 473 tpm_msleep(TPM_TIMEOUT); 474 rmb(); 475 } while (time_before(jiffies, stop)); 476 477 chip->ops->cancel(chip); 478 dev_err(&chip->dev, "Operation Timed out\n"); 479 rc = -ETIME; 480 goto out; 481 482 out_recv: 483 len = chip->ops->recv(chip, (u8 *) buf, bufsiz); 484 if (len < 0) { 485 rc = len; 486 dev_err(&chip->dev, 487 "tpm_transmit: tpm_recv: error %d\n", rc); 488 goto out; 489 } else if (len < TPM_HEADER_SIZE) { 490 rc = -EFAULT; 491 goto out; 492 } 493 494 if (len != be32_to_cpu(header->length)) { 495 rc = -EFAULT; 496 goto out; 497 } 498 499 rc = tpm2_commit_space(chip, space, ordinal, buf, &len); 500 501 out: 502 if (need_locality && chip->ops->relinquish_locality) { 503 chip->ops->relinquish_locality(chip, chip->locality); 504 chip->locality = -1; 505 } 506 out_no_locality: 507 if (chip->ops->clk_enable != NULL) 508 chip->ops->clk_enable(chip, false); 509 510 if (chip->dev.parent) 511 pm_runtime_put_sync(chip->dev.parent); 512 513 if (!(flags & TPM_TRANSMIT_UNLOCKED)) 514 mutex_unlock(&chip->tpm_mutex); 515 return rc ? rc : len; 516 } 517 518 /** 519 * tmp_transmit_cmd - send a tpm command to the device 520 * The function extracts tpm out header return code 521 * 522 * @chip: TPM chip to use 523 * @buf: TPM command buffer 524 * @bufsiz: length of the buffer 525 * @min_rsp_body_length: minimum expected length of response body 526 * @flags: tpm transmit flags - bitmap 527 * @desc: command description used in the error message 528 * 529 * Return: 530 * 0 when the operation is successful. 531 * A negative number for system errors (errno). 532 * A positive number for a TPM error. 533 */ 534 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space, 535 const void *buf, size_t bufsiz, 536 size_t min_rsp_body_length, unsigned int flags, 537 const char *desc) 538 { 539 const struct tpm_output_header *header = buf; 540 int err; 541 ssize_t len; 542 543 len = tpm_transmit(chip, space, (u8 *)buf, bufsiz, flags); 544 if (len < 0) 545 return len; 546 547 err = be32_to_cpu(header->return_code); 548 if (err != 0 && desc) 549 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err, 550 desc); 551 if (err) 552 return err; 553 554 if (len < min_rsp_body_length + TPM_HEADER_SIZE) 555 return -EFAULT; 556 557 return 0; 558 } 559 EXPORT_SYMBOL_GPL(tpm_transmit_cmd); 560 561 #define TPM_ORD_STARTUP 153 562 #define TPM_ST_CLEAR 1 563 564 /** 565 * tpm_startup - turn on the TPM 566 * @chip: TPM chip to use 567 * 568 * Normally the firmware should start the TPM. This function is provided as a 569 * workaround if this does not happen. A legal case for this could be for 570 * example when a TPM emulator is used. 571 * 572 * Return: same as tpm_transmit_cmd() 573 */ 574 int tpm_startup(struct tpm_chip *chip) 575 { 576 struct tpm_buf buf; 577 int rc; 578 579 dev_info(&chip->dev, "starting up the TPM manually\n"); 580 581 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 582 rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_STARTUP); 583 if (rc < 0) 584 return rc; 585 586 tpm_buf_append_u16(&buf, TPM2_SU_CLEAR); 587 } else { 588 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_STARTUP); 589 if (rc < 0) 590 return rc; 591 592 tpm_buf_append_u16(&buf, TPM_ST_CLEAR); 593 } 594 595 rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE, 0, 0, 596 "attempting to start the TPM"); 597 598 tpm_buf_destroy(&buf); 599 return rc; 600 } 601 602 #define TPM_DIGEST_SIZE 20 603 #define TPM_RET_CODE_IDX 6 604 #define TPM_INTERNAL_RESULT_SIZE 200 605 #define TPM_ORD_GET_CAP 101 606 #define TPM_ORD_GET_RANDOM 70 607 608 static const struct tpm_input_header tpm_getcap_header = { 609 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 610 .length = cpu_to_be32(22), 611 .ordinal = cpu_to_be32(TPM_ORD_GET_CAP) 612 }; 613 614 ssize_t tpm_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap, 615 const char *desc, size_t min_cap_length) 616 { 617 struct tpm_buf buf; 618 int rc; 619 620 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP); 621 if (rc) 622 return rc; 623 624 if (subcap_id == TPM_CAP_VERSION_1_1 || 625 subcap_id == TPM_CAP_VERSION_1_2) { 626 tpm_buf_append_u32(&buf, subcap_id); 627 tpm_buf_append_u32(&buf, 0); 628 } else { 629 if (subcap_id == TPM_CAP_FLAG_PERM || 630 subcap_id == TPM_CAP_FLAG_VOL) 631 tpm_buf_append_u32(&buf, TPM_CAP_FLAG); 632 else 633 tpm_buf_append_u32(&buf, TPM_CAP_PROP); 634 635 tpm_buf_append_u32(&buf, 4); 636 tpm_buf_append_u32(&buf, subcap_id); 637 } 638 rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE, 639 min_cap_length, 0, desc); 640 if (!rc) 641 *cap = *(cap_t *)&buf.data[TPM_HEADER_SIZE + 4]; 642 643 tpm_buf_destroy(&buf); 644 return rc; 645 } 646 EXPORT_SYMBOL_GPL(tpm_getcap); 647 648 int tpm_get_timeouts(struct tpm_chip *chip) 649 { 650 cap_t cap; 651 unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4]; 652 ssize_t rc; 653 654 if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS) 655 return 0; 656 657 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 658 /* Fixed timeouts for TPM2 */ 659 chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A); 660 chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B); 661 chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C); 662 chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D); 663 chip->duration[TPM_SHORT] = 664 msecs_to_jiffies(TPM2_DURATION_SHORT); 665 chip->duration[TPM_MEDIUM] = 666 msecs_to_jiffies(TPM2_DURATION_MEDIUM); 667 chip->duration[TPM_LONG] = 668 msecs_to_jiffies(TPM2_DURATION_LONG); 669 670 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS; 671 return 0; 672 } 673 674 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL, 675 sizeof(cap.timeout)); 676 if (rc == TPM_ERR_INVALID_POSTINIT) { 677 if (tpm_startup(chip)) 678 return rc; 679 680 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, 681 "attempting to determine the timeouts", 682 sizeof(cap.timeout)); 683 } 684 685 if (rc) { 686 dev_err(&chip->dev, 687 "A TPM error (%zd) occurred attempting to determine the timeouts\n", 688 rc); 689 return rc; 690 } 691 692 timeout_old[0] = jiffies_to_usecs(chip->timeout_a); 693 timeout_old[1] = jiffies_to_usecs(chip->timeout_b); 694 timeout_old[2] = jiffies_to_usecs(chip->timeout_c); 695 timeout_old[3] = jiffies_to_usecs(chip->timeout_d); 696 timeout_chip[0] = be32_to_cpu(cap.timeout.a); 697 timeout_chip[1] = be32_to_cpu(cap.timeout.b); 698 timeout_chip[2] = be32_to_cpu(cap.timeout.c); 699 timeout_chip[3] = be32_to_cpu(cap.timeout.d); 700 memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff)); 701 702 /* 703 * Provide ability for vendor overrides of timeout values in case 704 * of misreporting. 705 */ 706 if (chip->ops->update_timeouts != NULL) 707 chip->timeout_adjusted = 708 chip->ops->update_timeouts(chip, timeout_eff); 709 710 if (!chip->timeout_adjusted) { 711 /* Restore default if chip reported 0 */ 712 int i; 713 714 for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) { 715 if (timeout_eff[i]) 716 continue; 717 718 timeout_eff[i] = timeout_old[i]; 719 chip->timeout_adjusted = true; 720 } 721 722 if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) { 723 /* timeouts in msec rather usec */ 724 for (i = 0; i != ARRAY_SIZE(timeout_eff); i++) 725 timeout_eff[i] *= 1000; 726 chip->timeout_adjusted = true; 727 } 728 } 729 730 /* Report adjusted timeouts */ 731 if (chip->timeout_adjusted) { 732 dev_info(&chip->dev, 733 HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n", 734 timeout_chip[0], timeout_eff[0], 735 timeout_chip[1], timeout_eff[1], 736 timeout_chip[2], timeout_eff[2], 737 timeout_chip[3], timeout_eff[3]); 738 } 739 740 chip->timeout_a = usecs_to_jiffies(timeout_eff[0]); 741 chip->timeout_b = usecs_to_jiffies(timeout_eff[1]); 742 chip->timeout_c = usecs_to_jiffies(timeout_eff[2]); 743 chip->timeout_d = usecs_to_jiffies(timeout_eff[3]); 744 745 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap, 746 "attempting to determine the durations", 747 sizeof(cap.duration)); 748 if (rc) 749 return rc; 750 751 chip->duration[TPM_SHORT] = 752 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short)); 753 chip->duration[TPM_MEDIUM] = 754 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium)); 755 chip->duration[TPM_LONG] = 756 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long)); 757 758 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above 759 * value wrong and apparently reports msecs rather than usecs. So we 760 * fix up the resulting too-small TPM_SHORT value to make things work. 761 * We also scale the TPM_MEDIUM and -_LONG values by 1000. 762 */ 763 if (chip->duration[TPM_SHORT] < (HZ / 100)) { 764 chip->duration[TPM_SHORT] = HZ; 765 chip->duration[TPM_MEDIUM] *= 1000; 766 chip->duration[TPM_LONG] *= 1000; 767 chip->duration_adjusted = true; 768 dev_info(&chip->dev, "Adjusting TPM timeout parameters."); 769 } 770 771 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS; 772 return 0; 773 } 774 EXPORT_SYMBOL_GPL(tpm_get_timeouts); 775 776 #define TPM_ORD_CONTINUE_SELFTEST 83 777 #define CONTINUE_SELFTEST_RESULT_SIZE 10 778 779 static const struct tpm_input_header continue_selftest_header = { 780 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 781 .length = cpu_to_be32(10), 782 .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST), 783 }; 784 785 /** 786 * tpm_continue_selftest -- run TPM's selftest 787 * @chip: TPM chip to use 788 * 789 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing 790 * a TPM error code. 791 */ 792 static int tpm_continue_selftest(struct tpm_chip *chip) 793 { 794 int rc; 795 struct tpm_cmd_t cmd; 796 797 cmd.header.in = continue_selftest_header; 798 rc = tpm_transmit_cmd(chip, NULL, &cmd, CONTINUE_SELFTEST_RESULT_SIZE, 799 0, 0, "continue selftest"); 800 return rc; 801 } 802 803 #define TPM_ORDINAL_PCRREAD 21 804 #define READ_PCR_RESULT_SIZE 30 805 #define READ_PCR_RESULT_BODY_SIZE 20 806 static const struct tpm_input_header pcrread_header = { 807 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 808 .length = cpu_to_be32(14), 809 .ordinal = cpu_to_be32(TPM_ORDINAL_PCRREAD) 810 }; 811 812 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf) 813 { 814 int rc; 815 struct tpm_cmd_t cmd; 816 817 cmd.header.in = pcrread_header; 818 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx); 819 rc = tpm_transmit_cmd(chip, NULL, &cmd, READ_PCR_RESULT_SIZE, 820 READ_PCR_RESULT_BODY_SIZE, 0, 821 "attempting to read a pcr value"); 822 823 if (rc == 0) 824 memcpy(res_buf, cmd.params.pcrread_out.pcr_result, 825 TPM_DIGEST_SIZE); 826 return rc; 827 } 828 829 /** 830 * tpm_is_tpm2 - do we a have a TPM2 chip? 831 * @chip: a &struct tpm_chip instance, %NULL for the default chip 832 * 833 * Return: 834 * 1 if we have a TPM2 chip. 835 * 0 if we don't have a TPM2 chip. 836 * A negative number for system errors (errno). 837 */ 838 int tpm_is_tpm2(struct tpm_chip *chip) 839 { 840 int rc; 841 842 chip = tpm_chip_find_get(chip); 843 if (!chip) 844 return -ENODEV; 845 846 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0; 847 848 tpm_put_ops(chip); 849 850 return rc; 851 } 852 EXPORT_SYMBOL_GPL(tpm_is_tpm2); 853 854 /** 855 * tpm_pcr_read - read a PCR value from SHA1 bank 856 * @chip: a &struct tpm_chip instance, %NULL for the default chip 857 * @pcr_idx: the PCR to be retrieved 858 * @res_buf: the value of the PCR 859 * 860 * Return: same as with tpm_transmit_cmd() 861 */ 862 int tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf) 863 { 864 int rc; 865 866 chip = tpm_chip_find_get(chip); 867 if (!chip) 868 return -ENODEV; 869 if (chip->flags & TPM_CHIP_FLAG_TPM2) 870 rc = tpm2_pcr_read(chip, pcr_idx, res_buf); 871 else 872 rc = tpm_pcr_read_dev(chip, pcr_idx, res_buf); 873 tpm_put_ops(chip); 874 return rc; 875 } 876 EXPORT_SYMBOL_GPL(tpm_pcr_read); 877 878 #define TPM_ORD_PCR_EXTEND 20 879 #define EXTEND_PCR_RESULT_SIZE 34 880 #define EXTEND_PCR_RESULT_BODY_SIZE 20 881 static const struct tpm_input_header pcrextend_header = { 882 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 883 .length = cpu_to_be32(34), 884 .ordinal = cpu_to_be32(TPM_ORD_PCR_EXTEND) 885 }; 886 887 static int tpm1_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash, 888 char *log_msg) 889 { 890 struct tpm_buf buf; 891 int rc; 892 893 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND); 894 if (rc) 895 return rc; 896 897 tpm_buf_append_u32(&buf, pcr_idx); 898 tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE); 899 900 rc = tpm_transmit_cmd(chip, NULL, buf.data, EXTEND_PCR_RESULT_SIZE, 901 EXTEND_PCR_RESULT_BODY_SIZE, 0, log_msg); 902 tpm_buf_destroy(&buf); 903 return rc; 904 } 905 906 /** 907 * tpm_pcr_extend - extend a PCR value in SHA1 bank. 908 * @chip: a &struct tpm_chip instance, %NULL for the default chip 909 * @pcr_idx: the PCR to be retrieved 910 * @hash: the hash value used to extend the PCR value 911 * 912 * Note: with TPM 2.0 extends also those banks with a known digest size to the 913 * cryto subsystem in order to prevent malicious use of those PCR banks. In the 914 * future we should dynamically determine digest sizes. 915 * 916 * Return: same as with tpm_transmit_cmd() 917 */ 918 int tpm_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash) 919 { 920 int rc; 921 struct tpm2_digest digest_list[ARRAY_SIZE(chip->active_banks)]; 922 u32 count = 0; 923 int i; 924 925 chip = tpm_chip_find_get(chip); 926 if (!chip) 927 return -ENODEV; 928 929 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 930 memset(digest_list, 0, sizeof(digest_list)); 931 932 for (i = 0; i < ARRAY_SIZE(chip->active_banks) && 933 chip->active_banks[i] != TPM2_ALG_ERROR; i++) { 934 digest_list[i].alg_id = chip->active_banks[i]; 935 memcpy(digest_list[i].digest, hash, TPM_DIGEST_SIZE); 936 count++; 937 } 938 939 rc = tpm2_pcr_extend(chip, pcr_idx, count, digest_list); 940 tpm_put_ops(chip); 941 return rc; 942 } 943 944 rc = tpm1_pcr_extend(chip, pcr_idx, hash, 945 "attempting extend a PCR value"); 946 tpm_put_ops(chip); 947 return rc; 948 } 949 EXPORT_SYMBOL_GPL(tpm_pcr_extend); 950 951 /** 952 * tpm_do_selftest - have the TPM continue its selftest and wait until it 953 * can receive further commands 954 * @chip: TPM chip to use 955 * 956 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing 957 * a TPM error code. 958 */ 959 int tpm_do_selftest(struct tpm_chip *chip) 960 { 961 int rc; 962 unsigned int loops; 963 unsigned int delay_msec = 100; 964 unsigned long duration; 965 u8 dummy[TPM_DIGEST_SIZE]; 966 967 duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST); 968 969 loops = jiffies_to_msecs(duration) / delay_msec; 970 971 rc = tpm_continue_selftest(chip); 972 /* This may fail if there was no TPM driver during a suspend/resume 973 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST) 974 */ 975 if (rc) 976 return rc; 977 978 do { 979 /* Attempt to read a PCR value */ 980 rc = tpm_pcr_read_dev(chip, 0, dummy); 981 982 /* Some buggy TPMs will not respond to tpm_tis_ready() for 983 * around 300ms while the self test is ongoing, keep trying 984 * until the self test duration expires. */ 985 if (rc == -ETIME) { 986 dev_info( 987 &chip->dev, HW_ERR 988 "TPM command timed out during continue self test"); 989 tpm_msleep(delay_msec); 990 continue; 991 } 992 993 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) { 994 dev_info(&chip->dev, 995 "TPM is disabled/deactivated (0x%X)\n", rc); 996 /* TPM is disabled and/or deactivated; driver can 997 * proceed and TPM does handle commands for 998 * suspend/resume correctly 999 */ 1000 return 0; 1001 } 1002 if (rc != TPM_WARN_DOING_SELFTEST) 1003 return rc; 1004 tpm_msleep(delay_msec); 1005 } while (--loops > 0); 1006 1007 return rc; 1008 } 1009 EXPORT_SYMBOL_GPL(tpm_do_selftest); 1010 1011 /** 1012 * tpm1_auto_startup - Perform the standard automatic TPM initialization 1013 * sequence 1014 * @chip: TPM chip to use 1015 * 1016 * Returns 0 on success, < 0 in case of fatal error. 1017 */ 1018 int tpm1_auto_startup(struct tpm_chip *chip) 1019 { 1020 int rc; 1021 1022 rc = tpm_get_timeouts(chip); 1023 if (rc) 1024 goto out; 1025 rc = tpm_do_selftest(chip); 1026 if (rc) { 1027 dev_err(&chip->dev, "TPM self test failed\n"); 1028 goto out; 1029 } 1030 1031 return rc; 1032 out: 1033 if (rc > 0) 1034 rc = -ENODEV; 1035 return rc; 1036 } 1037 1038 /** 1039 * tpm_send - send a TPM command 1040 * @chip: a &struct tpm_chip instance, %NULL for the default chip 1041 * @cmd: a TPM command buffer 1042 * @buflen: the length of the TPM command buffer 1043 * 1044 * Return: same as with tpm_transmit_cmd() 1045 */ 1046 int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen) 1047 { 1048 int rc; 1049 1050 chip = tpm_chip_find_get(chip); 1051 if (!chip) 1052 return -ENODEV; 1053 1054 rc = tpm_transmit_cmd(chip, NULL, cmd, buflen, 0, 0, 1055 "attempting to a send a command"); 1056 tpm_put_ops(chip); 1057 return rc; 1058 } 1059 EXPORT_SYMBOL_GPL(tpm_send); 1060 1061 #define TPM_ORD_SAVESTATE 152 1062 #define SAVESTATE_RESULT_SIZE 10 1063 1064 static const struct tpm_input_header savestate_header = { 1065 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 1066 .length = cpu_to_be32(10), 1067 .ordinal = cpu_to_be32(TPM_ORD_SAVESTATE) 1068 }; 1069 1070 /* 1071 * We are about to suspend. Save the TPM state 1072 * so that it can be restored. 1073 */ 1074 int tpm_pm_suspend(struct device *dev) 1075 { 1076 struct tpm_chip *chip = dev_get_drvdata(dev); 1077 struct tpm_cmd_t cmd; 1078 int rc, try; 1079 1080 u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 }; 1081 1082 if (chip == NULL) 1083 return -ENODEV; 1084 1085 if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED) 1086 return 0; 1087 1088 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 1089 tpm2_shutdown(chip, TPM2_SU_STATE); 1090 return 0; 1091 } 1092 1093 /* for buggy tpm, flush pcrs with extend to selected dummy */ 1094 if (tpm_suspend_pcr) 1095 rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash, 1096 "extending dummy pcr before suspend"); 1097 1098 /* now do the actual savestate */ 1099 for (try = 0; try < TPM_RETRY; try++) { 1100 cmd.header.in = savestate_header; 1101 rc = tpm_transmit_cmd(chip, NULL, &cmd, SAVESTATE_RESULT_SIZE, 1102 0, 0, NULL); 1103 1104 /* 1105 * If the TPM indicates that it is too busy to respond to 1106 * this command then retry before giving up. It can take 1107 * several seconds for this TPM to be ready. 1108 * 1109 * This can happen if the TPM has already been sent the 1110 * SaveState command before the driver has loaded. TCG 1.2 1111 * specification states that any communication after SaveState 1112 * may cause the TPM to invalidate previously saved state. 1113 */ 1114 if (rc != TPM_WARN_RETRY) 1115 break; 1116 tpm_msleep(TPM_TIMEOUT_RETRY); 1117 } 1118 1119 if (rc) 1120 dev_err(&chip->dev, 1121 "Error (%d) sending savestate before suspend\n", rc); 1122 else if (try > 0) 1123 dev_warn(&chip->dev, "TPM savestate took %dms\n", 1124 try * TPM_TIMEOUT_RETRY); 1125 1126 return rc; 1127 } 1128 EXPORT_SYMBOL_GPL(tpm_pm_suspend); 1129 1130 /* 1131 * Resume from a power safe. The BIOS already restored 1132 * the TPM state. 1133 */ 1134 int tpm_pm_resume(struct device *dev) 1135 { 1136 struct tpm_chip *chip = dev_get_drvdata(dev); 1137 1138 if (chip == NULL) 1139 return -ENODEV; 1140 1141 return 0; 1142 } 1143 EXPORT_SYMBOL_GPL(tpm_pm_resume); 1144 1145 #define TPM_GETRANDOM_RESULT_SIZE 18 1146 static const struct tpm_input_header tpm_getrandom_header = { 1147 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND), 1148 .length = cpu_to_be32(14), 1149 .ordinal = cpu_to_be32(TPM_ORD_GET_RANDOM) 1150 }; 1151 1152 /** 1153 * tpm_get_random() - get random bytes from the TPM's RNG 1154 * @chip: a &struct tpm_chip instance, %NULL for the default chip 1155 * @out: destination buffer for the random bytes 1156 * @max: the max number of bytes to write to @out 1157 * 1158 * Return: same as with tpm_transmit_cmd() 1159 */ 1160 int tpm_get_random(struct tpm_chip *chip, u8 *out, size_t max) 1161 { 1162 struct tpm_cmd_t tpm_cmd; 1163 u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA), rlength; 1164 int err, total = 0, retries = 5; 1165 u8 *dest = out; 1166 1167 if (!out || !num_bytes || max > TPM_MAX_RNG_DATA) 1168 return -EINVAL; 1169 1170 chip = tpm_chip_find_get(chip); 1171 if (!chip) 1172 return -ENODEV; 1173 1174 if (chip->flags & TPM_CHIP_FLAG_TPM2) { 1175 err = tpm2_get_random(chip, out, max); 1176 tpm_put_ops(chip); 1177 return err; 1178 } 1179 1180 do { 1181 tpm_cmd.header.in = tpm_getrandom_header; 1182 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes); 1183 1184 err = tpm_transmit_cmd(chip, NULL, &tpm_cmd, 1185 TPM_GETRANDOM_RESULT_SIZE + num_bytes, 1186 offsetof(struct tpm_getrandom_out, 1187 rng_data), 1188 0, "attempting get random"); 1189 if (err) 1190 break; 1191 1192 recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len); 1193 1194 rlength = be32_to_cpu(tpm_cmd.header.out.length); 1195 if (rlength < offsetof(struct tpm_getrandom_out, rng_data) + 1196 recd) { 1197 total = -EFAULT; 1198 break; 1199 } 1200 memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd); 1201 1202 dest += recd; 1203 total += recd; 1204 num_bytes -= recd; 1205 } while (retries-- && total < max); 1206 1207 tpm_put_ops(chip); 1208 return total ? total : -EIO; 1209 } 1210 EXPORT_SYMBOL_GPL(tpm_get_random); 1211 1212 /** 1213 * tpm_seal_trusted() - seal a trusted key payload 1214 * @chip: a &struct tpm_chip instance, %NULL for the default chip 1215 * @options: authentication values and other options 1216 * @payload: the key data in clear and encrypted form 1217 * 1218 * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in 1219 * the keyring subsystem. 1220 * 1221 * Return: same as with tpm_transmit_cmd() 1222 */ 1223 int tpm_seal_trusted(struct tpm_chip *chip, struct trusted_key_payload *payload, 1224 struct trusted_key_options *options) 1225 { 1226 int rc; 1227 1228 chip = tpm_chip_find_get(chip); 1229 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2)) 1230 return -ENODEV; 1231 1232 rc = tpm2_seal_trusted(chip, payload, options); 1233 1234 tpm_put_ops(chip); 1235 return rc; 1236 } 1237 EXPORT_SYMBOL_GPL(tpm_seal_trusted); 1238 1239 /** 1240 * tpm_unseal_trusted() - unseal a trusted key 1241 * @chip: a &struct tpm_chip instance, %NULL for the default chip 1242 * @options: authentication values and other options 1243 * @payload: the key data in clear and encrypted form 1244 * 1245 * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in 1246 * the keyring subsystem. 1247 * 1248 * Return: same as with tpm_transmit_cmd() 1249 */ 1250 int tpm_unseal_trusted(struct tpm_chip *chip, 1251 struct trusted_key_payload *payload, 1252 struct trusted_key_options *options) 1253 { 1254 int rc; 1255 1256 chip = tpm_chip_find_get(chip); 1257 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2)) 1258 return -ENODEV; 1259 1260 rc = tpm2_unseal_trusted(chip, payload, options); 1261 1262 tpm_put_ops(chip); 1263 1264 return rc; 1265 } 1266 EXPORT_SYMBOL_GPL(tpm_unseal_trusted); 1267 1268 static int __init tpm_init(void) 1269 { 1270 int rc; 1271 1272 tpm_class = class_create(THIS_MODULE, "tpm"); 1273 if (IS_ERR(tpm_class)) { 1274 pr_err("couldn't create tpm class\n"); 1275 return PTR_ERR(tpm_class); 1276 } 1277 1278 tpmrm_class = class_create(THIS_MODULE, "tpmrm"); 1279 if (IS_ERR(tpmrm_class)) { 1280 pr_err("couldn't create tpmrm class\n"); 1281 class_destroy(tpm_class); 1282 return PTR_ERR(tpmrm_class); 1283 } 1284 1285 rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm"); 1286 if (rc < 0) { 1287 pr_err("tpm: failed to allocate char dev region\n"); 1288 class_destroy(tpmrm_class); 1289 class_destroy(tpm_class); 1290 return rc; 1291 } 1292 1293 return 0; 1294 } 1295 1296 static void __exit tpm_exit(void) 1297 { 1298 idr_destroy(&dev_nums_idr); 1299 class_destroy(tpm_class); 1300 class_destroy(tpmrm_class); 1301 unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES); 1302 } 1303 1304 subsys_initcall(tpm_init); 1305 module_exit(tpm_exit); 1306 1307 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); 1308 MODULE_DESCRIPTION("TPM Driver"); 1309 MODULE_VERSION("2.0"); 1310 MODULE_LICENSE("GPL"); 1311