Thomas Gleixner | b886d83c | 2019-06-01 10:08:55 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2005, 2006 IBM Corporation |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 4 | * Copyright (C) 2014, 2015 Intel Corporation |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 5 | * |
| 6 | * Authors: |
| 7 | * Leendert van Doorn <leendert@watson.ibm.com> |
| 8 | * Kylene Hall <kjhall@us.ibm.com> |
| 9 | * |
Kent Yoder | 8e81cc1 | 2007-08-22 14:01:04 -0700 | [diff] [blame] | 10 | * Maintained by: <tpmdd-devel@lists.sourceforge.net> |
| 11 | * |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 12 | * Device driver for TCG/TCPA TPM (trusted platform module). |
| 13 | * Specifications at www.trustedcomputinggroup.org |
| 14 | * |
| 15 | * This device driver implements the TPM interface as defined in |
| 16 | * the TCG TPM Interface Spec version 1.2, revision 1.0. |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 17 | */ |
Kylene Jo Hall | 5713556 | 2006-04-22 02:39:44 -0700 | [diff] [blame] | 18 | #include <linux/init.h> |
| 19 | #include <linux/module.h> |
| 20 | #include <linux/moduleparam.h> |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 21 | #include <linux/pnp.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 22 | #include <linux/slab.h> |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 23 | #include <linux/interrupt.h> |
| 24 | #include <linux/wait.h> |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 25 | #include <linux/acpi.h> |
Stefan Berger | 20b87bb | 2011-03-30 12:13:31 -0400 | [diff] [blame] | 26 | #include <linux/freezer.h> |
Jason Gunthorpe | 420d439 | 2016-11-07 15:44:31 -0700 | [diff] [blame] | 27 | #include <linux/of.h> |
| 28 | #include <linux/of_device.h> |
Jérémy Lefaure | 33957a1 | 2017-10-01 15:30:51 -0400 | [diff] [blame] | 29 | #include <linux/kernel.h> |
Jerry Snitselaar | b154ce1 | 2020-10-15 14:44:30 -0700 | [diff] [blame] | 30 | #include <linux/dmi.h> |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 31 | #include "tpm.h" |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 32 | #include "tpm_tis_core.h" |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 33 | |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 34 | struct tpm_info { |
Jason Gunthorpe | 51dd43d | 2016-01-07 17:36:23 -0700 | [diff] [blame] | 35 | struct resource res; |
Jason Gunthorpe | ef7b81d | 2016-01-07 17:36:21 -0700 | [diff] [blame] | 36 | /* irq > 0 means: use irq $irq; |
| 37 | * irq = 0 means: autoprobe for an irq; |
| 38 | * irq = -1 means: no irq support |
| 39 | */ |
| 40 | int irq; |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 41 | }; |
| 42 | |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 43 | struct tpm_tis_tcg_phy { |
| 44 | struct tpm_tis_data priv; |
Christophe Ricard | 4eea703 | 2016-03-31 22:56:55 +0200 | [diff] [blame] | 45 | void __iomem *iobase; |
Scot Doyle | 448e9c5 | 2014-09-24 22:41:10 +0000 | [diff] [blame] | 46 | }; |
| 47 | |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 48 | static inline struct tpm_tis_tcg_phy *to_tpm_tis_tcg_phy(struct tpm_tis_data *data) |
| 49 | { |
| 50 | return container_of(data, struct tpm_tis_tcg_phy, priv); |
| 51 | } |
| 52 | |
Jerry Snitselaar | b154ce1 | 2020-10-15 14:44:30 -0700 | [diff] [blame] | 53 | static int interrupts = -1; |
| 54 | module_param(interrupts, int, 0444); |
Christophe Ricard | 41a5e1c | 2016-05-19 00:35:52 +0200 | [diff] [blame] | 55 | MODULE_PARM_DESC(interrupts, "Enable interrupts"); |
| 56 | |
| 57 | static bool itpm; |
| 58 | module_param(itpm, bool, 0444); |
| 59 | MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)"); |
| 60 | |
| 61 | static bool force; |
| 62 | #ifdef CONFIG_X86 |
| 63 | module_param(force, bool, 0444); |
| 64 | MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry"); |
| 65 | #endif |
| 66 | |
Jerry Snitselaar | b154ce1 | 2020-10-15 14:44:30 -0700 | [diff] [blame] | 67 | static int tpm_tis_disable_irq(const struct dmi_system_id *d) |
| 68 | { |
| 69 | if (interrupts == -1) { |
| 70 | pr_notice("tpm_tis: %s detected: disabling interrupts.\n", d->ident); |
| 71 | interrupts = 0; |
| 72 | } |
| 73 | |
| 74 | return 0; |
| 75 | } |
| 76 | |
| 77 | static const struct dmi_system_id tpm_tis_dmi_table[] = { |
| 78 | { |
| 79 | .callback = tpm_tis_disable_irq, |
| 80 | .ident = "ThinkPad T490s", |
| 81 | .matches = { |
| 82 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), |
| 83 | DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T490s"), |
| 84 | }, |
| 85 | }, |
| 86 | {} |
| 87 | }; |
| 88 | |
Randy Dunlap | 1560ffe6 | 2011-08-03 16:21:11 -0700 | [diff] [blame] | 89 | #if defined(CONFIG_PNP) && defined(CONFIG_ACPI) |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 90 | static int has_hid(struct acpi_device *dev, const char *hid) |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 91 | { |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 92 | struct acpi_hardware_id *id; |
| 93 | |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 94 | list_for_each_entry(id, &dev->pnp.ids, list) |
| 95 | if (!strcmp(hid, id->id)) |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 96 | return 1; |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 97 | |
| 98 | return 0; |
| 99 | } |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 100 | |
| 101 | static inline int is_itpm(struct acpi_device *dev) |
| 102 | { |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 103 | if (!dev) |
| 104 | return 0; |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 105 | return has_hid(dev, "INTC0102"); |
| 106 | } |
Randy Dunlap | 1560ffe6 | 2011-08-03 16:21:11 -0700 | [diff] [blame] | 107 | #else |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 108 | static inline int is_itpm(struct acpi_device *dev) |
Randy Dunlap | 1560ffe6 | 2011-08-03 16:21:11 -0700 | [diff] [blame] | 109 | { |
| 110 | return 0; |
| 111 | } |
Matthew Garrett | 3f0d3d0 | 2010-10-21 17:42:40 -0400 | [diff] [blame] | 112 | #endif |
| 113 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 114 | #if defined(CONFIG_ACPI) |
| 115 | #define DEVICE_IS_TPM2 1 |
| 116 | |
| 117 | static const struct acpi_device_id tpm_acpi_tbl[] = { |
| 118 | {"MSFT0101", DEVICE_IS_TPM2}, |
| 119 | {}, |
| 120 | }; |
| 121 | MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl); |
| 122 | |
| 123 | static int check_acpi_tpm2(struct device *dev) |
| 124 | { |
| 125 | const struct acpi_device_id *aid = acpi_match_device(tpm_acpi_tbl, dev); |
| 126 | struct acpi_table_tpm2 *tbl; |
| 127 | acpi_status st; |
| 128 | |
| 129 | if (!aid || aid->driver_data != DEVICE_IS_TPM2) |
| 130 | return 0; |
| 131 | |
| 132 | /* If the ACPI TPM2 signature is matched then a global ACPI_SIG_TPM2 |
| 133 | * table is mandatory |
| 134 | */ |
| 135 | st = |
| 136 | acpi_get_table(ACPI_SIG_TPM2, 1, (struct acpi_table_header **)&tbl); |
| 137 | if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) { |
| 138 | dev_err(dev, FW_BUG "failed to get TPM2 ACPI table\n"); |
| 139 | return -EINVAL; |
| 140 | } |
| 141 | |
| 142 | /* The tpm2_crb driver handles this device */ |
| 143 | if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED) |
| 144 | return -ENODEV; |
| 145 | |
| 146 | return 0; |
| 147 | } |
| 148 | #else |
| 149 | static int check_acpi_tpm2(struct device *dev) |
| 150 | { |
| 151 | return 0; |
| 152 | } |
| 153 | #endif |
| 154 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 155 | static int tpm_tcg_read_bytes(struct tpm_tis_data *data, u32 addr, u16 len, |
| 156 | u8 *result) |
| 157 | { |
| 158 | struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); |
| 159 | |
| 160 | while (len--) |
| 161 | *result++ = ioread8(phy->iobase + addr); |
Azhar Shaikh | 5e572ca | 2017-06-18 19:17:59 -0700 | [diff] [blame] | 162 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 163 | return 0; |
| 164 | } |
| 165 | |
| 166 | static int tpm_tcg_write_bytes(struct tpm_tis_data *data, u32 addr, u16 len, |
Arnd Bergmann | c37fbc0 | 2017-09-07 15:30:45 +0200 | [diff] [blame] | 167 | const u8 *value) |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 168 | { |
| 169 | struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); |
| 170 | |
| 171 | while (len--) |
| 172 | iowrite8(*value++, phy->iobase + addr); |
Azhar Shaikh | 5e572ca | 2017-06-18 19:17:59 -0700 | [diff] [blame] | 173 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 174 | return 0; |
| 175 | } |
| 176 | |
| 177 | static int tpm_tcg_read16(struct tpm_tis_data *data, u32 addr, u16 *result) |
| 178 | { |
| 179 | struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); |
| 180 | |
| 181 | *result = ioread16(phy->iobase + addr); |
Azhar Shaikh | 5e572ca | 2017-06-18 19:17:59 -0700 | [diff] [blame] | 182 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 183 | return 0; |
| 184 | } |
| 185 | |
| 186 | static int tpm_tcg_read32(struct tpm_tis_data *data, u32 addr, u32 *result) |
| 187 | { |
| 188 | struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); |
| 189 | |
| 190 | *result = ioread32(phy->iobase + addr); |
Azhar Shaikh | 5e572ca | 2017-06-18 19:17:59 -0700 | [diff] [blame] | 191 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 192 | return 0; |
| 193 | } |
| 194 | |
| 195 | static int tpm_tcg_write32(struct tpm_tis_data *data, u32 addr, u32 value) |
| 196 | { |
| 197 | struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); |
| 198 | |
| 199 | iowrite32(value, phy->iobase + addr); |
Azhar Shaikh | 5e572ca | 2017-06-18 19:17:59 -0700 | [diff] [blame] | 200 | |
Christophe Ricard | 1107d06 | 2016-05-19 00:35:49 +0200 | [diff] [blame] | 201 | return 0; |
| 202 | } |
| 203 | |
| 204 | static const struct tpm_tis_phy_ops tpm_tcg = { |
| 205 | .read_bytes = tpm_tcg_read_bytes, |
| 206 | .write_bytes = tpm_tcg_write_bytes, |
| 207 | .read16 = tpm_tcg_read16, |
| 208 | .read32 = tpm_tcg_read32, |
| 209 | .write32 = tpm_tcg_write32, |
| 210 | }; |
| 211 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 212 | static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info) |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 213 | { |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 214 | struct tpm_tis_tcg_phy *phy; |
Christophe Ricard | 41a5e1c | 2016-05-19 00:35:52 +0200 | [diff] [blame] | 215 | int irq = -1; |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 216 | int rc; |
| 217 | |
Jerry Snitselaar | b154ce1 | 2020-10-15 14:44:30 -0700 | [diff] [blame] | 218 | dmi_check_system(tpm_tis_dmi_table); |
| 219 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 220 | rc = check_acpi_tpm2(dev); |
| 221 | if (rc) |
| 222 | return rc; |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 223 | |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 224 | phy = devm_kzalloc(dev, sizeof(struct tpm_tis_tcg_phy), GFP_KERNEL); |
| 225 | if (phy == NULL) |
Scot Doyle | 448e9c5 | 2014-09-24 22:41:10 +0000 | [diff] [blame] | 226 | return -ENOMEM; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 227 | |
Christophe Ricard | 57dacc2 | 2016-05-19 00:35:48 +0200 | [diff] [blame] | 228 | phy->iobase = devm_ioremap_resource(dev, &tpm_info->res); |
| 229 | if (IS_ERR(phy->iobase)) |
| 230 | return PTR_ERR(phy->iobase); |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 231 | |
Christophe Ricard | 41a5e1c | 2016-05-19 00:35:52 +0200 | [diff] [blame] | 232 | if (interrupts) |
| 233 | irq = tpm_info->irq; |
Stefan Berger | 9519de3f | 2011-03-30 12:13:33 -0400 | [diff] [blame] | 234 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 235 | if (itpm || is_itpm(ACPI_COMPANION(dev))) |
Maciej S. Szmigiero | 1d70fe9 | 2017-01-13 22:37:00 +0100 | [diff] [blame] | 236 | phy->priv.flags |= TPM_TIS_ITPM_WORKAROUND; |
Rajiv Andrade | 3507d61 | 2009-09-10 17:09:35 -0300 | [diff] [blame] | 237 | |
Christophe Ricard | 41a5e1c | 2016-05-19 00:35:52 +0200 | [diff] [blame] | 238 | return tpm_tis_core_init(dev, &phy->priv, irq, &tpm_tcg, |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 239 | ACPI_HANDLE(dev)); |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 240 | } |
Stefan Berger | 9685431 | 2011-07-17 01:04:24 -0400 | [diff] [blame] | 241 | |
Shuah Khan | a2fa3fb | 2013-09-11 14:23:13 -0700 | [diff] [blame] | 242 | static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume); |
| 243 | |
Bill Pemberton | afc6d36 | 2012-11-19 13:22:42 -0500 | [diff] [blame] | 244 | static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev, |
Jason Gunthorpe | ef7b81d | 2016-01-07 17:36:21 -0700 | [diff] [blame] | 245 | const struct pnp_device_id *pnp_id) |
Kylene Jo Hall | 9e323d3 | 2006-07-14 00:24:31 -0700 | [diff] [blame] | 246 | { |
Jason Gunthorpe | ef7b81d | 2016-01-07 17:36:21 -0700 | [diff] [blame] | 247 | struct tpm_info tpm_info = {}; |
Jason Gunthorpe | 51dd43d | 2016-01-07 17:36:23 -0700 | [diff] [blame] | 248 | struct resource *res; |
Bjorn Helgaas | 7917ff9 | 2007-10-16 23:26:46 -0700 | [diff] [blame] | 249 | |
Jason Gunthorpe | 51dd43d | 2016-01-07 17:36:23 -0700 | [diff] [blame] | 250 | res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0); |
| 251 | if (!res) |
| 252 | return -ENODEV; |
| 253 | tpm_info.res = *res; |
Kylene Jo Hall | 9e323d3 | 2006-07-14 00:24:31 -0700 | [diff] [blame] | 254 | |
Bjorn Helgaas | 7917ff9 | 2007-10-16 23:26:46 -0700 | [diff] [blame] | 255 | if (pnp_irq_valid(pnp_dev, 0)) |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 256 | tpm_info.irq = pnp_irq(pnp_dev, 0); |
Bjorn Helgaas | 7917ff9 | 2007-10-16 23:26:46 -0700 | [diff] [blame] | 257 | else |
Jason Gunthorpe | ef7b81d | 2016-01-07 17:36:21 -0700 | [diff] [blame] | 258 | tpm_info.irq = -1; |
Bjorn Helgaas | 7917ff9 | 2007-10-16 23:26:46 -0700 | [diff] [blame] | 259 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 260 | return tpm_tis_init(&pnp_dev->dev, &tpm_info); |
Kylene Jo Hall | 9e323d3 | 2006-07-14 00:24:31 -0700 | [diff] [blame] | 261 | } |
| 262 | |
Jarkko Sakkinen | 786a2aa | 2020-07-06 23:53:42 +0300 | [diff] [blame] | 263 | /* |
| 264 | * There is a known bug caused by 93e1b7d42e1e ("[PATCH] tpm: add HID module |
| 265 | * parameter"). This commit added IFX0102 device ID, which is also used by |
| 266 | * tpm_infineon but ignored to add quirks to probe which driver ought to be |
| 267 | * used. |
| 268 | */ |
| 269 | |
Bill Pemberton | 0bbed20 | 2012-11-19 13:24:36 -0500 | [diff] [blame] | 270 | static struct pnp_device_id tpm_pnp_tbl[] = { |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 271 | {"PNP0C31", 0}, /* TPM */ |
Kylene Jo Hall | 93e1b7d | 2006-04-22 02:39:52 -0700 | [diff] [blame] | 272 | {"ATM1200", 0}, /* Atmel */ |
Jarkko Sakkinen | 786a2aa | 2020-07-06 23:53:42 +0300 | [diff] [blame] | 273 | {"IFX0102", 0}, /* Infineon */ |
Kylene Jo Hall | 93e1b7d | 2006-04-22 02:39:52 -0700 | [diff] [blame] | 274 | {"BCM0101", 0}, /* Broadcom */ |
LE DISEZ Erwan | 061991e | 2008-07-25 19:44:56 -0700 | [diff] [blame] | 275 | {"BCM0102", 0}, /* Broadcom */ |
Kylene Jo Hall | 93e1b7d | 2006-04-22 02:39:52 -0700 | [diff] [blame] | 276 | {"NSC1200", 0}, /* National */ |
Marcin Obara | fb0e7e1 | 2008-07-10 17:30:42 -0700 | [diff] [blame] | 277 | {"ICO0102", 0}, /* Intel */ |
Kylene Jo Hall | 93e1b7d | 2006-04-22 02:39:52 -0700 | [diff] [blame] | 278 | /* Add new here */ |
| 279 | {"", 0}, /* User Specified */ |
| 280 | {"", 0} /* Terminator */ |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 281 | }; |
Matt Domsch | 31bde71 | 2009-11-03 12:05:50 +1100 | [diff] [blame] | 282 | MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl); |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 283 | |
Bill Pemberton | 39af33f | 2012-11-19 13:26:26 -0500 | [diff] [blame] | 284 | static void tpm_tis_pnp_remove(struct pnp_dev *dev) |
Rajiv Andrade | 253115b | 2008-10-11 09:04:39 +1100 | [diff] [blame] | 285 | { |
| 286 | struct tpm_chip *chip = pnp_get_drvdata(dev); |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 287 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 288 | tpm_chip_unregister(chip); |
| 289 | tpm_tis_remove(chip); |
Rajiv Andrade | 253115b | 2008-10-11 09:04:39 +1100 | [diff] [blame] | 290 | } |
| 291 | |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 292 | static struct pnp_driver tis_pnp_driver = { |
| 293 | .name = "tpm_tis", |
| 294 | .id_table = tpm_pnp_tbl, |
| 295 | .probe = tpm_tis_pnp_init, |
Rajiv Andrade | 253115b | 2008-10-11 09:04:39 +1100 | [diff] [blame] | 296 | .remove = tpm_tis_pnp_remove, |
Shuah Khan | a2fa3fb | 2013-09-11 14:23:13 -0700 | [diff] [blame] | 297 | .driver = { |
| 298 | .pm = &tpm_tis_pm, |
| 299 | }, |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 300 | }; |
| 301 | |
Jérémy Lefaure | 33957a1 | 2017-10-01 15:30:51 -0400 | [diff] [blame] | 302 | #define TIS_HID_USR_IDX (ARRAY_SIZE(tpm_pnp_tbl) - 2) |
Kylene Jo Hall | 93e1b7d | 2006-04-22 02:39:52 -0700 | [diff] [blame] | 303 | module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id, |
| 304 | sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444); |
| 305 | MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe"); |
Ming Lei | 7a192ec | 2009-02-06 23:40:12 +0800 | [diff] [blame] | 306 | |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 307 | static struct platform_device *force_pdev; |
| 308 | |
| 309 | static int tpm_tis_plat_probe(struct platform_device *pdev) |
| 310 | { |
| 311 | struct tpm_info tpm_info = {}; |
| 312 | struct resource *res; |
| 313 | |
| 314 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 315 | if (res == NULL) { |
| 316 | dev_err(&pdev->dev, "no memory resource defined\n"); |
| 317 | return -ENODEV; |
| 318 | } |
| 319 | tpm_info.res = *res; |
| 320 | |
Hans de Goede | 9c8c574 | 2019-10-25 11:14:48 +0200 | [diff] [blame] | 321 | tpm_info.irq = platform_get_irq_optional(pdev, 0); |
Jason Gunthorpe | fc0e132 | 2017-05-04 09:53:24 -0600 | [diff] [blame] | 322 | if (tpm_info.irq <= 0) { |
Jason Gunthorpe | d27f81f | 2017-05-04 09:53:23 -0600 | [diff] [blame] | 323 | if (pdev != force_pdev) |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 324 | tpm_info.irq = -1; |
| 325 | else |
| 326 | /* When forcing auto probe the IRQ */ |
| 327 | tpm_info.irq = 0; |
| 328 | } |
| 329 | |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 330 | return tpm_tis_init(&pdev->dev, &tpm_info); |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 331 | } |
| 332 | |
| 333 | static int tpm_tis_plat_remove(struct platform_device *pdev) |
| 334 | { |
| 335 | struct tpm_chip *chip = dev_get_drvdata(&pdev->dev); |
| 336 | |
| 337 | tpm_chip_unregister(chip); |
| 338 | tpm_tis_remove(chip); |
| 339 | |
| 340 | return 0; |
| 341 | } |
| 342 | |
Jason Gunthorpe | 420d439 | 2016-11-07 15:44:31 -0700 | [diff] [blame] | 343 | #ifdef CONFIG_OF |
| 344 | static const struct of_device_id tis_of_platform_match[] = { |
| 345 | {.compatible = "tcg,tpm-tis-mmio"}, |
| 346 | {}, |
| 347 | }; |
| 348 | MODULE_DEVICE_TABLE(of, tis_of_platform_match); |
| 349 | #endif |
| 350 | |
Ming Lei | 7a192ec | 2009-02-06 23:40:12 +0800 | [diff] [blame] | 351 | static struct platform_driver tis_drv = { |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 352 | .probe = tpm_tis_plat_probe, |
| 353 | .remove = tpm_tis_plat_remove, |
Ming Lei | 7a192ec | 2009-02-06 23:40:12 +0800 | [diff] [blame] | 354 | .driver = { |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 355 | .name = "tpm_tis", |
Rafael J. Wysocki | b633f05 | 2012-07-06 19:09:20 +0200 | [diff] [blame] | 356 | .pm = &tpm_tis_pm, |
Jason Gunthorpe | 420d439 | 2016-11-07 15:44:31 -0700 | [diff] [blame] | 357 | .of_match_table = of_match_ptr(tis_of_platform_match), |
Jason Gunthorpe | 4cb586a | 2017-05-04 09:53:25 -0600 | [diff] [blame] | 358 | .acpi_match_table = ACPI_PTR(tpm_acpi_tbl), |
Ming Lei | 7a192ec | 2009-02-06 23:40:12 +0800 | [diff] [blame] | 359 | }, |
Kylene Jo Hall | 9e323d3 | 2006-07-14 00:24:31 -0700 | [diff] [blame] | 360 | }; |
| 361 | |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 362 | static int tpm_tis_force_device(void) |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 363 | { |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 364 | struct platform_device *pdev; |
| 365 | static const struct resource x86_resources[] = { |
| 366 | { |
| 367 | .start = 0xFED40000, |
| 368 | .end = 0xFED40000 + TIS_MEM_LEN - 1, |
| 369 | .flags = IORESOURCE_MEM, |
| 370 | }, |
| 371 | }; |
| 372 | |
Jarkko Sakkinen | 399235d | 2015-09-29 00:32:19 +0300 | [diff] [blame] | 373 | if (!force) |
| 374 | return 0; |
Kylene Jo Hall | 9e323d3 | 2006-07-14 00:24:31 -0700 | [diff] [blame] | 375 | |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 376 | /* The driver core will match the name tpm_tis of the device to |
| 377 | * the tpm_tis platform driver and complete the setup via |
| 378 | * tpm_tis_plat_probe |
| 379 | */ |
| 380 | pdev = platform_device_register_simple("tpm_tis", -1, x86_resources, |
| 381 | ARRAY_SIZE(x86_resources)); |
| 382 | if (IS_ERR(pdev)) |
| 383 | return PTR_ERR(pdev); |
| 384 | force_pdev = pdev; |
| 385 | |
Wei Yongjun | 4fba3c3 | 2013-04-25 15:07:47 +0800 | [diff] [blame] | 386 | return 0; |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 387 | } |
| 388 | |
| 389 | static int __init init_tis(void) |
| 390 | { |
| 391 | int rc; |
| 392 | |
| 393 | rc = tpm_tis_force_device(); |
| 394 | if (rc) |
| 395 | goto err_force; |
| 396 | |
| 397 | rc = platform_driver_register(&tis_drv); |
| 398 | if (rc) |
| 399 | goto err_platform; |
| 400 | |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 401 | |
| 402 | if (IS_ENABLED(CONFIG_PNP)) { |
| 403 | rc = pnp_register_driver(&tis_pnp_driver); |
| 404 | if (rc) |
| 405 | goto err_pnp; |
| 406 | } |
| 407 | |
| 408 | return 0; |
| 409 | |
| 410 | err_pnp: |
Wei Yongjun | 5939eaf | 2017-02-07 15:51:47 +0000 | [diff] [blame] | 411 | platform_driver_unregister(&tis_drv); |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 412 | err_platform: |
| 413 | if (force_pdev) |
| 414 | platform_device_unregister(force_pdev); |
| 415 | err_force: |
Rajiv Andrade | 7f2ab00 | 2010-05-13 17:37:54 -0300 | [diff] [blame] | 416 | return rc; |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 417 | } |
| 418 | |
| 419 | static void __exit cleanup_tis(void) |
| 420 | { |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 421 | pnp_unregister_driver(&tis_pnp_driver); |
Rajiv Andrade | 7f2ab00 | 2010-05-13 17:37:54 -0300 | [diff] [blame] | 422 | platform_driver_unregister(&tis_drv); |
Jason Gunthorpe | 0019482 | 2016-01-07 17:36:24 -0700 | [diff] [blame] | 423 | |
| 424 | if (force_pdev) |
| 425 | platform_device_unregister(force_pdev); |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 426 | } |
| 427 | |
| 428 | module_init(init_tis); |
| 429 | module_exit(cleanup_tis); |
| 430 | MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); |
| 431 | MODULE_DESCRIPTION("TPM Driver"); |
| 432 | MODULE_VERSION("2.0"); |
| 433 | MODULE_LICENSE("GPL"); |