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