tpm.c revision 2b30a90f6c358714b9d6e628ac92e514917f93a1
1/* 2 * Copyright (C) 2004 IBM Corporation 3 * 4 * Authors: 5 * Leendert van Doorn <leendert@watson.ibm.com> 6 * Dave Safford <safford@watson.ibm.com> 7 * Reiner Sailer <sailer@watson.ibm.com> 8 * Kylene Hall <kjhall@us.ibm.com> 9 * 10 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 11 * 12 * Device driver for TCG/TCPA TPM (trusted platform module). 13 * Specifications at www.trustedcomputinggroup.org 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License as 17 * published by the Free Software Foundation, version 2 of the 18 * License. 19 * 20 * Note, the TPM chip is not interrupt driven (only polling) 21 * and can have very long timeouts (minutes!). Hence the unusual 22 * calls to msleep. 23 * 24 */ 25 26#include <linux/poll.h> 27#include <linux/slab.h> 28#include <linux/mutex.h> 29#include <linux/spinlock.h> 30 31#include "tpm.h" 32 33enum tpm_const { 34 TPM_MINOR = 224, /* officially assigned */ 35 TPM_BUFSIZE = 4096, 36 TPM_NUM_DEVICES = 256, 37}; 38 39enum tpm_duration { 40 TPM_SHORT = 0, 41 TPM_MEDIUM = 1, 42 TPM_LONG = 2, 43 TPM_UNDEFINED, 44}; 45 46#define TPM_MAX_ORDINAL 243 47#define TPM_MAX_PROTECTED_ORDINAL 12 48#define TPM_PROTECTED_ORDINAL_MASK 0xFF 49 50/* 51 * Bug workaround - some TPM's don't flush the most 52 * recently changed pcr on suspend, so force the flush 53 * with an extend to the selected _unused_ non-volatile pcr. 54 */ 55static int tpm_suspend_pcr; 56module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644); 57MODULE_PARM_DESC(suspend_pcr, 58 "PCR to use for dummy writes to faciltate flush on suspend."); 59 60static LIST_HEAD(tpm_chip_list); 61static DEFINE_SPINLOCK(driver_lock); 62static DECLARE_BITMAP(dev_mask, TPM_NUM_DEVICES); 63 64/* 65 * Array with one entry per ordinal defining the maximum amount 66 * of time the chip could take to return the result. The ordinal 67 * designation of short, medium or long is defined in a table in 68 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The 69 * values of the SHORT, MEDIUM, and LONG durations are retrieved 70 * from the chip during initialization with a call to tpm_get_timeouts. 71 */ 72static const u8 tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL] = { 73 TPM_UNDEFINED, /* 0 */ 74 TPM_UNDEFINED, 75 TPM_UNDEFINED, 76 TPM_UNDEFINED, 77 TPM_UNDEFINED, 78 TPM_UNDEFINED, /* 5 */ 79 TPM_UNDEFINED, 80 TPM_UNDEFINED, 81 TPM_UNDEFINED, 82 TPM_UNDEFINED, 83 TPM_SHORT, /* 10 */ 84 TPM_SHORT, 85}; 86 87static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = { 88 TPM_UNDEFINED, /* 0 */ 89 TPM_UNDEFINED, 90 TPM_UNDEFINED, 91 TPM_UNDEFINED, 92 TPM_UNDEFINED, 93 TPM_UNDEFINED, /* 5 */ 94 TPM_UNDEFINED, 95 TPM_UNDEFINED, 96 TPM_UNDEFINED, 97 TPM_UNDEFINED, 98 TPM_SHORT, /* 10 */ 99 TPM_SHORT, 100 TPM_MEDIUM, 101 TPM_LONG, 102 TPM_LONG, 103 TPM_MEDIUM, /* 15 */ 104 TPM_SHORT, 105 TPM_SHORT, 106 TPM_MEDIUM, 107 TPM_LONG, 108 TPM_SHORT, /* 20 */ 109 TPM_SHORT, 110 TPM_MEDIUM, 111 TPM_MEDIUM, 112 TPM_MEDIUM, 113 TPM_SHORT, /* 25 */ 114 TPM_SHORT, 115 TPM_MEDIUM, 116 TPM_SHORT, 117 TPM_SHORT, 118 TPM_MEDIUM, /* 30 */ 119 TPM_LONG, 120 TPM_MEDIUM, 121 TPM_SHORT, 122 TPM_SHORT, 123 TPM_SHORT, /* 35 */ 124 TPM_MEDIUM, 125 TPM_MEDIUM, 126 TPM_UNDEFINED, 127 TPM_UNDEFINED, 128 TPM_MEDIUM, /* 40 */ 129 TPM_LONG, 130 TPM_MEDIUM, 131 TPM_SHORT, 132 TPM_SHORT, 133 TPM_SHORT, /* 45 */ 134 TPM_SHORT, 135 TPM_SHORT, 136 TPM_SHORT, 137 TPM_LONG, 138 TPM_MEDIUM, /* 50 */ 139 TPM_MEDIUM, 140 TPM_UNDEFINED, 141 TPM_UNDEFINED, 142 TPM_UNDEFINED, 143 TPM_UNDEFINED, /* 55 */ 144 TPM_UNDEFINED, 145 TPM_UNDEFINED, 146 TPM_UNDEFINED, 147 TPM_UNDEFINED, 148 TPM_MEDIUM, /* 60 */ 149 TPM_MEDIUM, 150 TPM_MEDIUM, 151 TPM_SHORT, 152 TPM_SHORT, 153 TPM_MEDIUM, /* 65 */ 154 TPM_UNDEFINED, 155 TPM_UNDEFINED, 156 TPM_UNDEFINED, 157 TPM_UNDEFINED, 158 TPM_SHORT, /* 70 */ 159 TPM_SHORT, 160 TPM_UNDEFINED, 161 TPM_UNDEFINED, 162 TPM_UNDEFINED, 163 TPM_UNDEFINED, /* 75 */ 164 TPM_UNDEFINED, 165 TPM_UNDEFINED, 166 TPM_UNDEFINED, 167 TPM_UNDEFINED, 168 TPM_LONG, /* 80 */ 169 TPM_UNDEFINED, 170 TPM_MEDIUM, 171 TPM_LONG, 172 TPM_SHORT, 173 TPM_UNDEFINED, /* 85 */ 174 TPM_UNDEFINED, 175 TPM_UNDEFINED, 176 TPM_UNDEFINED, 177 TPM_UNDEFINED, 178 TPM_SHORT, /* 90 */ 179 TPM_SHORT, 180 TPM_SHORT, 181 TPM_SHORT, 182 TPM_SHORT, 183 TPM_UNDEFINED, /* 95 */ 184 TPM_UNDEFINED, 185 TPM_UNDEFINED, 186 TPM_UNDEFINED, 187 TPM_UNDEFINED, 188 TPM_MEDIUM, /* 100 */ 189 TPM_SHORT, 190 TPM_SHORT, 191 TPM_UNDEFINED, 192 TPM_UNDEFINED, 193 TPM_UNDEFINED, /* 105 */ 194 TPM_UNDEFINED, 195 TPM_UNDEFINED, 196 TPM_UNDEFINED, 197 TPM_UNDEFINED, 198 TPM_SHORT, /* 110 */ 199 TPM_SHORT, 200 TPM_SHORT, 201 TPM_SHORT, 202 TPM_SHORT, 203 TPM_SHORT, /* 115 */ 204 TPM_SHORT, 205 TPM_SHORT, 206 TPM_UNDEFINED, 207 TPM_UNDEFINED, 208 TPM_LONG, /* 120 */ 209 TPM_LONG, 210 TPM_MEDIUM, 211 TPM_UNDEFINED, 212 TPM_SHORT, 213 TPM_SHORT, /* 125 */ 214 TPM_SHORT, 215 TPM_LONG, 216 TPM_SHORT, 217 TPM_SHORT, 218 TPM_SHORT, /* 130 */ 219 TPM_MEDIUM, 220 TPM_UNDEFINED, 221 TPM_SHORT, 222 TPM_MEDIUM, 223 TPM_UNDEFINED, /* 135 */ 224 TPM_UNDEFINED, 225 TPM_UNDEFINED, 226 TPM_UNDEFINED, 227 TPM_UNDEFINED, 228 TPM_SHORT, /* 140 */ 229 TPM_SHORT, 230 TPM_UNDEFINED, 231 TPM_UNDEFINED, 232 TPM_UNDEFINED, 233 TPM_UNDEFINED, /* 145 */ 234 TPM_UNDEFINED, 235 TPM_UNDEFINED, 236 TPM_UNDEFINED, 237 TPM_UNDEFINED, 238 TPM_SHORT, /* 150 */ 239 TPM_MEDIUM, 240 TPM_MEDIUM, 241 TPM_SHORT, 242 TPM_SHORT, 243 TPM_UNDEFINED, /* 155 */ 244 TPM_UNDEFINED, 245 TPM_UNDEFINED, 246 TPM_UNDEFINED, 247 TPM_UNDEFINED, 248 TPM_SHORT, /* 160 */ 249 TPM_SHORT, 250 TPM_SHORT, 251 TPM_SHORT, 252 TPM_UNDEFINED, 253 TPM_UNDEFINED, /* 165 */ 254 TPM_UNDEFINED, 255 TPM_UNDEFINED, 256 TPM_UNDEFINED, 257 TPM_UNDEFINED, 258 TPM_LONG, /* 170 */ 259 TPM_UNDEFINED, 260 TPM_UNDEFINED, 261 TPM_UNDEFINED, 262 TPM_UNDEFINED, 263 TPM_UNDEFINED, /* 175 */ 264 TPM_UNDEFINED, 265 TPM_UNDEFINED, 266 TPM_UNDEFINED, 267 TPM_UNDEFINED, 268 TPM_MEDIUM, /* 180 */ 269 TPM_SHORT, 270 TPM_MEDIUM, 271 TPM_MEDIUM, 272 TPM_MEDIUM, 273 TPM_MEDIUM, /* 185 */ 274 TPM_SHORT, 275 TPM_UNDEFINED, 276 TPM_UNDEFINED, 277 TPM_UNDEFINED, 278 TPM_UNDEFINED, /* 190 */ 279 TPM_UNDEFINED, 280 TPM_UNDEFINED, 281 TPM_UNDEFINED, 282 TPM_UNDEFINED, 283 TPM_UNDEFINED, /* 195 */ 284 TPM_UNDEFINED, 285 TPM_UNDEFINED, 286 TPM_UNDEFINED, 287 TPM_UNDEFINED, 288 TPM_SHORT, /* 200 */ 289 TPM_UNDEFINED, 290 TPM_UNDEFINED, 291 TPM_UNDEFINED, 292 TPM_SHORT, 293 TPM_SHORT, /* 205 */ 294 TPM_SHORT, 295 TPM_SHORT, 296 TPM_SHORT, 297 TPM_SHORT, 298 TPM_MEDIUM, /* 210 */ 299 TPM_UNDEFINED, 300 TPM_MEDIUM, 301 TPM_MEDIUM, 302 TPM_MEDIUM, 303 TPM_UNDEFINED, /* 215 */ 304 TPM_MEDIUM, 305 TPM_UNDEFINED, 306 TPM_UNDEFINED, 307 TPM_SHORT, 308 TPM_SHORT, /* 220 */ 309 TPM_SHORT, 310 TPM_SHORT, 311 TPM_SHORT, 312 TPM_SHORT, 313 TPM_UNDEFINED, /* 225 */ 314 TPM_UNDEFINED, 315 TPM_UNDEFINED, 316 TPM_UNDEFINED, 317 TPM_UNDEFINED, 318 TPM_SHORT, /* 230 */ 319 TPM_LONG, 320 TPM_MEDIUM, 321 TPM_UNDEFINED, 322 TPM_UNDEFINED, 323 TPM_UNDEFINED, /* 235 */ 324 TPM_UNDEFINED, 325 TPM_UNDEFINED, 326 TPM_UNDEFINED, 327 TPM_UNDEFINED, 328 TPM_SHORT, /* 240 */ 329 TPM_UNDEFINED, 330 TPM_MEDIUM, 331}; 332 333static void user_reader_timeout(unsigned long ptr) 334{ 335 struct tpm_chip *chip = (struct tpm_chip *) ptr; 336 337 schedule_work(&chip->work); 338} 339 340static void timeout_work(struct work_struct *work) 341{ 342 struct tpm_chip *chip = container_of(work, struct tpm_chip, work); 343 344 mutex_lock(&chip->buffer_mutex); 345 atomic_set(&chip->data_pending, 0); 346 memset(chip->data_buffer, 0, TPM_BUFSIZE); 347 mutex_unlock(&chip->buffer_mutex); 348} 349 350/* 351 * Returns max number of jiffies to wait 352 */ 353unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, 354 u32 ordinal) 355{ 356 int duration_idx = TPM_UNDEFINED; 357 int duration = 0; 358 359 if (ordinal < TPM_MAX_ORDINAL) 360 duration_idx = tpm_ordinal_duration[ordinal]; 361 else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) < 362 TPM_MAX_PROTECTED_ORDINAL) 363 duration_idx = 364 tpm_protected_ordinal_duration[ordinal & 365 TPM_PROTECTED_ORDINAL_MASK]; 366 367 if (duration_idx != TPM_UNDEFINED) 368 duration = chip->vendor.duration[duration_idx]; 369 if (duration <= 0) 370 return 2 * 60 * HZ; 371 else 372 return duration; 373} 374EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration); 375 376/* 377 * Internal kernel interface to transmit TPM commands 378 */ 379static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf, 380 size_t bufsiz) 381{ 382 ssize_t rc; 383 u32 count, ordinal; 384 unsigned long stop; 385 386 count = be32_to_cpu(*((__be32 *) (buf + 2))); 387 ordinal = be32_to_cpu(*((__be32 *) (buf + 6))); 388 if (count == 0) 389 return -ENODATA; 390 if (count > bufsiz) { 391 dev_err(chip->dev, 392 "invalid count value %x %zx \n", count, bufsiz); 393 return -E2BIG; 394 } 395 396 mutex_lock(&chip->tpm_mutex); 397 398 if ((rc = chip->vendor.send(chip, (u8 *) buf, count)) < 0) { 399 dev_err(chip->dev, 400 "tpm_transmit: tpm_send: error %zd\n", rc); 401 goto out; 402 } 403 404 if (chip->vendor.irq) 405 goto out_recv; 406 407 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal); 408 do { 409 u8 status = chip->vendor.status(chip); 410 if ((status & chip->vendor.req_complete_mask) == 411 chip->vendor.req_complete_val) 412 goto out_recv; 413 414 if ((status == chip->vendor.req_canceled)) { 415 dev_err(chip->dev, "Operation Canceled\n"); 416 rc = -ECANCELED; 417 goto out; 418 } 419 420 msleep(TPM_TIMEOUT); /* CHECK */ 421 rmb(); 422 } while (time_before(jiffies, stop)); 423 424 chip->vendor.cancel(chip); 425 dev_err(chip->dev, "Operation Timed out\n"); 426 rc = -ETIME; 427 goto out; 428 429out_recv: 430 rc = chip->vendor.recv(chip, (u8 *) buf, bufsiz); 431 if (rc < 0) 432 dev_err(chip->dev, 433 "tpm_transmit: tpm_recv: error %zd\n", rc); 434out: 435 mutex_unlock(&chip->tpm_mutex); 436 return rc; 437} 438 439#define TPM_DIGEST_SIZE 20 440#define TPM_ERROR_SIZE 10 441#define TPM_RET_CODE_IDX 6 442 443enum tpm_capabilities { 444 TPM_CAP_FLAG = cpu_to_be32(4), 445 TPM_CAP_PROP = cpu_to_be32(5), 446 CAP_VERSION_1_1 = cpu_to_be32(0x06), 447 CAP_VERSION_1_2 = cpu_to_be32(0x1A) 448}; 449 450enum tpm_sub_capabilities { 451 TPM_CAP_PROP_PCR = cpu_to_be32(0x101), 452 TPM_CAP_PROP_MANUFACTURER = cpu_to_be32(0x103), 453 TPM_CAP_FLAG_PERM = cpu_to_be32(0x108), 454 TPM_CAP_FLAG_VOL = cpu_to_be32(0x109), 455 TPM_CAP_PROP_OWNER = cpu_to_be32(0x111), 456 TPM_CAP_PROP_TIS_TIMEOUT = cpu_to_be32(0x115), 457 TPM_CAP_PROP_TIS_DURATION = cpu_to_be32(0x120), 458 459}; 460 461static ssize_t transmit_cmd(struct tpm_chip *chip, struct tpm_cmd_t *cmd, 462 int len, const char *desc) 463{ 464 int err; 465 466 len = tpm_transmit(chip,(u8 *) cmd, len); 467 if (len < 0) 468 return len; 469 if (len == TPM_ERROR_SIZE) { 470 err = be32_to_cpu(cmd->header.out.return_code); 471 dev_dbg(chip->dev, "A TPM error (%d) occurred %s\n", err, desc); 472 return err; 473 } 474 return 0; 475} 476 477#define TPM_INTERNAL_RESULT_SIZE 200 478#define TPM_TAG_RQU_COMMAND cpu_to_be16(193) 479#define TPM_ORD_GET_CAP cpu_to_be32(101) 480 481static const struct tpm_input_header tpm_getcap_header = { 482 .tag = TPM_TAG_RQU_COMMAND, 483 .length = cpu_to_be32(22), 484 .ordinal = TPM_ORD_GET_CAP 485}; 486 487ssize_t tpm_getcap(struct device *dev, __be32 subcap_id, cap_t *cap, 488 const char *desc) 489{ 490 struct tpm_cmd_t tpm_cmd; 491 int rc; 492 struct tpm_chip *chip = dev_get_drvdata(dev); 493 494 tpm_cmd.header.in = tpm_getcap_header; 495 if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) { 496 tpm_cmd.params.getcap_in.cap = subcap_id; 497 /*subcap field not necessary */ 498 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0); 499 tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32)); 500 } else { 501 if (subcap_id == TPM_CAP_FLAG_PERM || 502 subcap_id == TPM_CAP_FLAG_VOL) 503 tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG; 504 else 505 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; 506 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); 507 tpm_cmd.params.getcap_in.subcap = subcap_id; 508 } 509 rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc); 510 if (!rc) 511 *cap = tpm_cmd.params.getcap_out.cap; 512 return rc; 513} 514 515void tpm_gen_interrupt(struct tpm_chip *chip) 516{ 517 struct tpm_cmd_t tpm_cmd; 518 ssize_t rc; 519 520 tpm_cmd.header.in = tpm_getcap_header; 521 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; 522 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); 523 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT; 524 525 rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 526 "attempting to determine the timeouts"); 527} 528EXPORT_SYMBOL_GPL(tpm_gen_interrupt); 529 530int tpm_get_timeouts(struct tpm_chip *chip) 531{ 532 struct tpm_cmd_t tpm_cmd; 533 struct timeout_t *timeout_cap; 534 struct duration_t *duration_cap; 535 ssize_t rc; 536 u32 timeout; 537 unsigned int scale = 1; 538 539 tpm_cmd.header.in = tpm_getcap_header; 540 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; 541 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); 542 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT; 543 544 rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 545 "attempting to determine the timeouts"); 546 if (rc) 547 goto duration; 548 549 if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || 550 be32_to_cpu(tpm_cmd.header.out.length) 551 != sizeof(tpm_cmd.header.out) + sizeof(u32) + 4 * sizeof(u32)) 552 return -EINVAL; 553 554 timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout; 555 /* Don't overwrite default if value is 0 */ 556 timeout = be32_to_cpu(timeout_cap->a); 557 if (timeout && timeout < 1000) { 558 /* timeouts in msec rather usec */ 559 scale = 1000; 560 chip->vendor.timeout_adjusted = true; 561 } 562 if (timeout) 563 chip->vendor.timeout_a = usecs_to_jiffies(timeout * scale); 564 timeout = be32_to_cpu(timeout_cap->b); 565 if (timeout) 566 chip->vendor.timeout_b = usecs_to_jiffies(timeout * scale); 567 timeout = be32_to_cpu(timeout_cap->c); 568 if (timeout) 569 chip->vendor.timeout_c = usecs_to_jiffies(timeout * scale); 570 timeout = be32_to_cpu(timeout_cap->d); 571 if (timeout) 572 chip->vendor.timeout_d = usecs_to_jiffies(timeout * scale); 573 574duration: 575 tpm_cmd.header.in = tpm_getcap_header; 576 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; 577 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); 578 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION; 579 580 rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 581 "attempting to determine the durations"); 582 if (rc) 583 return rc; 584 585 if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || 586 be32_to_cpu(tpm_cmd.header.out.length) 587 != sizeof(tpm_cmd.header.out) + sizeof(u32) + 3 * sizeof(u32)) 588 return -EINVAL; 589 590 duration_cap = &tpm_cmd.params.getcap_out.cap.duration; 591 chip->vendor.duration[TPM_SHORT] = 592 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_short)); 593 chip->vendor.duration[TPM_MEDIUM] = 594 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_medium)); 595 chip->vendor.duration[TPM_LONG] = 596 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_long)); 597 598 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above 599 * value wrong and apparently reports msecs rather than usecs. So we 600 * fix up the resulting too-small TPM_SHORT value to make things work. 601 * We also scale the TPM_MEDIUM and -_LONG values by 1000. 602 */ 603 if (chip->vendor.duration[TPM_SHORT] < (HZ / 100)) { 604 chip->vendor.duration[TPM_SHORT] = HZ; 605 chip->vendor.duration[TPM_MEDIUM] *= 1000; 606 chip->vendor.duration[TPM_LONG] *= 1000; 607 chip->vendor.duration_adjusted = true; 608 dev_info(chip->dev, "Adjusting TPM timeout parameters."); 609 } 610 return 0; 611} 612EXPORT_SYMBOL_GPL(tpm_get_timeouts); 613 614void tpm_continue_selftest(struct tpm_chip *chip) 615{ 616 u8 data[] = { 617 0, 193, /* TPM_TAG_RQU_COMMAND */ 618 0, 0, 0, 10, /* length */ 619 0, 0, 0, 83, /* TPM_ORD_ContinueSelfTest */ 620 }; 621 622 tpm_transmit(chip, data, sizeof(data)); 623} 624EXPORT_SYMBOL_GPL(tpm_continue_selftest); 625 626ssize_t tpm_show_enabled(struct device * dev, struct device_attribute * attr, 627 char *buf) 628{ 629 cap_t cap; 630 ssize_t rc; 631 632 rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap, 633 "attempting to determine the permanent enabled state"); 634 if (rc) 635 return 0; 636 637 rc = sprintf(buf, "%d\n", !cap.perm_flags.disable); 638 return rc; 639} 640EXPORT_SYMBOL_GPL(tpm_show_enabled); 641 642ssize_t tpm_show_active(struct device * dev, struct device_attribute * attr, 643 char *buf) 644{ 645 cap_t cap; 646 ssize_t rc; 647 648 rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap, 649 "attempting to determine the permanent active state"); 650 if (rc) 651 return 0; 652 653 rc = sprintf(buf, "%d\n", !cap.perm_flags.deactivated); 654 return rc; 655} 656EXPORT_SYMBOL_GPL(tpm_show_active); 657 658ssize_t tpm_show_owned(struct device * dev, struct device_attribute * attr, 659 char *buf) 660{ 661 cap_t cap; 662 ssize_t rc; 663 664 rc = tpm_getcap(dev, TPM_CAP_PROP_OWNER, &cap, 665 "attempting to determine the owner state"); 666 if (rc) 667 return 0; 668 669 rc = sprintf(buf, "%d\n", cap.owned); 670 return rc; 671} 672EXPORT_SYMBOL_GPL(tpm_show_owned); 673 674ssize_t tpm_show_temp_deactivated(struct device * dev, 675 struct device_attribute * attr, char *buf) 676{ 677 cap_t cap; 678 ssize_t rc; 679 680 rc = tpm_getcap(dev, TPM_CAP_FLAG_VOL, &cap, 681 "attempting to determine the temporary state"); 682 if (rc) 683 return 0; 684 685 rc = sprintf(buf, "%d\n", cap.stclear_flags.deactivated); 686 return rc; 687} 688EXPORT_SYMBOL_GPL(tpm_show_temp_deactivated); 689 690/* 691 * tpm_chip_find_get - return tpm_chip for given chip number 692 */ 693static struct tpm_chip *tpm_chip_find_get(int chip_num) 694{ 695 struct tpm_chip *pos, *chip = NULL; 696 697 rcu_read_lock(); 698 list_for_each_entry_rcu(pos, &tpm_chip_list, list) { 699 if (chip_num != TPM_ANY_NUM && chip_num != pos->dev_num) 700 continue; 701 702 if (try_module_get(pos->dev->driver->owner)) { 703 chip = pos; 704 break; 705 } 706 } 707 rcu_read_unlock(); 708 return chip; 709} 710 711#define TPM_ORDINAL_PCRREAD cpu_to_be32(21) 712#define READ_PCR_RESULT_SIZE 30 713static struct tpm_input_header pcrread_header = { 714 .tag = TPM_TAG_RQU_COMMAND, 715 .length = cpu_to_be32(14), 716 .ordinal = TPM_ORDINAL_PCRREAD 717}; 718 719int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf) 720{ 721 int rc; 722 struct tpm_cmd_t cmd; 723 724 cmd.header.in = pcrread_header; 725 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx); 726 rc = transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE, 727 "attempting to read a pcr value"); 728 729 if (rc == 0) 730 memcpy(res_buf, cmd.params.pcrread_out.pcr_result, 731 TPM_DIGEST_SIZE); 732 return rc; 733} 734 735/** 736 * tpm_pcr_read - read a pcr value 737 * @chip_num: tpm idx # or ANY 738 * @pcr_idx: pcr idx to retrieve 739 * @res_buf: TPM_PCR value 740 * size of res_buf is 20 bytes (or NULL if you don't care) 741 * 742 * The TPM driver should be built-in, but for whatever reason it 743 * isn't, protect against the chip disappearing, by incrementing 744 * the module usage count. 745 */ 746int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf) 747{ 748 struct tpm_chip *chip; 749 int rc; 750 751 chip = tpm_chip_find_get(chip_num); 752 if (chip == NULL) 753 return -ENODEV; 754 rc = __tpm_pcr_read(chip, pcr_idx, res_buf); 755 tpm_chip_put(chip); 756 return rc; 757} 758EXPORT_SYMBOL_GPL(tpm_pcr_read); 759 760/** 761 * tpm_pcr_extend - extend pcr value with hash 762 * @chip_num: tpm idx # or AN& 763 * @pcr_idx: pcr idx to extend 764 * @hash: hash value used to extend pcr value 765 * 766 * The TPM driver should be built-in, but for whatever reason it 767 * isn't, protect against the chip disappearing, by incrementing 768 * the module usage count. 769 */ 770#define TPM_ORD_PCR_EXTEND cpu_to_be32(20) 771#define EXTEND_PCR_RESULT_SIZE 34 772static struct tpm_input_header pcrextend_header = { 773 .tag = TPM_TAG_RQU_COMMAND, 774 .length = cpu_to_be32(34), 775 .ordinal = TPM_ORD_PCR_EXTEND 776}; 777 778int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash) 779{ 780 struct tpm_cmd_t cmd; 781 int rc; 782 struct tpm_chip *chip; 783 784 chip = tpm_chip_find_get(chip_num); 785 if (chip == NULL) 786 return -ENODEV; 787 788 cmd.header.in = pcrextend_header; 789 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx); 790 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE); 791 rc = transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 792 "attempting extend a PCR value"); 793 794 tpm_chip_put(chip); 795 return rc; 796} 797EXPORT_SYMBOL_GPL(tpm_pcr_extend); 798 799int tpm_send(u32 chip_num, void *cmd, size_t buflen) 800{ 801 struct tpm_chip *chip; 802 int rc; 803 804 chip = tpm_chip_find_get(chip_num); 805 if (chip == NULL) 806 return -ENODEV; 807 808 rc = transmit_cmd(chip, cmd, buflen, "attempting tpm_cmd"); 809 810 tpm_chip_put(chip); 811 return rc; 812} 813EXPORT_SYMBOL_GPL(tpm_send); 814 815ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr, 816 char *buf) 817{ 818 cap_t cap; 819 u8 digest[TPM_DIGEST_SIZE]; 820 ssize_t rc; 821 int i, j, num_pcrs; 822 char *str = buf; 823 struct tpm_chip *chip = dev_get_drvdata(dev); 824 825 rc = tpm_getcap(dev, TPM_CAP_PROP_PCR, &cap, 826 "attempting to determine the number of PCRS"); 827 if (rc) 828 return 0; 829 830 num_pcrs = be32_to_cpu(cap.num_pcrs); 831 for (i = 0; i < num_pcrs; i++) { 832 rc = __tpm_pcr_read(chip, i, digest); 833 if (rc) 834 break; 835 str += sprintf(str, "PCR-%02d: ", i); 836 for (j = 0; j < TPM_DIGEST_SIZE; j++) 837 str += sprintf(str, "%02X ", digest[j]); 838 str += sprintf(str, "\n"); 839 } 840 return str - buf; 841} 842EXPORT_SYMBOL_GPL(tpm_show_pcrs); 843 844#define READ_PUBEK_RESULT_SIZE 314 845#define TPM_ORD_READPUBEK cpu_to_be32(124) 846struct tpm_input_header tpm_readpubek_header = { 847 .tag = TPM_TAG_RQU_COMMAND, 848 .length = cpu_to_be32(30), 849 .ordinal = TPM_ORD_READPUBEK 850}; 851 852ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr, 853 char *buf) 854{ 855 u8 *data; 856 struct tpm_cmd_t tpm_cmd; 857 ssize_t err; 858 int i, rc; 859 char *str = buf; 860 861 struct tpm_chip *chip = dev_get_drvdata(dev); 862 863 tpm_cmd.header.in = tpm_readpubek_header; 864 err = transmit_cmd(chip, &tpm_cmd, READ_PUBEK_RESULT_SIZE, 865 "attempting to read the PUBEK"); 866 if (err) 867 goto out; 868 869 /* 870 ignore header 10 bytes 871 algorithm 32 bits (1 == RSA ) 872 encscheme 16 bits 873 sigscheme 16 bits 874 parameters (RSA 12->bytes: keybit, #primes, expbit) 875 keylenbytes 32 bits 876 256 byte modulus 877 ignore checksum 20 bytes 878 */ 879 data = tpm_cmd.params.readpubek_out_buffer; 880 str += 881 sprintf(str, 882 "Algorithm: %02X %02X %02X %02X\n" 883 "Encscheme: %02X %02X\n" 884 "Sigscheme: %02X %02X\n" 885 "Parameters: %02X %02X %02X %02X " 886 "%02X %02X %02X %02X " 887 "%02X %02X %02X %02X\n" 888 "Modulus length: %d\n" 889 "Modulus:\n", 890 data[0], data[1], data[2], data[3], 891 data[4], data[5], 892 data[6], data[7], 893 data[12], data[13], data[14], data[15], 894 data[16], data[17], data[18], data[19], 895 data[20], data[21], data[22], data[23], 896 be32_to_cpu(*((__be32 *) (data + 24)))); 897 898 for (i = 0; i < 256; i++) { 899 str += sprintf(str, "%02X ", data[i + 28]); 900 if ((i + 1) % 16 == 0) 901 str += sprintf(str, "\n"); 902 } 903out: 904 rc = str - buf; 905 return rc; 906} 907EXPORT_SYMBOL_GPL(tpm_show_pubek); 908 909 910ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr, 911 char *buf) 912{ 913 cap_t cap; 914 ssize_t rc; 915 char *str = buf; 916 917 rc = tpm_getcap(dev, TPM_CAP_PROP_MANUFACTURER, &cap, 918 "attempting to determine the manufacturer"); 919 if (rc) 920 return 0; 921 str += sprintf(str, "Manufacturer: 0x%x\n", 922 be32_to_cpu(cap.manufacturer_id)); 923 924 rc = tpm_getcap(dev, CAP_VERSION_1_1, &cap, 925 "attempting to determine the 1.1 version"); 926 if (rc) 927 return 0; 928 str += sprintf(str, 929 "TCG version: %d.%d\nFirmware version: %d.%d\n", 930 cap.tpm_version.Major, cap.tpm_version.Minor, 931 cap.tpm_version.revMajor, cap.tpm_version.revMinor); 932 return str - buf; 933} 934EXPORT_SYMBOL_GPL(tpm_show_caps); 935 936ssize_t tpm_show_caps_1_2(struct device * dev, 937 struct device_attribute * attr, char *buf) 938{ 939 cap_t cap; 940 ssize_t rc; 941 char *str = buf; 942 943 rc = tpm_getcap(dev, TPM_CAP_PROP_MANUFACTURER, &cap, 944 "attempting to determine the manufacturer"); 945 if (rc) 946 return 0; 947 str += sprintf(str, "Manufacturer: 0x%x\n", 948 be32_to_cpu(cap.manufacturer_id)); 949 rc = tpm_getcap(dev, CAP_VERSION_1_2, &cap, 950 "attempting to determine the 1.2 version"); 951 if (rc) 952 return 0; 953 str += sprintf(str, 954 "TCG version: %d.%d\nFirmware version: %d.%d\n", 955 cap.tpm_version_1_2.Major, cap.tpm_version_1_2.Minor, 956 cap.tpm_version_1_2.revMajor, 957 cap.tpm_version_1_2.revMinor); 958 return str - buf; 959} 960EXPORT_SYMBOL_GPL(tpm_show_caps_1_2); 961 962ssize_t tpm_show_durations(struct device *dev, struct device_attribute *attr, 963 char *buf) 964{ 965 struct tpm_chip *chip = dev_get_drvdata(dev); 966 967 if (chip->vendor.duration[TPM_LONG] == 0) 968 return 0; 969 970 return sprintf(buf, "%d %d %d [%s]\n", 971 jiffies_to_usecs(chip->vendor.duration[TPM_SHORT]), 972 jiffies_to_usecs(chip->vendor.duration[TPM_MEDIUM]), 973 jiffies_to_usecs(chip->vendor.duration[TPM_LONG]), 974 chip->vendor.duration_adjusted 975 ? "adjusted" : "original"); 976} 977EXPORT_SYMBOL_GPL(tpm_show_durations); 978 979ssize_t tpm_show_timeouts(struct device *dev, struct device_attribute *attr, 980 char *buf) 981{ 982 struct tpm_chip *chip = dev_get_drvdata(dev); 983 984 return sprintf(buf, "%d %d %d %d [%s]\n", 985 jiffies_to_usecs(chip->vendor.timeout_a), 986 jiffies_to_usecs(chip->vendor.timeout_b), 987 jiffies_to_usecs(chip->vendor.timeout_c), 988 jiffies_to_usecs(chip->vendor.timeout_d), 989 chip->vendor.timeout_adjusted 990 ? "adjusted" : "original"); 991} 992EXPORT_SYMBOL_GPL(tpm_show_timeouts); 993 994ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr, 995 const char *buf, size_t count) 996{ 997 struct tpm_chip *chip = dev_get_drvdata(dev); 998 if (chip == NULL) 999 return 0; 1000 1001 chip->vendor.cancel(chip); 1002 return count; 1003} 1004EXPORT_SYMBOL_GPL(tpm_store_cancel); 1005 1006/* 1007 * Device file system interface to the TPM 1008 * 1009 * It's assured that the chip will be opened just once, 1010 * by the check of is_open variable, which is protected 1011 * by driver_lock. 1012 */ 1013int tpm_open(struct inode *inode, struct file *file) 1014{ 1015 int minor = iminor(inode); 1016 struct tpm_chip *chip = NULL, *pos; 1017 1018 rcu_read_lock(); 1019 list_for_each_entry_rcu(pos, &tpm_chip_list, list) { 1020 if (pos->vendor.miscdev.minor == minor) { 1021 chip = pos; 1022 get_device(chip->dev); 1023 break; 1024 } 1025 } 1026 rcu_read_unlock(); 1027 1028 if (!chip) 1029 return -ENODEV; 1030 1031 if (test_and_set_bit(0, &chip->is_open)) { 1032 dev_dbg(chip->dev, "Another process owns this TPM\n"); 1033 put_device(chip->dev); 1034 return -EBUSY; 1035 } 1036 1037 chip->data_buffer = kzalloc(TPM_BUFSIZE, GFP_KERNEL); 1038 if (chip->data_buffer == NULL) { 1039 clear_bit(0, &chip->is_open); 1040 put_device(chip->dev); 1041 return -ENOMEM; 1042 } 1043 1044 atomic_set(&chip->data_pending, 0); 1045 1046 file->private_data = chip; 1047 return 0; 1048} 1049EXPORT_SYMBOL_GPL(tpm_open); 1050 1051/* 1052 * Called on file close 1053 */ 1054int tpm_release(struct inode *inode, struct file *file) 1055{ 1056 struct tpm_chip *chip = file->private_data; 1057 1058 del_singleshot_timer_sync(&chip->user_read_timer); 1059 flush_work_sync(&chip->work); 1060 file->private_data = NULL; 1061 atomic_set(&chip->data_pending, 0); 1062 kfree(chip->data_buffer); 1063 clear_bit(0, &chip->is_open); 1064 put_device(chip->dev); 1065 return 0; 1066} 1067EXPORT_SYMBOL_GPL(tpm_release); 1068 1069ssize_t tpm_write(struct file *file, const char __user *buf, 1070 size_t size, loff_t *off) 1071{ 1072 struct tpm_chip *chip = file->private_data; 1073 size_t in_size = size, out_size; 1074 1075 /* cannot perform a write until the read has cleared 1076 either via tpm_read or a user_read_timer timeout */ 1077 while (atomic_read(&chip->data_pending) != 0) 1078 msleep(TPM_TIMEOUT); 1079 1080 mutex_lock(&chip->buffer_mutex); 1081 1082 if (in_size > TPM_BUFSIZE) 1083 in_size = TPM_BUFSIZE; 1084 1085 if (copy_from_user 1086 (chip->data_buffer, (void __user *) buf, in_size)) { 1087 mutex_unlock(&chip->buffer_mutex); 1088 return -EFAULT; 1089 } 1090 1091 /* atomic tpm command send and result receive */ 1092 out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE); 1093 1094 atomic_set(&chip->data_pending, out_size); 1095 mutex_unlock(&chip->buffer_mutex); 1096 1097 /* Set a timeout by which the reader must come claim the result */ 1098 mod_timer(&chip->user_read_timer, jiffies + (60 * HZ)); 1099 1100 return in_size; 1101} 1102EXPORT_SYMBOL_GPL(tpm_write); 1103 1104ssize_t tpm_read(struct file *file, char __user *buf, 1105 size_t size, loff_t *off) 1106{ 1107 struct tpm_chip *chip = file->private_data; 1108 ssize_t ret_size; 1109 1110 del_singleshot_timer_sync(&chip->user_read_timer); 1111 flush_work_sync(&chip->work); 1112 ret_size = atomic_read(&chip->data_pending); 1113 atomic_set(&chip->data_pending, 0); 1114 if (ret_size > 0) { /* relay data */ 1115 if (size < ret_size) 1116 ret_size = size; 1117 1118 mutex_lock(&chip->buffer_mutex); 1119 if (copy_to_user(buf, chip->data_buffer, ret_size)) 1120 ret_size = -EFAULT; 1121 mutex_unlock(&chip->buffer_mutex); 1122 } 1123 1124 return ret_size; 1125} 1126EXPORT_SYMBOL_GPL(tpm_read); 1127 1128void tpm_remove_hardware(struct device *dev) 1129{ 1130 struct tpm_chip *chip = dev_get_drvdata(dev); 1131 1132 if (chip == NULL) { 1133 dev_err(dev, "No device data found\n"); 1134 return; 1135 } 1136 1137 spin_lock(&driver_lock); 1138 list_del_rcu(&chip->list); 1139 spin_unlock(&driver_lock); 1140 synchronize_rcu(); 1141 1142 misc_deregister(&chip->vendor.miscdev); 1143 sysfs_remove_group(&dev->kobj, chip->vendor.attr_group); 1144 tpm_bios_log_teardown(chip->bios_dir); 1145 1146 /* write it this way to be explicit (chip->dev == dev) */ 1147 put_device(chip->dev); 1148} 1149EXPORT_SYMBOL_GPL(tpm_remove_hardware); 1150 1151#define TPM_ORD_SAVESTATE cpu_to_be32(152) 1152#define SAVESTATE_RESULT_SIZE 10 1153 1154static struct tpm_input_header savestate_header = { 1155 .tag = TPM_TAG_RQU_COMMAND, 1156 .length = cpu_to_be32(10), 1157 .ordinal = TPM_ORD_SAVESTATE 1158}; 1159 1160/* 1161 * We are about to suspend. Save the TPM state 1162 * so that it can be restored. 1163 */ 1164int tpm_pm_suspend(struct device *dev, pm_message_t pm_state) 1165{ 1166 struct tpm_chip *chip = dev_get_drvdata(dev); 1167 struct tpm_cmd_t cmd; 1168 int rc; 1169 1170 u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 }; 1171 1172 if (chip == NULL) 1173 return -ENODEV; 1174 1175 /* for buggy tpm, flush pcrs with extend to selected dummy */ 1176 if (tpm_suspend_pcr) { 1177 cmd.header.in = pcrextend_header; 1178 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr); 1179 memcpy(cmd.params.pcrextend_in.hash, dummy_hash, 1180 TPM_DIGEST_SIZE); 1181 rc = transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 1182 "extending dummy pcr before suspend"); 1183 } 1184 1185 /* now do the actual savestate */ 1186 cmd.header.in = savestate_header; 1187 rc = transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE, 1188 "sending savestate before suspend"); 1189 return rc; 1190} 1191EXPORT_SYMBOL_GPL(tpm_pm_suspend); 1192 1193/* 1194 * Resume from a power safe. The BIOS already restored 1195 * the TPM state. 1196 */ 1197int tpm_pm_resume(struct device *dev) 1198{ 1199 struct tpm_chip *chip = dev_get_drvdata(dev); 1200 1201 if (chip == NULL) 1202 return -ENODEV; 1203 1204 return 0; 1205} 1206EXPORT_SYMBOL_GPL(tpm_pm_resume); 1207 1208/* In case vendor provided release function, call it too.*/ 1209 1210void tpm_dev_vendor_release(struct tpm_chip *chip) 1211{ 1212 if (chip->vendor.release) 1213 chip->vendor.release(chip->dev); 1214 1215 clear_bit(chip->dev_num, dev_mask); 1216 kfree(chip->vendor.miscdev.name); 1217} 1218EXPORT_SYMBOL_GPL(tpm_dev_vendor_release); 1219 1220 1221/* 1222 * Once all references to platform device are down to 0, 1223 * release all allocated structures. 1224 */ 1225void tpm_dev_release(struct device *dev) 1226{ 1227 struct tpm_chip *chip = dev_get_drvdata(dev); 1228 1229 tpm_dev_vendor_release(chip); 1230 1231 chip->release(dev); 1232 kfree(chip); 1233} 1234EXPORT_SYMBOL_GPL(tpm_dev_release); 1235 1236/* 1237 * Called from tpm_<specific>.c probe function only for devices 1238 * the driver has determined it should claim. Prior to calling 1239 * this function the specific probe function has called pci_enable_device 1240 * upon errant exit from this function specific probe function should call 1241 * pci_disable_device 1242 */ 1243struct tpm_chip *tpm_register_hardware(struct device *dev, 1244 const struct tpm_vendor_specific *entry) 1245{ 1246#define DEVNAME_SIZE 7 1247 1248 char *devname; 1249 struct tpm_chip *chip; 1250 1251 /* Driver specific per-device data */ 1252 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 1253 devname = kmalloc(DEVNAME_SIZE, GFP_KERNEL); 1254 1255 if (chip == NULL || devname == NULL) 1256 goto out_free; 1257 1258 mutex_init(&chip->buffer_mutex); 1259 mutex_init(&chip->tpm_mutex); 1260 INIT_LIST_HEAD(&chip->list); 1261 1262 INIT_WORK(&chip->work, timeout_work); 1263 1264 setup_timer(&chip->user_read_timer, user_reader_timeout, 1265 (unsigned long)chip); 1266 1267 memcpy(&chip->vendor, entry, sizeof(struct tpm_vendor_specific)); 1268 1269 chip->dev_num = find_first_zero_bit(dev_mask, TPM_NUM_DEVICES); 1270 1271 if (chip->dev_num >= TPM_NUM_DEVICES) { 1272 dev_err(dev, "No available tpm device numbers\n"); 1273 goto out_free; 1274 } else if (chip->dev_num == 0) 1275 chip->vendor.miscdev.minor = TPM_MINOR; 1276 else 1277 chip->vendor.miscdev.minor = MISC_DYNAMIC_MINOR; 1278 1279 set_bit(chip->dev_num, dev_mask); 1280 1281 scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num); 1282 chip->vendor.miscdev.name = devname; 1283 1284 chip->vendor.miscdev.parent = dev; 1285 chip->dev = get_device(dev); 1286 chip->release = dev->release; 1287 dev->release = tpm_dev_release; 1288 dev_set_drvdata(dev, chip); 1289 1290 if (misc_register(&chip->vendor.miscdev)) { 1291 dev_err(chip->dev, 1292 "unable to misc_register %s, minor %d\n", 1293 chip->vendor.miscdev.name, 1294 chip->vendor.miscdev.minor); 1295 put_device(chip->dev); 1296 return NULL; 1297 } 1298 1299 if (sysfs_create_group(&dev->kobj, chip->vendor.attr_group)) { 1300 misc_deregister(&chip->vendor.miscdev); 1301 put_device(chip->dev); 1302 1303 return NULL; 1304 } 1305 1306 chip->bios_dir = tpm_bios_log_setup(devname); 1307 1308 /* Make chip available */ 1309 spin_lock(&driver_lock); 1310 list_add_rcu(&chip->list, &tpm_chip_list); 1311 spin_unlock(&driver_lock); 1312 1313 return chip; 1314 1315out_free: 1316 kfree(chip); 1317 kfree(devname); 1318 return NULL; 1319} 1320EXPORT_SYMBOL_GPL(tpm_register_hardware); 1321 1322MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); 1323MODULE_DESCRIPTION("TPM Driver"); 1324MODULE_VERSION("2.0"); 1325MODULE_LICENSE("GPL"); 1326