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>
34 TPM_MINOR
= 224, /* officially assigned */
36 TPM_NUM_DEVICES
= 256,
46 #define TPM_MAX_ORDINAL 243
47 #define TPM_MAX_PROTECTED_ORDINAL 12
48 #define TPM_PROTECTED_ORDINAL_MASK 0xFF
51 * Bug workaround - some TPM's don't flush the most
52 * recently changed pcr on suspend, so force the flush
53 * with an extend to the selected _unused_ non-volatile pcr.
55 static int tpm_suspend_pcr
;
56 module_param_named(suspend_pcr
, tpm_suspend_pcr
, uint
, 0644);
57 MODULE_PARM_DESC(suspend_pcr
,
58 "PCR to use for dummy writes to faciltate flush on suspend.");
60 static LIST_HEAD(tpm_chip_list
);
61 static DEFINE_SPINLOCK(driver_lock
);
62 static DECLARE_BITMAP(dev_mask
, TPM_NUM_DEVICES
);
65 * Array with one entry per ordinal defining the maximum amount
66 * of time the chip could take to return the result. The ordinal
67 * designation of short, medium or long is defined in a table in
68 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
69 * values of the SHORT, MEDIUM, and LONG durations are retrieved
70 * from the chip during initialization with a call to tpm_get_timeouts.
72 static const u8 tpm_protected_ordinal_duration
[TPM_MAX_PROTECTED_ORDINAL
] = {
73 TPM_UNDEFINED
, /* 0 */
78 TPM_UNDEFINED
, /* 5 */
87 static const u8 tpm_ordinal_duration
[TPM_MAX_ORDINAL
] = {
88 TPM_UNDEFINED
, /* 0 */
93 TPM_UNDEFINED
, /* 5 */
143 TPM_UNDEFINED
, /* 55 */
163 TPM_UNDEFINED
, /* 75 */
173 TPM_UNDEFINED
, /* 85 */
183 TPM_UNDEFINED
, /* 95 */
188 TPM_MEDIUM
, /* 100 */
193 TPM_UNDEFINED
, /* 105 */
223 TPM_UNDEFINED
, /* 135 */
233 TPM_UNDEFINED
, /* 145 */
243 TPM_UNDEFINED
, /* 155 */
253 TPM_UNDEFINED
, /* 165 */
263 TPM_UNDEFINED
, /* 175 */
268 TPM_MEDIUM
, /* 180 */
273 TPM_MEDIUM
, /* 185 */
278 TPM_UNDEFINED
, /* 190 */
283 TPM_UNDEFINED
, /* 195 */
298 TPM_MEDIUM
, /* 210 */
303 TPM_UNDEFINED
, /* 215 */
313 TPM_UNDEFINED
, /* 225 */
323 TPM_UNDEFINED
, /* 235 */
333 static void user_reader_timeout(unsigned long ptr
)
335 struct tpm_chip
*chip
= (struct tpm_chip
*) ptr
;
337 schedule_work(&chip
->work
);
340 static void timeout_work(struct work_struct
*work
)
342 struct tpm_chip
*chip
= container_of(work
, struct tpm_chip
, work
);
344 mutex_lock(&chip
->buffer_mutex
);
345 atomic_set(&chip
->data_pending
, 0);
346 memset(chip
->data_buffer
, 0, TPM_BUFSIZE
);
347 mutex_unlock(&chip
->buffer_mutex
);
351 * Returns max number of jiffies to wait
353 unsigned long tpm_calc_ordinal_duration(struct tpm_chip
*chip
,
356 int duration_idx
= TPM_UNDEFINED
;
359 if (ordinal
< TPM_MAX_ORDINAL
)
360 duration_idx
= tpm_ordinal_duration
[ordinal
];
361 else if ((ordinal
& TPM_PROTECTED_ORDINAL_MASK
) <
362 TPM_MAX_PROTECTED_ORDINAL
)
364 tpm_protected_ordinal_duration
[ordinal
&
365 TPM_PROTECTED_ORDINAL_MASK
];
367 if (duration_idx
!= TPM_UNDEFINED
)
368 duration
= chip
->vendor
.duration
[duration_idx
];
374 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration
);
377 * Internal kernel interface to transmit TPM commands
379 static ssize_t
tpm_transmit(struct tpm_chip
*chip
, const char *buf
,
386 count
= be32_to_cpu(*((__be32
*) (buf
+ 2)));
387 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
390 if (count
> bufsiz
) {
392 "invalid count value %x %zx \n", count
, bufsiz
);
396 mutex_lock(&chip
->tpm_mutex
);
398 if ((rc
= chip
->vendor
.send(chip
, (u8
*) buf
, count
)) < 0) {
400 "tpm_transmit: tpm_send: error %zd\n", rc
);
404 if (chip
->vendor
.irq
)
407 stop
= jiffies
+ tpm_calc_ordinal_duration(chip
, ordinal
);
409 u8 status
= chip
->vendor
.status(chip
);
410 if ((status
& chip
->vendor
.req_complete_mask
) ==
411 chip
->vendor
.req_complete_val
)
414 if ((status
== chip
->vendor
.req_canceled
)) {
415 dev_err(chip
->dev
, "Operation Canceled\n");
420 msleep(TPM_TIMEOUT
); /* CHECK */
422 } while (time_before(jiffies
, stop
));
424 chip
->vendor
.cancel(chip
);
425 dev_err(chip
->dev
, "Operation Timed out\n");
430 rc
= chip
->vendor
.recv(chip
, (u8
*) buf
, bufsiz
);
433 "tpm_transmit: tpm_recv: error %zd\n", rc
);
435 mutex_unlock(&chip
->tpm_mutex
);
439 #define TPM_DIGEST_SIZE 20
440 #define TPM_ERROR_SIZE 10
441 #define TPM_RET_CODE_IDX 6
443 enum tpm_capabilities
{
444 TPM_CAP_FLAG
= cpu_to_be32(4),
445 TPM_CAP_PROP
= cpu_to_be32(5),
446 CAP_VERSION_1_1
= cpu_to_be32(0x06),
447 CAP_VERSION_1_2
= cpu_to_be32(0x1A)
450 enum tpm_sub_capabilities
{
451 TPM_CAP_PROP_PCR
= cpu_to_be32(0x101),
452 TPM_CAP_PROP_MANUFACTURER
= cpu_to_be32(0x103),
453 TPM_CAP_FLAG_PERM
= cpu_to_be32(0x108),
454 TPM_CAP_FLAG_VOL
= cpu_to_be32(0x109),
455 TPM_CAP_PROP_OWNER
= cpu_to_be32(0x111),
456 TPM_CAP_PROP_TIS_TIMEOUT
= cpu_to_be32(0x115),
457 TPM_CAP_PROP_TIS_DURATION
= cpu_to_be32(0x120),
461 static ssize_t
transmit_cmd(struct tpm_chip
*chip
, struct tpm_cmd_t
*cmd
,
462 int len
, const char *desc
)
466 len
= tpm_transmit(chip
,(u8
*) cmd
, len
);
469 if (len
== TPM_ERROR_SIZE
) {
470 err
= be32_to_cpu(cmd
->header
.out
.return_code
);
471 dev_dbg(chip
->dev
, "A TPM error (%d) occurred %s\n", err
, desc
);
477 #define TPM_INTERNAL_RESULT_SIZE 200
478 #define TPM_TAG_RQU_COMMAND cpu_to_be16(193)
479 #define TPM_ORD_GET_CAP cpu_to_be32(101)
481 static const struct tpm_input_header tpm_getcap_header
= {
482 .tag
= TPM_TAG_RQU_COMMAND
,
483 .length
= cpu_to_be32(22),
484 .ordinal
= TPM_ORD_GET_CAP
487 ssize_t
tpm_getcap(struct device
*dev
, __be32 subcap_id
, cap_t
*cap
,
490 struct tpm_cmd_t tpm_cmd
;
492 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
494 tpm_cmd
.header
.in
= tpm_getcap_header
;
495 if (subcap_id
== CAP_VERSION_1_1
|| subcap_id
== CAP_VERSION_1_2
) {
496 tpm_cmd
.params
.getcap_in
.cap
= subcap_id
;
497 /*subcap field not necessary */
498 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(0);
499 tpm_cmd
.header
.in
.length
-= cpu_to_be32(sizeof(__be32
));
501 if (subcap_id
== TPM_CAP_FLAG_PERM
||
502 subcap_id
== TPM_CAP_FLAG_VOL
)
503 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_FLAG
;
505 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
506 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
507 tpm_cmd
.params
.getcap_in
.subcap
= subcap_id
;
509 rc
= transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
, desc
);
511 *cap
= tpm_cmd
.params
.getcap_out
.cap
;
515 void tpm_gen_interrupt(struct tpm_chip
*chip
)
517 struct tpm_cmd_t tpm_cmd
;
520 tpm_cmd
.header
.in
= tpm_getcap_header
;
521 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
522 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
523 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
525 rc
= transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
526 "attempting to determine the timeouts");
528 EXPORT_SYMBOL_GPL(tpm_gen_interrupt
);
530 void tpm_get_timeouts(struct tpm_chip
*chip
)
532 struct tpm_cmd_t tpm_cmd
;
533 struct timeout_t
*timeout_cap
;
534 struct duration_t
*duration_cap
;
538 tpm_cmd
.header
.in
= tpm_getcap_header
;
539 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
540 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
541 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_TIMEOUT
;
543 rc
= transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
544 "attempting to determine the timeouts");
548 if (be32_to_cpu(tpm_cmd
.header
.out
.length
)
552 timeout_cap
= &tpm_cmd
.params
.getcap_out
.cap
.timeout
;
553 /* Don't overwrite default if value is 0 */
554 timeout
= be32_to_cpu(timeout_cap
->a
);
556 chip
->vendor
.timeout_a
= usecs_to_jiffies(timeout
);
557 timeout
= be32_to_cpu(timeout_cap
->b
);
559 chip
->vendor
.timeout_b
= usecs_to_jiffies(timeout
);
560 timeout
= be32_to_cpu(timeout_cap
->c
);
562 chip
->vendor
.timeout_c
= usecs_to_jiffies(timeout
);
563 timeout
= be32_to_cpu(timeout_cap
->d
);
565 chip
->vendor
.timeout_d
= usecs_to_jiffies(timeout
);
568 tpm_cmd
.header
.in
= tpm_getcap_header
;
569 tpm_cmd
.params
.getcap_in
.cap
= TPM_CAP_PROP
;
570 tpm_cmd
.params
.getcap_in
.subcap_size
= cpu_to_be32(4);
571 tpm_cmd
.params
.getcap_in
.subcap
= TPM_CAP_PROP_TIS_DURATION
;
573 rc
= transmit_cmd(chip
, &tpm_cmd
, TPM_INTERNAL_RESULT_SIZE
,
574 "attempting to determine the durations");
578 if (be32_to_cpu(tpm_cmd
.header
.out
.return_code
)
581 duration_cap
= &tpm_cmd
.params
.getcap_out
.cap
.duration
;
582 chip
->vendor
.duration
[TPM_SHORT
] =
583 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_short
));
584 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
585 * value wrong and apparently reports msecs rather than usecs. So we
586 * fix up the resulting too-small TPM_SHORT value to make things work.
588 if (chip
->vendor
.duration
[TPM_SHORT
] < (HZ
/100))
589 chip
->vendor
.duration
[TPM_SHORT
] = HZ
;
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 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
598 void tpm_continue_selftest(struct tpm_chip
*chip
)
601 0, 193, /* TPM_TAG_RQU_COMMAND */
602 0, 0, 0, 10, /* length */
603 0, 0, 0, 83, /* TPM_ORD_GetCapability */
606 tpm_transmit(chip
, data
, sizeof(data
));
608 EXPORT_SYMBOL_GPL(tpm_continue_selftest
);
610 ssize_t
tpm_show_enabled(struct device
* dev
, struct device_attribute
* attr
,
616 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_PERM
, &cap
,
617 "attempting to determine the permanent enabled state");
621 rc
= sprintf(buf
, "%d\n", !cap
.perm_flags
.disable
);
624 EXPORT_SYMBOL_GPL(tpm_show_enabled
);
626 ssize_t
tpm_show_active(struct device
* dev
, struct device_attribute
* attr
,
632 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_PERM
, &cap
,
633 "attempting to determine the permanent active state");
637 rc
= sprintf(buf
, "%d\n", !cap
.perm_flags
.deactivated
);
640 EXPORT_SYMBOL_GPL(tpm_show_active
);
642 ssize_t
tpm_show_owned(struct device
* dev
, struct device_attribute
* attr
,
648 rc
= tpm_getcap(dev
, TPM_CAP_PROP_OWNER
, &cap
,
649 "attempting to determine the owner state");
653 rc
= sprintf(buf
, "%d\n", cap
.owned
);
656 EXPORT_SYMBOL_GPL(tpm_show_owned
);
658 ssize_t
tpm_show_temp_deactivated(struct device
* dev
,
659 struct device_attribute
* attr
, char *buf
)
664 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_VOL
, &cap
,
665 "attempting to determine the temporary state");
669 rc
= sprintf(buf
, "%d\n", cap
.stclear_flags
.deactivated
);
672 EXPORT_SYMBOL_GPL(tpm_show_temp_deactivated
);
675 * tpm_chip_find_get - return tpm_chip for given chip number
677 static struct tpm_chip
*tpm_chip_find_get(int chip_num
)
679 struct tpm_chip
*pos
, *chip
= NULL
;
682 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
683 if (chip_num
!= TPM_ANY_NUM
&& chip_num
!= pos
->dev_num
)
686 if (try_module_get(pos
->dev
->driver
->owner
)) {
695 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
696 #define READ_PCR_RESULT_SIZE 30
697 static struct tpm_input_header pcrread_header
= {
698 .tag
= TPM_TAG_RQU_COMMAND
,
699 .length
= cpu_to_be32(14),
700 .ordinal
= TPM_ORDINAL_PCRREAD
703 int __tpm_pcr_read(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
706 struct tpm_cmd_t cmd
;
708 cmd
.header
.in
= pcrread_header
;
709 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
710 rc
= transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
711 "attempting to read a pcr value");
714 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
720 * tpm_pcr_read - read a pcr value
721 * @chip_num: tpm idx # or ANY
722 * @pcr_idx: pcr idx to retrieve
723 * @res_buf: TPM_PCR value
724 * size of res_buf is 20 bytes (or NULL if you don't care)
726 * The TPM driver should be built-in, but for whatever reason it
727 * isn't, protect against the chip disappearing, by incrementing
728 * the module usage count.
730 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
732 struct tpm_chip
*chip
;
735 chip
= tpm_chip_find_get(chip_num
);
738 rc
= __tpm_pcr_read(chip
, pcr_idx
, res_buf
);
742 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
745 * tpm_pcr_extend - extend pcr value with hash
746 * @chip_num: tpm idx # or AN&
747 * @pcr_idx: pcr idx to extend
748 * @hash: hash value used to extend pcr value
750 * The TPM driver should be built-in, but for whatever reason it
751 * isn't, protect against the chip disappearing, by incrementing
752 * the module usage count.
754 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
755 #define EXTEND_PCR_RESULT_SIZE 34
756 static struct tpm_input_header pcrextend_header
= {
757 .tag
= TPM_TAG_RQU_COMMAND
,
758 .length
= cpu_to_be32(34),
759 .ordinal
= TPM_ORD_PCR_EXTEND
762 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
764 struct tpm_cmd_t cmd
;
766 struct tpm_chip
*chip
;
768 chip
= tpm_chip_find_get(chip_num
);
772 cmd
.header
.in
= pcrextend_header
;
773 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
774 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
775 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
776 "attempting extend a PCR value");
781 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
783 int tpm_send(u32 chip_num
, void *cmd
, size_t buflen
)
785 struct tpm_chip
*chip
;
788 chip
= tpm_chip_find_get(chip_num
);
792 rc
= transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
797 EXPORT_SYMBOL_GPL(tpm_send
);
799 ssize_t
tpm_show_pcrs(struct device
*dev
, struct device_attribute
*attr
,
803 u8 digest
[TPM_DIGEST_SIZE
];
807 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
809 rc
= tpm_getcap(dev
, TPM_CAP_PROP_PCR
, &cap
,
810 "attempting to determine the number of PCRS");
814 num_pcrs
= be32_to_cpu(cap
.num_pcrs
);
815 for (i
= 0; i
< num_pcrs
; i
++) {
816 rc
= __tpm_pcr_read(chip
, i
, digest
);
819 str
+= sprintf(str
, "PCR-%02d: ", i
);
820 for (j
= 0; j
< TPM_DIGEST_SIZE
; j
++)
821 str
+= sprintf(str
, "%02X ", digest
[j
]);
822 str
+= sprintf(str
, "\n");
826 EXPORT_SYMBOL_GPL(tpm_show_pcrs
);
828 #define READ_PUBEK_RESULT_SIZE 314
829 #define TPM_ORD_READPUBEK cpu_to_be32(124)
830 struct tpm_input_header tpm_readpubek_header
= {
831 .tag
= TPM_TAG_RQU_COMMAND
,
832 .length
= cpu_to_be32(30),
833 .ordinal
= TPM_ORD_READPUBEK
836 ssize_t
tpm_show_pubek(struct device
*dev
, struct device_attribute
*attr
,
840 struct tpm_cmd_t tpm_cmd
;
845 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
847 tpm_cmd
.header
.in
= tpm_readpubek_header
;
848 err
= transmit_cmd(chip
, &tpm_cmd
, READ_PUBEK_RESULT_SIZE
,
849 "attempting to read the PUBEK");
854 ignore header 10 bytes
855 algorithm 32 bits (1 == RSA )
858 parameters (RSA 12->bytes: keybit, #primes, expbit)
861 ignore checksum 20 bytes
863 data
= tpm_cmd
.params
.readpubek_out_buffer
;
866 "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
867 "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
868 " %02X %02X %02X %02X %02X %02X %02X %02X\n"
869 "Modulus length: %d\nModulus: \n",
870 data
[10], data
[11], data
[12], data
[13], data
[14],
871 data
[15], data
[16], data
[17], data
[22], data
[23],
872 data
[24], data
[25], data
[26], data
[27], data
[28],
873 data
[29], data
[30], data
[31], data
[32], data
[33],
874 be32_to_cpu(*((__be32
*) (data
+ 34))));
876 for (i
= 0; i
< 256; i
++) {
877 str
+= sprintf(str
, "%02X ", data
[i
+ 38]);
878 if ((i
+ 1) % 16 == 0)
879 str
+= sprintf(str
, "\n");
885 EXPORT_SYMBOL_GPL(tpm_show_pubek
);
888 ssize_t
tpm_show_caps(struct device
*dev
, struct device_attribute
*attr
,
895 rc
= tpm_getcap(dev
, TPM_CAP_PROP_MANUFACTURER
, &cap
,
896 "attempting to determine the manufacturer");
899 str
+= sprintf(str
, "Manufacturer: 0x%x\n",
900 be32_to_cpu(cap
.manufacturer_id
));
902 rc
= tpm_getcap(dev
, CAP_VERSION_1_1
, &cap
,
903 "attempting to determine the 1.1 version");
907 "TCG version: %d.%d\nFirmware version: %d.%d\n",
908 cap
.tpm_version
.Major
, cap
.tpm_version
.Minor
,
909 cap
.tpm_version
.revMajor
, cap
.tpm_version
.revMinor
);
912 EXPORT_SYMBOL_GPL(tpm_show_caps
);
914 ssize_t
tpm_show_caps_1_2(struct device
* dev
,
915 struct device_attribute
* attr
, char *buf
)
921 rc
= tpm_getcap(dev
, TPM_CAP_PROP_MANUFACTURER
, &cap
,
922 "attempting to determine the manufacturer");
925 str
+= sprintf(str
, "Manufacturer: 0x%x\n",
926 be32_to_cpu(cap
.manufacturer_id
));
927 rc
= tpm_getcap(dev
, CAP_VERSION_1_2
, &cap
,
928 "attempting to determine the 1.2 version");
932 "TCG version: %d.%d\nFirmware version: %d.%d\n",
933 cap
.tpm_version_1_2
.Major
, cap
.tpm_version_1_2
.Minor
,
934 cap
.tpm_version_1_2
.revMajor
,
935 cap
.tpm_version_1_2
.revMinor
);
938 EXPORT_SYMBOL_GPL(tpm_show_caps_1_2
);
940 ssize_t
tpm_store_cancel(struct device
*dev
, struct device_attribute
*attr
,
941 const char *buf
, size_t count
)
943 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
947 chip
->vendor
.cancel(chip
);
950 EXPORT_SYMBOL_GPL(tpm_store_cancel
);
953 * Device file system interface to the TPM
955 * It's assured that the chip will be opened just once,
956 * by the check of is_open variable, which is protected
959 int tpm_open(struct inode
*inode
, struct file
*file
)
961 int minor
= iminor(inode
);
962 struct tpm_chip
*chip
= NULL
, *pos
;
965 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
966 if (pos
->vendor
.miscdev
.minor
== minor
) {
968 get_device(chip
->dev
);
977 if (test_and_set_bit(0, &chip
->is_open
)) {
978 dev_dbg(chip
->dev
, "Another process owns this TPM\n");
979 put_device(chip
->dev
);
983 chip
->data_buffer
= kzalloc(TPM_BUFSIZE
, GFP_KERNEL
);
984 if (chip
->data_buffer
== NULL
) {
985 clear_bit(0, &chip
->is_open
);
986 put_device(chip
->dev
);
990 atomic_set(&chip
->data_pending
, 0);
992 file
->private_data
= chip
;
995 EXPORT_SYMBOL_GPL(tpm_open
);
998 * Called on file close
1000 int tpm_release(struct inode
*inode
, struct file
*file
)
1002 struct tpm_chip
*chip
= file
->private_data
;
1004 del_singleshot_timer_sync(&chip
->user_read_timer
);
1005 flush_work_sync(&chip
->work
);
1006 file
->private_data
= NULL
;
1007 atomic_set(&chip
->data_pending
, 0);
1008 kfree(chip
->data_buffer
);
1009 clear_bit(0, &chip
->is_open
);
1010 put_device(chip
->dev
);
1013 EXPORT_SYMBOL_GPL(tpm_release
);
1015 ssize_t
tpm_write(struct file
*file
, const char __user
*buf
,
1016 size_t size
, loff_t
*off
)
1018 struct tpm_chip
*chip
= file
->private_data
;
1019 size_t in_size
= size
, out_size
;
1021 /* cannot perform a write until the read has cleared
1022 either via tpm_read or a user_read_timer timeout */
1023 while (atomic_read(&chip
->data_pending
) != 0)
1024 msleep(TPM_TIMEOUT
);
1026 mutex_lock(&chip
->buffer_mutex
);
1028 if (in_size
> TPM_BUFSIZE
)
1029 in_size
= TPM_BUFSIZE
;
1032 (chip
->data_buffer
, (void __user
*) buf
, in_size
)) {
1033 mutex_unlock(&chip
->buffer_mutex
);
1037 /* atomic tpm command send and result receive */
1038 out_size
= tpm_transmit(chip
, chip
->data_buffer
, TPM_BUFSIZE
);
1040 atomic_set(&chip
->data_pending
, out_size
);
1041 mutex_unlock(&chip
->buffer_mutex
);
1043 /* Set a timeout by which the reader must come claim the result */
1044 mod_timer(&chip
->user_read_timer
, jiffies
+ (60 * HZ
));
1048 EXPORT_SYMBOL_GPL(tpm_write
);
1050 ssize_t
tpm_read(struct file
*file
, char __user
*buf
,
1051 size_t size
, loff_t
*off
)
1053 struct tpm_chip
*chip
= file
->private_data
;
1056 del_singleshot_timer_sync(&chip
->user_read_timer
);
1057 flush_work_sync(&chip
->work
);
1058 ret_size
= atomic_read(&chip
->data_pending
);
1059 atomic_set(&chip
->data_pending
, 0);
1060 if (ret_size
> 0) { /* relay data */
1061 if (size
< ret_size
)
1064 mutex_lock(&chip
->buffer_mutex
);
1065 if (copy_to_user(buf
, chip
->data_buffer
, ret_size
))
1067 mutex_unlock(&chip
->buffer_mutex
);
1072 EXPORT_SYMBOL_GPL(tpm_read
);
1074 void tpm_remove_hardware(struct device
*dev
)
1076 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1079 dev_err(dev
, "No device data found\n");
1083 spin_lock(&driver_lock
);
1084 list_del_rcu(&chip
->list
);
1085 spin_unlock(&driver_lock
);
1088 misc_deregister(&chip
->vendor
.miscdev
);
1089 sysfs_remove_group(&dev
->kobj
, chip
->vendor
.attr_group
);
1090 tpm_bios_log_teardown(chip
->bios_dir
);
1092 /* write it this way to be explicit (chip->dev == dev) */
1093 put_device(chip
->dev
);
1095 EXPORT_SYMBOL_GPL(tpm_remove_hardware
);
1097 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
1098 #define SAVESTATE_RESULT_SIZE 10
1100 static struct tpm_input_header savestate_header
= {
1101 .tag
= TPM_TAG_RQU_COMMAND
,
1102 .length
= cpu_to_be32(10),
1103 .ordinal
= TPM_ORD_SAVESTATE
1107 * We are about to suspend. Save the TPM state
1108 * so that it can be restored.
1110 int tpm_pm_suspend(struct device
*dev
, pm_message_t pm_state
)
1112 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1113 struct tpm_cmd_t cmd
;
1116 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
1121 /* for buggy tpm, flush pcrs with extend to selected dummy */
1122 if (tpm_suspend_pcr
) {
1123 cmd
.header
.in
= pcrextend_header
;
1124 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
1125 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
1127 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
1128 "extending dummy pcr before suspend");
1131 /* now do the actual savestate */
1132 cmd
.header
.in
= savestate_header
;
1133 rc
= transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
,
1134 "sending savestate before suspend");
1137 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
1140 * Resume from a power safe. The BIOS already restored
1143 int tpm_pm_resume(struct device
*dev
)
1145 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1152 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
1154 /* In case vendor provided release function, call it too.*/
1156 void tpm_dev_vendor_release(struct tpm_chip
*chip
)
1158 if (chip
->vendor
.release
)
1159 chip
->vendor
.release(chip
->dev
);
1161 clear_bit(chip
->dev_num
, dev_mask
);
1162 kfree(chip
->vendor
.miscdev
.name
);
1164 EXPORT_SYMBOL_GPL(tpm_dev_vendor_release
);
1168 * Once all references to platform device are down to 0,
1169 * release all allocated structures.
1171 void tpm_dev_release(struct device
*dev
)
1173 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1175 tpm_dev_vendor_release(chip
);
1180 EXPORT_SYMBOL_GPL(tpm_dev_release
);
1183 * Called from tpm_<specific>.c probe function only for devices
1184 * the driver has determined it should claim. Prior to calling
1185 * this function the specific probe function has called pci_enable_device
1186 * upon errant exit from this function specific probe function should call
1187 * pci_disable_device
1189 struct tpm_chip
*tpm_register_hardware(struct device
*dev
,
1190 const struct tpm_vendor_specific
*entry
)
1192 #define DEVNAME_SIZE 7
1195 struct tpm_chip
*chip
;
1197 /* Driver specific per-device data */
1198 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1199 devname
= kmalloc(DEVNAME_SIZE
, GFP_KERNEL
);
1201 if (chip
== NULL
|| devname
== NULL
)
1204 mutex_init(&chip
->buffer_mutex
);
1205 mutex_init(&chip
->tpm_mutex
);
1206 INIT_LIST_HEAD(&chip
->list
);
1208 INIT_WORK(&chip
->work
, timeout_work
);
1210 setup_timer(&chip
->user_read_timer
, user_reader_timeout
,
1211 (unsigned long)chip
);
1213 memcpy(&chip
->vendor
, entry
, sizeof(struct tpm_vendor_specific
));
1215 chip
->dev_num
= find_first_zero_bit(dev_mask
, TPM_NUM_DEVICES
);
1217 if (chip
->dev_num
>= TPM_NUM_DEVICES
) {
1218 dev_err(dev
, "No available tpm device numbers\n");
1220 } else if (chip
->dev_num
== 0)
1221 chip
->vendor
.miscdev
.minor
= TPM_MINOR
;
1223 chip
->vendor
.miscdev
.minor
= MISC_DYNAMIC_MINOR
;
1225 set_bit(chip
->dev_num
, dev_mask
);
1227 scnprintf(devname
, DEVNAME_SIZE
, "%s%d", "tpm", chip
->dev_num
);
1228 chip
->vendor
.miscdev
.name
= devname
;
1230 chip
->vendor
.miscdev
.parent
= dev
;
1231 chip
->dev
= get_device(dev
);
1232 chip
->release
= dev
->release
;
1233 dev
->release
= tpm_dev_release
;
1234 dev_set_drvdata(dev
, chip
);
1236 if (misc_register(&chip
->vendor
.miscdev
)) {
1238 "unable to misc_register %s, minor %d\n",
1239 chip
->vendor
.miscdev
.name
,
1240 chip
->vendor
.miscdev
.minor
);
1241 put_device(chip
->dev
);
1245 if (sysfs_create_group(&dev
->kobj
, chip
->vendor
.attr_group
)) {
1246 misc_deregister(&chip
->vendor
.miscdev
);
1247 put_device(chip
->dev
);
1252 chip
->bios_dir
= tpm_bios_log_setup(devname
);
1254 /* Make chip available */
1255 spin_lock(&driver_lock
);
1256 list_add_rcu(&chip
->list
, &tpm_chip_list
);
1257 spin_unlock(&driver_lock
);
1266 EXPORT_SYMBOL_GPL(tpm_register_hardware
);
1268 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1269 MODULE_DESCRIPTION("TPM Driver");
1270 MODULE_VERSION("2.0");
1271 MODULE_LICENSE("GPL");