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 static ssize_t
transmit_cmd(struct tpm_chip
*chip
, struct tpm_cmd_t
*cmd
,
402 int len
, const char *desc
)
406 len
= tpm_transmit(chip
, (u8
*) cmd
, len
);
409 else if (len
< TPM_HEADER_SIZE
)
412 err
= be32_to_cpu(cmd
->header
.out
.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
= 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
= 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 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
= 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
= 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
= 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
= transmit_cmd(chip
, &cmd
, CONTINUE_SELFTEST_RESULT_SIZE
,
635 "continue selftest");
640 * tpm_chip_find_get - return tpm_chip for given chip number
642 static struct tpm_chip
*tpm_chip_find_get(int chip_num
)
644 struct tpm_chip
*pos
, *chip
= NULL
;
647 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
648 if (chip_num
!= TPM_ANY_NUM
&& chip_num
!= pos
->dev_num
)
651 if (try_module_get(pos
->dev
->driver
->owner
)) {
660 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
661 #define READ_PCR_RESULT_SIZE 30
662 static struct tpm_input_header pcrread_header
= {
663 .tag
= TPM_TAG_RQU_COMMAND
,
664 .length
= cpu_to_be32(14),
665 .ordinal
= TPM_ORDINAL_PCRREAD
668 int tpm_pcr_read_dev(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
671 struct tpm_cmd_t cmd
;
673 cmd
.header
.in
= pcrread_header
;
674 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
675 rc
= transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
676 "attempting to read a pcr value");
679 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
685 * tpm_pcr_read - read a pcr value
686 * @chip_num: tpm idx # or ANY
687 * @pcr_idx: pcr idx to retrieve
688 * @res_buf: TPM_PCR value
689 * size of res_buf is 20 bytes (or NULL if you don't care)
691 * The TPM driver should be built-in, but for whatever reason it
692 * isn't, protect against the chip disappearing, by incrementing
693 * the module usage count.
695 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
697 struct tpm_chip
*chip
;
700 chip
= tpm_chip_find_get(chip_num
);
703 rc
= tpm_pcr_read_dev(chip
, pcr_idx
, res_buf
);
707 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
710 * tpm_pcr_extend - extend pcr value with hash
711 * @chip_num: tpm idx # or AN&
712 * @pcr_idx: pcr idx to extend
713 * @hash: hash value used to extend pcr value
715 * The TPM driver should be built-in, but for whatever reason it
716 * isn't, protect against the chip disappearing, by incrementing
717 * the module usage count.
719 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
720 #define EXTEND_PCR_RESULT_SIZE 34
721 static struct tpm_input_header pcrextend_header
= {
722 .tag
= TPM_TAG_RQU_COMMAND
,
723 .length
= cpu_to_be32(34),
724 .ordinal
= TPM_ORD_PCR_EXTEND
727 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
729 struct tpm_cmd_t cmd
;
731 struct tpm_chip
*chip
;
733 chip
= tpm_chip_find_get(chip_num
);
737 cmd
.header
.in
= pcrextend_header
;
738 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
739 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
740 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
741 "attempting extend a PCR value");
746 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
749 * tpm_do_selftest - have the TPM continue its selftest and wait until it
750 * can receive further commands
751 * @chip: TPM chip to use
753 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
756 int tpm_do_selftest(struct tpm_chip
*chip
)
760 unsigned int delay_msec
= 100;
761 unsigned long duration
;
762 struct tpm_cmd_t cmd
;
764 duration
= tpm_calc_ordinal_duration(chip
, TPM_ORD_CONTINUE_SELFTEST
);
766 loops
= jiffies_to_msecs(duration
) / delay_msec
;
768 rc
= tpm_continue_selftest(chip
);
769 /* This may fail if there was no TPM driver during a suspend/resume
770 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
776 /* Attempt to read a PCR value */
777 cmd
.header
.in
= pcrread_header
;
778 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(0);
779 rc
= tpm_transmit(chip
, (u8
*) &cmd
, READ_PCR_RESULT_SIZE
);
780 /* Some buggy TPMs will not respond to tpm_tis_ready() for
781 * around 300ms while the self test is ongoing, keep trying
782 * until the self test duration expires. */
784 dev_info(chip
->dev
, HW_ERR
"TPM command timed out during continue self test");
789 if (rc
< TPM_HEADER_SIZE
)
792 rc
= be32_to_cpu(cmd
.header
.out
.return_code
);
793 if (rc
== TPM_ERR_DISABLED
|| rc
== TPM_ERR_DEACTIVATED
) {
795 "TPM is disabled/deactivated (0x%X)\n", rc
);
796 /* TPM is disabled and/or deactivated; driver can
797 * proceed and TPM does handle commands for
798 * suspend/resume correctly
802 if (rc
!= TPM_WARN_DOING_SELFTEST
)
805 } while (--loops
> 0);
809 EXPORT_SYMBOL_GPL(tpm_do_selftest
);
811 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
813 struct tpm_chip
*chip
;
816 chip
= tpm_chip_find_get(chip_num
);
820 rc
= transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
825 EXPORT_SYMBOL_GPL(tpm_send
);
827 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
828 bool check_cancel
, bool *canceled
)
830 u8 status
= chip
->ops
->status(chip
);
833 if ((status
& mask
) == mask
)
835 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
842 int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
, unsigned long timeout
,
843 wait_queue_head_t
*queue
, bool check_cancel
)
848 bool canceled
= false;
850 /* check current status */
851 status
= chip
->ops
->status(chip
);
852 if ((status
& mask
) == mask
)
855 stop
= jiffies
+ timeout
;
857 if (chip
->vendor
.irq
) {
859 timeout
= stop
- jiffies
;
860 if ((long)timeout
<= 0)
862 rc
= wait_event_interruptible_timeout(*queue
,
863 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
871 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
872 clear_thread_flag(TIF_SIGPENDING
);
878 status
= chip
->ops
->status(chip
);
879 if ((status
& mask
) == mask
)
881 } while (time_before(jiffies
, stop
));
885 EXPORT_SYMBOL_GPL(wait_for_tpm_stat
);
887 void tpm_remove_hardware(struct device
*dev
)
889 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
892 dev_err(dev
, "No device data found\n");
896 spin_lock(&driver_lock
);
897 list_del_rcu(&chip
->list
);
898 spin_unlock(&driver_lock
);
901 tpm_dev_del_device(chip
);
902 tpm_sysfs_del_device(chip
);
903 tpm_remove_ppi(&dev
->kobj
);
904 tpm_bios_log_teardown(chip
->bios_dir
);
906 /* write it this way to be explicit (chip->dev == dev) */
907 put_device(chip
->dev
);
909 EXPORT_SYMBOL_GPL(tpm_remove_hardware
);
911 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
912 #define SAVESTATE_RESULT_SIZE 10
914 static struct tpm_input_header savestate_header
= {
915 .tag
= TPM_TAG_RQU_COMMAND
,
916 .length
= cpu_to_be32(10),
917 .ordinal
= TPM_ORD_SAVESTATE
921 * We are about to suspend. Save the TPM state
922 * so that it can be restored.
924 int tpm_pm_suspend(struct device
*dev
)
926 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
927 struct tpm_cmd_t cmd
;
930 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
935 /* for buggy tpm, flush pcrs with extend to selected dummy */
936 if (tpm_suspend_pcr
) {
937 cmd
.header
.in
= pcrextend_header
;
938 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
939 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
941 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
942 "extending dummy pcr before suspend");
945 /* now do the actual savestate */
946 for (try = 0; try < TPM_RETRY
; try++) {
947 cmd
.header
.in
= savestate_header
;
948 rc
= transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
, NULL
);
951 * If the TPM indicates that it is too busy to respond to
952 * this command then retry before giving up. It can take
953 * several seconds for this TPM to be ready.
955 * This can happen if the TPM has already been sent the
956 * SaveState command before the driver has loaded. TCG 1.2
957 * specification states that any communication after SaveState
958 * may cause the TPM to invalidate previously saved state.
960 if (rc
!= TPM_WARN_RETRY
)
962 msleep(TPM_TIMEOUT_RETRY
);
967 "Error (%d) sending savestate before suspend\n", rc
);
969 dev_warn(chip
->dev
, "TPM savestate took %dms\n",
970 try * TPM_TIMEOUT_RETRY
);
974 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
977 * Resume from a power safe. The BIOS already restored
980 int tpm_pm_resume(struct device
*dev
)
982 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
989 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
991 #define TPM_GETRANDOM_RESULT_SIZE 18
992 static struct tpm_input_header tpm_getrandom_header
= {
993 .tag
= TPM_TAG_RQU_COMMAND
,
994 .length
= cpu_to_be32(14),
995 .ordinal
= TPM_ORD_GET_RANDOM
999 * tpm_get_random() - Get random bytes from the tpm's RNG
1000 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1001 * @out: destination buffer for the random bytes
1002 * @max: the max number of bytes to write to @out
1004 * Returns < 0 on error and the number of bytes read on success
1006 int tpm_get_random(u32 chip_num
, u8
*out
, size_t max
)
1008 struct tpm_chip
*chip
;
1009 struct tpm_cmd_t tpm_cmd
;
1010 u32 recd
, num_bytes
= min_t(u32
, max
, TPM_MAX_RNG_DATA
);
1011 int err
, total
= 0, retries
= 5;
1014 if (!out
|| !num_bytes
|| max
> TPM_MAX_RNG_DATA
)
1017 chip
= tpm_chip_find_get(chip_num
);
1022 tpm_cmd
.header
.in
= tpm_getrandom_header
;
1023 tpm_cmd
.params
.getrandom_in
.num_bytes
= cpu_to_be32(num_bytes
);
1025 err
= transmit_cmd(chip
, &tpm_cmd
,
1026 TPM_GETRANDOM_RESULT_SIZE
+ num_bytes
,
1027 "attempting get random");
1031 recd
= be32_to_cpu(tpm_cmd
.params
.getrandom_out
.rng_data_len
);
1032 memcpy(dest
, tpm_cmd
.params
.getrandom_out
.rng_data
, recd
);
1037 } while (retries
-- && total
< max
);
1040 return total
? total
: -EIO
;
1042 EXPORT_SYMBOL_GPL(tpm_get_random
);
1044 /* In case vendor provided release function, call it too.*/
1046 void tpm_dev_vendor_release(struct tpm_chip
*chip
)
1051 clear_bit(chip
->dev_num
, dev_mask
);
1053 EXPORT_SYMBOL_GPL(tpm_dev_vendor_release
);
1057 * Once all references to platform device are down to 0,
1058 * release all allocated structures.
1060 static void tpm_dev_release(struct device
*dev
)
1062 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1067 tpm_dev_vendor_release(chip
);
1074 * Called from tpm_<specific>.c probe function only for devices
1075 * the driver has determined it should claim. Prior to calling
1076 * this function the specific probe function has called pci_enable_device
1077 * upon errant exit from this function specific probe function should call
1078 * pci_disable_device
1080 struct tpm_chip
*tpm_register_hardware(struct device
*dev
,
1081 const struct tpm_class_ops
*ops
)
1083 struct tpm_chip
*chip
;
1085 /* Driver specific per-device data */
1086 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1091 mutex_init(&chip
->tpm_mutex
);
1092 INIT_LIST_HEAD(&chip
->list
);
1095 chip
->dev_num
= find_first_zero_bit(dev_mask
, TPM_NUM_DEVICES
);
1097 if (chip
->dev_num
>= TPM_NUM_DEVICES
) {
1098 dev_err(dev
, "No available tpm device numbers\n");
1102 set_bit(chip
->dev_num
, dev_mask
);
1104 scnprintf(chip
->devname
, sizeof(chip
->devname
), "%s%d", "tpm",
1107 chip
->dev
= get_device(dev
);
1108 chip
->release
= dev
->release
;
1109 dev
->release
= tpm_dev_release
;
1110 dev_set_drvdata(dev
, chip
);
1112 if (tpm_dev_add_device(chip
))
1115 if (tpm_sysfs_add_device(chip
))
1118 if (tpm_add_ppi(&dev
->kobj
))
1121 chip
->bios_dir
= tpm_bios_log_setup(chip
->devname
);
1123 /* Make chip available */
1124 spin_lock(&driver_lock
);
1125 list_add_rcu(&chip
->list
, &tpm_chip_list
);
1126 spin_unlock(&driver_lock
);
1131 tpm_sysfs_del_device(chip
);
1133 tpm_dev_del_device(chip
);
1135 put_device(chip
->dev
);
1140 EXPORT_SYMBOL_GPL(tpm_register_hardware
);
1142 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1143 MODULE_DESCRIPTION("TPM Driver");
1144 MODULE_VERSION("2.0");
1145 MODULE_LICENSE("GPL");