drivers/char/tpm/tpm_tis.c

   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 "tpm.h"
  32
  33 enum tis_access {
  34         TPM_ACCESS_VALID = 0x80,
  35         TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
  36         TPM_ACCESS_REQUEST_PENDING = 0x04,
  37         TPM_ACCESS_REQUEST_USE = 0x02,
  38 };
  39
  40 enum tis_status {
  41         TPM_STS_VALID = 0x80,
  42         TPM_STS_COMMAND_READY = 0x40,
  43         TPM_STS_GO = 0x20,
  44         TPM_STS_DATA_AVAIL = 0x10,
  45         TPM_STS_DATA_EXPECT = 0x08,
  46 };
  47
  48 enum tis_int_flags {
  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,
  59 };
  60
  61 enum tis_defaults {
  62         TIS_MEM_LEN = 0x5000,
  63         TIS_SHORT_TIMEOUT = 750,        /* ms */
  64         TIS_LONG_TIMEOUT = 2000,        /* 2 sec */
  65 };
  66
  67 struct tpm_info {
  68         struct resource res;
  69         /* irq > 0 means: use irq $irq;
  70          * irq = 0 means: autoprobe for an irq;
  71          * irq = -1 means: no irq support
  72          */
  73         int irq;
  74 };
  75
  76 /* Some timeout values are needed before it is known whether the chip is
  77  * TPM 1.0 or TPM 2.0.
  78  */
  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)
  83
  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))
  92
  93 #define TPM_DID_VID(l)                  (0x0F00 | ((l) << 12))
  94 #define TPM_RID(l)                      (0x0F04 | ((l) << 12))
  95
  96 struct priv_data {
  97         void __iomem *iobase;
  98         u16 manufacturer_id;
  99         int irq;
 100         bool irq_tested;
 101         wait_queue_head_t int_queue;
 102         wait_queue_head_t read_queue;
 103 };
 104
 105 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
 106 static int has_hid(struct acpi_device *dev, const char *hid)
 107 {
 108         struct acpi_hardware_id *id;
 109
 110         list_for_each_entry(id, &dev->pnp.ids, list)
 111                 if (!strcmp(hid, id->id))
 112                         return 1;
 113
 114         return 0;
 115 }
 116
 117 static inline int is_itpm(struct acpi_device *dev)
 118 {
 119         return has_hid(dev, "INTC0102");
 120 }
 121 #else
 122 static inline int is_itpm(struct acpi_device *dev)
 123 {
 124         return 0;
 125 }
 126 #endif
 127
 128 /* Before we attempt to access the TPM we must see that the valid bit is set.
 129  * The specification says that this bit is 0 at reset and remains 0 until the
 130  * 'TPM has gone through its self test and initialization and has established
 131  * correct values in the other bits.' */
 132 static int wait_startup(struct tpm_chip *chip, int l)
 133 {
 134         struct priv_data *priv = chip->vendor.priv;
 135         unsigned long stop = jiffies + chip->vendor.timeout_a;
 136         do {
 137                 if (ioread8(priv->iobase + TPM_ACCESS(l)) &
 138                     TPM_ACCESS_VALID)
 139                         return 0;
 140                 msleep(TPM_TIMEOUT);
 141         } while (time_before(jiffies, stop));
 142         return -1;
 143 }
 144
 145 static int check_locality(struct tpm_chip *chip, int l)
 146 {
 147         struct priv_data *priv = chip->vendor.priv;
 148
 149         if ((ioread8(priv->iobase + TPM_ACCESS(l)) &
 150              (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
 151             (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
 152                 return chip->vendor.locality = l;
 153
 154         return -1;
 155 }
 156
 157 static void release_locality(struct tpm_chip *chip, int l, int force)
 158 {
 159         struct priv_data *priv = chip->vendor.priv;
 160
 161         if (force || (ioread8(priv->iobase + TPM_ACCESS(l)) &
 162                       (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
 163             (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))
 164                 iowrite8(TPM_ACCESS_ACTIVE_LOCALITY,
 165                          priv->iobase + TPM_ACCESS(l));
 166 }
 167
 168 static int request_locality(struct tpm_chip *chip, int l)
 169 {
 170         struct priv_data *priv = chip->vendor.priv;
 171         unsigned long stop, timeout;
 172         long rc;
 173
 174         if (check_locality(chip, l) >= 0)
 175                 return l;
 176
 177         iowrite8(TPM_ACCESS_REQUEST_USE,
 178                  priv->iobase + TPM_ACCESS(l));
 179
 180         stop = jiffies + chip->vendor.timeout_a;
 181
 182         if (chip->flags & TPM_CHIP_FLAG_IRQ) {
 183 again:
 184                 timeout = stop - jiffies;
 185                 if ((long)timeout <= 0)
 186                         return -1;
 187                 rc = wait_event_interruptible_timeout(priv->int_queue,
 188                                                       (check_locality
 189                                                        (chip, l) >= 0),
 190                                                       timeout);
 191                 if (rc > 0)
 192                         return l;
 193                 if (rc == -ERESTARTSYS && freezing(current)) {
 194                         clear_thread_flag(TIF_SIGPENDING);
 195                         goto again;
 196                 }
 197         } else {
 198                 /* wait for burstcount */
 199                 do {
 200                         if (check_locality(chip, l) >= 0)
 201                                 return l;
 202                         msleep(TPM_TIMEOUT);
 203                 }
 204                 while (time_before(jiffies, stop));
 205         }
 206         return -1;
 207 }
 208
 209 static u8 tpm_tis_status(struct tpm_chip *chip)
 210 {
 211         struct priv_data *priv = chip->vendor.priv;
 212
 213         return ioread8(priv->iobase +
 214                        TPM_STS(chip->vendor.locality));
 215 }
 216
 217 static void tpm_tis_ready(struct tpm_chip *chip)
 218 {
 219         struct priv_data *priv = chip->vendor.priv;
 220
 221         /* this causes the current command to be aborted */
 222         iowrite8(TPM_STS_COMMAND_READY,
 223                  priv->iobase + TPM_STS(chip->vendor.locality));
 224 }
 225
 226 static int get_burstcount(struct tpm_chip *chip)
 227 {
 228         struct priv_data *priv = chip->vendor.priv;
 229         unsigned long stop;
 230         int burstcnt;
 231
 232         /* wait for burstcount */
 233         /* which timeout value, spec has 2 answers (c & d) */
 234         stop = jiffies + chip->vendor.timeout_d;
 235         do {
 236                 burstcnt = ioread8(priv->iobase +
 237                                    TPM_STS(chip->vendor.locality) + 1);
 238                 burstcnt += ioread8(priv->iobase +
 239                                     TPM_STS(chip->vendor.locality) +
 240                                     2) << 8;
 241                 if (burstcnt)
 242                         return burstcnt;
 243                 msleep(TPM_TIMEOUT);
 244         } while (time_before(jiffies, stop));
 245         return -EBUSY;
 246 }
 247
 248 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 249 {
 250         struct priv_data *priv = chip->vendor.priv;
 251         int size = 0, burstcnt;
 252         while (size < count &&
 253                wait_for_tpm_stat(chip,
 254                                  TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 255                                  chip->vendor.timeout_c,
 256                                  &priv->read_queue, true)
 257                == 0) {
 258                 burstcnt = get_burstcount(chip);
 259                 for (; burstcnt > 0 && size < count; burstcnt--)
 260                         buf[size++] = ioread8(priv->iobase +
 261                                               TPM_DATA_FIFO(chip->vendor.
 262                                                             locality));
 263         }
 264         return size;
 265 }
 266
 267 static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 268 {
 269         struct priv_data *priv = chip->vendor.priv;
 270         int size = 0;
 271         int expected, status;
 272
 273         if (count < TPM_HEADER_SIZE) {
 274                 size = -EIO;
 275                 goto out;
 276         }
 277
 278         /* read first 10 bytes, including tag, paramsize, and result */
 279         if ((size =
 280              recv_data(chip, buf, TPM_HEADER_SIZE)) < TPM_HEADER_SIZE) {
 281                 dev_err(&chip->dev, "Unable to read header\n");
 282                 goto out;
 283         }
 284
 285         expected = be32_to_cpu(*(__be32 *) (buf + 2));
 286         if (expected > count) {
 287                 size = -EIO;
 288                 goto out;
 289         }
 290
 291         if ((size +=
 292              recv_data(chip, &buf[TPM_HEADER_SIZE],
 293                        expected - TPM_HEADER_SIZE)) < expected) {
 294                 dev_err(&chip->dev, "Unable to read remainder of result\n");
 295                 size = -ETIME;
 296                 goto out;
 297         }
 298
 299         wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
 300                           &priv->int_queue, false);
 301         status = tpm_tis_status(chip);
 302         if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
 303                 dev_err(&chip->dev, "Error left over data\n");
 304                 size = -EIO;
 305                 goto out;
 306         }
 307
 308 out:
 309         tpm_tis_ready(chip);
 310         release_locality(chip, chip->vendor.locality, 0);
 311         return size;
 312 }
 313
 314 static bool itpm;
 315 module_param(itpm, bool, 0444);
 316 MODULE_PARM_DESC(itpm, "Force iTPM workarounds (found on some Lenovo laptops)");
 317
 318 /*
 319  * If interrupts are used (signaled by an irq set in the vendor structure)
 320  * tpm.c can skip polling for the data to be available as the interrupt is
 321  * waited for here
 322  */
 323 static int tpm_tis_send_data(struct tpm_chip *chip, u8 *buf, size_t len)
 324 {
 325         struct priv_data *priv = chip->vendor.priv;
 326         int rc, status, burstcnt;
 327         size_t count = 0;
 328
 329         if (request_locality(chip, 0) < 0)
 330                 return -EBUSY;
 331
 332         status = tpm_tis_status(chip);
 333         if ((status & TPM_STS_COMMAND_READY) == 0) {
 334                 tpm_tis_ready(chip);
 335                 if (wait_for_tpm_stat
 336                     (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
 337                      &priv->int_queue, false) < 0) {
 338                         rc = -ETIME;
 339                         goto out_err;
 340                 }
 341         }
 342
 343         while (count < len - 1) {
 344                 burstcnt = get_burstcount(chip);
 345                 for (; burstcnt > 0 && count < len - 1; burstcnt--) {
 346                         iowrite8(buf[count], priv->iobase +
 347                                  TPM_DATA_FIFO(chip->vendor.locality));
 348                         count++;
 349                 }
 350
 351                 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
 352                                   &priv->int_queue, false);
 353                 status = tpm_tis_status(chip);
 354                 if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
 355                         rc = -EIO;
 356                         goto out_err;
 357                 }
 358         }
 359
 360         /* write last byte */
 361         iowrite8(buf[count],
 362                  priv->iobase + TPM_DATA_FIFO(chip->vendor.locality));
 363         wait_for_tpm_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c,
 364                           &priv->int_queue, false);
 365         status = tpm_tis_status(chip);
 366         if ((status & TPM_STS_DATA_EXPECT) != 0) {
 367                 rc = -EIO;
 368                 goto out_err;
 369         }
 370
 371         return 0;
 372
 373 out_err:
 374         tpm_tis_ready(chip);
 375         release_locality(chip, chip->vendor.locality, 0);
 376         return rc;
 377 }
 378
 379 static void disable_interrupts(struct tpm_chip *chip)
 380 {
 381         struct priv_data *priv = chip->vendor.priv;
 382         u32 intmask;
 383
 384         intmask =
 385             ioread32(priv->iobase +
 386                      TPM_INT_ENABLE(chip->vendor.locality));
 387         intmask &= ~TPM_GLOBAL_INT_ENABLE;
 388         iowrite32(intmask,
 389                   priv->iobase + TPM_INT_ENABLE(chip->vendor.locality));
 390         devm_free_irq(&chip->dev, priv->irq, chip);
 391         priv->irq = 0;
 392         chip->flags &= ~TPM_CHIP_FLAG_IRQ;
 393 }
 394
 395 /*
 396  * If interrupts are used (signaled by an irq set in the vendor structure)
 397  * tpm.c can skip polling for the data to be available as the interrupt is
 398  * waited for here
 399  */
 400 static int tpm_tis_send_main(struct tpm_chip *chip, u8 *buf, size_t len)
 401 {
 402         struct priv_data *priv = chip->vendor.priv;
 403         int rc;
 404         u32 ordinal;
 405         unsigned long dur;
 406
 407         rc = tpm_tis_send_data(chip, buf, len);
 408         if (rc < 0)
 409                 return rc;
 410
 411         /* go and do it */
 412         iowrite8(TPM_STS_GO,
 413                  priv->iobase + TPM_STS(chip->vendor.locality));
 414
 415         if (chip->flags & TPM_CHIP_FLAG_IRQ) {
 416                 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
 417
 418                 if (chip->flags & TPM_CHIP_FLAG_TPM2)
 419                         dur = tpm2_calc_ordinal_duration(chip, ordinal);
 420                 else
 421                         dur = tpm_calc_ordinal_duration(chip, ordinal);
 422
 423                 if (wait_for_tpm_stat
 424                     (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID, dur,
 425                      &priv->read_queue, false) < 0) {
 426                         rc = -ETIME;
 427                         goto out_err;
 428                 }
 429         }
 430         return len;
 431 out_err:
 432         tpm_tis_ready(chip);
 433         release_locality(chip, chip->vendor.locality, 0);
 434         return rc;
 435 }
 436
 437 static int tpm_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
 438 {
 439         int rc, irq;
 440         struct priv_data *priv = chip->vendor.priv;
 441
 442         if (!(chip->flags & TPM_CHIP_FLAG_IRQ) || priv->irq_tested)
 443                 return tpm_tis_send_main(chip, buf, len);
 444
 445         /* Verify receipt of the expected IRQ */
 446         irq = priv->irq;
 447         priv->irq = 0;
 448         chip->flags &= ~TPM_CHIP_FLAG_IRQ;
 449         rc = tpm_tis_send_main(chip, buf, len);
 450         priv->irq = irq;
 451         chip->flags |= TPM_CHIP_FLAG_IRQ;
 452         if (!priv->irq_tested)
 453                 msleep(1);
 454         if (!priv->irq_tested)
 455                 disable_interrupts(chip);
 456         priv->irq_tested = true;
 457         return rc;
 458 }
 459
 460 struct tis_vendor_timeout_override {
 461         u32 did_vid;
 462         unsigned long timeout_us[4];
 463 };
 464
 465 static const struct tis_vendor_timeout_override vendor_timeout_overrides[] = {
 466         /* Atmel 3204 */
 467         { 0x32041114, { (TIS_SHORT_TIMEOUT*1000), (TIS_LONG_TIMEOUT*1000),
 468                         (TIS_SHORT_TIMEOUT*1000), (TIS_SHORT_TIMEOUT*1000) } },
 469 };
 470
 471 static bool tpm_tis_update_timeouts(struct tpm_chip *chip,
 472                                     unsigned long *timeout_cap)
 473 {
 474         struct priv_data *priv = chip->vendor.priv;
 475         int i;
 476         u32 did_vid;
 477
 478         did_vid = ioread32(priv->iobase + TPM_DID_VID(0));
 479
 480         for (i = 0; i != ARRAY_SIZE(vendor_timeout_overrides); i++) {
 481                 if (vendor_timeout_overrides[i].did_vid != did_vid)
 482                         continue;
 483                 memcpy(timeout_cap, vendor_timeout_overrides[i].timeout_us,
 484                        sizeof(vendor_timeout_overrides[i].timeout_us));
 485                 return true;
 486         }
 487
 488         return false;
 489 }
 490
 491 /*
 492  * Early probing for iTPM with STS_DATA_EXPECT flaw.
 493  * Try sending command without itpm flag set and if that
 494  * fails, repeat with itpm flag set.
 495  */
 496 static int probe_itpm(struct tpm_chip *chip)
 497 {
 498         struct priv_data *priv = chip->vendor.priv;
 499         int rc = 0;
 500         u8 cmd_getticks[] = {
 501                 0x00, 0xc1, 0x00, 0x00, 0x00, 0x0a,
 502                 0x00, 0x00, 0x00, 0xf1
 503         };
 504         size_t len = sizeof(cmd_getticks);
 505         bool rem_itpm = itpm;
 506         u16 vendor = ioread16(priv->iobase + TPM_DID_VID(0));
 507
 508         /* probe only iTPMS */
 509         if (vendor != TPM_VID_INTEL)
 510                 return 0;
 511
 512         itpm = false;
 513
 514         rc = tpm_tis_send_data(chip, cmd_getticks, len);
 515         if (rc == 0)
 516                 goto out;
 517
 518         tpm_tis_ready(chip);
 519         release_locality(chip, chip->vendor.locality, 0);
 520
 521         itpm = true;
 522
 523         rc = tpm_tis_send_data(chip, cmd_getticks, len);
 524         if (rc == 0) {
 525                 dev_info(&chip->dev, "Detected an iTPM.\n");
 526                 rc = 1;
 527         } else
 528                 rc = -EFAULT;
 529
 530 out:
 531         itpm = rem_itpm;
 532         tpm_tis_ready(chip);
 533         release_locality(chip, chip->vendor.locality, 0);
 534
 535         return rc;
 536 }
 537
 538 static bool tpm_tis_req_canceled(struct tpm_chip *chip, u8 status)
 539 {
 540         struct priv_data *priv = chip->vendor.priv;
 541
 542         switch (priv->manufacturer_id) {
 543         case TPM_VID_WINBOND:
 544                 return ((status == TPM_STS_VALID) ||
 545                         (status == (TPM_STS_VALID | TPM_STS_COMMAND_READY)));
 546         case TPM_VID_STM:
 547                 return (status == (TPM_STS_VALID | TPM_STS_COMMAND_READY));
 548         default:
 549                 return (status == TPM_STS_COMMAND_READY);
 550         }
 551 }
 552
 553 static const struct tpm_class_ops tpm_tis = {
 554         .status = tpm_tis_status,
 555         .recv = tpm_tis_recv,
 556         .send = tpm_tis_send,
 557         .cancel = tpm_tis_ready,
 558         .update_timeouts = tpm_tis_update_timeouts,
 559         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 560         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 561         .req_canceled = tpm_tis_req_canceled,
 562 };
 563
 564 static irqreturn_t tis_int_handler(int dummy, void *dev_id)
 565 {
 566         struct tpm_chip *chip = dev_id;
 567         struct priv_data *priv = chip->vendor.priv;
 568         u32 interrupt;
 569         int i;
 570
 571         interrupt = ioread32(priv->iobase +
 572                              TPM_INT_STATUS(chip->vendor.locality));
 573
 574         if (interrupt == 0)
 575                 return IRQ_NONE;
 576
 577         ((struct priv_data *)chip->vendor.priv)->irq_tested = true;
 578         if (interrupt & TPM_INTF_DATA_AVAIL_INT)
 579                 wake_up_interruptible(&priv->read_queue);
 580         if (interrupt & TPM_INTF_LOCALITY_CHANGE_INT)
 581                 for (i = 0; i < 5; i++)
 582                         if (check_locality(chip, i) >= 0)
 583                                 break;
 584         if (interrupt &
 585             (TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT |
 586              TPM_INTF_CMD_READY_INT))
 587                 wake_up_interruptible(&priv->int_queue);
 588
 589         /* Clear interrupts handled with TPM_EOI */
 590         iowrite32(interrupt,
 591                   priv->iobase +
 592                   TPM_INT_STATUS(chip->vendor.locality));
 593         ioread32(priv->iobase + TPM_INT_STATUS(chip->vendor.locality));
 594         return IRQ_HANDLED;
 595 }
 596
 597 /* Register the IRQ and issue a command that will cause an interrupt. If an
 598  * irq is seen then leave the chip setup for IRQ operation, otherwise reverse
 599  * everything and leave in polling mode. Returns 0 on success.
 600  */
 601 static int tpm_tis_probe_irq_single(struct tpm_chip *chip, u32 intmask,
 602                                     int flags, int irq)
 603 {
 604         struct priv_data *priv = chip->vendor.priv;
 605         u8 original_int_vec;
 606
 607         if (devm_request_irq(&chip->dev, irq, tis_int_handler, flags,
 608                              dev_name(&chip->dev), chip) != 0) {
 609                 dev_info(&chip->dev, "Unable to request irq: %d for probe\n",
 610                          irq);
 611                 return -1;
 612         }
 613         priv->irq = irq;
 614
 615         original_int_vec = ioread8(priv->iobase +
 616                                    TPM_INT_VECTOR(chip->vendor.locality));
 617         iowrite8(irq,
 618                  priv->iobase + TPM_INT_VECTOR(chip->vendor.locality));
 619
 620         /* Clear all existing */
 621         iowrite32(ioread32(priv->iobase +
 622                            TPM_INT_STATUS(chip->vendor.locality)),
 623                   priv->iobase + TPM_INT_STATUS(chip->vendor.locality));
 624
 625         /* Turn on */
 626         iowrite32(intmask | TPM_GLOBAL_INT_ENABLE,
 627                   priv->iobase + TPM_INT_ENABLE(chip->vendor.locality));
 628
 629         priv->irq_tested = false;
 630
 631         /* Generate an interrupt by having the core call through to
 632          * tpm_tis_send
 633          */
 634         if (chip->flags & TPM_CHIP_FLAG_TPM2)
 635                 tpm2_gen_interrupt(chip);
 636         else
 637                 tpm_gen_interrupt(chip);
 638
 639         /* tpm_tis_send will either confirm the interrupt is working or it
 640          * will call disable_irq which undoes all of the above.
 641          */
 642         if (!(chip->flags & TPM_CHIP_FLAG_IRQ)) {
 643                 iowrite8(original_int_vec,
 644                          priv->iobase + TPM_INT_VECTOR(chip->vendor.locality));
 645                 return 1;
 646         }
 647
 648         return 0;
 649 }
 650
 651 /* Try to find the IRQ the TPM is using. This is for legacy x86 systems that
 652  * do not have ACPI/etc. We typically expect the interrupt to be declared if
 653  * present.
 654  */
 655 static void tpm_tis_probe_irq(struct tpm_chip *chip, u32 intmask)
 656 {
 657         struct priv_data *priv = chip->vendor.priv;
 658         u8 original_int_vec;
 659         int i;
 660
 661         original_int_vec = ioread8(priv->iobase +
 662                                    TPM_INT_VECTOR(chip->vendor.locality));
 663
 664         if (!original_int_vec) {
 665                 if (IS_ENABLED(CONFIG_X86))
 666                         for (i = 3; i <= 15; i++)
 667                                 if (!tpm_tis_probe_irq_single(chip, intmask, 0,
 668                                                               i))
 669                                         return;
 670         } else if (!tpm_tis_probe_irq_single(chip, intmask, 0,
 671                                              original_int_vec))
 672                 return;
 673 }
 674
 675 static bool interrupts = true;
 676 module_param(interrupts, bool, 0444);
 677 MODULE_PARM_DESC(interrupts, "Enable interrupts");
 678
 679 static void tpm_tis_remove(struct tpm_chip *chip)
 680 {
 681         struct priv_data *priv = chip->vendor.priv;
 682         void __iomem *reg = priv->iobase +
 683                 TPM_INT_ENABLE(chip->vendor.locality);
 684
 685         iowrite32(~TPM_GLOBAL_INT_ENABLE & ioread32(reg), reg);
 686         release_locality(chip, chip->vendor.locality, 1);
 687 }
 688
 689 static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
 690                         acpi_handle acpi_dev_handle)
 691 {
 692         u32 vendor, intfcaps, intmask;
 693         int rc, probe;
 694         struct tpm_chip *chip;
 695         struct priv_data *priv;
 696
 697         priv = devm_kzalloc(dev, sizeof(struct priv_data), GFP_KERNEL);
 698         if (priv == NULL)
 699                 return -ENOMEM;
 700
 701         chip = tpmm_chip_alloc(dev, &tpm_tis);
 702         if (IS_ERR(chip))
 703                 return PTR_ERR(chip);
 704
 705         chip->vendor.priv = priv;
 706 #ifdef CONFIG_ACPI
 707         chip->acpi_dev_handle = acpi_dev_handle;
 708 #endif
 709
 710         priv->iobase = devm_ioremap_resource(dev, &tpm_info->res);
 711         if (IS_ERR(priv->iobase))
 712                 return PTR_ERR(priv->iobase);
 713
 714         /* Maximum timeouts */
 715         chip->vendor.timeout_a = TIS_TIMEOUT_A_MAX;
 716         chip->vendor.timeout_b = TIS_TIMEOUT_B_MAX;
 717         chip->vendor.timeout_c = TIS_TIMEOUT_C_MAX;
 718         chip->vendor.timeout_d = TIS_TIMEOUT_D_MAX;
 719
 720         if (wait_startup(chip, 0) != 0) {
 721                 rc = -ENODEV;
 722                 goto out_err;
 723         }
 724
 725         /* Take control of the TPM's interrupt hardware and shut it off */
 726         intmask = ioread32(priv->iobase +
 727                            TPM_INT_ENABLE(chip->vendor.locality));
 728         intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
 729                    TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
 730         intmask &= ~TPM_GLOBAL_INT_ENABLE;
 731         iowrite32(intmask,
 732                   priv->iobase + TPM_INT_ENABLE(chip->vendor.locality));
 733
 734         if (request_locality(chip, 0) != 0) {
 735                 rc = -ENODEV;
 736                 goto out_err;
 737         }
 738
 739         rc = tpm2_probe(chip);
 740         if (rc)
 741                 goto out_err;
 742
 743         vendor = ioread32(priv->iobase + TPM_DID_VID(0));
 744         priv->manufacturer_id = vendor;
 745
 746         dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n",
 747                  (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2",
 748                  vendor >> 16, ioread8(priv->iobase + TPM_RID(0)));
 749
 750         if (!itpm) {
 751                 probe = probe_itpm(chip);
 752                 if (probe < 0) {
 753                         rc = -ENODEV;
 754                         goto out_err;
 755                 }
 756                 itpm = !!probe;
 757         }
 758
 759         if (itpm)
 760                 dev_info(dev, "Intel iTPM workaround enabled\n");
 761
 762
 763         /* Figure out the capabilities */
 764         intfcaps =
 765             ioread32(priv->iobase +
 766                      TPM_INTF_CAPS(chip->vendor.locality));
 767         dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
 768                 intfcaps);
 769         if (intfcaps & TPM_INTF_BURST_COUNT_STATIC)
 770                 dev_dbg(dev, "\tBurst Count Static\n");
 771         if (intfcaps & TPM_INTF_CMD_READY_INT)
 772                 dev_dbg(dev, "\tCommand Ready Int Support\n");
 773         if (intfcaps & TPM_INTF_INT_EDGE_FALLING)
 774                 dev_dbg(dev, "\tInterrupt Edge Falling\n");
 775         if (intfcaps & TPM_INTF_INT_EDGE_RISING)
 776                 dev_dbg(dev, "\tInterrupt Edge Rising\n");
 777         if (intfcaps & TPM_INTF_INT_LEVEL_LOW)
 778                 dev_dbg(dev, "\tInterrupt Level Low\n");
 779         if (intfcaps & TPM_INTF_INT_LEVEL_HIGH)
 780                 dev_dbg(dev, "\tInterrupt Level High\n");
 781         if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT)
 782                 dev_dbg(dev, "\tLocality Change Int Support\n");
 783         if (intfcaps & TPM_INTF_STS_VALID_INT)
 784                 dev_dbg(dev, "\tSts Valid Int Support\n");
 785         if (intfcaps & TPM_INTF_DATA_AVAIL_INT)
 786                 dev_dbg(dev, "\tData Avail Int Support\n");
 787
 788         /* Very early on issue a command to the TPM in polling mode to make
 789          * sure it works. May as well use that command to set the proper
 790          *  timeouts for the driver.
 791          */
 792         if (tpm_get_timeouts(chip)) {
 793                 dev_err(dev, "Could not get TPM timeouts and durations\n");
 794                 rc = -ENODEV;
 795                 goto out_err;
 796         }
 797
 798         /* INTERRUPT Setup */
 799         init_waitqueue_head(&priv->read_queue);
 800         init_waitqueue_head(&priv->int_queue);
 801         if (interrupts && tpm_info->irq != -1) {
 802                 if (tpm_info->irq) {
 803                         tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
 804                                                  tpm_info->irq);
 805                         if (!(chip->flags & TPM_CHIP_FLAG_IRQ))
 806                                 dev_err(&chip->dev, FW_BUG
 807                                         "TPM interrupt not working, polling instead\n");
 808                 } else
 809                         tpm_tis_probe_irq(chip, intmask);
 810         }
 811
 812         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
 813                 rc = tpm2_do_selftest(chip);
 814                 if (rc == TPM2_RC_INITIALIZE) {
 815                         dev_warn(dev, "Firmware has not started TPM\n");
 816                         rc  = tpm2_startup(chip, TPM2_SU_CLEAR);
 817                         if (!rc)
 818                                 rc = tpm2_do_selftest(chip);
 819                 }
 820
 821                 if (rc) {
 822                         dev_err(dev, "TPM self test failed\n");
 823                         if (rc > 0)
 824                                 rc = -ENODEV;
 825                         goto out_err;
 826                 }
 827         } else {
 828                 if (tpm_do_selftest(chip)) {
 829                         dev_err(dev, "TPM self test failed\n");
 830                         rc = -ENODEV;
 831                         goto out_err;
 832                 }
 833         }
 834
 835         return tpm_chip_register(chip);
 836 out_err:
 837         tpm_tis_remove(chip);
 838         return rc;
 839 }
 840
 841 #ifdef CONFIG_PM_SLEEP
 842 static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
 843 {
 844         struct priv_data *priv = chip->vendor.priv;
 845         u32 intmask;
 846
 847         /* reenable interrupts that device may have lost or
 848            BIOS/firmware may have disabled */
 849         iowrite8(priv->irq, priv->iobase +
 850                  TPM_INT_VECTOR(chip->vendor.locality));
 851
 852         intmask =
 853             ioread32(priv->iobase + TPM_INT_ENABLE(chip->vendor.locality));
 854
 855         intmask |= TPM_INTF_CMD_READY_INT
 856             | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
 857             | TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE;
 858
 859         iowrite32(intmask,
 860                   priv->iobase + TPM_INT_ENABLE(chip->vendor.locality));
 861 }
 862
 863 static int tpm_tis_resume(struct device *dev)
 864 {
 865         struct tpm_chip *chip = dev_get_drvdata(dev);
 866         int ret;
 867
 868         if (chip->flags & TPM_CHIP_FLAG_IRQ)
 869                 tpm_tis_reenable_interrupts(chip);
 870
 871         ret = tpm_pm_resume(dev);
 872         if (ret)
 873                 return ret;
 874
 875         /* TPM 1.2 requires self-test on resume. This function actually returns
 876          * an error code but for unknown reason it isn't handled.
 877          */
 878         if (!(chip->flags & TPM_CHIP_FLAG_TPM2))
 879                 tpm_do_selftest(chip);
 880
 881         return 0;
 882 }
 883 #endif
 884
 885 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
 886
 887 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 888                             const struct pnp_device_id *pnp_id)
 889 {
 890         struct tpm_info tpm_info = {};
 891         acpi_handle acpi_dev_handle = NULL;
 892         struct resource *res;
 893
 894         res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0);
 895         if (!res)
 896                 return -ENODEV;
 897         tpm_info.res = *res;
 898
 899         if (pnp_irq_valid(pnp_dev, 0))
 900                 tpm_info.irq = pnp_irq(pnp_dev, 0);
 901         else
 902                 tpm_info.irq = -1;
 903
 904         if (pnp_acpi_device(pnp_dev)) {
 905                 if (is_itpm(pnp_acpi_device(pnp_dev)))
 906                         itpm = true;
 907
 908                 acpi_dev_handle = ACPI_HANDLE(&pnp_dev->dev);
 909         }
 910
 911         return tpm_tis_init(&pnp_dev->dev, &tpm_info, acpi_dev_handle);
 912 }
 913
 914 static struct pnp_device_id tpm_pnp_tbl[] = {
 915         {"PNP0C31", 0},         /* TPM */
 916         {"ATM1200", 0},         /* Atmel */
 917         {"IFX0102", 0},         /* Infineon */
 918         {"BCM0101", 0},         /* Broadcom */
 919         {"BCM0102", 0},         /* Broadcom */
 920         {"NSC1200", 0},         /* National */
 921         {"ICO0102", 0},         /* Intel */
 922         /* Add new here */
 923         {"", 0},                /* User Specified */
 924         {"", 0}                 /* Terminator */
 925 };
 926 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 927
 928 static void tpm_tis_pnp_remove(struct pnp_dev *dev)
 929 {
 930         struct tpm_chip *chip = pnp_get_drvdata(dev);
 931
 932         tpm_chip_unregister(chip);
 933         tpm_tis_remove(chip);
 934 }
 935
 936 static struct pnp_driver tis_pnp_driver = {
 937         .name = "tpm_tis",
 938         .id_table = tpm_pnp_tbl,
 939         .probe = tpm_tis_pnp_init,
 940         .remove = tpm_tis_pnp_remove,
 941         .driver = {
 942                 .pm = &tpm_tis_pm,
 943         },
 944 };
 945
 946 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2
 947 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
 948                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 949 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 950
 951 #ifdef CONFIG_ACPI
 952 static int tpm_check_resource(struct acpi_resource *ares, void *data)
 953 {
 954         struct tpm_info *tpm_info = (struct tpm_info *) data;
 955         struct resource res;
 956
 957         if (acpi_dev_resource_interrupt(ares, 0, &res))
 958                 tpm_info->irq = res.start;
 959         else if (acpi_dev_resource_memory(ares, &res)) {
 960                 tpm_info->res = res;
 961                 tpm_info->res.name = NULL;
 962         }
 963
 964         return 1;
 965 }
 966
 967 static int tpm_tis_acpi_init(struct acpi_device *acpi_dev)
 968 {
 969         struct acpi_table_tpm2 *tbl;
 970         acpi_status st;
 971         struct list_head resources;
 972         struct tpm_info tpm_info = {};
 973         int ret;
 974
 975         st = acpi_get_table(ACPI_SIG_TPM2, 1,
 976                             (struct acpi_table_header **) &tbl);
 977         if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) {
 978                 dev_err(&acpi_dev->dev,
 979                         FW_BUG "failed to get TPM2 ACPI table\n");
 980                 return -EINVAL;
 981         }
 982
 983         if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED)
 984                 return -ENODEV;
 985
 986         INIT_LIST_HEAD(&resources);
 987         tpm_info.irq = -1;
 988         ret = acpi_dev_get_resources(acpi_dev, &resources, tpm_check_resource,
 989                                      &tpm_info);
 990         if (ret < 0)
 991                 return ret;
 992
 993         acpi_dev_free_resource_list(&resources);
 994
 995         if (resource_type(&tpm_info.res) != IORESOURCE_MEM) {
 996                 dev_err(&acpi_dev->dev,
 997                         FW_BUG "TPM2 ACPI table does not define a memory resource\n");
 998                 return -EINVAL;
 999         }
