1 /* 2 * Copyright (C) 2005, 2006 IBM Corporation 3 * Copyright (C) 2014, 2015 Intel Corporation 4 * 5 * Authors: 6 * Leendert van Doorn <leendert@watson.ibm.com> 7 * Kylene Hall <kjhall@us.ibm.com> 8 * 9 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 10 * 11 * Device driver for TCG/TCPA TPM (trusted platform module). 12 * Specifications at www.trustedcomputinggroup.org 13 * 14 * This device driver implements the TPM interface as defined in 15 * the TCG TPM Interface Spec version 1.2, revision 1.0. 16 * 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 20 * License. 21 */ 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 <linux/of.h> 32 #include <linux/of_device.h> 33 #include "tpm.h" 34 #include "tpm_tis_core.h" 35 36 struct tpm_info { 37 struct resource res; 38 /* irq > 0 means: use irq $irq; 39 * irq = 0 means: autoprobe for an irq; 40 * irq = -1 means: no irq support 41 */ 42 int irq; 43 }; 44 45 struct tpm_tis_tcg_phy { 46 struct tpm_tis_data priv; 47 void __iomem *iobase; 48 }; 49 50 static inline struct tpm_tis_tcg_phy *to_tpm_tis_tcg_phy(struct tpm_tis_data *data) 51 { 52 return container_of(data, struct tpm_tis_tcg_phy, priv); 53 } 54 55 static bool interrupts = true; 56 module_param(interrupts, bool, 0444); 57 MODULE_PARM_DESC(interrupts, "Enable interrupts"); 58 59 static bool itpm; 60 module_param(itpm, bool, 0444); 61 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)"); 62 63 static bool force; 64 #ifdef CONFIG_X86 65 module_param(force, bool, 0444); 66 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry"); 67 #endif 68 69 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI) 70 static int has_hid(struct acpi_device *dev, const char *hid) 71 { 72 struct acpi_hardware_id *id; 73 74 list_for_each_entry(id, &dev->pnp.ids, list) 75 if (!strcmp(hid, id->id)) 76 return 1; 77 78 return 0; 79 } 80 81 static inline int is_itpm(struct acpi_device *dev) 82 { 83 return has_hid(dev, "INTC0102"); 84 } 85 #else 86 static inline int is_itpm(struct acpi_device *dev) 87 { 88 return 0; 89 } 90 #endif 91 92 static int tpm_tcg_read_bytes(struct tpm_tis_data *data, u32 addr, u16 len, 93 u8 *result) 94 { 95 struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); 96 97 while (len--) 98 *result++ = ioread8(phy->iobase + addr); 99 return 0; 100 } 101 102 static int tpm_tcg_write_bytes(struct tpm_tis_data *data, u32 addr, u16 len, 103 u8 *value) 104 { 105 struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); 106 107 while (len--) 108 iowrite8(*value++, phy->iobase + addr); 109 return 0; 110 } 111 112 static int tpm_tcg_read16(struct tpm_tis_data *data, u32 addr, u16 *result) 113 { 114 struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); 115 116 *result = ioread16(phy->iobase + addr); 117 return 0; 118 } 119 120 static int tpm_tcg_read32(struct tpm_tis_data *data, u32 addr, u32 *result) 121 { 122 struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); 123 124 *result = ioread32(phy->iobase + addr); 125 return 0; 126 } 127 128 static int tpm_tcg_write32(struct tpm_tis_data *data, u32 addr, u32 value) 129 { 130 struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data); 131 132 iowrite32(value, phy->iobase + addr); 133 return 0; 134 } 135 136 static const struct tpm_tis_phy_ops tpm_tcg = { 137 .read_bytes = tpm_tcg_read_bytes, 138 .write_bytes = tpm_tcg_write_bytes, 139 .read16 = tpm_tcg_read16, 140 .read32 = tpm_tcg_read32, 141 .write32 = tpm_tcg_write32, 142 }; 143 144 static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info, 145 acpi_handle acpi_dev_handle) 146 { 147 struct tpm_tis_tcg_phy *phy; 148 int irq = -1; 149 150 phy = devm_kzalloc(dev, sizeof(struct tpm_tis_tcg_phy), GFP_KERNEL); 151 if (phy == NULL) 152 return -ENOMEM; 153 154 phy->iobase = devm_ioremap_resource(dev, &tpm_info->res); 155 if (IS_ERR(phy->iobase)) 156 return PTR_ERR(phy->iobase); 157 158 if (interrupts) 159 irq = tpm_info->irq; 160 161 if (itpm) 162 phy->priv.flags |= TPM_TIS_ITPM_WORKAROUND; 163 164 return tpm_tis_core_init(dev, &phy->priv, irq, &tpm_tcg, 165 acpi_dev_handle); 166 } 167 168 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume); 169 170 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev, 171 const struct pnp_device_id *pnp_id) 172 { 173 struct tpm_info tpm_info = {}; 174 acpi_handle acpi_dev_handle = NULL; 175 struct resource *res; 176 177 res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0); 178 if (!res) 179 return -ENODEV; 180 tpm_info.res = *res; 181 182 if (pnp_irq_valid(pnp_dev, 0)) 183 tpm_info.irq = pnp_irq(pnp_dev, 0); 184 else 185 tpm_info.irq = -1; 186 187 if (pnp_acpi_device(pnp_dev)) { 188 if (is_itpm(pnp_acpi_device(pnp_dev))) 189 itpm = true; 190 191 acpi_dev_handle = ACPI_HANDLE(&pnp_dev->dev); 192 } 193 194 return tpm_tis_init(&pnp_dev->dev, &tpm_info, acpi_dev_handle); 195 } 196 197 static struct pnp_device_id tpm_pnp_tbl[] = { 198 {"PNP0C31", 0}, /* TPM */ 199 {"ATM1200", 0}, /* Atmel */ 200 {"IFX0102", 0}, /* Infineon */ 201 {"BCM0101", 0}, /* Broadcom */ 202 {"BCM0102", 0}, /* Broadcom */ 203 {"NSC1200", 0}, /* National */ 204 {"ICO0102", 0}, /* Intel */ 205 /* Add new here */ 206 {"", 0}, /* User Specified */ 207 {"", 0} /* Terminator */ 208 }; 209 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl); 210 211 static void tpm_tis_pnp_remove(struct pnp_dev *dev) 212 { 213 struct tpm_chip *chip = pnp_get_drvdata(dev); 214 215 tpm_chip_unregister(chip); 216 tpm_tis_remove(chip); 217 } 218 219 static struct pnp_driver tis_pnp_driver = { 220 .name = "tpm_tis", 221 .id_table = tpm_pnp_tbl, 222 .probe = tpm_tis_pnp_init, 223 .remove = tpm_tis_pnp_remove, 224 .driver = { 225 .pm = &tpm_tis_pm, 226 }, 227 }; 228 229 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2 230 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id, 231 sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444); 232 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe"); 233 234 #ifdef CONFIG_ACPI 235 static int tpm_check_resource(struct acpi_resource *ares, void *data) 236 { 237 struct tpm_info *tpm_info = (struct tpm_info *) data; 238 struct resource res; 239 240 if (acpi_dev_resource_interrupt(ares, 0, &res)) 241 tpm_info->irq = res.start; 242 else if (acpi_dev_resource_memory(ares, &res)) { 243 tpm_info->res = res; 244 tpm_info->res.name = NULL; 245 } 246 247 return 1; 248 } 249 250 static int tpm_tis_acpi_init(struct acpi_device *acpi_dev) 251 { 252 struct acpi_table_tpm2 *tbl; 253 acpi_status st; 254 struct list_head resources; 255 struct tpm_info tpm_info = {}; 256 int ret; 257 258 st = acpi_get_table(ACPI_SIG_TPM2, 1, 259 (struct acpi_table_header **) &tbl); 260 if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) { 261 dev_err(&acpi_dev->dev, 262 FW_BUG "failed to get TPM2 ACPI table\n"); 263 return -EINVAL; 264 } 265 266 if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED) 267 return -ENODEV; 268 269 INIT_LIST_HEAD(&resources); 270 tpm_info.irq = -1; 271 ret = acpi_dev_get_resources(acpi_dev, &resources, tpm_check_resource, 272 &tpm_info); 273 if (ret < 0) 274 return ret; 275 276 acpi_dev_free_resource_list(&resources); 277 278 if (resource_type(&tpm_info.res) != IORESOURCE_MEM) { 279 dev_err(&acpi_dev->dev, 280 FW_BUG "TPM2 ACPI table does not define a memory resource\n"); 281 return -EINVAL; 282 } 283 284 if (is_itpm(acpi_dev)) 285 itpm = true; 286 287 return tpm_tis_init(&acpi_dev->dev, &tpm_info, acpi_dev->handle); 288 } 289 290 static int tpm_tis_acpi_remove(struct acpi_device *dev) 291 { 292 struct tpm_chip *chip = dev_get_drvdata(&dev->dev); 293 294 tpm_chip_unregister(chip); 295 tpm_tis_remove(chip); 296 297 return 0; 298 } 299 300 static struct acpi_device_id tpm_acpi_tbl[] = { 301 {"MSFT0101", 0}, /* TPM 2.0 */ 302 /* Add new here */ 303 {"", 0}, /* User Specified */ 304 {"", 0} /* Terminator */ 305 }; 306 MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl); 307 308 static struct acpi_driver tis_acpi_driver = { 309 .name = "tpm_tis", 310 .ids = tpm_acpi_tbl, 311 .ops = { 312 .add = tpm_tis_acpi_init, 313 .remove = tpm_tis_acpi_remove, 314 }, 315 .drv = { 316 .pm = &tpm_tis_pm, 317 }, 318 }; 319 #endif 320 321 static struct platform_device *force_pdev; 322 323 static int tpm_tis_plat_probe(struct platform_device *pdev) 324 { 325 struct tpm_info tpm_info = {}; 326 struct resource *res; 327 328 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 329 if (res == NULL) { 330 dev_err(&pdev->dev, "no memory resource defined\n"); 331 return -ENODEV; 332 } 333 tpm_info.res = *res; 334 335 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 336 if (res) { 337 tpm_info.irq = res->start; 338 } else { 339 if (pdev == force_pdev) 340 tpm_info.irq = -1; 341 else 342 /* When forcing auto probe the IRQ */ 343 tpm_info.irq = 0; 344 } 345 346 return tpm_tis_init(&pdev->dev, &tpm_info, NULL); 347 } 348 349 static int tpm_tis_plat_remove(struct platform_device *pdev) 350 { 351 struct tpm_chip *chip = dev_get_drvdata(&pdev->dev); 352 353 tpm_chip_unregister(chip); 354 tpm_tis_remove(chip); 355 356 return 0; 357 } 358 359 #ifdef CONFIG_OF 360 static const struct of_device_id tis_of_platform_match[] = { 361 {.compatible = "tcg,tpm-tis-mmio"}, 362 {}, 363 }; 364 MODULE_DEVICE_TABLE(of, tis_of_platform_match); 365 #endif 366 367 static struct platform_driver tis_drv = { 368 .probe = tpm_tis_plat_probe, 369 .remove = tpm_tis_plat_remove, 370 .driver = { 371 .name = "tpm_tis", 372 .pm = &tpm_tis_pm, 373 .of_match_table = of_match_ptr(tis_of_platform_match), 374 }, 375 }; 376 377 static int tpm_tis_force_device(void) 378 { 379 struct platform_device *pdev; 380 static const struct resource x86_resources[] = { 381 { 382 .start = 0xFED40000, 383 .end = 0xFED40000 + TIS_MEM_LEN - 1, 384 .flags = IORESOURCE_MEM, 385 }, 386 }; 387 388 if (!force) 389 return 0; 390 391 /* The driver core will match the name tpm_tis of the device to 392 * the tpm_tis platform driver and complete the setup via 393 * tpm_tis_plat_probe 394 */ 395 pdev = platform_device_register_simple("tpm_tis", -1, x86_resources, 396 ARRAY_SIZE(x86_resources)); 397 if (IS_ERR(pdev)) 398 return PTR_ERR(pdev); 399 force_pdev = pdev; 400 401 return 0; 402 } 403 404 static int __init init_tis(void) 405 { 406 int rc; 407 408 rc = tpm_tis_force_device(); 409 if (rc) 410 goto err_force; 411 412 rc = platform_driver_register(&tis_drv); 413 if (rc) 414 goto err_platform; 415 416 #ifdef CONFIG_ACPI 417 rc = acpi_bus_register_driver(&tis_acpi_driver); 418 if (rc) 419 goto err_acpi; 420 #endif 421 422 if (IS_ENABLED(CONFIG_PNP)) { 423 rc = pnp_register_driver(&tis_pnp_driver); 424 if (rc) 425 goto err_pnp; 426 } 427 428 return 0; 429 430 err_pnp: 431 #ifdef CONFIG_ACPI 432 acpi_bus_unregister_driver(&tis_acpi_driver); 433 err_acpi: 434 #endif 435 platform_driver_unregister(&tis_drv); 436 err_platform: 437 if (force_pdev) 438 platform_device_unregister(force_pdev); 439 err_force: 440 return rc; 441 } 442 443 static void __exit cleanup_tis(void) 444 { 445 pnp_unregister_driver(&tis_pnp_driver); 446 #ifdef CONFIG_ACPI 447 acpi_bus_unregister_driver(&tis_acpi_driver); 448 #endif 449 platform_driver_unregister(&tis_drv); 450 451 if (force_pdev) 452 platform_device_unregister(force_pdev); 453 } 454 455 module_init(init_tis); 456 module_exit(cleanup_tis); 457 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); 458 MODULE_DESCRIPTION("TPM Driver"); 459 MODULE_VERSION("2.0"); 460 MODULE_LICENSE("GPL"); 461