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  * tpm1_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, &buf, 0, "attempting to start the TPM");
 338         tpm_buf_destroy(&buf);
 339         return rc;
 340 }
 341
 342 int tpm1_get_timeouts(struct tpm_chip *chip)
 343 {
 344         cap_t cap;
 345         unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
 346         unsigned long durations[3];
 347         ssize_t rc;
 348
 349         rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
 350                          sizeof(cap.timeout));
 351         if (rc == TPM_ERR_INVALID_POSTINIT) {
 352                 if (tpm1_startup(chip))
 353                         return rc;
 354
 355                 rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
 356                                  "attempting to determine the timeouts",
 357                                  sizeof(cap.timeout));
 358         }
 359
 360         if (rc) {
 361                 dev_err(&chip->dev, "A TPM error (%zd) occurred attempting to determine the timeouts\n",
 362                         rc);
 363                 return rc;
 364         }
 365
 366         timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
 367         timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
 368         timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
 369         timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
 370         timeout_chip[0] = be32_to_cpu(cap.timeout.a);
 371         timeout_chip[1] = be32_to_cpu(cap.timeout.b);
 372         timeout_chip[2] = be32_to_cpu(cap.timeout.c);
 373         timeout_chip[3] = be32_to_cpu(cap.timeout.d);
 374         memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
 375
 376         /*
 377          * Provide ability for vendor overrides of timeout values in case
 378          * of misreporting.
 379          */
 380         if (chip->ops->update_timeouts)
 381                 chip->ops->update_timeouts(chip, timeout_eff);
 382
 383         if (!chip->timeout_adjusted) {
 384                 /* Restore default if chip reported 0 */
 385                 unsigned int i;
 386
 387                 for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
 388                         if (timeout_eff[i])
 389                                 continue;
 390
 391                         timeout_eff[i] = timeout_old[i];
 392                         chip->timeout_adjusted = true;
 393                 }
 394
 395                 if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
 396                         /* timeouts in msec rather usec */
 397                         for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
 398                                 timeout_eff[i] *= 1000;
 399                         chip->timeout_adjusted = true;
 400                 }
 401         }
 402
 403         /* Report adjusted timeouts */
 404         if (chip->timeout_adjusted) {
 405                 dev_info(&chip->dev, HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
 406                          timeout_chip[0], timeout_eff[0],
 407                          timeout_chip[1], timeout_eff[1],
 408                          timeout_chip[2], timeout_eff[2],
 409                          timeout_chip[3], timeout_eff[3]);
 410         }
 411
 412         chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
 413         chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
 414         chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
 415         chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
 416
 417         rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
 418                          "attempting to determine the durations",
 419                           sizeof(cap.duration));
 420         if (rc)
 421                 return rc;
 422
 423         chip->duration[TPM_SHORT] =
 424                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
 425         chip->duration[TPM_MEDIUM] =
 426                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
 427         chip->duration[TPM_LONG] =
 428                 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
 429         chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
 430
 431         /*
 432          * Provide the ability for vendor overrides of duration values in case
 433          * of misreporting.
 434          */
 435         if (chip->ops->update_durations)
 436                 chip->ops->update_durations(chip, durations);
 437
 438         if (chip->duration_adjusted) {
 439                 dev_info(&chip->dev, HW_ERR "Adjusting reported durations.");
 440                 chip->duration[TPM_SHORT] = durations[0];
 441                 chip->duration[TPM_MEDIUM] = durations[1];
 442                 chip->duration[TPM_LONG] = durations[2];
 443         }
 444
 445         /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
 446          * value wrong and apparently reports msecs rather than usecs. So we
 447          * fix up the resulting too-small TPM_SHORT value to make things work.
 448          * We also scale the TPM_MEDIUM and -_LONG values by 1000.
 449          */
 450         if (chip->duration[TPM_SHORT] < (HZ / 100)) {
 451                 chip->duration[TPM_SHORT] = HZ;
 452                 chip->duration[TPM_MEDIUM] *= 1000;
 453                 chip->duration[TPM_LONG] *= 1000;
 454                 chip->duration_adjusted = true;
 455                 dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
 456         }
 457
 458         chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
 459         return 0;
 460 }
 461
 462 #define TPM_ORD_PCR_EXTEND 20
 463 int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash,
 464                     const char *log_msg)
 465 {
 466         struct tpm_buf buf;
 467         int rc;
 468
 469         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND);
 470         if (rc)
 471                 return rc;
 472
 473         tpm_buf_append_u32(&buf, pcr_idx);
 474         tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE);
 475
 476         rc = tpm_transmit_cmd(chip, &buf, TPM_DIGEST_SIZE, log_msg);
 477         tpm_buf_destroy(&buf);
 478         return rc;
 479 }
 480
 481 #define TPM_ORD_GET_CAP 101
 482 ssize_t tpm1_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap,
 483                     const char *desc, size_t min_cap_length)
 484 {
 485         struct tpm_buf buf;
 486         int rc;
 487
 488         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP);
 489         if (rc)
 490                 return rc;
 491
 492         if (subcap_id == TPM_CAP_VERSION_1_1 ||
 493             subcap_id == TPM_CAP_VERSION_1_2) {
 494                 tpm_buf_append_u32(&buf, subcap_id);
 495                 tpm_buf_append_u32(&buf, 0);
 496         } else {
 497                 if (subcap_id == TPM_CAP_FLAG_PERM ||
 498                     subcap_id == TPM_CAP_FLAG_VOL)
 499                         tpm_buf_append_u32(&buf, TPM_CAP_FLAG);
 500                 else
 501                         tpm_buf_append_u32(&buf, TPM_CAP_PROP);
 502
 503                 tpm_buf_append_u32(&buf, 4);
 504                 tpm_buf_append_u32(&buf, subcap_id);
 505         }
 506         rc = tpm_transmit_cmd(chip, &buf, min_cap_length, desc);
 507         if (!rc)
 508                 *cap = *(cap_t *)&buf.data[TPM_HEADER_SIZE + 4];
 509         tpm_buf_destroy(&buf);
 510         return rc;
 511 }
 512 EXPORT_SYMBOL_GPL(tpm1_getcap);
 513
 514 #define TPM_ORD_GET_RANDOM 70
 515 struct tpm1_get_random_out {
 516         __be32 rng_data_len;
 517         u8 rng_data[TPM_MAX_RNG_DATA];
 518 } __packed;
 519
 520 /**
 521  * tpm1_get_random() - get random bytes from the TPM's RNG
 522  * @chip:       a &struct tpm_chip instance
 523  * @dest:       destination buffer for the random bytes
 524  * @max:        the maximum number of bytes to write to @dest
 525  *
 526  * Return:
 527  * *  number of bytes read
 528  * * -errno (positive TPM return codes are masked to -EIO)
 529  */
 530 int tpm1_get_random(struct tpm_chip *chip, u8 *dest, size_t max)
 531 {
 532         struct tpm1_get_random_out *out;
 533         u32 num_bytes =  min_t(u32, max, TPM_MAX_RNG_DATA);
 534         struct tpm_buf buf;
 535         u32 total = 0;
 536         int retries = 5;
 537         u32 recd;
 538         int rc;
 539
 540         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
 541         if (rc)
 542                 return rc;
 543
 544         do {
 545                 tpm_buf_append_u32(&buf, num_bytes);
 546
 547                 rc = tpm_transmit_cmd(chip, &buf, sizeof(out->rng_data_len),
 548                                       "attempting get random");
 549                 if (rc) {
 550                         if (rc > 0)
 551                                 rc = -EIO;
 552                         goto out;
 553                 }
 554
 555                 out = (struct tpm1_get_random_out *)&buf.data[TPM_HEADER_SIZE];
 556
 557                 recd = be32_to_cpu(out->rng_data_len);
 558                 if (recd > num_bytes) {
 559                         rc = -EFAULT;
 560                         goto out;
 561                 }
 562
 563                 if (tpm_buf_length(&buf) < TPM_HEADER_SIZE +
 564                                            sizeof(out->rng_data_len) + recd) {
 565                         rc = -EFAULT;
 566                         goto out;
 567                 }
 568                 memcpy(dest, out->rng_data, recd);
 569
 570                 dest += recd;
 571                 total += recd;
 572                 num_bytes -= recd;
 573
 574                 tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
 575         } while (retries-- && total < max);
 576
 577         rc = total ? (int)total : -EIO;
 578 out:
 579         tpm_buf_destroy(&buf);
 580         return rc;
 581 }
 582
 583 #define TPM_ORD_PCRREAD 21
 584 int tpm1_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf)
 585 {
 586         struct tpm_buf buf;
 587         int rc;
 588
 589         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCRREAD);
 590         if (rc)
 591                 return rc;
 592
 593         tpm_buf_append_u32(&buf, pcr_idx);
 594
 595         rc = tpm_transmit_cmd(chip, &buf, TPM_DIGEST_SIZE,
 596                               "attempting to read a pcr value");
 597         if (rc)
 598                 goto out;
 599
 600         if (tpm_buf_length(&buf) < TPM_DIGEST_SIZE) {
 601                 rc = -EFAULT;
 602                 goto out;
 603         }
 604
 605         memcpy(res_buf, &buf.data[TPM_HEADER_SIZE], TPM_DIGEST_SIZE);
 606
 607 out:
 608         tpm_buf_destroy(&buf);
 609         return rc;
 610 }
 611
 612 #define TPM_ORD_CONTINUE_SELFTEST 83
 613 /**
 614  * tpm1_continue_selftest() - run TPM's selftest
 615  * @chip: TPM chip to use
 616  *
 617  * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
 618  * a TPM error code.
 619  */
 620 static int tpm1_continue_selftest(struct tpm_chip *chip)
 621 {
 622         struct tpm_buf buf;
 623         int rc;
 624
 625         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_CONTINUE_SELFTEST);
 626         if (rc)
 627                 return rc;
 628
 629         rc = tpm_transmit_cmd(chip, &buf, 0, "continue selftest");
 630         tpm_buf_destroy(&buf);
 631         return rc;
 632 }
 633
 634 /**
 635  * tpm1_do_selftest - have the TPM continue its selftest and wait until it
 636  *                   can receive further commands
 637  * @chip: TPM chip to use
 638  *
 639  * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
 640  * a TPM error code.
 641  */
 642 int tpm1_do_selftest(struct tpm_chip *chip)
 643 {
 644         int rc;
 645         unsigned int loops;
 646         unsigned int delay_msec = 100;
 647         unsigned long duration;
 648         u8 dummy[TPM_DIGEST_SIZE];
 649
 650         duration = tpm1_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
 651
 652         loops = jiffies_to_msecs(duration) / delay_msec;
 653
 654         rc = tpm1_continue_selftest(chip);
 655         if (rc == TPM_ERR_INVALID_POSTINIT) {
 656                 chip->flags |= TPM_CHIP_FLAG_ALWAYS_POWERED;
 657                 dev_info(&chip->dev, "TPM not ready (%d)\n", rc);
 658         }
 659         /* This may fail if there was no TPM driver during a suspend/resume
 660          * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
 661          */
 662         if (rc)
 663                 return rc;
 664
 665         do {
 666                 /* Attempt to read a PCR value */
 667                 rc = tpm1_pcr_read(chip, 0, dummy);
 668
 669                 /* Some buggy TPMs will not respond to tpm_tis_ready() for
 670                  * around 300ms while the self test is ongoing, keep trying
 671                  * until the self test duration expires.
 672                  */
 673                 if (rc == -ETIME) {
 674                         dev_info(&chip->dev, HW_ERR "TPM command timed out during continue self test");
 675                         tpm_msleep(delay_msec);
 676                         continue;
 677                 }
 678
 679                 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
 680                         dev_info(&chip->dev, "TPM is disabled/deactivated (0x%X)\n",
 681                                  rc);
 682                         /* TPM is disabled and/or deactivated; driver can
 683                          * proceed and TPM does handle commands for
 684                          * suspend/resume correctly
 685                          */
 686                         return 0;
 687                 }
 688                 if (rc != TPM_WARN_DOING_SELFTEST)
 689                         return rc;
 690                 tpm_msleep(delay_msec);
 691         } while (--loops > 0);
 692
 693         return rc;
 694 }
 695 EXPORT_SYMBOL_GPL(tpm1_do_selftest);
 696
 697 /**
 698  * tpm1_auto_startup - Perform the standard automatic TPM initialization
 699  *                     sequence
 700  * @chip: TPM chip to use
 701  *
 702  * Returns 0 on success, < 0 in case of fatal error.
 703  */
 704 int tpm1_auto_startup(struct tpm_chip *chip)
 705 {
 706         int rc;
 707
 708         rc = tpm1_get_timeouts(chip);
 709         if (rc)
 710                 goto out;
 711         rc = tpm1_do_selftest(chip);
 712         if (rc == TPM_ERR_FAILEDSELFTEST) {
 713                 dev_warn(&chip->dev, "TPM self test failed, switching to the firmware upgrade mode\n");
 714                 /* A TPM in this state possibly allows or needs a firmware upgrade */
 715                 chip->flags |= TPM_CHIP_FLAG_FIRMWARE_UPGRADE;
 716                 return 0;
 717         } else if (rc) {
 718                 dev_err(&chip->dev, "TPM self test failed\n");
 719                 goto out;
 720         }
 721
 722         return rc;
 723 out:
 724         if (rc > 0)
 725                 rc = -ENODEV;
 726         return rc;
 727 }
 728
 729 #define TPM_ORD_SAVESTATE 152
 730
 731 /**
 732  * tpm1_pm_suspend() - pm suspend handler
 733  * @chip: TPM chip to use.
 734  * @tpm_suspend_pcr: flush pcr for buggy TPM chips.
 735  *
 736  * The functions saves the TPM state to be restored on resume.
 737  *
 738  * Return:
 739  * * 0 on success,
 740  * * < 0 on error.
 741  */
 742 int tpm1_pm_suspend(struct tpm_chip *chip, u32 tpm_suspend_pcr)
 743 {
 744         u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
 745         struct tpm_buf buf;
 746         unsigned int try;
 747         int rc;
 748
 749
 750         /* for buggy tpm, flush pcrs with extend to selected dummy */
 751         if (tpm_suspend_pcr)
 752                 rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
 753                                      "extending dummy pcr before suspend");
 754
 755         rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_SAVESTATE);
 756         if (rc)
 757                 return rc;
 758         /* now do the actual savestate */
 759         for (try = 0; try < TPM_RETRY; try++) {
 760                 rc = tpm_transmit_cmd(chip, &buf, 0, NULL);
 761                 /*
 762                  * If the TPM indicates that it is too busy to respond to
 763                  * this command then retry before giving up.  It can take
 764                  * several seconds for this TPM to be ready.
 765                  *
 766                  * This can happen if the TPM has already been sent the
 767                  * SaveState command before the driver has loaded.  TCG 1.2
 768                  * specification states that any communication after SaveState
 769                  * may cause the TPM to invalidate previously saved state.
 770                  */
 771                 if (rc != TPM_WARN_RETRY)
 772                         break;
 773                 tpm_msleep(TPM_TIMEOUT_RETRY);
 774
 775                 tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_SAVESTATE);
 776         }
 777
 778         if (rc)
 779                 dev_err(&chip->dev, "Error (%d) sending savestate before suspend\n",
 780                         rc);
 781         else if (try > 0)
 782                 dev_warn(&chip->dev, "TPM savestate took %dms\n",
 783                          try * TPM_TIMEOUT_RETRY);
 784
 785         tpm_buf_destroy(&buf);
 786
 787         return rc;
 788 }
 789
 790 /**
 791  * tpm1_get_pcr_allocation() - initialize the allocated bank
 792  * @chip: TPM chip to use.
 793  *
 794  * The function initializes the SHA1 allocated bank to extend PCR
 795  *
 796  * Return:
 797  * * 0 on success,
 798  * * < 0 on error.
 799  */
 800 int tpm1_get_pcr_allocation(struct tpm_chip *chip)
 801 {
 802         chip->allocated_banks = kcalloc(1, sizeof(*chip->allocated_banks),
 803                                         GFP_KERNEL);
 804         if (!chip->allocated_banks)
 805                 return -ENOMEM;
 806
 807         chip->allocated_banks[0].alg_id = TPM_ALG_SHA1;
 808         chip->allocated_banks[0].digest_size = hash_digest_size[HASH_ALGO_SHA1];
 809         chip->allocated_banks[0].crypto_id = HASH_ALGO_SHA1;
 810         chip->nr_allocated_banks = 1;
 811
 812         return 0;
 813 }