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
) != 0 ||
579 be32_to_cpu(tpm_cmd
.header
.out
.length
)
580 != sizeof(tpm_cmd
.header
.out
) + sizeof(u32
) + 3 * sizeof(u32
))
583 duration_cap
= &tpm_cmd
.params
.getcap_out
.cap
.duration
;
584 chip
->vendor
.duration
[TPM_SHORT
] =
585 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_short
));
586 chip
->vendor
.duration
[TPM_MEDIUM
] =
587 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_medium
));
588 chip
->vendor
.duration
[TPM_LONG
] =
589 usecs_to_jiffies(be32_to_cpu(duration_cap
->tpm_long
));
591 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
592 * value wrong and apparently reports msecs rather than usecs. So we
593 * fix up the resulting too-small TPM_SHORT value to make things work.
594 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
596 if (chip
->vendor
.duration
[TPM_SHORT
] < (HZ
/ 100)) {
597 chip
->vendor
.duration
[TPM_SHORT
] = HZ
;
598 chip
->vendor
.duration
[TPM_MEDIUM
] *= 1000;
599 chip
->vendor
.duration
[TPM_LONG
] *= 1000;
600 chip
->vendor
.duration_adjusted
= true;
601 dev_info(chip
->dev
, "Adjusting TPM timeout parameters.");
604 EXPORT_SYMBOL_GPL(tpm_get_timeouts
);
606 void tpm_continue_selftest(struct tpm_chip
*chip
)
609 0, 193, /* TPM_TAG_RQU_COMMAND */
610 0, 0, 0, 10, /* length */
611 0, 0, 0, 83, /* TPM_ORD_GetCapability */
614 tpm_transmit(chip
, data
, sizeof(data
));
616 EXPORT_SYMBOL_GPL(tpm_continue_selftest
);
618 ssize_t
tpm_show_enabled(struct device
* dev
, struct device_attribute
* attr
,
624 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_PERM
, &cap
,
625 "attempting to determine the permanent enabled state");
629 rc
= sprintf(buf
, "%d\n", !cap
.perm_flags
.disable
);
632 EXPORT_SYMBOL_GPL(tpm_show_enabled
);
634 ssize_t
tpm_show_active(struct device
* dev
, struct device_attribute
* attr
,
640 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_PERM
, &cap
,
641 "attempting to determine the permanent active state");
645 rc
= sprintf(buf
, "%d\n", !cap
.perm_flags
.deactivated
);
648 EXPORT_SYMBOL_GPL(tpm_show_active
);
650 ssize_t
tpm_show_owned(struct device
* dev
, struct device_attribute
* attr
,
656 rc
= tpm_getcap(dev
, TPM_CAP_PROP_OWNER
, &cap
,
657 "attempting to determine the owner state");
661 rc
= sprintf(buf
, "%d\n", cap
.owned
);
664 EXPORT_SYMBOL_GPL(tpm_show_owned
);
666 ssize_t
tpm_show_temp_deactivated(struct device
* dev
,
667 struct device_attribute
* attr
, char *buf
)
672 rc
= tpm_getcap(dev
, TPM_CAP_FLAG_VOL
, &cap
,
673 "attempting to determine the temporary state");
677 rc
= sprintf(buf
, "%d\n", cap
.stclear_flags
.deactivated
);
680 EXPORT_SYMBOL_GPL(tpm_show_temp_deactivated
);
683 * tpm_chip_find_get - return tpm_chip for given chip number
685 static struct tpm_chip
*tpm_chip_find_get(int chip_num
)
687 struct tpm_chip
*pos
, *chip
= NULL
;
690 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
691 if (chip_num
!= TPM_ANY_NUM
&& chip_num
!= pos
->dev_num
)
694 if (try_module_get(pos
->dev
->driver
->owner
)) {
703 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
704 #define READ_PCR_RESULT_SIZE 30
705 static struct tpm_input_header pcrread_header
= {
706 .tag
= TPM_TAG_RQU_COMMAND
,
707 .length
= cpu_to_be32(14),
708 .ordinal
= TPM_ORDINAL_PCRREAD
711 int __tpm_pcr_read(struct tpm_chip
*chip
, int pcr_idx
, u8
*res_buf
)
714 struct tpm_cmd_t cmd
;
716 cmd
.header
.in
= pcrread_header
;
717 cmd
.params
.pcrread_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
718 rc
= transmit_cmd(chip
, &cmd
, READ_PCR_RESULT_SIZE
,
719 "attempting to read a pcr value");
722 memcpy(res_buf
, cmd
.params
.pcrread_out
.pcr_result
,
728 * tpm_pcr_read - read a pcr value
729 * @chip_num: tpm idx # or ANY
730 * @pcr_idx: pcr idx to retrieve
731 * @res_buf: TPM_PCR value
732 * size of res_buf is 20 bytes (or NULL if you don't care)
734 * The TPM driver should be built-in, but for whatever reason it
735 * isn't, protect against the chip disappearing, by incrementing
736 * the module usage count.
738 int tpm_pcr_read(u32 chip_num
, int pcr_idx
, u8
*res_buf
)
740 struct tpm_chip
*chip
;
743 chip
= tpm_chip_find_get(chip_num
);
746 rc
= __tpm_pcr_read(chip
, pcr_idx
, res_buf
);
750 EXPORT_SYMBOL_GPL(tpm_pcr_read
);
753 * tpm_pcr_extend - extend pcr value with hash
754 * @chip_num: tpm idx # or AN&
755 * @pcr_idx: pcr idx to extend
756 * @hash: hash value used to extend pcr value
758 * The TPM driver should be built-in, but for whatever reason it
759 * isn't, protect against the chip disappearing, by incrementing
760 * the module usage count.
762 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
763 #define EXTEND_PCR_RESULT_SIZE 34
764 static struct tpm_input_header pcrextend_header
= {
765 .tag
= TPM_TAG_RQU_COMMAND
,
766 .length
= cpu_to_be32(34),
767 .ordinal
= TPM_ORD_PCR_EXTEND
770 int tpm_pcr_extend(u32 chip_num
, int pcr_idx
, const u8
*hash
)
772 struct tpm_cmd_t cmd
;
774 struct tpm_chip
*chip
;
776 chip
= tpm_chip_find_get(chip_num
);
780 cmd
.header
.in
= pcrextend_header
;
781 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(pcr_idx
);
782 memcpy(cmd
.params
.pcrextend_in
.hash
, hash
, TPM_DIGEST_SIZE
);
783 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
784 "attempting extend a PCR value");
789 EXPORT_SYMBOL_GPL(tpm_pcr_extend
);
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
= transmit_cmd(chip
, cmd
, buflen
, "attempting tpm_cmd");
805 EXPORT_SYMBOL_GPL(tpm_send
);
807 ssize_t
tpm_show_pcrs(struct device
*dev
, struct device_attribute
*attr
,
811 u8 digest
[TPM_DIGEST_SIZE
];
815 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
817 rc
= tpm_getcap(dev
, TPM_CAP_PROP_PCR
, &cap
,
818 "attempting to determine the number of PCRS");
822 num_pcrs
= be32_to_cpu(cap
.num_pcrs
);
823 for (i
= 0; i
< num_pcrs
; i
++) {
824 rc
= __tpm_pcr_read(chip
, i
, digest
);
827 str
+= sprintf(str
, "PCR-%02d: ", i
);
828 for (j
= 0; j
< TPM_DIGEST_SIZE
; j
++)
829 str
+= sprintf(str
, "%02X ", digest
[j
]);
830 str
+= sprintf(str
, "\n");
834 EXPORT_SYMBOL_GPL(tpm_show_pcrs
);
836 #define READ_PUBEK_RESULT_SIZE 314
837 #define TPM_ORD_READPUBEK cpu_to_be32(124)
838 struct tpm_input_header tpm_readpubek_header
= {
839 .tag
= TPM_TAG_RQU_COMMAND
,
840 .length
= cpu_to_be32(30),
841 .ordinal
= TPM_ORD_READPUBEK
844 ssize_t
tpm_show_pubek(struct device
*dev
, struct device_attribute
*attr
,
848 struct tpm_cmd_t tpm_cmd
;
853 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
855 tpm_cmd
.header
.in
= tpm_readpubek_header
;
856 err
= transmit_cmd(chip
, &tpm_cmd
, READ_PUBEK_RESULT_SIZE
,
857 "attempting to read the PUBEK");
862 ignore header 10 bytes
863 algorithm 32 bits (1 == RSA )
866 parameters (RSA 12->bytes: keybit, #primes, expbit)
869 ignore checksum 20 bytes
871 data
= tpm_cmd
.params
.readpubek_out_buffer
;
874 "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
875 "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
876 " %02X %02X %02X %02X %02X %02X %02X %02X\n"
877 "Modulus length: %d\nModulus: \n",
878 data
[10], data
[11], data
[12], data
[13], data
[14],
879 data
[15], data
[16], data
[17], data
[22], data
[23],
880 data
[24], data
[25], data
[26], data
[27], data
[28],
881 data
[29], data
[30], data
[31], data
[32], data
[33],
882 be32_to_cpu(*((__be32
*) (data
+ 34))));
884 for (i
= 0; i
< 256; i
++) {
885 str
+= sprintf(str
, "%02X ", data
[i
+ 38]);
886 if ((i
+ 1) % 16 == 0)
887 str
+= sprintf(str
, "\n");
893 EXPORT_SYMBOL_GPL(tpm_show_pubek
);
896 ssize_t
tpm_show_caps(struct device
*dev
, struct device_attribute
*attr
,
903 rc
= tpm_getcap(dev
, TPM_CAP_PROP_MANUFACTURER
, &cap
,
904 "attempting to determine the manufacturer");
907 str
+= sprintf(str
, "Manufacturer: 0x%x\n",
908 be32_to_cpu(cap
.manufacturer_id
));
910 rc
= tpm_getcap(dev
, CAP_VERSION_1_1
, &cap
,
911 "attempting to determine the 1.1 version");
915 "TCG version: %d.%d\nFirmware version: %d.%d\n",
916 cap
.tpm_version
.Major
, cap
.tpm_version
.Minor
,
917 cap
.tpm_version
.revMajor
, cap
.tpm_version
.revMinor
);
920 EXPORT_SYMBOL_GPL(tpm_show_caps
);
922 ssize_t
tpm_show_caps_1_2(struct device
* dev
,
923 struct device_attribute
* attr
, char *buf
)
929 rc
= tpm_getcap(dev
, TPM_CAP_PROP_MANUFACTURER
, &cap
,
930 "attempting to determine the manufacturer");
933 str
+= sprintf(str
, "Manufacturer: 0x%x\n",
934 be32_to_cpu(cap
.manufacturer_id
));
935 rc
= tpm_getcap(dev
, CAP_VERSION_1_2
, &cap
,
936 "attempting to determine the 1.2 version");
940 "TCG version: %d.%d\nFirmware version: %d.%d\n",
941 cap
.tpm_version_1_2
.Major
, cap
.tpm_version_1_2
.Minor
,
942 cap
.tpm_version_1_2
.revMajor
,
943 cap
.tpm_version_1_2
.revMinor
);
946 EXPORT_SYMBOL_GPL(tpm_show_caps_1_2
);
948 ssize_t
tpm_show_durations(struct device
*dev
, struct device_attribute
*attr
,
951 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
953 return sprintf(buf
, "%d %d %d [%s]\n",
954 jiffies_to_usecs(chip
->vendor
.duration
[TPM_SHORT
]),
955 jiffies_to_usecs(chip
->vendor
.duration
[TPM_MEDIUM
]),
956 jiffies_to_usecs(chip
->vendor
.duration
[TPM_LONG
]),
957 chip
->vendor
.duration_adjusted
958 ? "adjusted" : "original");
960 EXPORT_SYMBOL_GPL(tpm_show_durations
);
962 ssize_t
tpm_store_cancel(struct device
*dev
, struct device_attribute
*attr
,
963 const char *buf
, size_t count
)
965 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
969 chip
->vendor
.cancel(chip
);
972 EXPORT_SYMBOL_GPL(tpm_store_cancel
);
975 * Device file system interface to the TPM
977 * It's assured that the chip will be opened just once,
978 * by the check of is_open variable, which is protected
981 int tpm_open(struct inode
*inode
, struct file
*file
)
983 int minor
= iminor(inode
);
984 struct tpm_chip
*chip
= NULL
, *pos
;
987 list_for_each_entry_rcu(pos
, &tpm_chip_list
, list
) {
988 if (pos
->vendor
.miscdev
.minor
== minor
) {
990 get_device(chip
->dev
);
999 if (test_and_set_bit(0, &chip
->is_open
)) {
1000 dev_dbg(chip
->dev
, "Another process owns this TPM\n");
1001 put_device(chip
->dev
);
1005 chip
->data_buffer
= kzalloc(TPM_BUFSIZE
, GFP_KERNEL
);
1006 if (chip
->data_buffer
== NULL
) {
1007 clear_bit(0, &chip
->is_open
);
1008 put_device(chip
->dev
);
1012 atomic_set(&chip
->data_pending
, 0);
1014 file
->private_data
= chip
;
1017 EXPORT_SYMBOL_GPL(tpm_open
);
1020 * Called on file close
1022 int tpm_release(struct inode
*inode
, struct file
*file
)
1024 struct tpm_chip
*chip
= file
->private_data
;
1026 del_singleshot_timer_sync(&chip
->user_read_timer
);
1027 flush_work_sync(&chip
->work
);
1028 file
->private_data
= NULL
;
1029 atomic_set(&chip
->data_pending
, 0);
1030 kfree(chip
->data_buffer
);
1031 clear_bit(0, &chip
->is_open
);
1032 put_device(chip
->dev
);
1035 EXPORT_SYMBOL_GPL(tpm_release
);
1037 ssize_t
tpm_write(struct file
*file
, const char __user
*buf
,
1038 size_t size
, loff_t
*off
)
1040 struct tpm_chip
*chip
= file
->private_data
;
1041 size_t in_size
= size
, out_size
;
1043 /* cannot perform a write until the read has cleared
1044 either via tpm_read or a user_read_timer timeout */
1045 while (atomic_read(&chip
->data_pending
) != 0)
1046 msleep(TPM_TIMEOUT
);
1048 mutex_lock(&chip
->buffer_mutex
);
1050 if (in_size
> TPM_BUFSIZE
)
1051 in_size
= TPM_BUFSIZE
;
1054 (chip
->data_buffer
, (void __user
*) buf
, in_size
)) {
1055 mutex_unlock(&chip
->buffer_mutex
);
1059 /* atomic tpm command send and result receive */
1060 out_size
= tpm_transmit(chip
, chip
->data_buffer
, TPM_BUFSIZE
);
1062 atomic_set(&chip
->data_pending
, out_size
);
1063 mutex_unlock(&chip
->buffer_mutex
);
1065 /* Set a timeout by which the reader must come claim the result */
1066 mod_timer(&chip
->user_read_timer
, jiffies
+ (60 * HZ
));
1070 EXPORT_SYMBOL_GPL(tpm_write
);
1072 ssize_t
tpm_read(struct file
*file
, char __user
*buf
,
1073 size_t size
, loff_t
*off
)
1075 struct tpm_chip
*chip
= file
->private_data
;
1078 del_singleshot_timer_sync(&chip
->user_read_timer
);
1079 flush_work_sync(&chip
->work
);
1080 ret_size
= atomic_read(&chip
->data_pending
);
1081 atomic_set(&chip
->data_pending
, 0);
1082 if (ret_size
> 0) { /* relay data */
1083 if (size
< ret_size
)
1086 mutex_lock(&chip
->buffer_mutex
);
1087 if (copy_to_user(buf
, chip
->data_buffer
, ret_size
))
1089 mutex_unlock(&chip
->buffer_mutex
);
1094 EXPORT_SYMBOL_GPL(tpm_read
);
1096 void tpm_remove_hardware(struct device
*dev
)
1098 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1101 dev_err(dev
, "No device data found\n");
1105 spin_lock(&driver_lock
);
1106 list_del_rcu(&chip
->list
);
1107 spin_unlock(&driver_lock
);
1110 misc_deregister(&chip
->vendor
.miscdev
);
1111 sysfs_remove_group(&dev
->kobj
, chip
->vendor
.attr_group
);
1112 tpm_bios_log_teardown(chip
->bios_dir
);
1114 /* write it this way to be explicit (chip->dev == dev) */
1115 put_device(chip
->dev
);
1117 EXPORT_SYMBOL_GPL(tpm_remove_hardware
);
1119 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
1120 #define SAVESTATE_RESULT_SIZE 10
1122 static struct tpm_input_header savestate_header
= {
1123 .tag
= TPM_TAG_RQU_COMMAND
,
1124 .length
= cpu_to_be32(10),
1125 .ordinal
= TPM_ORD_SAVESTATE
1129 * We are about to suspend. Save the TPM state
1130 * so that it can be restored.
1132 int tpm_pm_suspend(struct device
*dev
, pm_message_t pm_state
)
1134 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1135 struct tpm_cmd_t cmd
;
1138 u8 dummy_hash
[TPM_DIGEST_SIZE
] = { 0 };
1143 /* for buggy tpm, flush pcrs with extend to selected dummy */
1144 if (tpm_suspend_pcr
) {
1145 cmd
.header
.in
= pcrextend_header
;
1146 cmd
.params
.pcrextend_in
.pcr_idx
= cpu_to_be32(tpm_suspend_pcr
);
1147 memcpy(cmd
.params
.pcrextend_in
.hash
, dummy_hash
,
1149 rc
= transmit_cmd(chip
, &cmd
, EXTEND_PCR_RESULT_SIZE
,
1150 "extending dummy pcr before suspend");
1153 /* now do the actual savestate */
1154 cmd
.header
.in
= savestate_header
;
1155 rc
= transmit_cmd(chip
, &cmd
, SAVESTATE_RESULT_SIZE
,
1156 "sending savestate before suspend");
1159 EXPORT_SYMBOL_GPL(tpm_pm_suspend
);
1162 * Resume from a power safe. The BIOS already restored
1165 int tpm_pm_resume(struct device
*dev
)
1167 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1174 EXPORT_SYMBOL_GPL(tpm_pm_resume
);
1176 /* In case vendor provided release function, call it too.*/
1178 void tpm_dev_vendor_release(struct tpm_chip
*chip
)
1180 if (chip
->vendor
.release
)
1181 chip
->vendor
.release(chip
->dev
);
1183 clear_bit(chip
->dev_num
, dev_mask
);
1184 kfree(chip
->vendor
.miscdev
.name
);
1186 EXPORT_SYMBOL_GPL(tpm_dev_vendor_release
);
1190 * Once all references to platform device are down to 0,
1191 * release all allocated structures.
1193 void tpm_dev_release(struct device
*dev
)
1195 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1197 tpm_dev_vendor_release(chip
);
1202 EXPORT_SYMBOL_GPL(tpm_dev_release
);
1205 * Called from tpm_<specific>.c probe function only for devices
1206 * the driver has determined it should claim. Prior to calling
1207 * this function the specific probe function has called pci_enable_device
1208 * upon errant exit from this function specific probe function should call
1209 * pci_disable_device
1211 struct tpm_chip
*tpm_register_hardware(struct device
*dev
,
1212 const struct tpm_vendor_specific
*entry
)
1214 #define DEVNAME_SIZE 7
1217 struct tpm_chip
*chip
;
1219 /* Driver specific per-device data */
1220 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1221 devname
= kmalloc(DEVNAME_SIZE
, GFP_KERNEL
);
1223 if (chip
== NULL
|| devname
== NULL
)
1226 mutex_init(&chip
->buffer_mutex
);
1227 mutex_init(&chip
->tpm_mutex
);
1228 INIT_LIST_HEAD(&chip
->list
);
1230 INIT_WORK(&chip
->work
, timeout_work
);
1232 setup_timer(&chip
->user_read_timer
, user_reader_timeout
,
1233 (unsigned long)chip
);
1235 memcpy(&chip
->vendor
, entry
, sizeof(struct tpm_vendor_specific
));
1237 chip
->dev_num
= find_first_zero_bit(dev_mask
, TPM_NUM_DEVICES
);
1239 if (chip
->dev_num
>= TPM_NUM_DEVICES
) {
1240 dev_err(dev
, "No available tpm device numbers\n");
1242 } else if (chip
->dev_num
== 0)
1243 chip
->vendor
.miscdev
.minor
= TPM_MINOR
;
1245 chip
->vendor
.miscdev
.minor
= MISC_DYNAMIC_MINOR
;
1247 set_bit(chip
->dev_num
, dev_mask
);
1249 scnprintf(devname
, DEVNAME_SIZE
, "%s%d", "tpm", chip
->dev_num
);
1250 chip
->vendor
.miscdev
.name
= devname
;
1252 chip
->vendor
.miscdev
.parent
= dev
;
1253 chip
->dev
= get_device(dev
);
1254 chip
->release
= dev
->release
;
1255 dev
->release
= tpm_dev_release
;
1256 dev_set_drvdata(dev
, chip
);
1258 if (misc_register(&chip
->vendor
.miscdev
)) {
1260 "unable to misc_register %s, minor %d\n",
1261 chip
->vendor
.miscdev
.name
,
1262 chip
->vendor
.miscdev
.minor
);
1263 put_device(chip
->dev
);
1267 if (sysfs_create_group(&dev
->kobj
, chip
->vendor
.attr_group
)) {
1268 misc_deregister(&chip
->vendor
.miscdev
);
1269 put_device(chip
->dev
);
1274 chip
->bios_dir
= tpm_bios_log_setup(devname
);
1276 /* Make chip available */
1277 spin_lock(&driver_lock
);
1278 list_add_rcu(&chip
->list
, &tpm_chip_list
);
1279 spin_unlock(&driver_lock
);
1288 EXPORT_SYMBOL_GPL(tpm_register_hardware
);
1290 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1291 MODULE_DESCRIPTION("TPM Driver");
1292 MODULE_VERSION("2.0");
1293 MODULE_LICENSE("GPL");