projects/linux·blob master · refs

576 lines · 13.0 KiB

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 * Leendert van Doorn <[email protected]>
8 * Dave Safford <[email protected]>
9 * Reiner Sailer <[email protected]>
10 * Kylene Hall <[email protected]>
11 *
12 * Maintained by: <[email protected]>
13 *
14 * Device driver for TCG/TCPA TPM (trusted platform module).
15 * Specifications at www.trustedcomputinggroup.org
16 *
17 * Note, the TPM chip is not interrupt driven (only polling)
18 * and can have very long timeouts (minutes!). Hence the unusual
19 * calls to msleep.
20 */
21
22#include <linux/poll.h>
23#include <linux/slab.h>
24#include <linux/mutex.h>
25#include <linux/spinlock.h>
26#include <linux/suspend.h>
27#include <linux/freezer.h>
28#include <linux/tpm_eventlog.h>
29
30#include "tpm.h"
31
32/*
33 * Bug workaround - some TPM's don't flush the most
34 * recently changed pcr on suspend, so force the flush
35 * with an extend to the selected _unused_ non-volatile pcr.
36 */
37static u32 tpm_suspend_pcr;
38module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
39MODULE_PARM_DESC(suspend_pcr,
40 "PCR to use for dummy writes to facilitate flush on suspend.");
41
42/**
43 * tpm_calc_ordinal_duration() - calculate the maximum command duration
44 * @chip: TPM chip to use.
45 * @ordinal: TPM command ordinal.
46 *
47 * The function returns the maximum amount of time the chip could take
48 * to return the result for a particular ordinal in jiffies.
49 *
50 * Return: A maximal duration time for an ordinal in jiffies.
51 */
52unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
53{
54 if (chip->flags & TPM_CHIP_FLAG_TPM2)
55 return tpm2_calc_ordinal_duration(ordinal);
56 else
57 return tpm1_calc_ordinal_duration(chip, ordinal);
58}
59EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
60
61static void tpm_chip_cancel(struct tpm_chip *chip)
62{
63 if (!chip->ops->cancel)
64 return;
65
66 chip->ops->cancel(chip);
67}
68
69static u8 tpm_chip_status(struct tpm_chip *chip)
70{
71 if (!chip->ops->status)
72 return 0;
73
74 return chip->ops->status(chip);
75}
76
77static bool tpm_chip_req_canceled(struct tpm_chip *chip, u8 status)
78{
79 if (!chip->ops->req_canceled)
80 return false;
81
82 return chip->ops->req_canceled(chip, status);
83}
84
85static bool tpm_transmit_completed(u8 status, struct tpm_chip *chip)
86{
87 u8 status_masked = status & chip->ops->req_complete_mask;
88
89 return status_masked == chip->ops->req_complete_val;
90}
91
92static ssize_t tpm_try_transmit(struct tpm_chip *chip, void *buf, size_t bufsiz)
93{
94 struct tpm_header *header = buf;
95 int rc;
96 ssize_t len = 0;
97 u32 count, ordinal;
98 unsigned long stop;
99
100 if (bufsiz < TPM_HEADER_SIZE)
101 return -EINVAL;
102
103 if (bufsiz > TPM_BUFSIZE)
104 bufsiz = TPM_BUFSIZE;
105
106 count = be32_to_cpu(header->length);
107 ordinal = be32_to_cpu(header->ordinal);
108 if (count == 0)
109 return -ENODATA;
110 if (count > bufsiz) {
111 dev_err(&chip->dev,
112 "invalid count value %x %zx\n", count, bufsiz);
113 return -E2BIG;
114 }
115
116 rc = chip->ops->send(chip, buf, bufsiz, count);
117 if (rc < 0) {
118 if (rc != -EPIPE)
119 dev_err(&chip->dev,
120 "%s: send(): error %d\n", __func__, rc);
121 return rc;
122 }
123
124 /*
125 * Synchronous devices return the response directly during the send()
126 * call in the same buffer.
127 */
128 if (chip->flags & TPM_CHIP_FLAG_SYNC) {
129 len = rc;
130 rc = 0;
131 goto out_sync;
132 }
133
134 /*
135 * A sanity check. send() of asynchronous devices should just return
136 * zero on success e.g. not the command length.
137 */
138 if (rc > 0) {
139 dev_warn(&chip->dev,
140 "%s: send(): invalid value %d\n", __func__, rc);
141 rc = 0;
142 }
143
144 if (chip->flags & TPM_CHIP_FLAG_IRQ)
145 goto out_recv;
146
147 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
148 do {
149 u8 status = tpm_chip_status(chip);
150 if (tpm_transmit_completed(status, chip))
151 goto out_recv;
152
153 if (tpm_chip_req_canceled(chip, status)) {
154 dev_err(&chip->dev, "Operation Canceled\n");
155 return -ECANCELED;
156 }
157
158 tpm_msleep(TPM_TIMEOUT_POLL);
159 rmb();
160 } while (time_before(jiffies, stop));
161
162 /*
163 * Check for completion one more time, just in case the device reported
164 * it while the driver was sleeping in the busy loop above.
165 */
166 if (tpm_transmit_completed(tpm_chip_status(chip), chip))
167 goto out_recv;
168
169 tpm_chip_cancel(chip);
170 dev_err(&chip->dev, "Operation Timed out\n");
171 return -ETIME;
172
173out_recv:
174 len = chip->ops->recv(chip, buf, bufsiz);
175 if (len < 0) {
176 rc = len;
177 dev_err(&chip->dev, "tpm_transmit: tpm_recv: error %d\n", rc);
178 return rc;
179 }
180out_sync:
181 if (len < TPM_HEADER_SIZE || len != be32_to_cpu(header->length))
182 rc = -EFAULT;
183
184 return rc ? rc : len;
185}
186
187/**
188 * tpm_transmit - Internal kernel interface to transmit TPM commands.
189 * @chip: a TPM chip to use
190 * @buf: a TPM command buffer
191 * @bufsiz: length of the TPM command buffer
192 *
193 * A wrapper around tpm_try_transmit() that handles TPM2_RC_RETRY returns from
194 * the TPM and retransmits the command after a delay up to a maximum wait of
195 * TPM2_DURATION_LONG.
196 *
197 * Note that TPM 1.x never returns TPM2_RC_RETRY so the retry logic is TPM 2.0
198 * only.
199 *
200 * Return:
201 * * The response length - OK
202 * * -errno - A system error
203 */
204ssize_t tpm_transmit(struct tpm_chip *chip, u8 *buf, size_t bufsiz)
205{
206 struct tpm_header *header = (struct tpm_header *)buf;
207 /* space for header and handles */
208 u8 save[TPM_HEADER_SIZE + 3*sizeof(u32)];
209 unsigned int delay_msec = TPM2_DURATION_SHORT;
210 u32 rc = 0;
211 ssize_t ret;
212 const size_t save_size = min(sizeof(save), bufsiz);
213 /* the command code is where the return code will be */
214 u32 cc = be32_to_cpu(header->return_code);
215
216 /*
217 * Subtlety here: if we have a space, the handles will be
218 * transformed, so when we restore the header we also have to
219 * restore the handles.
220 */
221 memcpy(save, buf, save_size);
222
223 for (;;) {
224 ret = tpm_try_transmit(chip, buf, bufsiz);
225 if (ret < 0)
226 break;
227 rc = be32_to_cpu(header->return_code);
228 if (rc != TPM2_RC_RETRY && rc != TPM2_RC_TESTING)
229 break;
230 /*
231 * return immediately if self test returns test
232 * still running to shorten boot time.
233 */
234 if (rc == TPM2_RC_TESTING && cc == TPM2_CC_SELF_TEST)
235 break;
236
237 if (delay_msec > TPM2_DURATION_LONG) {
238 if (rc == TPM2_RC_RETRY)
239 dev_err(&chip->dev, "in retry loop\n");
240 else
241 dev_err(&chip->dev,
242 "self test is still running\n");
243 break;
244 }
245 tpm_msleep(delay_msec);
246 delay_msec *= 2;
247 memcpy(buf, save, save_size);
248 }
249 return ret;
250}
251
252/**
253 * tpm_transmit_cmd - send a tpm command to the device
254 * @chip: a TPM chip to use
255 * @buf: a TPM command buffer
256 * @min_rsp_body_length: minimum expected length of response body
257 * @desc: command description used in the error message
258 *
259 * Return:
260 * * 0 - OK
261 * * -errno - A system error
262 * * TPM_RC - A TPM error
263 */
264ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_buf *buf,
265 size_t min_rsp_body_length, const char *desc)
266{
267 const struct tpm_header *header = (struct tpm_header *)buf->data;
268 int err;
269 ssize_t len;
270
271 len = tpm_transmit(chip, buf->data, buf->capacity);
272 if (len < 0)
273 return len;
274
275 err = be32_to_cpu(header->return_code);
276 if (err != 0 && err != TPM_ERR_DISABLED && err != TPM_ERR_DEACTIVATED
277 && err != TPM2_RC_TESTING && desc)
278 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
279 desc);
280 if (err)
281 return err;
282
283 if (len < min_rsp_body_length + TPM_HEADER_SIZE)
284 return -EFAULT;
285
286 buf->length = len;
287 return 0;
288}
289EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
290
291int tpm_get_timeouts(struct tpm_chip *chip)
292{
293 if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS)
294 return 0;
295
296 if (chip->flags & TPM_CHIP_FLAG_TPM2)
297 return tpm2_get_timeouts(chip);
298 else
299 return tpm1_get_timeouts(chip);
300}
301EXPORT_SYMBOL_GPL(tpm_get_timeouts);
302
303/**
304 * tpm_is_tpm2 - do we a have a TPM2 chip?
305 * @chip: a &struct tpm_chip instance, %NULL for the default chip
306 *
307 * Return:
308 * 1 if we have a TPM2 chip.
309 * 0 if we don't have a TPM2 chip.
310 * A negative number for system errors (errno).
311 */
312int tpm_is_tpm2(struct tpm_chip *chip)
313{
314 int rc;
315
316 if (!chip)
317 return -ENODEV;
318
319 rc = tpm_try_get_ops(chip);
320 if (rc)
321 return rc;
322
323 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0;
324
325 tpm_put_ops(chip);
326
327 return rc;
328}
329EXPORT_SYMBOL_GPL(tpm_is_tpm2);
330
331/**
332 * tpm_pcr_read - read a PCR value from SHA1 bank
333 * @chip: a &struct tpm_chip instance, %NULL for the default chip
334 * @pcr_idx: the PCR to be retrieved
335 * @digest: the PCR bank and buffer current PCR value is written to
336 *
337 * Return: same as with tpm_transmit_cmd()
338 */
339int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx,
340 struct tpm_digest *digest)
341{
342 int rc;
343
344 if (!chip)
345 return -ENODEV;
346
347 rc = tpm_try_get_ops(chip);
348 if (rc)
349 return rc;
350
351 if (chip->flags & TPM_CHIP_FLAG_TPM2)
352 rc = tpm2_pcr_read(chip, pcr_idx, digest, NULL);
353 else
354 rc = tpm1_pcr_read(chip, pcr_idx, digest->digest);
355
356 tpm_put_ops(chip);
357 return rc;
358}
359EXPORT_SYMBOL_GPL(tpm_pcr_read);
360
361/**
362 * tpm_pcr_extend - extend a PCR value in SHA1 bank.
363 * @chip: a &struct tpm_chip instance, %NULL for the default chip
364 * @pcr_idx: the PCR to be retrieved
365 * @digests: array of tpm_digest structures used to extend PCRs
366 *
367 * Note: callers must pass a digest for every allocated PCR bank, in the same
368 * order of the banks in chip->allocated_banks.
369 *
370 * Return: same as with tpm_transmit_cmd()
371 */
372int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx,
373 struct tpm_digest *digests)
374{
375 int rc;
376 int i;
377
378 if (!chip)
379 return -ENODEV;
380
381 rc = tpm_try_get_ops(chip);
382 if (rc)
383 return rc;
384
385 for (i = 0; i < chip->nr_allocated_banks; i++) {
386 if (digests[i].alg_id != chip->allocated_banks[i].alg_id) {
387 rc = -EINVAL;
388 goto out;
389 }
390 }
391
392 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
393 rc = tpm2_pcr_extend(chip, pcr_idx, digests);
394 goto out;
395 }
396
397 rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest,
398 "attempting extend a PCR value");
399
400out:
401 tpm_put_ops(chip);
402 return rc;
403}
404EXPORT_SYMBOL_GPL(tpm_pcr_extend);
405
406int tpm_auto_startup(struct tpm_chip *chip)
407{
408 int rc;
409
410 if (!(chip->ops->flags & TPM_OPS_AUTO_STARTUP))
411 return 0;
412
413 if (chip->flags & TPM_CHIP_FLAG_TPM2)
414 rc = tpm2_auto_startup(chip);
415 else
416 rc = tpm1_auto_startup(chip);
417
418 return rc;
419}
420
421/*
422 * We are about to suspend. Save the TPM state
423 * so that it can be restored.
424 */
425int tpm_pm_suspend(struct device *dev)
426{
427 struct tpm_chip *chip = dev_get_drvdata(dev);
428 int rc = 0;
429
430 if (!chip)
431 return -ENODEV;
432
433 rc = tpm_try_get_ops(chip);
434 if (rc) {
435 /* Can be safely set out of locks, as no action cannot race: */
436 chip->flags |= TPM_CHIP_FLAG_SUSPENDED;
437 goto out;
438 }
439
440 if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)
441 goto suspended;
442
443 if ((chip->flags & TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED) &&
444 !pm_suspend_via_firmware())
445 goto suspended;
446
447 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
448 tpm2_end_auth_session(chip);
449 tpm2_shutdown(chip, TPM2_SU_STATE);
450 goto suspended;
451 }
452
453 rc = tpm1_pm_suspend(chip, tpm_suspend_pcr);
454
455suspended:
456 chip->flags |= TPM_CHIP_FLAG_SUSPENDED;
457 tpm_put_ops(chip);
458
459out:
460 if (rc)
461 dev_err(dev, "Ignoring error %d while suspending\n", rc);
462 return 0;
463}
464EXPORT_SYMBOL_GPL(tpm_pm_suspend);
465
466/*
467 * Resume from a power safe. The BIOS already restored
468 * the TPM state.
469 */
470int tpm_pm_resume(struct device *dev)
471{
472 struct tpm_chip *chip = dev_get_drvdata(dev);
473
474 if (chip == NULL)
475 return -ENODEV;
476
477 chip->flags &= ~TPM_CHIP_FLAG_SUSPENDED;
478
479 /*
480 * Guarantee that SUSPENDED is written last, so that hwrng does not
481 * activate before the chip has been fully resumed.
482 */
483 wmb();
484
485 return 0;
486}
487EXPORT_SYMBOL_GPL(tpm_pm_resume);
488
489/**
490 * tpm_get_random() - get random bytes from the TPM's RNG
491 * @chip: a &struct tpm_chip instance, %NULL for the default chip
492 * @out: destination buffer for the random bytes
493 * @max: the max number of bytes to write to @out
494 *
495 * Return: number of random bytes read or a negative error value.
496 */
497int tpm_get_random(struct tpm_chip *chip, u8 *out, size_t max)
498{
499 int rc;
500
501 if (!out || max > TPM_MAX_RNG_DATA)
502 return -EINVAL;
503
504 if (!chip)
505 return -ENODEV;
506
507 rc = tpm_try_get_ops(chip);
508 if (rc)
509 return rc;
510
511 if (chip->flags & TPM_CHIP_FLAG_TPM2)
512 rc = tpm2_get_random(chip, out, max);
513 else
514 rc = tpm1_get_random(chip, out, max);
515
516 tpm_put_ops(chip);
517 return rc;
518}
519EXPORT_SYMBOL_GPL(tpm_get_random);
520
521static int __init tpm_init(void)
522{
523 int rc;
524
525 rc = class_register(&tpm_class);
526 if (rc) {
527 pr_err("couldn't create tpm class\n");
528 return rc;
529 }
530
531 rc = class_register(&tpmrm_class);
532 if (rc) {
533 pr_err("couldn't create tpmrm class\n");
534 goto out_destroy_tpm_class;
535 }
536
537 rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm");
538 if (rc < 0) {
539 pr_err("tpm: failed to allocate char dev region\n");
540 goto out_destroy_tpmrm_class;
541 }
542
543 rc = tpm_dev_common_init();
544 if (rc) {
545 pr_err("tpm: failed to allocate char dev region\n");
546 goto out_unreg_chrdev;
547 }
548
549 return 0;
550
551out_unreg_chrdev:
552 unregister_chrdev_region(tpm_devt, 2 * TPM_NUM_DEVICES);
553out_destroy_tpmrm_class:
554 class_unregister(&tpmrm_class);
555out_destroy_tpm_class:
556 class_unregister(&tpm_class);
557
558 return rc;
559}
560
561static void __exit tpm_exit(void)
562{
563 idr_destroy(&dev_nums_idr);
564 class_unregister(&tpm_class);
565 class_unregister(&tpmrm_class);
566 unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES);
567 tpm_dev_common_exit();
568}
569
570subsys_initcall(tpm_init);
571module_exit(tpm_exit);
572
573MODULE_AUTHOR("Leendert van Doorn <[email protected]>");
574MODULE_DESCRIPTION("TPM Driver");
575MODULE_VERSION("2.0");
576MODULE_LICENSE("GPL");