drivers/char/tpm/tpm-interface.c

   1 /*
   2  * Copyright (C) 2004 IBM Corporation
   3  * Copyright (C) 2014 Intel Corporation
   4  *
   5  * Authors:
   6  * Leendert van Doorn <leendert@watson.ibm.com>
   7  * Dave Safford <safford@watson.ibm.com>
   8  * Reiner Sailer <sailer@watson.ibm.com>
   9  * Kylene Hall <kjhall@us.ibm.com>
  10  *
  11  * Maintained by: <tpmdd-devel@lists.sourceforge.net>
  12  *
  13  * Device driver for TCG/TCPA TPM (trusted platform module).
  14  * Specifications at www.trustedcomputinggroup.org
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License as
  18  * published by the Free Software Foundation, version 2 of the
  19  * License.
  20  *
  21  * Note, the TPM chip is not interrupt driven (only polling)
  22  * and can have very long timeouts (minutes!). Hence the unusual
  23  * calls to msleep.
  24  *
  25  */
  26
  27 #include <linux/poll.h>
  28 #include <linux/slab.h>
  29 #include <linux/mutex.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/freezer.h>
  32 #include <linux/pm_runtime.h>
  33
  34 #include "tpm.h"
  35 #include "tpm_eventlog.h"
  36
  37 #define TPM_MAX_ORDINAL 243
  38 #define TSC_MAX_ORDINAL 12
  39 #define TPM_PROTECTED_COMMAND 0x00
  40 #define TPM_CONNECTION_COMMAND 0x40
  41
  42 /*
  43  * Bug workaround - some TPM's don't flush the most
  44  * recently changed pcr on suspend, so force the flush
  45  * with an extend to the selected _unused_ non-volatile pcr.
  46  */
  47 static int tpm_suspend_pcr;
  48 module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
  49 MODULE_PARM_DESC(suspend_pcr,
  50                  "PCR to use for dummy writes to facilitate flush on suspend.");
  51
  52 /*
  53  * Array with one entry per ordinal defining the maximum amount
  54  * of time the chip could take to return the result.  The ordinal
  55  * designation of short, medium or long is defined in a table in
  56  * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
  57  * values of the SHORT, MEDIUM, and LONG durations are retrieved
  58  * from the chip during initialization with a call to tpm_get_timeouts.
  59  */
  60 static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = {
  61         TPM_UNDEFINED,          /* 0 */
  62         TPM_UNDEFINED,
  63         TPM_UNDEFINED,
  64         TPM_UNDEFINED,
  65         TPM_UNDEFINED,
  66         TPM_UNDEFINED,          /* 5 */
  67         TPM_UNDEFINED,
  68         TPM_UNDEFINED,
  69         TPM_UNDEFINED,
  70         TPM_UNDEFINED,
  71         TPM_SHORT,              /* 10 */
  72         TPM_SHORT,
  73         TPM_MEDIUM,
  74         TPM_LONG,
  75         TPM_LONG,
  76         TPM_MEDIUM,             /* 15 */
  77         TPM_SHORT,
  78         TPM_SHORT,
  79         TPM_MEDIUM,
  80         TPM_LONG,
  81         TPM_SHORT,              /* 20 */
  82         TPM_SHORT,
  83         TPM_MEDIUM,
  84         TPM_MEDIUM,
  85         TPM_MEDIUM,
  86         TPM_SHORT,              /* 25 */
  87         TPM_SHORT,
  88         TPM_MEDIUM,
  89         TPM_SHORT,
  90         TPM_SHORT,
  91         TPM_MEDIUM,             /* 30 */
  92         TPM_LONG,
  93         TPM_MEDIUM,
  94         TPM_SHORT,
  95         TPM_SHORT,
  96         TPM_SHORT,              /* 35 */
  97         TPM_MEDIUM,
  98         TPM_MEDIUM,
  99         TPM_UNDEFINED,
 100         TPM_UNDEFINED,
 101         TPM_MEDIUM,             /* 40 */
 102         TPM_LONG,
 103         TPM_MEDIUM,
 104         TPM_SHORT,
 105         TPM_SHORT,
 106         TPM_SHORT,              /* 45 */
 107         TPM_SHORT,
 108         TPM_SHORT,
 109         TPM_SHORT,
 110         TPM_LONG,
 111         TPM_MEDIUM,             /* 50 */
 112         TPM_MEDIUM,
 113         TPM_UNDEFINED,
 114         TPM_UNDEFINED,
 115         TPM_UNDEFINED,
 116         TPM_UNDEFINED,          /* 55 */
 117         TPM_UNDEFINED,
 118         TPM_UNDEFINED,
 119         TPM_UNDEFINED,
 120         TPM_UNDEFINED,
 121         TPM_MEDIUM,             /* 60 */
 122         TPM_MEDIUM,
 123         TPM_MEDIUM,
 124         TPM_SHORT,
 125         TPM_SHORT,
 126         TPM_MEDIUM,             /* 65 */
 127         TPM_UNDEFINED,
 128         TPM_UNDEFINED,
 129         TPM_UNDEFINED,
 130         TPM_UNDEFINED,
 131         TPM_SHORT,              /* 70 */
 132         TPM_SHORT,
 133         TPM_UNDEFINED,
 134         TPM_UNDEFINED,
 135         TPM_UNDEFINED,
 136         TPM_UNDEFINED,          /* 75 */
 137         TPM_UNDEFINED,
 138         TPM_UNDEFINED,
 139         TPM_UNDEFINED,
 140         TPM_UNDEFINED,
 141         TPM_LONG,               /* 80 */
 142         TPM_UNDEFINED,
 143         TPM_MEDIUM,
 144         TPM_LONG,
 145         TPM_SHORT,
 146         TPM_UNDEFINED,          /* 85 */
 147         TPM_UNDEFINED,
 148         TPM_UNDEFINED,
 149         TPM_UNDEFINED,
 150         TPM_UNDEFINED,
 151         TPM_SHORT,              /* 90 */
 152         TPM_SHORT,
 153         TPM_SHORT,
 154         TPM_SHORT,
 155         TPM_SHORT,
 156         TPM_UNDEFINED,          /* 95 */
 157         TPM_UNDEFINED,
 158         TPM_UNDEFINED,
 159         TPM_UNDEFINED,
 160         TPM_UNDEFINED,
 161         TPM_MEDIUM,             /* 100 */
 162         TPM_SHORT,
 163         TPM_SHORT,
 164         TPM_UNDEFINED,
 165         TPM_UNDEFINED,
 166         TPM_UNDEFINED,          /* 105 */
 167         TPM_UNDEFINED,
 168         TPM_UNDEFINED,
 169         TPM_UNDEFINED,
 170         TPM_UNDEFINED,
 171         TPM_SHORT,              /* 110 */
 172         TPM_SHORT,
 173         TPM_SHORT,
 174         TPM_SHORT,
 175         TPM_SHORT,
 176         TPM_SHORT,              /* 115 */
 177         TPM_SHORT,
 178         TPM_SHORT,
 179         TPM_UNDEFINED,
 180         TPM_UNDEFINED,
 181         TPM_LONG,               /* 120 */
 182         TPM_LONG,
 183         TPM_MEDIUM,
 184         TPM_UNDEFINED,
 185         TPM_SHORT,
 186         TPM_SHORT,              /* 125 */
 187         TPM_SHORT,
 188         TPM_LONG,
 189         TPM_SHORT,
 190         TPM_SHORT,
 191         TPM_SHORT,              /* 130 */
 192         TPM_MEDIUM,
 193         TPM_UNDEFINED,
 194         TPM_SHORT,
 195         TPM_MEDIUM,
 196         TPM_UNDEFINED,          /* 135 */
 197         TPM_UNDEFINED,
 198         TPM_UNDEFINED,
 199         TPM_UNDEFINED,
 200         TPM_UNDEFINED,
 201         TPM_SHORT,              /* 140 */
 202         TPM_SHORT,
 203         TPM_UNDEFINED,
 204         TPM_UNDEFINED,
 205         TPM_UNDEFINED,
 206         TPM_UNDEFINED,          /* 145 */
 207         TPM_UNDEFINED,
 208         TPM_UNDEFINED,
 209         TPM_UNDEFINED,
 210         TPM_UNDEFINED,
 211         TPM_SHORT,              /* 150 */
 212         TPM_MEDIUM,
 213         TPM_MEDIUM,
 214         TPM_SHORT,
 215         TPM_SHORT,
 216         TPM_UNDEFINED,          /* 155 */
 217         TPM_UNDEFINED,
 218         TPM_UNDEFINED,
 219         TPM_UNDEFINED,
 220         TPM_UNDEFINED,
 221         TPM_SHORT,              /* 160 */
 222         TPM_SHORT,
 223         TPM_SHORT,
 224         TPM_SHORT,
 225         TPM_UNDEFINED,
 226         TPM_UNDEFINED,          /* 165 */
 227         TPM_UNDEFINED,
 228         TPM_UNDEFINED,
 229         TPM_UNDEFINED,
 230         TPM_UNDEFINED,
 231         TPM_LONG,               /* 170 */
 232         TPM_UNDEFINED,
 233         TPM_UNDEFINED,
 234         TPM_UNDEFINED,
 235         TPM_UNDEFINED,
 236         TPM_UNDEFINED,          /* 175 */
 237         TPM_UNDEFINED,
 238         TPM_UNDEFINED,
 239         TPM_UNDEFINED,
 240         TPM_UNDEFINED,
 241         TPM_MEDIUM,             /* 180 */
 242         TPM_SHORT,
 243         TPM_MEDIUM,
 244         TPM_MEDIUM,
 245         TPM_MEDIUM,
 246         TPM_MEDIUM,             /* 185 */
 247         TPM_SHORT,
 248         TPM_UNDEFINED,
 249         TPM_UNDEFINED,
 250         TPM_UNDEFINED,
 251         TPM_UNDEFINED,          /* 190 */
 252         TPM_UNDEFINED,
 253         TPM_UNDEFINED,
 254         TPM_UNDEFINED,
 255         TPM_UNDEFINED,
 256         TPM_UNDEFINED,          /* 195 */
 257         TPM_UNDEFINED,
 258         TPM_UNDEFINED,
 259         TPM_UNDEFINED,
 260         TPM_UNDEFINED,
 261         TPM_SHORT,              /* 200 */
 262         TPM_UNDEFINED,
 263         TPM_UNDEFINED,
 264         TPM_UNDEFINED,
 265         TPM_SHORT,
 266         TPM_SHORT,              /* 205 */
 267         TPM_SHORT,
 268         TPM_SHORT,
 269         TPM_SHORT,
 270         TPM_SHORT,
 271         TPM_MEDIUM,             /* 210 */
 272         TPM_UNDEFINED,
 273         TPM_MEDIUM,
 274         TPM_MEDIUM,
 275         TPM_MEDIUM,
 276         TPM_UNDEFINED,          /* 215 */
 277         TPM_MEDIUM,
 278         TPM_UNDEFINED,
 279         TPM_UNDEFINED,
 280         TPM_SHORT,
 281         TPM_SHORT,              /* 220 */
 282         TPM_SHORT,
 283         TPM_SHORT,
 284         TPM_SHORT,
 285         TPM_SHORT,
 286         TPM_UNDEFINED,          /* 225 */
 287         TPM_UNDEFINED,
 288         TPM_UNDEFINED,
 289         TPM_UNDEFINED,
 290         TPM_UNDEFINED,
 291         TPM_SHORT,              /* 230 */
 292         TPM_LONG,
 293         TPM_MEDIUM,
 294         TPM_UNDEFINED,
 295         TPM_UNDEFINED,
 296         TPM_UNDEFINED,          /* 235 */
 297         TPM_UNDEFINED,
 298         TPM_UNDEFINED,
 299         TPM_UNDEFINED,
 300         TPM_UNDEFINED,
 301         TPM_SHORT,              /* 240 */
 302         TPM_UNDEFINED,
 303         TPM_MEDIUM,
 304 };
 305
 306 /*
 307  * Returns max number of jiffies to wait
 308  */
 309 unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
 310                                            u32 ordinal)
 311 {
 312         int duration_idx = TPM_UNDEFINED;
 313         int duration = 0;
 314
 315         /*
 316          * We only have a duration table for protected commands, where the upper
 317          * 16 bits are 0. For the few other ordinals the fallback will be used.
 318          */
 319         if (ordinal < TPM_MAX_ORDINAL)
 320                 duration_idx = tpm_ordinal_duration[ordinal];
 321
 322         if (duration_idx != TPM_UNDEFINED)
 323                 duration = chip->duration[duration_idx];
 324         if (duration <= 0)
 325                 return 2 * 60 * HZ;
 326         else
 327                 return duration;
 328 }
 329 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
 330
 331 static bool tpm_validate_command(struct tpm_chip *chip,
 332                                  struct tpm_space *space,
 333                                  const u8 *cmd,
 334                                  size_t len)
 335 {
 336         const struct tpm_input_header *header = (const void *)cmd;
 337         int i;
 338         u32 cc;
 339         u32 attrs;
 340         unsigned int nr_handles;
 341
 342         if (len < TPM_HEADER_SIZE)
 343                 return false;
 344
 345         if (!space)
 346                 return true;
 347
 348         if (chip->flags & TPM_CHIP_FLAG_TPM2 && chip->nr_commands) {
 349                 cc = be32_to_cpu(header->ordinal);
 350
 351                 i = tpm2_find_cc(chip, cc);
 352                 if (i < 0) {
 353                         dev_dbg(&chip->dev, "0x%04X is an invalid command\n",
 354                                 cc);
 355                         return false;
 356                 }
 357
 358                 attrs = chip->cc_attrs_tbl[i];
 359                 nr_handles =
 360                         4 * ((attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0));
 361                 if (len < TPM_HEADER_SIZE + 4 * nr_handles)
 362                         goto err_len;
 363         }
 364
 365         return true;
 366 err_len:
 367         dev_dbg(&chip->dev,
 368                 "%s: insufficient command length %zu", __func__, len);
 369         return false;
 370 }
 371
 372 /**
 373  * tmp_transmit - Internal kernel interface to transmit TPM commands.
 374  *
 375  * @chip: TPM chip to use
 376  * @buf: TPM command buffer
 377  * @bufsiz: length of the TPM command buffer
 378  * @flags: tpm transmit flags - bitmap
 379  *
 380  * Return:
 381  *     0 when the operation is successful.
 382  *     A negative number for system errors (errno).
 383  */
 384 ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space,
 385                      u8 *buf, size_t bufsiz, unsigned int flags)
 386 {
 387         struct tpm_output_header *header = (void *)buf;
 388         int rc;
 389         ssize_t len = 0;
 390         u32 count, ordinal;
 391         unsigned long stop;
 392         bool need_locality;
 393
 394         if (!tpm_validate_command(chip, space, buf, bufsiz))
 395                 return -EINVAL;
 396
 397         if (bufsiz > TPM_BUFSIZE)
 398                 bufsiz = TPM_BUFSIZE;
 399
 400         count = be32_to_cpu(*((__be32 *) (buf + 2)));
 401         ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
 402         if (count == 0)
 403                 return -ENODATA;
 404         if (count > bufsiz) {
 405                 dev_err(&chip->dev,
 406                         "invalid count value %x %zx\n", count, bufsiz);
 407                 return -E2BIG;
 408         }
 409
 410         if (!(flags & TPM_TRANSMIT_UNLOCKED))
 411                 mutex_lock(&chip->tpm_mutex);
 412
 413         if (chip->dev.parent)
 414                 pm_runtime_get_sync(chip->dev.parent);
 415
 416         /* Store the decision as chip->locality will be changed. */
 417         need_locality = chip->locality == -1;
 418
 419         if (!(flags & TPM_TRANSMIT_RAW) &&
 420             need_locality && chip->ops->request_locality)  {
 421                 rc = chip->ops->request_locality(chip, 0);
 422                 if (rc < 0)
 423                         goto out_no_locality;
 424                 chip->locality = rc;
 425         }
 426
 427         rc = tpm2_prepare_space(chip, space, ordinal, buf);
 428         if (rc)
 429                 goto out;
 430
 431         rc = chip->ops->send(chip, (u8 *) buf, count);
 432         if (rc < 0) {
 433                 if (rc != -EPIPE)
 434                         dev_err(&chip->dev,
 435                                 "%s: tpm_send: error %d\n", __func__, rc);
 436                 goto out;
 437         }
 438
 439         if (chip->flags & TPM_CHIP_FLAG_IRQ)
 440                 goto out_recv;
 441
 442         if (chip->flags & TPM_CHIP_FLAG_TPM2)
 443                 stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal);
 444         else
 445                 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
 446         do {
 447                 u8 status = chip->ops->status(chip);
 448                 if ((status & chip->ops->req_complete_mask) ==
 449                     chip->ops->req_complete_val)
 450                         goto out_recv;
 451
 452                 if (chip->ops->req_canceled(chip, status)) {
 453                         dev_err(&chip->dev, "Operation Canceled\n");
 454                         rc = -ECANCELED;
 455                         goto out;
 456                 }
 457
 458                 msleep(TPM_TIMEOUT);    /* CHECK */
 459                 rmb();
 460         } while (time_before(jiffies, stop));
 461
 462         chip->ops->cancel(chip);
 463         dev_err(&chip->dev, "Operation Timed out\n");
 464         rc = -ETIME;
 465         goto out;
 466
 467 out_recv:
 468         len = chip->ops->recv(chip, (u8 *) buf, bufsiz);
 469         if (len < 0) {
 470                 rc = len;
 471                 dev_err(&chip->dev,
 472                         "tpm_transmit: tpm_recv: error %d\n", rc);
 473                 goto out;
 474         } else if (len < TPM_HEADER_SIZE) {
 475                 rc = -EFAULT;
 476                 goto out;
 477         }
 478
 479         if (len != be32_to_cpu(header->length)) {
 480                 rc = -EFAULT;
 481                 goto out;
 482         }
 483
 484         rc = tpm2_commit_space(chip, space, ordinal, buf, &len);
 485
 486 out:
 487         if (need_locality && chip->ops->relinquish_locality) {
 488                 chip->ops->relinquish_locality(chip, chip->locality);
 489                 chip->locality = -1;
 490         }
 491 out_no_locality:
 492         if (chip->dev.parent)
 493                 pm_runtime_put_sync(chip->dev.parent);
 494
 495         if (!(flags & TPM_TRANSMIT_UNLOCKED))
 496                 mutex_unlock(&chip->tpm_mutex);
 497         return rc ? rc : len;
 498 }
 499
 500 /**
 501  * tmp_transmit_cmd - send a tpm command to the device
 502  *    The function extracts tpm out header return code
 503  *
 504  * @chip: TPM chip to use
 505  * @buf: TPM command buffer
 506  * @bufsiz: length of the buffer
 507  * @min_rsp_body_length: minimum expected length of response body
 508  * @flags: tpm transmit flags - bitmap
 509  * @desc: command description used in the error message
 510  *
 511  * Return:
 512  *     0 when the operation is successful.
 513  *     A negative number for system errors (errno).
 514  *     A positive number for a TPM error.
 515  */
 516 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space,
 517                          const void *buf, size_t bufsiz,
 518                          size_t min_rsp_body_length, unsigned int flags,
 519                          const char *desc)
 520 {
 521         const struct tpm_output_header *header = buf;
 522         int err;
 523         ssize_t len;
 524
 525         len = tpm_transmit(chip, space, (u8 *)buf, bufsiz, flags);
 526         if (len <  0)
 527                 return len;
 528
 529         err = be32_to_cpu(header->return_code);
 530         if (err != 0 && desc)
 531                 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
 532                         desc);
 533         if (err)
 534                 return err;
 535
 536         if (len < min_rsp_body_length + TPM_HEADER_SIZE)
 537                 return -EFAULT;
 538
 539         return 0;
 540 }
 541 EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
 542
 543 #define TPM_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                         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                 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                         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_TPM2) {
