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