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>
31 #include <acpi/actbl2.h>
35 TPM_ACCESS_VALID = 0x80,
36 TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
37 TPM_ACCESS_REQUEST_PENDING = 0x04,
38 TPM_ACCESS_REQUEST_USE = 0x02,
43 TPM_STS_COMMAND_READY = 0x40,
45 TPM_STS_DATA_AVAIL = 0x10,
46 TPM_STS_DATA_EXPECT = 0x08,
50 TPM_GLOBAL_INT_ENABLE = 0x80000000,
51 TPM_INTF_BURST_COUNT_STATIC = 0x100,
52 TPM_INTF_CMD_READY_INT = 0x080,
53 TPM_INTF_INT_EDGE_FALLING = 0x040,
54 TPM_INTF_INT_EDGE_RISING = 0x020,
55 TPM_INTF_INT_LEVEL_LOW = 0x010,
56 TPM_INTF_INT_LEVEL_HIGH = 0x008,
57 TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
58 TPM_INTF_STS_VALID_INT = 0x002,
59 TPM_INTF_DATA_AVAIL_INT = 0x001,
63 TIS_MEM_BASE = 0xFED40000,
65 TIS_SHORT_TIMEOUT = 750, /* ms */
66 TIS_LONG_TIMEOUT = 2000, /* 2 sec */
75 static struct tpm_info tis_default_info = {
76 .start = TIS_MEM_BASE,
81 /* Some timeout values are needed before it is known whether the chip is
84 #define TIS_TIMEOUT_A_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_A)
85 #define TIS_TIMEOUT_B_MAX max(TIS_LONG_TIMEOUT, TPM2_TIMEOUT_B)
86 #define TIS_TIMEOUT_C_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_C)
87 #define TIS_TIMEOUT_D_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_D)
89 #define TPM_ACCESS(l) (0x0000 | ((l) << 12))
90 #define TPM_INT_ENABLE(l) (0x0008 | ((l) << 12))
91 #define TPM_INT_VECTOR(l) (0x000C | ((l) << 12))
92 #define TPM_INT_STATUS(l) (0x0010 | ((l) << 12))
93 #define TPM_INTF_CAPS(l) (0x0014 | ((l) << 12))
94 #define TPM_STS(l) (0x0018 | ((l) << 12))
95 #define TPM_STS3(l) (0x001b | ((l) << 12))
96 #define TPM_DATA_FIFO(l) (0x0024 | ((l) << 12))
98 #define TPM_DID_VID(l) (0x0F00 | ((l) << 12))
99 #define TPM_RID(l) (0x0F04 | ((l) << 12))
105 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
106 static int has_hid(struct acpi_device *dev, const char *hid)
108 struct acpi_hardware_id *id;
110 list_for_each_entry(id, &dev->pnp.ids, list)
111 if (!strcmp(hid, id->id))
117 static inline int is_itpm(struct acpi_device *dev)
119 return has_hid(dev, "INTC0102");
122 static inline int is_fifo(struct acpi_device *dev)
124 struct acpi_table_tpm2 *tbl;
128 if (!has_hid(dev, "MSFT0101"))
131 st = acpi_get_table(ACPI_SIG_TPM2, 1,
132 (struct acpi_table_header **) &tbl);
133 if (ACPI_FAILURE(st)) {
134 dev_err(&dev->dev, "failed to get TPM2 ACPI table\n");
138 if (le32_to_cpu(tbl->start_method) != TPM2_START_FIFO)
145 static inline int is_itpm(struct acpi_device *dev)
150 static inline int is_fifo(struct acpi_device *dev)
156 /* Before we attempt to access the TPM we must see that the valid bit is set.
157 * The specification says that this bit is 0 at reset and remains 0 until the
158 * 'TPM has gone through its self test and initialization and has established
159 * correct values in the other bits.' */
160 static int wait_startup(struct tpm_chip *chip, int l)
162 unsigned long stop = jiffies + chip->vendor.timeout_a;
164 if (ioread8(chip->vendor.iobase + TPM_ACCESS(l)) &
168 } while (time_before(jiffies, stop));
172 static int check_locality(struct tpm_chip *chip, int l)
174 if ((ioread8(chip->vendor.iobase + TPM_ACCESS(l)) &
175 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
176 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
177 return chip->vendor.locality = l;
182 static void release_locality(struct tpm_chip *chip, int l, int force)
184 if (force || (ioread8(chip->vendor.iobase + TPM_ACCESS(l)) &
185 (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
186 (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))
187 iowrite8(TPM_ACCESS_ACTIVE_LOCALITY,
188 chip->vendor.iobase + TPM_ACCESS(l));
191 static int request_locality(struct tpm_chip *chip, int l)
193 unsigned long stop, timeout;
196 if (check_locality(chip, l) >= 0)
199 iowrite8(TPM_ACCESS_REQUEST_USE,
200 chip->vendor.iobase + TPM_ACCESS(l));
202 stop = jiffies + chip->vendor.timeout_a;
204 if (chip->vendor.irq) {
206 timeout = stop - jiffies;
207 if ((long)timeout <= 0)
209 rc = wait_event_interruptible_timeout(chip->vendor.int_queue,
215 if (rc == -ERESTARTSYS && freezing(current)) {
216 clear_thread_flag(TIF_SIGPENDING);
220 /* wait for burstcount */
222 if (check_locality(chip, l) >= 0)
226 while (time_before(jiffies, stop));
231 static u8 tpm_tis_status(struct tpm_chip *chip)
233 return ioread8(chip->vendor.iobase +
234 TPM_STS(chip->vendor.locality));
237 static void tpm_tis_ready(struct tpm_chip *chip)
239 /* this causes the current command to be aborted */
240 iowrite8(TPM_STS_COMMAND_READY,
241 chip->vendor.iobase + TPM_STS(chip->vendor.locality));
244 static int get_burstcount(struct tpm_chip *chip)
249 /* wait for burstcount */
250 /* which timeout value, spec has 2 answers (c & d) */
251 stop = jiffies + chip->vendor.timeout_d;
253 burstcnt = ioread8(chip->vendor.iobase +
254 TPM_STS(chip->vendor.locality) + 1);
255 burstcnt += ioread8(chip->vendor.iobase +
256 TPM_STS(chip->vendor.locality) +
261 } while (time_before(jiffies, stop));
265 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
267 int size = 0, burstcnt;
268 while (size < count &&
269 wait_for_tpm_stat(chip,
270 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
271 chip->vendor.timeout_c,
272 &chip->vendor.read_queue, true)
274 burstcnt = get_burstcount(chip);
275 for (; burstcnt > 0 && size < count; burstcnt--)
276 buf[size++] = ioread8(chip->vendor.iobase +
277 TPM_DATA_FIFO(chip->vendor.
283 static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
286 int expected, status;
288 if (count < TPM_HEADER_SIZE) {
293 /* read first 10 bytes, including tag, paramsize, and result */
295 recv_data(chip, buf, TPM_HEADER_SIZE)) < TPM_HEADER_SIZE) {
296 dev_err(chip->pdev, "Unable to read header\n");
300 expected = be32_to_cpu(*(__be32 *) (buf + 2));
301 if (expected > count) {
307 recv_data(chip, &buf[TPM_HEADER_SIZE],
308 expected - TPM_HEADER_SIZE)) < expected) {
309 dev_err(chip->pdev, "Unable to read remainder of result\n");
314 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
315 &chip->vendor.int_queue, false);
316 status = tpm_tis_status(chip);
317 if (status & TPM_STS_DATA_AVAIL) { /* retry? */
318 dev_err(chip->pdev, "Error left over data\n");
325 release_locality(chip, chip->vendor.locality, 0);
330 module_param(itpm, bool, 0444);
331 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
334 * If interrupts are used (signaled by an irq set in the vendor structure)
335 * tpm.c can skip polling for the data to be available as the interrupt is
338 static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
340 int rc, status, burstcnt;
343 if (request_locality(chip, 0) < 0)
346 status = tpm_tis_status(chip);
347 if ((status & TPM_STS_COMMAND_READY) == 0) {
349 if (wait_for_tpm_stat
350 (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
351 &chip->vendor.int_queue, false) < 0) {
357 while (count < len - 1) {
358 burstcnt = get_burstcount(chip);
359 for (; burstcnt > 0 && count < len - 1; burstcnt--) {
360 iowrite8(buf[count], chip->vendor.iobase +
361 TPM_DATA_FIFO(chip->vendor.locality));
365 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
366 &chip->vendor.int_queue, false);
367 status = tpm_tis_status(chip);
368 if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
374 /* write last byte */
376 chip->vendor.iobase + TPM_DATA_FIFO(chip->vendor.locality));
377 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
378 &chip->vendor.int_queue, false);
379 status = tpm_tis_status(chip);
380 if ((status & TPM_STS_DATA_EXPECT) != 0) {
389 release_locality(chip, chip->vendor.locality, 0);
393 static void disable_interrupts(struct tpm_chip *chip)
398 ioread32(chip->vendor.iobase +
399 TPM_INT_ENABLE(chip->vendor.locality));
400 intmask &= ~TPM_GLOBAL_INT_ENABLE;
402 chip->vendor.iobase +
403 TPM_INT_ENABLE(chip->vendor.locality));
404 devm_free_irq(chip->pdev, chip->vendor.irq, chip);
405 chip->vendor.irq = 0;
409 * If interrupts are used (signaled by an irq set in the vendor structure)
410 * tpm.c can skip polling for the data to be available as the interrupt is
413 static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len)
419 rc = tpm_tis_send_data(chip, buf, len);
425 chip->vendor.iobase + TPM_STS(chip->vendor.locality));
427 if (chip->vendor.irq) {
428 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
430 if (chip->flags & TPM_CHIP_FLAG_TPM2)
431 dur = tpm2_calc_ordinal_duration(chip, ordinal);
433 dur = tpm_calc_ordinal_duration(chip, ordinal);
435 if (wait_for_tpm_stat
436 (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID, dur,
437 &chip->vendor.read_queue, false) < 0) {
445 release_locality(chip, chip->vendor.locality, 0);
449 static int tpm_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
452 struct priv_data *priv = chip->vendor.priv;
454 if (!chip->vendor.irq || priv->irq_tested)
455 return tpm_tis_send_main(chip, buf, len);
457 /* Verify receipt of the expected IRQ */
458 irq = chip->vendor.irq;
459 chip->vendor.irq = 0;
460 rc = tpm_tis_send_main(chip, buf, len);
461 chip->vendor.irq = irq;
462 if (!priv->irq_tested)
464 if (!priv->irq_tested)
465 disable_interrupts(chip);
466 priv->irq_tested = true;
470 struct tis_vendor_timeout_override {
472 unsigned long timeout_us[4];
475 static const struct tis_vendor_timeout_override vendor_timeout_overrides[] = {
477 { 0x32041114, { (TIS_SHORT_TIMEOUT*1000), (TIS_LONG_TIMEOUT*1000),
478 (TIS_SHORT_TIMEOUT*1000), (TIS_SHORT_TIMEOUT*1000) } },
481 static bool tpm_tis_update_timeouts(struct tpm_chip *chip,
482 unsigned long *timeout_cap)
487 did_vid = ioread32(chip->vendor.iobase + TPM_DID_VID(0));
489 for (i = 0; i != ARRAY_SIZE(vendor_timeout_overrides); i++) {
490 if (vendor_timeout_overrides[i].did_vid != did_vid)
492 memcpy(timeout_cap, vendor_timeout_overrides[i].timeout_us,
493 sizeof(vendor_timeout_overrides[i].timeout_us));
501 * Early probing for iTPM with STS_DATA_EXPECT flaw.
502 * Try sending command without itpm flag set and if that
503 * fails, repeat with itpm flag set.
505 static int probe_itpm(struct tpm_chip *chip)
508 u8 cmd_getticks[] = {
509 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
510 0x00, 0x00, 0x00, 0xf1
512 size_t len = sizeof(cmd_getticks);
513 bool rem_itpm = itpm;
514 u16 vendor = ioread16(chip->vendor.iobase + TPM_DID_VID(0));
516 /* probe only iTPMS */
517 if (vendor != TPM_VID_INTEL)
522 rc = tpm_tis_send_data(chip, cmd_getticks, len);
527 release_locality(chip, chip->vendor.locality, 0);
531 rc = tpm_tis_send_data(chip, cmd_getticks, len);
533 dev_info(chip->pdev, "Detected an iTPM.\n");
541 release_locality(chip, chip->vendor.locality, 0);
546 static bool tpm_tis_req_canceled(struct tpm_chip *chip, u8 status)
548 switch (chip->vendor.manufacturer_id) {
549 case TPM_VID_WINBOND:
550 return ((status == TPM_STS_VALID) ||
551 (status == (TPM_STS_VALID | TPM_STS_COMMAND_READY)));
553 return (status == (TPM_STS_VALID | TPM_STS_COMMAND_READY));
555 return (status == TPM_STS_COMMAND_READY);
559 static const struct tpm_class_ops tpm_tis = {
560 .status = tpm_tis_status,
561 .recv = tpm_tis_recv,
562 .send = tpm_tis_send,
563 .cancel = tpm_tis_ready,
564 .update_timeouts = tpm_tis_update_timeouts,
565 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
566 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
567 .req_canceled = tpm_tis_req_canceled,
570 static irqreturn_t tis_int_handler(int dummy, void *dev_id)
572 struct tpm_chip *chip = dev_id;
576 interrupt = ioread32(chip->vendor.iobase +
577 TPM_INT_STATUS(chip->vendor.locality));
582 ((struct priv_data *)chip->vendor.priv)->irq_tested = true;
583 if (interrupt & TPM_INTF_DATA_AVAIL_INT)
584 wake_up_interruptible(&chip->vendor.read_queue);
585 if (interrupt & TPM_INTF_LOCALITY_CHANGE_INT)
586 for (i = 0; i < 5; i++)
587 if (check_locality(chip, i) >= 0)
590 (TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT |
591 TPM_INTF_CMD_READY_INT))
592 wake_up_interruptible(&chip->vendor.int_queue);
594 /* Clear interrupts handled with TPM_EOI */
596 chip->vendor.iobase +
597 TPM_INT_STATUS(chip->vendor.locality));
598 ioread32(chip->vendor.iobase + TPM_INT_STATUS(chip->vendor.locality));
602 /* Register the IRQ and issue a command that will cause an interrupt. If an
603 * irq is seen then leave the chip setup for IRQ operation, otherwise reverse
604 * everything and leave in polling mode. Returns 0 on success.
606 static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
609 struct priv_data *priv = chip->vendor.priv;
612 if (devm_request_irq(chip->pdev, irq, tis_int_handler, flags,
613 chip->devname, chip) != 0) {
614 dev_info(chip->pdev, "Unable to request irq: %d for probe\n",
618 chip->vendor.irq = irq;
620 original_int_vec = ioread8(chip->vendor.iobase +
621 TPM_INT_VECTOR(chip->vendor.locality));
623 chip->vendor.iobase + TPM_INT_VECTOR(chip->vendor.locality));
625 /* Clear all existing */
626 iowrite32(ioread32(chip->vendor.iobase +
627 TPM_INT_STATUS(chip->vendor.locality)),
628 chip->vendor.iobase + TPM_INT_STATUS(chip->vendor.locality));
631 iowrite32(intmask | TPM_GLOBAL_INT_ENABLE,
632 chip->vendor.iobase + TPM_INT_ENABLE(chip->vendor.locality));
634 priv->irq_tested = false;
636 /* Generate an interrupt by having the core call through to
639 if (chip->flags & TPM_CHIP_FLAG_TPM2)
640 tpm2_gen_interrupt(chip);
642 tpm_gen_interrupt(chip);
644 /* tpm_tis_send will either confirm the interrupt is working or it
645 * will call disable_irq which undoes all of the above.
647 if (!chip->vendor.irq) {
648 iowrite8(original_int_vec,
649 chip->vendor.iobase +
650 TPM_INT_VECTOR(chip->vendor.locality));
657 /* Try to find the IRQ the TPM is using. This is for legacy x86 systems that
658 * do not have ACPI/etc. We typically expect the interrupt to be declared if
661 static void tpm_tis_probe_irq(struct tpm_chip *chip, u32 intmask)
666 original_int_vec = ioread8(chip->vendor.iobase +
667 TPM_INT_VECTOR(chip->vendor.locality));
669 if (!original_int_vec) {
670 if (IS_ENABLED(CONFIG_X86))
671 for (i = 3; i <= 15; i++)
672 if (!tpm_tis_probe_irq_single(chip, intmask, 0,
675 } else if (!tpm_tis_probe_irq_single(chip, intmask, 0,
680 static bool interrupts = true;
681 module_param(interrupts, bool, 0444);
682 MODULE_PARM_DESC(interrupts, "Enable interrupts");
684 static void tpm_tis_remove(struct tpm_chip *chip)
686 if (chip->flags & TPM_CHIP_FLAG_TPM2)
687 tpm2_shutdown(chip, TPM2_SU_CLEAR);
689 iowrite32(~TPM_GLOBAL_INT_ENABLE &
690 ioread32(chip->vendor.iobase +
691 TPM_INT_ENABLE(chip->vendor.
693 chip->vendor.iobase +
694 TPM_INT_ENABLE(chip->vendor.locality));
695 release_locality(chip, chip->vendor.locality, 1);
698 static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
699 acpi_handle acpi_dev_handle)
701 u32 vendor, intfcaps, intmask;
703 struct tpm_chip *chip;
704 struct priv_data *priv;
706 priv = devm_kzalloc(dev, sizeof(struct priv_data), GFP_KERNEL);
710 chip = tpmm_chip_alloc(dev, &tpm_tis);
712 return PTR_ERR(chip);
714 chip->vendor.priv = priv;
716 chip->acpi_dev_handle = acpi_dev_handle;
719 chip->vendor.iobase = devm_ioremap(dev, tpm_info->start, tpm_info->len);
720 if (!chip->vendor.iobase)
723 /* Maximum timeouts */
724 chip->vendor.timeout_a = TIS_TIMEOUT_A_MAX;
725 chip->vendor.timeout_b = TIS_TIMEOUT_B_MAX;
726 chip->vendor.timeout_c = TIS_TIMEOUT_C_MAX;
727 chip->vendor.timeout_d = TIS_TIMEOUT_D_MAX;
729 if (wait_startup(chip, 0) != 0) {
734 /* Take control of the TPM's interrupt hardware and shut it off */
735 intmask = ioread32(chip->vendor.iobase +
736 TPM_INT_ENABLE(chip->vendor.locality));
737 intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
738 TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
739 intmask &= ~TPM_GLOBAL_INT_ENABLE;
741 chip->vendor.iobase + TPM_INT_ENABLE(chip->vendor.locality));
743 if (request_locality(chip, 0) != 0) {
748 rc = tpm2_probe(chip);
752 vendor = ioread32(chip->vendor.iobase + TPM_DID_VID(0));
753 chip->vendor.manufacturer_id = vendor;
755 dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n",
756 (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2",
757 vendor >> 16, ioread8(chip->vendor.iobase + TPM_RID(0)));
760 probe = probe_itpm(chip);
769 dev_info(dev, "Intel iTPM workaround enabled\n");
772 /* Figure out the capabilities */
774 ioread32(chip->vendor.iobase +
775 TPM_INTF_CAPS(chip->vendor.locality));
776 dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
778 if (intfcaps & TPM_INTF_BURST_COUNT_STATIC)
779 dev_dbg(dev, "\tBurst Count Static\n");
780 if (intfcaps & TPM_INTF_CMD_READY_INT)
781 dev_dbg(dev, "\tCommand Ready Int Support\n");
782 if (intfcaps & TPM_INTF_INT_EDGE_FALLING)
783 dev_dbg(dev, "\tInterrupt Edge Falling\n");
784 if (intfcaps & TPM_INTF_INT_EDGE_RISING)
785 dev_dbg(dev, "\tInterrupt Edge Rising\n");
786 if (intfcaps & TPM_INTF_INT_LEVEL_LOW)
787 dev_dbg(dev, "\tInterrupt Level Low\n");
788 if (intfcaps & TPM_INTF_INT_LEVEL_HIGH)
789 dev_dbg(dev, "\tInterrupt Level High\n");
790 if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT)
791 dev_dbg(dev, "\tLocality Change Int Support\n");
792 if (intfcaps & TPM_INTF_STS_VALID_INT)
793 dev_dbg(dev, "\tSts Valid Int Support\n");
794 if (intfcaps & TPM_INTF_DATA_AVAIL_INT)
795 dev_dbg(dev, "\tData Avail Int Support\n");
797 /* Very early on issue a command to the TPM in polling mode to make
798 * sure it works. May as well use that command to set the proper
799 * timeouts for the driver.
801 if (tpm_get_timeouts(chip)) {
802 dev_err(dev, "Could not get TPM timeouts and durations\n");
807 /* INTERRUPT Setup */
808 init_waitqueue_head(&chip->vendor.read_queue);
809 init_waitqueue_head(&chip->vendor.int_queue);
812 tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
814 if (!chip->vendor.irq)
815 dev_err(chip->pdev, FW_BUG
816 "TPM interrupt not working, polling instead\n");
818 tpm_tis_probe_irq(chip, intmask);
821 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
822 rc = tpm2_do_selftest(chip);
823 if (rc == TPM2_RC_INITIALIZE) {
824 dev_warn(dev, "Firmware has not started TPM\n");
825 rc = tpm2_startup(chip, TPM2_SU_CLEAR);
827 rc = tpm2_do_selftest(chip);
831 dev_err(dev, "TPM self test failed\n");
837 if (tpm_do_selftest(chip)) {
838 dev_err(dev, "TPM self test failed\n");
844 return tpm_chip_register(chip);
846 tpm_tis_remove(chip);
850 #ifdef CONFIG_PM_SLEEP
851 static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
855 /* reenable interrupts that device may have lost or
856 BIOS/firmware may have disabled */
857 iowrite8(chip->vendor.irq, chip->vendor.iobase +
858 TPM_INT_VECTOR(chip->vendor.locality));
861 ioread32(chip->vendor.iobase +
862 TPM_INT_ENABLE(chip->vendor.locality));
864 intmask |= TPM_INTF_CMD_READY_INT
865 | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
866 | TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE;
869 chip->vendor.iobase + TPM_INT_ENABLE(chip->vendor.locality));
872 static int tpm_tis_resume(struct device *dev)
874 struct tpm_chip *chip = dev_get_drvdata(dev);
877 if (chip->vendor.irq)
878 tpm_tis_reenable_interrupts(chip);
880 ret = tpm_pm_resume(dev);
884 /* TPM 1.2 requires self-test on resume. This function actually returns
885 * an error code but for unknown reason it isn't handled.
887 if (!(chip->flags & TPM_CHIP_FLAG_TPM2))
888 tpm_do_selftest(chip);
894 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
897 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
898 const struct pnp_device_id *pnp_id)
900 struct tpm_info tpm_info = tis_default_info;
901 acpi_handle acpi_dev_handle = NULL;
903 tpm_info.start = pnp_mem_start(pnp_dev, 0);
904 tpm_info.len = pnp_mem_len(pnp_dev, 0);
906 if (pnp_irq_valid(pnp_dev, 0))
907 tpm_info.irq = pnp_irq(pnp_dev, 0);
912 if (pnp_acpi_device(pnp_dev)) {
913 if (is_itpm(pnp_acpi_device(pnp_dev)))
916 acpi_dev_handle = pnp_acpi_device(pnp_dev)->handle;
920 return tpm_tis_init(&pnp_dev->dev, &tpm_info, acpi_dev_handle);
923 static struct pnp_device_id tpm_pnp_tbl[] = {
924 {"PNP0C31", 0}, /* TPM */
925 {"ATM1200", 0}, /* Atmel */
926 {"IFX0102", 0}, /* Infineon */
927 {"BCM0101", 0}, /* Broadcom */
928 {"BCM0102", 0}, /* Broadcom */
929 {"NSC1200", 0}, /* National */
930 {"ICO0102", 0}, /* Intel */
932 {"", 0}, /* User Specified */
933 {"", 0} /* Terminator */
935 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
937 static void tpm_tis_pnp_remove(struct pnp_dev *dev)
939 struct tpm_chip *chip = pnp_get_drvdata(dev);
941 tpm_chip_unregister(chip);
942 tpm_tis_remove(chip);
945 static struct pnp_driver tis_pnp_driver = {
947 .id_table = tpm_pnp_tbl,
948 .probe = tpm_tis_pnp_init,
949 .remove = tpm_tis_pnp_remove,
955 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2
956 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
957 sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
958 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
962 static int tpm_check_resource(struct acpi_resource *ares, void *data)
964 struct tpm_info *tpm_info = (struct tpm_info *) data;
967 if (acpi_dev_resource_interrupt(ares, 0, &res)) {
968 tpm_info->irq = res.start;
969 } else if (acpi_dev_resource_memory(ares, &res)) {
970 tpm_info->start = res.start;
971 tpm_info->len = resource_size(&res);
977 static int tpm_tis_acpi_init(struct acpi_device *acpi_dev)
979 struct list_head resources;
980 struct tpm_info tpm_info = tis_default_info;
983 if (!is_fifo(acpi_dev))
986 INIT_LIST_HEAD(&resources);
987 ret = acpi_dev_get_resources(acpi_dev, &resources, tpm_check_resource,
992 acpi_dev_free_resource_list(&resources);
997 if (is_itpm(acpi_dev))
1000 return tpm_tis_init(&acpi_dev->dev, &tpm_info, acpi_dev->handle);
1003 static int tpm_tis_acpi_remove(struct acpi_device *dev)
1005 struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
1007 tpm_chip_unregister(chip);
1008 tpm_tis_remove(chip);
1013 static struct acpi_device_id tpm_acpi_tbl[] = {
1014 {"MSFT0101", 0}, /* TPM 2.0 */
1016 {"", 0}, /* User Specified */
1017 {"", 0} /* Terminator */
1019 MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl);
1021 static struct acpi_driver tis_acpi_driver = {
1023 .ids = tpm_acpi_tbl,
1025 .add = tpm_tis_acpi_init,
1026 .remove = tpm_tis_acpi_remove,
1034 static struct platform_driver tis_drv = {
1041 static struct platform_device *pdev;
1044 module_param(force, bool, 0444);
1045 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
1046 static int __init init_tis(void)
1051 rc = pnp_register_driver(&tis_pnp_driver);
1058 rc = acpi_bus_register_driver(&tis_acpi_driver);
1061 pnp_unregister_driver(&tis_pnp_driver);
1070 rc = platform_driver_register(&tis_drv);
1073 pdev = platform_device_register_simple("tpm_tis", -1, NULL, 0);
1078 rc = tpm_tis_init(&pdev->dev, &tis_default_info, NULL);
1083 platform_device_unregister(pdev);
1085 platform_driver_unregister(&tis_drv);
1089 static void __exit cleanup_tis(void)
1091 struct tpm_chip *chip;
1092 #if defined(CONFIG_PNP) || defined(CONFIG_ACPI)
1095 acpi_bus_unregister_driver(&tis_acpi_driver);
1098 pnp_unregister_driver(&tis_pnp_driver);
1103 chip = dev_get_drvdata(&pdev->dev);
1104 tpm_chip_unregister(chip);
1105 tpm_tis_remove(chip);
1106 platform_device_unregister(pdev);
1107 platform_driver_unregister(&tis_drv);
1110 module_init(init_tis);
1111 module_exit(cleanup_tis);
1112 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1113 MODULE_DESCRIPTION("TPM Driver");
1114 MODULE_VERSION("2.0");
1115 MODULE_LICENSE("GPL");