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