drivers/char/tpm/tpm-chip.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2004 IBM Corporation
   4  * Copyright (C) 2014 Intel Corporation
   5  *
   6  * Authors:
   7  * Jarkko Sakkinen <[email protected]>
   8  * Leendert van Doorn <[email protected]>
   9  * Dave Safford <[email protected]>
  10  * Reiner Sailer <[email protected]>
  11  * Kylene Hall <[email protected]>
  12  *
  13  * Maintained by: <[email protected]>
  14  *
  15  * TPM chip management routines.
  16  */
  17
  18 #include <linux/poll.h>
  19 #include <linux/slab.h>
  20 #include <linux/mutex.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/freezer.h>
  23 #include <linux/major.h>
  24 #include <linux/tpm_eventlog.h>
  25 #include <linux/hw_random.h>
  26 #include "tpm.h"
  27
  28 DEFINE_IDR(dev_nums_idr);
  29 static DEFINE_MUTEX(idr_lock);
  30
  31 const struct class tpm_class = {
  32         .name = "tpm",
  33         .shutdown_pre = tpm_class_shutdown,
  34 };
  35 const struct class tpmrm_class = {
  36         .name = "tpmrm",
  37 };
  38 dev_t tpm_devt;
  39
  40 static int tpm_request_locality(struct tpm_chip *chip)
  41 {
  42         int rc;
  43
  44         if (!chip->ops->request_locality)
  45                 return 0;
  46
  47         rc = chip->ops->request_locality(chip, 0);
  48         if (rc < 0)
  49                 return rc;
  50
  51         chip->locality = rc;
  52         return 0;
  53 }
  54
  55 static void tpm_relinquish_locality(struct tpm_chip *chip)
  56 {
  57         int rc;
  58
  59         if (!chip->ops->relinquish_locality)
  60                 return;
  61
  62         rc = chip->ops->relinquish_locality(chip, chip->locality);
  63         if (rc)
  64                 dev_err(&chip->dev, "%s: : error %d\n", __func__, rc);
  65
  66         chip->locality = -1;
  67 }
  68
  69 static int tpm_cmd_ready(struct tpm_chip *chip)
  70 {
  71         if (!chip->ops->cmd_ready)
  72                 return 0;
  73
  74         return chip->ops->cmd_ready(chip);
  75 }
  76
  77 static int tpm_go_idle(struct tpm_chip *chip)
  78 {
  79         if (!chip->ops->go_idle)
  80                 return 0;
  81
  82         return chip->ops->go_idle(chip);
  83 }
  84
  85 static void tpm_clk_enable(struct tpm_chip *chip)
  86 {
  87         if (chip->ops->clk_enable)
  88                 chip->ops->clk_enable(chip, true);
  89 }
  90
  91 static void tpm_clk_disable(struct tpm_chip *chip)
  92 {
  93         if (chip->ops->clk_enable)
  94                 chip->ops->clk_enable(chip, false);
  95 }
  96
  97 /**
  98  * tpm_chip_start() - power on the TPM
  99  * @chip:       a TPM chip to use
 100  *
 101  * Return:
 102  * * The response length        - OK
 103  * * -errno                     - A system error
 104  */
 105 int tpm_chip_start(struct tpm_chip *chip)
 106 {
 107         int ret;
 108
 109         tpm_clk_enable(chip);
 110
 111         if (chip->locality == -1) {
 112                 ret = tpm_request_locality(chip);
 113                 if (ret) {
 114                         tpm_clk_disable(chip);
 115                         return ret;
 116                 }
 117         }
 118
 119         ret = tpm_cmd_ready(chip);
 120         if (ret) {
 121                 tpm_relinquish_locality(chip);
 122                 tpm_clk_disable(chip);
 123                 return ret;
 124         }
 125
 126         return 0;
 127 }
 128 EXPORT_SYMBOL_GPL(tpm_chip_start);
 129
 130 /**
 131  * tpm_chip_stop() - power off the TPM
 132  * @chip:       a TPM chip to use
 133  *
 134  * Return:
 135  * * The response length        - OK
 136  * * -errno                     - A system error
 137  */
 138 void tpm_chip_stop(struct tpm_chip *chip)
 139 {
 140         tpm_go_idle(chip);
 141         tpm_relinquish_locality(chip);
 142         tpm_clk_disable(chip);
 143 }
 144 EXPORT_SYMBOL_GPL(tpm_chip_stop);
 145
 146 /**
 147  * tpm_try_get_ops() - Get a ref to the tpm_chip
 148  * @chip: Chip to ref
 149  *
 150  * The caller must already have some kind of locking to ensure that chip is
 151  * valid. This function will lock the chip so that the ops member can be
 152  * accessed safely. The locking prevents tpm_chip_unregister from
 153  * completing, so it should not be held for long periods.
 154  *
 155  * Returns -ERRNO if the chip could not be got.
 156  */
 157 int tpm_try_get_ops(struct tpm_chip *chip)
 158 {
 159         int rc = -EIO;
 160
 161         get_device(&chip->dev);
 162
 163         down_read(&chip->ops_sem);
 164         if (!chip->ops)
 165                 goto out_ops;
 166
 167         mutex_lock(&chip->tpm_mutex);
 168         rc = tpm_chip_start(chip);
 169         if (rc)
 170                 goto out_lock;
 171
 172         return 0;
 173 out_lock:
 174         mutex_unlock(&chip->tpm_mutex);
 175 out_ops:
 176         up_read(&chip->ops_sem);
 177         put_device(&chip->dev);
 178         return rc;
 179 }
 180 EXPORT_SYMBOL_GPL(tpm_try_get_ops);
 181
 182 /**
 183  * tpm_put_ops() - Release a ref to the tpm_chip
 184  * @chip: Chip to put
 185  *
 186  * This is the opposite pair to tpm_try_get_ops(). After this returns chip may
 187  * be kfree'd.
 188  */
 189 void tpm_put_ops(struct tpm_chip *chip)
 190 {
 191         tpm_chip_stop(chip);
 192         mutex_unlock(&chip->tpm_mutex);
 193         up_read(&chip->ops_sem);
 194         put_device(&chip->dev);
 195 }
 196 EXPORT_SYMBOL_GPL(tpm_put_ops);
 197
 198 /**
 199  * tpm_default_chip() - find a TPM chip and get a reference to it
 200  */
 201 struct tpm_chip *tpm_default_chip(void)
 202 {
 203         struct tpm_chip *chip, *res = NULL;
 204         int chip_num = 0;
 205         int chip_prev;
 206
 207         mutex_lock(&idr_lock);
 208
 209         do {
 210                 chip_prev = chip_num;
 211                 chip = idr_get_next(&dev_nums_idr, &chip_num);
 212                 if (chip) {
 213                         get_device(&chip->dev);
 214                         res = chip;
 215                         break;
 216                 }
 217         } while (chip_prev != chip_num);
 218
 219         mutex_unlock(&idr_lock);
 220
 221         return res;
 222 }
 223 EXPORT_SYMBOL_GPL(tpm_default_chip);
 224
 225 /**
 226  * tpm_find_get_ops() - find and reserve a TPM chip
 227  * @chip:       a &struct tpm_chip instance, %NULL for the default chip
 228  *
 229  * Finds a TPM chip and reserves its class device and operations. The chip must
 230  * be released with tpm_put_ops() after use.
 231  * This function is for internal use only. It supports existing TPM callers
 232  * by accepting NULL, but those callers should be converted to pass in a chip
 233  * directly.
 234  *
 235  * Return:
 236  * A reserved &struct tpm_chip instance.
 237  * %NULL if a chip is not found.
 238  * %NULL if the chip is not available.
 239  */
 240 struct tpm_chip *tpm_find_get_ops(struct tpm_chip *chip)
 241 {
 242         int rc;
 243
 244         if (chip) {
 245                 if (!tpm_try_get_ops(chip))
 246                         return chip;
 247                 return NULL;
 248         }
 249
 250         chip = tpm_default_chip();
 251         if (!chip)
 252                 return NULL;
 253         rc = tpm_try_get_ops(chip);
 254         /* release additional reference we got from tpm_default_chip() */
 255         put_device(&chip->dev);
 256         if (rc)
 257                 return NULL;
 258         return chip;
 259 }
 260
 261 /**
 262  * tpm_dev_release() - free chip memory and the device number
 263  * @dev: the character device for the TPM chip
 264  *
 265  * This is used as the release function for the character device.
 266  */
 267 static void tpm_dev_release(struct device *dev)
 268 {
 269         struct tpm_chip *chip = container_of(dev, struct tpm_chip, dev);
 270
 271         mutex_lock(&idr_lock);
 272         idr_remove(&dev_nums_idr, chip->dev_num);
 273         mutex_unlock(&idr_lock);
 274
 275         kfree(chip->work_space.context_buf);
 276         kfree(chip->work_space.session_buf);
 277         kfree(chip->allocated_banks);
 278         kfree(chip);
 279 }
 280
 281 /**
 282  * tpm_class_shutdown() - prepare the TPM device for loss of power.
 283  * @dev: device to which the chip is associated.
 284  *
 285  * Issues a TPM2_Shutdown command prior to loss of power, as required by the
 286  * TPM 2.0 spec. Then, calls bus- and device- specific shutdown code.
 287  *
 288  * Return: always 0 (i.e. success)
 289  */
 290 int tpm_class_shutdown(struct device *dev)
 291 {
 292         struct tpm_chip *chip = container_of(dev, struct tpm_chip, dev);
 293
 294         down_write(&chip->ops_sem);
 295         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
 296                 if (!tpm_chip_start(chip)) {
 297                         tpm2_shutdown(chip, TPM2_SU_CLEAR);
 298                         tpm_chip_stop(chip);
 299                 }
 300         }
 301         chip->ops = NULL;
 302         up_write(&chip->ops_sem);
 303
 304         return 0;
 305 }
 306
 307 /**
 308  * tpm_chip_alloc() - allocate a new struct tpm_chip instance
 309  * @pdev: device to which the chip is associated
 310  *        At this point pdev mst be initialized, but does not have to
 311  *        be registered
 312  * @ops: struct tpm_class_ops instance
 313  *
 314  * Allocates a new struct tpm_chip instance and assigns a free
 315  * device number for it. Must be paired with put_device(&chip->dev).
 316  */
 317 struct tpm_chip *tpm_chip_alloc(struct device *pdev,
 318                                 const struct tpm_class_ops *ops)
 319 {
 320         struct tpm_chip *chip;
 321         int rc;
 322
 323         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 324         if (chip == NULL)
 325                 return ERR_PTR(-ENOMEM);
 326
 327         mutex_init(&chip->tpm_mutex);
 328         init_rwsem(&chip->ops_sem);
 329
 330         chip->ops = ops;
 331
 332         mutex_lock(&idr_lock);
 333         rc = idr_alloc(&dev_nums_idr, NULL, 0, TPM_NUM_DEVICES, GFP_KERNEL);
 334         mutex_unlock(&idr_lock);
 335         if (rc < 0) {
 336                 dev_err(pdev, "No available tpm device numbers\n");
 337                 kfree(chip);
 338                 return ERR_PTR(rc);
 339         }
 340         chip->dev_num = rc;
 341
 342         device_initialize(&chip->dev);
 343
 344         chip->dev.class = &tpm_class;
 345         chip->dev.release = tpm_dev_release;
 346         chip->dev.parent = pdev;
 347         chip->dev.groups = chip->groups;
 348
 349         if (chip->dev_num == 0)
 350                 chip->dev.devt = MKDEV(MISC_MAJOR, TPM_MINOR);
 351         else
 352                 chip->dev.devt = MKDEV(MAJOR(tpm_devt), chip->dev_num);
 353
 354         rc = dev_set_name(&chip->dev, "tpm%d", chip->dev_num);
 355         if (rc)
 356                 goto out;
 357
 358         if (!pdev)
 359                 chip->flags |= TPM_CHIP_FLAG_VIRTUAL;
 360
 361         cdev_init(&chip->cdev, &tpm_fops);
 362         chip->cdev.owner = THIS_MODULE;
 363
 364         rc = tpm2_init_space(&chip->work_space, TPM2_SPACE_BUFFER_SIZE);
 365         if (rc) {
 366                 rc = -ENOMEM;
 367                 goto out;
 368         }
 369
 370         chip->locality = -1;
 371         return chip;
 372
 373 out:
 374         put_device(&chip->dev);
 375         return ERR_PTR(rc);
 376 }
 377 EXPORT_SYMBOL_GPL(tpm_chip_alloc);
 378
 379 static void tpm_put_device(void *dev)
 380 {
 381         put_device(dev);
 382 }
 383
 384 /**
 385  * tpmm_chip_alloc() - allocate a new struct tpm_chip instance
 386  * @pdev: parent device to which the chip is associated
 387  * @ops: struct tpm_class_ops instance
 388  *
 389  * Same as tpm_chip_alloc except devm is used to do the put_device
 390  */
 391 struct tpm_chip *tpmm_chip_alloc(struct device *pdev,
 392                                  const struct tpm_class_ops *ops)
 393 {
 394         struct tpm_chip *chip;
 395         int rc;
 396
 397         chip = tpm_chip_alloc(pdev, ops);
 398         if (IS_ERR(chip))
 399                 return chip;
 400
 401         rc = devm_add_action_or_reset(pdev,
 402                                       tpm_put_device,
 403                                       &chip->dev);
 404         if (rc)
 405                 return ERR_PTR(rc);
 406
 407         dev_set_drvdata(pdev, chip);
 408
 409         return chip;
 410 }
 411 EXPORT_SYMBOL_GPL(tpmm_chip_alloc);
 412
 413 static int tpm_add_char_device(struct tpm_chip *chip)
 414 {
 415         int rc;
 416
 417         rc = cdev_device_add(&chip->cdev, &chip->dev);
 418         if (rc) {
 419                 dev_err(&chip->dev,
 420                         "unable to cdev_device_add() %s, major %d, minor %d, err=%d\n",
 421                         dev_name(&chip->dev), MAJOR(chip->dev.devt),
 422                         MINOR(chip->dev.devt), rc);
 423                 return rc;
 424         }
 425
 426         if (chip->flags & TPM_CHIP_FLAG_TPM2 && !tpm_is_firmware_upgrade(chip)) {
 427                 rc = tpm_devs_add(chip);
 428                 if (rc)
 429                         goto err_del_cdev;
 430         }
 431
 432         /* Make the chip available. */
 433         mutex_lock(&idr_lock);
 434         idr_replace(&dev_nums_idr, chip, chip->dev_num);
 435         mutex_unlock(&idr_lock);
 436
 437         return 0;
 438
 439 err_del_cdev:
 440         cdev_device_del(&chip->cdev, &chip->dev);
 441         return rc;
 442 }
 443
 444 static void tpm_del_char_device(struct tpm_chip *chip)
 445 {
 446         cdev_device_del(&chip->cdev, &chip->dev);
 447
 448         /* Make the chip unavailable. */
 449         mutex_lock(&idr_lock);
 450         idr_replace(&dev_nums_idr, NULL, chip->dev_num);
 451         mutex_unlock(&idr_lock);
 452
 453         /* Make the driver uncallable. */
 454         down_write(&chip->ops_sem);
 455
 456         /*
 457          * Check if chip->ops is still valid: In case that the controller
 458          * drivers shutdown handler unregisters the controller in its
 459          * shutdown handler we are called twice and chip->ops to NULL.
 460          */
 461         if (chip->ops) {
 462                 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
 463                         if (!tpm_chip_start(chip)) {
 464                                 tpm2_shutdown(chip, TPM2_SU_CLEAR);
 465                                 tpm_chip_stop(chip);
 466                         }
 467                 }
 468                 chip->ops = NULL;
 469         }
 470         up_write(&chip->ops_sem);
 471 }
 472
 473 static void tpm_del_legacy_sysfs(struct tpm_chip *chip)
 474 {
 475         struct attribute **i;
 476
 477         if (chip->flags & (TPM_CHIP_FLAG_TPM2 | TPM_CHIP_FLAG_VIRTUAL) ||
 478             tpm_is_firmware_upgrade(chip))
 479                 return;
 480
 481         sysfs_remove_link(&chip->dev.parent->kobj, "ppi");
 482
 483         for (i = chip->groups[0]->attrs; *i != NULL; ++i)
 484                 sysfs_remove_link(&chip->dev.parent->kobj, (*i)->name);
 485 }
 486
 487 /* For compatibility with legacy sysfs paths we provide symlinks from the
 488  * parent dev directory to selected names within the tpm chip directory. Old
 489  * kernel versions created these files directly under the parent.
 490  */
 491 static int tpm_add_legacy_sysfs(struct tpm_chip *chip)
 492 {
 493         struct attribute **i;
 494         int rc;
 495
 496         if (chip->flags & (TPM_CHIP_FLAG_TPM2 | TPM_CHIP_FLAG_VIRTUAL) ||
 497                 tpm_is_firmware_upgrade(chip))
 498                 return 0;
 499
 500         rc = compat_only_sysfs_link_entry_to_kobj(
 501                     &chip->dev.parent->kobj, &chip->dev.kobj, "ppi", NULL);
 502         if (rc && rc != -ENOENT)
 503                 return rc;
 504
 505         /* All the names from tpm-sysfs */
 506         for (i = chip->groups[0]->attrs; *i != NULL; ++i) {
 507                 rc = compat_only_sysfs_link_entry_to_kobj(
 508                     &chip->dev.parent->kobj, &chip->dev.kobj, (*i)->name, NULL);
 509                 if (rc) {
 510                         tpm_del_legacy_sysfs(chip);
 511                         return rc;
 512                 }
 513         }
 514
 515         return 0;
 516 }
 517
 518 static int tpm_hwrng_read(struct hwrng *rng, void *data, size_t max, bool wait)
 519 {
 520         struct tpm_chip *chip = container_of(rng, struct tpm_chip, hwrng);
 521
 522         /* Give back zero bytes, as TPM chip has not yet fully resumed: */
 523         if (chip->flags & TPM_CHIP_FLAG_SUSPENDED)
 524                 return 0;
 525
 526         return tpm_get_random(chip, data, max);
 527 }
 528
 529 static bool tpm_is_hwrng_enabled(struct tpm_chip *chip)
 530 {
 531         if (!IS_ENABLED(CONFIG_HW_RANDOM_TPM))
 532                 return false;
 533         if (tpm_is_firmware_upgrade(chip))
 534                 return false;
 535         if (chip->flags & TPM_CHIP_FLAG_HWRNG_DISABLED)
 536                 return false;
 537         return true;
 538 }
 539
 540 static int tpm_add_hwrng(struct tpm_chip *chip)
 541 {
 542         if (!tpm_is_hwrng_enabled(chip))
 543                 return 0;
 544
 545         snprintf(chip->hwrng_name, sizeof(chip->hwrng_name),
 546                  "tpm-rng-%d", chip->dev_num);
 547         chip->hwrng.name = chip->hwrng_name;
 548         chip->hwrng.read = tpm_hwrng_read;
 549         return hwrng_register(&chip->hwrng);
 550 }
 551
 552 static int tpm_get_pcr_allocation(struct tpm_chip *chip)
 553 {
 554         int rc;
 555
 556         if (tpm_is_firmware_upgrade(chip))
 557                 return 0;
 558
 559         rc = (chip->flags & TPM_CHIP_FLAG_TPM2) ?
 560              tpm2_get_pcr_allocation(chip) :
 561              tpm1_get_pcr_allocation(chip);
 562
 563         if (rc > 0)
 564                 return -ENODEV;
 565
 566         return rc;
 567 }
 568
 569 /*
 570  * tpm_chip_bootstrap() - Boostrap TPM chip after power on
 571  * @chip: TPM chip to use.
 572  *
 573  * Initialize TPM chip after power on. This a one-shot function: subsequent
 574  * calls will have no effect.
 575  */
 576 int tpm_chip_bootstrap(struct tpm_chip *chip)
 577 {
 578         int rc;
 579
 580         if (chip->flags & TPM_CHIP_FLAG_BOOTSTRAPPED)
 581                 return 0;
 582
 583         rc = tpm_chip_start(chip);
 584         if (rc)
 585                 return rc;
 586
 587         rc = tpm_auto_startup(chip);
 588         if (rc)
 589                 goto stop;
 590
 591         rc = tpm_get_pcr_allocation(chip);
 592 stop:
 593         tpm_chip_stop(chip);
 594
 595         /*
 596          * Unconditionally set, as driver initialization should cease, when the
 597          * boostrapping process fails.
 598          */
 599         chip->flags |= TPM_CHIP_FLAG_BOOTSTRAPPED;
 600
 601         return rc;
 602 }
 603 EXPORT_SYMBOL_GPL(tpm_chip_bootstrap);
 604
 605 /*
 606  * tpm_chip_register() - create a character device for the TPM chip
 607  * @chip: TPM chip to use.
 608  *
 609  * Creates a character device for the TPM chip and adds sysfs attributes for
 610  * the device. As the last step this function adds the chip to the list of TPM
 611  * chips available for in-kernel use.
 612  *
 613  * This function should be only called after the chip initialization is
 614  * complete.
 615  */
 616 int tpm_chip_register(struct tpm_chip *chip)
 617 {
 618         int rc;
 619
 620         rc = tpm_chip_bootstrap(chip);
 621         if (rc)
 622                 return rc;
 623
 624         tpm_sysfs_add_device(chip);
 625
 626         tpm_bios_log_setup(chip);
 627
 628         tpm_add_ppi(chip);
 629
 630         rc = tpm_add_hwrng(chip);
 631         if (rc)
 632                 goto out_ppi;
 633
 634         rc = tpm_add_char_device(chip);
 635         if (rc)
 636                 goto out_hwrng;
 637
 638         rc = tpm_add_legacy_sysfs(chip);
 639         if (rc) {
 640                 tpm_chip_unregister(chip);
 641                 return rc;
 642         }
 643
 644         return 0;
 645
 646 out_hwrng:
 647         if (tpm_is_hwrng_enabled(chip))
 648                 hwrng_unregister(&chip->hwrng);
 649 out_ppi:
 650         tpm_bios_log_teardown(chip);
 651
 652         return rc;
 653 }
 654 EXPORT_SYMBOL_GPL(tpm_chip_register);
 655
 656 /*
 657  * tpm_chip_unregister() - release the TPM driver
 658  * @chip: TPM chip to use.
 659  *
 660  * Takes the chip first away from the list of available TPM chips and then
 661  * cleans up all the resources reserved by tpm_chip_register().
 662  *
 663  * Once this function returns the driver call backs in 'op's will not be
 664  * running and will no longer start.
 665  *
 666  * NOTE: This function should be only called before deinitializing chip
 667  * resources.
 668  */
 669 void tpm_chip_unregister(struct tpm_chip *chip)
 670 {
 671         tpm_del_legacy_sysfs(chip);
 672         if (tpm_is_hwrng_enabled(chip))
 673                 hwrng_unregister(&chip->hwrng);
 674         tpm_bios_log_teardown(chip);
 675         if (chip->flags & TPM_CHIP_FLAG_TPM2 && !tpm_is_firmware_upgrade(chip))
 676                 tpm_devs_remove(chip);
 677         tpm_del_char_device(chip);
 678 }
 679 EXPORT_SYMBOL_GPL(tpm_chip_unregister);