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