1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2005, 2006 IBM Corporation
4 * Copyright (C) 2014, 2015 Intel Corporation
7 * Leendert van Doorn <leendert@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 device driver implements the TPM interface as defined in
16 * the TCG TPM Interface Spec version 1.2, revision 1.0.
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
21 #include <linux/pnp.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/wait.h>
25 #include <linux/acpi.h>
26 #include <linux/freezer.h>
28 #include "tpm_tis_core.h"
30 static void tpm_tis_clkrun_enable(struct tpm_chip
*chip
, bool value
);
32 static bool wait_for_tpm_stat_cond(struct tpm_chip
*chip
, u8 mask
,
33 bool check_cancel
, bool *canceled
)
35 u8 status
= chip
->ops
->status(chip
);
38 if ((status
& mask
) == mask
)
40 if (check_cancel
&& chip
->ops
->req_canceled(chip
, status
)) {
47 static int wait_for_tpm_stat(struct tpm_chip
*chip
, u8 mask
,
48 unsigned long timeout
, wait_queue_head_t
*queue
,
54 bool canceled
= false;
56 /* check current status */
57 status
= chip
->ops
->status(chip
);
58 if ((status
& mask
) == mask
)
61 stop
= jiffies
+ timeout
;
63 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
65 timeout
= stop
- jiffies
;
66 if ((long)timeout
<= 0)
68 rc
= wait_event_interruptible_timeout(*queue
,
69 wait_for_tpm_stat_cond(chip
, mask
, check_cancel
,
77 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
78 clear_thread_flag(TIF_SIGPENDING
);
83 usleep_range(TPM_TIMEOUT_USECS_MIN
,
84 TPM_TIMEOUT_USECS_MAX
);
85 status
= chip
->ops
->status(chip
);
86 if ((status
& mask
) == mask
)
88 } while (time_before(jiffies
, stop
));
93 /* Before we attempt to access the TPM we must see that the valid bit is set.
94 * The specification says that this bit is 0 at reset and remains 0 until the
95 * 'TPM has gone through its self test and initialization and has established
96 * correct values in the other bits.'
98 static int wait_startup(struct tpm_chip
*chip
, int l
)
100 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
101 unsigned long stop
= jiffies
+ chip
->timeout_a
;
107 rc
= tpm_tis_read8(priv
, TPM_ACCESS(l
), &access
);
111 if (access
& TPM_ACCESS_VALID
)
113 tpm_msleep(TPM_TIMEOUT
);
114 } while (time_before(jiffies
, stop
));
118 static bool check_locality(struct tpm_chip
*chip
, int l
)
120 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
124 rc
= tpm_tis_read8(priv
, TPM_ACCESS(l
), &access
);
128 if ((access
& (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
)) ==
129 (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
)) {
137 static bool locality_inactive(struct tpm_chip
*chip
, int l
)
139 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
143 rc
= tpm_tis_read8(priv
, TPM_ACCESS(l
), &access
);
147 if ((access
& (TPM_ACCESS_VALID
| TPM_ACCESS_ACTIVE_LOCALITY
))
154 static int release_locality(struct tpm_chip
*chip
, int l
)
156 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
157 unsigned long stop
, timeout
;
160 tpm_tis_write8(priv
, TPM_ACCESS(l
), TPM_ACCESS_ACTIVE_LOCALITY
);
162 stop
= jiffies
+ chip
->timeout_a
;
164 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
166 timeout
= stop
- jiffies
;
167 if ((long)timeout
<= 0)
170 rc
= wait_event_interruptible_timeout(priv
->int_queue
,
171 (locality_inactive(chip
, l
)),
177 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
178 clear_thread_flag(TIF_SIGPENDING
);
183 if (locality_inactive(chip
, l
))
185 tpm_msleep(TPM_TIMEOUT
);
186 } while (time_before(jiffies
, stop
));
191 static int request_locality(struct tpm_chip
*chip
, int l
)
193 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
194 unsigned long stop
, timeout
;
197 if (check_locality(chip
, l
))
200 rc
= tpm_tis_write8(priv
, TPM_ACCESS(l
), TPM_ACCESS_REQUEST_USE
);
204 stop
= jiffies
+ chip
->timeout_a
;
206 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
208 timeout
= stop
- jiffies
;
209 if ((long)timeout
<= 0)
211 rc
= wait_event_interruptible_timeout(priv
->int_queue
,
217 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
218 clear_thread_flag(TIF_SIGPENDING
);
222 /* wait for burstcount */
224 if (check_locality(chip
, l
))
226 tpm_msleep(TPM_TIMEOUT
);
227 } while (time_before(jiffies
, stop
));
232 static u8
tpm_tis_status(struct tpm_chip
*chip
)
234 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
238 rc
= tpm_tis_read8(priv
, TPM_STS(priv
->locality
), &status
);
245 static void tpm_tis_ready(struct tpm_chip
*chip
)
247 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
249 /* this causes the current command to be aborted */
250 tpm_tis_write8(priv
, TPM_STS(priv
->locality
), TPM_STS_COMMAND_READY
);
253 static int get_burstcount(struct tpm_chip
*chip
)
255 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
260 /* wait for burstcount */
261 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
262 stop
= jiffies
+ chip
->timeout_a
;
264 stop
= jiffies
+ chip
->timeout_d
;
266 rc
= tpm_tis_read32(priv
, TPM_STS(priv
->locality
), &value
);
270 burstcnt
= (value
>> 8) & 0xFFFF;
273 usleep_range(TPM_TIMEOUT_USECS_MIN
, TPM_TIMEOUT_USECS_MAX
);
274 } while (time_before(jiffies
, stop
));
278 static int recv_data(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
280 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
281 int size
= 0, burstcnt
, rc
;
283 while (size
< count
) {
284 rc
= wait_for_tpm_stat(chip
,
285 TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
287 &priv
->read_queue
, true);
290 burstcnt
= get_burstcount(chip
);
292 dev_err(&chip
->dev
, "Unable to read burstcount\n");
295 burstcnt
= min_t(int, burstcnt
, count
- size
);
297 rc
= tpm_tis_read_bytes(priv
, TPM_DATA_FIFO(priv
->locality
),
298 burstcnt
, buf
+ size
);
307 static int tpm_tis_recv(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
309 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
314 if (count
< TPM_HEADER_SIZE
) {
319 size
= recv_data(chip
, buf
, TPM_HEADER_SIZE
);
320 /* read first 10 bytes, including tag, paramsize, and result */
321 if (size
< TPM_HEADER_SIZE
) {
322 dev_err(&chip
->dev
, "Unable to read header\n");
326 expected
= be32_to_cpu(*(__be32
*) (buf
+ 2));
327 if (expected
> count
|| expected
< TPM_HEADER_SIZE
) {
332 size
+= recv_data(chip
, &buf
[TPM_HEADER_SIZE
],
333 expected
- TPM_HEADER_SIZE
);
334 if (size
< expected
) {
335 dev_err(&chip
->dev
, "Unable to read remainder of result\n");
340 if (wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->timeout_c
,
341 &priv
->int_queue
, false) < 0) {
345 status
= tpm_tis_status(chip
);
346 if (status
& TPM_STS_DATA_AVAIL
) { /* retry? */
347 dev_err(&chip
->dev
, "Error left over data\n");
358 * If interrupts are used (signaled by an irq set in the vendor structure)
359 * tpm.c can skip polling for the data to be available as the interrupt is
362 static int tpm_tis_send_data(struct tpm_chip
*chip
, const u8
*buf
, size_t len
)
364 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
365 int rc
, status
, burstcnt
;
367 bool itpm
= priv
->flags
& TPM_TIS_ITPM_WORKAROUND
;
369 status
= tpm_tis_status(chip
);
370 if ((status
& TPM_STS_COMMAND_READY
) == 0) {
372 if (wait_for_tpm_stat
373 (chip
, TPM_STS_COMMAND_READY
, chip
->timeout_b
,
374 &priv
->int_queue
, false) < 0) {
380 while (count
< len
- 1) {
381 burstcnt
= get_burstcount(chip
);
383 dev_err(&chip
->dev
, "Unable to read burstcount\n");
387 burstcnt
= min_t(int, burstcnt
, len
- count
- 1);
388 rc
= tpm_tis_write_bytes(priv
, TPM_DATA_FIFO(priv
->locality
),
389 burstcnt
, buf
+ count
);
395 if (wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->timeout_c
,
396 &priv
->int_queue
, false) < 0) {
400 status
= tpm_tis_status(chip
);
401 if (!itpm
&& (status
& TPM_STS_DATA_EXPECT
) == 0) {
407 /* write last byte */
408 rc
= tpm_tis_write8(priv
, TPM_DATA_FIFO(priv
->locality
), buf
[count
]);
412 if (wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->timeout_c
,
413 &priv
->int_queue
, false) < 0) {
417 status
= tpm_tis_status(chip
);
418 if (!itpm
&& (status
& TPM_STS_DATA_EXPECT
) != 0) {
430 static void disable_interrupts(struct tpm_chip
*chip
)
432 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
436 rc
= tpm_tis_read32(priv
, TPM_INT_ENABLE(priv
->locality
), &intmask
);
440 intmask
&= ~TPM_GLOBAL_INT_ENABLE
;
441 rc
= tpm_tis_write32(priv
, TPM_INT_ENABLE(priv
->locality
), intmask
);
443 devm_free_irq(chip
->dev
.parent
, priv
->irq
, chip
);
445 chip
->flags
&= ~TPM_CHIP_FLAG_IRQ
;
449 * If interrupts are used (signaled by an irq set in the vendor structure)
450 * tpm.c can skip polling for the data to be available as the interrupt is
453 static int tpm_tis_send_main(struct tpm_chip
*chip
, const u8
*buf
, size_t len
)
455 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
460 rc
= tpm_tis_send_data(chip
, buf
, len
);
465 rc
= tpm_tis_write8(priv
, TPM_STS(priv
->locality
), TPM_STS_GO
);
469 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
) {
470 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
472 dur
= tpm_calc_ordinal_duration(chip
, ordinal
);
473 if (wait_for_tpm_stat
474 (chip
, TPM_STS_DATA_AVAIL
| TPM_STS_VALID
, dur
,
475 &priv
->read_queue
, false) < 0) {
486 static int tpm_tis_send(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
489 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
491 if (!(chip
->flags
& TPM_CHIP_FLAG_IRQ
) || priv
->irq_tested
)
492 return tpm_tis_send_main(chip
, buf
, len
);
494 /* Verify receipt of the expected IRQ */
497 chip
->flags
&= ~TPM_CHIP_FLAG_IRQ
;
498 rc
= tpm_tis_send_main(chip
, buf
, len
);
500 chip
->flags
|= TPM_CHIP_FLAG_IRQ
;
501 if (!priv
->irq_tested
)
503 if (!priv
->irq_tested
)
504 disable_interrupts(chip
);
505 priv
->irq_tested
= true;
509 struct tis_vendor_durations_override
{
511 struct tpm1_version version
;
512 unsigned long durations
[3];
515 static const struct tis_vendor_durations_override vendor_dur_overrides
[] = {
516 /* STMicroelectronics 0x104a */
519 { (2 * 60 * HZ
), (2 * 60 * HZ
), (2 * 60 * HZ
) } },
522 static void tpm_tis_update_durations(struct tpm_chip
*chip
,
523 unsigned long *duration_cap
)
525 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
526 struct tpm1_version
*version
;
531 chip
->duration_adjusted
= false;
533 if (chip
->ops
->clk_enable
!= NULL
)
534 chip
->ops
->clk_enable(chip
, true);
536 rc
= tpm_tis_read32(priv
, TPM_DID_VID(0), &did_vid
);
538 dev_warn(&chip
->dev
, "%s: failed to read did_vid. %d\n",
543 /* Try to get a TPM version 1.2 or 1.1 TPM_CAP_VERSION_INFO */
544 rc
= tpm1_getcap(chip
, TPM_CAP_VERSION_1_2
, &cap
,
545 "attempting to determine the 1.2 version",
546 sizeof(cap
.version2
));
548 version
= &cap
.version2
.version
;
550 rc
= tpm1_getcap(chip
, TPM_CAP_VERSION_1_1
, &cap
,
551 "attempting to determine the 1.1 version",
552 sizeof(cap
.version1
));
557 version
= &cap
.version1
;
560 for (i
= 0; i
!= ARRAY_SIZE(vendor_dur_overrides
); i
++) {
561 if (vendor_dur_overrides
[i
].did_vid
!= did_vid
)
564 if ((version
->major
==
565 vendor_dur_overrides
[i
].version
.major
) &&
567 vendor_dur_overrides
[i
].version
.minor
) &&
568 (version
->rev_major
==
569 vendor_dur_overrides
[i
].version
.rev_major
) &&
570 (version
->rev_minor
==
571 vendor_dur_overrides
[i
].version
.rev_minor
)) {
574 vendor_dur_overrides
[i
].durations
,
575 sizeof(vendor_dur_overrides
[i
].durations
));
577 chip
->duration_adjusted
= true;
583 if (chip
->ops
->clk_enable
!= NULL
)
584 chip
->ops
->clk_enable(chip
, false);
587 struct tis_vendor_timeout_override
{
589 unsigned long timeout_us
[4];
592 static const struct tis_vendor_timeout_override vendor_timeout_overrides
[] = {
594 { 0x32041114, { (TIS_SHORT_TIMEOUT
*1000), (TIS_LONG_TIMEOUT
*1000),
595 (TIS_SHORT_TIMEOUT
*1000), (TIS_SHORT_TIMEOUT
*1000) } },
598 static void tpm_tis_update_timeouts(struct tpm_chip
*chip
,
599 unsigned long *timeout_cap
)
601 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
605 chip
->timeout_adjusted
= false;
607 if (chip
->ops
->clk_enable
!= NULL
)
608 chip
->ops
->clk_enable(chip
, true);
610 rc
= tpm_tis_read32(priv
, TPM_DID_VID(0), &did_vid
);
612 dev_warn(&chip
->dev
, "%s: failed to read did_vid: %d\n",
617 for (i
= 0; i
!= ARRAY_SIZE(vendor_timeout_overrides
); i
++) {
618 if (vendor_timeout_overrides
[i
].did_vid
!= did_vid
)
620 memcpy(timeout_cap
, vendor_timeout_overrides
[i
].timeout_us
,
621 sizeof(vendor_timeout_overrides
[i
].timeout_us
));
622 chip
->timeout_adjusted
= true;
626 if (chip
->ops
->clk_enable
!= NULL
)
627 chip
->ops
->clk_enable(chip
, false);
633 * Early probing for iTPM with STS_DATA_EXPECT flaw.
634 * Try sending command without itpm flag set and if that
635 * fails, repeat with itpm flag set.
637 static int probe_itpm(struct tpm_chip
*chip
)
639 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
641 static const u8 cmd_getticks
[] = {
642 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
643 0x00, 0x00, 0x00, 0xf1
645 size_t len
= sizeof(cmd_getticks
);
648 if (priv
->flags
& TPM_TIS_ITPM_WORKAROUND
)
651 rc
= tpm_tis_read16(priv
, TPM_DID_VID(0), &vendor
);
655 /* probe only iTPMS */
656 if (vendor
!= TPM_VID_INTEL
)
659 if (request_locality(chip
, 0) != 0)
662 rc
= tpm_tis_send_data(chip
, cmd_getticks
, len
);
668 priv
->flags
|= TPM_TIS_ITPM_WORKAROUND
;
670 rc
= tpm_tis_send_data(chip
, cmd_getticks
, len
);
672 dev_info(&chip
->dev
, "Detected an iTPM.\n");
674 priv
->flags
&= ~TPM_TIS_ITPM_WORKAROUND
;
680 release_locality(chip
, priv
->locality
);
685 static bool tpm_tis_req_canceled(struct tpm_chip
*chip
, u8 status
)
687 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
689 switch (priv
->manufacturer_id
) {
690 case TPM_VID_WINBOND
:
691 return ((status
== TPM_STS_VALID
) ||
692 (status
== (TPM_STS_VALID
| TPM_STS_COMMAND_READY
)));
694 return (status
== (TPM_STS_VALID
| TPM_STS_COMMAND_READY
));
696 return (status
== TPM_STS_COMMAND_READY
);
700 static irqreturn_t
tis_int_handler(int dummy
, void *dev_id
)
702 struct tpm_chip
*chip
= dev_id
;
703 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
707 rc
= tpm_tis_read32(priv
, TPM_INT_STATUS(priv
->locality
), &interrupt
);
714 priv
->irq_tested
= true;
715 if (interrupt
& TPM_INTF_DATA_AVAIL_INT
)
716 wake_up_interruptible(&priv
->read_queue
);
717 if (interrupt
& TPM_INTF_LOCALITY_CHANGE_INT
)
718 for (i
= 0; i
< 5; i
++)
719 if (check_locality(chip
, i
))
722 (TPM_INTF_LOCALITY_CHANGE_INT
| TPM_INTF_STS_VALID_INT
|
723 TPM_INTF_CMD_READY_INT
))
724 wake_up_interruptible(&priv
->int_queue
);
726 /* Clear interrupts handled with TPM_EOI */
727 rc
= tpm_tis_write32(priv
, TPM_INT_STATUS(priv
->locality
), interrupt
);
731 tpm_tis_read32(priv
, TPM_INT_STATUS(priv
->locality
), &interrupt
);
735 static int tpm_tis_gen_interrupt(struct tpm_chip
*chip
)
737 const char *desc
= "attempting to generate an interrupt";
741 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
742 return tpm2_get_tpm_pt(chip
, 0x100, &cap2
, desc
);
744 return tpm1_getcap(chip
, TPM_CAP_PROP_TIS_TIMEOUT
, &cap
, desc
,
748 /* Register the IRQ and issue a command that will cause an interrupt. If an
749 * irq is seen then leave the chip setup for IRQ operation, otherwise reverse
750 * everything and leave in polling mode. Returns 0 on success.
752 static int tpm_tis_probe_irq_single(struct tpm_chip
*chip
, u32 intmask
,
755 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
760 if (devm_request_irq(chip
->dev
.parent
, irq
, tis_int_handler
, flags
,
761 dev_name(&chip
->dev
), chip
) != 0) {
762 dev_info(&chip
->dev
, "Unable to request irq: %d for probe\n",
768 rc
= tpm_tis_read8(priv
, TPM_INT_VECTOR(priv
->locality
),
773 rc
= tpm_tis_write8(priv
, TPM_INT_VECTOR(priv
->locality
), irq
);
777 rc
= tpm_tis_read32(priv
, TPM_INT_STATUS(priv
->locality
), &int_status
);
781 /* Clear all existing */
782 rc
= tpm_tis_write32(priv
, TPM_INT_STATUS(priv
->locality
), int_status
);
787 rc
= tpm_tis_write32(priv
, TPM_INT_ENABLE(priv
->locality
),
788 intmask
| TPM_GLOBAL_INT_ENABLE
);
792 priv
->irq_tested
= false;
794 /* Generate an interrupt by having the core call through to
797 rc
= tpm_tis_gen_interrupt(chip
);
801 /* tpm_tis_send will either confirm the interrupt is working or it
802 * will call disable_irq which undoes all of the above.
804 if (!(chip
->flags
& TPM_CHIP_FLAG_IRQ
)) {
805 rc
= tpm_tis_write8(priv
, original_int_vec
,
806 TPM_INT_VECTOR(priv
->locality
));
816 /* Try to find the IRQ the TPM is using. This is for legacy x86 systems that
817 * do not have ACPI/etc. We typically expect the interrupt to be declared if
820 static void tpm_tis_probe_irq(struct tpm_chip
*chip
, u32 intmask
)
822 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
826 rc
= tpm_tis_read8(priv
, TPM_INT_VECTOR(priv
->locality
),
831 if (!original_int_vec
) {
832 if (IS_ENABLED(CONFIG_X86
))
833 for (i
= 3; i
<= 15; i
++)
834 if (!tpm_tis_probe_irq_single(chip
, intmask
, 0,
837 } else if (!tpm_tis_probe_irq_single(chip
, intmask
, 0,
842 void tpm_tis_remove(struct tpm_chip
*chip
)
844 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
845 u32 reg
= TPM_INT_ENABLE(priv
->locality
);
849 tpm_tis_clkrun_enable(chip
, true);
851 rc
= tpm_tis_read32(priv
, reg
, &interrupt
);
855 tpm_tis_write32(priv
, reg
, ~TPM_GLOBAL_INT_ENABLE
& interrupt
);
857 tpm_tis_clkrun_enable(chip
, false);
859 if (priv
->ilb_base_addr
)
860 iounmap(priv
->ilb_base_addr
);
862 EXPORT_SYMBOL_GPL(tpm_tis_remove
);
865 * tpm_tis_clkrun_enable() - Keep clkrun protocol disabled for entire duration
866 * of a single TPM command
867 * @chip: TPM chip to use
868 * @value: 1 - Disable CLKRUN protocol, so that clocks are free running
869 * 0 - Enable CLKRUN protocol
870 * Call this function directly in tpm_tis_remove() in error or driver removal
871 * path, since the chip->ops is set to NULL in tpm_chip_unregister().
873 static void tpm_tis_clkrun_enable(struct tpm_chip
*chip
, bool value
)
875 struct tpm_tis_data
*data
= dev_get_drvdata(&chip
->dev
);
878 if (!IS_ENABLED(CONFIG_X86
) || !is_bsw() ||
879 !data
->ilb_base_addr
)
883 data
->clkrun_enabled
++;
884 if (data
->clkrun_enabled
> 1)
886 clkrun_val
= ioread32(data
->ilb_base_addr
+ LPC_CNTRL_OFFSET
);
888 /* Disable LPC CLKRUN# */
889 clkrun_val
&= ~LPC_CLKRUN_EN
;
890 iowrite32(clkrun_val
, data
->ilb_base_addr
+ LPC_CNTRL_OFFSET
);
893 * Write any random value on port 0x80 which is on LPC, to make
894 * sure LPC clock is running before sending any TPM command.
898 data
->clkrun_enabled
--;
899 if (data
->clkrun_enabled
)
902 clkrun_val
= ioread32(data
->ilb_base_addr
+ LPC_CNTRL_OFFSET
);
904 /* Enable LPC CLKRUN# */
905 clkrun_val
|= LPC_CLKRUN_EN
;
906 iowrite32(clkrun_val
, data
->ilb_base_addr
+ LPC_CNTRL_OFFSET
);
909 * Write any random value on port 0x80 which is on LPC, to make
910 * sure LPC clock is running before sending any TPM command.
916 static const struct tpm_class_ops tpm_tis
= {
917 .flags
= TPM_OPS_AUTO_STARTUP
,
918 .status
= tpm_tis_status
,
919 .recv
= tpm_tis_recv
,
920 .send
= tpm_tis_send
,
921 .cancel
= tpm_tis_ready
,
922 .update_timeouts
= tpm_tis_update_timeouts
,
923 .update_durations
= tpm_tis_update_durations
,
924 .req_complete_mask
= TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
925 .req_complete_val
= TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
926 .req_canceled
= tpm_tis_req_canceled
,
927 .request_locality
= request_locality
,
928 .relinquish_locality
= release_locality
,
929 .clk_enable
= tpm_tis_clkrun_enable
,
932 int tpm_tis_core_init(struct device
*dev
, struct tpm_tis_data
*priv
, int irq
,
933 const struct tpm_tis_phy_ops
*phy_ops
,
934 acpi_handle acpi_dev_handle
)
942 struct tpm_chip
*chip
;
944 chip
= tpmm_chip_alloc(dev
, &tpm_tis
);
946 return PTR_ERR(chip
);
949 chip
->acpi_dev_handle
= acpi_dev_handle
;
952 chip
->hwrng
.quality
= priv
->rng_quality
;
954 /* Maximum timeouts */
955 chip
->timeout_a
= msecs_to_jiffies(TIS_TIMEOUT_A_MAX
);
956 chip
->timeout_b
= msecs_to_jiffies(TIS_TIMEOUT_B_MAX
);
957 chip
->timeout_c
= msecs_to_jiffies(TIS_TIMEOUT_C_MAX
);
958 chip
->timeout_d
= msecs_to_jiffies(TIS_TIMEOUT_D_MAX
);
959 priv
->phy_ops
= phy_ops
;
960 dev_set_drvdata(&chip
->dev
, priv
);
963 priv
->ilb_base_addr
= ioremap(INTEL_LEGACY_BLK_BASE_ADDR
,
965 if (!priv
->ilb_base_addr
)
968 clkrun_val
= ioread32(priv
->ilb_base_addr
+ LPC_CNTRL_OFFSET
);
969 /* Check if CLKRUN# is already not enabled in the LPC bus */
970 if (!(clkrun_val
& LPC_CLKRUN_EN
)) {
971 iounmap(priv
->ilb_base_addr
);
972 priv
->ilb_base_addr
= NULL
;
976 if (chip
->ops
->clk_enable
!= NULL
)
977 chip
->ops
->clk_enable(chip
, true);
979 if (wait_startup(chip
, 0) != 0) {
984 /* Take control of the TPM's interrupt hardware and shut it off */
985 rc
= tpm_tis_read32(priv
, TPM_INT_ENABLE(priv
->locality
), &intmask
);
989 intmask
|= TPM_INTF_CMD_READY_INT
| TPM_INTF_LOCALITY_CHANGE_INT
|
990 TPM_INTF_DATA_AVAIL_INT
| TPM_INTF_STS_VALID_INT
;
991 intmask
&= ~TPM_GLOBAL_INT_ENABLE
;
992 tpm_tis_write32(priv
, TPM_INT_ENABLE(priv
->locality
), intmask
);
994 rc
= tpm_chip_start(chip
);
997 rc
= tpm2_probe(chip
);
1002 rc
= tpm_tis_read32(priv
, TPM_DID_VID(0), &vendor
);
1006 priv
->manufacturer_id
= vendor
;
1008 rc
= tpm_tis_read8(priv
, TPM_RID(0), &rid
);
1012 dev_info(dev
, "%s TPM (device-id 0x%X, rev-id %d)\n",
1013 (chip
->flags
& TPM_CHIP_FLAG_TPM2
) ? "2.0" : "1.2",
1016 probe
= probe_itpm(chip
);
1022 /* Figure out the capabilities */
1023 rc
= tpm_tis_read32(priv
, TPM_INTF_CAPS(priv
->locality
), &intfcaps
);
1027 dev_dbg(dev
, "TPM interface capabilities (0x%x):\n",
1029 if (intfcaps
& TPM_INTF_BURST_COUNT_STATIC
)
1030 dev_dbg(dev
, "\tBurst Count Static\n");
1031 if (intfcaps
& TPM_INTF_CMD_READY_INT
)
1032 dev_dbg(dev
, "\tCommand Ready Int Support\n");
1033 if (intfcaps
& TPM_INTF_INT_EDGE_FALLING
)
1034 dev_dbg(dev
, "\tInterrupt Edge Falling\n");
1035 if (intfcaps
& TPM_INTF_INT_EDGE_RISING
)
1036 dev_dbg(dev
, "\tInterrupt Edge Rising\n");
1037 if (intfcaps
& TPM_INTF_INT_LEVEL_LOW
)
1038 dev_dbg(dev
, "\tInterrupt Level Low\n");
1039 if (intfcaps
& TPM_INTF_INT_LEVEL_HIGH
)
1040 dev_dbg(dev
, "\tInterrupt Level High\n");
1041 if (intfcaps
& TPM_INTF_LOCALITY_CHANGE_INT
)
1042 dev_dbg(dev
, "\tLocality Change Int Support\n");
1043 if (intfcaps
& TPM_INTF_STS_VALID_INT
)
1044 dev_dbg(dev
, "\tSts Valid Int Support\n");
1045 if (intfcaps
& TPM_INTF_DATA_AVAIL_INT
)
1046 dev_dbg(dev
, "\tData Avail Int Support\n");
1048 /* INTERRUPT Setup */
1049 init_waitqueue_head(&priv
->read_queue
);
1050 init_waitqueue_head(&priv
->int_queue
);
1052 /* Before doing irq testing issue a command to the TPM in polling mode
1053 * to make sure it works. May as well use that command to set the
1054 * proper timeouts for the driver.
1056 if (tpm_get_timeouts(chip
)) {
1057 dev_err(dev
, "Could not get TPM timeouts and durations\n");
1063 tpm_tis_probe_irq_single(chip
, intmask
, IRQF_SHARED
,
1065 if (!(chip
->flags
& TPM_CHIP_FLAG_IRQ
))
1066 dev_err(&chip
->dev
, FW_BUG
1067 "TPM interrupt not working, polling instead\n");
1069 tpm_tis_probe_irq(chip
, intmask
);
1073 rc
= tpm_chip_register(chip
);
1077 if (chip
->ops
->clk_enable
!= NULL
)
1078 chip
->ops
->clk_enable(chip
, false);
1082 if ((chip
->ops
!= NULL
) && (chip
->ops
->clk_enable
!= NULL
))
1083 chip
->ops
->clk_enable(chip
, false);
1085 tpm_tis_remove(chip
);
1089 EXPORT_SYMBOL_GPL(tpm_tis_core_init
);
1091 #ifdef CONFIG_PM_SLEEP
1092 static void tpm_tis_reenable_interrupts(struct tpm_chip
*chip
)
1094 struct tpm_tis_data
*priv
= dev_get_drvdata(&chip
->dev
);
1098 if (chip
->ops
->clk_enable
!= NULL
)
1099 chip
->ops
->clk_enable(chip
, true);
1101 /* reenable interrupts that device may have lost or
1102 * BIOS/firmware may have disabled
1104 rc
= tpm_tis_write8(priv
, TPM_INT_VECTOR(priv
->locality
), priv
->irq
);
1108 rc
= tpm_tis_read32(priv
, TPM_INT_ENABLE(priv
->locality
), &intmask
);
1112 intmask
|= TPM_INTF_CMD_READY_INT
1113 | TPM_INTF_LOCALITY_CHANGE_INT
| TPM_INTF_DATA_AVAIL_INT
1114 | TPM_INTF_STS_VALID_INT
| TPM_GLOBAL_INT_ENABLE
;
1116 tpm_tis_write32(priv
, TPM_INT_ENABLE(priv
->locality
), intmask
);
1119 if (chip
->ops
->clk_enable
!= NULL
)
1120 chip
->ops
->clk_enable(chip
, false);
1125 int tpm_tis_resume(struct device
*dev
)
1127 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
1130 if (chip
->flags
& TPM_CHIP_FLAG_IRQ
)
1131 tpm_tis_reenable_interrupts(chip
);
1133 ret
= tpm_pm_resume(dev
);
1137 /* TPM 1.2 requires self-test on resume. This function actually returns
1138 * an error code but for unknown reason it isn't handled.
1140 if (!(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
1141 tpm1_do_selftest(chip
);
1145 EXPORT_SYMBOL_GPL(tpm_tis_resume
);
1148 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1149 MODULE_DESCRIPTION("TPM Driver");
1150 MODULE_VERSION("2.0");
1151 MODULE_LICENSE("GPL");