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>
34 #include "tpm_eventlog.h"
36 #define TPM_MAX_ORDINAL 243
37 #define TSC_MAX_ORDINAL 12
38 #define TPM_PROTECTED_COMMAND 0x00
39 #define TPM_CONNECTION_COMMAND 0x40
42 * Bug workaround - some TPM's don't flush the most
43 * recently changed pcr on suspend, so force the flush
44 * with an extend to the selected _unused_ non-volatile pcr.
46 static int tpm_suspend_pcr
;
47 module_param_named(suspend_pcr
, tpm_suspend_pcr
, uint
, 0644);
48 MODULE_PARM_DESC(suspend_pcr
,
49 "PCR to use for dummy writes to faciltate flush on suspend.");
52 * Array with one entry per ordinal defining the maximum amount
53 * of time the chip could take to return the result. The ordinal
54 * designation of short, medium or long is defined in a table in
55 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
56 * values of the SHORT, MEDIUM, and LONG durations are retrieved
57 * from the chip during initialization with a call to tpm_get_timeouts.
59 static const u8 tpm_ordinal_duration
[TPM_MAX_ORDINAL
] = {
60 TPM_UNDEFINED
, /* 0 */
65 TPM_UNDEFINED
, /* 5 */
115 TPM_UNDEFINED
, /* 55 */
135 TPM_UNDEFINED
, /* 75 */
145 TPM_UNDEFINED
, /* 85 */
155 TPM_UNDEFINED
, /* 95 */
160 TPM_MEDIUM
, /* 100 */
165 TPM_UNDEFINED
, /* 105 */
195 TPM_UNDEFINED
, /* 135 */
205 TPM_UNDEFINED
, /* 145 */
215 TPM_UNDEFINED
, /* 155 */
225 TPM_UNDEFINED
, /* 165 */
235 TPM_UNDEFINED
, /* 175 */
240 TPM_MEDIUM
, /* 180 */
245 TPM_MEDIUM
, /* 185 */
250 TPM_UNDEFINED
, /* 190 */
255 TPM_UNDEFINED
, /* 195 */
270 TPM_MEDIUM
, /* 210 */
275 TPM_UNDEFINED
, /* 215 */
285 TPM_UNDEFINED
, /* 225 */
295 TPM_UNDEFINED
, /* 235 */
306 * Returns max number of jiffies to wait
308 unsigned long tpm_calc_ordinal_duration(struct tpm_chip
*chip
,
311 int duration_idx
= TPM_UNDEFINED
;
313 u8 category
= (ordinal
>> 24) & 0xFF;
315 if ((category
== TPM_PROTECTED_COMMAND
&& ordinal
< TPM_MAX_ORDINAL
) ||
316 (category
== TPM_CONNECTION_COMMAND
&& ordinal
< TSC_MAX_ORDINAL
))
317 duration_idx
= tpm_ordinal_duration
[ordinal
];
319 if (duration_idx
!= TPM_UNDEFINED
)
320 duration
= chip
->vendor
.duration
[duration_idx
];
326 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration
);
329 * Internal kernel interface to transmit TPM commands
331 ssize_t
tpm_transmit(struct tpm_chip
*chip
, const char *buf
,
338 if (bufsiz
> TPM_BUFSIZE
)
339 bufsiz
= TPM_BUFSIZE
;
341 count
= be32_to_cpu(*((__be32
*) (buf
+ 2)));
342 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
345 if (count
> bufsiz
) {
347 "invalid count value %x %zx\n", count
, bufsiz
);
351 mutex_lock(&chip
->tpm_mutex
);
353 rc
= chip
->ops
->send(chip
, (u8
*) buf
, count
);
356 "tpm_transmit: tpm_send: error %zd\n", rc
);
360 if (chip
->vendor
.irq
)
363 stop
= jiffies
+ tpm_calc_ordinal_duration(chip
, ordinal
);
365 u8 status
= chip
->ops
->status(chip
);
366 if ((status
& chip
->ops
->req_complete_mask
) ==
367 chip
->ops
->req_complete_val
)
370 if (chip
->ops
->req_canceled(chip
, status
)) {
371 dev_err(chip
->dev
, "Operation Canceled\n");
376 msleep(TPM_TIMEOUT
); /* CHECK */
378 } while (time_before(jiffies
, stop
));
380 chip
->ops
->cancel(chip
);
381 dev_err(chip
->dev
, "Operation Timed out\n");
386 rc
= chip
->ops
->recv(chip
, (u8
*) buf
, bufsiz
);
389 "tpm_transmit: tpm_recv: error %zd\n", rc
);
391 mutex_unlock(&chip
->tpm_mutex
);
395 #define TPM_DIGEST_SIZE 20
396 #define TPM_RET_CODE_IDX 6
398 ssize_t
tpm_transmit_cmd(struct tpm_chip
*chip
, void *cmd
,
399 int len
, const char *desc
)
401 struct tpm_output_header
*header
;
404 len
= tpm_transmit(chip
, (u8
*) cmd
, len
);
407 else if (len
< TPM_HEADER_SIZE
)
412 err
= be32_to_cpu(header
->return_code
);
413 if (err
!= 0 && desc
)
414 dev_err(chip
->dev
, "A TPM error (%d) occurred %s\n", err
, desc
);
419 #define TPM_INTERNAL_RESULT_SIZE 200
420 #define TPM_ORD_GET_CAP cpu_to_be32(101)
421 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
423 static const struct tpm_input_header tpm_getcap_header
= {
424 .tag
= TPM_TAG_RQU_COMMAND
,
425 .length
= cpu_to_be32(22),
426 .ordinal
= TPM_ORD_GET_CAP
429 ssize_t
tpm_getcap(struct device
*dev
, __be32 subcap_id
, cap_t
*cap
,
432 struct tpm_cmd_t tpm_cmd
;
434 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
436 tpm_cmd
.header
.in
= tpm_getcap_header
;
437 if (subcap_id
== CAP_VERSION_1_1
|| subcap_id
== CAP_VERSION_1_2
) {
438 tpm_cmd
.params
.getcap_in
.cap
= subcap_id
;
439 /*subcap field not necessary */
440 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
441 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
443 if (subcap_id
== TPM_CAP_FLAG_PERM
||
444 subcap_id
== TPM_CAP_FLAG_VOL
)
445 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_FLAG
;
447 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
448 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
449 tpm_cmd
.params
.getcap_in
.subcap
= subcap_id
;
451 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, desc
);
453 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
457 void tpm_gen_interrupt(struct tpm_chip
*chip
)
459 struct tpm_cmd_t tpm_cmd
;
462 tpm_cmd
.header
.in
= tpm_getcap_header
;
463 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
464 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
465 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
467 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
468 "attempting to determine the timeouts");
470 EXPORT_SYMBOL_GPL(tpm_gen_interrupt
);
472 #define TPM_ORD_STARTUP cpu_to_be32(153)
473 #define TPM_ST_CLEAR cpu_to_be16(1)
474 #define TPM_ST_STATE cpu_to_be16(2)
475 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
476 static const struct tpm_input_header tpm_startup_header
= {
477 .tag
= TPM_TAG_RQU_COMMAND
,
478 .length
= cpu_to_be32(12),
479 .ordinal
= TPM_ORD_STARTUP
482 static int tpm_startup(struct tpm_chip
*chip
, __be16 startup_type
)
484 struct tpm_cmd_t start_cmd
;
485 start_cmd
.header
.in
= tpm_startup_header
;
486 start_cmd
.params
.startup_in
.startup_type
= startup_type
;
487 return tpm_transmit_cmd(chip
, &start_cmd
, TPM_INTERNAL_RESULT_SIZE
,
488 "attempting to start the TPM");
491 int tpm_get_timeouts(struct tpm_chip
*chip
)
493 struct tpm_cmd_t tpm_cmd
;
494 unsigned long new_timeout
[4];
495 unsigned long old_timeout
[4];
496 struct duration_t
*duration_cap
;
499 tpm_cmd
.header
.in
= tpm_getcap_header
;
500 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
501 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
502 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
503 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, NULL
);
505 if (rc
== TPM_ERR_INVALID_POSTINIT
) {
506 /* The TPM is not started, we are the first to talk to it.
507 Execute a startup command. */
508 dev_info(chip
->dev
, "Issuing TPM_STARTUP");
509 if (tpm_startup(chip
, TPM_ST_CLEAR
))
512 tpm_cmd
.header
.in
= tpm_getcap_header
;
513 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
514 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
515 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
516 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
521 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
526 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
527 be32_to_cpu(tpm_cmd
.header
.out
.length
)
528 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 4 * sizeof(u32
))
531 old_timeout
[0] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.a
);
532 old_timeout
[1] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.b
);
533 old_timeout
[2] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.c
);
534 old_timeout
[3] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.d
);
535 memcpy(new_timeout
, old_timeout
, sizeof(new_timeout
));
538 * Provide ability for vendor overrides of timeout values in case
541 if (chip
->ops
->update_timeouts
!= NULL
)
542 chip
->vendor
.timeout_adjusted
=
543 chip
->ops
->update_timeouts(chip
, new_timeout
);
545 if (!chip
->vendor
.timeout_adjusted
) {
546 /* Don't overwrite default if value is 0 */
547 if (new_timeout
[0] != 0 && new_timeout
[0] < 1000) {
550 /* timeouts in msec rather usec */
551 for (i
= 0; i
!= ARRAY_SIZE(new_timeout
); i
++)
552 new_timeout
[i
] *= 1000;
553 chip
->vendor
.timeout_adjusted
= true;
557 /* Report adjusted timeouts */
558 if (chip
->vendor
.timeout_adjusted
) {
560 HW_ERR
"Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
561 old_timeout
[0], new_timeout
[0],
562 old_timeout
[1], new_timeout
[1],
563 old_timeout
[2], new_timeout
[2],
564 old_timeout
[3], new_timeout
[3]);
567 chip
->vendor
.timeout_a
= usecs_to_jiffies(new_timeout
[0]);
568 chip
->vendor
.timeout_b
= usecs_to_jiffies(new_timeout
[1]);
569 chip
->vendor
.timeout_c
= usecs_to_jiffies(new_timeout
[2]);
570 chip
->vendor
.timeout_d
= usecs_to_jiffies(new_timeout
[3]);
573 tpm_cmd
.header
.in
= tpm_getcap_header
;
574 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
575 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
576 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_DURATION
;
578 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
579 "attempting to determine the durations");
583 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
584 be32_to_cpu(tpm_cmd
.header
.out
.length
)
585 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 3 * sizeof(u32
))
588 duration_cap
= &tpm_cmd
.params
.getcap_out
.cap
.duration
;
589 chip
->vendor
.duration
[TPM_SHORT
] =
590 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_short
));
591 chip
->vendor
.duration
[TPM_MEDIUM
] =
592 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_medium
));
593 chip
->vendor
.duration
[TPM_LONG
] =
594 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_long
));
596 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
597 * value wrong and apparently reports msecs rather than usecs. So we
598 * fix up the resulting too-small TPM_SHORT value to make things work.
599 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
601 if (chip
->vendor
.duration
[TPM_SHORT
] < (HZ
/ 100)) {
602 chip
->vendor
.duration
[TPM_SHORT
] = HZ
;
603 chip
->vendor
.duration
[TPM_MEDIUM
] *= 1000;
604 chip
->vendor
.duration
[TPM_LONG
] *= 1000;
605 chip
->vendor
.duration_adjusted
= true;
606 dev_info(chip
->dev
, "Adjusting TPM timeout parameters.");
610 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
612 #define TPM_ORD_CONTINUE_SELFTEST 83
613 #define CONTINUE_SELFTEST_RESULT_SIZE 10
615 static struct tpm_input_header continue_selftest_header
= {
616 .tag
= TPM_TAG_RQU_COMMAND
,
617 .length
= cpu_to_be32(10),
618 .ordinal
= cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST
),
622 * tpm_continue_selftest -- run TPM's selftest
623 * @chip: TPM chip to use
625 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
628 static int tpm_continue_selftest(struct tpm_chip
*chip
)
631 struct tpm_cmd_t cmd
;
633 cmd
.header
.in
= continue_selftest_header
;
634 rc
= tpm_transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
,
635 "continue selftest");
639 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
640 #define READ_PCR_RESULT_SIZE 30
641 static struct tpm_input_header pcrread_header
= {
642 .tag
= TPM_TAG_RQU_COMMAND
,
643 .length
= cpu_to_be32(14),
644 .ordinal
= TPM_ORDINAL_PCRREAD
647 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
650 struct tpm_cmd_t cmd
;
652 cmd
.header
.in
= pcrread_header
;
653 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
654 rc
= tpm_transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
655 "attempting to read a pcr value");
658 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
664 * tpm_pcr_read - read a pcr value
665 * @chip_num: tpm idx # or ANY
666 * @pcr_idx: pcr idx to retrieve
667 * @res_buf: TPM_PCR value
668 * size of res_buf is 20 bytes (or NULL if you don't care)
670 * The TPM driver should be built-in, but for whatever reason it
671 * isn't, protect against the chip disappearing, by incrementing
672 * the module usage count.
674 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
676 struct tpm_chip
*chip
;
679 chip
= tpm_chip_find_get(chip_num
);
682 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
686 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
689 * tpm_pcr_extend - extend pcr value with hash
690 * @chip_num: tpm idx # or AN&
691 * @pcr_idx: pcr idx to extend
692 * @hash: hash value used to extend pcr value
694 * The TPM driver should be built-in, but for whatever reason it
695 * isn't, protect against the chip disappearing, by incrementing
696 * the module usage count.
698 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
699 #define EXTEND_PCR_RESULT_SIZE 34
700 static struct tpm_input_header pcrextend_header
= {
701 .tag
= TPM_TAG_RQU_COMMAND
,
702 .length
= cpu_to_be32(34),
703 .ordinal
= TPM_ORD_PCR_EXTEND
706 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
708 struct tpm_cmd_t cmd
;
710 struct tpm_chip
*chip
;
712 chip
= tpm_chip_find_get(chip_num
);
716 cmd
.header
.in
= pcrextend_header
;
717 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
718 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
719 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
720 "attempting extend a PCR value");
725 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
728 * tpm_do_selftest - have the TPM continue its selftest and wait until it
729 * can receive further commands
730 * @chip: TPM chip to use
732 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
735 int tpm_do_selftest(struct tpm_chip
*chip
)
739 unsigned int delay_msec
= 100;
740 unsigned long duration
;
741 struct tpm_cmd_t cmd
;
743 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
745 loops
= jiffies_to_msecs(duration
) / delay_msec
;
747 rc
= tpm_continue_selftest(chip
);
748 /* This may fail if there was no TPM driver during a suspend/resume
749 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
755 /* Attempt to read a PCR value */
756 cmd
.header
.in
= pcrread_header
;
757 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(0);
758 rc
= tpm_transmit(chip
, (u8
*) &cmd
, READ_PCR_RESULT_SIZE
);
759 /* Some buggy TPMs will not respond to tpm_tis_ready() for
760 * around 300ms while the self test is ongoing, keep trying
761 * until the self test duration expires. */
763 dev_info(chip
->dev
, HW_ERR
"TPM command timed out during continue self test");
768 if (rc
< TPM_HEADER_SIZE
)
771 rc
= be32_to_cpu(cmd
.header
.out
.return_code
);
772 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
774 "TPM is disabled/deactivated (0x%X)\n", rc
);
775 /* TPM is disabled and/or deactivated; driver can
776 * proceed and TPM does handle commands for
777 * suspend/resume correctly
781 if (rc
!= TPM_WARN_DOING_SELFTEST
)
784 } while (--loops
> 0);
788 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
790 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
792 struct tpm_chip
*chip
;
795 chip
= tpm_chip_find_get(chip_num
);
799 rc
= tpm_transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
804 EXPORT_SYMBOL_GPL(tpm_send
);
806 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
807 bool check_cancel
, bool *canceled
)
809 u8 status
= chip
->ops
->status(chip
);
812 if ((status
& mask
) == mask
)
814 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
821 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
822 wait_queue_head_t
*queue
, bool check_cancel
)
827 bool canceled
= false;
829 /* check current status */
830 status
= chip
->ops
->status(chip
);
831 if ((status
& mask
) == mask
)
834 stop
= jiffies
+ timeout
;
836 if (chip
->vendor
.irq
) {
838 timeout
= stop
- jiffies
;
839 if ((long)timeout
<= 0)
841 rc
= wait_event_interruptible_timeout(*queue
,
842 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
850 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
851 clear_thread_flag(TIF_SIGPENDING
);
857 status
= chip
->ops
->status(chip
);
858 if ((status
& mask
) == mask
)
860 } while (time_before(jiffies
, stop
));
864 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
866 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
867 #define SAVESTATE_RESULT_SIZE 10
869 static struct tpm_input_header savestate_header
= {
870 .tag
= TPM_TAG_RQU_COMMAND
,
871 .length
= cpu_to_be32(10),
872 .ordinal
= TPM_ORD_SAVESTATE
876 * We are about to suspend. Save the TPM state
877 * so that it can be restored.
879 int tpm_pm_suspend(struct device
*dev
)
881 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
882 struct tpm_cmd_t cmd
;
885 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
890 /* for buggy tpm, flush pcrs with extend to selected dummy */
891 if (tpm_suspend_pcr
) {
892 cmd
.header
.in
= pcrextend_header
;
893 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
894 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
896 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
897 "extending dummy pcr before suspend");
900 /* now do the actual savestate */
901 for (try = 0; try < TPM_RETRY
; try++) {
902 cmd
.header
.in
= savestate_header
;
903 rc
= tpm_transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, NULL
);
906 * If the TPM indicates that it is too busy to respond to
907 * this command then retry before giving up. It can take
908 * several seconds for this TPM to be ready.
910 * This can happen if the TPM has already been sent the
911 * SaveState command before the driver has loaded. TCG 1.2
912 * specification states that any communication after SaveState
913 * may cause the TPM to invalidate previously saved state.
915 if (rc
!= TPM_WARN_RETRY
)
917 msleep(TPM_TIMEOUT_RETRY
);
922 "Error (%d) sending savestate before suspend\n", rc
);
924 dev_warn(chip
->dev
, "TPM savestate took %dms\n",
925 try * TPM_TIMEOUT_RETRY
);
929 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
932 * Resume from a power safe. The BIOS already restored
935 int tpm_pm_resume(struct device
*dev
)
937 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
944 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
946 #define TPM_GETRANDOM_RESULT_SIZE 18
947 static struct tpm_input_header tpm_getrandom_header
= {
948 .tag
= TPM_TAG_RQU_COMMAND
,
949 .length
= cpu_to_be32(14),
950 .ordinal
= TPM_ORD_GET_RANDOM
954 * tpm_get_random() - Get random bytes from the tpm's RNG
955 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
956 * @out: destination buffer for the random bytes
957 * @max: the max number of bytes to write to @out
959 * Returns < 0 on error and the number of bytes read on success
961 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
963 struct tpm_chip
*chip
;
964 struct tpm_cmd_t tpm_cmd
;
965 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
);
966 int err
, total
= 0, retries
= 5;
969 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
972 chip
= tpm_chip_find_get(chip_num
);
977 tpm_cmd
.header
.in
= tpm_getrandom_header
;
978 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
980 err
= tpm_transmit_cmd(chip
, &tpm_cmd
,
981 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
982 "attempting get random");
986 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
987 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
992 } while (retries
-- && total
< max
);
995 return total
? total
: -EIO
;
997 EXPORT_SYMBOL_GPL(tpm_get_random
);
999 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1000 MODULE_DESCRIPTION("TPM Driver");
1001 MODULE_VERSION("2.0");
1002 MODULE_LICENSE("GPL");