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