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
->pdev
, "Operation Canceled\n");
376 msleep(TPM_TIMEOUT
); /* CHECK */
378 } while (time_before(jiffies
, stop
));
380 chip
->ops
->cancel(chip
);
381 dev_err(chip
->pdev
, "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
->pdev
, "A TPM error (%d) occurred %s\n", err
,
420 #define TPM_INTERNAL_RESULT_SIZE 200
421 #define TPM_ORD_GET_CAP cpu_to_be32(101)
422 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
424 static const struct tpm_input_header tpm_getcap_header
= {
425 .tag
= TPM_TAG_RQU_COMMAND
,
426 .length
= cpu_to_be32(22),
427 .ordinal
= TPM_ORD_GET_CAP
430 ssize_t
tpm_getcap(struct device
*dev
, __be32 subcap_id
, cap_t
*cap
,
433 struct tpm_cmd_t tpm_cmd
;
435 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
437 tpm_cmd
.header
.in
= tpm_getcap_header
;
438 if (subcap_id
== CAP_VERSION_1_1
|| subcap_id
== CAP_VERSION_1_2
) {
439 tpm_cmd
.params
.getcap_in
.cap
= subcap_id
;
440 /*subcap field not necessary */
441 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
442 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
444 if (subcap_id
== TPM_CAP_FLAG_PERM
||
445 subcap_id
== TPM_CAP_FLAG_VOL
)
446 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_FLAG
;
448 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
449 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
450 tpm_cmd
.params
.getcap_in
.subcap
= subcap_id
;
452 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, desc
);
454 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
458 void tpm_gen_interrupt(struct tpm_chip
*chip
)
460 struct tpm_cmd_t tpm_cmd
;
463 tpm_cmd
.header
.in
= tpm_getcap_header
;
464 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
465 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
466 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
468 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
469 "attempting to determine the timeouts");
471 EXPORT_SYMBOL_GPL(tpm_gen_interrupt
);
473 #define TPM_ORD_STARTUP cpu_to_be32(153)
474 #define TPM_ST_CLEAR cpu_to_be16(1)
475 #define TPM_ST_STATE cpu_to_be16(2)
476 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
477 static const struct tpm_input_header tpm_startup_header
= {
478 .tag
= TPM_TAG_RQU_COMMAND
,
479 .length
= cpu_to_be32(12),
480 .ordinal
= TPM_ORD_STARTUP
483 static int tpm_startup(struct tpm_chip
*chip
, __be16 startup_type
)
485 struct tpm_cmd_t start_cmd
;
486 start_cmd
.header
.in
= tpm_startup_header
;
487 start_cmd
.params
.startup_in
.startup_type
= startup_type
;
488 return tpm_transmit_cmd(chip
, &start_cmd
, TPM_INTERNAL_RESULT_SIZE
,
489 "attempting to start the TPM");
492 int tpm_get_timeouts(struct tpm_chip
*chip
)
494 struct tpm_cmd_t tpm_cmd
;
495 unsigned long new_timeout
[4];
496 unsigned long old_timeout
[4];
497 struct duration_t
*duration_cap
;
500 tpm_cmd
.header
.in
= tpm_getcap_header
;
501 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
502 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
503 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
504 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, NULL
);
506 if (rc
== TPM_ERR_INVALID_POSTINIT
) {
507 /* The TPM is not started, we are the first to talk to it.
508 Execute a startup command. */
509 dev_info(chip
->pdev
, "Issuing TPM_STARTUP");
510 if (tpm_startup(chip
, TPM_ST_CLEAR
))
513 tpm_cmd
.header
.in
= tpm_getcap_header
;
514 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
515 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
516 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
517 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
522 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
527 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
528 be32_to_cpu(tpm_cmd
.header
.out
.length
)
529 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 4 * sizeof(u32
))
532 old_timeout
[0] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.a
);
533 old_timeout
[1] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.b
);
534 old_timeout
[2] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.c
);
535 old_timeout
[3] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.d
);
536 memcpy(new_timeout
, old_timeout
, sizeof(new_timeout
));
539 * Provide ability for vendor overrides of timeout values in case
542 if (chip
->ops
->update_timeouts
!= NULL
)
543 chip
->vendor
.timeout_adjusted
=
544 chip
->ops
->update_timeouts(chip
, new_timeout
);
546 if (!chip
->vendor
.timeout_adjusted
) {
547 /* Don't overwrite default if value is 0 */
548 if (new_timeout
[0] != 0 && new_timeout
[0] < 1000) {
551 /* timeouts in msec rather usec */
552 for (i
= 0; i
!= ARRAY_SIZE(new_timeout
); i
++)
553 new_timeout
[i
] *= 1000;
554 chip
->vendor
.timeout_adjusted
= true;
558 /* Report adjusted timeouts */
559 if (chip
->vendor
.timeout_adjusted
) {
561 HW_ERR
"Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
562 old_timeout
[0], new_timeout
[0],
563 old_timeout
[1], new_timeout
[1],
564 old_timeout
[2], new_timeout
[2],
565 old_timeout
[3], new_timeout
[3]);
568 chip
->vendor
.timeout_a
= usecs_to_jiffies(new_timeout
[0]);
569 chip
->vendor
.timeout_b
= usecs_to_jiffies(new_timeout
[1]);
570 chip
->vendor
.timeout_c
= usecs_to_jiffies(new_timeout
[2]);
571 chip
->vendor
.timeout_d
= usecs_to_jiffies(new_timeout
[3]);
574 tpm_cmd
.header
.in
= tpm_getcap_header
;
575 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
576 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
577 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_DURATION
;
579 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
580 "attempting to determine the durations");
584 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
585 be32_to_cpu(tpm_cmd
.header
.out
.length
)
586 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 3 * sizeof(u32
))
589 duration_cap
= &tpm_cmd
.params
.getcap_out
.cap
.duration
;
590 chip
->vendor
.duration
[TPM_SHORT
] =
591 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_short
));
592 chip
->vendor
.duration
[TPM_MEDIUM
] =
593 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_medium
));
594 chip
->vendor
.duration
[TPM_LONG
] =
595 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_long
));
597 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
598 * value wrong and apparently reports msecs rather than usecs. So we
599 * fix up the resulting too-small TPM_SHORT value to make things work.
600 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
602 if (chip
->vendor
.duration
[TPM_SHORT
] < (HZ
/ 100)) {
603 chip
->vendor
.duration
[TPM_SHORT
] = HZ
;
604 chip
->vendor
.duration
[TPM_MEDIUM
] *= 1000;
605 chip
->vendor
.duration
[TPM_LONG
] *= 1000;
606 chip
->vendor
.duration_adjusted
= true;
607 dev_info(chip
->pdev
, "Adjusting TPM timeout parameters.");
611 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
613 #define TPM_ORD_CONTINUE_SELFTEST 83
614 #define CONTINUE_SELFTEST_RESULT_SIZE 10
616 static struct tpm_input_header continue_selftest_header
= {
617 .tag
= TPM_TAG_RQU_COMMAND
,
618 .length
= cpu_to_be32(10),
619 .ordinal
= cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST
),
623 * tpm_continue_selftest -- run TPM's selftest
624 * @chip: TPM chip to use
626 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
629 static int tpm_continue_selftest(struct tpm_chip
*chip
)
632 struct tpm_cmd_t cmd
;
634 cmd
.header
.in
= continue_selftest_header
;
635 rc
= tpm_transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
,
636 "continue selftest");
640 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
641 #define READ_PCR_RESULT_SIZE 30
642 static struct tpm_input_header pcrread_header
= {
643 .tag
= TPM_TAG_RQU_COMMAND
,
644 .length
= cpu_to_be32(14),
645 .ordinal
= TPM_ORDINAL_PCRREAD
648 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
651 struct tpm_cmd_t cmd
;
653 cmd
.header
.in
= pcrread_header
;
654 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
655 rc
= tpm_transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
656 "attempting to read a pcr value");
659 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
665 * tpm_pcr_read - read a pcr value
666 * @chip_num: tpm idx # or ANY
667 * @pcr_idx: pcr idx to retrieve
668 * @res_buf: TPM_PCR value
669 * size of res_buf is 20 bytes (or NULL if you don't care)
671 * The TPM driver should be built-in, but for whatever reason it
672 * isn't, protect against the chip disappearing, by incrementing
673 * the module usage count.
675 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
677 struct tpm_chip
*chip
;
680 chip
= tpm_chip_find_get(chip_num
);
683 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
687 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
690 * tpm_pcr_extend - extend pcr value with hash
691 * @chip_num: tpm idx # or AN&
692 * @pcr_idx: pcr idx to extend
693 * @hash: hash value used to extend pcr value
695 * The TPM driver should be built-in, but for whatever reason it
696 * isn't, protect against the chip disappearing, by incrementing
697 * the module usage count.
699 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
700 #define EXTEND_PCR_RESULT_SIZE 34
701 static struct tpm_input_header pcrextend_header
= {
702 .tag
= TPM_TAG_RQU_COMMAND
,
703 .length
= cpu_to_be32(34),
704 .ordinal
= TPM_ORD_PCR_EXTEND
707 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
709 struct tpm_cmd_t cmd
;
711 struct tpm_chip
*chip
;
713 chip
= tpm_chip_find_get(chip_num
);
717 cmd
.header
.in
= pcrextend_header
;
718 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
719 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
720 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
721 "attempting extend a PCR value");
726 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
729 * tpm_do_selftest - have the TPM continue its selftest and wait until it
730 * can receive further commands
731 * @chip: TPM chip to use
733 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
736 int tpm_do_selftest(struct tpm_chip
*chip
)
740 unsigned int delay_msec
= 100;
741 unsigned long duration
;
742 struct tpm_cmd_t cmd
;
744 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
746 loops
= jiffies_to_msecs(duration
) / delay_msec
;
748 rc
= tpm_continue_selftest(chip
);
749 /* This may fail if there was no TPM driver during a suspend/resume
750 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
756 /* Attempt to read a PCR value */
757 cmd
.header
.in
= pcrread_header
;
758 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(0);
759 rc
= tpm_transmit(chip
, (u8
*) &cmd
, READ_PCR_RESULT_SIZE
);
760 /* Some buggy TPMs will not respond to tpm_tis_ready() for
761 * around 300ms while the self test is ongoing, keep trying
762 * until the self test duration expires. */
764 dev_info(chip
->pdev
, HW_ERR
"TPM command timed out during continue self test");
769 if (rc
< TPM_HEADER_SIZE
)
772 rc
= be32_to_cpu(cmd
.header
.out
.return_code
);
773 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
775 "TPM is disabled/deactivated (0x%X)\n", rc
);
776 /* TPM is disabled and/or deactivated; driver can
777 * proceed and TPM does handle commands for
778 * suspend/resume correctly
782 if (rc
!= TPM_WARN_DOING_SELFTEST
)
785 } while (--loops
> 0);
789 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
791 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
793 struct tpm_chip
*chip
;
796 chip
= tpm_chip_find_get(chip_num
);
800 rc
= tpm_transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
805 EXPORT_SYMBOL_GPL(tpm_send
);
807 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
808 bool check_cancel
, bool *canceled
)
810 u8 status
= chip
->ops
->status(chip
);
813 if ((status
& mask
) == mask
)
815 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
822 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
823 wait_queue_head_t
*queue
, bool check_cancel
)
828 bool canceled
= false;
830 /* check current status */
831 status
= chip
->ops
->status(chip
);
832 if ((status
& mask
) == mask
)
835 stop
= jiffies
+ timeout
;
837 if (chip
->vendor
.irq
) {
839 timeout
= stop
- jiffies
;
840 if ((long)timeout
<= 0)
842 rc
= wait_event_interruptible_timeout(*queue
,
843 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
851 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
852 clear_thread_flag(TIF_SIGPENDING
);
858 status
= chip
->ops
->status(chip
);
859 if ((status
& mask
) == mask
)
861 } while (time_before(jiffies
, stop
));
865 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
867 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
868 #define SAVESTATE_RESULT_SIZE 10
870 static struct tpm_input_header savestate_header
= {
871 .tag
= TPM_TAG_RQU_COMMAND
,
872 .length
= cpu_to_be32(10),
873 .ordinal
= TPM_ORD_SAVESTATE
877 * We are about to suspend. Save the TPM state
878 * so that it can be restored.
880 int tpm_pm_suspend(struct device
*dev
)
882 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
883 struct tpm_cmd_t cmd
;
886 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
891 /* for buggy tpm, flush pcrs with extend to selected dummy */
892 if (tpm_suspend_pcr
) {
893 cmd
.header
.in
= pcrextend_header
;
894 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
895 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
897 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
898 "extending dummy pcr before suspend");
901 /* now do the actual savestate */
902 for (try = 0; try < TPM_RETRY
; try++) {
903 cmd
.header
.in
= savestate_header
;
904 rc
= tpm_transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, NULL
);
907 * If the TPM indicates that it is too busy to respond to
908 * this command then retry before giving up. It can take
909 * several seconds for this TPM to be ready.
911 * This can happen if the TPM has already been sent the
912 * SaveState command before the driver has loaded. TCG 1.2
913 * specification states that any communication after SaveState
914 * may cause the TPM to invalidate previously saved state.
916 if (rc
!= TPM_WARN_RETRY
)
918 msleep(TPM_TIMEOUT_RETRY
);
923 "Error (%d) sending savestate before suspend\n", rc
);
925 dev_warn(chip
->pdev
, "TPM savestate took %dms\n",
926 try * TPM_TIMEOUT_RETRY
);
930 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
933 * Resume from a power safe. The BIOS already restored
936 int tpm_pm_resume(struct device
*dev
)
938 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
945 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
947 #define TPM_GETRANDOM_RESULT_SIZE 18
948 static struct tpm_input_header tpm_getrandom_header
= {
949 .tag
= TPM_TAG_RQU_COMMAND
,
950 .length
= cpu_to_be32(14),
951 .ordinal
= TPM_ORD_GET_RANDOM
955 * tpm_get_random() - Get random bytes from the tpm's RNG
956 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
957 * @out: destination buffer for the random bytes
958 * @max: the max number of bytes to write to @out
960 * Returns < 0 on error and the number of bytes read on success
962 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
964 struct tpm_chip
*chip
;
965 struct tpm_cmd_t tpm_cmd
;
966 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
);
967 int err
, total
= 0, retries
= 5;
970 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
973 chip
= tpm_chip_find_get(chip_num
);
978 tpm_cmd
.header
.in
= tpm_getrandom_header
;
979 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
981 err
= tpm_transmit_cmd(chip
, &tpm_cmd
,
982 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
983 "attempting get random");
987 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
988 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
993 } while (retries
-- && total
< max
);
996 return total
? total
: -EIO
;
998 EXPORT_SYMBOL_GPL(tpm_get_random
);
1000 static int __init
tpm_init(void)
1004 tpm_class
= class_create(THIS_MODULE
, "tpm");
1005 if (IS_ERR(tpm_class
)) {
1006 pr_err("couldn't create tpm class\n");
1007 return PTR_ERR(tpm_class
);
1010 rc
= alloc_chrdev_region(&tpm_devt
, 0, TPM_NUM_DEVICES
, "tpm");
1012 pr_err("tpm: failed to allocate char dev region\n");
1013 class_destroy(tpm_class
);
1020 static void __exit
tpm_exit(void)
1022 class_destroy(tpm_class
);
1023 unregister_chrdev_region(tpm_devt
, TPM_NUM_DEVICES
);
1026 subsys_initcall(tpm_init
);
1027 module_exit(tpm_exit
);
1029 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1030 MODULE_DESCRIPTION("TPM Driver");
1031 MODULE_VERSION("2.0");
1032 MODULE_LICENSE("GPL");