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