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 locality;
 100         int irq;
 101         bool irq_tested;
 102         wait_queue_head_t int_queue;
 103         wait_queue_head_t read_queue;
 104 };
 105
 106 #if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
 107 static int has_hid(struct acpi_device *dev, const char *hid)
 108 {
 109         struct acpi_hardware_id *id;
 110
 111         list_for_each_entry(id, &dev->pnp.ids, list)
 112                 if (!strcmp(hid, id->id))
 113                         return 1;
 114
 115         return 0;
 116 }
 117
 118 static inline int is_itpm(struct acpi_device *dev)
 119 {
 120         return has_hid(dev, "INTC0102");
 121 }
 122 #else
 123 static inline int is_itpm(struct acpi_device *dev)
 124 {
 125         return 0;
 126 }
 127 #endif
 128
 129 /* Before we attempt to access the TPM we must see that the valid bit is set.
 130  * The specification says that this bit is 0 at reset and remains 0 until the
 131  * 'TPM has gone through its self test and initialization and has established
 132  * correct values in the other bits.' */
 133 static int wait_startup(struct tpm_chip *chip, int l)
 134 {
 135         struct priv_data *priv = chip->vendor.priv;
 136         unsigned long stop = jiffies + chip->timeout_a;
 137         do {
 138                 if (ioread8(priv->iobase + TPM_ACCESS(l)) &
 139                     TPM_ACCESS_VALID)
 140                         return 0;
 141                 msleep(TPM_TIMEOUT);
 142         } while (time_before(jiffies, stop));
 143         return -1;
 144 }
 145
 146 static int check_locality(struct tpm_chip *chip, int l)
 147 {
 148         struct priv_data *priv = chip->vendor.priv;
 149
 150         if ((ioread8(priv->iobase + TPM_ACCESS(l)) &
 151              (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
 152             (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
 153                 return priv->locality = l;
 154
 155         return -1;
 156 }
 157
 158 static void release_locality(struct tpm_chip *chip, int l, int force)
 159 {
 160         struct priv_data *priv = chip->vendor.priv;
 161
 162         if (force || (ioread8(priv->iobase + TPM_ACCESS(l)) &
 163                       (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
 164             (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))
 165                 iowrite8(TPM_ACCESS_ACTIVE_LOCALITY,
 166                          priv->iobase + TPM_ACCESS(l));
 167 }
 168
 169 static int request_locality(struct tpm_chip *chip, int l)
 170 {
 171         struct priv_data *priv = chip->vendor.priv;
 172         unsigned long stop, timeout;
 173         long rc;
 174
 175         if (check_locality(chip, l) >= 0)
 176                 return l;
 177
 178         iowrite8(TPM_ACCESS_REQUEST_USE,
 179                  priv->iobase + TPM_ACCESS(l));
 180
 181         stop = jiffies + chip->timeout_a;
 182
 183         if (chip->flags & TPM_CHIP_FLAG_IRQ) {
 184 again:
 185                 timeout = stop - jiffies;
 186                 if ((long)timeout <= 0)
 187                         return -1;
 188                 rc = wait_event_interruptible_timeout(priv->int_queue,
 189                                                       (check_locality
 190                                                        (chip, l) >= 0),
 191                                                       timeout);
 192                 if (rc > 0)
 193                         return l;
 194                 if (rc == -ERESTARTSYS && freezing(current)) {
 195                         clear_thread_flag(TIF_SIGPENDING);
 196                         goto again;
 197                 }
 198         } else {
 199                 /* wait for burstcount */
 200                 do {
 201                         if (check_locality(chip, l) >= 0)
 202                                 return l;
 203                         msleep(TPM_TIMEOUT);
 204                 }
 205                 while (time_before(jiffies, stop));
 206         }
 207         return -1;
 208 }
 209
 210 static u8 tpm_tis_status(struct tpm_chip *chip)
 211 {
 212         struct priv_data *priv = chip->vendor.priv;
 213
 214         return ioread8(priv->iobase +
 215                        TPM_STS(priv->locality));
 216 }
 217
 218 static void tpm_tis_ready(struct tpm_chip *chip)
 219 {
 220         struct priv_data *priv = chip->vendor.priv;
 221
 222         /* this causes the current command to be aborted */
 223         iowrite8(TPM_STS_COMMAND_READY,
 224                  priv->iobase + TPM_STS(priv->locality));
 225 }
 226
 227 static int get_burstcount(struct tpm_chip *chip)
 228 {
 229         struct priv_data *priv = chip->vendor.priv;
 230         unsigned long stop;
 231         int burstcnt;
 232
 233         /* wait for burstcount */
 234         /* which timeout value, spec has 2 answers (c & d) */
 235         stop = jiffies + chip->timeout_d;
 236         do {
 237                 burstcnt = ioread8(priv->iobase +
 238                                    TPM_STS(priv->locality) + 1);
 239                 burstcnt += ioread8(priv->iobase +
 240                                     TPM_STS(priv->locality) +
 241                                     2) << 8;
 242                 if (burstcnt)
 243                         return burstcnt;
 244                 msleep(TPM_TIMEOUT);
 245         } while (time_before(jiffies, stop));
 246         return -EBUSY;
 247 }
 248
 249 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 250 {
 251         struct priv_data *priv = chip->vendor.priv;
 252         int size = 0, burstcnt;
 253         while (size < count &&
 254                wait_for_tpm_stat(chip,
 255                                  TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 256                                  chip->timeout_c,
 257                                  &priv->read_queue, true)
 258                == 0) {
 259                 burstcnt = get_burstcount(chip);
 260                 for (; burstcnt > 0 && size < count; burstcnt--)
 261                         buf[size++] = ioread8(priv->iobase +
 262                                               TPM_DATA_FIFO(priv->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->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, priv->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->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(priv->locality));
 348                         count++;
 349                 }
 350
 351                 wait_for_tpm_stat(chip, TPM_STS_VALID, chip->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(priv->locality));
 363         wait_for_tpm_stat(chip, TPM_STS_VALID, chip->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, priv->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(priv->locality));
 387         intmask &= ~TPM_GLOBAL_INT_ENABLE;
 388         iowrite32(intmask,
 389                   priv->iobase + TPM_INT_ENABLE(priv->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(priv->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, priv->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, priv->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, priv->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(priv->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(priv->locality));
 593         ioread32(priv->iobase + TPM_INT_STATUS(priv->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(priv->locality));
 617         iowrite8(irq,
 618                  priv->iobase + TPM_INT_VECTOR(priv->locality));
 619
 620         /* Clear all existing */
 621         iowrite32(ioread32(priv->iobase +
 622                            TPM_INT_STATUS(priv->locality)),
 623                   priv->iobase + TPM_INT_STATUS(priv->locality));
 624
 625         /* Turn on */
 626         iowrite32(intmask | TPM_GLOBAL_INT_ENABLE,
 627                   priv->iobase + TPM_INT_ENABLE(priv->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(priv->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(priv->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 + TPM_INT_ENABLE(priv->locality);
 683
 684         iowrite32(~TPM_GLOBAL_INT_ENABLE & ioread32(reg), reg);
 685         release_locality(chip, priv->locality, 1);
 686 }
 687
 688 static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
 689                         acpi_handle acpi_dev_handle)
 690 {
 691         u32 vendor, intfcaps, intmask;
 692         int rc, probe;
 693         struct tpm_chip *chip;
 694         struct priv_data *priv;
 695
 696         priv = devm_kzalloc(dev, sizeof(struct priv_data), GFP_KERNEL);
 697         if (priv == NULL)
 698                 return -ENOMEM;
 699
 700         chip = tpmm_chip_alloc(dev, &tpm_tis);
 701         if (IS_ERR(chip))
 702                 return PTR_ERR(chip);
 703
 704         chip->vendor.priv = priv;
 705 #ifdef CONFIG_ACPI
 706         chip->acpi_dev_handle = acpi_dev_handle;
 707 #endif
 708
 709         priv->iobase = devm_ioremap_resource(dev, &tpm_info->res);
 710         if (IS_ERR(priv->iobase))
 711                 return PTR_ERR(priv->iobase);
 712
 713         /* Maximum timeouts */
 714         chip->timeout_a = TIS_TIMEOUT_A_MAX;
 715         chip->timeout_b = TIS_TIMEOUT_B_MAX;
 716         chip->timeout_c = TIS_TIMEOUT_C_MAX;
 717         chip->timeout_d = TIS_TIMEOUT_D_MAX;
 718
 719         if (wait_startup(chip, 0) != 0) {
 720                 rc = -ENODEV;
 721                 goto out_err;
 722         }
 723
 724         /* Take control of the TPM's interrupt hardware and shut it off */
 725         intmask = ioread32(priv->iobase +
 726                            TPM_INT_ENABLE(priv->locality));
 727         intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
 728                    TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
 729         intmask &= ~TPM_GLOBAL_INT_ENABLE;
 730         iowrite32(intmask,
 731                   priv->iobase + TPM_INT_ENABLE(priv->locality));
 732
 733         if (request_locality(chip, 0) != 0) {
 734                 rc = -ENODEV;
 735                 goto out_err;
 736         }
 737
 738         rc = tpm2_probe(chip);
 739         if (rc)
 740                 goto out_err;
 741
 742         vendor = ioread32(priv->iobase + TPM_DID_VID(0));
 743         priv->manufacturer_id = vendor;
 744
 745         dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n",
 746                  (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2",
 747                  vendor >> 16, ioread8(priv->iobase + TPM_RID(0)));
 748
 749         if (!itpm) {
 750                 probe = probe_itpm(chip);
 751                 if (probe < 0) {
 752                         rc = -ENODEV;
 753                         goto out_err;
 754                 }
 755                 itpm = !!probe;
 756         }
 757
 758         if (itpm)
 759                 dev_info(dev, "Intel iTPM workaround enabled\n");
 760
 761
 762         /* Figure out the capabilities */
 763         intfcaps =
 764             ioread32(priv->iobase +
 765                      TPM_INTF_CAPS(priv->locality));
 766         dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
 767                 intfcaps);
 768         if (intfcaps & TPM_INTF_BURST_COUNT_STATIC)
 769                 dev_dbg(dev, "\tBurst Count Static\n");
 770         if (intfcaps & TPM_INTF_CMD_READY_INT)
 771                 dev_dbg(dev, "\tCommand Ready Int Support\n");
 772         if (intfcaps & TPM_INTF_INT_EDGE_FALLING)
 773                 dev_dbg(dev, "\tInterrupt Edge Falling\n");
 774         if (intfcaps & TPM_INTF_INT_EDGE_RISING)
 775                 dev_dbg(dev, "\tInterrupt Edge Rising\n");
 776         if (intfcaps & TPM_INTF_INT_LEVEL_LOW)
 777                 dev_dbg(dev, "\tInterrupt Level Low\n");
 778         if (intfcaps & TPM_INTF_INT_LEVEL_HIGH)
 779                 dev_dbg(dev, "\tInterrupt Level High\n");
 780         if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT)
 781                 dev_dbg(dev, "\tLocality Change Int Support\n");
 782         if (intfcaps & TPM_INTF_STS_VALID_INT)
 783                 dev_dbg(dev, "\tSts Valid Int Support\n");
 784         if (intfcaps & TPM_INTF_DATA_AVAIL_INT)
 785                 dev_dbg(dev, "\tData Avail Int Support\n");
 786
 787         /* Very early on issue a command to the TPM in polling mode to make
 788          * sure it works. May as well use that command to set the proper
 789          *  timeouts for the driver.
 790          */
 791         if (tpm_get_timeouts(chip)) {
 792                 dev_err(dev, "Could not get TPM timeouts and durations\n");
 793                 rc = -ENODEV;
 794                 goto out_err;
 795         }
 796
 797         /* INTERRUPT Setup */
 798         init_waitqueue_head(&priv->read_queue);
 799         init_waitqueue_head(&priv->int_queue);
 800         if (interrupts && tpm_info->irq != -1) {
 801                 if (tpm_info->irq) {
 802                         tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
 803                                                  tpm_info->irq);
 804                         if (!(chip->flags & TPM_CHIP_FLAG_IRQ))
 805                                 dev_err(&chip->dev, FW_BUG
 806                                         "TPM interrupt not working, polling instead\n");
 807                 } else
 808                         tpm_tis_probe_irq(chip, intmask);
 809         }
 810
 811         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
 812                 rc = tpm2_do_selftest(chip);
 813                 if (rc == TPM2_RC_INITIALIZE) {
 814                         dev_warn(dev, "Firmware has not started TPM\n");
 815                         rc  = tpm2_startup(chip, TPM2_SU_CLEAR);
 816                         if (!rc)
 817                                 rc = tpm2_do_selftest(chip);
 818                 }
 819
 820                 if (rc) {
 821                         dev_err(dev, "TPM self test failed\n");
 822                         if (rc > 0)
 823                                 rc = -ENODEV;
 824                         goto out_err;
 825                 }
 826         } else {
 827                 if (tpm_do_selftest(chip)) {
 828                         dev_err(dev, "TPM self test failed\n");
 829                         rc = -ENODEV;
 830                         goto out_err;
 831                 }
 832         }
 833
 834         return tpm_chip_register(chip);
 835 out_err:
 836         tpm_tis_remove(chip);
 837         return rc;
 838 }
 839
 840 #ifdef CONFIG_PM_SLEEP
 841 static void tpm_tis_reenable_interrupts(struct tpm_chip *chip)
 842 {
 843         struct priv_data *priv = chip->vendor.priv;
 844         u32 intmask;
 845
 846         /* reenable interrupts that device may have lost or
 847            BIOS/firmware may have disabled */
 848         iowrite8(priv->irq, priv->iobase +
 849                  TPM_INT_VECTOR(priv->locality));
 850
 851         intmask =
 852             ioread32(priv->iobase + TPM_INT_ENABLE(priv->locality));
 853
 854         intmask |= TPM_INTF_CMD_READY_INT
 855             | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT
 856             | TPM_INTF_STS_VALID_INT | TPM_GLOBAL_INT_ENABLE;
 857
 858         iowrite32(intmask,
 859                   priv->iobase + TPM_INT_ENABLE(priv->locality));
 860 }
 861
 862 static int tpm_tis_resume(struct device *dev)
 863 {
 864         struct tpm_chip *chip = dev_get_drvdata(dev);
 865         int ret;
 866
 867         if (chip->flags & TPM_CHIP_FLAG_IRQ)
 868                 tpm_tis_reenable_interrupts(chip);
 869
 870         ret = tpm_pm_resume(dev);
 871         if (ret)
 872                 return ret;
 873
 874         /* TPM 1.2 requires self-test on resume. This function actually returns
 875          * an error code but for unknown reason it isn't handled.
 876          */
 877         if (!(chip->flags & TPM_CHIP_FLAG_TPM2))
 878                 tpm_do_selftest(chip);
 879
 880         return 0;
 881 }
 882 #endif
 883
 884 static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
 885
 886 static int tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 887                             const struct pnp_device_id *pnp_id)
 888 {
 889         struct tpm_info tpm_info = {};
 890         acpi_handle acpi_dev_handle = NULL;
 891         struct resource *res;
 892
 893         res = pnp_get_resource(pnp_dev, IORESOURCE_MEM, 0);
 894         if (!res)
 895                 return -ENODEV;
 896         tpm_info.res = *res;
 897
 898         if (pnp_irq_valid(pnp_dev, 0))
 899                 tpm_info.irq = pnp_irq(pnp_dev, 0);
 900         else
 901                 tpm_info.irq = -1;
 902
 903         if (pnp_acpi_device(pnp_dev)) {
 904                 if (is_itpm(pnp_acpi_device(pnp_dev)))
 905                         itpm = true;
 906
 907                 acpi_dev_handle = ACPI_HANDLE(&pnp_dev->dev);
 908         }
 909
 910         return tpm_tis_init(&pnp_dev->dev, &tpm_info, acpi_dev_handle);
 911 }
 912
 913 static struct pnp_device_id tpm_pnp_tbl[] = {
 914         {"PNP0C31", 0},         /* TPM */
 915         {"ATM1200", 0},         /* Atmel */
 916         {"IFX0102", 0},         /* Infineon */
 917         {"BCM0101", 0},         /* Broadcom */
 918         {"BCM0102", 0},         /* Broadcom */
 919         {"NSC1200", 0},         /* National */
 920         {"ICO0102", 0},         /* Intel */
 921         /* Add new here */
 922         {"", 0},                /* User Specified */
 923         {"", 0}                 /* Terminator */
 924 };
 925 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 926
 927 static void tpm_tis_pnp_remove(struct pnp_dev *dev)
 928 {
 929         struct tpm_chip *chip = pnp_get_drvdata(dev);
 930
 931         tpm_chip_unregister(chip);
 932         tpm_tis_remove(chip);
 933 }
 934
 935 static struct pnp_driver tis_pnp_driver = {
 936         .name = "tpm_tis",
 937         .id_table = tpm_pnp_tbl,
 938         .probe = tpm_tis_pnp_init,
 939         .remove = tpm_tis_pnp_remove,
 940         .driver = {
 941                 .pm = &tpm_tis_pm,
 942         },
 943 };
 944
 945 #define TIS_HID_USR_IDX sizeof(tpm_pnp_tbl)/sizeof(struct pnp_device_id) -2
 946 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
 947                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 948 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 949
 950 #ifdef CONFIG_ACPI
 951 static int tpm_check_resource(struct acpi_resource *ares, void *data)
 952 {
 953         struct tpm_info *tpm_info = (struct tpm_info *) data;
 954         struct resource res;
 955
 956         if (acpi_dev_resource_interrupt(ares, 0, &res))
 957                 tpm_info->irq = res.start;
 958         else if (acpi_dev_resource_memory(ares, &res)) {
 959                 tpm_info->res = res;
 960                 tpm_info->res.name = NULL;
 961         }
 962
 963         return 1;
 964 }
 965
 966 static int tpm_tis_acpi_init(struct acpi_device *acpi_dev)
 967 {
 968         struct acpi_table_tpm2 *tbl;
 969         acpi_status st;
 970         struct list_head resources;
 971         struct tpm_info tpm_info = {};
 972         int ret;
 973
 974         st = acpi_get_table(ACPI_SIG_TPM2, 1,
 975                             (struct acpi_table_header **) &tbl);
 976         if (ACPI_FAILURE(st) || tbl->header.length < sizeof(*tbl)) {
 977                 dev_err(&acpi_dev->dev,
 978                         FW_BUG "failed to get TPM2 ACPI table\n");
 979                 return -EINVAL;
 980         }
 981
 982         if (tbl->start_method != ACPI_TPM2_MEMORY_MAPPED)
 983                 return -ENODEV;
 984
 985         INIT_LIST_HEAD(&resources);
 986         tpm_info.irq = -1;
 987         ret = acpi_dev_get_resources(acpi_dev, &resources, tpm_check_resource,
 988                                      &tpm_info);
 989         if (ret < 0)
 990                 return ret;
 991
 992         acpi_dev_free_resource_list(&resources);
 993
 994         if (resource_type(&tpm_info.res) != IORESOURCE_MEM) {
 995                 dev_err(&acpi_dev->dev,
 996                         FW_BUG "TPM2 ACPI table does not define a memory resource\n");
 997                 return -EINVAL;
 998         }
 999
1000         if (is_itpm(acpi_dev))
1001                 itpm = true;
1002
1003         return tpm_tis_init(&acpi_dev->dev, &tpm_info, acpi_dev->handle);
1004 }
1005
1006 static int tpm_tis_acpi_remove(struct acpi_device *dev)
1007 {
1008         struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
1009
1010         tpm_chip_unregister(chip);
1011         tpm_tis_remove(chip);
1012
1013         return 0;
1014 }
1015
1016 static struct acpi_device_id tpm_acpi_tbl[] = {
1017         {"MSFT0101", 0},        /* TPM 2.0 */
1018         /* Add new here */
1019         {"", 0},                /* User Specified */
1020         {"", 0}                 /* Terminator */
1021 };
1022 MODULE_DEVICE_TABLE(acpi, tpm_acpi_tbl);
1023
1024 static struct acpi_driver tis_acpi_driver = {
1025         .name = "tpm_tis",
1026         .ids = tpm_acpi_tbl,
1027         .ops = {
1028                 .add = tpm_tis_acpi_init,
1029                 .remove = tpm_tis_acpi_remove,
1030         },
1031         .drv = {
1032                 .pm = &tpm_tis_pm,
1033         },
1034 };
1035 #endif
1036
1037 static struct platform_device *force_pdev;
1038
1039 static int tpm_tis_plat_probe(struct platform_device *pdev)
1040 {
1041         struct tpm_info tpm_info = {};
1042         struct resource *res;
1043
1044         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1045         if (res == NULL) {
1046                 dev_err(&pdev->dev, "no memory resource defined\n");
1047                 return -ENODEV;
1048         }
1049         tpm_info.res = *res;
1050
1051         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1052         if (res) {
1053                 tpm_info.irq = res->start;
1054         } else {
1055                 if (pdev == force_pdev)
1056                         tpm_info.irq = -1;
1057                 else
1058                         /* When forcing auto probe the IRQ */
1059                         tpm_info.irq = 0;
1060         }
1061
1062         return tpm_tis_init(&pdev->dev, &tpm_info, NULL);
1063 }
1064
1065 static int tpm_tis_plat_remove(struct platform_device *pdev)
1066 {
1067         struct tpm_chip *chip = dev_get_drvdata(&pdev->dev);
1068
1069         tpm_chip_unregister(chip);
1070         tpm_tis_remove(chip);
1071
1072         return 0;
1073 }
1074
1075 static struct platform_driver tis_drv = {
1076         .probe = tpm_tis_plat_probe,
1077         .remove = tpm_tis_plat_remove,
1078         .driver = {
1079                 .name           = "tpm_tis",
1080                 .pm             = &tpm_tis_pm,
1081         },
1082 };
1083
1084 static bool force;
1085 #ifdef CONFIG_X86
1086 module_param(force, bool, 0444);
1087 MODULE_PARM_DESC(force, "Force device probe rather than using ACPI entry");
1088 #endif
1089
1090 static int tpm_tis_force_device(void)
1091 {
1092         struct platform_device *pdev;
1093         static const struct resource x86_resources[] = {
1094                 {
1095                         .start = 0xFED40000,
1096                         .end = 0xFED40000 + TIS_MEM_LEN - 1,
1097                         .flags = IORESOURCE_MEM,
1098                 },
1099         };
1100
1101         if (!force)
1102                 return 0;
1103
1104         /* The driver core will match the name tpm_tis of the device to
1105          * the tpm_tis platform driver and complete the setup via
1106          * tpm_tis_plat_probe
1107          */
1108         pdev = platform_device_register_simple("tpm_tis", -1, x86_resources,
1109                                                ARRAY_SIZE(x86_resources));
1110         if (IS_ERR(pdev))
1111                 return PTR_ERR(pdev);
1112         force_pdev = pdev;
1113
1114         return 0;
1115 }
1116
1117 static int __init init_tis(void)
1118 {
1119         int rc;
1120
1121         rc = tpm_tis_force_device();
1122         if (rc)
1123                 goto err_force;
1124
1125         rc = platform_driver_register(&tis_drv);
1126         if (rc)
1127                 goto err_platform;
1128
1129 #ifdef CONFIG_ACPI
1130         rc = acpi_bus_register_driver(&tis_acpi_driver);
1131         if (rc)
1132                 goto err_acpi;
1133 #endif
1134
1135         if (IS_ENABLED(CONFIG_PNP)) {
1136                 rc = pnp_register_driver(&tis_pnp_driver);
1137                 if (rc)
1138                         goto err_pnp;
1139         }
1140
1141         return 0;
1142
1143 err_pnp:
1144 #ifdef CONFIG_ACPI
1145         acpi_bus_unregister_driver(&tis_acpi_driver);
1146 err_acpi:
1147 #endif
1148         platform_device_unregister(force_pdev);
1149 err_platform:
1150         if (force_pdev)
1151                 platform_device_unregister(force_pdev);
1152 err_force:
1153         return rc;
1154 }
1155
1156 static void __exit cleanup_tis(void)
1157 {
1158         pnp_unregister_driver(&tis_pnp_driver);
1159 #ifdef CONFIG_ACPI
1160         acpi_bus_unregister_driver(&tis_acpi_driver);
1161 #endif
1162         platform_driver_unregister(&tis_drv);
1163
1164         if (force_pdev)
1165                 platform_device_unregister(force_pdev);
1166 }
1167
1168 module_init(init_tis);
1169 module_exit(cleanup_tis);
1170 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1171 MODULE_DESCRIPTION("TPM Driver");
1172 MODULE_VERSION("2.0");
1173 MODULE_LICENSE("GPL");