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