1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * STMicroelectronics TPM Linux driver for TPM ST33ZP24 4 * Copyright (C) 2009 - 2016 STMicroelectronics 5 */ 6 7 #include <linux/acpi.h> 8 #include <linux/module.h> 9 #include <linux/fs.h> 10 #include <linux/kernel.h> 11 #include <linux/delay.h> 12 #include <linux/wait.h> 13 #include <linux/freezer.h> 14 #include <linux/string.h> 15 #include <linux/interrupt.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/sched.h> 18 #include <linux/uaccess.h> 19 #include <linux/io.h> 20 #include <linux/slab.h> 21 22 #include "../tpm.h" 23 #include "st33zp24.h" 24 25 #define TPM_ACCESS 0x0 26 #define TPM_STS 0x18 27 #define TPM_DATA_FIFO 0x24 28 #define TPM_INTF_CAPABILITY 0x14 29 #define TPM_INT_STATUS 0x10 30 #define TPM_INT_ENABLE 0x08 31 32 #define LOCALITY0 0 33 34 enum st33zp24_access { 35 TPM_ACCESS_VALID = 0x80, 36 TPM_ACCESS_ACTIVE_LOCALITY = 0x20, 37 TPM_ACCESS_REQUEST_PENDING = 0x04, 38 TPM_ACCESS_REQUEST_USE = 0x02, 39 }; 40 41 enum st33zp24_status { 42 TPM_STS_VALID = 0x80, 43 TPM_STS_COMMAND_READY = 0x40, 44 TPM_STS_GO = 0x20, 45 TPM_STS_DATA_AVAIL = 0x10, 46 TPM_STS_DATA_EXPECT = 0x08, 47 }; 48 49 enum st33zp24_int_flags { 50 TPM_GLOBAL_INT_ENABLE = 0x80, 51 TPM_INTF_CMD_READY_INT = 0x080, 52 TPM_INTF_FIFO_AVALAIBLE_INT = 0x040, 53 TPM_INTF_WAKE_UP_READY_INT = 0x020, 54 TPM_INTF_LOCALITY_CHANGE_INT = 0x004, 55 TPM_INTF_STS_VALID_INT = 0x002, 56 TPM_INTF_DATA_AVAIL_INT = 0x001, 57 }; 58 59 enum tis_defaults { 60 TIS_SHORT_TIMEOUT = 750, 61 TIS_LONG_TIMEOUT = 2000, 62 }; 63 64 /* 65 * clear the pending interrupt. 66 */ 67 static u8 clear_interruption(struct st33zp24_dev *tpm_dev) 68 { 69 u8 interrupt; 70 71 tpm_dev->ops->recv(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1); 72 tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1); 73 return interrupt; 74 } 75 76 /* 77 * cancel the current command execution or set STS to COMMAND READY. 78 */ 79 static void st33zp24_cancel(struct tpm_chip *chip) 80 { 81 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 82 u8 data; 83 84 data = TPM_STS_COMMAND_READY; 85 tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1); 86 } 87 88 /* 89 * return the TPM_STS register 90 */ 91 static u8 st33zp24_status(struct tpm_chip *chip) 92 { 93 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 94 u8 data; 95 96 tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS, &data, 1); 97 return data; 98 } 99 100 /* 101 * if the locality is active 102 */ 103 static bool check_locality(struct tpm_chip *chip) 104 { 105 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 106 u8 data; 107 u8 status; 108 109 status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_ACCESS, &data, 1); 110 if (status && (data & 111 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) == 112 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) 113 return true; 114 115 return false; 116 } 117 118 static int request_locality(struct tpm_chip *chip) 119 { 120 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 121 unsigned long stop; 122 long ret; 123 u8 data; 124 125 if (check_locality(chip)) 126 return tpm_dev->locality; 127 128 data = TPM_ACCESS_REQUEST_USE; 129 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1); 130 if (ret < 0) 131 return ret; 132 133 stop = jiffies + chip->timeout_a; 134 135 /* Request locality is usually effective after the request */ 136 do { 137 if (check_locality(chip)) 138 return tpm_dev->locality; 139 msleep(TPM_TIMEOUT); 140 } while (time_before(jiffies, stop)); 141 142 /* could not get locality */ 143 return -EACCES; 144 } 145 146 static void release_locality(struct tpm_chip *chip) 147 { 148 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 149 u8 data; 150 151 data = TPM_ACCESS_ACTIVE_LOCALITY; 152 153 tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1); 154 } 155 156 /* 157 * get_burstcount return the burstcount value 158 */ 159 static int get_burstcount(struct tpm_chip *chip) 160 { 161 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 162 unsigned long stop; 163 int burstcnt, status; 164 u8 temp; 165 166 stop = jiffies + chip->timeout_d; 167 do { 168 status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS + 1, 169 &temp, 1); 170 if (status < 0) 171 return -EBUSY; 172 173 burstcnt = temp; 174 status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS + 2, 175 &temp, 1); 176 if (status < 0) 177 return -EBUSY; 178 179 burstcnt |= temp << 8; 180 if (burstcnt) 181 return burstcnt; 182 msleep(TPM_TIMEOUT); 183 } while (time_before(jiffies, stop)); 184 return -EBUSY; 185 } 186 187 static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask, 188 bool check_cancel, bool *canceled) 189 { 190 u8 status = chip->ops->status(chip); 191 192 *canceled = false; 193 if ((status & mask) == mask) 194 return true; 195 if (check_cancel && chip->ops->req_canceled(chip, status)) { 196 *canceled = true; 197 return true; 198 } 199 return false; 200 } 201 202 /* 203 * wait for a TPM_STS value 204 */ 205 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, 206 wait_queue_head_t *queue, bool check_cancel) 207 { 208 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 209 unsigned long stop; 210 int ret = 0; 211 bool canceled = false; 212 bool condition; 213 u32 cur_intrs; 214 u8 status; 215 216 /* check current status */ 217 status = st33zp24_status(chip); 218 if ((status & mask) == mask) 219 return 0; 220 221 stop = jiffies + timeout; 222 223 if (chip->flags & TPM_CHIP_FLAG_IRQ) { 224 cur_intrs = tpm_dev->intrs; 225 clear_interruption(tpm_dev); 226 enable_irq(tpm_dev->irq); 227 228 do { 229 if (ret == -ERESTARTSYS && freezing(current)) 230 clear_thread_flag(TIF_SIGPENDING); 231 232 timeout = stop - jiffies; 233 if ((long) timeout <= 0) 234 return -1; 235 236 ret = wait_event_interruptible_timeout(*queue, 237 cur_intrs != tpm_dev->intrs, 238 timeout); 239 clear_interruption(tpm_dev); 240 condition = wait_for_tpm_stat_cond(chip, mask, 241 check_cancel, &canceled); 242 if (ret >= 0 && condition) { 243 if (canceled) 244 return -ECANCELED; 245 return 0; 246 } 247 } while (ret == -ERESTARTSYS && freezing(current)); 248 249 disable_irq_nosync(tpm_dev->irq); 250 251 } else { 252 do { 253 msleep(TPM_TIMEOUT); 254 status = chip->ops->status(chip); 255 if ((status & mask) == mask) 256 return 0; 257 } while (time_before(jiffies, stop)); 258 } 259 260 return -ETIME; 261 } 262 263 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count) 264 { 265 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 266 int size = 0, burstcnt, len, ret; 267 268 while (size < count && 269 wait_for_stat(chip, 270 TPM_STS_DATA_AVAIL | TPM_STS_VALID, 271 chip->timeout_c, 272 &tpm_dev->read_queue, true) == 0) { 273 burstcnt = get_burstcount(chip); 274 if (burstcnt < 0) 275 return burstcnt; 276 len = min_t(int, burstcnt, count - size); 277 ret = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_DATA_FIFO, 278 buf + size, len); 279 if (ret < 0) 280 return ret; 281 282 size += len; 283 } 284 return size; 285 } 286 287 static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id) 288 { 289 struct tpm_chip *chip = dev_id; 290 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 291 292 tpm_dev->intrs++; 293 wake_up_interruptible(&tpm_dev->read_queue); 294 disable_irq_nosync(tpm_dev->irq); 295 296 return IRQ_HANDLED; 297 } 298 299 /* 300 * send TPM commands through the I2C bus. 301 */ 302 static int st33zp24_send(struct tpm_chip *chip, unsigned char *buf, 303 size_t len) 304 { 305 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 306 u32 status, i, size, ordinal; 307 int burstcnt = 0; 308 int ret; 309 u8 data; 310 311 if (len < TPM_HEADER_SIZE) 312 return -EBUSY; 313 314 ret = request_locality(chip); 315 if (ret < 0) 316 return ret; 317 318 status = st33zp24_status(chip); 319 if ((status & TPM_STS_COMMAND_READY) == 0) { 320 st33zp24_cancel(chip); 321 if (wait_for_stat 322 (chip, TPM_STS_COMMAND_READY, chip->timeout_b, 323 &tpm_dev->read_queue, false) < 0) { 324 ret = -ETIME; 325 goto out_err; 326 } 327 } 328 329 for (i = 0; i < len - 1;) { 330 burstcnt = get_burstcount(chip); 331 if (burstcnt < 0) 332 return burstcnt; 333 size = min_t(int, len - i - 1, burstcnt); 334 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO, 335 buf + i, size); 336 if (ret < 0) 337 goto out_err; 338 339 i += size; 340 } 341 342 status = st33zp24_status(chip); 343 if ((status & TPM_STS_DATA_EXPECT) == 0) { 344 ret = -EIO; 345 goto out_err; 346 } 347 348 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO, 349 buf + len - 1, 1); 350 if (ret < 0) 351 goto out_err; 352 353 status = st33zp24_status(chip); 354 if ((status & TPM_STS_DATA_EXPECT) != 0) { 355 ret = -EIO; 356 goto out_err; 357 } 358 359 data = TPM_STS_GO; 360 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1); 361 if (ret < 0) 362 goto out_err; 363 364 if (chip->flags & TPM_CHIP_FLAG_IRQ) { 365 ordinal = be32_to_cpu(*((__be32 *) (buf + 6))); 366 367 ret = wait_for_stat(chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID, 368 tpm_calc_ordinal_duration(chip, ordinal), 369 &tpm_dev->read_queue, false); 370 if (ret < 0) 371 goto out_err; 372 } 373 374 return 0; 375 out_err: 376 st33zp24_cancel(chip); 377 release_locality(chip); 378 return ret; 379 } 380 381 static int st33zp24_recv(struct tpm_chip *chip, unsigned char *buf, 382 size_t count) 383 { 384 int size = 0; 385 u32 expected; 386 387 if (!chip) 388 return -EBUSY; 389 390 if (count < TPM_HEADER_SIZE) { 391 size = -EIO; 392 goto out; 393 } 394 395 size = recv_data(chip, buf, TPM_HEADER_SIZE); 396 if (size < TPM_HEADER_SIZE) { 397 dev_err(&chip->dev, "Unable to read header\n"); 398 goto out; 399 } 400 401 expected = be32_to_cpu(*(__be32 *)(buf + 2)); 402 if (expected > count || expected < TPM_HEADER_SIZE) { 403 size = -EIO; 404 goto out; 405 } 406 407 size += recv_data(chip, &buf[TPM_HEADER_SIZE], 408 expected - TPM_HEADER_SIZE); 409 if (size < expected) { 410 dev_err(&chip->dev, "Unable to read remainder of result\n"); 411 size = -ETIME; 412 } 413 414 out: 415 st33zp24_cancel(chip); 416 release_locality(chip); 417 return size; 418 } 419 420 static bool st33zp24_req_canceled(struct tpm_chip *chip, u8 status) 421 { 422 return (status == TPM_STS_COMMAND_READY); 423 } 424 425 static const struct tpm_class_ops st33zp24_tpm = { 426 .flags = TPM_OPS_AUTO_STARTUP, 427 .send = st33zp24_send, 428 .recv = st33zp24_recv, 429 .cancel = st33zp24_cancel, 430 .status = st33zp24_status, 431 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID, 432 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID, 433 .req_canceled = st33zp24_req_canceled, 434 }; 435 436 static const struct acpi_gpio_params lpcpd_gpios = { 1, 0, false }; 437 438 static const struct acpi_gpio_mapping acpi_st33zp24_gpios[] = { 439 { "lpcpd-gpios", &lpcpd_gpios, 1 }, 440 { }, 441 }; 442 443 /* 444 * initialize the TPM device 445 */ 446 int st33zp24_probe(void *phy_id, const struct st33zp24_phy_ops *ops, 447 struct device *dev, int irq) 448 { 449 int ret; 450 u8 intmask = 0; 451 struct tpm_chip *chip; 452 struct st33zp24_dev *tpm_dev; 453 454 chip = tpmm_chip_alloc(dev, &st33zp24_tpm); 455 if (IS_ERR(chip)) 456 return PTR_ERR(chip); 457 458 tpm_dev = devm_kzalloc(dev, sizeof(struct st33zp24_dev), 459 GFP_KERNEL); 460 if (!tpm_dev) 461 return -ENOMEM; 462 463 tpm_dev->phy_id = phy_id; 464 tpm_dev->ops = ops; 465 dev_set_drvdata(&chip->dev, tpm_dev); 466 467 chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 468 chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT); 469 chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 470 chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT); 471 472 tpm_dev->locality = LOCALITY0; 473 474 if (ACPI_COMPANION(dev)) { 475 ret = devm_acpi_dev_add_driver_gpios(dev, acpi_st33zp24_gpios); 476 if (ret) 477 return ret; 478 } 479 480 /* 481 * Get LPCPD GPIO. If lpcpd pin is not specified. This is not an 482 * issue as power management can be also managed by TPM specific 483 * commands. 484 */ 485 tpm_dev->io_lpcpd = devm_gpiod_get_optional(dev, "lpcpd", 486 GPIOD_OUT_HIGH); 487 ret = PTR_ERR_OR_ZERO(tpm_dev->io_lpcpd); 488 if (ret) { 489 dev_err(dev, "failed to request lpcpd gpio: %d\n", ret); 490 return ret; 491 } 492 493 if (irq) { 494 /* INTERRUPT Setup */ 495 init_waitqueue_head(&tpm_dev->read_queue); 496 tpm_dev->intrs = 0; 497 498 if (request_locality(chip) != LOCALITY0) { 499 ret = -ENODEV; 500 goto _tpm_clean_answer; 501 } 502 503 clear_interruption(tpm_dev); 504 ret = devm_request_irq(dev, irq, tpm_ioserirq_handler, 505 IRQF_TRIGGER_HIGH, "TPM SERIRQ management", 506 chip); 507 if (ret < 0) { 508 dev_err(&chip->dev, "TPM SERIRQ signals %d not available\n", 509 irq); 510 goto _tpm_clean_answer; 511 } 512 513 intmask |= TPM_INTF_CMD_READY_INT 514 | TPM_INTF_STS_VALID_INT 515 | TPM_INTF_DATA_AVAIL_INT; 516 517 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_ENABLE, 518 &intmask, 1); 519 if (ret < 0) 520 goto _tpm_clean_answer; 521 522 intmask = TPM_GLOBAL_INT_ENABLE; 523 ret = tpm_dev->ops->send(tpm_dev->phy_id, (TPM_INT_ENABLE + 3), 524 &intmask, 1); 525 if (ret < 0) 526 goto _tpm_clean_answer; 527 528 tpm_dev->irq = irq; 529 chip->flags |= TPM_CHIP_FLAG_IRQ; 530 531 disable_irq_nosync(tpm_dev->irq); 532 } 533 534 return tpm_chip_register(chip); 535 _tpm_clean_answer: 536 dev_info(&chip->dev, "TPM initialization fail\n"); 537 return ret; 538 } 539 EXPORT_SYMBOL(st33zp24_probe); 540 541 void st33zp24_remove(struct tpm_chip *chip) 542 { 543 tpm_chip_unregister(chip); 544 } 545 EXPORT_SYMBOL(st33zp24_remove); 546 547 #ifdef CONFIG_PM_SLEEP 548 int st33zp24_pm_suspend(struct device *dev) 549 { 550 struct tpm_chip *chip = dev_get_drvdata(dev); 551 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 552 553 int ret = 0; 554 555 if (tpm_dev->io_lpcpd) 556 gpiod_set_value_cansleep(tpm_dev->io_lpcpd, 0); 557 else 558 ret = tpm_pm_suspend(dev); 559 560 return ret; 561 } 562 EXPORT_SYMBOL(st33zp24_pm_suspend); 563 564 int st33zp24_pm_resume(struct device *dev) 565 { 566 struct tpm_chip *chip = dev_get_drvdata(dev); 567 struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev); 568 int ret = 0; 569 570 if (tpm_dev->io_lpcpd) { 571 gpiod_set_value_cansleep(tpm_dev->io_lpcpd, 1); 572 ret = wait_for_stat(chip, 573 TPM_STS_VALID, chip->timeout_b, 574 &tpm_dev->read_queue, false); 575 } else { 576 ret = tpm_pm_resume(dev); 577 if (!ret) 578 tpm1_do_selftest(chip); 579 } 580 return ret; 581 } 582 EXPORT_SYMBOL(st33zp24_pm_resume); 583 #endif 584 585 MODULE_AUTHOR("TPM support <TPMsupport@list.st.com>"); 586 MODULE_DESCRIPTION("ST33ZP24 TPM 1.2 driver"); 587 MODULE_VERSION("1.3.0"); 588 MODULE_LICENSE("GPL"); 589