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 void 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 377 /** 378 * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 379 * @vdev: vio device struct 380 * 381 * Return: 382 * Number of bytes the driver needs to DMA map. 383 */ 384 static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 385 { 386 struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 387 struct ibmvtpm_dev *ibmvtpm; 388 389 /* 390 * ibmvtpm initializes at probe time, so the data we are 391 * asking for may not be set yet. Estimate that 4K required 392 * for TCE-mapped buffer in addition to CRQ. 393 */ 394 if (chip) 395 ibmvtpm = dev_get_drvdata(&chip->dev); 396 else 397 return CRQ_RES_BUF_SIZE + PAGE_SIZE; 398 399 return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 400 } 401 402 /** 403 * tpm_ibmvtpm_suspend - Suspend 404 * @dev: device struct 405 * 406 * Return: Always 0. 407 */ 408 static int tpm_ibmvtpm_suspend(struct device *dev) 409 { 410 struct tpm_chip *chip = dev_get_drvdata(dev); 411 struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 412 int rc = 0; 413 414 rc = ibmvtpm_send_crq(ibmvtpm->vdev, 415 IBMVTPM_VALID_CMD, VTPM_PREPARE_TO_SUSPEND, 0, 0); 416 if (rc != H_SUCCESS) 417 dev_err(ibmvtpm->dev, 418 "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 419 420 return rc; 421 } 422 423 /** 424 * ibmvtpm_reset_crq - Reset CRQ 425 * 426 * @ibmvtpm: ibm vtpm struct 427 * 428 * Return: 429 * 0 on success. 430 * Non-zero on failure. 431 */ 432 static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 433 { 434 int rc = 0; 435 436 do { 437 if (rc) 438 msleep(100); 439 rc = plpar_hcall_norets(H_FREE_CRQ, 440 ibmvtpm->vdev->unit_address); 441 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 442 443 memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 444 ibmvtpm->crq_queue.index = 0; 445 446 return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 447 ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 448 } 449 450 static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) 451 { 452 return (status == 0); 453 } 454 455 static const struct tpm_class_ops tpm_ibmvtpm = { 456 .recv = tpm_ibmvtpm_recv, 457 .send = tpm_ibmvtpm_send, 458 .cancel = tpm_ibmvtpm_cancel, 459 .status = tpm_ibmvtpm_status, 460 .req_complete_mask = 0, 461 .req_complete_val = 0, 462 .req_canceled = tpm_ibmvtpm_req_canceled, 463 }; 464 465 static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 466 .suspend = tpm_ibmvtpm_suspend, 467 .resume = tpm_ibmvtpm_resume, 468 }; 469 470 /** 471 * ibmvtpm_crq_get_next - Get next responded crq 472 * 473 * @ibmvtpm: vtpm device struct 474 * 475 * Return: vtpm crq pointer or NULL. 476 */ 477 static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 478 { 479 struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 480 struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 481 482 if (crq->valid & VTPM_MSG_RES) { 483 if (++crq_q->index == crq_q->num_entry) 484 crq_q->index = 0; 485 smp_rmb(); 486 } else 487 crq = NULL; 488 return crq; 489 } 490 491 /** 492 * ibmvtpm_crq_process - Process responded crq 493 * 494 * @crq: crq to be processed 495 * @ibmvtpm: vtpm device struct 496 * 497 */ 498 static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 499 struct ibmvtpm_dev *ibmvtpm) 500 { 501 int rc = 0; 502 503 switch (crq->valid) { 504 case VALID_INIT_CRQ: 505 switch (crq->msg) { 506 case INIT_CRQ_RES: 507 dev_info(ibmvtpm->dev, "CRQ initialized\n"); 508 rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 509 if (rc) 510 dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 511 return; 512 case INIT_CRQ_COMP_RES: 513 dev_info(ibmvtpm->dev, 514 "CRQ initialization completed\n"); 515 return; 516 default: 517 dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 518 return; 519 } 520 case IBMVTPM_VALID_CMD: 521 switch (crq->msg) { 522 case VTPM_GET_RTCE_BUFFER_SIZE_RES: 523 if (be16_to_cpu(crq->len) <= 0) { 524 dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 525 return; 526 } 527 ibmvtpm->rtce_size = be16_to_cpu(crq->len); 528 ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 529 GFP_ATOMIC); 530 if (!ibmvtpm->rtce_buf) { 531 dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 532 return; 533 } 534 535 ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 536 ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 537 DMA_BIDIRECTIONAL); 538 539 if (dma_mapping_error(ibmvtpm->dev, 540 ibmvtpm->rtce_dma_handle)) { 541 kfree(ibmvtpm->rtce_buf); 542 ibmvtpm->rtce_buf = NULL; 543 dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 544 } 545 546 return; 547 case VTPM_GET_VERSION_RES: 548 ibmvtpm->vtpm_version = be32_to_cpu(crq->data); 549 return; 550 case VTPM_TPM_COMMAND_RES: 551 /* len of the data in rtce buffer */ 552 ibmvtpm->res_len = be16_to_cpu(crq->len); 553 ibmvtpm->tpm_processing_cmd = false; 554 wake_up_interruptible(&ibmvtpm->wq); 555 return; 556 default: 557 return; 558 } 559 } 560 return; 561 } 562 563 /** 564 * ibmvtpm_interrupt - Interrupt handler 565 * 566 * @irq: irq number to handle 567 * @vtpm_instance: vtpm that received interrupt 568 * 569 * Returns: 570 * IRQ_HANDLED 571 **/ 572 static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 573 { 574 struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 575 struct ibmvtpm_crq *crq; 576 577 /* while loop is needed for initial setup (get version and 578 * get rtce_size). There should be only one tpm request at any 579 * given time. 580 */ 581 while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 582 ibmvtpm_crq_process(crq, ibmvtpm); 583 wake_up_interruptible(&ibmvtpm->crq_queue.wq); 584 crq->valid = 0; 585 smp_wmb(); 586 } 587 588 return IRQ_HANDLED; 589 } 590 591 /** 592 * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 593 * 594 * @vio_dev: vio device struct 595 * @id: vio device id struct 596 * 597 * Return: 598 * 0 on success. 599 * Non-zero on failure. 600 */ 601 static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 602 const struct vio_device_id *id) 603 { 604 struct ibmvtpm_dev *ibmvtpm; 605 struct device *dev = &vio_dev->dev; 606 struct ibmvtpm_crq_queue *crq_q; 607 struct tpm_chip *chip; 608 int rc = -ENOMEM, rc1; 609 610 chip = tpmm_chip_alloc(dev, &tpm_ibmvtpm); 611 if (IS_ERR(chip)) 612 return PTR_ERR(chip); 613 614 ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 615 if (!ibmvtpm) { 616 dev_err(dev, "kzalloc for ibmvtpm failed\n"); 617 goto cleanup; 618 } 619 620 ibmvtpm->dev = dev; 621 ibmvtpm->vdev = vio_dev; 622 623 crq_q = &ibmvtpm->crq_queue; 624 crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 625 if (!crq_q->crq_addr) { 626 dev_err(dev, "Unable to allocate memory for crq_addr\n"); 627 goto cleanup; 628 } 629 630 crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 631 init_waitqueue_head(&crq_q->wq); 632 ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 633 CRQ_RES_BUF_SIZE, 634 DMA_BIDIRECTIONAL); 635 636 if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 637 dev_err(dev, "dma mapping failed\n"); 638 goto cleanup; 639 } 640 641 rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 642 ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 643 if (rc == H_RESOURCE) 644 rc = ibmvtpm_reset_crq(ibmvtpm); 645 646 if (rc) { 647 dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 648 goto reg_crq_cleanup; 649 } 650 651 rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 652 tpm_ibmvtpm_driver_name, ibmvtpm); 653 if (rc) { 654 dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 655 goto init_irq_cleanup; 656 } 657 658 rc = vio_enable_interrupts(vio_dev); 659 if (rc) { 660 dev_err(dev, "Error %d enabling interrupts\n", rc); 661 goto init_irq_cleanup; 662 } 663 664 init_waitqueue_head(&ibmvtpm->wq); 665 666 crq_q->index = 0; 667 668 dev_set_drvdata(&chip->dev, ibmvtpm); 669 670 spin_lock_init(&ibmvtpm->rtce_lock); 671 672 rc = ibmvtpm_crq_send_init(ibmvtpm); 673 if (rc) 674 goto init_irq_cleanup; 675 676 rc = ibmvtpm_crq_get_version(ibmvtpm); 677 if (rc) 678 goto init_irq_cleanup; 679 680 rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 681 if (rc) 682 goto init_irq_cleanup; 683 684 if (!wait_event_timeout(ibmvtpm->crq_queue.wq, 685 ibmvtpm->rtce_buf != NULL, 686 HZ)) { 687 dev_err(dev, "CRQ response timed out\n"); 688 goto init_irq_cleanup; 689 } 690 691 if (!strcmp(id->compat, "IBM,vtpm20")) { 692 chip->flags |= TPM_CHIP_FLAG_TPM2; 693 rc = tpm2_get_cc_attrs_tbl(chip); 694 if (rc) 695 goto init_irq_cleanup; 696 } 697 698 return tpm_chip_register(chip); 699 init_irq_cleanup: 700 do { 701 rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 702 } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 703 reg_crq_cleanup: 704 dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 705 DMA_BIDIRECTIONAL); 706 cleanup: 707 if (ibmvtpm) { 708 if (crq_q->crq_addr) 709 free_page((unsigned long)crq_q->crq_addr); 710 kfree(ibmvtpm); 711 } 712 713 return rc; 714 } 715 716 static struct vio_driver ibmvtpm_driver = { 717 .id_table = tpm_ibmvtpm_device_table, 718 .probe = tpm_ibmvtpm_probe, 719 .remove = tpm_ibmvtpm_remove, 720 .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 721 .name = tpm_ibmvtpm_driver_name, 722 .pm = &tpm_ibmvtpm_pm_ops, 723 }; 724 725 /** 726 * ibmvtpm_module_init - Initialize ibm vtpm module. 727 * 728 * 729 * Return: 730 * 0 on success. 731 * Non-zero on failure. 732 */ 733 static int __init ibmvtpm_module_init(void) 734 { 735 return vio_register_driver(&ibmvtpm_driver); 736 } 737 738 /** 739 * ibmvtpm_module_exit - Tear down ibm vtpm module. 740 */ 741 static void __exit ibmvtpm_module_exit(void) 742 { 743 vio_unregister_driver(&ibmvtpm_driver); 744 } 745 746 module_init(ibmvtpm_module_init); 747 module_exit(ibmvtpm_module_exit); 748 749 MODULE_AUTHOR("adlai@us.ibm.com"); 750 MODULE_DESCRIPTION("IBM vTPM Driver"); 751 MODULE_VERSION("1.0"); 752 MODULE_LICENSE("GPL"); 753