1000
1001         if (is_itpm(acpi_dev))
1002                 itpm = true;
1003
1004         return tpm_tis_init(&acpi_dev->dev, &tpm_info, acpi_dev->handle);
1005 }
1006
1007 static int tpm_tis_acpi_remove(struct acpi_device *dev)
1008 {
1009         struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
1010
1011         tpm_chip_unregister(chip);
1012         tpm_tis_remove(chip);
1013
1014         return 0;
1015 }
1016
1017 static struct acpi_device_id tpm_acpi_tbl[] = {
1018         {"MSFT0101", 0},        /* TPM 2.0 */
1019         /* Add new here */
1020         {"", 0},                /* User Specified */
1021         {"", 0}                 /* Terminator */
1022 };
1023 MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl);
1024
1025 static struct acpi_driver tis_acpi_driver = {
1026         .name = "tpm_tis",
1027         .ids = tpm_acpi_tbl,
1028         .ops = {
1029                 .add = tpm_tis_acpi_init,
1030                 .remove = tpm_tis_acpi_remove,
1031         },
1032         .drv = {
1033                 .pm = &tpm_tis_pm,
1034         },
1035 };
1036 #endif
1037
1038 static struct platform_device *force_pdev;
1039
1040 static int tpm_tis_plat_probe(struct platform_device *pdev)
1041 {
1042         struct tpm_info tpm_info = {};
1043         struct resource *res;
1044
1045         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1046         if (res == NULL) {
1047                 dev_err(&pdev->dev, "no memory resource defined\n");
1048                 return -ENODEV;
1049         }
1050         tpm_info.res = *res;
1051
1052         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1053         if (res) {
1054                 tpm_info.irq = res->start;
1055         } else {
1056                 if (pdev == force_pdev)
1057                         tpm_info.irq = -1;
1058                 else
1059                         /* When forcing auto probe the IRQ */
1060                         tpm_info.irq = 0;
1061         }
1062
1063         return tpm_tis_init(&pdev->dev, &tpm_info, NULL);
1064 }
1065
1066 static int tpm_tis_plat_remove(struct platform_device *pdev)
1067 {
1068         struct tpm_chip *chip = dev_get_drvdata(&pdev->dev);
1069
1070         tpm_chip_unregister(chip);
1071         tpm_tis_remove(chip);
1072
1073         return 0;
1074 }
1075
1076 static struct platform_driver tis_drv = {
1077         .probe = tpm_tis_plat_probe,
1078         .remove = tpm_tis_plat_remove,
1079         .driver = {
1080                 .name           = "tpm_tis",
1081                 .pm             = &tpm_tis_pm,
1082         },
1083 };
1084
1085 static bool force;
1086 #ifdef CONFIG_X86
1087 module_param(force, bool, 0444);
1088 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
1089 #endif
1090
1091 static int tpm_tis_force_device(void)
1092 {
1093         struct platform_device *pdev;
1094         static const struct resource x86_resources[] = {
1095                 {
1096                         .start = 0xFED40000,
1097                         .end = 0xFED40000 + TIS_MEM_LEN - 1,
1098                         .flags = IORESOURCE_MEM,
1099                 },
1100         };
1101
1102         if (!force)
1103                 return 0;
1104
1105         /* The driver core will match the name tpm_tis of the device to
1106          * the tpm_tis platform driver and complete the setup via
1107          * tpm_tis_plat_probe
1108          */
1109         pdev = platform_device_register_simple("tpm_tis", -1, x86_resources,
1110                                                ARRAY_SIZE(x86_resources));
1111         if (IS_ERR(pdev))
1112                 return PTR_ERR(pdev);
1113         force_pdev = pdev;
1114
1115         return 0;
1116 }
1117
1118 static int __init init_tis(void)
1119 {
1120         int rc;
1121
1122         rc = tpm_tis_force_device();
1123         if (rc)
1124                 goto err_force;
1125
1126         rc = platform_driver_register(&tis_drv);
1127         if (rc)
1128                 goto err_platform;
1129
1130 #ifdef CONFIG_ACPI
1131         rc = acpi_bus_register_driver(&tis_acpi_driver);
1132         if (rc)
1133                 goto err_acpi;
1134 #endif
1135
1136         if (IS_ENABLED(CONFIG_PNP)) {
1137                 rc = pnp_register_driver(&tis_pnp_driver);
1138                 if (rc)
1139                         goto err_pnp;
1140         }
1141
1142         return 0;
1143
1144 err_pnp:
1145 #ifdef CONFIG_ACPI
1146         acpi_bus_unregister_driver(&tis_acpi_driver);
1147 err_acpi:
1148 #endif
1149         platform_device_unregister(force_pdev);
1150 err_platform:
1151         if (force_pdev)
1152                 platform_device_unregister(force_pdev);
1153 err_force:
1154         return rc;
1155 }
1156
1157 static void __exit cleanup_tis(void)
1158 {
1159         pnp_unregister_driver(&tis_pnp_driver);
1160 #ifdef CONFIG_ACPI
1161         acpi_bus_unregister_driver(&tis_acpi_driver);
1162 #endif
1163         platform_driver_unregister(&tis_drv);
1164
1165         if (force_pdev)
1166                 platform_device_unregister(force_pdev);
1167 }
1168
1169 module_init(init_tis);
1170 module_exit(cleanup_tis);
1171 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1172 MODULE_DESCRIPTION("TPM Driver");
1173 MODULE_VERSION("2.0");
1174 MODULE_LICENSE("GPL");