2 * Copyright (C) 2004 IBM Corporation
3 * Copyright (C) 2014 Intel Corporation
6 * Leendert van Doorn <leendert@watson.ibm.com>
7 * Dave Safford <safford@watson.ibm.com>
8 * Reiner Sailer <sailer@watson.ibm.com>
9 * Kylene Hall <kjhall@us.ibm.com>
11 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
13 * Device driver for TCG/TCPA TPM (trusted platform module).
14 * Specifications at www.trustedcomputinggroup.org
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation, version 2 of the
21 * Note, the TPM chip is not interrupt driven (only polling)
22 * and can have very long timeouts (minutes!). Hence the unusual
27 #include <linux/poll.h>
28 #include <linux/slab.h>
29 #include <linux/mutex.h>
30 #include <linux/spinlock.h>
31 #include <linux/freezer.h>
32 #include <linux/pm_runtime.h>
35 #include "tpm_eventlog.h"
37 #define TPM_MAX_ORDINAL 243
38 #define TSC_MAX_ORDINAL 12
39 #define TPM_PROTECTED_COMMAND 0x00
40 #define TPM_CONNECTION_COMMAND 0x40
43 * Bug workaround - some TPM's don't flush the most
44 * recently changed pcr on suspend, so force the flush
45 * with an extend to the selected _unused_ non-volatile pcr.
47 static int tpm_suspend_pcr
;
48 module_param_named(suspend_pcr
, tpm_suspend_pcr
, uint
, 0644);
49 MODULE_PARM_DESC(suspend_pcr
,
50 "PCR to use for dummy writes to faciltate flush on suspend.");
53 * Array with one entry per ordinal defining the maximum amount
54 * of time the chip could take to return the result. The ordinal
55 * designation of short, medium or long is defined in a table in
56 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
57 * values of the SHORT, MEDIUM, and LONG durations are retrieved
58 * from the chip during initialization with a call to tpm_get_timeouts.
60 static const u8 tpm_ordinal_duration
[TPM_MAX_ORDINAL
] = {
61 TPM_UNDEFINED
, /* 0 */
66 TPM_UNDEFINED
, /* 5 */
116 TPM_UNDEFINED
, /* 55 */
136 TPM_UNDEFINED
, /* 75 */
146 TPM_UNDEFINED
, /* 85 */
156 TPM_UNDEFINED
, /* 95 */
161 TPM_MEDIUM
, /* 100 */
166 TPM_UNDEFINED
, /* 105 */
196 TPM_UNDEFINED
, /* 135 */
206 TPM_UNDEFINED
, /* 145 */
216 TPM_UNDEFINED
, /* 155 */
226 TPM_UNDEFINED
, /* 165 */
236 TPM_UNDEFINED
, /* 175 */
241 TPM_MEDIUM
, /* 180 */
246 TPM_MEDIUM
, /* 185 */
251 TPM_UNDEFINED
, /* 190 */
256 TPM_UNDEFINED
, /* 195 */
271 TPM_MEDIUM
, /* 210 */
276 TPM_UNDEFINED
, /* 215 */
286 TPM_UNDEFINED
, /* 225 */
296 TPM_UNDEFINED
, /* 235 */
307 * Returns max number of jiffies to wait
309 unsigned long tpm_calc_ordinal_duration(struct tpm_chip
*chip
,
312 int duration_idx
= TPM_UNDEFINED
;
316 * We only have a duration table for protected commands, where the upper
317 * 16 bits are 0. For the few other ordinals the fallback will be used.
319 if (ordinal
< TPM_MAX_ORDINAL
)
320 duration_idx
= tpm_ordinal_duration
[ordinal
];
322 if (duration_idx
!= TPM_UNDEFINED
)
323 duration
= chip
->duration
[duration_idx
];
329 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration
);
332 * tmp_transmit - Internal kernel interface to transmit TPM commands.
334 * @chip: TPM chip to use
335 * @buf: TPM command buffer
336 * @bufsiz: length of the TPM command buffer
337 * @flags: tpm transmit flags - bitmap
340 * 0 when the operation is successful.
341 * A negative number for system errors (errno).
343 ssize_t
tpm_transmit(struct tpm_chip
*chip
, const u8
*buf
, size_t bufsiz
,
350 if (bufsiz
< TPM_HEADER_SIZE
)
353 if (bufsiz
> TPM_BUFSIZE
)
354 bufsiz
= TPM_BUFSIZE
;
356 count
= be32_to_cpu(*((__be32
*) (buf
+ 2)));
357 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
360 if (count
> bufsiz
) {
362 "invalid count value %x %zx\n", count
, bufsiz
);
366 if (!(flags
& TPM_TRANSMIT_UNLOCKED
))
367 mutex_lock(&chip
->tpm_mutex
);
369 if (chip
->dev
.parent
)
370 pm_runtime_get_sync(chip
->dev
.parent
);
372 rc
= chip
->ops
->send(chip
, (u8
*) buf
, count
);
375 "tpm_transmit: tpm_send: error %zd\n", rc
);
379 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
)
382 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
383 stop
= jiffies
+ tpm2_calc_ordinal_duration(chip
, ordinal
);
385 stop
= jiffies
+ tpm_calc_ordinal_duration(chip
, ordinal
);
387 u8 status
= chip
->ops
->status(chip
);
388 if ((status
& chip
->ops
->req_complete_mask
) ==
389 chip
->ops
->req_complete_val
)
392 if (chip
->ops
->req_canceled(chip
, status
)) {
393 dev_err(&chip
->dev
, "Operation Canceled\n");
398 msleep(TPM_TIMEOUT
); /* CHECK */
400 } while (time_before(jiffies
, stop
));
402 chip
->ops
->cancel(chip
);
403 dev_err(&chip
->dev
, "Operation Timed out\n");
408 rc
= chip
->ops
->recv(chip
, (u8
*) buf
, bufsiz
);
411 "tpm_transmit: tpm_recv: error %zd\n", rc
);
413 if (chip
->dev
.parent
)
414 pm_runtime_put_sync(chip
->dev
.parent
);
416 if (!(flags
& TPM_TRANSMIT_UNLOCKED
))
417 mutex_unlock(&chip
->tpm_mutex
);
422 * tmp_transmit_cmd - send a tpm command to the device
423 * The function extracts tpm out header return code
425 * @chip: TPM chip to use
426 * @cmd: TPM command buffer
427 * @len: length of the TPM command
428 * @flags: tpm transmit flags - bitmap
429 * @desc: command description used in the error message
432 * 0 when the operation is successful.
433 * A negative number for system errors (errno).
434 * A positive number for a TPM error.
436 ssize_t
tpm_transmit_cmd(struct tpm_chip
*chip
, const void *cmd
,
437 int len
, unsigned int flags
, const char *desc
)
439 const struct tpm_output_header
*header
;
442 len
= tpm_transmit(chip
, (const u8
*)cmd
, len
, flags
);
445 else if (len
< TPM_HEADER_SIZE
)
450 err
= be32_to_cpu(header
->return_code
);
451 if (err
!= 0 && desc
)
452 dev_err(&chip
->dev
, "A TPM error (%d) occurred %s\n", err
,
458 #define TPM_DIGEST_SIZE 20
459 #define TPM_RET_CODE_IDX 6
460 #define TPM_INTERNAL_RESULT_SIZE 200
461 #define TPM_ORD_GET_CAP cpu_to_be32(101)
462 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
464 static const struct tpm_input_header tpm_getcap_header
= {
465 .tag
= TPM_TAG_RQU_COMMAND
,
466 .length
= cpu_to_be32(22),
467 .ordinal
= TPM_ORD_GET_CAP
470 ssize_t
tpm_getcap(struct tpm_chip
*chip
, u32 subcap_id
, cap_t
*cap
,
473 struct tpm_cmd_t tpm_cmd
;
476 tpm_cmd
.header
.in
= tpm_getcap_header
;
477 if (subcap_id
== TPM_CAP_VERSION_1_1
||
478 subcap_id
== TPM_CAP_VERSION_1_2
) {
479 tpm_cmd
.params
.getcap_in
.cap
= cpu_to_be32(subcap_id
);
480 /*subcap field not necessary */
481 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
482 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
484 if (subcap_id
== TPM_CAP_FLAG_PERM
||
485 subcap_id
== TPM_CAP_FLAG_VOL
)
486 tpm_cmd
.params
.getcap_in
.cap
=
487 cpu_to_be32(TPM_CAP_FLAG
);
489 tpm_cmd
.params
.getcap_in
.cap
=
490 cpu_to_be32(TPM_CAP_PROP
);
491 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
492 tpm_cmd
.params
.getcap_in
.subcap
= cpu_to_be32(subcap_id
);
494 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, 0,
497 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
500 EXPORT_SYMBOL_GPL(tpm_getcap
);
502 #define TPM_ORD_STARTUP cpu_to_be32(153)
503 #define TPM_ST_CLEAR cpu_to_be16(1)
504 #define TPM_ST_STATE cpu_to_be16(2)
505 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
506 static const struct tpm_input_header tpm_startup_header
= {
507 .tag
= TPM_TAG_RQU_COMMAND
,
508 .length
= cpu_to_be32(12),
509 .ordinal
= TPM_ORD_STARTUP
512 static int tpm_startup(struct tpm_chip
*chip
, __be16 startup_type
)
514 struct tpm_cmd_t start_cmd
;
515 start_cmd
.header
.in
= tpm_startup_header
;
517 start_cmd
.params
.startup_in
.startup_type
= startup_type
;
518 return tpm_transmit_cmd(chip
, &start_cmd
, TPM_INTERNAL_RESULT_SIZE
, 0,
519 "attempting to start the TPM");
522 int tpm_get_timeouts(struct tpm_chip
*chip
)
525 unsigned long timeout_old
[4], timeout_chip
[4], timeout_eff
[4];
528 if (chip
->flags
& TPM_CHIP_FLAG_HAVE_TIMEOUTS
)
531 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
532 /* Fixed timeouts for TPM2 */
533 chip
->timeout_a
= msecs_to_jiffies(TPM2_TIMEOUT_A
);
534 chip
->timeout_b
= msecs_to_jiffies(TPM2_TIMEOUT_B
);
535 chip
->timeout_c
= msecs_to_jiffies(TPM2_TIMEOUT_C
);
536 chip
->timeout_d
= msecs_to_jiffies(TPM2_TIMEOUT_D
);
537 chip
->duration
[TPM_SHORT
] =
538 msecs_to_jiffies(TPM2_DURATION_SHORT
);
539 chip
->duration
[TPM_MEDIUM
] =
540 msecs_to_jiffies(TPM2_DURATION_MEDIUM
);
541 chip
->duration
[TPM_LONG
] =
542 msecs_to_jiffies(TPM2_DURATION_LONG
);
544 chip
->flags
|= TPM_CHIP_FLAG_HAVE_TIMEOUTS
;
548 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_TIMEOUT
, &cap
, NULL
);
549 if (rc
== TPM_ERR_INVALID_POSTINIT
) {
550 /* The TPM is not started, we are the first to talk to it.
551 Execute a startup command. */
552 dev_info(&chip
->dev
, "Issuing TPM_STARTUP\n");
553 if (tpm_startup(chip
, TPM_ST_CLEAR
))
556 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_TIMEOUT
, &cap
,
557 "attempting to determine the timeouts");
561 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
566 timeout_old
[0] = jiffies_to_usecs(chip
->timeout_a
);
567 timeout_old
[1] = jiffies_to_usecs(chip
->timeout_b
);
568 timeout_old
[2] = jiffies_to_usecs(chip
->timeout_c
);
569 timeout_old
[3] = jiffies_to_usecs(chip
->timeout_d
);
570 timeout_chip
[0] = be32_to_cpu(cap
.timeout
.a
);
571 timeout_chip
[1] = be32_to_cpu(cap
.timeout
.b
);
572 timeout_chip
[2] = be32_to_cpu(cap
.timeout
.c
);
573 timeout_chip
[3] = be32_to_cpu(cap
.timeout
.d
);
574 memcpy(timeout_eff
, timeout_chip
, sizeof(timeout_eff
));
577 * Provide ability for vendor overrides of timeout values in case
580 if (chip
->ops
->update_timeouts
!= NULL
)
581 chip
->timeout_adjusted
=
582 chip
->ops
->update_timeouts(chip
, timeout_eff
);
584 if (!chip
->timeout_adjusted
) {
585 /* Restore default if chip reported 0 */
588 for (i
= 0; i
< ARRAY_SIZE(timeout_eff
); i
++) {
592 timeout_eff
[i
] = timeout_old
[i
];
593 chip
->timeout_adjusted
= true;
596 if (timeout_eff
[0] != 0 && timeout_eff
[0] < 1000) {
597 /* timeouts in msec rather usec */
598 for (i
= 0; i
!= ARRAY_SIZE(timeout_eff
); i
++)
599 timeout_eff
[i
] *= 1000;
600 chip
->timeout_adjusted
= true;
604 /* Report adjusted timeouts */
605 if (chip
->timeout_adjusted
) {
607 HW_ERR
"Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
608 timeout_chip
[0], timeout_eff
[0],
609 timeout_chip
[1], timeout_eff
[1],
610 timeout_chip
[2], timeout_eff
[2],
611 timeout_chip
[3], timeout_eff
[3]);
614 chip
->timeout_a
= usecs_to_jiffies(timeout_eff
[0]);
615 chip
->timeout_b
= usecs_to_jiffies(timeout_eff
[1]);
616 chip
->timeout_c
= usecs_to_jiffies(timeout_eff
[2]);
617 chip
->timeout_d
= usecs_to_jiffies(timeout_eff
[3]);
619 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_DURATION
, &cap
,
620 "attempting to determine the durations");
624 chip
->duration
[TPM_SHORT
] =
625 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_short
));
626 chip
->duration
[TPM_MEDIUM
] =
627 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_medium
));
628 chip
->duration
[TPM_LONG
] =
629 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_long
));
631 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
632 * value wrong and apparently reports msecs rather than usecs. So we
633 * fix up the resulting too-small TPM_SHORT value to make things work.
634 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
636 if (chip
->duration
[TPM_SHORT
] < (HZ
/ 100)) {
637 chip
->duration
[TPM_SHORT
] = HZ
;
638 chip
->duration
[TPM_MEDIUM
] *= 1000;
639 chip
->duration
[TPM_LONG
] *= 1000;
640 chip
->duration_adjusted
= true;
641 dev_info(&chip
->dev
, "Adjusting TPM timeout parameters.");
644 chip
->flags
|= TPM_CHIP_FLAG_HAVE_TIMEOUTS
;
647 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
649 #define TPM_ORD_CONTINUE_SELFTEST 83
650 #define CONTINUE_SELFTEST_RESULT_SIZE 10
652 static const struct tpm_input_header continue_selftest_header
= {
653 .tag
= TPM_TAG_RQU_COMMAND
,
654 .length
= cpu_to_be32(10),
655 .ordinal
= cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST
),
659 * tpm_continue_selftest -- run TPM's selftest
660 * @chip: TPM chip to use
662 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
665 static int tpm_continue_selftest(struct tpm_chip
*chip
)
668 struct tpm_cmd_t cmd
;
670 cmd
.header
.in
= continue_selftest_header
;
671 rc
= tpm_transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
, 0,
672 "continue selftest");
676 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
677 #define READ_PCR_RESULT_SIZE 30
678 static const struct tpm_input_header pcrread_header
= {
679 .tag
= TPM_TAG_RQU_COMMAND
,
680 .length
= cpu_to_be32(14),
681 .ordinal
= TPM_ORDINAL_PCRREAD
684 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
687 struct tpm_cmd_t cmd
;
689 cmd
.header
.in
= pcrread_header
;
690 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
691 rc
= tpm_transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
, 0,
692 "attempting to read a pcr value");
695 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
701 * tpm_is_tpm2 - is the chip a TPM2 chip?
702 * @chip_num: tpm idx # or ANY
704 * Returns < 0 on error, and 1 or 0 on success depending whether the chip
707 int tpm_is_tpm2(u32 chip_num
)
709 struct tpm_chip
*chip
;
712 chip
= tpm_chip_find_get(chip_num
);
716 rc
= (chip
->flags
& TPM_CHIP_FLAG_TPM2
) != 0;
722 EXPORT_SYMBOL_GPL(tpm_is_tpm2
);
725 * tpm_pcr_read - read a pcr value
726 * @chip_num: tpm idx # or ANY
727 * @pcr_idx: pcr idx to retrieve
728 * @res_buf: TPM_PCR value
729 * size of res_buf is 20 bytes (or NULL if you don't care)
731 * The TPM driver should be built-in, but for whatever reason it
732 * isn't, protect against the chip disappearing, by incrementing
733 * the module usage count.
735 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
737 struct tpm_chip
*chip
;
740 chip
= tpm_chip_find_get(chip_num
);
743 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
744 rc
= tpm2_pcr_read(chip
, pcr_idx
, res_buf
);
746 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
750 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
752 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
753 #define EXTEND_PCR_RESULT_SIZE 34
754 static const struct tpm_input_header pcrextend_header
= {
755 .tag
= TPM_TAG_RQU_COMMAND
,
756 .length
= cpu_to_be32(34),
757 .ordinal
= TPM_ORD_PCR_EXTEND
761 * tpm_pcr_extend - extend pcr value with hash
762 * @chip_num: tpm idx # or AN&
763 * @pcr_idx: pcr idx to extend
764 * @hash: hash value used to extend pcr value
766 * The TPM driver should be built-in, but for whatever reason it
767 * isn't, protect against the chip disappearing, by incrementing
768 * the module usage count.
770 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
772 struct tpm_cmd_t cmd
;
774 struct tpm_chip
*chip
;
776 chip
= tpm_chip_find_get(chip_num
);
780 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
781 rc
= tpm2_pcr_extend(chip
, pcr_idx
, hash
);
786 cmd
.header
.in
= pcrextend_header
;
787 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
788 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
789 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
, 0,
790 "attempting extend a PCR value");
795 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
798 * tpm_do_selftest - have the TPM continue its selftest and wait until it
799 * can receive further commands
800 * @chip: TPM chip to use
802 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
805 int tpm_do_selftest(struct tpm_chip
*chip
)
809 unsigned int delay_msec
= 100;
810 unsigned long duration
;
811 u8 dummy
[TPM_DIGEST_SIZE
];
813 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
815 loops
= jiffies_to_msecs(duration
) / delay_msec
;
817 rc
= tpm_continue_selftest(chip
);
818 /* This may fail if there was no TPM driver during a suspend/resume
819 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
825 /* Attempt to read a PCR value */
826 rc
= tpm_pcr_read_dev(chip
, 0, dummy
);
828 /* Some buggy TPMs will not respond to tpm_tis_ready() for
829 * around 300ms while the self test is ongoing, keep trying
830 * until the self test duration expires. */
834 "TPM command timed out during continue self test");
839 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
841 "TPM is disabled/deactivated (0x%X)\n", rc
);
842 /* TPM is disabled and/or deactivated; driver can
843 * proceed and TPM does handle commands for
844 * suspend/resume correctly
848 if (rc
!= TPM_WARN_DOING_SELFTEST
)
851 } while (--loops
> 0);
855 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
858 * tpm1_auto_startup - Perform the standard automatic TPM initialization
860 * @chip: TPM chip to use
862 * Returns 0 on success, < 0 in case of fatal error.
864 int tpm1_auto_startup(struct tpm_chip
*chip
)
868 rc
= tpm_get_timeouts(chip
);
871 rc
= tpm_do_selftest(chip
);
873 dev_err(&chip
->dev
, "TPM self test failed\n");
884 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
886 struct tpm_chip
*chip
;
889 chip
= tpm_chip_find_get(chip_num
);
893 rc
= tpm_transmit_cmd(chip
, cmd
, buflen
, 0, "attempting tpm_cmd");
898 EXPORT_SYMBOL_GPL(tpm_send
);
900 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
901 bool check_cancel
, bool *canceled
)
903 u8 status
= chip
->ops
->status(chip
);
906 if ((status
& mask
) == mask
)
908 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
915 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
916 wait_queue_head_t
*queue
, bool check_cancel
)
921 bool canceled
= false;
923 /* check current status */
924 status
= chip
->ops
->status(chip
);
925 if ((status
& mask
) == mask
)
928 stop
= jiffies
+ timeout
;
930 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
932 timeout
= stop
- jiffies
;
933 if ((long)timeout
<= 0)
935 rc
= wait_event_interruptible_timeout(*queue
,
936 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
944 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
945 clear_thread_flag(TIF_SIGPENDING
);
951 status
= chip
->ops
->status(chip
);
952 if ((status
& mask
) == mask
)
954 } while (time_before(jiffies
, stop
));
958 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
960 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
961 #define SAVESTATE_RESULT_SIZE 10
963 static const struct tpm_input_header savestate_header
= {
964 .tag
= TPM_TAG_RQU_COMMAND
,
965 .length
= cpu_to_be32(10),
966 .ordinal
= TPM_ORD_SAVESTATE
970 * We are about to suspend. Save the TPM state
971 * so that it can be restored.
973 int tpm_pm_suspend(struct device
*dev
)
975 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
976 struct tpm_cmd_t cmd
;
979 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
984 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
985 tpm2_shutdown(chip
, TPM2_SU_STATE
);
989 /* for buggy tpm, flush pcrs with extend to selected dummy */
990 if (tpm_suspend_pcr
) {
991 cmd
.header
.in
= pcrextend_header
;
992 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
993 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
995 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
, 0,
996 "extending dummy pcr before suspend");
999 /* now do the actual savestate */
1000 for (try = 0; try < TPM_RETRY
; try++) {
1001 cmd
.header
.in
= savestate_header
;
1002 rc
= tpm_transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, 0,
1006 * If the TPM indicates that it is too busy to respond to
1007 * this command then retry before giving up. It can take
1008 * several seconds for this TPM to be ready.
1010 * This can happen if the TPM has already been sent the
1011 * SaveState command before the driver has loaded. TCG 1.2
1012 * specification states that any communication after SaveState
1013 * may cause the TPM to invalidate previously saved state.
1015 if (rc
!= TPM_WARN_RETRY
)
1017 msleep(TPM_TIMEOUT_RETRY
);
1022 "Error (%d) sending savestate before suspend\n", rc
);
1024 dev_warn(&chip
->dev
, "TPM savestate took %dms\n",
1025 try * TPM_TIMEOUT_RETRY
);
1029 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
1032 * Resume from a power safe. The BIOS already restored
1035 int tpm_pm_resume(struct device
*dev
)
1037 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1044 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
1046 #define TPM_GETRANDOM_RESULT_SIZE 18
1047 static const struct tpm_input_header tpm_getrandom_header
= {
1048 .tag
= TPM_TAG_RQU_COMMAND
,
1049 .length
= cpu_to_be32(14),
1050 .ordinal
= TPM_ORD_GET_RANDOM
1054 * tpm_get_random() - Get random bytes from the tpm's RNG
1055 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1056 * @out: destination buffer for the random bytes
1057 * @max: the max number of bytes to write to @out
1059 * Returns < 0 on error and the number of bytes read on success
1061 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
1063 struct tpm_chip
*chip
;
1064 struct tpm_cmd_t tpm_cmd
;
1065 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
);
1066 int err
, total
= 0, retries
= 5;
1069 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
1072 chip
= tpm_chip_find_get(chip_num
);
1076 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
1077 err
= tpm2_get_random(chip
, out
, max
);
1083 tpm_cmd
.header
.in
= tpm_getrandom_header
;
1084 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
1086 err
= tpm_transmit_cmd(chip
, &tpm_cmd
,
1087 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
1088 0, "attempting get random");
1092 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
1093 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
1098 } while (retries
-- && total
< max
);
1101 return total
? total
: -EIO
;
1103 EXPORT_SYMBOL_GPL(tpm_get_random
);
1106 * tpm_seal_trusted() - seal a trusted key
1107 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1108 * @options: authentication values and other options
1109 * @payload: the key data in clear and encrypted form
1111 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1114 int tpm_seal_trusted(u32 chip_num
, struct trusted_key_payload
*payload
,
1115 struct trusted_key_options
*options
)
1117 struct tpm_chip
*chip
;
1120 chip
= tpm_chip_find_get(chip_num
);
1121 if (chip
== NULL
|| !(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
1124 rc
= tpm2_seal_trusted(chip
, payload
, options
);
1129 EXPORT_SYMBOL_GPL(tpm_seal_trusted
);
1132 * tpm_unseal_trusted() - unseal a trusted key
1133 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1134 * @options: authentication values and other options
1135 * @payload: the key data in clear and encrypted form
1137 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1140 int tpm_unseal_trusted(u32 chip_num
, struct trusted_key_payload
*payload
,
1141 struct trusted_key_options
*options
)
1143 struct tpm_chip
*chip
;
1146 chip
= tpm_chip_find_get(chip_num
);
1147 if (chip
== NULL
|| !(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
1150 rc
= tpm2_unseal_trusted(chip
, payload
, options
);
1156 EXPORT_SYMBOL_GPL(tpm_unseal_trusted
);
1158 static int __init
tpm_init(void)
1162 tpm_class
= class_create(THIS_MODULE
, "tpm");
1163 if (IS_ERR(tpm_class
)) {
1164 pr_err("couldn't create tpm class\n");
1165 return PTR_ERR(tpm_class
);
1168 rc
= alloc_chrdev_region(&tpm_devt
, 0, TPM_NUM_DEVICES
, "tpm");
1170 pr_err("tpm: failed to allocate char dev region\n");
1171 class_destroy(tpm_class
);
1178 static void __exit
tpm_exit(void)
1180 idr_destroy(&dev_nums_idr
);
1181 class_destroy(tpm_class
);
1182 unregister_chrdev_region(tpm_devt
, TPM_NUM_DEVICES
);
1185 subsys_initcall(tpm_init
);
1186 module_exit(tpm_exit
);
1188 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1189 MODULE_DESCRIPTION("TPM Driver");
1190 MODULE_VERSION("2.0");
1191 MODULE_LICENSE("GPL");