drivers/char/tpm/tpm_tis.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2005, 2006 IBM Corporation
   4  * Copyright (C) 2014, 2015 Intel Corporation
   5  *
   6  * Authors:
   7  * Leendert van Doorn <[email protected]>
   8  * Kylene Hall <[email protected]>
   9  *
  10  * Maintained by: <[email protected]>
  11  *
  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.
  17  */
  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>
  27 #include <linux/of.h>
  28 #include <linux/of_device.h>
  29 #include <linux/kernel.h>
  30 #include <linux/dmi.h>
  31 #include "tpm.h"
  32 #include "tpm_tis_core.h"
  33
  34 struct tpm_info {
  35         struct resource res;
  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;
  41 };
  42
  43 struct tpm_tis_tcg_phy {
  44         struct tpm_tis_data priv;
  45         void __iomem *iobase;
  46 };
  47
  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
  53 #ifdef CONFIG_PREEMPT_RT
  54 /*
  55  * Flush previous write operations with a dummy read operation to the
  56  * TPM MMIO base address.
  57  */
  58 static inline void tpm_tis_flush(void __iomem *iobase)
  59 {
  60         ioread8(iobase + TPM_ACCESS(0));
  61 }
  62 #else
  63 #define tpm_tis_flush(iobase) do { } while (0)
  64 #endif
  65
  66 /*
  67  * Write a byte word to the TPM MMIO address, and flush the write queue.
  68  * The flush ensures that the data is sent immediately over the bus and not
  69  * aggregated with further requests and transferred later in a batch. The large
  70  * write requests can lead to unwanted latency spikes by blocking the CPU until
  71  * the complete batch has been transferred.
  72  */
  73 static inline void tpm_tis_iowrite8(u8 b, void __iomem *iobase, u32 addr)
  74 {
  75         iowrite8(b, iobase + addr);
  76         tpm_tis_flush(iobase);
  77 }
  78
  79 /*
  80  * Write a 32-bit word to the TPM MMIO address, and flush the write queue.
  81  * The flush ensures that the data is sent immediately over the bus and not
  82  * aggregated with further requests and transferred later in a batch. The large
  83  * write requests can lead to unwanted latency spikes by blocking the CPU until
  84  * the complete batch has been transferred.
  85  */
  86 static inline void tpm_tis_iowrite32(u32 b, void __iomem *iobase, u32 addr)
  87 {
  88         iowrite32(b, iobase + addr);
  89         tpm_tis_flush(iobase);
  90 }
  91
  92 static int interrupts = -1;
  93 module_param(interrupts, int, 0444);
  94 MODULE_PARM_DESC(interrupts, "Enable interrupts");
  95
  96 static bool itpm;
  97 module_param(itpm, bool, 0444);
  98 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
  99
 100 static bool force;
 101 #ifdef CONFIG_X86
 102 module_param(force, bool, 0444);
 103 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
 104 #endif
 105
 106 static int tpm_tis_disable_irq(const struct dmi_system_id *d)
 107 {
 108         if (interrupts == -1) {
 109                 pr_notice("tpm_tis: %s detected: disabling interrupts.\n", d->ident);
 110                 interrupts = 0;
 111         }
 112
 113         return 0;
 114 }
 115
 116 static const struct dmi_system_id tpm_tis_dmi_table[] = {
 117         {
 118                 .callback = tpm_tis_disable_irq,
 119                 .ident = "ThinkPad T490s",
 120                 .matches = {
 121                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 122                         DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T490s"),
 123                 },
 124         },
 125         {}
 126 };
 127
 128 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
 129 static int has_hid(struct acpi_device *dev, const char *hid)
 130 {
 131         struct acpi_hardware_id *id;
 132
 133         list_for_each_entry(id, &dev->pnp.ids, list)
 134                 if (!strcmp(hid, id->id))
 135                         return 1;
 136
 137         return 0;
 138 }
 139
 140 static inline int is_itpm(struct acpi_device *dev)
 141 {
 142         if (!dev)
 143                 return 0;
 144         return has_hid(dev, "INTC0102");
 145 }
 146 #else
 147 static inline int is_itpm(struct acpi_device *dev)
 148 {
 149         return 0;
 150 }
 151 #endif
 152
 153 #if defined(CONFIG_ACPI)
 154 #define DEVICE_IS_TPM2 1
 155
 156 static const struct acpi_device_id tpm_acpi_tbl[] = {
 157         {"MSFT0101", DEVICE_IS_TPM2},
 158         {},
 159 };
 160 MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl);
 161
 162 static int check_acpi_tpm2(struct device *dev)
 163 {
 164         const struct acpi_device_id *aid = acpi_match_device(tpm_acpi_tbl, dev);
 165         struct acpi_table_tpm2 *tbl;
 166         acpi_status st;
 167         int ret = 0;
 168
 169         if (!aid || aid->driver_data != DEVICE_IS_TPM2)
 170                 return 0;
 171
 172         /* If the ACPI TPM2 signature is matched then a global ACPI_SIG_TPM2
 173          * table is mandatory
 174          */
 175         st = acpi_get_table(ACPI_SIG_TPM2, 1, (struct acpi_table_header **)&tbl);
 176         if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) {
 177                 dev_err(dev, FW_BUG "failed to get TPM2 ACPI table\n");
 178                 return -EINVAL;
 179         }
 180
 181         /* The tpm2_crb driver handles this device */
 182         if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED)
 183                 ret = -ENODEV;
 184
 185         acpi_put_table((struct acpi_table_header *)tbl);
 186         return ret;
 187 }
 188 #else
 189 static int check_acpi_tpm2(struct device *dev)
 190 {
 191         return 0;
 192 }
 193 #endif
 194
 195 static int tpm_tcg_read_bytes(struct tpm_tis_data *data, u32 addr, u16 len,
 196                               u8 *result, enum tpm_tis_io_mode io_mode)
 197 {
 198         struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
 199         __le16 result_le16;
 200         __le32 result_le32;
 201
 202         switch (io_mode) {
 203         case TPM_TIS_PHYS_8:
 204                 while (len--)
 205                         *result++ = ioread8(phy->iobase + addr);
 206                 break;
 207         case TPM_TIS_PHYS_16:
 208                 result_le16 = cpu_to_le16(ioread16(phy->iobase + addr));
 209                 memcpy(result, &result_le16, sizeof(u16));
 210                 break;
 211         case TPM_TIS_PHYS_32:
 212                 result_le32 = cpu_to_le32(ioread32(phy->iobase + addr));
 213                 memcpy(result, &result_le32, sizeof(u32));
 214                 break;
 215         }
 216
 217         return 0;
 218 }
 219
 220 static int tpm_tcg_write_bytes(struct tpm_tis_data *data, u32 addr, u16 len,
 221                                const u8 *value, enum tpm_tis_io_mode io_mode)
 222 {
 223         struct tpm_tis_tcg_phy *phy = to_tpm_tis_tcg_phy(data);
 224
 225         switch (io_mode) {
 226         case TPM_TIS_PHYS_8:
 227                 while (len--)
 228                         tpm_tis_iowrite8(*value++, phy->iobase, addr);
 229                 break;
 230         case TPM_TIS_PHYS_16:
 231                 return -EINVAL;
 232         case TPM_TIS_PHYS_32:
 233                 tpm_tis_iowrite32(le32_to_cpu(*((__le32 *)value)), phy->iobase, addr);
 234                 break;
 235         }
 236
 237         return 0;
 238 }
 239
 240 static const struct tpm_tis_phy_ops tpm_tcg = {
 241         .read_bytes = tpm_tcg_read_bytes,
 242         .write_bytes = tpm_tcg_write_bytes,
 243 };
 244
 245 static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info)
 246 {
 247         struct tpm_tis_tcg_phy *phy;
 248         int irq = -1;
 249         int rc;
 250
 251         dmi_check_system(tpm_tis_dmi_table);
 252
 253         rc = check_acpi_tpm2(dev);
 254         if (rc)
 255                 return rc;
 256
 257         phy = devm_kzalloc(dev, sizeof(struct tpm_tis_tcg_phy), GFP_KERNEL);
 258         if (phy == NULL)
 259                 return -ENOMEM;
 260
 261         phy->iobase = devm_ioremap_resource(dev, &tpm_info->res);
 262         if (IS_ERR(phy->iobase))
 263                 return PTR_ERR(phy->iobase);
 264
 265         if (interrupts)
 266                 irq = tpm_info->irq;
 267
 268         if (itpm || is_itpm(ACPI_COMPANION(dev)))
 269                 set_bit(TPM_TIS_ITPM_WORKAROUND, &phy->priv.flags);
 270
 271         return tpm_tis_core_init(dev, &phy->priv, irq, &tpm_tcg,
 272                                  ACPI_HANDLE(dev));
 273 }
 274
 275 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
 276
 277 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 278                             const struct pnp_device_id *pnp_id)
 279 {
 280         struct tpm_info tpm_info = {};
 281         struct resource *res;
 282
 283         res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0);
 284         if (!res)
 285                 return -ENODEV;
 286         tpm_info.res = *res;
 287
 288         if (pnp_irq_valid(pnp_dev, 0))
 289                 tpm_info.irq = pnp_irq(pnp_dev, 0);
 290         else
 291                 tpm_info.irq = -1;
 292
 293         return tpm_tis_init(&pnp_dev->dev, &tpm_info);
 294 }
 295
 296 /*
 297  * There is a known bug caused by 93e1b7d42e1e ("[PATCH] tpm: add HID module
 298  * parameter"). This commit added IFX0102 device ID, which is also used by
 299  * tpm_infineon but ignored to add quirks to probe which driver ought to be
 300  * used.
 301  */
 302
 303 static struct pnp_device_id tpm_pnp_tbl[] = {
 304         {"PNP0C31", 0},         /* TPM */
 305         {"ATM1200", 0},         /* Atmel */
 306         {"IFX0102", 0},         /* Infineon */
 307         {"BCM0101", 0},         /* Broadcom */
 308         {"BCM0102", 0},         /* Broadcom */
 309         {"NSC1200", 0},         /* National */
 310         {"ICO0102", 0},         /* Intel */
 311         /* Add new here */
 312         {"", 0},                /* User Specified */
 313         {"", 0}                 /* Terminator */
 314 };
 315 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 316
 317 static void tpm_tis_pnp_remove(struct pnp_dev *dev)
 318 {
 319         struct tpm_chip *chip = pnp_get_drvdata(dev);
 320
 321         tpm_chip_unregister(chip);
 322         tpm_tis_remove(chip);
 323 }
 324
 325 static struct pnp_driver tis_pnp_driver = {
 326         .name = "tpm_tis",
 327         .id_table = tpm_pnp_tbl,
 328         .probe = tpm_tis_pnp_init,
 329         .remove = tpm_tis_pnp_remove,
 330         .driver = {
 331                 .pm = &tpm_tis_pm,
 332         },
 333 };
 334
 335 #define TIS_HID_USR_IDX (ARRAY_SIZE(tpm_pnp_tbl) - 2)
 336 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
 337                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 338 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 339
 340 static struct platform_device *force_pdev;
 341
 342 static int tpm_tis_plat_probe(struct platform_device *pdev)
 343 {
 344         struct tpm_info tpm_info = {};
 345         struct resource *res;
 346
 347         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 348         if (res == NULL) {
 349                 dev_err(&pdev->dev, "no memory resource defined\n");
 350                 return -ENODEV;
 351         }
 352         tpm_info.res = *res;
 353
 354         tpm_info.irq = platform_get_irq_optional(pdev, 0);
 355         if (tpm_info.irq <= 0) {
 356                 if (pdev != force_pdev)
 357                         tpm_info.irq = -1;
 358                 else
 359                         /* When forcing auto probe the IRQ */
 360                         tpm_info.irq = 0;
 361         }
 362
 363         return tpm_tis_init(&pdev->dev, &tpm_info);
 364 }
 365
 366 static void tpm_tis_plat_remove(struct platform_device *pdev)
 367 {
 368         struct tpm_chip *chip = dev_get_drvdata(&pdev->dev);
 369
 370         tpm_chip_unregister(chip);
 371         tpm_tis_remove(chip);
 372 }
 373
 374 #ifdef CONFIG_OF
 375 static const struct of_device_id tis_of_platform_match[] = {
 376         {.compatible = "tcg,tpm-tis-mmio"},
 377         {},
 378 };
 379 MODULE_DEVICE_TABLE(of, tis_of_platform_match);
 380 #endif
 381
 382 static struct platform_driver tis_drv = {
 383         .probe = tpm_tis_plat_probe,
 384         .remove_new = tpm_tis_plat_remove,
 385         .driver = {
 386                 .name           = "tpm_tis",
 387                 .pm             = &tpm_tis_pm,
 388                 .of_match_table = of_match_ptr(tis_of_platform_match),
 389                 .acpi_match_table = ACPI_PTR(tpm_acpi_tbl),
 390         },
 391 };
 392
 393 static int tpm_tis_force_device(void)
 394 {
 395         struct platform_device *pdev;
 396         static const struct resource x86_resources[] = {
 397                 DEFINE_RES_MEM(0xFED40000, TIS_MEM_LEN)
 398         };
 399
 400         if (!force)
 401                 return 0;
 402
 403         /* The driver core will match the name tpm_tis of the device to
 404          * the tpm_tis platform driver and complete the setup via
 405          * tpm_tis_plat_probe
 406          */
 407         pdev = platform_device_register_simple("tpm_tis", -1, x86_resources,
 408                                                ARRAY_SIZE(x86_resources));
 409         if (IS_ERR(pdev))
 410                 return PTR_ERR(pdev);
 411         force_pdev = pdev;
 412
 413         return 0;
 414 }
 415
 416 static int __init init_tis(void)
 417 {
 418         int rc;
 419
 420         rc = tpm_tis_force_device();
 421         if (rc)
 422                 goto err_force;
 423
 424         rc = platform_driver_register(&tis_drv);
 425         if (rc)
 426                 goto err_platform;
 427
 428
 429         if (IS_ENABLED(CONFIG_PNP)) {
 430                 rc = pnp_register_driver(&tis_pnp_driver);
 431                 if (rc)
 432                         goto err_pnp;
 433         }
 434
 435         return 0;
 436
 437 err_pnp:
 438         platform_driver_unregister(&tis_drv);
 439 err_platform:
 440         if (force_pdev)
 441                 platform_device_unregister(force_pdev);
 442 err_force:
 443         return rc;
 444 }
 445
 446 static void __exit cleanup_tis(void)
 447 {
 448         pnp_unregister_driver(&tis_pnp_driver);
 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 ([email protected])");
 458 MODULE_DESCRIPTION("TPM Driver");
 459 MODULE_VERSION("2.0");
 460 MODULE_LICENSE("GPL");