1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2012-2020 IBM Corporation 4 * 5 * Author: Ashley Lai <ashleydlai@gmail.com> 6 * 7 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 8 * 9 * Device driver for TCG/TCPA TPM (trusted platform module). 10 * Specifications at www.trustedcomputinggroup.org 11 */ 12 13 #include <linux/dma-mapping.h> 14 #include <linux/dmapool.h> 15 #include <linux/slab.h> 16 #include <asm/vio.h> 17 #include <asm/irq.h> 18 #include <linux/types.h> 19 #include <linux/list.h> 20 #include <linux/spinlock.h> 21 #include <linux/interrupt.h> 22 #include <linux/wait.h> 23 #include <asm/prom.h> 24 25 #include "tpm.h" 26 #include "tpm_ibmvtpm.h" 27 28 static const char tpm_ibmvtpm_driver_name[] = "tpm_ibmvtpm"; 29 30 static const struct vio_device_id tpm_ibmvtpm_device_table[] = { 31 { "IBM,vtpm", "IBM,vtpm"}, 32 { "IBM,vtpm", "IBM,vtpm20"}, 33 { "", "" } 34 }; 35 MODULE_DEVICE_TABLE(vio, tpm_ibmvtpm_device_table); 36 37 /** 38 * ibmvtpm_send_crq_word() - Send a CRQ request 39 * @vdev: vio device struct 40 * @w1: pre-constructed first word of tpm crq (second word is reserved) 41 * 42 * Return: 43 * 0 - Success 44 * Non-zero - Failure 45 */ 46 static int ibmvtpm_send_crq_word(struct vio_dev *vdev, u64 w1) 47 { 48 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, 0); 49 } 50 51 /** 52 * ibmvtpm_send_crq() - Send a CRQ request 53 * 54 * @vdev: vio device struct 55 * @valid: Valid field 56 * @msg: Type field 57 * @len: Length field 58 * @data: Data field 59 * 60 * The ibmvtpm crq is defined as follows: 61 * 62 * Byte | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 63 * ----------------------------------------------------------------------- 64 * Word0 | Valid | Type | Length | Data 65 * ----------------------------------------------------------------------- 66 * Word1 | Reserved 67 * ----------------------------------------------------------------------- 68 * 69 * Which matches the following structure (on bigendian host): 70 * 71 * struct ibmvtpm_crq { 72 * u8 valid; 73 * u8 msg; 74 * __be16 len; 75 * __be32 data; 76 * __be64 reserved; 77 * } __attribute__((packed, aligned(8))); 78 * 79 * However, the value is passed in a register so just compute the numeric value 80 * to load into the register avoiding byteswap altogether. Endian only affects 81 * memory loads and stores - registers are internally represented the same. 82 * 83 * Return: 84 * 0 (H_SUCCESS) - Success 85 * Non-zero - Failure 86 */ 87 static int ibmvtpm_send_crq(struct vio_dev *vdev, 88 u8 valid, u8 msg, u16 len, u32 data) 89 { 90 u64 w1 = ((u64)valid << 56) | ((u64)msg << 48) | ((u64)len << 32) | 91 (u64)data; 92 return ibmvtpm_send_crq_word(vdev, w1); 93 } 94 95 /** 96 * tpm_ibmvtpm_recv - Receive data after send 97 * 98 * @chip: tpm chip struct 99 * @buf: buffer to read 100 * @count: size of buffer 101 * 102 * Return: 103 * Number of bytes read 104 */ 105 static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) 106 { 107 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 108 u16 len; 109 int sig; 110 111 if (!ibmvtpm->rtce_buf) { 112 dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 113 return 0; 114 } 115 116 sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 117 if (sig) 118 return -EINTR; 119 120 len = ibmvtpm->res_len; 121 122 if (count < len) { 123 dev_err(ibmvtpm->dev, 124 "Invalid size in recv: count=%zd, crq_size=%d\n", 125 count, len); 126 return -EIO; 127 } 128 129 spin_lock(&ibmvtpm->rtce_lock); 130 memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len); 131 memset(ibmvtpm->rtce_buf, 0, len); 132 ibmvtpm->res_len = 0; 133 spin_unlock(&ibmvtpm->rtce_lock); 134 return len; 135 } 136 137 /** 138 * ibmvtpm_crq_send_init - Send a CRQ initialize message 139 * @ibmvtpm: vtpm device struct 140 * 141 * Return: 142 * 0 on success. 143 * Non-zero on failure. 144 */ 145 static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) 146 { 147 int rc; 148 149 rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_CMD); 150 if (rc != H_SUCCESS) 151 dev_err(ibmvtpm->dev, 152 "%s failed rc=%d\n", __func__, rc); 153 154 return rc; 155 } 156 157 /** 158 * tpm_ibmvtpm_resume - Resume from suspend 159 * 160 * @dev: device struct 161 * 162 * Return: Always 0. 163 */ 164 static int tpm_ibmvtpm_resume(struct device *dev) 165 { 166 struct tpm_chip *chip = dev_get_drvdata(dev); 167 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 168 int rc = 0; 169 170 do { 171 if (rc) 172 msleep(100); 173 rc = plpar_hcall_norets(H_ENABLE_CRQ, 174 ibmvtpm->vdev->unit_address); 175 } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); 176 177 if (rc) { 178 dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc); 179 return rc; 180 } 181 182 rc = vio_enable_interrupts(ibmvtpm->vdev); 183 if (rc) { 184 dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc); 185 return rc; 186 } 187 188 rc = ibmvtpm_crq_send_init(ibmvtpm); 189 if (rc) 190 dev_err(dev, "Error send_init rc=%d\n", rc); 191 192 return rc; 193 } 194 195 /** 196 * tpm_ibmvtpm_send() - Send a TPM command 197 * @chip: tpm chip struct 198 * @buf: buffer contains data to send 199 * @count: size of buffer 200 * 201 * Return: 202 * 0 on success, 203 * -errno on error 204 */ 205 static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) 206 { 207 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 208 bool retry = true; 209 int rc, sig; 210 211 if (!ibmvtpm->rtce_buf) { 212 dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 213 return 0; 214 } 215 216 if (count > ibmvtpm->rtce_size) { 217 dev_err(ibmvtpm->dev, 218 "Invalid size in send: count=%zd, rtce_size=%d\n", 219 count, ibmvtpm->rtce_size); 220 return -EIO; 221 } 222 223 if (ibmvtpm->tpm_processing_cmd) { 224 dev_info(ibmvtpm->dev, 225 "Need to wait for TPM to finish\n"); 226 /* wait for previous command to finish */ 227 sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 228 if (sig) 229 return -EINTR; 230 } 231 232 spin_lock(&ibmvtpm->rtce_lock); 233 ibmvtpm->res_len = 0; 234 memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); 235 236 /* 237 * set the processing flag before the Hcall, since we may get the 238 * result (interrupt) before even being able to check rc. 239 */ 240 ibmvtpm->tpm_processing_cmd = true; 241 242 again: 243 rc = ibmvtpm_send_crq(ibmvtpm->vdev, 244 IBMVTPM_VALID_CMD, VTPM_TPM_COMMAND, 245 count, ibmvtpm->rtce_dma_handle); 246 if (rc != H_SUCCESS) { 247 /* 248 * H_CLOSED can be returned after LPM resume. Call 249 * tpm_ibmvtpm_resume() to re-enable the CRQ then retry 250 * ibmvtpm_send_crq() once before failing. 251 */ 252 if (rc == H_CLOSED && retry) { 253 tpm_ibmvtpm_resume(ibmvtpm->dev); 254 retry = false; 255 goto again; 256 } 257 dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc); 258 ibmvtpm->tpm_processing_cmd = false; 259 } 260 261 spin_unlock(&ibmvtpm->rtce_lock); 262 return 0; 263 } 264 265 static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) 266 { 267 return; 268 } 269 270 static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) 271 { 272 return 0; 273 } 274 275 /** 276 * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size 277 * 278 * @ibmvtpm: vtpm device struct 279 * 280 * Return: 281 * 0 on success. 282 * Non-zero on failure. 283 */ 284 static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) 285 { 286 int rc; 287 288 rc = ibmvtpm_send_crq(ibmvtpm->vdev, 289 IBMVTPM_VALID_CMD, VTPM_GET_RTCE_BUFFER_SIZE, 0, 0); 290 if (rc != H_SUCCESS) 291 dev_err(ibmvtpm->dev, 292 "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc); 293 294 return rc; 295 } 296 297 /** 298 * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version 299 * - Note that this is vtpm version and not tpm version 300 * 301 * @ibmvtpm: vtpm device struct 302 * 303 * Return: 304 * 0 on success. 305 * Non-zero on failure. 306 */ 307 static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm) 308 { 309 int rc; 310 311 rc = ibmvtpm_send_crq(ibmvtpm->vdev, 312 IBMVTPM_VALID_CMD, VTPM_GET_VERSION, 0, 0); 313 if (rc != H_SUCCESS) 314 dev_err(ibmvtpm->dev, 315 "ibmvtpm_crq_get_version failed rc=%d\n", rc); 316 317 return rc; 318 } 319 320 /** 321 * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message 322 * @ibmvtpm: vtpm device struct 323 * 324 * Return: 325 * 0 on success. 326 * Non-zero on failure. 327 */ 328 static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) 329 { 330 int rc; 331 332 rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_COMP_CMD); 333 if (rc != H_SUCCESS) 334 dev_err(ibmvtpm->dev, 335 "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc); 336 337 return rc; 338 } 339 340 /** 341 * tpm_ibmvtpm_remove - ibm vtpm remove entry point 342 * @vdev: vio device struct 343 * 344 * Return: Always 0. 345 */ 346 static int tpm_ibmvtpm_remove(struct vio_dev *vdev) 347 { 348 struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 349 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 350 int rc = 0; 351 352 tpm_chip_unregister(chip); 353 354 free_irq(vdev->irq, ibmvtpm); 355 356 do { 357 if (rc) 358 msleep(100); 359 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 360 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 361 362 dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, 363 CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); 364 free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); 365 366 if (ibmvtpm->rtce_buf) { 367 dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, 368 ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); 369 kfree(ibmvtpm->rtce_buf); 370 } 371 372 kfree(ibmvtpm); 373 /* For tpm_ibmvtpm_get_desired_dma */ 374 dev_set_drvdata(&vdev->dev, NULL); 375 376 return 0; 377 } 378 379 /** 380 * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 381 * @vdev: vio device struct 382 * 383 * Return: 384 * Number of bytes the driver needs to DMA map. 385 */ 386 static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 387 { 388 struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 389 struct ibmvtpm_dev *ibmvtpm; 390 391 /* 392 * ibmvtpm initializes at probe time, so the data we are 393 * asking for may not be set yet. Estimate that 4K required 394 * for TCE-mapped buffer in addition to CRQ. 395 */ 396 if (chip) 397 ibmvtpm = dev_get_drvdata(&chip->dev); 398 else 399 return CRQ_RES_BUF_SIZE + PAGE_SIZE; 400 401 return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 402 } 403 404 /** 405 * tpm_ibmvtpm_suspend - Suspend 406 * @dev: device struct 407 * 408 * Return: Always 0. 409 */ 410 static int tpm_ibmvtpm_suspend(struct device *dev) 411 { 412 struct tpm_chip *chip = dev_get_drvdata(dev); 413 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 414 int rc = 0; 415 416 rc = ibmvtpm_send_crq(ibmvtpm->vdev, 417 IBMVTPM_VALID_CMD, VTPM_PREPARE_TO_SUSPEND, 0, 0); 418 if (rc != H_SUCCESS) 419 dev_err(ibmvtpm->dev, 420 "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 421 422 return rc; 423 } 424 425 /** 426 * ibmvtpm_reset_crq - Reset CRQ 427 * 428 * @ibmvtpm: ibm vtpm struct 429 * 430 * Return: 431 * 0 on success. 432 * Non-zero on failure. 433 */ 434 static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 435 { 436 int rc = 0; 437 438 do { 439 if (rc) 440 msleep(100); 441 rc = plpar_hcall_norets(H_FREE_CRQ, 442 ibmvtpm->vdev->unit_address); 443 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 444 445 memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 446 ibmvtpm->crq_queue.index = 0; 447 448 return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 449 ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 450 } 451 452 static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) 453 { 454 return (status == 0); 455 } 456 457 static const struct tpm_class_ops tpm_ibmvtpm = { 458 .recv = tpm_ibmvtpm_recv, 459 .send = tpm_ibmvtpm_send, 460 .cancel = tpm_ibmvtpm_cancel, 461 .status = tpm_ibmvtpm_status, 462 .req_complete_mask = 0, 463 .req_complete_val = 0, 464 .req_canceled = tpm_ibmvtpm_req_canceled, 465 }; 466 467 static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 468 .suspend = tpm_ibmvtpm_suspend, 469 .resume = tpm_ibmvtpm_resume, 470 }; 471 472 /** 473 * ibmvtpm_crq_get_next - Get next responded crq 474 * 475 * @ibmvtpm: vtpm device struct 476 * 477 * Return: vtpm crq pointer or NULL. 478 */ 479 static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 480 { 481 struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 482 struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 483 484 if (crq->valid & VTPM_MSG_RES) { 485 if (++crq_q->index == crq_q->num_entry) 486 crq_q->index = 0; 487 smp_rmb(); 488 } else 489 crq = NULL; 490 return crq; 491 } 492 493 /** 494 * ibmvtpm_crq_process - Process responded crq 495 * 496 * @crq: crq to be processed 497 * @ibmvtpm: vtpm device struct 498 * 499 */ 500 static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 501 struct ibmvtpm_dev *ibmvtpm) 502 { 503 int rc = 0; 504 505 switch (crq->valid) { 506 case VALID_INIT_CRQ: 507 switch (crq->msg) { 508 case INIT_CRQ_RES: 509 dev_info(ibmvtpm->dev, "CRQ initialized\n"); 510 rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 511 if (rc) 512 dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 513 return; 514 case INIT_CRQ_COMP_RES: 515 dev_info(ibmvtpm->dev, 516 "CRQ initialization completed\n"); 517 return; 518 default: 519 dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 520 return; 521 } 522 case IBMVTPM_VALID_CMD: 523 switch (crq->msg) { 524 case VTPM_GET_RTCE_BUFFER_SIZE_RES: 525 if (be16_to_cpu(crq->len) <= 0) { 526 dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 527 return; 528 } 529 ibmvtpm->rtce_size = be16_to_cpu(crq->len); 530 ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 531 GFP_ATOMIC); 532 if (!ibmvtpm->rtce_buf) { 533 dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 534 return; 535 } 536 537 ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 538 ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 539 DMA_BIDIRECTIONAL); 540 541 if (dma_mapping_error(ibmvtpm->dev, 542 ibmvtpm->rtce_dma_handle)) { 543 kfree(ibmvtpm->rtce_buf); 544 ibmvtpm->rtce_buf = NULL; 545 dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 546 } 547 548 return; 549 case VTPM_GET_VERSION_RES: 550 ibmvtpm->vtpm_version = be32_to_cpu(crq->data); 551 return; 552 case VTPM_TPM_COMMAND_RES: 553 /* len of the data in rtce buffer */ 554 ibmvtpm->res_len = be16_to_cpu(crq->len); 555 ibmvtpm->tpm_processing_cmd = false; 556 wake_up_interruptible(&ibmvtpm->wq); 557 return; 558 default: 559 return; 560 } 561 } 562 return; 563 } 564 565 /** 566 * ibmvtpm_interrupt - Interrupt handler 567 * 568 * @irq: irq number to handle 569 * @vtpm_instance: vtpm that received interrupt 570 * 571 * Returns: 572 * IRQ_HANDLED 573 **/ 574 static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 575 { 576 struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 577 struct ibmvtpm_crq *crq; 578 579 /* while loop is needed for initial setup (get version and 580 * get rtce_size). There should be only one tpm request at any 581 * given time. 582 */ 583 while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 584 ibmvtpm_crq_process(crq, ibmvtpm); 585 wake_up_interruptible(&ibmvtpm->crq_queue.wq); 586 crq->valid = 0; 587 smp_wmb(); 588 } 589 590 return IRQ_HANDLED; 591 } 592 593 /** 594 * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 595 * 596 * @vio_dev: vio device struct 597 * @id: vio device id struct 598 * 599 * Return: 600 * 0 on success. 601 * Non-zero on failure. 602 */ 603 static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 604 const struct vio_device_id *id) 605 { 606 struct ibmvtpm_dev *ibmvtpm; 607 struct device *dev = &vio_dev->dev; 608 struct ibmvtpm_crq_queue *crq_q; 609 struct tpm_chip *chip; 610 int rc = -ENOMEM, rc1; 611 612 chip = tpmm_chip_alloc(dev, &tpm_ibmvtpm); 613 if (IS_ERR(chip)) 614 return PTR_ERR(chip); 615 616 ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 617 if (!ibmvtpm) { 618 dev_err(dev, "kzalloc for ibmvtpm failed\n"); 619 goto cleanup; 620 } 621 622 ibmvtpm->dev = dev; 623 ibmvtpm->vdev = vio_dev; 624 625 crq_q = &ibmvtpm->crq_queue; 626 crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 627 if (!crq_q->crq_addr) { 628 dev_err(dev, "Unable to allocate memory for crq_addr\n"); 629 goto cleanup; 630 } 631 632 crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 633 init_waitqueue_head(&crq_q->wq); 634 ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 635 CRQ_RES_BUF_SIZE, 636 DMA_BIDIRECTIONAL); 637 638 if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 639 dev_err(dev, "dma mapping failed\n"); 640 goto cleanup; 641 } 642 643 rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 644 ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 645 if (rc == H_RESOURCE) 646 rc = ibmvtpm_reset_crq(ibmvtpm); 647 648 if (rc) { 649 dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 650 goto reg_crq_cleanup; 651 } 652 653 rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 654 tpm_ibmvtpm_driver_name, ibmvtpm); 655 if (rc) { 656 dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 657 goto init_irq_cleanup; 658 } 659 660 rc = vio_enable_interrupts(vio_dev); 661 if (rc) { 662 dev_err(dev, "Error %d enabling interrupts\n", rc); 663 goto init_irq_cleanup; 664 } 665 666 init_waitqueue_head(&ibmvtpm->wq); 667 668 crq_q->index = 0; 669 670 dev_set_drvdata(&chip->dev, ibmvtpm); 671 672 spin_lock_init(&ibmvtpm->rtce_lock); 673 674 rc = ibmvtpm_crq_send_init(ibmvtpm); 675 if (rc) 676 goto init_irq_cleanup; 677 678 rc = ibmvtpm_crq_get_version(ibmvtpm); 679 if (rc) 680 goto init_irq_cleanup; 681 682 rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 683 if (rc) 684 goto init_irq_cleanup; 685 686 if (!wait_event_timeout(ibmvtpm->crq_queue.wq, 687 ibmvtpm->rtce_buf != NULL, 688 HZ)) { 689 dev_err(dev, "CRQ response timed out\n"); 690 goto init_irq_cleanup; 691 } 692 693 if (!strcmp(id->compat, "IBM,vtpm20")) { 694 chip->flags |= TPM_CHIP_FLAG_TPM2; 695 rc = tpm2_get_cc_attrs_tbl(chip); 696 if (rc) 697 goto init_irq_cleanup; 698 } 699 700 return tpm_chip_register(chip); 701 init_irq_cleanup: 702 do { 703 rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 704 } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 705 reg_crq_cleanup: 706 dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 707 DMA_BIDIRECTIONAL); 708 cleanup: 709 if (ibmvtpm) { 710 if (crq_q->crq_addr) 711 free_page((unsigned long)crq_q->crq_addr); 712 kfree(ibmvtpm); 713 } 714 715 return rc; 716 } 717 718 static struct vio_driver ibmvtpm_driver = { 719 .id_table = tpm_ibmvtpm_device_table, 720 .probe = tpm_ibmvtpm_probe, 721 .remove = tpm_ibmvtpm_remove, 722 .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 723 .name = tpm_ibmvtpm_driver_name, 724 .pm = &tpm_ibmvtpm_pm_ops, 725 }; 726 727 /** 728 * ibmvtpm_module_init - Initialize ibm vtpm module. 729 * 730 * 731 * Return: 732 * 0 on success. 733 * Non-zero on failure. 734 */ 735 static int __init ibmvtpm_module_init(void) 736 { 737 return vio_register_driver(&ibmvtpm_driver); 738 } 739 740 /** 741 * ibmvtpm_module_exit - Tear down ibm vtpm module. 742 */ 743 static void __exit ibmvtpm_module_exit(void) 744 { 745 vio_unregister_driver(&ibmvtpm_driver); 746 } 747 748 module_init(ibmvtpm_module_init); 749 module_exit(ibmvtpm_module_exit); 750 751 MODULE_AUTHOR("adlai@us.ibm.com"); 752 MODULE_DESCRIPTION("IBM vTPM Driver"); 753 MODULE_VERSION("1.0"); 754 MODULE_LICENSE("GPL"); 755