2 * Copyright (C) 2004 IBM Corporation
5 * Leendert van Doorn <leendert@watson.ibm.com>
6 * Dave Safford <safford@watson.ibm.com>
7 * Reiner Sailer <sailer@watson.ibm.com>
8 * Kylene Hall <kjhall@us.ibm.com>
10 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
12 * Device driver for TCG/TCPA TPM (trusted platform module).
13 * Specifications at www.trustedcomputinggroup.org
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation, version 2 of the
20 * Note, the TPM chip is not interrupt driven (only polling)
21 * and can have very long timeouts (minutes!). Hence the unusual
26 #include <linux/poll.h>
27 #include <linux/slab.h>
28 #include <linux/mutex.h>
29 #include <linux/spinlock.h>
30 #include <linux/freezer.h>
33 #include "tpm_eventlog.h"
35 #define TPM_MAX_ORDINAL 243
36 #define TSC_MAX_ORDINAL 12
37 #define TPM_PROTECTED_COMMAND 0x00
38 #define TPM_CONNECTION_COMMAND 0x40
41 * Bug workaround - some TPM's don't flush the most
42 * recently changed pcr on suspend, so force the flush
43 * with an extend to the selected _unused_ non-volatile pcr.
45 static int tpm_suspend_pcr
;
46 module_param_named(suspend_pcr
, tpm_suspend_pcr
, uint
, 0644);
47 MODULE_PARM_DESC(suspend_pcr
,
48 "PCR to use for dummy writes to faciltate flush on suspend.");
50 static LIST_HEAD(tpm_chip_list
);
51 static DEFINE_SPINLOCK(driver_lock
);
52 static DECLARE_BITMAP(dev_mask
, TPM_NUM_DEVICES
);
55 * Array with one entry per ordinal defining the maximum amount
56 * of time the chip could take to return the result. The ordinal
57 * designation of short, medium or long is defined in a table in
58 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
59 * values of the SHORT, MEDIUM, and LONG durations are retrieved
60 * from the chip during initialization with a call to tpm_get_timeouts.
62 static const u8 tpm_ordinal_duration
[TPM_MAX_ORDINAL
] = {
63 TPM_UNDEFINED
, /* 0 */
68 TPM_UNDEFINED
, /* 5 */
118 TPM_UNDEFINED
, /* 55 */
138 TPM_UNDEFINED
, /* 75 */
148 TPM_UNDEFINED
, /* 85 */
158 TPM_UNDEFINED
, /* 95 */
163 TPM_MEDIUM
, /* 100 */
168 TPM_UNDEFINED
, /* 105 */
198 TPM_UNDEFINED
, /* 135 */
208 TPM_UNDEFINED
, /* 145 */
218 TPM_UNDEFINED
, /* 155 */
228 TPM_UNDEFINED
, /* 165 */
238 TPM_UNDEFINED
, /* 175 */
243 TPM_MEDIUM
, /* 180 */
248 TPM_MEDIUM
, /* 185 */
253 TPM_UNDEFINED
, /* 190 */
258 TPM_UNDEFINED
, /* 195 */
273 TPM_MEDIUM
, /* 210 */
278 TPM_UNDEFINED
, /* 215 */
288 TPM_UNDEFINED
, /* 225 */
298 TPM_UNDEFINED
, /* 235 */
309 * Returns max number of jiffies to wait
311 unsigned long tpm_calc_ordinal_duration(struct tpm_chip
*chip
,
314 int duration_idx
= TPM_UNDEFINED
;
316 u8 category
= (ordinal
>> 24) & 0xFF;
318 if ((category
== TPM_PROTECTED_COMMAND
&& ordinal
< TPM_MAX_ORDINAL
) ||
319 (category
== TPM_CONNECTION_COMMAND
&& ordinal
< TSC_MAX_ORDINAL
))
320 duration_idx
= tpm_ordinal_duration
[ordinal
];
322 if (duration_idx
!= TPM_UNDEFINED
)
323 duration
= chip
->vendor
.duration
[duration_idx
];
329 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration
);
332 * Internal kernel interface to transmit TPM commands
334 ssize_t
tpm_transmit(struct tpm_chip
*chip
, const char *buf
,
341 if (bufsiz
> TPM_BUFSIZE
)
342 bufsiz
= TPM_BUFSIZE
;
344 count
= be32_to_cpu(*((__be32
*) (buf
+ 2)));
345 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
348 if (count
> bufsiz
) {
350 "invalid count value %x %zx\n", count
, bufsiz
);
354 mutex_lock(&chip
->tpm_mutex
);
356 rc
= chip
->ops
->send(chip
, (u8
*) buf
, count
);
359 "tpm_transmit: tpm_send: error %zd\n", rc
);
363 if (chip
->vendor
.irq
)
366 stop
= jiffies
+ tpm_calc_ordinal_duration(chip
, ordinal
);
368 u8 status
= chip
->ops
->status(chip
);
369 if ((status
& chip
->ops
->req_complete_mask
) ==
370 chip
->ops
->req_complete_val
)
373 if (chip
->ops
->req_canceled(chip
, status
)) {
374 dev_err(chip
->dev
, "Operation Canceled\n");
379 msleep(TPM_TIMEOUT
); /* CHECK */
381 } while (time_before(jiffies
, stop
));
383 chip
->ops
->cancel(chip
);
384 dev_err(chip
->dev
, "Operation Timed out\n");
389 rc
= chip
->ops
->recv(chip
, (u8
*) buf
, bufsiz
);
392 "tpm_transmit: tpm_recv: error %zd\n", rc
);
394 mutex_unlock(&chip
->tpm_mutex
);
398 #define TPM_DIGEST_SIZE 20
399 #define TPM_RET_CODE_IDX 6
401 ssize_t
tpm_transmit_cmd(struct tpm_chip
*chip
, void *cmd
,
402 int len
, const char *desc
)
404 struct tpm_output_header
*header
;
407 len
= tpm_transmit(chip
, (u8
*) cmd
, len
);
410 else if (len
< TPM_HEADER_SIZE
)
415 err
= be32_to_cpu(header
->return_code
);
416 if (err
!= 0 && desc
)
417 dev_err(chip
->dev
, "A TPM error (%d) occurred %s\n", err
, desc
);
422 #define TPM_INTERNAL_RESULT_SIZE 200
423 #define TPM_ORD_GET_CAP cpu_to_be32(101)
424 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
426 static const struct tpm_input_header tpm_getcap_header
= {
427 .tag
= TPM_TAG_RQU_COMMAND
,
428 .length
= cpu_to_be32(22),
429 .ordinal
= TPM_ORD_GET_CAP
432 ssize_t
tpm_getcap(struct device
*dev
, __be32 subcap_id
, cap_t
*cap
,
435 struct tpm_cmd_t tpm_cmd
;
437 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
439 tpm_cmd
.header
.in
= tpm_getcap_header
;
440 if (subcap_id
== CAP_VERSION_1_1
|| subcap_id
== CAP_VERSION_1_2
) {
441 tpm_cmd
.params
.getcap_in
.cap
= subcap_id
;
442 /*subcap field not necessary */
443 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
444 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
446 if (subcap_id
== TPM_CAP_FLAG_PERM
||
447 subcap_id
== TPM_CAP_FLAG_VOL
)
448 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_FLAG
;
450 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
451 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
452 tpm_cmd
.params
.getcap_in
.subcap
= subcap_id
;
454 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, desc
);
456 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
460 void tpm_gen_interrupt(struct tpm_chip
*chip
)
462 struct tpm_cmd_t tpm_cmd
;
465 tpm_cmd
.header
.in
= tpm_getcap_header
;
466 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
467 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
468 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
470 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
471 "attempting to determine the timeouts");
473 EXPORT_SYMBOL_GPL(tpm_gen_interrupt
);
475 #define TPM_ORD_STARTUP cpu_to_be32(153)
476 #define TPM_ST_CLEAR cpu_to_be16(1)
477 #define TPM_ST_STATE cpu_to_be16(2)
478 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
479 static const struct tpm_input_header tpm_startup_header
= {
480 .tag
= TPM_TAG_RQU_COMMAND
,
481 .length
= cpu_to_be32(12),
482 .ordinal
= TPM_ORD_STARTUP
485 static int tpm_startup(struct tpm_chip
*chip
, __be16 startup_type
)
487 struct tpm_cmd_t start_cmd
;
488 start_cmd
.header
.in
= tpm_startup_header
;
489 start_cmd
.params
.startup_in
.startup_type
= startup_type
;
490 return tpm_transmit_cmd(chip
, &start_cmd
, TPM_INTERNAL_RESULT_SIZE
,
491 "attempting to start the TPM");
494 int tpm_get_timeouts(struct tpm_chip
*chip
)
496 struct tpm_cmd_t tpm_cmd
;
497 unsigned long new_timeout
[4];
498 unsigned long old_timeout
[4];
499 struct duration_t
*duration_cap
;
502 tpm_cmd
.header
.in
= tpm_getcap_header
;
503 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
504 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
505 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
506 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, NULL
);
508 if (rc
== TPM_ERR_INVALID_POSTINIT
) {
509 /* The TPM is not started, we are the first to talk to it.
510 Execute a startup command. */
511 dev_info(chip
->dev
, "Issuing TPM_STARTUP");
512 if (tpm_startup(chip
, TPM_ST_CLEAR
))
515 tpm_cmd
.header
.in
= tpm_getcap_header
;
516 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
517 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
518 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
519 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
524 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
529 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
530 be32_to_cpu(tpm_cmd
.header
.out
.length
)
531 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 4 * sizeof(u32
))
534 old_timeout
[0] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.a
);
535 old_timeout
[1] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.b
);
536 old_timeout
[2] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.c
);
537 old_timeout
[3] = be32_to_cpu(tpm_cmd
.params
.getcap_out
.cap
.timeout
.d
);
538 memcpy(new_timeout
, old_timeout
, sizeof(new_timeout
));
541 * Provide ability for vendor overrides of timeout values in case
544 if (chip
->ops
->update_timeouts
!= NULL
)
545 chip
->vendor
.timeout_adjusted
=
546 chip
->ops
->update_timeouts(chip
, new_timeout
);
548 if (!chip
->vendor
.timeout_adjusted
) {
549 /* Don't overwrite default if value is 0 */
550 if (new_timeout
[0] != 0 && new_timeout
[0] < 1000) {
553 /* timeouts in msec rather usec */
554 for (i
= 0; i
!= ARRAY_SIZE(new_timeout
); i
++)
555 new_timeout
[i
] *= 1000;
556 chip
->vendor
.timeout_adjusted
= true;
560 /* Report adjusted timeouts */
561 if (chip
->vendor
.timeout_adjusted
) {
563 HW_ERR
"Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
564 old_timeout
[0], new_timeout
[0],
565 old_timeout
[1], new_timeout
[1],
566 old_timeout
[2], new_timeout
[2],
567 old_timeout
[3], new_timeout
[3]);
570 chip
->vendor
.timeout_a
= usecs_to_jiffies(new_timeout
[0]);
571 chip
->vendor
.timeout_b
= usecs_to_jiffies(new_timeout
[1]);
572 chip
->vendor
.timeout_c
= usecs_to_jiffies(new_timeout
[2]);
573 chip
->vendor
.timeout_d
= usecs_to_jiffies(new_timeout
[3]);
576 tpm_cmd
.header
.in
= tpm_getcap_header
;
577 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
578 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
579 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_DURATION
;
581 rc
= tpm_transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
582 "attempting to determine the durations");
586 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
) != 0 ||
587 be32_to_cpu(tpm_cmd
.header
.out
.length
)
588 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 3 * sizeof(u32
))
591 duration_cap
= &tpm_cmd
.params
.getcap_out
.cap
.duration
;
592 chip
->vendor
.duration
[TPM_SHORT
] =
593 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_short
));
594 chip
->vendor
.duration
[TPM_MEDIUM
] =
595 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_medium
));
596 chip
->vendor
.duration
[TPM_LONG
] =
597 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_long
));
599 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
600 * value wrong and apparently reports msecs rather than usecs. So we
601 * fix up the resulting too-small TPM_SHORT value to make things work.
602 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
604 if (chip
->vendor
.duration
[TPM_SHORT
] < (HZ
/ 100)) {
605 chip
->vendor
.duration
[TPM_SHORT
] = HZ
;
606 chip
->vendor
.duration
[TPM_MEDIUM
] *= 1000;
607 chip
->vendor
.duration
[TPM_LONG
] *= 1000;
608 chip
->vendor
.duration_adjusted
= true;
609 dev_info(chip
->dev
, "Adjusting TPM timeout parameters.");
613 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
615 #define TPM_ORD_CONTINUE_SELFTEST 83
616 #define CONTINUE_SELFTEST_RESULT_SIZE 10
618 static struct tpm_input_header continue_selftest_header
= {
619 .tag
= TPM_TAG_RQU_COMMAND
,
620 .length
= cpu_to_be32(10),
621 .ordinal
= cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST
),
625 * tpm_continue_selftest -- run TPM's selftest
626 * @chip: TPM chip to use
628 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
631 static int tpm_continue_selftest(struct tpm_chip
*chip
)
634 struct tpm_cmd_t cmd
;
636 cmd
.header
.in
= continue_selftest_header
;
637 rc
= tpm_transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
,
638 "continue selftest");
643 * tpm_chip_find_get - return tpm_chip for given chip number
645 static struct tpm_chip
*tpm_chip_find_get(int chip_num
)
647 struct tpm_chip
*pos
, *chip
= NULL
;
650 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
651 if (chip_num
!= TPM_ANY_NUM
&& chip_num
!= pos
->dev_num
)
654 if (try_module_get(pos
->dev
->driver
->owner
)) {
663 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
664 #define READ_PCR_RESULT_SIZE 30
665 static struct tpm_input_header pcrread_header
= {
666 .tag
= TPM_TAG_RQU_COMMAND
,
667 .length
= cpu_to_be32(14),
668 .ordinal
= TPM_ORDINAL_PCRREAD
671 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
674 struct tpm_cmd_t cmd
;
676 cmd
.header
.in
= pcrread_header
;
677 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
678 rc
= tpm_transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
679 "attempting to read a pcr value");
682 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
688 * tpm_pcr_read - read a pcr value
689 * @chip_num: tpm idx # or ANY
690 * @pcr_idx: pcr idx to retrieve
691 * @res_buf: TPM_PCR value
692 * size of res_buf is 20 bytes (or NULL if you don't care)
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 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
700 struct tpm_chip
*chip
;
703 chip
= tpm_chip_find_get(chip_num
);
706 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
710 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
713 * tpm_pcr_extend - extend pcr value with hash
714 * @chip_num: tpm idx # or AN&
715 * @pcr_idx: pcr idx to extend
716 * @hash: hash value used to extend pcr value
718 * The TPM driver should be built-in, but for whatever reason it
719 * isn't, protect against the chip disappearing, by incrementing
720 * the module usage count.
722 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
723 #define EXTEND_PCR_RESULT_SIZE 34
724 static struct tpm_input_header pcrextend_header
= {
725 .tag
= TPM_TAG_RQU_COMMAND
,
726 .length
= cpu_to_be32(34),
727 .ordinal
= TPM_ORD_PCR_EXTEND
730 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
732 struct tpm_cmd_t cmd
;
734 struct tpm_chip
*chip
;
736 chip
= tpm_chip_find_get(chip_num
);
740 cmd
.header
.in
= pcrextend_header
;
741 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
742 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
743 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
744 "attempting extend a PCR value");
749 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
752 * tpm_do_selftest - have the TPM continue its selftest and wait until it
753 * can receive further commands
754 * @chip: TPM chip to use
756 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
759 int tpm_do_selftest(struct tpm_chip
*chip
)
763 unsigned int delay_msec
= 100;
764 unsigned long duration
;
765 struct tpm_cmd_t cmd
;
767 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
769 loops
= jiffies_to_msecs(duration
) / delay_msec
;
771 rc
= tpm_continue_selftest(chip
);
772 /* This may fail if there was no TPM driver during a suspend/resume
773 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
779 /* Attempt to read a PCR value */
780 cmd
.header
.in
= pcrread_header
;
781 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(0);
782 rc
= tpm_transmit(chip
, (u8
*) &cmd
, READ_PCR_RESULT_SIZE
);
783 /* Some buggy TPMs will not respond to tpm_tis_ready() for
784 * around 300ms while the self test is ongoing, keep trying
785 * until the self test duration expires. */
787 dev_info(chip
->dev
, HW_ERR
"TPM command timed out during continue self test");
792 if (rc
< TPM_HEADER_SIZE
)
795 rc
= be32_to_cpu(cmd
.header
.out
.return_code
);
796 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
798 "TPM is disabled/deactivated (0x%X)\n", rc
);
799 /* TPM is disabled and/or deactivated; driver can
800 * proceed and TPM does handle commands for
801 * suspend/resume correctly
805 if (rc
!= TPM_WARN_DOING_SELFTEST
)
808 } while (--loops
> 0);
812 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
814 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
816 struct tpm_chip
*chip
;
819 chip
= tpm_chip_find_get(chip_num
);
823 rc
= tpm_transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
828 EXPORT_SYMBOL_GPL(tpm_send
);
830 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
831 bool check_cancel
, bool *canceled
)
833 u8 status
= chip
->ops
->status(chip
);
836 if ((status
& mask
) == mask
)
838 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
845 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
846 wait_queue_head_t
*queue
, bool check_cancel
)
851 bool canceled
= false;
853 /* check current status */
854 status
= chip
->ops
->status(chip
);
855 if ((status
& mask
) == mask
)
858 stop
= jiffies
+ timeout
;
860 if (chip
->vendor
.irq
) {
862 timeout
= stop
- jiffies
;
863 if ((long)timeout
<= 0)
865 rc
= wait_event_interruptible_timeout(*queue
,
866 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
874 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
875 clear_thread_flag(TIF_SIGPENDING
);
881 status
= chip
->ops
->status(chip
);
882 if ((status
& mask
) == mask
)
884 } while (time_before(jiffies
, stop
));
888 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
890 void tpm_remove_hardware(struct device
*dev
)
892 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
895 dev_err(dev
, "No device data found\n");
899 spin_lock(&driver_lock
);
900 list_del_rcu(&chip
->list
);
901 spin_unlock(&driver_lock
);
904 tpm_dev_del_device(chip
);
905 tpm_sysfs_del_device(chip
);
906 tpm_remove_ppi(&dev
->kobj
);
907 tpm_bios_log_teardown(chip
->bios_dir
);
909 /* write it this way to be explicit (chip->dev == dev) */
910 put_device(chip
->dev
);
912 EXPORT_SYMBOL_GPL(tpm_remove_hardware
);
914 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
915 #define SAVESTATE_RESULT_SIZE 10
917 static struct tpm_input_header savestate_header
= {
918 .tag
= TPM_TAG_RQU_COMMAND
,
919 .length
= cpu_to_be32(10),
920 .ordinal
= TPM_ORD_SAVESTATE
924 * We are about to suspend. Save the TPM state
925 * so that it can be restored.
927 int tpm_pm_suspend(struct device
*dev
)
929 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
930 struct tpm_cmd_t cmd
;
933 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
938 /* for buggy tpm, flush pcrs with extend to selected dummy */
939 if (tpm_suspend_pcr
) {
940 cmd
.header
.in
= pcrextend_header
;
941 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
942 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
944 rc
= tpm_transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
945 "extending dummy pcr before suspend");
948 /* now do the actual savestate */
949 for (try = 0; try < TPM_RETRY
; try++) {
950 cmd
.header
.in
= savestate_header
;
951 rc
= tpm_transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, NULL
);
954 * If the TPM indicates that it is too busy to respond to
955 * this command then retry before giving up. It can take
956 * several seconds for this TPM to be ready.
958 * This can happen if the TPM has already been sent the
959 * SaveState command before the driver has loaded. TCG 1.2
960 * specification states that any communication after SaveState
961 * may cause the TPM to invalidate previously saved state.
963 if (rc
!= TPM_WARN_RETRY
)
965 msleep(TPM_TIMEOUT_RETRY
);
970 "Error (%d) sending savestate before suspend\n", rc
);
972 dev_warn(chip
->dev
, "TPM savestate took %dms\n",
973 try * TPM_TIMEOUT_RETRY
);
977 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
980 * Resume from a power safe. The BIOS already restored
983 int tpm_pm_resume(struct device
*dev
)
985 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
992 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
994 #define TPM_GETRANDOM_RESULT_SIZE 18
995 static struct tpm_input_header tpm_getrandom_header
= {
996 .tag
= TPM_TAG_RQU_COMMAND
,
997 .length
= cpu_to_be32(14),
998 .ordinal
= TPM_ORD_GET_RANDOM
1002 * tpm_get_random() - Get random bytes from the tpm's RNG
1003 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1004 * @out: destination buffer for the random bytes
1005 * @max: the max number of bytes to write to @out
1007 * Returns < 0 on error and the number of bytes read on success
1009 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
1011 struct tpm_chip
*chip
;
1012 struct tpm_cmd_t tpm_cmd
;
1013 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
);
1014 int err
, total
= 0, retries
= 5;
1017 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
1020 chip
= tpm_chip_find_get(chip_num
);
1025 tpm_cmd
.header
.in
= tpm_getrandom_header
;
1026 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
1028 err
= tpm_transmit_cmd(chip
, &tpm_cmd
,
1029 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
1030 "attempting get random");
1034 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
1035 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
1040 } while (retries
-- && total
< max
);
1043 return total
? total
: -EIO
;
1045 EXPORT_SYMBOL_GPL(tpm_get_random
);
1047 /* In case vendor provided release function, call it too.*/
1049 void tpm_dev_vendor_release(struct tpm_chip
*chip
)
1054 clear_bit(chip
->dev_num
, dev_mask
);
1056 EXPORT_SYMBOL_GPL(tpm_dev_vendor_release
);
1060 * Once all references to platform device are down to 0,
1061 * release all allocated structures.
1063 static void tpm_dev_release(struct device
*dev
)
1065 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1070 tpm_dev_vendor_release(chip
);
1077 * Called from tpm_<specific>.c probe function only for devices
1078 * the driver has determined it should claim. Prior to calling
1079 * this function the specific probe function has called pci_enable_device
1080 * upon errant exit from this function specific probe function should call
1081 * pci_disable_device
1083 struct tpm_chip
*tpm_register_hardware(struct device
*dev
,
1084 const struct tpm_class_ops
*ops
)
1086 struct tpm_chip
*chip
;
1088 /* Driver specific per-device data */
1089 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1094 mutex_init(&chip
->tpm_mutex
);
1095 INIT_LIST_HEAD(&chip
->list
);
1098 chip
->dev_num
= find_first_zero_bit(dev_mask
, TPM_NUM_DEVICES
);
1100 if (chip
->dev_num
>= TPM_NUM_DEVICES
) {
1101 dev_err(dev
, "No available tpm device numbers\n");
1105 set_bit(chip
->dev_num
, dev_mask
);
1107 scnprintf(chip
->devname
, sizeof(chip
->devname
), "%s%d", "tpm",
1110 chip
->dev
= get_device(dev
);
1111 chip
->release
= dev
->release
;
1112 dev
->release
= tpm_dev_release
;
1113 dev_set_drvdata(dev
, chip
);
1115 if (tpm_dev_add_device(chip
))
1118 if (tpm_sysfs_add_device(chip
))
1121 if (tpm_add_ppi(&dev
->kobj
))
1124 chip
->bios_dir
= tpm_bios_log_setup(chip
->devname
);
1126 /* Make chip available */
1127 spin_lock(&driver_lock
);
1128 list_add_tail_rcu(&chip
->list
, &tpm_chip_list
);
1129 spin_unlock(&driver_lock
);
1134 tpm_sysfs_del_device(chip
);
1136 tpm_dev_del_device(chip
);
1138 put_device(chip
->dev
);
1143 EXPORT_SYMBOL_GPL(tpm_register_hardware
);
1145 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1146 MODULE_DESCRIPTION("TPM Driver");
1147 MODULE_VERSION("2.0");
1148 MODULE_LICENSE("GPL");