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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 = dev_get_drvdata(&chip->dev); 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 #ifdef CONFIG_ACPI 705 chip->acpi_dev_handle = acpi_dev_handle; 706 #endif 707 708 priv->iobase = devm_ioremap_resource(dev, &tpm_info->res); 709 if (IS_ERR(priv->iobase)) 710 return PTR_ERR(priv->iobase); 711 712 /* Maximum timeouts */ 713 chip->timeout_a = TIS_TIMEOUT_A_MAX; 714 chip->timeout_b = TIS_TIMEOUT_B_MAX; 715 chip->timeout_c = TIS_TIMEOUT_C_MAX; 716 chip->timeout_d = TIS_TIMEOUT_D_MAX; 717 718 dev_set_drvdata(&chip->dev, priv); 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(priv->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(priv->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(priv->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 = dev_get_drvdata(&chip->dev); 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(priv->locality)); 851 852 intmask = 853 ioread32(priv->iobase + TPM_INT_ENABLE(priv->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(priv->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"); 1175