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 facilitate 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 * @buf: TPM command buffer
427 * @bufsiz: length of the buffer
428 * @min_rsp_body_length: minimum expected length of response body
429 * @flags: tpm transmit flags - bitmap
430 * @desc: command description used in the error message
433 * 0 when the operation is successful.
434 * A negative number for system errors (errno).
435 * A positive number for a TPM error.
437 ssize_t
tpm_transmit_cmd(struct tpm_chip
*chip
, const void *buf
,
438 size_t bufsiz
, size_t min_rsp_body_length
,
439 unsigned int flags
, const char *desc
)
441 const struct tpm_output_header
*header
;
445 len
= tpm_transmit(chip
, (const u8
*)buf
, bufsiz
, flags
);
448 else if (len
< TPM_HEADER_SIZE
)
452 if (len
!= be32_to_cpu(header
->length
))
455 err
= be32_to_cpu(header
->return_code
);
456 if (err
!= 0 && desc
)
457 dev_err(&chip
->dev
, "A TPM error (%d) occurred %s\n", err
,
462 if (len
< min_rsp_body_length
+ TPM_HEADER_SIZE
)
468 #define TPM_DIGEST_SIZE 20
469 #define TPM_RET_CODE_IDX 6
470 #define TPM_INTERNAL_RESULT_SIZE 200
471 #define TPM_ORD_GET_CAP cpu_to_be32(101)
472 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
474 static const struct tpm_input_header tpm_getcap_header
= {
475 .tag
= TPM_TAG_RQU_COMMAND
,
476 .length
= cpu_to_be32(22),
477 .ordinal
= TPM_ORD_GET_CAP
480 ssize_t
tpm_getcap(struct tpm_chip
*chip
, u32 subcap_id
, cap_t
*cap
,
481 const char *desc
, size_t min_cap_length
)
483 struct tpm_cmd_t tpm_cmd
;
486 tpm_cmd
.header
.in
= tpm_getcap_header
;
487 if (subcap_id
== TPM_CAP_VERSION_1_1
||
488 subcap_id
== TPM_CAP_VERSION_1_2
) {
489 tpm_cmd
.params
.getcap_in
.cap
= cpu_to_be32(subcap_id
);
490 /*subcap field not necessary */
491 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
492 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
494 if (subcap_id
== TPM_CAP_FLAG_PERM
||
495 subcap_id
== TPM_CAP_FLAG_VOL
)
496 tpm_cmd
.params
.getcap_in
.cap
=
497 cpu_to_be32(TPM_CAP_FLAG
);
499 tpm_cmd
.params
.getcap_in
.cap
=
500 cpu_to_be32(TPM_CAP_PROP
);
501 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
502 tpm_cmd
.params
.getcap_in
.subcap
= cpu_to_be32(subcap_id
);
504 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
505 min_cap_length
, 0, desc
);
507 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
510 EXPORT_SYMBOL_GPL(tpm_getcap
);
512 #define TPM_ORD_STARTUP cpu_to_be32(153)
513 #define TPM_ST_CLEAR cpu_to_be16(1)
514 #define TPM_ST_STATE cpu_to_be16(2)
515 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
516 static const struct tpm_input_header tpm_startup_header
= {
517 .tag
= TPM_TAG_RQU_COMMAND
,
518 .length
= cpu_to_be32(12),
519 .ordinal
= TPM_ORD_STARTUP
522 static int tpm_startup(struct tpm_chip
*chip
, __be16 startup_type
)
524 struct tpm_cmd_t start_cmd
;
525 start_cmd
.header
.in
= tpm_startup_header
;
527 start_cmd
.params
.startup_in
.startup_type
= startup_type
;
528 return tpm_transmit_cmd(chip
, &start_cmd
, TPM_INTERNAL_RESULT_SIZE
, 0,
529 0, "attempting to start the TPM");
532 int tpm_get_timeouts(struct tpm_chip
*chip
)
535 unsigned long timeout_old
[4], timeout_chip
[4], timeout_eff
[4];
538 if (chip
->flags
& TPM_CHIP_FLAG_HAVE_TIMEOUTS
)
541 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
542 /* Fixed timeouts for TPM2 */
543 chip
->timeout_a
= msecs_to_jiffies(TPM2_TIMEOUT_A
);
544 chip
->timeout_b
= msecs_to_jiffies(TPM2_TIMEOUT_B
);
545 chip
->timeout_c
= msecs_to_jiffies(TPM2_TIMEOUT_C
);
546 chip
->timeout_d
= msecs_to_jiffies(TPM2_TIMEOUT_D
);
547 chip
->duration
[TPM_SHORT
] =
548 msecs_to_jiffies(TPM2_DURATION_SHORT
);
549 chip
->duration
[TPM_MEDIUM
] =
550 msecs_to_jiffies(TPM2_DURATION_MEDIUM
);
551 chip
->duration
[TPM_LONG
] =
552 msecs_to_jiffies(TPM2_DURATION_LONG
);
554 chip
->flags
|= TPM_CHIP_FLAG_HAVE_TIMEOUTS
;
558 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_TIMEOUT
, &cap
, NULL
,
559 sizeof(cap
.timeout
));
560 if (rc
== TPM_ERR_INVALID_POSTINIT
) {
561 /* The TPM is not started, we are the first to talk to it.
562 Execute a startup command. */
563 dev_info(&chip
->dev
, "Issuing TPM_STARTUP\n");
564 if (tpm_startup(chip
, TPM_ST_CLEAR
))
567 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_TIMEOUT
, &cap
,
568 "attempting to determine the timeouts",
569 sizeof(cap
.timeout
));
574 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
579 timeout_old
[0] = jiffies_to_usecs(chip
->timeout_a
);
580 timeout_old
[1] = jiffies_to_usecs(chip
->timeout_b
);
581 timeout_old
[2] = jiffies_to_usecs(chip
->timeout_c
);
582 timeout_old
[3] = jiffies_to_usecs(chip
->timeout_d
);
583 timeout_chip
[0] = be32_to_cpu(cap
.timeout
.a
);
584 timeout_chip
[1] = be32_to_cpu(cap
.timeout
.b
);
585 timeout_chip
[2] = be32_to_cpu(cap
.timeout
.c
);
586 timeout_chip
[3] = be32_to_cpu(cap
.timeout
.d
);
587 memcpy(timeout_eff
, timeout_chip
, sizeof(timeout_eff
));
590 * Provide ability for vendor overrides of timeout values in case
593 if (chip
->ops
->update_timeouts
!= NULL
)
594 chip
->timeout_adjusted
=
595 chip
->ops
->update_timeouts(chip
, timeout_eff
);
597 if (!chip
->timeout_adjusted
) {
598 /* Restore default if chip reported 0 */
601 for (i
= 0; i
< ARRAY_SIZE(timeout_eff
); i
++) {
605 timeout_eff
[i
] = timeout_old
[i
];
606 chip
->timeout_adjusted
= true;
609 if (timeout_eff
[0] != 0 && timeout_eff
[0] < 1000) {
610 /* timeouts in msec rather usec */
611 for (i
= 0; i
!= ARRAY_SIZE(timeout_eff
); i
++)
612 timeout_eff
[i
] *= 1000;
613 chip
->timeout_adjusted
= true;
617 /* Report adjusted timeouts */
618 if (chip
->timeout_adjusted
) {
620 HW_ERR
"Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
621 timeout_chip
[0], timeout_eff
[0],
622 timeout_chip
[1], timeout_eff
[1],
623 timeout_chip
[2], timeout_eff
[2],
624 timeout_chip
[3], timeout_eff
[3]);
627 chip
->timeout_a
= usecs_to_jiffies(timeout_eff
[0]);
628 chip
->timeout_b
= usecs_to_jiffies(timeout_eff
[1]);
629 chip
->timeout_c
= usecs_to_jiffies(timeout_eff
[2]);
630 chip
->timeout_d
= usecs_to_jiffies(timeout_eff
[3]);
632 rc
= tpm_getcap(chip
, TPM_CAP_PROP_TIS_DURATION
, &cap
,
633 "attempting to determine the durations",
634 sizeof(cap
.duration
));
638 chip
->duration
[TPM_SHORT
] =
639 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_short
));
640 chip
->duration
[TPM_MEDIUM
] =
641 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_medium
));
642 chip
->duration
[TPM_LONG
] =
643 usecs_to_jiffies(be32_to_cpu(cap
.duration
.tpm_long
));
645 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
646 * value wrong and apparently reports msecs rather than usecs. So we
647 * fix up the resulting too-small TPM_SHORT value to make things work.
648 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
650 if (chip
->duration
[TPM_SHORT
] < (HZ
/ 100)) {
651 chip
->duration
[TPM_SHORT
] = HZ
;
652 chip
->duration
[TPM_MEDIUM
] *= 1000;
653 chip
->duration
[TPM_LONG
] *= 1000;
654 chip
->duration_adjusted
= true;
655 dev_info(&chip
->dev
, "Adjusting TPM timeout parameters.");
658 chip
->flags
|= TPM_CHIP_FLAG_HAVE_TIMEOUTS
;
661 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
663 #define TPM_ORD_CONTINUE_SELFTEST 83
664 #define CONTINUE_SELFTEST_RESULT_SIZE 10
666 static const struct tpm_input_header continue_selftest_header
= {
667 .tag
= TPM_TAG_RQU_COMMAND
,
668 .length
= cpu_to_be32(10),
669 .ordinal
= cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST
),
673 * tpm_continue_selftest -- run TPM's selftest
674 * @chip: TPM chip to use
676 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
679 static int tpm_continue_selftest(struct tpm_chip
*chip
)
682 struct tpm_cmd_t cmd
;
684 cmd
.header
.in
= continue_selftest_header
;
685 rc
= tpm_transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
, 0, 0,
686 "continue selftest");
690 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
691 #define READ_PCR_RESULT_SIZE 30
692 #define READ_PCR_RESULT_BODY_SIZE 20
693 static const struct tpm_input_header pcrread_header
= {
694 .tag
= TPM_TAG_RQU_COMMAND
,
695 .length
= cpu_to_be32(14),
696 .ordinal
= TPM_ORDINAL_PCRREAD
699 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
702 struct tpm_cmd_t cmd
;
704 cmd
.header
.in
= pcrread_header
;
705 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
706 rc
= tpm_transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
707 READ_PCR_RESULT_BODY_SIZE
, 0,
708 "attempting to read a pcr value");
711 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
717 * tpm_is_tpm2 - is the chip a TPM2 chip?
718 * @chip_num: tpm idx # or ANY
720 * Returns < 0 on error, and 1 or 0 on success depending whether the chip
723 int tpm_is_tpm2(u32 chip_num
)
725 struct tpm_chip
*chip
;
728 chip
= tpm_chip_find_get(chip_num
);
732 rc
= (chip
->flags
& TPM_CHIP_FLAG_TPM2
) != 0;
738 EXPORT_SYMBOL_GPL(tpm_is_tpm2
);
741 * tpm_pcr_read - read a pcr value
742 * @chip_num: tpm idx # or ANY
743 * @pcr_idx: pcr idx to retrieve
744 * @res_buf: TPM_PCR value
745 * size of res_buf is 20 bytes (or NULL if you don't care)
747 * The TPM driver should be built-in, but for whatever reason it
748 * isn't, protect against the chip disappearing, by incrementing
749 * the module usage count.
751 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
753 struct tpm_chip
*chip
;
756 chip
= tpm_chip_find_get(chip_num
);
759 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
760 rc
= tpm2_pcr_read(chip
, pcr_idx
, res_buf
);
762 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
766 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
768 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
769 #define EXTEND_PCR_RESULT_SIZE 34
770 #define EXTEND_PCR_RESULT_BODY_SIZE 20
771 static const struct tpm_input_header pcrextend_header
= {
772 .tag
= TPM_TAG_RQU_COMMAND
,
773 .length
= cpu_to_be32(34),
774 .ordinal
= TPM_ORD_PCR_EXTEND
778 * tpm_pcr_extend - extend pcr value with hash
779 * @chip_num: tpm idx # or AN&
780 * @pcr_idx: pcr idx to extend
781 * @hash: hash value used to extend pcr value
783 * The TPM driver should be built-in, but for whatever reason it
784 * isn't, protect against the chip disappearing, by incrementing
785 * the module usage count.
787 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
789 struct tpm_cmd_t cmd
;
791 struct tpm_chip
*chip
;
792 struct tpm2_digest digest_list
[ARRAY_SIZE(chip
->active_banks
)];
796 chip
= tpm_chip_find_get(chip_num
);
800 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
801 memset(digest_list
, 0, sizeof(digest_list
));
803 for (i
= 0; i
< ARRAY_SIZE(chip
->active_banks
) &&
804 chip
->active_banks
[i
] != TPM2_ALG_ERROR
; i
++) {
805 digest_list
[i
].alg_id
= chip
->active_banks
[i
];
806 memcpy(digest_list
[i
].digest
, hash
, TPM_DIGEST_SIZE
);
810 rc
= tpm2_pcr_extend(chip
, pcr_idx
, count
, digest_list
);
815 cmd
.header
.in
= pcrextend_header
;
816 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
817 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
818 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
819 EXTEND_PCR_RESULT_BODY_SIZE
, 0,
820 "attempting extend a PCR value");
825 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
828 * tpm_do_selftest - have the TPM continue its selftest and wait until it
829 * can receive further commands
830 * @chip: TPM chip to use
832 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
835 int tpm_do_selftest(struct tpm_chip
*chip
)
839 unsigned int delay_msec
= 100;
840 unsigned long duration
;
841 u8 dummy
[TPM_DIGEST_SIZE
];
843 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
845 loops
= jiffies_to_msecs(duration
) / delay_msec
;
847 rc
= tpm_continue_selftest(chip
);
848 /* This may fail if there was no TPM driver during a suspend/resume
849 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
855 /* Attempt to read a PCR value */
856 rc
= tpm_pcr_read_dev(chip
, 0, dummy
);
858 /* Some buggy TPMs will not respond to tpm_tis_ready() for
859 * around 300ms while the self test is ongoing, keep trying
860 * until the self test duration expires. */
864 "TPM command timed out during continue self test");
869 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
871 "TPM is disabled/deactivated (0x%X)\n", rc
);
872 /* TPM is disabled and/or deactivated; driver can
873 * proceed and TPM does handle commands for
874 * suspend/resume correctly
878 if (rc
!= TPM_WARN_DOING_SELFTEST
)
881 } while (--loops
> 0);
885 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
888 * tpm1_auto_startup - Perform the standard automatic TPM initialization
890 * @chip: TPM chip to use
892 * Returns 0 on success, < 0 in case of fatal error.
894 int tpm1_auto_startup(struct tpm_chip
*chip
)
898 rc
= tpm_get_timeouts(chip
);
901 rc
= tpm_do_selftest(chip
);
903 dev_err(&chip
->dev
, "TPM self test failed\n");
914 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
916 struct tpm_chip
*chip
;
919 chip
= tpm_chip_find_get(chip_num
);
923 rc
= tpm_transmit_cmd(chip
, cmd
, buflen
, 0, 0, "attempting tpm_cmd");
928 EXPORT_SYMBOL_GPL(tpm_send
);
930 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
931 bool check_cancel
, bool *canceled
)
933 u8 status
= chip
->ops
->status(chip
);
936 if ((status
& mask
) == mask
)
938 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
945 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
946 wait_queue_head_t
*queue
, bool check_cancel
)
951 bool canceled
= false;
953 /* check current status */
954 status
= chip
->ops
->status(chip
);
955 if ((status
& mask
) == mask
)
958 stop
= jiffies
+ timeout
;
960 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
962 timeout
= stop
- jiffies
;
963 if ((long)timeout
<= 0)
965 rc
= wait_event_interruptible_timeout(*queue
,
966 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
974 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
975 clear_thread_flag(TIF_SIGPENDING
);
981 status
= chip
->ops
->status(chip
);
982 if ((status
& mask
) == mask
)
984 } while (time_before(jiffies
, stop
));
988 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
990 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
991 #define SAVESTATE_RESULT_SIZE 10
993 static const struct tpm_input_header savestate_header
= {
994 .tag
= TPM_TAG_RQU_COMMAND
,
995 .length
= cpu_to_be32(10),
996 .ordinal
= TPM_ORD_SAVESTATE
1000 * We are about to suspend. Save the TPM state
1001 * so that it can be restored.
1003 int tpm_pm_suspend(struct device
*dev
)
1005 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1006 struct tpm_cmd_t cmd
;
1009 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
1014 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
1015 tpm2_shutdown(chip
, TPM2_SU_STATE
);
1019 /* for buggy tpm, flush pcrs with extend to selected dummy */
1020 if (tpm_suspend_pcr
) {
1021 cmd
.header
.in
= pcrextend_header
;
1022 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
1023 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
1025 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
1026 EXTEND_PCR_RESULT_BODY_SIZE
, 0,
1027 "extending dummy pcr before suspend");
1030 /* now do the actual savestate */
1031 for (try = 0; try < TPM_RETRY
; try++) {
1032 cmd
.header
.in
= savestate_header
;
1033 rc
= tpm_transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, 0,
1037 * If the TPM indicates that it is too busy to respond to
1038 * this command then retry before giving up. It can take
1039 * several seconds for this TPM to be ready.
1041 * This can happen if the TPM has already been sent the
1042 * SaveState command before the driver has loaded. TCG 1.2
1043 * specification states that any communication after SaveState
1044 * may cause the TPM to invalidate previously saved state.
1046 if (rc
!= TPM_WARN_RETRY
)
1048 msleep(TPM_TIMEOUT_RETRY
);
1053 "Error (%d) sending savestate before suspend\n", rc
);
1055 dev_warn(&chip
->dev
, "TPM savestate took %dms\n",
1056 try * TPM_TIMEOUT_RETRY
);
1060 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
1063 * Resume from a power safe. The BIOS already restored
1066 int tpm_pm_resume(struct device
*dev
)
1068 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1075 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
1077 #define TPM_GETRANDOM_RESULT_SIZE 18
1078 static const struct tpm_input_header tpm_getrandom_header
= {
1079 .tag
= TPM_TAG_RQU_COMMAND
,
1080 .length
= cpu_to_be32(14),
1081 .ordinal
= TPM_ORD_GET_RANDOM
1085 * tpm_get_random() - Get random bytes from the tpm's RNG
1086 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1087 * @out: destination buffer for the random bytes
1088 * @max: the max number of bytes to write to @out
1090 * Returns < 0 on error and the number of bytes read on success
1092 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
1094 struct tpm_chip
*chip
;
1095 struct tpm_cmd_t tpm_cmd
;
1096 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
), rlength
;
1097 int err
, total
= 0, retries
= 5;
1100 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
1103 chip
= tpm_chip_find_get(chip_num
);
1107 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
1108 err
= tpm2_get_random(chip
, out
, max
);
1114 tpm_cmd
.header
.in
= tpm_getrandom_header
;
1115 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
1117 err
= tpm_transmit_cmd(chip
, &tpm_cmd
,
1118 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
1119 offsetof(struct tpm_getrandom_out
,
1121 0, "attempting get random");
1125 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
1127 rlength
= be32_to_cpu(tpm_cmd
.header
.out
.length
);
1128 if (rlength
< offsetof(struct tpm_getrandom_out
, rng_data
) +
1133 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
1138 } while (retries
-- && total
< max
);
1141 return total
? total
: -EIO
;
1143 EXPORT_SYMBOL_GPL(tpm_get_random
);
1146 * tpm_seal_trusted() - seal a trusted key
1147 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1148 * @options: authentication values and other options
1149 * @payload: the key data in clear and encrypted form
1151 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1154 int tpm_seal_trusted(u32 chip_num
, struct trusted_key_payload
*payload
,
1155 struct trusted_key_options
*options
)
1157 struct tpm_chip
*chip
;
1160 chip
= tpm_chip_find_get(chip_num
);
1161 if (chip
== NULL
|| !(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
1164 rc
= tpm2_seal_trusted(chip
, payload
, options
);
1169 EXPORT_SYMBOL_GPL(tpm_seal_trusted
);
1172 * tpm_unseal_trusted() - unseal a trusted key
1173 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1174 * @options: authentication values and other options
1175 * @payload: the key data in clear and encrypted form
1177 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1180 int tpm_unseal_trusted(u32 chip_num
, struct trusted_key_payload
*payload
,
1181 struct trusted_key_options
*options
)
1183 struct tpm_chip
*chip
;
1186 chip
= tpm_chip_find_get(chip_num
);
1187 if (chip
== NULL
|| !(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
1190 rc
= tpm2_unseal_trusted(chip
, payload
, options
);
1196 EXPORT_SYMBOL_GPL(tpm_unseal_trusted
);
1198 static int __init
tpm_init(void)
1202 tpm_class
= class_create(THIS_MODULE
, "tpm");
1203 if (IS_ERR(tpm_class
)) {
1204 pr_err("couldn't create tpm class\n");
1205 return PTR_ERR(tpm_class
);
1208 rc
= alloc_chrdev_region(&tpm_devt
, 0, TPM_NUM_DEVICES
, "tpm");
1210 pr_err("tpm: failed to allocate char dev region\n");
1211 class_destroy(tpm_class
);
1218 static void __exit
tpm_exit(void)
1220 idr_destroy(&dev_nums_idr
);
1221 class_destroy(tpm_class
);
1222 unregister_chrdev_region(tpm_devt
, TPM_NUM_DEVICES
);
1225 subsys_initcall(tpm_init
);
1226 module_exit(tpm_exit
);
1228 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1229 MODULE_DESCRIPTION("TPM Driver");
1230 MODULE_VERSION("2.0");
1231 MODULE_LICENSE("GPL");