drivers/char/tpm/tpm_ibmvtpm.c

   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");