1123                 tpm2_shutdown(chip, TPM2_SU_STATE);
1124                 return 0;
1125         }
1126
1127         /* for buggy tpm, flush pcrs with extend to selected dummy */
1128         if (tpm_suspend_pcr)
1129                 rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
1130                                      "extending dummy pcr before suspend");
1131
1132         /* now do the actual savestate */
1133         for (try = 0; try < TPM_RETRY; try++) {
1134                 cmd.header.in = savestate_header;
1135                 rc = tpm_transmit_cmd(chip, NULL, &cmd, SAVESTATE_RESULT_SIZE,
1136                                       0, 0, NULL);
1137
1138                 /*
1139                  * If the TPM indicates that it is too busy to respond to
1140                  * this command then retry before giving up.  It can take
1141                  * several seconds for this TPM to be ready.
1142                  *
1143                  * This can happen if the TPM has already been sent the
1144                  * SaveState command before the driver has loaded.  TCG 1.2
1145                  * specification states that any communication after SaveState
1146                  * may cause the TPM to invalidate previously saved state.
1147                  */
1148                 if (rc != TPM_WARN_RETRY)
1149                         break;
1150                 msleep(TPM_TIMEOUT_RETRY);
1151         }
1152
1153         if (rc)
1154                 dev_err(&chip->dev,
1155                         "Error (%d) sending savestate before suspend\n", rc);
1156         else if (try > 0)
1157                 dev_warn(&chip->dev, "TPM savestate took %dms\n",
1158                          try * TPM_TIMEOUT_RETRY);
1159
1160         return rc;
1161 }
1162 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
1163
1164 /*
1165  * Resume from a power safe. The BIOS already restored
1166  * the TPM state.
1167  */
1168 int tpm_pm_resume(struct device *dev)
1169 {
1170         struct tpm_chip *chip = dev_get_drvdata(dev);
1171
1172         if (chip == NULL)
1173                 return -ENODEV;
1174
1175         return 0;
1176 }
1177 EXPORT_SYMBOL_GPL(tpm_pm_resume);
1178
1179 #define TPM_GETRANDOM_RESULT_SIZE       18
1180 static const struct tpm_input_header tpm_getrandom_header = {
1181         .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1182         .length = cpu_to_be32(14),
1183         .ordinal = cpu_to_be32(TPM_ORD_GET_RANDOM)
1184 };
1185
1186 /**
1187  * tpm_get_random() - Get random bytes from the tpm's RNG
1188  * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1189  * @out: destination buffer for the random bytes
1190  * @max: the max number of bytes to write to @out
1191  *
1192  * Returns < 0 on error and the number of bytes read on success
1193  */
1194 int tpm_get_random(u32 chip_num, u8 *out, size_t max)
1195 {
1196         struct tpm_chip *chip;
1197         struct tpm_cmd_t tpm_cmd;
1198         u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA), rlength;
1199         int err, total = 0, retries = 5;
1200         u8 *dest = out;
1201
1202         if (!out || !num_bytes || max > TPM_MAX_RNG_DATA)
1203                 return -EINVAL;
1204
1205         chip = tpm_chip_find_get(chip_num);
1206         if (chip == NULL)
1207                 return -ENODEV;
1208
1209         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1210                 err = tpm2_get_random(chip, out, max);
1211                 tpm_put_ops(chip);
1212                 return err;
1213         }
1214
1215         do {
1216                 tpm_cmd.header.in = tpm_getrandom_header;
1217                 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
1218
1219                 err = tpm_transmit_cmd(chip, NULL, &tpm_cmd,
1220                                        TPM_GETRANDOM_RESULT_SIZE + num_bytes,
1221                                        offsetof(struct tpm_getrandom_out,
1222                                                 rng_data),
1223                                        0, "attempting get random");
1224                 if (err)
1225                         break;
1226
1227                 recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);
1228
1229                 rlength = be32_to_cpu(tpm_cmd.header.out.length);
1230                 if (rlength < offsetof(struct tpm_getrandom_out, rng_data) +
1231                               recd) {
1232                         total = -EFAULT;
1233                         break;
1234                 }
1235                 memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);
1236
1237                 dest += recd;
1238                 total += recd;
1239                 num_bytes -= recd;
1240         } while (retries-- && total < max);
1241
1242         tpm_put_ops(chip);
1243         return total ? total : -EIO;
1244 }
1245 EXPORT_SYMBOL_GPL(tpm_get_random);
1246
1247 /**
1248  * tpm_seal_trusted() - seal a trusted key
1249  * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1250  * @options: authentication values and other options
1251  * @payload: the key data in clear and encrypted form
1252  *
1253  * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1254  * are supported.
1255  */
1256 int tpm_seal_trusted(u32 chip_num, struct trusted_key_payload *payload,
1257                      struct trusted_key_options *options)
1258 {
1259         struct tpm_chip *chip;
1260         int rc;
1261
1262         chip = tpm_chip_find_get(chip_num);
1263         if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1264                 return -ENODEV;
1265
1266         rc = tpm2_seal_trusted(chip, payload, options);
1267
1268         tpm_put_ops(chip);
1269         return rc;
1270 }
1271 EXPORT_SYMBOL_GPL(tpm_seal_trusted);
1272
1273 /**
1274  * tpm_unseal_trusted() - unseal a trusted key
1275  * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1276  * @options: authentication values and other options
1277  * @payload: the key data in clear and encrypted form
1278  *
1279  * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1280  * are supported.
1281  */
1282 int tpm_unseal_trusted(u32 chip_num, struct trusted_key_payload *payload,
1283                        struct trusted_key_options *options)
1284 {
1285         struct tpm_chip *chip;
1286         int rc;
1287
1288         chip = tpm_chip_find_get(chip_num);
1289         if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1290                 return -ENODEV;
1291
1292         rc = tpm2_unseal_trusted(chip, payload, options);
1293
1294         tpm_put_ops(chip);
1295
1296         return rc;
1297 }
1298 EXPORT_SYMBOL_GPL(tpm_unseal_trusted);
1299
1300 static int __init tpm_init(void)
1301 {
1302         int rc;
1303
1304         tpm_class = class_create(THIS_MODULE, "tpm");
1305         if (IS_ERR(tpm_class)) {
1306                 pr_err("couldn't create tpm class\n");
1307                 return PTR_ERR(tpm_class);
1308         }
1309
1310         tpmrm_class = class_create(THIS_MODULE, "tpmrm");
1311         if (IS_ERR(tpmrm_class)) {
1312                 pr_err("couldn't create tpmrm class\n");
1313                 class_destroy(tpm_class);
1314                 return PTR_ERR(tpmrm_class);
1315         }
1316
1317         rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm");
1318         if (rc < 0) {
1319                 pr_err("tpm: failed to allocate char dev region\n");
1320                 class_destroy(tpmrm_class);
1321                 class_destroy(tpm_class);
1322                 return rc;
1323         }
1324
1325         return 0;
1326 }
1327
1328 static void __exit tpm_exit(void)
1329 {
1330         idr_destroy(&dev_nums_idr);
1331         class_destroy(tpm_class);
1332         class_destroy(tpmrm_class);
1333         unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES);
1334 }
1335
1336 subsys_initcall(tpm_init);
1337 module_exit(tpm_exit);
1338
1339 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1340 MODULE_DESCRIPTION("TPM Driver");
1341 MODULE_VERSION("2.0");
1342 MODULE_LICENSE("GPL");