2 * Copyright (C) 2005, 2006 IBM Corporation
3 * Copyright (C) 2014, 2015 Intel Corporation
6 * Leendert van Doorn <leendert@watson.ibm.com>
7 * Kylene Hall <kjhall@us.ibm.com>
9 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
11 * Device driver for TCG/TCPA TPM (trusted platform module).
12 * Specifications at www.trustedcomputinggroup.org
14 * This device driver implements the TPM interface as defined in
15 * the TCG TPM Interface Spec version 1.2, revision 1.0.
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License as
19 * published by the Free Software Foundation, version 2 of the
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/pnp.h>
26 #include <linux/slab.h>
27 #include <linux/interrupt.h>
28 #include <linux/wait.h>
29 #include <linux/acpi.h>
30 #include <linux/freezer.h>
34 TPM_ACCESS_VALID
= 0x80,
35 TPM_ACCESS_ACTIVE_LOCALITY
= 0x20,
36 TPM_ACCESS_REQUEST_PENDING
= 0x04,
37 TPM_ACCESS_REQUEST_USE
= 0x02,
42 TPM_STS_COMMAND_READY
= 0x40,
44 TPM_STS_DATA_AVAIL
= 0x10,
45 TPM_STS_DATA_EXPECT
= 0x08,
49 TPM_GLOBAL_INT_ENABLE
= 0x80000000,
50 TPM_INTF_BURST_COUNT_STATIC
= 0x100,
51 TPM_INTF_CMD_READY_INT
= 0x080,
52 TPM_INTF_INT_EDGE_FALLING
= 0x040,
53 TPM_INTF_INT_EDGE_RISING
= 0x020,
54 TPM_INTF_INT_LEVEL_LOW
= 0x010,
55 TPM_INTF_INT_LEVEL_HIGH
= 0x008,
56 TPM_INTF_LOCALITY_CHANGE_INT
= 0x004,
57 TPM_INTF_STS_VALID_INT
= 0x002,
58 TPM_INTF_DATA_AVAIL_INT
= 0x001,
63 TIS_SHORT_TIMEOUT
= 750, /* ms */
64 TIS_LONG_TIMEOUT
= 2000, /* 2 sec */
69 /* irq > 0 means: use irq $irq;
70 * irq = 0 means: autoprobe for an irq;
71 * irq = -1 means: no irq support
76 /* Some timeout values are needed before it is known whether the chip is
79 #define TIS_TIMEOUT_A_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_A)
80 #define TIS_TIMEOUT_B_MAX max(TIS_LONG_TIMEOUT, TPM2_TIMEOUT_B)
81 #define TIS_TIMEOUT_C_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_C)
82 #define TIS_TIMEOUT_D_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_D)
84 #define TPM_ACCESS(l) (0x0000 | ((l) << 12))
85 #define TPM_INT_ENABLE(l) (0x0008 | ((l) << 12))
86 #define TPM_INT_VECTOR(l) (0x000C | ((l) << 12))
87 #define TPM_INT_STATUS(l) (0x0010 | ((l) << 12))
88 #define TPM_INTF_CAPS(l) (0x0014 | ((l) << 12))
89 #define TPM_STS(l) (0x0018 | ((l) << 12))
90 #define TPM_STS3(l) (0x001b | ((l) << 12))
91 #define TPM_DATA_FIFO(l) (0x0024 | ((l) << 12))
93 #define TPM_DID_VID(l) (0x0F00 | ((l) << 12))
94 #define TPM_RID(l) (0x0F04 | ((l) << 12))
100 wait_queue_head_t int_queue
;
103 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
104 static int has_hid(struct acpi_device
*dev
, const char *hid
)
106 struct acpi_hardware_id
*id
;
108 list_for_each_entry(id
, &dev
->pnp
.ids
, list
)
109 if (!strcmp(hid
, id
->id
))
115 static inline int is_itpm(struct acpi_device
*dev
)
117 return has_hid(dev
, "INTC0102");
120 static inline int is_itpm(struct acpi_device
*dev
)
126 /* Before we attempt to access the TPM we must see that the valid bit is set.
127 * The specification says that this bit is 0 at reset and remains 0 until the
128 * 'TPM has gone through its self test and initialization and has established
129 * correct values in the other bits.' */
130 static int wait_startup(struct tpm_chip
*chip
, int l
)
132 struct priv_data
*priv
= chip
->vendor
.priv
;
133 unsigned long stop
= jiffies
+ chip
->vendor
.timeout_a
;
135 if (ioread8(priv
->iobase
+ TPM_ACCESS(l
)) &
139 } while (time_before(jiffies
, stop
));
143 static int check_locality(struct tpm_chip
*chip
, int l
)
145 struct priv_data
*priv
= chip
->vendor
.priv
;
147 if ((ioread8(priv
->iobase
+ TPM_ACCESS(l
)) &
148 (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
)) ==
149 (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
))
150 return chip
->vendor
.locality
= l
;
155 static void release_locality(struct tpm_chip
*chip
, int l
, int force
)
157 struct priv_data
*priv
= chip
->vendor
.priv
;
159 if (force
|| (ioread8(priv
->iobase
+ TPM_ACCESS(l
)) &
160 (TPM_ACCESS_REQUEST_PENDING
| TPM_ACCESS_VALID
)) ==
161 (TPM_ACCESS_REQUEST_PENDING
| TPM_ACCESS_VALID
))
162 iowrite8(TPM_ACCESS_ACTIVE_LOCALITY
,
163 priv
->iobase
+ TPM_ACCESS(l
));
166 static int request_locality(struct tpm_chip
*chip
, int l
)
168 struct priv_data
*priv
= chip
->vendor
.priv
;
169 unsigned long stop
, timeout
;
172 if (check_locality(chip
, l
) >= 0)
175 iowrite8(TPM_ACCESS_REQUEST_USE
,
176 priv
->iobase
+ TPM_ACCESS(l
));
178 stop
= jiffies
+ chip
->vendor
.timeout_a
;
180 if (chip
->vendor
.irq
) {
182 timeout
= stop
- jiffies
;
183 if ((long)timeout
<= 0)
185 rc
= wait_event_interruptible_timeout(priv
->int_queue
,
191 if (rc
== -ERESTARTSYS
&& freezing(current
)) {
192 clear_thread_flag(TIF_SIGPENDING
);
196 /* wait for burstcount */
198 if (check_locality(chip
, l
) >= 0)
202 while (time_before(jiffies
, stop
));
207 static u8
tpm_tis_status(struct tpm_chip
*chip
)
209 struct priv_data
*priv
= chip
->vendor
.priv
;
211 return ioread8(priv
->iobase
+
212 TPM_STS(chip
->vendor
.locality
));
215 static void tpm_tis_ready(struct tpm_chip
*chip
)
217 struct priv_data
*priv
= chip
->vendor
.priv
;
219 /* this causes the current command to be aborted */
220 iowrite8(TPM_STS_COMMAND_READY
,
221 priv
->iobase
+ TPM_STS(chip
->vendor
.locality
));
224 static int get_burstcount(struct tpm_chip
*chip
)
226 struct priv_data
*priv
= chip
->vendor
.priv
;
230 /* wait for burstcount */
231 /* which timeout value, spec has 2 answers (c & d) */
232 stop
= jiffies
+ chip
->vendor
.timeout_d
;
234 burstcnt
= ioread8(priv
->iobase
+
235 TPM_STS(chip
->vendor
.locality
) + 1);
236 burstcnt
+= ioread8(priv
->iobase
+
237 TPM_STS(chip
->vendor
.locality
) +
242 } while (time_before(jiffies
, stop
));
246 static int recv_data(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
248 struct priv_data
*priv
= chip
->vendor
.priv
;
249 int size
= 0, burstcnt
;
250 while (size
< count
&&
251 wait_for_tpm_stat(chip
,
252 TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
253 chip
->vendor
.timeout_c
,
254 &chip
->vendor
.read_queue
, true)
256 burstcnt
= get_burstcount(chip
);
257 for (; burstcnt
> 0 && size
< count
; burstcnt
--)
258 buf
[size
++] = ioread8(priv
->iobase
+
259 TPM_DATA_FIFO(chip
->vendor
.
265 static int tpm_tis_recv(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
267 struct priv_data
*priv
= chip
->vendor
.priv
;
269 int expected
, status
;
271 if (count
< TPM_HEADER_SIZE
) {
276 /* read first 10 bytes, including tag, paramsize, and result */
278 recv_data(chip
, buf
, TPM_HEADER_SIZE
)) < TPM_HEADER_SIZE
) {
279 dev_err(&chip
->dev
, "Unable to read header\n");
283 expected
= be32_to_cpu(*(__be32
*) (buf
+ 2));
284 if (expected
> count
) {
290 recv_data(chip
, &buf
[TPM_HEADER_SIZE
],
291 expected
- TPM_HEADER_SIZE
)) < expected
) {
292 dev_err(&chip
->dev
, "Unable to read remainder of result\n");
297 wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->vendor
.timeout_c
,
298 &priv
->int_queue
, false);
299 status
= tpm_tis_status(chip
);
300 if (status
& TPM_STS_DATA_AVAIL
) { /* retry? */
301 dev_err(&chip
->dev
, "Error left over data\n");
308 release_locality(chip
, chip
->vendor
.locality
, 0);
313 module_param(itpm
, bool, 0444);
314 MODULE_PARM_DESC(itpm
, "Force iTPM workarounds (found on some Lenovo laptops)");
317 * If interrupts are used (signaled by an irq set in the vendor structure)
318 * tpm.c can skip polling for the data to be available as the interrupt is
321 static int tpm_tis_send_data(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
323 struct priv_data
*priv
= chip
->vendor
.priv
;
324 int rc
, status
, burstcnt
;
327 if (request_locality(chip
, 0) < 0)
330 status
= tpm_tis_status(chip
);
331 if ((status
& TPM_STS_COMMAND_READY
) == 0) {
333 if (wait_for_tpm_stat
334 (chip
, TPM_STS_COMMAND_READY
, chip
->vendor
.timeout_b
,
335 &priv
->int_queue
, false) < 0) {
341 while (count
< len
- 1) {
342 burstcnt
= get_burstcount(chip
);
343 for (; burstcnt
> 0 && count
< len
- 1; burstcnt
--) {
344 iowrite8(buf
[count
], priv
->iobase
+
345 TPM_DATA_FIFO(chip
->vendor
.locality
));
349 wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->vendor
.timeout_c
,
350 &priv
->int_queue
, false);
351 status
= tpm_tis_status(chip
);
352 if (!itpm
&& (status
& TPM_STS_DATA_EXPECT
) == 0) {
358 /* write last byte */
360 priv
->iobase
+ TPM_DATA_FIFO(chip
->vendor
.locality
));
361 wait_for_tpm_stat(chip
, TPM_STS_VALID
, chip
->vendor
.timeout_c
,
362 &priv
->int_queue
, false);
363 status
= tpm_tis_status(chip
);
364 if ((status
& TPM_STS_DATA_EXPECT
) != 0) {
373 release_locality(chip
, chip
->vendor
.locality
, 0);
377 static void disable_interrupts(struct tpm_chip
*chip
)
379 struct priv_data
*priv
= chip
->vendor
.priv
;
383 ioread32(priv
->iobase
+
384 TPM_INT_ENABLE(chip
->vendor
.locality
));
385 intmask
&= ~TPM_GLOBAL_INT_ENABLE
;
387 priv
->iobase
+ TPM_INT_ENABLE(chip
->vendor
.locality
));
388 devm_free_irq(&chip
->dev
, chip
->vendor
.irq
, chip
);
389 chip
->vendor
.irq
= 0;
393 * If interrupts are used (signaled by an irq set in the vendor structure)
394 * tpm.c can skip polling for the data to be available as the interrupt is
397 static int tpm_tis_send_main(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
399 struct priv_data
*priv
= chip
->vendor
.priv
;
404 rc
= tpm_tis_send_data(chip
, buf
, len
);
410 priv
->iobase
+ TPM_STS(chip
->vendor
.locality
));
412 if (chip
->vendor
.irq
) {
413 ordinal
= be32_to_cpu(*((__be32
*) (buf
+ 6)));
415 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
416 dur
= tpm2_calc_ordinal_duration(chip
, ordinal
);
418 dur
= tpm_calc_ordinal_duration(chip
, ordinal
);
420 if (wait_for_tpm_stat
421 (chip
, TPM_STS_DATA_AVAIL
| TPM_STS_VALID
, dur
,
422 &chip
->vendor
.read_queue
, false) < 0) {
430 release_locality(chip
, chip
->vendor
.locality
, 0);
434 static int tpm_tis_send(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
437 struct priv_data
*priv
= chip
->vendor
.priv
;
439 if (!chip
->vendor
.irq
|| priv
->irq_tested
)
440 return tpm_tis_send_main(chip
, buf
, len
);
442 /* Verify receipt of the expected IRQ */
443 irq
= chip
->vendor
.irq
;
444 chip
->vendor
.irq
= 0;
445 rc
= tpm_tis_send_main(chip
, buf
, len
);
446 chip
->vendor
.irq
= irq
;
447 if (!priv
->irq_tested
)
449 if (!priv
->irq_tested
)
450 disable_interrupts(chip
);
451 priv
->irq_tested
= true;
455 struct tis_vendor_timeout_override
{
457 unsigned long timeout_us
[4];
460 static const struct tis_vendor_timeout_override vendor_timeout_overrides
[] = {
462 { 0x32041114, { (TIS_SHORT_TIMEOUT
*1000), (TIS_LONG_TIMEOUT
*1000),
463 (TIS_SHORT_TIMEOUT
*1000), (TIS_SHORT_TIMEOUT
*1000) } },
466 static bool tpm_tis_update_timeouts(struct tpm_chip
*chip
,
467 unsigned long *timeout_cap
)
469 struct priv_data
*priv
= chip
->vendor
.priv
;
473 did_vid
= ioread32(priv
->iobase
+ TPM_DID_VID(0));
475 for (i
= 0; i
!= ARRAY_SIZE(vendor_timeout_overrides
); i
++) {
476 if (vendor_timeout_overrides
[i
].did_vid
!= did_vid
)
478 memcpy(timeout_cap
, vendor_timeout_overrides
[i
].timeout_us
,
479 sizeof(vendor_timeout_overrides
[i
].timeout_us
));
487 * Early probing for iTPM with STS_DATA_EXPECT flaw.
488 * Try sending command without itpm flag set and if that
489 * fails, repeat with itpm flag set.
491 static int probe_itpm(struct tpm_chip
*chip
)
493 struct priv_data
*priv
= chip
->vendor
.priv
;
495 u8 cmd_getticks
[] = {
496 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
497 0x00, 0x00, 0x00, 0xf1
499 size_t len
= sizeof(cmd_getticks
);
500 bool rem_itpm
= itpm
;
501 u16 vendor
= ioread16(priv
->iobase
+ TPM_DID_VID(0));
503 /* probe only iTPMS */
504 if (vendor
!= TPM_VID_INTEL
)
509 rc
= tpm_tis_send_data(chip
, cmd_getticks
, len
);
514 release_locality(chip
, chip
->vendor
.locality
, 0);
518 rc
= tpm_tis_send_data(chip
, cmd_getticks
, len
);
520 dev_info(&chip
->dev
, "Detected an iTPM.\n");
528 release_locality(chip
, chip
->vendor
.locality
, 0);
533 static bool tpm_tis_req_canceled(struct tpm_chip
*chip
, u8 status
)
535 struct priv_data
*priv
= chip
->vendor
.priv
;
537 switch (priv
->manufacturer_id
) {
538 case TPM_VID_WINBOND
:
539 return ((status
== TPM_STS_VALID
) ||
540 (status
== (TPM_STS_VALID
| TPM_STS_COMMAND_READY
)));
542 return (status
== (TPM_STS_VALID
| TPM_STS_COMMAND_READY
));
544 return (status
== TPM_STS_COMMAND_READY
);
548 static const struct tpm_class_ops tpm_tis
= {
549 .status
= tpm_tis_status
,
550 .recv
= tpm_tis_recv
,
551 .send
= tpm_tis_send
,
552 .cancel
= tpm_tis_ready
,
553 .update_timeouts
= tpm_tis_update_timeouts
,
554 .req_complete_mask
= TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
555 .req_complete_val
= TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
556 .req_canceled
= tpm_tis_req_canceled
,
559 static irqreturn_t
tis_int_handler(int dummy
, void *dev_id
)
561 struct tpm_chip
*chip
= dev_id
;
562 struct priv_data
*priv
= chip
->vendor
.priv
;
566 interrupt
= ioread32(priv
->iobase
+
567 TPM_INT_STATUS(chip
->vendor
.locality
));
572 ((struct priv_data
*)chip
->vendor
.priv
)->irq_tested
= true;
573 if (interrupt
& TPM_INTF_DATA_AVAIL_INT
)
574 wake_up_interruptible(&chip
->vendor
.read_queue
);
575 if (interrupt
& TPM_INTF_LOCALITY_CHANGE_INT
)
576 for (i
= 0; i
< 5; i
++)
577 if (check_locality(chip
, i
) >= 0)
580 (TPM_INTF_LOCALITY_CHANGE_INT
| TPM_INTF_STS_VALID_INT
|
581 TPM_INTF_CMD_READY_INT
))
582 wake_up_interruptible(&priv
->int_queue
);
584 /* Clear interrupts handled with TPM_EOI */
587 TPM_INT_STATUS(chip
->vendor
.locality
));
588 ioread32(priv
->iobase
+ TPM_INT_STATUS(chip
->vendor
.locality
));
592 /* Register the IRQ and issue a command that will cause an interrupt. If an
593 * irq is seen then leave the chip setup for IRQ operation, otherwise reverse
594 * everything and leave in polling mode. Returns 0 on success.
596 static int tpm_tis_probe_irq_single(struct tpm_chip
*chip
, u32 intmask
,
599 struct priv_data
*priv
= chip
->vendor
.priv
;
602 if (devm_request_irq(&chip
->dev
, irq
, tis_int_handler
, flags
,
603 dev_name(&chip
->dev
), chip
) != 0) {
604 dev_info(&chip
->dev
, "Unable to request irq: %d for probe\n",
608 chip
->vendor
.irq
= irq
;
610 original_int_vec
= ioread8(priv
->iobase
+
611 TPM_INT_VECTOR(chip
->vendor
.locality
));
613 priv
->iobase
+ TPM_INT_VECTOR(chip
->vendor
.locality
));
615 /* Clear all existing */
616 iowrite32(ioread32(priv
->iobase
+
617 TPM_INT_STATUS(chip
->vendor
.locality
)),
618 priv
->iobase
+ TPM_INT_STATUS(chip
->vendor
.locality
));
621 iowrite32(intmask
| TPM_GLOBAL_INT_ENABLE
,
622 priv
->iobase
+ TPM_INT_ENABLE(chip
->vendor
.locality
));
624 priv
->irq_tested
= false;
626 /* Generate an interrupt by having the core call through to
629 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
630 tpm2_gen_interrupt(chip
);
632 tpm_gen_interrupt(chip
);
634 /* tpm_tis_send will either confirm the interrupt is working or it
635 * will call disable_irq which undoes all of the above.
637 if (!chip
->vendor
.irq
) {
638 iowrite8(original_int_vec
,
639 priv
->iobase
+ TPM_INT_VECTOR(chip
->vendor
.locality
));
646 /* Try to find the IRQ the TPM is using. This is for legacy x86 systems that
647 * do not have ACPI/etc. We typically expect the interrupt to be declared if
650 static void tpm_tis_probe_irq(struct tpm_chip
*chip
, u32 intmask
)
652 struct priv_data
*priv
= chip
->vendor
.priv
;
656 original_int_vec
= ioread8(priv
->iobase
+
657 TPM_INT_VECTOR(chip
->vendor
.locality
));
659 if (!original_int_vec
) {
660 if (IS_ENABLED(CONFIG_X86
))
661 for (i
= 3; i
<= 15; i
++)
662 if (!tpm_tis_probe_irq_single(chip
, intmask
, 0,
665 } else if (!tpm_tis_probe_irq_single(chip
, intmask
, 0,
670 static bool interrupts
= true;
671 module_param(interrupts
, bool, 0444);
672 MODULE_PARM_DESC(interrupts
, "Enable interrupts");
674 static void tpm_tis_remove(struct tpm_chip
*chip
)
676 struct priv_data
*priv
= chip
->vendor
.priv
;
677 void __iomem
*reg
= priv
->iobase
+
678 TPM_INT_ENABLE(chip
->vendor
.locality
);
680 iowrite32(~TPM_GLOBAL_INT_ENABLE
& ioread32(reg
), reg
);
681 release_locality(chip
, chip
->vendor
.locality
, 1);
684 static int tpm_tis_init(struct device
*dev
, struct tpm_info
*tpm_info
,
685 acpi_handle acpi_dev_handle
)
687 u32 vendor
, intfcaps
, intmask
;
689 struct tpm_chip
*chip
;
690 struct priv_data
*priv
;
692 priv
= devm_kzalloc(dev
, sizeof(struct priv_data
), GFP_KERNEL
);
696 chip
= tpmm_chip_alloc(dev
, &tpm_tis
);
698 return PTR_ERR(chip
);
700 chip
->vendor
.priv
= priv
;
702 chip
->acpi_dev_handle
= acpi_dev_handle
;
705 priv
->iobase
= devm_ioremap_resource(dev
, &tpm_info
->res
);
706 if (IS_ERR(priv
->iobase
))
707 return PTR_ERR(priv
->iobase
);
709 /* Maximum timeouts */
710 chip
->vendor
.timeout_a
= TIS_TIMEOUT_A_MAX
;
711 chip
->vendor
.timeout_b
= TIS_TIMEOUT_B_MAX
;
712 chip
->vendor
.timeout_c
= TIS_TIMEOUT_C_MAX
;
713 chip
->vendor
.timeout_d
= TIS_TIMEOUT_D_MAX
;
715 if (wait_startup(chip
, 0) != 0) {
720 /* Take control of the TPM's interrupt hardware and shut it off */
721 intmask
= ioread32(priv
->iobase
+
722 TPM_INT_ENABLE(chip
->vendor
.locality
));
723 intmask
|= TPM_INTF_CMD_READY_INT
| TPM_INTF_LOCALITY_CHANGE_INT
|
724 TPM_INTF_DATA_AVAIL_INT
| TPM_INTF_STS_VALID_INT
;
725 intmask
&= ~TPM_GLOBAL_INT_ENABLE
;
727 priv
->iobase
+ TPM_INT_ENABLE(chip
->vendor
.locality
));
729 if (request_locality(chip
, 0) != 0) {
734 rc
= tpm2_probe(chip
);
738 vendor
= ioread32(priv
->iobase
+ TPM_DID_VID(0));
739 priv
->manufacturer_id
= vendor
;
741 dev_info(dev
, "%s TPM (device-id 0x%X, rev-id %d)\n",
742 (chip
->flags
& TPM_CHIP_FLAG_TPM2
) ? "2.0" : "1.2",
743 vendor
>> 16, ioread8(priv
->iobase
+ TPM_RID(0)));
746 probe
= probe_itpm(chip
);
755 dev_info(dev
, "Intel iTPM workaround enabled\n");
758 /* Figure out the capabilities */
760 ioread32(priv
->iobase
+
761 TPM_INTF_CAPS(chip
->vendor
.locality
));
762 dev_dbg(dev
, "TPM interface capabilities (0x%x):\n",
764 if (intfcaps
& TPM_INTF_BURST_COUNT_STATIC
)
765 dev_dbg(dev
, "\tBurst Count Static\n");
766 if (intfcaps
& TPM_INTF_CMD_READY_INT
)
767 dev_dbg(dev
, "\tCommand Ready Int Support\n");
768 if (intfcaps
& TPM_INTF_INT_EDGE_FALLING
)
769 dev_dbg(dev
, "\tInterrupt Edge Falling\n");
770 if (intfcaps
& TPM_INTF_INT_EDGE_RISING
)
771 dev_dbg(dev
, "\tInterrupt Edge Rising\n");
772 if (intfcaps
& TPM_INTF_INT_LEVEL_LOW
)
773 dev_dbg(dev
, "\tInterrupt Level Low\n");
774 if (intfcaps
& TPM_INTF_INT_LEVEL_HIGH
)
775 dev_dbg(dev
, "\tInterrupt Level High\n");
776 if (intfcaps
& TPM_INTF_LOCALITY_CHANGE_INT
)
777 dev_dbg(dev
, "\tLocality Change Int Support\n");
778 if (intfcaps
& TPM_INTF_STS_VALID_INT
)
779 dev_dbg(dev
, "\tSts Valid Int Support\n");
780 if (intfcaps
& TPM_INTF_DATA_AVAIL_INT
)
781 dev_dbg(dev
, "\tData Avail Int Support\n");
783 /* Very early on issue a command to the TPM in polling mode to make
784 * sure it works. May as well use that command to set the proper
785 * timeouts for the driver.
787 if (tpm_get_timeouts(chip
)) {
788 dev_err(dev
, "Could not get TPM timeouts and durations\n");
793 /* INTERRUPT Setup */
794 init_waitqueue_head(&chip
->vendor
.read_queue
);
795 init_waitqueue_head(&priv
->int_queue
);
796 if (interrupts
&& tpm_info
->irq
!= -1) {
798 tpm_tis_probe_irq_single(chip
, intmask
, IRQF_SHARED
,
800 if (!chip
->vendor
.irq
)
801 dev_err(&chip
->dev
, FW_BUG
802 "TPM interrupt not working, polling instead\n");
804 tpm_tis_probe_irq(chip
, intmask
);
807 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
) {
808 rc
= tpm2_do_selftest(chip
);
809 if (rc
== TPM2_RC_INITIALIZE
) {
810 dev_warn(dev
, "Firmware has not started TPM\n");
811 rc
= tpm2_startup(chip
, TPM2_SU_CLEAR
);
813 rc
= tpm2_do_selftest(chip
);
817 dev_err(dev
, "TPM self test failed\n");
823 if (tpm_do_selftest(chip
)) {
824 dev_err(dev
, "TPM self test failed\n");
830 return tpm_chip_register(chip
);
832 tpm_tis_remove(chip
);
836 #ifdef CONFIG_PM_SLEEP
837 static void tpm_tis_reenable_interrupts(struct tpm_chip
*chip
)
839 struct priv_data
*priv
= chip
->vendor
.priv
;
842 /* reenable interrupts that device may have lost or
843 BIOS/firmware may have disabled */
844 iowrite8(chip
->vendor
.irq
, priv
->iobase
+
845 TPM_INT_VECTOR(chip
->vendor
.locality
));
848 ioread32(priv
->iobase
+ TPM_INT_ENABLE(chip
->vendor
.locality
));
850 intmask
|= TPM_INTF_CMD_READY_INT
851 | TPM_INTF_LOCALITY_CHANGE_INT
| TPM_INTF_DATA_AVAIL_INT
852 | TPM_INTF_STS_VALID_INT
| TPM_GLOBAL_INT_ENABLE
;
855 priv
->iobase
+ TPM_INT_ENABLE(chip
->vendor
.locality
));
858 static int tpm_tis_resume(struct device
*dev
)
860 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
863 if (chip
->vendor
.irq
)
864 tpm_tis_reenable_interrupts(chip
);
866 ret
= tpm_pm_resume(dev
);
870 /* TPM 1.2 requires self-test on resume. This function actually returns
871 * an error code but for unknown reason it isn't handled.
873 if (!(chip
->flags
& TPM_CHIP_FLAG_TPM2
))
874 tpm_do_selftest(chip
);
880 static SIMPLE_DEV_PM_OPS(tpm_tis_pm
, tpm_pm_suspend
, tpm_tis_resume
);
882 static int tpm_tis_pnp_init(struct pnp_dev
*pnp_dev
,
883 const struct pnp_device_id
*pnp_id
)
885 struct tpm_info tpm_info
= {};
886 acpi_handle acpi_dev_handle
= NULL
;
887 struct resource
*res
;
889 res
= pnp_get_resource(pnp_dev
, IORESOURCE_MEM
, 0);
894 if (pnp_irq_valid(pnp_dev
, 0))
895 tpm_info
.irq
= pnp_irq(pnp_dev
, 0);
899 if (pnp_acpi_device(pnp_dev
)) {
900 if (is_itpm(pnp_acpi_device(pnp_dev
)))
903 acpi_dev_handle
= ACPI_HANDLE(&pnp_dev
->dev
);
906 return tpm_tis_init(&pnp_dev
->dev
, &tpm_info
, acpi_dev_handle
);
909 static struct pnp_device_id tpm_pnp_tbl
[] = {
910 {"PNP0C31", 0}, /* TPM */
911 {"ATM1200", 0}, /* Atmel */
912 {"IFX0102", 0}, /* Infineon */
913 {"BCM0101", 0}, /* Broadcom */
914 {"BCM0102", 0}, /* Broadcom */
915 {"NSC1200", 0}, /* National */
916 {"ICO0102", 0}, /* Intel */
918 {"", 0}, /* User Specified */
919 {"", 0} /* Terminator */
921 MODULE_DEVICE_TABLE(pnp
, tpm_pnp_tbl
);
923 static void tpm_tis_pnp_remove(struct pnp_dev
*dev
)
925 struct tpm_chip
*chip
= pnp_get_drvdata(dev
);
927 tpm_chip_unregister(chip
);
928 tpm_tis_remove(chip
);
931 static struct pnp_driver tis_pnp_driver
= {
933 .id_table
= tpm_pnp_tbl
,
934 .probe
= tpm_tis_pnp_init
,
935 .remove
= tpm_tis_pnp_remove
,
941 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2
942 module_param_string(hid
, tpm_pnp_tbl
[TIS_HID_USR_IDX
].id
,
943 sizeof(tpm_pnp_tbl
[TIS_HID_USR_IDX
].id
), 0444);
944 MODULE_PARM_DESC(hid
, "Set additional specific HID for this driver to probe");
947 static int tpm_check_resource(struct acpi_resource
*ares
, void *data
)
949 struct tpm_info
*tpm_info
= (struct tpm_info
*) data
;
952 if (acpi_dev_resource_interrupt(ares
, 0, &res
))
953 tpm_info
->irq
= res
.start
;
954 else if (acpi_dev_resource_memory(ares
, &res
)) {
956 tpm_info
->res
.name
= NULL
;
962 static int tpm_tis_acpi_init(struct acpi_device
*acpi_dev
)
964 struct acpi_table_tpm2
*tbl
;
966 struct list_head resources
;
967 struct tpm_info tpm_info
= {};
970 st
= acpi_get_table(ACPI_SIG_TPM2
, 1,
971 (struct acpi_table_header
**) &tbl
);
972 if (ACPI_FAILURE(st
) || tbl
->header
.length
< sizeof(*tbl
)) {
973 dev_err(&acpi_dev
->dev
,
974 FW_BUG
"failed to get TPM2 ACPI table\n");
978 if (tbl
->start_method
!= ACPI_TPM2_MEMORY_MAPPED
)
981 INIT_LIST_HEAD(&resources
);
983 ret
= acpi_dev_get_resources(acpi_dev
, &resources
, tpm_check_resource
,
988 acpi_dev_free_resource_list(&resources
);
990 if (resource_type(&tpm_info
.res
) != IORESOURCE_MEM
) {
991 dev_err(&acpi_dev
->dev
,
992 FW_BUG
"TPM2 ACPI table does not define a memory resource\n");
996 if (is_itpm(acpi_dev
))
999 return tpm_tis_init(&acpi_dev
->dev
, &tpm_info
, acpi_dev
->handle
);
1002 static int tpm_tis_acpi_remove(struct acpi_device
*dev
)
1004 struct tpm_chip
*chip
= dev_get_drvdata(&dev
->dev
);
1006 tpm_chip_unregister(chip
);
1007 tpm_tis_remove(chip
);
1012 static struct acpi_device_id tpm_acpi_tbl
[] = {
1013 {"MSFT0101", 0}, /* TPM 2.0 */
1015 {"", 0}, /* User Specified */
1016 {"", 0} /* Terminator */
1018 MODULE_DEVICE_TABLE(acpi
, tpm_acpi_tbl
);
1020 static struct acpi_driver tis_acpi_driver
= {
1022 .ids
= tpm_acpi_tbl
,
1024 .add
= tpm_tis_acpi_init
,
1025 .remove
= tpm_tis_acpi_remove
,
1033 static struct platform_device
*force_pdev
;
1035 static int tpm_tis_plat_probe(struct platform_device
*pdev
)
1037 struct tpm_info tpm_info
= {};
1038 struct resource
*res
;
1040 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1042 dev_err(&pdev
->dev
, "no memory resource defined\n");
1045 tpm_info
.res
= *res
;
1047 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1049 tpm_info
.irq
= res
->start
;
1051 if (pdev
== force_pdev
)
1054 /* When forcing auto probe the IRQ */
1058 return tpm_tis_init(&pdev
->dev
, &tpm_info
, NULL
);
1061 static int tpm_tis_plat_remove(struct platform_device
*pdev
)
1063 struct tpm_chip
*chip
= dev_get_drvdata(&pdev
->dev
);
1065 tpm_chip_unregister(chip
);
1066 tpm_tis_remove(chip
);
1071 static struct platform_driver tis_drv
= {
1072 .probe
= tpm_tis_plat_probe
,
1073 .remove
= tpm_tis_plat_remove
,
1082 module_param(force
, bool, 0444);
1083 MODULE_PARM_DESC(force
, "Force device probe rather than using ACPI entry");
1086 static int tpm_tis_force_device(void)
1088 struct platform_device
*pdev
;
1089 static const struct resource x86_resources
[] = {
1091 .start
= 0xFED40000,
1092 .end
= 0xFED40000 + TIS_MEM_LEN
- 1,
1093 .flags
= IORESOURCE_MEM
,
1100 /* The driver core will match the name tpm_tis of the device to
1101 * the tpm_tis platform driver and complete the setup via
1102 * tpm_tis_plat_probe
1104 pdev
= platform_device_register_simple("tpm_tis", -1, x86_resources
,
1105 ARRAY_SIZE(x86_resources
));
1107 return PTR_ERR(pdev
);
1113 static int __init
init_tis(void)
1117 rc
= tpm_tis_force_device();
1121 rc
= platform_driver_register(&tis_drv
);
1126 rc
= acpi_bus_register_driver(&tis_acpi_driver
);
1131 if (IS_ENABLED(CONFIG_PNP
)) {
1132 rc
= pnp_register_driver(&tis_pnp_driver
);
1141 acpi_bus_unregister_driver(&tis_acpi_driver
);
1144 platform_device_unregister(force_pdev
);
1147 platform_device_unregister(force_pdev
);
1152 static void __exit
cleanup_tis(void)
1154 pnp_unregister_driver(&tis_pnp_driver
);
1156 acpi_bus_unregister_driver(&tis_acpi_driver
);
1158 platform_driver_unregister(&tis_drv
);
1161 platform_device_unregister(force_pdev
);
1164 module_init(init_tis
);
1165 module_exit(cleanup_tis
);
1166 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1167 MODULE_DESCRIPTION("TPM Driver");
1168 MODULE_VERSION("2.0");
1169 MODULE_LICENSE("GPL");