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
 110         if (!ibmvtpm->rtce_buf) {
 111                 dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n");
 112                 return 0;
 113         }
 114
 115         len = ibmvtpm->res_len;
 116
 117         if (count < len) {
 118                 dev_err(ibmvtpm->dev,
 119                         "Invalid size in recv: count=%zd, crq_size=%d\n",
 120                         count, len);
 121                 return -EIO;
 122         }
 123
 124         spin_lock(&ibmvtpm->rtce_lock);
 125         memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len);
 126         memset(ibmvtpm->rtce_buf, 0, len);
 127         ibmvtpm->res_len = 0;
 128         spin_unlock(&ibmvtpm->rtce_lock);
 129         return len;
 130 }
 131
 132 /**
 133  * ibmvtpm_crq_send_init - Send a CRQ initialize message
 134  * @ibmvtpm:    vtpm device struct
 135  *
 136  * Return:
 137  *      0 on success.
 138  *      Non-zero on failure.
 139  */
 140 static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm)
 141 {
 142         int rc;
 143
 144         rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_CMD);
 145         if (rc != H_SUCCESS)
 146                 dev_err(ibmvtpm->dev,
 147                         "%s failed rc=%d\n", __func__, rc);
 148
 149         return rc;
 150 }
 151
 152 /**
 153  * tpm_ibmvtpm_resume - Resume from suspend
 154  *
 155  * @dev:        device struct
 156  *
 157  * Return: Always 0.
 158  */
 159 static int tpm_ibmvtpm_resume(struct device *dev)
 160 {
 161         struct tpm_chip *chip = dev_get_drvdata(dev);
 162         struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev);
 163         int rc = 0;
 164
 165         do {
 166                 if (rc)
 167                         msleep(100);
 168                 rc = plpar_hcall_norets(H_ENABLE_CRQ,
 169                                         ibmvtpm->vdev->unit_address);
 170         } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
 171
 172         if (rc) {
 173                 dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc);
 174                 return rc;
 175         }
 176
 177         rc = vio_enable_interrupts(ibmvtpm->vdev);
 178         if (rc) {
 179                 dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc);
 180                 return rc;
 181         }
 182
 183         rc = ibmvtpm_crq_send_init(ibmvtpm);
 184         if (rc)
 185                 dev_err(dev, "Error send_init rc=%d\n", rc);
 186
 187         return rc;
 188 }
 189
 190 /**
 191  * tpm_ibmvtpm_send() - Send a TPM command
 192  * @chip:       tpm chip struct
 193  * @buf:        buffer contains data to send
 194  * @count:      size of buffer
 195  *
 196  * Return:
 197  *   0 on success,
 198  *   -errno on error
 199  */
 200 static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
 201 {
 202         struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev);
 203         bool retry = true;
 204         int rc, sig;
 205
 206         if (!ibmvtpm->rtce_buf) {
 207                 dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n");
 208                 return 0;
 209         }
 210
 211         if (count > ibmvtpm->rtce_size) {
 212                 dev_err(ibmvtpm->dev,
 213                         "Invalid size in send: count=%zd, rtce_size=%d\n",
 214                         count, ibmvtpm->rtce_size);
 215                 return -EIO;
 216         }
 217
 218         if (ibmvtpm->tpm_processing_cmd) {
 219                 dev_info(ibmvtpm->dev,
 220                          "Need to wait for TPM to finish\n");
 221                 /* wait for previous command to finish */
 222                 sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd);
 223                 if (sig)
 224                         return -EINTR;
 225         }
 226
 227         spin_lock(&ibmvtpm->rtce_lock);
 228         ibmvtpm->res_len = 0;
 229         memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count);
 230
 231         /*
 232          * set the processing flag before the Hcall, since we may get the
 233          * result (interrupt) before even being able to check rc.
 234          */
 235         ibmvtpm->tpm_processing_cmd = 1;
 236
 237 again:
 238         rc = ibmvtpm_send_crq(ibmvtpm->vdev,
 239                         IBMVTPM_VALID_CMD, VTPM_TPM_COMMAND,
 240                         count, ibmvtpm->rtce_dma_handle);
 241         if (rc != H_SUCCESS) {
 242                 /*
 243                  * H_CLOSED can be returned after LPM resume.  Call
 244                  * tpm_ibmvtpm_resume() to re-enable the CRQ then retry
 245                  * ibmvtpm_send_crq() once before failing.
 246                  */
 247                 if (rc == H_CLOSED && retry) {
 248                         tpm_ibmvtpm_resume(ibmvtpm->dev);
 249                         retry = false;
 250                         goto again;
 251                 }
 252                 dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc);
 253                 ibmvtpm->tpm_processing_cmd = 0;
 254         }
 255
 256         spin_unlock(&ibmvtpm->rtce_lock);
 257         return 0;
 258 }
 259
 260 static void tpm_ibmvtpm_cancel(struct tpm_chip *chip)
 261 {
 262         return;
 263 }
 264
 265 static u8 tpm_ibmvtpm_status(struct tpm_chip *chip)
 266 {
 267         struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev);
 268
 269         return ibmvtpm->tpm_processing_cmd;
 270 }
 271
 272 /**
 273  * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size
 274  *
 275  * @ibmvtpm:    vtpm device struct
 276  *
 277  * Return:
 278  *      0 on success.
 279  *      Non-zero on failure.
 280  */
 281 static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm)
 282 {
 283         int rc;
 284
 285         rc = ibmvtpm_send_crq(ibmvtpm->vdev,
 286                         IBMVTPM_VALID_CMD, VTPM_GET_RTCE_BUFFER_SIZE, 0, 0);
 287         if (rc != H_SUCCESS)
 288                 dev_err(ibmvtpm->dev,
 289                         "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc);
 290
 291         return rc;
 292 }
 293
 294 /**
 295  * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version
 296  *                         - Note that this is vtpm version and not tpm version
 297  *
 298  * @ibmvtpm:    vtpm device struct
 299  *
 300  * Return:
 301  *      0 on success.
 302  *      Non-zero on failure.
 303  */
 304 static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm)
 305 {
 306         int rc;
 307
 308         rc = ibmvtpm_send_crq(ibmvtpm->vdev,
 309                         IBMVTPM_VALID_CMD, VTPM_GET_VERSION, 0, 0);
 310         if (rc != H_SUCCESS)
 311                 dev_err(ibmvtpm->dev,
 312                         "ibmvtpm_crq_get_version failed rc=%d\n", rc);
 313
 314         return rc;
 315 }
 316
 317 /**
 318  * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message
 319  * @ibmvtpm:    vtpm device struct
 320  *
 321  * Return:
 322  *      0 on success.
 323  *      Non-zero on failure.
 324  */
 325 static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm)
 326 {
 327         int rc;
 328
 329         rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_COMP_CMD);
 330         if (rc != H_SUCCESS)
 331                 dev_err(ibmvtpm->dev,
 332                         "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc);
 333
 334         return rc;
 335 }
 336
 337 /**
 338  * tpm_ibmvtpm_remove - ibm vtpm remove entry point
 339  * @vdev:       vio device struct
 340  *
 341  * Return: Always 0.
 342  */
 343 static void tpm_ibmvtpm_remove(struct vio_dev *vdev)
 344 {
 345         struct tpm_chip *chip = dev_get_drvdata(&vdev->dev);
 346         struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev);
 347         int rc = 0;
 348
 349         tpm_chip_unregister(chip);
 350
 351         free_irq(vdev->irq, ibmvtpm);
 352
 353         do {
 354                 if (rc)
 355                         msleep(100);
 356                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 357         } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
 358
 359         dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle,
 360                          CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL);
 361         free_page((unsigned long)ibmvtpm->crq_queue.crq_addr);
 362
 363         if (ibmvtpm->rtce_buf) {
 364                 dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle,
 365                                  ibmvtpm->rtce_size, DMA_BIDIRECTIONAL);
 366                 kfree(ibmvtpm->rtce_buf);
 367         }
 368
 369         kfree(ibmvtpm);
 370         /* For tpm_ibmvtpm_get_desired_dma */
 371         dev_set_drvdata(&vdev->dev, NULL);
 372 }
 373
 374 /**
 375  * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver
 376  * @vdev:       vio device struct
 377  *
 378  * Return:
 379  *      Number of bytes the driver needs to DMA map.
 380  */
 381 static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev)
 382 {
 383         struct tpm_chip *chip = dev_get_drvdata(&vdev->dev);
 384         struct ibmvtpm_dev *ibmvtpm;
 385
 386         /*
 387          * ibmvtpm initializes at probe time, so the data we are
 388          * asking for may not be set yet. Estimate that 4K required
 389          * for TCE-mapped buffer in addition to CRQ.
 390          */
 391         if (chip)
 392                 ibmvtpm = dev_get_drvdata(&chip->dev);
 393         else
 394                 return CRQ_RES_BUF_SIZE + PAGE_SIZE;
 395
 396         return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size;
 397 }
 398
 399 /**
 400  * tpm_ibmvtpm_suspend - Suspend
 401  * @dev:        device struct
 402  *
 403  * Return: Always 0.
 404  */
 405 static int tpm_ibmvtpm_suspend(struct device *dev)
 406 {
 407         struct tpm_chip *chip = dev_get_drvdata(dev);
 408         struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev);
 409         int rc = 0;
 410
 411         rc = ibmvtpm_send_crq(ibmvtpm->vdev,
 412                         IBMVTPM_VALID_CMD, VTPM_PREPARE_TO_SUSPEND, 0, 0);
 413         if (rc != H_SUCCESS)
 414                 dev_err(ibmvtpm->dev,
 415                         "tpm_ibmvtpm_suspend failed rc=%d\n", rc);
 416
 417         return rc;
 418 }
 419
 420 /**
 421  * ibmvtpm_reset_crq - Reset CRQ
 422  *
 423  * @ibmvtpm:    ibm vtpm struct
 424  *
 425  * Return:
 426  *      0 on success.
 427  *      Non-zero on failure.
 428  */
 429 static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm)
 430 {
 431         int rc = 0;
 432
 433         do {
 434                 if (rc)
 435                         msleep(100);
 436                 rc = plpar_hcall_norets(H_FREE_CRQ,
 437                                         ibmvtpm->vdev->unit_address);
 438         } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
 439
 440         memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE);
 441         ibmvtpm->crq_queue.index = 0;
 442
 443         return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address,
 444                                   ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE);
 445 }
 446
 447 static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status)
 448 {
 449         return (status == 0);
 450 }
 451
 452 static const struct tpm_class_ops tpm_ibmvtpm = {
 453         .recv = tpm_ibmvtpm_recv,
 454         .send = tpm_ibmvtpm_send,
 455         .cancel = tpm_ibmvtpm_cancel,
 456         .status = tpm_ibmvtpm_status,
 457         .req_complete_mask = 1,
 458         .req_complete_val = 0,
 459         .req_canceled = tpm_ibmvtpm_req_canceled,
 460 };
 461
 462 static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = {
 463         .suspend = tpm_ibmvtpm_suspend,
 464         .resume = tpm_ibmvtpm_resume,
 465 };
 466
 467 /**
 468  * ibmvtpm_crq_get_next - Get next responded crq
 469  *
 470  * @ibmvtpm:    vtpm device struct
 471  *
 472  * Return: vtpm crq pointer or NULL.
 473  */
 474 static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm)
 475 {
 476         struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue;
 477         struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index];
 478
 479         if (crq->valid & VTPM_MSG_RES) {
 480                 if (++crq_q->index == crq_q->num_entry)
 481                         crq_q->index = 0;
 482                 smp_rmb();
 483         } else
 484                 crq = NULL;
 485         return crq;
 486 }
 487
 488 /**
 489  * ibmvtpm_crq_process - Process responded crq
 490  *
 491  * @crq:        crq to be processed
 492  * @ibmvtpm:    vtpm device struct
 493  *
 494  */
 495 static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq,
 496                                 struct ibmvtpm_dev *ibmvtpm)
 497 {
 498         int rc = 0;
 499
 500         switch (crq->valid) {
 501         case VALID_INIT_CRQ:
 502                 switch (crq->msg) {
 503                 case INIT_CRQ_RES:
 504                         dev_info(ibmvtpm->dev, "CRQ initialized\n");
 505                         rc = ibmvtpm_crq_send_init_complete(ibmvtpm);
 506                         if (rc)
 507                                 dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc);
 508                         return;
 509                 case INIT_CRQ_COMP_RES:
 510                         dev_info(ibmvtpm->dev,
 511                                  "CRQ initialization completed\n");
 512                         return;
 513                 default:
 514                         dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg);
 515                         return;
 516                 }
 517         case IBMVTPM_VALID_CMD:
 518                 switch (crq->msg) {
 519                 case VTPM_GET_RTCE_BUFFER_SIZE_RES:
 520                         if (be16_to_cpu(crq->len) <= 0) {
 521                                 dev_err(ibmvtpm->dev, "Invalid rtce size\n");
 522                                 return;
 523                         }
 524                         ibmvtpm->rtce_size = be16_to_cpu(crq->len);
 525                         ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size,
 526                                                     GFP_ATOMIC);
 527                         if (!ibmvtpm->rtce_buf) {
 528                                 dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n");
 529                                 return;
 530                         }
 531
 532                         ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev,
 533                                 ibmvtpm->rtce_buf, ibmvtpm->rtce_size,
 534                                 DMA_BIDIRECTIONAL);
 535
 536                         if (dma_mapping_error(ibmvtpm->dev,
 537                                               ibmvtpm->rtce_dma_handle)) {
 538                                 kfree(ibmvtpm->rtce_buf);
 539                                 ibmvtpm->rtce_buf = NULL;
 540                                 dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n");
 541                         }
 542
 543                         return;
 544                 case VTPM_GET_VERSION_RES:
 545                         ibmvtpm->vtpm_version = be32_to_cpu(crq->data);
 546                         return;
 547                 case VTPM_TPM_COMMAND_RES:
 548                         /* len of the data in rtce buffer */
 549                         ibmvtpm->res_len = be16_to_cpu(crq->len);
 550                         ibmvtpm->tpm_processing_cmd = 0;
 551                         wake_up_interruptible(&ibmvtpm->wq);
 552                         return;
 553                 default:
 554                         return;
 555                 }
 556         }
 557         return;
 558 }
 559
 560 /**
 561  * ibmvtpm_interrupt -  Interrupt handler
 562  *
 563  * @irq:                irq number to handle
 564  * @vtpm_instance:      vtpm that received interrupt
 565  *
 566  * Returns:
 567  *      IRQ_HANDLED
 568  **/
 569 static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance)
 570 {
 571         struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance;
 572         struct ibmvtpm_crq *crq;
 573
 574         /* while loop is needed for initial setup (get version and
 575          * get rtce_size). There should be only one tpm request at any
 576          * given time.
 577          */
 578         while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) {
 579                 ibmvtpm_crq_process(crq, ibmvtpm);
 580                 wake_up_interruptible(&ibmvtpm->crq_queue.wq);
 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         init_waitqueue_head(&crq_q->wq);
 629         ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr,
 630                                                  CRQ_RES_BUF_SIZE,
 631                                                  DMA_BIDIRECTIONAL);
 632
 633         if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) {
 634                 dev_err(dev, "dma mapping failed\n");
 635                 goto cleanup;
 636         }
 637
 638         rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address,
 639                                 ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE);
 640         if (rc == H_RESOURCE)
 641                 rc = ibmvtpm_reset_crq(ibmvtpm);
 642
 643         if (rc) {
 644                 dev_err(dev, "Unable to register CRQ rc=%d\n", rc);
 645                 goto reg_crq_cleanup;
 646         }
 647
 648         rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0,
 649                          tpm_ibmvtpm_driver_name, ibmvtpm);
 650         if (rc) {
 651                 dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq);
 652                 goto init_irq_cleanup;
 653         }
 654
 655         rc = vio_enable_interrupts(vio_dev);
 656         if (rc) {
 657                 dev_err(dev, "Error %d enabling interrupts\n", rc);
 658                 goto init_irq_cleanup;
 659         }
 660
 661         init_waitqueue_head(&ibmvtpm->wq);
 662
 663         crq_q->index = 0;
 664
 665         dev_set_drvdata(&chip->dev, ibmvtpm);
 666
 667         spin_lock_init(&ibmvtpm->rtce_lock);
 668
 669         rc = ibmvtpm_crq_send_init(ibmvtpm);
 670         if (rc)
 671                 goto init_irq_cleanup;
 672
 673         rc = ibmvtpm_crq_get_version(ibmvtpm);
 674         if (rc)
 675                 goto init_irq_cleanup;
 676
 677         rc = ibmvtpm_crq_get_rtce_size(ibmvtpm);
 678         if (rc)
 679                 goto init_irq_cleanup;
 680
 681         if (!wait_event_timeout(ibmvtpm->crq_queue.wq,
 682                                 ibmvtpm->rtce_buf != NULL,
 683                                 HZ)) {
 684                 dev_err(dev, "CRQ response timed out\n");
 685                 goto init_irq_cleanup;
 686         }
 687
 688
 689         if (!strcmp(id->compat, "IBM,vtpm20"))
 690                 chip->flags |= TPM_CHIP_FLAG_TPM2;
 691
 692         rc = tpm_get_timeouts(chip);
 693         if (rc)
 694                 goto init_irq_cleanup;
 695
 696         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
 697                 rc = tpm2_get_cc_attrs_tbl(chip);
 698                 if (rc)
 699                         goto init_irq_cleanup;
 700         }
 701
 702         return tpm_chip_register(chip);
 703 init_irq_cleanup:
 704         do {
 705                 rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address);
 706         } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1));
 707 reg_crq_cleanup:
 708         dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE,
 709                          DMA_BIDIRECTIONAL);
 710 cleanup:
 711         if (ibmvtpm) {
 712                 if (crq_q->crq_addr)
 713                         free_page((unsigned long)crq_q->crq_addr);
 714                 kfree(ibmvtpm);
 715         }
 716
 717         return rc;
 718 }
 719
 720 static struct vio_driver ibmvtpm_driver = {
 721         .id_table        = tpm_ibmvtpm_device_table,
 722         .probe           = tpm_ibmvtpm_probe,
 723         .remove          = tpm_ibmvtpm_remove,
 724         .get_desired_dma = tpm_ibmvtpm_get_desired_dma,
 725         .name            = tpm_ibmvtpm_driver_name,
 726         .pm              = &tpm_ibmvtpm_pm_ops,
 727 };
 728
 729 /**
 730  * ibmvtpm_module_init - Initialize ibm vtpm module.
 731  *
 732  *
 733  * Return:
 734  *      0 on success.
 735  *      Non-zero on failure.
 736  */
 737 static int __init ibmvtpm_module_init(void)
 738 {
 739         return vio_register_driver(&ibmvtpm_driver);
 740 }
 741
 742 /**
 743  * ibmvtpm_module_exit - Tear down ibm vtpm module.
 744  */
 745 static void __exit ibmvtpm_module_exit(void)
 746 {
 747         vio_unregister_driver(&ibmvtpm_driver);
 748 }
 749
 750 module_init(ibmvtpm_module_init);
 751 module_exit(ibmvtpm_module_exit);
 752
 753 MODULE_AUTHOR("adlai@us.ibm.com");
 754 MODULE_DESCRIPTION("IBM vTPM Driver");
 755 MODULE_VERSION("1.0");
 756 MODULE_LICENSE("GPL");