1132f7629SAshley Lai /* 2132f7629SAshley Lai * Copyright (C) 2012 IBM Corporation 3132f7629SAshley Lai * 41a0f1b27SAshley Lai * Author: Ashley Lai <ashleydlai@gmail.com> 5132f7629SAshley Lai * 6132f7629SAshley Lai * Maintained by: <tpmdd-devel@lists.sourceforge.net> 7132f7629SAshley Lai * 8132f7629SAshley Lai * Device driver for TCG/TCPA TPM (trusted platform module). 9132f7629SAshley Lai * Specifications at www.trustedcomputinggroup.org 10132f7629SAshley Lai * 11132f7629SAshley Lai * This program is free software; you can redistribute it and/or 12132f7629SAshley Lai * modify it under the terms of the GNU General Public License as 13132f7629SAshley Lai * published by the Free Software Foundation, version 2 of the 14132f7629SAshley Lai * License. 15132f7629SAshley Lai * 16132f7629SAshley Lai */ 17132f7629SAshley Lai 18132f7629SAshley Lai #include <linux/dma-mapping.h> 19132f7629SAshley Lai #include <linux/dmapool.h> 20132f7629SAshley Lai #include <linux/slab.h> 21132f7629SAshley Lai #include <asm/vio.h> 22132f7629SAshley Lai #include <asm/irq.h> 23132f7629SAshley Lai #include <linux/types.h> 24132f7629SAshley Lai #include <linux/list.h> 25132f7629SAshley Lai #include <linux/spinlock.h> 26132f7629SAshley Lai #include <linux/interrupt.h> 27132f7629SAshley Lai #include <linux/wait.h> 28132f7629SAshley Lai #include <asm/prom.h> 29132f7629SAshley Lai 30132f7629SAshley Lai #include "tpm.h" 31132f7629SAshley Lai #include "tpm_ibmvtpm.h" 32132f7629SAshley Lai 33132f7629SAshley Lai static const char tpm_ibmvtpm_driver_name[] = "tpm_ibmvtpm"; 34132f7629SAshley Lai 35c2a9c4bfSArvind Yadav static const struct vio_device_id tpm_ibmvtpm_device_table[] = { 36132f7629SAshley Lai { "IBM,vtpm", "IBM,vtpm"}, 37132f7629SAshley Lai { "", "" } 38132f7629SAshley Lai }; 39132f7629SAshley Lai MODULE_DEVICE_TABLE(vio, tpm_ibmvtpm_device_table); 40132f7629SAshley Lai 41132f7629SAshley Lai /** 42*fb154e0eSMichal Suchanek * 43*fb154e0eSMichal Suchanek * ibmvtpm_send_crq_word - Send a CRQ request 44*fb154e0eSMichal Suchanek * @vdev: vio device struct 45*fb154e0eSMichal Suchanek * @w1: pre-constructed first word of tpm crq (second word is reserved) 46*fb154e0eSMichal Suchanek * 47*fb154e0eSMichal Suchanek * Return: 48*fb154e0eSMichal Suchanek * 0 - Success 49*fb154e0eSMichal Suchanek * Non-zero - Failure 50*fb154e0eSMichal Suchanek */ 51*fb154e0eSMichal Suchanek static int ibmvtpm_send_crq_word(struct vio_dev *vdev, u64 w1) 52*fb154e0eSMichal Suchanek { 53*fb154e0eSMichal Suchanek return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, 0); 54*fb154e0eSMichal Suchanek } 55*fb154e0eSMichal Suchanek 56*fb154e0eSMichal Suchanek /** 57*fb154e0eSMichal Suchanek * 58132f7629SAshley Lai * ibmvtpm_send_crq - Send a CRQ request 5993c12f29SWinkler, Tomas * 60132f7629SAshley Lai * @vdev: vio device struct 61*fb154e0eSMichal Suchanek * @valid: Valid field 62*fb154e0eSMichal Suchanek * @msg: Type field 63*fb154e0eSMichal Suchanek * @len: Length field 64*fb154e0eSMichal Suchanek * @data: Data field 65*fb154e0eSMichal Suchanek * 66*fb154e0eSMichal Suchanek * The ibmvtpm crq is defined as follows: 67*fb154e0eSMichal Suchanek * 68*fb154e0eSMichal Suchanek * Byte | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 69*fb154e0eSMichal Suchanek * ----------------------------------------------------------------------- 70*fb154e0eSMichal Suchanek * Word0 | Valid | Type | Length | Data 71*fb154e0eSMichal Suchanek * ----------------------------------------------------------------------- 72*fb154e0eSMichal Suchanek * Word1 | Reserved 73*fb154e0eSMichal Suchanek * ----------------------------------------------------------------------- 74*fb154e0eSMichal Suchanek * 75*fb154e0eSMichal Suchanek * Which matches the following structure (on bigendian host): 76*fb154e0eSMichal Suchanek * 77*fb154e0eSMichal Suchanek * struct ibmvtpm_crq { 78*fb154e0eSMichal Suchanek * u8 valid; 79*fb154e0eSMichal Suchanek * u8 msg; 80*fb154e0eSMichal Suchanek * __be16 len; 81*fb154e0eSMichal Suchanek * __be32 data; 82*fb154e0eSMichal Suchanek * __be64 reserved; 83*fb154e0eSMichal Suchanek * } __attribute__((packed, aligned(8))); 84*fb154e0eSMichal Suchanek * 85*fb154e0eSMichal Suchanek * However, the value is passed in a register so just compute the numeric value 86*fb154e0eSMichal Suchanek * to load into the register avoiding byteswap altogether. Endian only affects 87*fb154e0eSMichal Suchanek * memory loads and stores - registers are internally represented the same. 88132f7629SAshley Lai * 8993c12f29SWinkler, Tomas * Return: 90*fb154e0eSMichal Suchanek * 0 (H_SUCCESS) - Success 91132f7629SAshley Lai * Non-zero - Failure 92132f7629SAshley Lai */ 93*fb154e0eSMichal Suchanek static int ibmvtpm_send_crq(struct vio_dev *vdev, 94*fb154e0eSMichal Suchanek u8 valid, u8 msg, u16 len, u32 data) 95132f7629SAshley Lai { 96*fb154e0eSMichal Suchanek u64 w1 = ((u64)valid << 56) | ((u64)msg << 48) | ((u64)len << 32) | 97*fb154e0eSMichal Suchanek (u64)data; 98*fb154e0eSMichal Suchanek return ibmvtpm_send_crq_word(vdev, w1); 99132f7629SAshley Lai } 100132f7629SAshley Lai 101132f7629SAshley Lai /** 102132f7629SAshley Lai * tpm_ibmvtpm_recv - Receive data after send 10393c12f29SWinkler, Tomas * 104132f7629SAshley Lai * @chip: tpm chip struct 105132f7629SAshley Lai * @buf: buffer to read 10693c12f29SWinkler, Tomas * @count: size of buffer 107132f7629SAshley Lai * 10893c12f29SWinkler, Tomas * Return: 109132f7629SAshley Lai * Number of bytes read 110132f7629SAshley Lai */ 111132f7629SAshley Lai static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) 112132f7629SAshley Lai { 1139e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 114132f7629SAshley Lai u16 len; 115b5666502SAshley Lai int sig; 116132f7629SAshley Lai 117132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 118132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 119132f7629SAshley Lai return 0; 120132f7629SAshley Lai } 121132f7629SAshley Lai 1226674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 123b5666502SAshley Lai if (sig) 124b5666502SAshley Lai return -EINTR; 125132f7629SAshley Lai 126b5666502SAshley Lai len = ibmvtpm->res_len; 127b5666502SAshley Lai 128b5666502SAshley Lai if (count < len) { 129132f7629SAshley Lai dev_err(ibmvtpm->dev, 13037ab0341SJason Gunthorpe "Invalid size in recv: count=%zd, crq_size=%d\n", 131b5666502SAshley Lai count, len); 132132f7629SAshley Lai return -EIO; 133132f7629SAshley Lai } 134132f7629SAshley Lai 135132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 136b5666502SAshley Lai memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len); 137b5666502SAshley Lai memset(ibmvtpm->rtce_buf, 0, len); 138b5666502SAshley Lai ibmvtpm->res_len = 0; 139132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 140132f7629SAshley Lai return len; 141132f7629SAshley Lai } 142132f7629SAshley Lai 143132f7629SAshley Lai /** 144132f7629SAshley Lai * tpm_ibmvtpm_send - Send tpm request 14593c12f29SWinkler, Tomas * 146132f7629SAshley Lai * @chip: tpm chip struct 147132f7629SAshley Lai * @buf: buffer contains data to send 14893c12f29SWinkler, Tomas * @count: size of buffer 149132f7629SAshley Lai * 15093c12f29SWinkler, Tomas * Return: 15193c12f29SWinkler, Tomas * Number of bytes sent or < 0 on error. 152132f7629SAshley Lai */ 153132f7629SAshley Lai static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) 154132f7629SAshley Lai { 1559e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 1566674ff14SStefan Berger int rc, sig; 157132f7629SAshley Lai 158132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 159132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 160132f7629SAshley Lai return 0; 161132f7629SAshley Lai } 162132f7629SAshley Lai 163132f7629SAshley Lai if (count > ibmvtpm->rtce_size) { 164132f7629SAshley Lai dev_err(ibmvtpm->dev, 16537ab0341SJason Gunthorpe "Invalid size in send: count=%zd, rtce_size=%d\n", 166132f7629SAshley Lai count, ibmvtpm->rtce_size); 167132f7629SAshley Lai return -EIO; 168132f7629SAshley Lai } 169132f7629SAshley Lai 1706674ff14SStefan Berger if (ibmvtpm->tpm_processing_cmd) { 1716674ff14SStefan Berger dev_info(ibmvtpm->dev, 1726674ff14SStefan Berger "Need to wait for TPM to finish\n"); 1736674ff14SStefan Berger /* wait for previous command to finish */ 1746674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 1756674ff14SStefan Berger if (sig) 1766674ff14SStefan Berger return -EINTR; 1776674ff14SStefan Berger } 1786674ff14SStefan Berger 179132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 1806674ff14SStefan Berger ibmvtpm->res_len = 0; 181132f7629SAshley Lai memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); 182132f7629SAshley Lai 1836674ff14SStefan Berger /* 1846674ff14SStefan Berger * set the processing flag before the Hcall, since we may get the 1856674ff14SStefan Berger * result (interrupt) before even being able to check rc. 1866674ff14SStefan Berger */ 1876674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = true; 1886674ff14SStefan Berger 189*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq(ibmvtpm->vdev, 190*fb154e0eSMichal Suchanek IBMVTPM_VALID_CMD, VTPM_TPM_COMMAND, 191*fb154e0eSMichal Suchanek count, ibmvtpm->rtce_dma_handle); 192132f7629SAshley Lai if (rc != H_SUCCESS) { 193132f7629SAshley Lai dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc); 194132f7629SAshley Lai rc = 0; 1956674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 196132f7629SAshley Lai } else 197132f7629SAshley Lai rc = count; 198132f7629SAshley Lai 199132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 200132f7629SAshley Lai return rc; 201132f7629SAshley Lai } 202132f7629SAshley Lai 203132f7629SAshley Lai static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) 204132f7629SAshley Lai { 205132f7629SAshley Lai return; 206132f7629SAshley Lai } 207132f7629SAshley Lai 208132f7629SAshley Lai static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) 209132f7629SAshley Lai { 210132f7629SAshley Lai return 0; 211132f7629SAshley Lai } 212132f7629SAshley Lai 213132f7629SAshley Lai /** 214132f7629SAshley Lai * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size 21593c12f29SWinkler, Tomas * 216132f7629SAshley Lai * @ibmvtpm: vtpm device struct 217132f7629SAshley Lai * 21893c12f29SWinkler, Tomas * Return: 21993c12f29SWinkler, Tomas * 0 on success. 22093c12f29SWinkler, Tomas * Non-zero on failure. 221132f7629SAshley Lai */ 222132f7629SAshley Lai static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) 223132f7629SAshley Lai { 224132f7629SAshley Lai int rc; 225132f7629SAshley Lai 226*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq(ibmvtpm->vdev, 227*fb154e0eSMichal Suchanek IBMVTPM_VALID_CMD, VTPM_GET_RTCE_BUFFER_SIZE, 0, 0); 228132f7629SAshley Lai if (rc != H_SUCCESS) 229132f7629SAshley Lai dev_err(ibmvtpm->dev, 230132f7629SAshley Lai "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc); 231132f7629SAshley Lai 232132f7629SAshley Lai return rc; 233132f7629SAshley Lai } 234132f7629SAshley Lai 235132f7629SAshley Lai /** 236132f7629SAshley Lai * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version 237132f7629SAshley Lai * - Note that this is vtpm version and not tpm version 23893c12f29SWinkler, Tomas * 239132f7629SAshley Lai * @ibmvtpm: vtpm device struct 240132f7629SAshley Lai * 24193c12f29SWinkler, Tomas * Return: 24293c12f29SWinkler, Tomas * 0 on success. 24393c12f29SWinkler, Tomas * Non-zero on failure. 244132f7629SAshley Lai */ 245132f7629SAshley Lai static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm) 246132f7629SAshley Lai { 247132f7629SAshley Lai int rc; 248132f7629SAshley Lai 249*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq(ibmvtpm->vdev, 250*fb154e0eSMichal Suchanek IBMVTPM_VALID_CMD, VTPM_GET_VERSION, 0, 0); 251132f7629SAshley Lai if (rc != H_SUCCESS) 252132f7629SAshley Lai dev_err(ibmvtpm->dev, 253132f7629SAshley Lai "ibmvtpm_crq_get_version failed rc=%d\n", rc); 254132f7629SAshley Lai 255132f7629SAshley Lai return rc; 256132f7629SAshley Lai } 257132f7629SAshley Lai 258132f7629SAshley Lai /** 259132f7629SAshley Lai * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message 260132f7629SAshley Lai * @ibmvtpm: vtpm device struct 261132f7629SAshley Lai * 26293c12f29SWinkler, Tomas * Return: 26393c12f29SWinkler, Tomas * 0 on success. 26493c12f29SWinkler, Tomas * Non-zero on failure. 265132f7629SAshley Lai */ 266132f7629SAshley Lai static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) 267132f7629SAshley Lai { 268132f7629SAshley Lai int rc; 269132f7629SAshley Lai 270*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_COMP_CMD); 271132f7629SAshley Lai if (rc != H_SUCCESS) 272132f7629SAshley Lai dev_err(ibmvtpm->dev, 273132f7629SAshley Lai "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc); 274132f7629SAshley Lai 275132f7629SAshley Lai return rc; 276132f7629SAshley Lai } 277132f7629SAshley Lai 278132f7629SAshley Lai /** 279132f7629SAshley Lai * ibmvtpm_crq_send_init - Send a CRQ initialize message 280132f7629SAshley Lai * @ibmvtpm: vtpm device struct 281132f7629SAshley Lai * 28293c12f29SWinkler, Tomas * Return: 28393c12f29SWinkler, Tomas * 0 on success. 28493c12f29SWinkler, Tomas * Non-zero on failure. 285132f7629SAshley Lai */ 286132f7629SAshley Lai static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) 287132f7629SAshley Lai { 288132f7629SAshley Lai int rc; 289132f7629SAshley Lai 290*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq_word(ibmvtpm->vdev, INIT_CRQ_CMD); 291132f7629SAshley Lai if (rc != H_SUCCESS) 292132f7629SAshley Lai dev_err(ibmvtpm->dev, 293132f7629SAshley Lai "ibmvtpm_crq_send_init failed rc=%d\n", rc); 294132f7629SAshley Lai 295132f7629SAshley Lai return rc; 296132f7629SAshley Lai } 297132f7629SAshley Lai 298132f7629SAshley Lai /** 299132f7629SAshley Lai * tpm_ibmvtpm_remove - ibm vtpm remove entry point 300132f7629SAshley Lai * @vdev: vio device struct 301132f7629SAshley Lai * 30293c12f29SWinkler, Tomas * Return: Always 0. 303132f7629SAshley Lai */ 30439af33fcSBill Pemberton static int tpm_ibmvtpm_remove(struct vio_dev *vdev) 305132f7629SAshley Lai { 3069e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 3079e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 308132f7629SAshley Lai int rc = 0; 309132f7629SAshley Lai 310afb5abc2SJarkko Sakkinen tpm_chip_unregister(chip); 311afb5abc2SJarkko Sakkinen 312132f7629SAshley Lai free_irq(vdev->irq, ibmvtpm); 313132f7629SAshley Lai 314132f7629SAshley Lai do { 315132f7629SAshley Lai if (rc) 316132f7629SAshley Lai msleep(100); 317132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 318132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 319132f7629SAshley Lai 320132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, 321132f7629SAshley Lai CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); 322132f7629SAshley Lai free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); 323132f7629SAshley Lai 324132f7629SAshley Lai if (ibmvtpm->rtce_buf) { 325132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, 326132f7629SAshley Lai ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); 327132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 328132f7629SAshley Lai } 329132f7629SAshley Lai 330132f7629SAshley Lai kfree(ibmvtpm); 33131574d32SHon Ching \(Vicky\) Lo /* For tpm_ibmvtpm_get_desired_dma */ 33231574d32SHon Ching \(Vicky\) Lo dev_set_drvdata(&vdev->dev, NULL); 333132f7629SAshley Lai 334132f7629SAshley Lai return 0; 335132f7629SAshley Lai } 336132f7629SAshley Lai 337132f7629SAshley Lai /** 338132f7629SAshley Lai * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 339132f7629SAshley Lai * @vdev: vio device struct 340132f7629SAshley Lai * 34193c12f29SWinkler, Tomas * Return: 34293c12f29SWinkler, Tomas * Number of bytes the driver needs to DMA map. 343132f7629SAshley Lai */ 344132f7629SAshley Lai static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 345132f7629SAshley Lai { 3469e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 34731574d32SHon Ching \(Vicky\) Lo struct ibmvtpm_dev *ibmvtpm; 34884eb186bSHon Ching (Vicky) Lo 34993c12f29SWinkler, Tomas /* 35093c12f29SWinkler, Tomas * ibmvtpm initializes at probe time, so the data we are 35184eb186bSHon Ching (Vicky) Lo * asking for may not be set yet. Estimate that 4K required 35284eb186bSHon Ching (Vicky) Lo * for TCE-mapped buffer in addition to CRQ. 35384eb186bSHon Ching (Vicky) Lo */ 35431574d32SHon Ching \(Vicky\) Lo if (chip) 35531574d32SHon Ching \(Vicky\) Lo ibmvtpm = dev_get_drvdata(&chip->dev); 35631574d32SHon Ching \(Vicky\) Lo else 35784eb186bSHon Ching (Vicky) Lo return CRQ_RES_BUF_SIZE + PAGE_SIZE; 35884eb186bSHon Ching (Vicky) Lo 359132f7629SAshley Lai return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 360132f7629SAshley Lai } 361132f7629SAshley Lai 362132f7629SAshley Lai /** 363132f7629SAshley Lai * tpm_ibmvtpm_suspend - Suspend 364132f7629SAshley Lai * @dev: device struct 365132f7629SAshley Lai * 36693c12f29SWinkler, Tomas * Return: Always 0. 367132f7629SAshley Lai */ 368132f7629SAshley Lai static int tpm_ibmvtpm_suspend(struct device *dev) 369132f7629SAshley Lai { 3709e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 3719e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 372132f7629SAshley Lai int rc = 0; 373132f7629SAshley Lai 374*fb154e0eSMichal Suchanek rc = ibmvtpm_send_crq(ibmvtpm->vdev, 375*fb154e0eSMichal Suchanek IBMVTPM_VALID_CMD, VTPM_PREPARE_TO_SUSPEND, 0, 0); 376132f7629SAshley Lai if (rc != H_SUCCESS) 377132f7629SAshley Lai dev_err(ibmvtpm->dev, 378132f7629SAshley Lai "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 379132f7629SAshley Lai 380132f7629SAshley Lai return rc; 381132f7629SAshley Lai } 382132f7629SAshley Lai 383132f7629SAshley Lai /** 384132f7629SAshley Lai * ibmvtpm_reset_crq - Reset CRQ 38593c12f29SWinkler, Tomas * 386132f7629SAshley Lai * @ibmvtpm: ibm vtpm struct 387132f7629SAshley Lai * 38893c12f29SWinkler, Tomas * Return: 38993c12f29SWinkler, Tomas * 0 on success. 39093c12f29SWinkler, Tomas * Non-zero on failure. 391132f7629SAshley Lai */ 392132f7629SAshley Lai static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 393132f7629SAshley Lai { 394132f7629SAshley Lai int rc = 0; 395132f7629SAshley Lai 396132f7629SAshley Lai do { 397132f7629SAshley Lai if (rc) 398132f7629SAshley Lai msleep(100); 399132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, 400132f7629SAshley Lai ibmvtpm->vdev->unit_address); 401132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 402132f7629SAshley Lai 403132f7629SAshley Lai memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 404132f7629SAshley Lai ibmvtpm->crq_queue.index = 0; 405132f7629SAshley Lai 406132f7629SAshley Lai return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 407132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 408132f7629SAshley Lai } 409132f7629SAshley Lai 410132f7629SAshley Lai /** 411132f7629SAshley Lai * tpm_ibmvtpm_resume - Resume from suspend 41293c12f29SWinkler, Tomas * 413132f7629SAshley Lai * @dev: device struct 414132f7629SAshley Lai * 41593c12f29SWinkler, Tomas * Return: Always 0. 416132f7629SAshley Lai */ 417132f7629SAshley Lai static int tpm_ibmvtpm_resume(struct device *dev) 418132f7629SAshley Lai { 4199e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 4209e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 421132f7629SAshley Lai int rc = 0; 422132f7629SAshley Lai 423132f7629SAshley Lai do { 424132f7629SAshley Lai if (rc) 425132f7629SAshley Lai msleep(100); 426132f7629SAshley Lai rc = plpar_hcall_norets(H_ENABLE_CRQ, 427132f7629SAshley Lai ibmvtpm->vdev->unit_address); 428132f7629SAshley Lai } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); 429132f7629SAshley Lai 430132f7629SAshley Lai if (rc) { 431132f7629SAshley Lai dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc); 432132f7629SAshley Lai return rc; 433132f7629SAshley Lai } 434132f7629SAshley Lai 435b5666502SAshley Lai rc = vio_enable_interrupts(ibmvtpm->vdev); 436b5666502SAshley Lai if (rc) { 437b5666502SAshley Lai dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc); 438b5666502SAshley Lai return rc; 439b5666502SAshley Lai } 440132f7629SAshley Lai 441132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 442132f7629SAshley Lai if (rc) 443132f7629SAshley Lai dev_err(dev, "Error send_init rc=%d\n", rc); 444132f7629SAshley Lai 445132f7629SAshley Lai return rc; 446132f7629SAshley Lai } 447132f7629SAshley Lai 4481f866057SStefan Berger static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) 4491f866057SStefan Berger { 4501f866057SStefan Berger return (status == 0); 4511f866057SStefan Berger } 4521f866057SStefan Berger 45301ad1fa7SJason Gunthorpe static const struct tpm_class_ops tpm_ibmvtpm = { 454132f7629SAshley Lai .recv = tpm_ibmvtpm_recv, 455132f7629SAshley Lai .send = tpm_ibmvtpm_send, 456132f7629SAshley Lai .cancel = tpm_ibmvtpm_cancel, 457132f7629SAshley Lai .status = tpm_ibmvtpm_status, 458132f7629SAshley Lai .req_complete_mask = 0, 459132f7629SAshley Lai .req_complete_val = 0, 4601f866057SStefan Berger .req_canceled = tpm_ibmvtpm_req_canceled, 461132f7629SAshley Lai }; 462132f7629SAshley Lai 463132f7629SAshley Lai static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 464132f7629SAshley Lai .suspend = tpm_ibmvtpm_suspend, 465132f7629SAshley Lai .resume = tpm_ibmvtpm_resume, 466132f7629SAshley Lai }; 467132f7629SAshley Lai 468132f7629SAshley Lai /** 469132f7629SAshley Lai * ibmvtpm_crq_get_next - Get next responded crq 470132f7629SAshley Lai * 47193c12f29SWinkler, Tomas * @ibmvtpm: vtpm device struct 47293c12f29SWinkler, Tomas * 47393c12f29SWinkler, Tomas * Return: vtpm crq pointer or NULL. 474132f7629SAshley Lai */ 475132f7629SAshley Lai static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 476132f7629SAshley Lai { 477132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 478132f7629SAshley Lai struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 479132f7629SAshley Lai 480132f7629SAshley Lai if (crq->valid & VTPM_MSG_RES) { 481132f7629SAshley Lai if (++crq_q->index == crq_q->num_entry) 482132f7629SAshley Lai crq_q->index = 0; 483b5666502SAshley Lai smp_rmb(); 484132f7629SAshley Lai } else 485132f7629SAshley Lai crq = NULL; 486132f7629SAshley Lai return crq; 487132f7629SAshley Lai } 488132f7629SAshley Lai 489132f7629SAshley Lai /** 490132f7629SAshley Lai * ibmvtpm_crq_process - Process responded crq 491132f7629SAshley Lai * 49293c12f29SWinkler, Tomas * @crq: crq to be processed 49393c12f29SWinkler, Tomas * @ibmvtpm: vtpm device struct 49493c12f29SWinkler, Tomas * 495132f7629SAshley Lai */ 496132f7629SAshley Lai static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 497132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm) 498132f7629SAshley Lai { 499132f7629SAshley Lai int rc = 0; 500132f7629SAshley Lai 501132f7629SAshley Lai switch (crq->valid) { 502132f7629SAshley Lai case VALID_INIT_CRQ: 503132f7629SAshley Lai switch (crq->msg) { 504132f7629SAshley Lai case INIT_CRQ_RES: 505132f7629SAshley Lai dev_info(ibmvtpm->dev, "CRQ initialized\n"); 506132f7629SAshley Lai rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 507132f7629SAshley Lai if (rc) 508132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 509132f7629SAshley Lai return; 510132f7629SAshley Lai case INIT_CRQ_COMP_RES: 511132f7629SAshley Lai dev_info(ibmvtpm->dev, 512132f7629SAshley Lai "CRQ initialization completed\n"); 513132f7629SAshley Lai return; 514132f7629SAshley Lai default: 515132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 516132f7629SAshley Lai return; 517132f7629SAshley Lai } 518132f7629SAshley Lai case IBMVTPM_VALID_CMD: 519132f7629SAshley Lai switch (crq->msg) { 520132f7629SAshley Lai case VTPM_GET_RTCE_BUFFER_SIZE_RES: 521eb71f8a5Shonclo if (be16_to_cpu(crq->len) <= 0) { 522132f7629SAshley Lai dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 523132f7629SAshley Lai return; 524132f7629SAshley Lai } 525eb71f8a5Shonclo ibmvtpm->rtce_size = be16_to_cpu(crq->len); 526132f7629SAshley Lai ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 52760ecd86cSHon Ching \(Vicky\) Lo GFP_ATOMIC); 528132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 529132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 530132f7629SAshley Lai return; 531132f7629SAshley Lai } 532132f7629SAshley Lai 533132f7629SAshley Lai ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 534132f7629SAshley Lai ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 535132f7629SAshley Lai DMA_BIDIRECTIONAL); 536132f7629SAshley Lai 537132f7629SAshley Lai if (dma_mapping_error(ibmvtpm->dev, 538132f7629SAshley Lai ibmvtpm->rtce_dma_handle)) { 539132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 540132f7629SAshley Lai ibmvtpm->rtce_buf = NULL; 541132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 542132f7629SAshley Lai } 543132f7629SAshley Lai 544132f7629SAshley Lai return; 545132f7629SAshley Lai case VTPM_GET_VERSION_RES: 546eb71f8a5Shonclo ibmvtpm->vtpm_version = be32_to_cpu(crq->data); 547132f7629SAshley Lai return; 548132f7629SAshley Lai case VTPM_TPM_COMMAND_RES: 549b5666502SAshley Lai /* len of the data in rtce buffer */ 550eb71f8a5Shonclo ibmvtpm->res_len = be16_to_cpu(crq->len); 5516674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 552b5666502SAshley Lai wake_up_interruptible(&ibmvtpm->wq); 553132f7629SAshley Lai return; 554132f7629SAshley Lai default: 555132f7629SAshley Lai return; 556132f7629SAshley Lai } 557132f7629SAshley Lai } 558132f7629SAshley Lai return; 559132f7629SAshley Lai } 560132f7629SAshley Lai 561132f7629SAshley Lai /** 562132f7629SAshley Lai * ibmvtpm_interrupt - Interrupt handler 56393c12f29SWinkler, Tomas * 564132f7629SAshley Lai * @irq: irq number to handle 565132f7629SAshley Lai * @vtpm_instance: vtpm that received interrupt 566132f7629SAshley Lai * 567132f7629SAshley Lai * Returns: 568132f7629SAshley Lai * IRQ_HANDLED 569132f7629SAshley Lai **/ 570132f7629SAshley Lai static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 571132f7629SAshley Lai { 572132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 573132f7629SAshley Lai struct ibmvtpm_crq *crq; 574132f7629SAshley Lai 575b5666502SAshley Lai /* while loop is needed for initial setup (get version and 576b5666502SAshley Lai * get rtce_size). There should be only one tpm request at any 577b5666502SAshley Lai * given time. 578b5666502SAshley Lai */ 579132f7629SAshley Lai while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 580132f7629SAshley Lai ibmvtpm_crq_process(crq, ibmvtpm); 581132f7629SAshley Lai crq->valid = 0; 582b5666502SAshley Lai smp_wmb(); 583132f7629SAshley Lai } 584132f7629SAshley Lai 585b5666502SAshley Lai return IRQ_HANDLED; 586132f7629SAshley Lai } 587132f7629SAshley Lai 588132f7629SAshley Lai /** 589132f7629SAshley Lai * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 59093c12f29SWinkler, Tomas * 591132f7629SAshley Lai * @vio_dev: vio device struct 592132f7629SAshley Lai * @id: vio device id struct 593132f7629SAshley Lai * 59493c12f29SWinkler, Tomas * Return: 59593c12f29SWinkler, Tomas * 0 on success. 59693c12f29SWinkler, Tomas * Non-zero on failure. 597132f7629SAshley Lai */ 598afc6d369SBill Pemberton static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 599132f7629SAshley Lai const struct vio_device_id *id) 600132f7629SAshley Lai { 601132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 602132f7629SAshley Lai struct device *dev = &vio_dev->dev; 603132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q; 604132f7629SAshley Lai struct tpm_chip *chip; 605132f7629SAshley Lai int rc = -ENOMEM, rc1; 606132f7629SAshley Lai 607afb5abc2SJarkko Sakkinen chip = tpmm_chip_alloc(dev, &tpm_ibmvtpm); 608afb5abc2SJarkko Sakkinen if (IS_ERR(chip)) 609afb5abc2SJarkko Sakkinen return PTR_ERR(chip); 610132f7629SAshley Lai 611132f7629SAshley Lai ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 612132f7629SAshley Lai if (!ibmvtpm) { 613132f7629SAshley Lai dev_err(dev, "kzalloc for ibmvtpm failed\n"); 614132f7629SAshley Lai goto cleanup; 615132f7629SAshley Lai } 616132f7629SAshley Lai 6179d75f089SHon Ching \(Vicky\) Lo ibmvtpm->dev = dev; 6189d75f089SHon Ching \(Vicky\) Lo ibmvtpm->vdev = vio_dev; 6199d75f089SHon Ching \(Vicky\) Lo 620132f7629SAshley Lai crq_q = &ibmvtpm->crq_queue; 621132f7629SAshley Lai crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 622132f7629SAshley Lai if (!crq_q->crq_addr) { 623132f7629SAshley Lai dev_err(dev, "Unable to allocate memory for crq_addr\n"); 624132f7629SAshley Lai goto cleanup; 625132f7629SAshley Lai } 626132f7629SAshley Lai 627132f7629SAshley Lai crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 628132f7629SAshley Lai ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 629132f7629SAshley Lai CRQ_RES_BUF_SIZE, 630132f7629SAshley Lai DMA_BIDIRECTIONAL); 631132f7629SAshley Lai 632132f7629SAshley Lai if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 633132f7629SAshley Lai dev_err(dev, "dma mapping failed\n"); 634132f7629SAshley Lai goto cleanup; 635132f7629SAshley Lai } 636132f7629SAshley Lai 637132f7629SAshley Lai rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 638132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 639132f7629SAshley Lai if (rc == H_RESOURCE) 640132f7629SAshley Lai rc = ibmvtpm_reset_crq(ibmvtpm); 641132f7629SAshley Lai 642132f7629SAshley Lai if (rc) { 643132f7629SAshley Lai dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 644132f7629SAshley Lai goto reg_crq_cleanup; 645132f7629SAshley Lai } 646132f7629SAshley Lai 647132f7629SAshley Lai rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 648132f7629SAshley Lai tpm_ibmvtpm_driver_name, ibmvtpm); 649132f7629SAshley Lai if (rc) { 650132f7629SAshley Lai dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 651132f7629SAshley Lai goto init_irq_cleanup; 652132f7629SAshley Lai } 653132f7629SAshley Lai 654132f7629SAshley Lai rc = vio_enable_interrupts(vio_dev); 655132f7629SAshley Lai if (rc) { 656132f7629SAshley Lai dev_err(dev, "Error %d enabling interrupts\n", rc); 657132f7629SAshley Lai goto init_irq_cleanup; 658132f7629SAshley Lai } 659132f7629SAshley Lai 660b5666502SAshley Lai init_waitqueue_head(&ibmvtpm->wq); 661b5666502SAshley Lai 662132f7629SAshley Lai crq_q->index = 0; 663132f7629SAshley Lai 66475254557SStephen Rothwell dev_set_drvdata(&chip->dev, ibmvtpm); 665132f7629SAshley Lai 666132f7629SAshley Lai spin_lock_init(&ibmvtpm->rtce_lock); 667132f7629SAshley Lai 668132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 669132f7629SAshley Lai if (rc) 670132f7629SAshley Lai goto init_irq_cleanup; 671132f7629SAshley Lai 672132f7629SAshley Lai rc = ibmvtpm_crq_get_version(ibmvtpm); 673132f7629SAshley Lai if (rc) 674132f7629SAshley Lai goto init_irq_cleanup; 675132f7629SAshley Lai 676132f7629SAshley Lai rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 677132f7629SAshley Lai if (rc) 678132f7629SAshley Lai goto init_irq_cleanup; 679132f7629SAshley Lai 680afb5abc2SJarkko Sakkinen return tpm_chip_register(chip); 681132f7629SAshley Lai init_irq_cleanup: 682132f7629SAshley Lai do { 683132f7629SAshley Lai rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 684132f7629SAshley Lai } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 685132f7629SAshley Lai reg_crq_cleanup: 686132f7629SAshley Lai dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 687132f7629SAshley Lai DMA_BIDIRECTIONAL); 688132f7629SAshley Lai cleanup: 689132f7629SAshley Lai if (ibmvtpm) { 690132f7629SAshley Lai if (crq_q->crq_addr) 691132f7629SAshley Lai free_page((unsigned long)crq_q->crq_addr); 692132f7629SAshley Lai kfree(ibmvtpm); 693132f7629SAshley Lai } 694132f7629SAshley Lai 695132f7629SAshley Lai return rc; 696132f7629SAshley Lai } 697132f7629SAshley Lai 698132f7629SAshley Lai static struct vio_driver ibmvtpm_driver = { 699132f7629SAshley Lai .id_table = tpm_ibmvtpm_device_table, 700132f7629SAshley Lai .probe = tpm_ibmvtpm_probe, 701132f7629SAshley Lai .remove = tpm_ibmvtpm_remove, 702132f7629SAshley Lai .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 703132f7629SAshley Lai .name = tpm_ibmvtpm_driver_name, 704132f7629SAshley Lai .pm = &tpm_ibmvtpm_pm_ops, 705132f7629SAshley Lai }; 706132f7629SAshley Lai 707132f7629SAshley Lai /** 70893c12f29SWinkler, Tomas * ibmvtpm_module_init - Initialize ibm vtpm module. 709132f7629SAshley Lai * 71093c12f29SWinkler, Tomas * 71193c12f29SWinkler, Tomas * Return: 71293c12f29SWinkler, Tomas * 0 on success. 71393c12f29SWinkler, Tomas * Non-zero on failure. 714132f7629SAshley Lai */ 715132f7629SAshley Lai static int __init ibmvtpm_module_init(void) 716132f7629SAshley Lai { 717132f7629SAshley Lai return vio_register_driver(&ibmvtpm_driver); 718132f7629SAshley Lai } 719132f7629SAshley Lai 720132f7629SAshley Lai /** 72193c12f29SWinkler, Tomas * ibmvtpm_module_exit - Tear down ibm vtpm module. 722132f7629SAshley Lai */ 723132f7629SAshley Lai static void __exit ibmvtpm_module_exit(void) 724132f7629SAshley Lai { 725132f7629SAshley Lai vio_unregister_driver(&ibmvtpm_driver); 726132f7629SAshley Lai } 727132f7629SAshley Lai 728132f7629SAshley Lai module_init(ibmvtpm_module_init); 729132f7629SAshley Lai module_exit(ibmvtpm_module_exit); 730132f7629SAshley Lai 731132f7629SAshley Lai MODULE_AUTHOR("adlai@us.ibm.com"); 732132f7629SAshley Lai MODULE_DESCRIPTION("IBM vTPM Driver"); 733132f7629SAshley Lai MODULE_VERSION("1.0"); 734132f7629SAshley Lai MODULE_LICENSE("GPL"); 735