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 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 (!strcmp(id->compat, "IBM,vtpm20")) {
 687                 chip->flags |= TPM_CHIP_FLAG_TPM2;
 688                 rc = tpm2_get_cc_attrs_tbl(chip);
 689                 if (rc)
 690                         goto init_irq_cleanup;
 691         }
 692
 693         if (!wait_event_timeout(ibmvtpm->crq_queue.wq,
 694                                 ibmvtpm->rtce_buf != NULL,
 695                                 HZ)) {
 696                 dev_err(dev, "CRQ response timed out\n");
 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");