drivers/char/tpm/tpm1-cmd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2004 IBM Corporation
   4  * Copyright (C) 2014 Intel Corporation
   5  *
   6  * Authors:
   7  * Leendert van Doorn <leendert@watson.ibm.com>
   8  * Dave Safford <safford@watson.ibm.com>
   9  * Reiner Sailer <sailer@watson.ibm.com>
  10  * Kylene Hall <kjhall@us.ibm.com>
  11  *
  12  * Device driver for TCG/TCPA TPM (trusted platform module).
  13  * Specifications at www.trustedcomputinggroup.org
  14  */
  15
  16 #include <linux/poll.h>
  17 #include <linux/slab.h>
  18 #include <linux/mutex.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/freezer.h>
  21 #include <linux/tpm_eventlog.h>
  22
  23 #include "tpm.h"
  24
  25 #define TPM_MAX_ORDINAL 243
  26
  27 /*
  28  * Array with one entry per ordinal defining the maximum amount
  29  * of time the chip could take to return the result.  The ordinal
  30  * designation of short, medium or long is defined in a table in
  31  * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
  32  * values of the SHORT, MEDIUM, and LONG durations are retrieved
  33  * from the chip during initialization with a call to tpm_get_timeouts.
  34  */
  35 static const u8 tpm1_ordinal_duration[TPM_MAX_ORDINAL] = {
  36         TPM_UNDEFINED,          /* 0 */
  37         TPM_UNDEFINED,
  38         TPM_UNDEFINED,
  39         TPM_UNDEFINED,
  40         TPM_UNDEFINED,
  41         TPM_UNDEFINED,          /* 5 */
  42         TPM_UNDEFINED,
  43         TPM_UNDEFINED,
  44         TPM_UNDEFINED,
  45         TPM_UNDEFINED,
  46         TPM_SHORT,              /* 10 */
  47         TPM_SHORT,
  48         TPM_MEDIUM,
  49         TPM_LONG,
  50         TPM_LONG,
  51         TPM_MEDIUM,             /* 15 */
  52         TPM_SHORT,
  53         TPM_SHORT,
  54         TPM_MEDIUM,
  55         TPM_LONG,
  56         TPM_SHORT,              /* 20 */
  57         TPM_SHORT,
  58         TPM_MEDIUM,
  59         TPM_MEDIUM,
  60         TPM_MEDIUM,
  61         TPM_SHORT,              /* 25 */
  62         TPM_SHORT,
  63         TPM_MEDIUM,
  64         TPM_SHORT,
  65         TPM_SHORT,
  66         TPM_MEDIUM,             /* 30 */
  67         TPM_LONG,
  68         TPM_MEDIUM,
  69         TPM_SHORT,
  70         TPM_SHORT,
  71         TPM_SHORT,              /* 35 */
  72         TPM_MEDIUM,
  73         TPM_MEDIUM,
  74         TPM_UNDEFINED,
  75         TPM_UNDEFINED,
  76         TPM_MEDIUM,             /* 40 */
  77         TPM_LONG,
  78         TPM_MEDIUM,
  79         TPM_SHORT,
  80         TPM_SHORT,
  81         TPM_SHORT,              /* 45 */
  82         TPM_SHORT,
  83         TPM_SHORT,
  84         TPM_SHORT,
  85         TPM_LONG,
  86         TPM_MEDIUM,             /* 50 */
  87         TPM_MEDIUM,
  88         TPM_UNDEFINED,
  89         TPM_UNDEFINED,
  90         TPM_UNDEFINED,
  91         TPM_UNDEFINED,          /* 55 */
  92         TPM_UNDEFINED,
  93         TPM_UNDEFINED,
  94         TPM_UNDEFINED,
  95         TPM_UNDEFINED,
  96         TPM_MEDIUM,             /* 60 */
  97         TPM_MEDIUM,
  98         TPM_MEDIUM,
  99         TPM_SHORT,
 100         TPM_SHORT,
 101         TPM_MEDIUM,             /* 65 */
 102         TPM_UNDEFINED,
 103         TPM_UNDEFINED,
 104         TPM_UNDEFINED,
 105         TPM_UNDEFINED,
 106         TPM_SHORT,              /* 70 */
 107         TPM_SHORT,
 108         TPM_UNDEFINED,
 109         TPM_UNDEFINED,
 110         TPM_UNDEFINED,
 111         TPM_UNDEFINED,          /* 75 */
 112         TPM_UNDEFINED,
 113         TPM_UNDEFINED,
 114         TPM_UNDEFINED,
 115         TPM_UNDEFINED,
 116         TPM_LONG,               /* 80 */
 117         TPM_UNDEFINED,
 118         TPM_MEDIUM,
 119         TPM_LONG,
 120         TPM_SHORT,
 121         TPM_UNDEFINED,          /* 85 */
 122         TPM_UNDEFINED,
 123         TPM_UNDEFINED,
 124         TPM_UNDEFINED,
 125         TPM_UNDEFINED,
 126         TPM_SHORT,              /* 90 */
 127         TPM_SHORT,
 128         TPM_SHORT,
 129         TPM_SHORT,
 130         TPM_SHORT,
 131         TPM_UNDEFINED,          /* 95 */
 132         TPM_UNDEFINED,
 133         TPM_UNDEFINED,
 134         TPM_UNDEFINED,
 135         TPM_UNDEFINED,
 136         TPM_MEDIUM,             /* 100 */
 137         TPM_SHORT,
 138         TPM_SHORT,
 139         TPM_UNDEFINED,
 140         TPM_UNDEFINED,
 141         TPM_UNDEFINED,          /* 105 */
 142         TPM_UNDEFINED,
 143         TPM_UNDEFINED,
 144         TPM_UNDEFINED,
 145         TPM_UNDEFINED,
 146         TPM_SHORT,              /* 110 */
 147         TPM_SHORT,
 148         TPM_SHORT,
 149         TPM_SHORT,
 150         TPM_SHORT,
 151         TPM_SHORT,              /* 115 */
 152         TPM_SHORT,
 153         TPM_SHORT,
 154         TPM_UNDEFINED,
 155         TPM_UNDEFINED,
 156         TPM_LONG,               /* 120 */
 157         TPM_LONG,
 158         TPM_MEDIUM,
 159         TPM_UNDEFINED,
 160         TPM_SHORT,
 161         TPM_SHORT,              /* 125 */
 162         TPM_SHORT,
 163         TPM_LONG,
 164         TPM_SHORT,
 165         TPM_SHORT,
 166         TPM_SHORT,              /* 130 */
 167         TPM_MEDIUM,
 168         TPM_UNDEFINED,
 169         TPM_SHORT,
 170         TPM_MEDIUM,
 171         TPM_UNDEFINED,          /* 135 */
 172         TPM_UNDEFINED,
 173         TPM_UNDEFINED,
 174         TPM_UNDEFINED,
 175         TPM_UNDEFINED,
 176         TPM_SHORT,              /* 140 */
 177         TPM_SHORT,
 178         TPM_UNDEFINED,
 179         TPM_UNDEFINED,
 180         TPM_UNDEFINED,
 181         TPM_UNDEFINED,          /* 145 */
 182         TPM_UNDEFINED,
 183         TPM_UNDEFINED,
 184         TPM_UNDEFINED,
 185         TPM_UNDEFINED,
 186         TPM_SHORT,              /* 150 */
 187         TPM_MEDIUM,
 188         TPM_MEDIUM,
 189         TPM_SHORT,
 190         TPM_SHORT,
 191         TPM_UNDEFINED,          /* 155 */
 192         TPM_UNDEFINED,
 193         TPM_UNDEFINED,
 194         TPM_UNDEFINED,
 195         TPM_UNDEFINED,
 196         TPM_SHORT,              /* 160 */
 197         TPM_SHORT,
 198         TPM_SHORT,
 199         TPM_SHORT,
 200         TPM_UNDEFINED,
 201         TPM_UNDEFINED,          /* 165 */
 202         TPM_UNDEFINED,
 203         TPM_UNDEFINED,
 204         TPM_UNDEFINED,
 205         TPM_UNDEFINED,
 206         TPM_LONG,               /* 170 */
 207         TPM_UNDEFINED,
 208         TPM_UNDEFINED,
 209         TPM_UNDEFINED,
 210         TPM_UNDEFINED,
 211         TPM_UNDEFINED,          /* 175 */
 212         TPM_UNDEFINED,
 213         TPM_UNDEFINED,
 214         TPM_UNDEFINED,
 215         TPM_UNDEFINED,
 216         TPM_MEDIUM,             /* 180 */
 217         TPM_SHORT,
 218         TPM_MEDIUM,
 219         TPM_MEDIUM,
 220         TPM_MEDIUM,
 221         TPM_MEDIUM,             /* 185 */
 222         TPM_SHORT,
 223         TPM_UNDEFINED,
 224         TPM_UNDEFINED,
 225         TPM_UNDEFINED,
 226         TPM_UNDEFINED,          /* 190 */
 227         TPM_UNDEFINED,
 228         TPM_UNDEFINED,
 229         TPM_UNDEFINED,
 230         TPM_UNDEFINED,
 231         TPM_UNDEFINED,          /* 195 */
 232         TPM_UNDEFINED,
 233         TPM_UNDEFINED,
 234         TPM_UNDEFINED,
 235         TPM_UNDEFINED,
 236         TPM_SHORT,              /* 200 */
 237         TPM_UNDEFINED,
 238         TPM_UNDEFINED,
 239         TPM_UNDEFINED,
 240         TPM_SHORT,
 241         TPM_SHORT,              /* 205 */
 242         TPM_SHORT,
 243         TPM_SHORT,
 244         TPM_SHORT,
 245         TPM_SHORT,
 246         TPM_MEDIUM,             /* 210 */
 247         TPM_UNDEFINED,
 248         TPM_MEDIUM,
 249         TPM_MEDIUM,
 250         TPM_MEDIUM,
 251         TPM_UNDEFINED,          /* 215 */
 252         TPM_MEDIUM,
 253         TPM_UNDEFINED,
 254         TPM_UNDEFINED,
 255         TPM_SHORT,
 256         TPM_SHORT,              /* 220 */
 257         TPM_SHORT,
 258         TPM_SHORT,
 259         TPM_SHORT,
 260         TPM_SHORT,
 261         TPM_UNDEFINED,          /* 225 */
 262         TPM_UNDEFINED,
 263         TPM_UNDEFINED,
 264         TPM_UNDEFINED,
 265         TPM_UNDEFINED,
 266         TPM_SHORT,              /* 230 */
 267         TPM_LONG,
 268         TPM_MEDIUM,
 269         TPM_UNDEFINED,
 270         TPM_UNDEFINED,
 271         TPM_UNDEFINED,          /* 235 */
 272         TPM_UNDEFINED,
 273         TPM_UNDEFINED,
 274         TPM_UNDEFINED,
 275         TPM_UNDEFINED,
 276         TPM_SHORT,              /* 240 */
 277         TPM_UNDEFINED,
 278         TPM_MEDIUM,
 279 };
 280
 281 /**
 282  * tpm1_calc_ordinal_duration() - calculate the maximum command duration
 283  * @chip:    TPM chip to use.
 284  * @ordinal: TPM command ordinal.
 285  *
 286  * The function returns the maximum amount of time the chip could take
 287  * to return the result for a particular ordinal in jiffies.
 288  *
 289  * Return: A maximal duration time for an ordinal in jiffies.
 290  */
 291 unsigned long tpm1_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
 292 {
 293         int duration_idx = TPM_UNDEFINED;
 294         int duration = 0;
 295
 296         /*
 297          * We only have a duration table for protected commands, where the upper
 298          * 16 bits are 0. For the few other ordinals the fallback will be used.
 299          */
 300         if (ordinal < TPM_MAX_ORDINAL)
 301                 duration_idx = tpm1_ordinal_duration[ordinal];
 302
 303         if (duration_idx != TPM_UNDEFINED)
 304                 duration = chip->duration[duration_idx];
 305         if (duration <= 0)
 306                 return 2 * 60 * HZ;
 307         else
 308                 return duration;
 309 }
 310
 311 #define TPM_ORD_STARTUP 153
 312 #define TPM_ST_CLEAR 1
 313
 314 /**
 315  * tpm_startup() - turn on the TPM
 316  * @chip: TPM chip to use
 317  *
 318  * Normally the firmware should start the TPM. This function is provided as a
 319  * workaround if this does not happen. A legal case for this could be for
 320  * example when a TPM emulator is used.
 321  *
 322  * Return: same as tpm_transmit_cmd()
 323  */
 324 static int tpm1_startup(struct tpm_chip *chip)
 325 {
 326         struct tpm_buf buf;
 327         int rc;
 328
 329         dev_info(&chip->dev, "starting up the TPM manually\n");
 330
 331         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_STARTUP);
 332         if (rc < 0)
 333                 return rc;
 334
 335         tpm_buf_append_u16(&buf, TPM_ST_CLEAR);
 336
 337         rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE, 0, 0,
 338                               "attempting to start the TPM");
 339
 340         tpm_buf_destroy(&buf);
 341
 342         return rc;
 343 }
 344
 345 int tpm1_get_timeouts(struct tpm_chip *chip)
 346 {
 347         cap_t cap;
 348         unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
 349         ssize_t rc;
 350
 351         rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
 352                          sizeof(cap.timeout));
 353         if (rc == TPM_ERR_INVALID_POSTINIT) {
 354                 if (tpm1_startup(chip))
 355                         return rc;
 356
 357                 rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
 358                                  "attempting to determine the timeouts",
 359                                  sizeof(cap.timeout));
 360         }
 361
 362         if (rc) {
 363                 dev_err(&chip->dev, "A TPM error (%zd) occurred attempting to determine the timeouts\n",
 364                         rc);
 365                 return rc;
 366         }
 367
 368         timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
 369         timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
 370         timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
 371         timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
 372         timeout_chip[0] = be32_to_cpu(cap.timeout.a);
 373         timeout_chip[1] = be32_to_cpu(cap.timeout.b);
 374         timeout_chip[2] = be32_to_cpu(cap.timeout.c);
 375         timeout_chip[3] = be32_to_cpu(cap.timeout.d);
 376         memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
 377
 378         /*
 379          * Provide ability for vendor overrides of timeout values in case
 380          * of misreporting.
 381          */
 382         if (chip->ops->update_timeouts)
 383                 chip->timeout_adjusted =
 384                         chip->ops->update_timeouts(chip, timeout_eff);
 385
 386         if (!chip->timeout_adjusted) {
 387                 /* Restore default if chip reported 0 */
 388                 unsigned int i;
 389
 390                 for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
 391                         if (timeout_eff[i])
 392                                 continue;
 393
 394                         timeout_eff[i] = timeout_old[i];
 395                         chip->timeout_adjusted = true;
 396                 }
 397
 398                 if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
 399                         /* timeouts in msec rather usec */
 400                         for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
 401                                 timeout_eff[i] *= 1000;
 402                         chip->timeout_adjusted = true;
 403                 }
 404         }
 405
 406         /* Report adjusted timeouts */
 407         if (chip->timeout_adjusted) {
 408                 dev_info(&chip->dev, HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
 409                          timeout_chip[0], timeout_eff[0],
 410                          timeout_chip[1], timeout_eff[1],
 411                          timeout_chip[2], timeout_eff[2],
 412                          timeout_chip[3], timeout_eff[3]);
 413         }
 414
 415         chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
 416         chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
 417         chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
 418         chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
 419
 420         rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
 421                          "attempting to determine the durations",
 422                           sizeof(cap.duration));
 423         if (rc)
 424                 return rc;
 425
 426         chip->duration[TPM_SHORT] =
 427                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
 428         chip->duration[TPM_MEDIUM] =
 429                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
 430         chip->duration[TPM_LONG] =
 431                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
 432         chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
 433
 434         /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
 435          * value wrong and apparently reports msecs rather than usecs. So we
 436          * fix up the resulting too-small TPM_SHORT value to make things work.
 437          * We also scale the TPM_MEDIUM and -_LONG values by 1000.
 438          */
 439         if (chip->duration[TPM_SHORT] < (HZ / 100)) {
 440                 chip->duration[TPM_SHORT] = HZ;
 441                 chip->duration[TPM_MEDIUM] *= 1000;
 442                 chip->duration[TPM_LONG] *= 1000;
 443                 chip->duration_adjusted = true;
 444                 dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
 445         }
 446
 447         chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
 448         return 0;
 449 }
 450
 451 #define TPM_ORD_PCR_EXTEND 20
 452 int tpm1_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash,
 453                     const char *log_msg)
 454 {
 455         struct tpm_buf buf;
 456         int rc;
 457
 458         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND);
 459         if (rc)
 460                 return rc;
 461
 462         tpm_buf_append_u32(&buf, pcr_idx);
 463         tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE);
 464
 465         rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
 466                               TPM_DIGEST_SIZE, 0, log_msg);
 467
 468         tpm_buf_destroy(&buf);
 469         return rc;
 470 }
 471
 472 #define TPM_ORD_GET_CAP 101
 473 ssize_t tpm1_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap,
 474                     const char *desc, size_t min_cap_length)
 475 {
 476         struct tpm_buf buf;
 477         int rc;
 478
 479         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP);
 480         if (rc)
 481                 return rc;
 482
 483         if (subcap_id == TPM_CAP_VERSION_1_1 ||
 484             subcap_id == TPM_CAP_VERSION_1_2) {
 485                 tpm_buf_append_u32(&buf, subcap_id);
 486                 tpm_buf_append_u32(&buf, 0);
 487         } else {
 488                 if (subcap_id == TPM_CAP_FLAG_PERM ||
 489                     subcap_id == TPM_CAP_FLAG_VOL)
 490                         tpm_buf_append_u32(&buf, TPM_CAP_FLAG);
 491                 else
 492                         tpm_buf_append_u32(&buf, TPM_CAP_PROP);
 493
 494                 tpm_buf_append_u32(&buf, 4);
 495                 tpm_buf_append_u32(&buf, subcap_id);
 496         }
 497         rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
 498                               min_cap_length, 0, desc);
 499         if (!rc)
 500                 *cap = *(cap_t *)&buf.data[TPM_HEADER_SIZE + 4];
 501
 502         tpm_buf_destroy(&buf);
 503         return rc;
 504 }
 505 EXPORT_SYMBOL_GPL(tpm1_getcap);
 506
 507 #define TPM_ORD_GET_RANDOM 70
 508 struct tpm1_get_random_out {
 509         __be32 rng_data_len;
 510         u8 rng_data[TPM_MAX_RNG_DATA];
 511 } __packed;
 512
 513 /**
 514  * tpm1_get_random() - get random bytes from the TPM's RNG
 515  * @chip:       a &struct tpm_chip instance
 516  * @dest:       destination buffer for the random bytes
 517  * @max:        the maximum number of bytes to write to @dest
 518  *
 519  * Return:
 520  * *  number of bytes read
 521  * * -errno or a TPM return code otherwise
 522  */
 523 int tpm1_get_random(struct tpm_chip *chip, u8 *dest, size_t max)
 524 {
 525         struct tpm1_get_random_out *out;
 526         u32 num_bytes =  min_t(u32, max, TPM_MAX_RNG_DATA);
 527         struct tpm_buf buf;
 528         u32 total = 0;
 529         int retries = 5;
 530         u32 recd;
 531         int rc;
 532
 533         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
 534         if (rc)
 535                 return rc;
 536
 537         do {
 538                 tpm_buf_append_u32(&buf, num_bytes);
 539
 540                 rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
 541                                       sizeof(out->rng_data_len), 0,
 542                                       "attempting get random");
 543                 if (rc)
 544                         goto out;
 545
 546                 out = (struct tpm1_get_random_out *)&buf.data[TPM_HEADER_SIZE];
 547
 548                 recd = be32_to_cpu(out->rng_data_len);
 549                 if (recd > num_bytes) {
 550                         rc = -EFAULT;
 551                         goto out;
 552                 }
 553
 554                 if (tpm_buf_length(&buf) < TPM_HEADER_SIZE +
 555                                            sizeof(out->rng_data_len) + recd) {
 556                         rc = -EFAULT;
 557                         goto out;
 558                 }
 559                 memcpy(dest, out->rng_data, recd);
 560
 561                 dest += recd;
 562                 total += recd;
 563                 num_bytes -= recd;
 564
 565                 tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
 566         } while (retries-- && total < max);
 567
 568         rc = total ? (int)total : -EIO;
 569 out:
 570         tpm_buf_destroy(&buf);
 571         return rc;
 572 }
 573
 574 #define TPM_ORD_PCRREAD 21
 575 int tpm1_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
 576 {
 577         struct tpm_buf buf;
 578         int rc;
 579
 580         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCRREAD);
 581         if (rc)
 582                 return rc;
 583
 584         tpm_buf_append_u32(&buf, pcr_idx);
 585
 586         rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
 587                               TPM_DIGEST_SIZE, 0,
 588                               "attempting to read a pcr value");
 589         if (rc)
 590                 goto out;
 591
 592         if (tpm_buf_length(&buf) < TPM_DIGEST_SIZE) {
 593                 rc = -EFAULT;
 594                 goto out;
 595         }
 596
 597         memcpy(res_buf, &buf.data[TPM_HEADER_SIZE], TPM_DIGEST_SIZE);
 598
 599 out:
 600         tpm_buf_destroy(&buf);
 601         return rc;
 602 }
 603
 604 #define TPM_ORD_CONTINUE_SELFTEST 83
 605 #define CONTINUE_SELFTEST_RESULT_SIZE 10
 606 static const struct tpm_input_header continue_selftest_header = {
 607         .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
 608         .length = cpu_to_be32(10),
 609         .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
 610 };
 611
 612 /**
 613  * tpm_continue_selftest -- run TPM's selftest
 614  * @chip: TPM chip to use
 615  *
 616  * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
 617  * a TPM error code.
 618  */
 619 static int tpm1_continue_selftest(struct tpm_chip *chip)
 620 {
 621         int rc;
 622         struct tpm_cmd_t cmd;
 623
 624         cmd.header.in = continue_selftest_header;
 625         rc = tpm_transmit_cmd(chip, NULL, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
 626                               0, 0, "continue selftest");
 627         return rc;
 628 }
 629
 630 /**
 631  * tpm1_do_selftest - have the TPM continue its selftest and wait until it
 632  *                   can receive further commands
 633  * @chip: TPM chip to use
 634  *
 635  * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
 636  * a TPM error code.
 637  */
 638 int tpm1_do_selftest(struct tpm_chip *chip)
 639 {
 640         int rc;
 641         unsigned int loops;
 642         unsigned int delay_msec = 100;
 643         unsigned long duration;
 644         u8 dummy[TPM_DIGEST_SIZE];
 645
 646         duration = tpm1_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
 647
 648         loops = jiffies_to_msecs(duration) / delay_msec;
 649
 650         rc = tpm1_continue_selftest(chip);
 651         if (rc == TPM_ERR_INVALID_POSTINIT) {
 652                 chip->flags |= TPM_CHIP_FLAG_ALWAYS_POWERED;
 653                 dev_info(&chip->dev, "TPM not ready (%d)\n", rc);
 654         }
 655         /* This may fail if there was no TPM driver during a suspend/resume
 656          * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
 657          */
 658         if (rc)
 659                 return rc;
 660
 661         do {
 662                 /* Attempt to read a PCR value */
 663                 rc = tpm1_pcr_read_dev(chip, 0, dummy);
 664
 665                 /* Some buggy TPMs will not respond to tpm_tis_ready() for
 666                  * around 300ms while the self test is ongoing, keep trying
 667                  * until the self test duration expires.
 668                  */
 669                 if (rc == -ETIME) {
 670                         dev_info(&chip->dev, HW_ERR "TPM command timed out during continue self test");
 671                         tpm_msleep(delay_msec);
 672                         continue;
 673                 }
 674
 675                 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
 676                         dev_info(&chip->dev, "TPM is disabled/deactivated (0x%X)\n",
 677                                  rc);
 678                         /* TPM is disabled and/or deactivated; driver can
 679                          * proceed and TPM does handle commands for
 680                          * suspend/resume correctly
 681                          */
 682                         return 0;
 683                 }
 684                 if (rc != TPM_WARN_DOING_SELFTEST)
 685                         return rc;
 686                 tpm_msleep(delay_msec);
 687         } while (--loops > 0);
 688
 689         return rc;
 690 }
 691 EXPORT_SYMBOL_GPL(tpm1_do_selftest);
 692
 693 /**
 694  * tpm1_auto_startup - Perform the standard automatic TPM initialization
 695  *                     sequence
 696  * @chip: TPM chip to use
 697  *
 698  * Returns 0 on success, < 0 in case of fatal error.
 699  */
 700 int tpm1_auto_startup(struct tpm_chip *chip)
 701 {
 702         int rc;
 703
 704         rc = tpm1_get_timeouts(chip);
 705         if (rc)
 706                 goto out;
 707         rc = tpm1_do_selftest(chip);
 708         if (rc) {
 709                 dev_err(&chip->dev, "TPM self test failed\n");
 710                 goto out;
 711         }
 712
 713         return rc;
 714 out:
 715         if (rc > 0)
 716                 rc = -ENODEV;
 717         return rc;
 718 }
 719
 720 #define TPM_ORD_SAVESTATE 152
 721 #define SAVESTATE_RESULT_SIZE 10
 722 static const struct tpm_input_header savestate_header = {
 723         .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
 724         .length = cpu_to_be32(10),
 725         .ordinal = cpu_to_be32(TPM_ORD_SAVESTATE)
 726 };
 727
 728 /**
 729  * tpm1_pm_suspend() - pm suspend handler
 730  * @chip: TPM chip to use.
 731  * @tpm_suspend_pcr: flush pcr for buggy TPM chips.
 732  *
 733  * The functions saves the TPM state to be restored on resume.
 734  *
 735  * Return:
 736  * * 0 on success,
 737  * * < 0 on error.
 738  */
 739 int tpm1_pm_suspend(struct tpm_chip *chip, int tpm_suspend_pcr)
 740 {
 741         u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
 742         struct tpm_cmd_t cmd;
 743         int rc, try;
 744
 745         /* for buggy tpm, flush pcrs with extend to selected dummy */
 746         if (tpm_suspend_pcr)
 747                 rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
 748                                      "extending dummy pcr before suspend");
 749
 750         /* now do the actual savestate */
 751         for (try = 0; try < TPM_RETRY; try++) {
 752                 cmd.header.in = savestate_header;
 753                 rc = tpm_transmit_cmd(chip, NULL, &cmd, SAVESTATE_RESULT_SIZE,
 754                                       0, 0, NULL);
 755
 756                 /*
 757                  * If the TPM indicates that it is too busy to respond to
 758                  * this command then retry before giving up.  It can take
 759                  * several seconds for this TPM to be ready.
 760                  *
 761                  * This can happen if the TPM has already been sent the
 762                  * SaveState command before the driver has loaded.  TCG 1.2
 763                  * specification states that any communication after SaveState
 764                  * may cause the TPM to invalidate previously saved state.
 765                  */
 766                 if (rc != TPM_WARN_RETRY)
 767                         break;
 768                 tpm_msleep(TPM_TIMEOUT_RETRY);
 769         }
 770
 771         if (rc)
 772                 dev_err(&chip->dev, "Error (%d) sending savestate before suspend\n",
 773                         rc);
 774         else if (try > 0)
 775                 dev_warn(&chip->dev, "TPM savestate took %dms\n",
 776                          try * TPM_TIMEOUT_RETRY);
 777
 778         return rc;
 779 }
 780