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 350bbed20eSBill Pemberton static 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 /** 42132f7629SAshley Lai * ibmvtpm_send_crq - Send a CRQ request 43*93c12f29SWinkler, Tomas * 44132f7629SAshley Lai * @vdev: vio device struct 45132f7629SAshley Lai * @w1: first word 46132f7629SAshley Lai * @w2: second word 47132f7629SAshley Lai * 48*93c12f29SWinkler, Tomas * Return: 49132f7629SAshley Lai * 0 -Sucess 50132f7629SAshley Lai * Non-zero - Failure 51132f7629SAshley Lai */ 52132f7629SAshley Lai static int ibmvtpm_send_crq(struct vio_dev *vdev, u64 w1, u64 w2) 53132f7629SAshley Lai { 54132f7629SAshley Lai return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, w2); 55132f7629SAshley Lai } 56132f7629SAshley Lai 57132f7629SAshley Lai /** 58132f7629SAshley Lai * tpm_ibmvtpm_recv - Receive data after send 59*93c12f29SWinkler, Tomas * 60132f7629SAshley Lai * @chip: tpm chip struct 61132f7629SAshley Lai * @buf: buffer to read 62*93c12f29SWinkler, Tomas * @count: size of buffer 63132f7629SAshley Lai * 64*93c12f29SWinkler, Tomas * Return: 65132f7629SAshley Lai * Number of bytes read 66132f7629SAshley Lai */ 67132f7629SAshley Lai static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) 68132f7629SAshley Lai { 699e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 70132f7629SAshley Lai u16 len; 71b5666502SAshley Lai int sig; 72132f7629SAshley Lai 73132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 74132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 75132f7629SAshley Lai return 0; 76132f7629SAshley Lai } 77132f7629SAshley Lai 786674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 79b5666502SAshley Lai if (sig) 80b5666502SAshley Lai return -EINTR; 81132f7629SAshley Lai 82b5666502SAshley Lai len = ibmvtpm->res_len; 83b5666502SAshley Lai 84b5666502SAshley Lai if (count < len) { 85132f7629SAshley Lai dev_err(ibmvtpm->dev, 8637ab0341SJason Gunthorpe "Invalid size in recv: count=%zd, crq_size=%d\n", 87b5666502SAshley Lai count, len); 88132f7629SAshley Lai return -EIO; 89132f7629SAshley Lai } 90132f7629SAshley Lai 91132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 92b5666502SAshley Lai memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len); 93b5666502SAshley Lai memset(ibmvtpm->rtce_buf, 0, len); 94b5666502SAshley Lai ibmvtpm->res_len = 0; 95132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 96132f7629SAshley Lai return len; 97132f7629SAshley Lai } 98132f7629SAshley Lai 99132f7629SAshley Lai /** 100132f7629SAshley Lai * tpm_ibmvtpm_send - Send tpm request 101*93c12f29SWinkler, Tomas * 102132f7629SAshley Lai * @chip: tpm chip struct 103132f7629SAshley Lai * @buf: buffer contains data to send 104*93c12f29SWinkler, Tomas * @count: size of buffer 105132f7629SAshley Lai * 106*93c12f29SWinkler, Tomas * Return: 107*93c12f29SWinkler, Tomas * Number of bytes sent or < 0 on error. 108132f7629SAshley Lai */ 109132f7629SAshley Lai static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) 110132f7629SAshley Lai { 1119e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 112132f7629SAshley Lai struct ibmvtpm_crq crq; 11362dfd912Sjmlatten@linux.vnet.ibm.com __be64 *word = (__be64 *)&crq; 1146674ff14SStefan Berger int rc, sig; 115132f7629SAshley Lai 116132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 117132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 118132f7629SAshley Lai return 0; 119132f7629SAshley Lai } 120132f7629SAshley Lai 121132f7629SAshley Lai if (count > ibmvtpm->rtce_size) { 122132f7629SAshley Lai dev_err(ibmvtpm->dev, 12337ab0341SJason Gunthorpe "Invalid size in send: count=%zd, rtce_size=%d\n", 124132f7629SAshley Lai count, ibmvtpm->rtce_size); 125132f7629SAshley Lai return -EIO; 126132f7629SAshley Lai } 127132f7629SAshley Lai 1286674ff14SStefan Berger if (ibmvtpm->tpm_processing_cmd) { 1296674ff14SStefan Berger dev_info(ibmvtpm->dev, 1306674ff14SStefan Berger "Need to wait for TPM to finish\n"); 1316674ff14SStefan Berger /* wait for previous command to finish */ 1326674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 1336674ff14SStefan Berger if (sig) 1346674ff14SStefan Berger return -EINTR; 1356674ff14SStefan Berger } 1366674ff14SStefan Berger 137132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 1386674ff14SStefan Berger ibmvtpm->res_len = 0; 139132f7629SAshley Lai memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); 140132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 141132f7629SAshley Lai crq.msg = (u8)VTPM_TPM_COMMAND; 14262dfd912Sjmlatten@linux.vnet.ibm.com crq.len = cpu_to_be16(count); 14362dfd912Sjmlatten@linux.vnet.ibm.com crq.data = cpu_to_be32(ibmvtpm->rtce_dma_handle); 144132f7629SAshley Lai 1456674ff14SStefan Berger /* 1466674ff14SStefan Berger * set the processing flag before the Hcall, since we may get the 1476674ff14SStefan Berger * result (interrupt) before even being able to check rc. 1486674ff14SStefan Berger */ 1496674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = true; 1506674ff14SStefan Berger 15162dfd912Sjmlatten@linux.vnet.ibm.com rc = ibmvtpm_send_crq(ibmvtpm->vdev, be64_to_cpu(word[0]), 15262dfd912Sjmlatten@linux.vnet.ibm.com be64_to_cpu(word[1])); 153132f7629SAshley Lai if (rc != H_SUCCESS) { 154132f7629SAshley Lai dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc); 155132f7629SAshley Lai rc = 0; 1566674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 157132f7629SAshley Lai } else 158132f7629SAshley Lai rc = count; 159132f7629SAshley Lai 160132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 161132f7629SAshley Lai return rc; 162132f7629SAshley Lai } 163132f7629SAshley Lai 164132f7629SAshley Lai static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) 165132f7629SAshley Lai { 166132f7629SAshley Lai return; 167132f7629SAshley Lai } 168132f7629SAshley Lai 169132f7629SAshley Lai static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) 170132f7629SAshley Lai { 171132f7629SAshley Lai return 0; 172132f7629SAshley Lai } 173132f7629SAshley Lai 174132f7629SAshley Lai /** 175132f7629SAshley Lai * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size 176*93c12f29SWinkler, Tomas * 177132f7629SAshley Lai * @ibmvtpm: vtpm device struct 178132f7629SAshley Lai * 179*93c12f29SWinkler, Tomas * Return: 180*93c12f29SWinkler, Tomas * 0 on success. 181*93c12f29SWinkler, Tomas * Non-zero on failure. 182132f7629SAshley Lai */ 183132f7629SAshley Lai static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) 184132f7629SAshley Lai { 185132f7629SAshley Lai struct ibmvtpm_crq crq; 186132f7629SAshley Lai u64 *buf = (u64 *) &crq; 187132f7629SAshley Lai int rc; 188132f7629SAshley Lai 189132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 190132f7629SAshley Lai crq.msg = (u8)VTPM_GET_RTCE_BUFFER_SIZE; 191132f7629SAshley Lai 192eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 193eb71f8a5Shonclo cpu_to_be64(buf[1])); 194132f7629SAshley Lai if (rc != H_SUCCESS) 195132f7629SAshley Lai dev_err(ibmvtpm->dev, 196132f7629SAshley Lai "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc); 197132f7629SAshley Lai 198132f7629SAshley Lai return rc; 199132f7629SAshley Lai } 200132f7629SAshley Lai 201132f7629SAshley Lai /** 202132f7629SAshley Lai * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version 203132f7629SAshley Lai * - Note that this is vtpm version and not tpm version 204*93c12f29SWinkler, Tomas * 205132f7629SAshley Lai * @ibmvtpm: vtpm device struct 206132f7629SAshley Lai * 207*93c12f29SWinkler, Tomas * Return: 208*93c12f29SWinkler, Tomas * 0 on success. 209*93c12f29SWinkler, Tomas * Non-zero on failure. 210132f7629SAshley Lai */ 211132f7629SAshley Lai static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm) 212132f7629SAshley Lai { 213132f7629SAshley Lai struct ibmvtpm_crq crq; 214132f7629SAshley Lai u64 *buf = (u64 *) &crq; 215132f7629SAshley Lai int rc; 216132f7629SAshley Lai 217132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 218132f7629SAshley Lai crq.msg = (u8)VTPM_GET_VERSION; 219132f7629SAshley Lai 220eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 221eb71f8a5Shonclo cpu_to_be64(buf[1])); 222132f7629SAshley Lai if (rc != H_SUCCESS) 223132f7629SAshley Lai dev_err(ibmvtpm->dev, 224132f7629SAshley Lai "ibmvtpm_crq_get_version failed rc=%d\n", rc); 225132f7629SAshley Lai 226132f7629SAshley Lai return rc; 227132f7629SAshley Lai } 228132f7629SAshley Lai 229132f7629SAshley Lai /** 230132f7629SAshley Lai * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message 231132f7629SAshley Lai * @ibmvtpm: vtpm device struct 232132f7629SAshley Lai * 233*93c12f29SWinkler, Tomas * Return: 234*93c12f29SWinkler, Tomas * 0 on success. 235*93c12f29SWinkler, Tomas * Non-zero on failure. 236132f7629SAshley Lai */ 237132f7629SAshley Lai static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) 238132f7629SAshley Lai { 239132f7629SAshley Lai int rc; 240132f7629SAshley Lai 241132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_COMP_CMD, 0); 242132f7629SAshley Lai if (rc != H_SUCCESS) 243132f7629SAshley Lai dev_err(ibmvtpm->dev, 244132f7629SAshley Lai "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc); 245132f7629SAshley Lai 246132f7629SAshley Lai return rc; 247132f7629SAshley Lai } 248132f7629SAshley Lai 249132f7629SAshley Lai /** 250132f7629SAshley Lai * ibmvtpm_crq_send_init - Send a CRQ initialize message 251132f7629SAshley Lai * @ibmvtpm: vtpm device struct 252132f7629SAshley Lai * 253*93c12f29SWinkler, Tomas * Return: 254*93c12f29SWinkler, Tomas * 0 on success. 255*93c12f29SWinkler, Tomas * Non-zero on failure. 256132f7629SAshley Lai */ 257132f7629SAshley Lai static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) 258132f7629SAshley Lai { 259132f7629SAshley Lai int rc; 260132f7629SAshley Lai 261132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_CMD, 0); 262132f7629SAshley Lai if (rc != H_SUCCESS) 263132f7629SAshley Lai dev_err(ibmvtpm->dev, 264132f7629SAshley Lai "ibmvtpm_crq_send_init failed rc=%d\n", rc); 265132f7629SAshley Lai 266132f7629SAshley Lai return rc; 267132f7629SAshley Lai } 268132f7629SAshley Lai 269132f7629SAshley Lai /** 270132f7629SAshley Lai * tpm_ibmvtpm_remove - ibm vtpm remove entry point 271132f7629SAshley Lai * @vdev: vio device struct 272132f7629SAshley Lai * 273*93c12f29SWinkler, Tomas * Return: Always 0. 274132f7629SAshley Lai */ 27539af33fcSBill Pemberton static int tpm_ibmvtpm_remove(struct vio_dev *vdev) 276132f7629SAshley Lai { 2779e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 2789e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 279132f7629SAshley Lai int rc = 0; 280132f7629SAshley Lai 281afb5abc2SJarkko Sakkinen tpm_chip_unregister(chip); 282afb5abc2SJarkko Sakkinen 283132f7629SAshley Lai free_irq(vdev->irq, ibmvtpm); 284132f7629SAshley Lai 285132f7629SAshley Lai do { 286132f7629SAshley Lai if (rc) 287132f7629SAshley Lai msleep(100); 288132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 289132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 290132f7629SAshley Lai 291132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, 292132f7629SAshley Lai CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); 293132f7629SAshley Lai free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); 294132f7629SAshley Lai 295132f7629SAshley Lai if (ibmvtpm->rtce_buf) { 296132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, 297132f7629SAshley Lai ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); 298132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 299132f7629SAshley Lai } 300132f7629SAshley Lai 301132f7629SAshley Lai kfree(ibmvtpm); 302132f7629SAshley Lai 303132f7629SAshley Lai return 0; 304132f7629SAshley Lai } 305132f7629SAshley Lai 306132f7629SAshley Lai /** 307132f7629SAshley Lai * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 308132f7629SAshley Lai * @vdev: vio device struct 309132f7629SAshley Lai * 310*93c12f29SWinkler, Tomas * Return: 311*93c12f29SWinkler, Tomas * Number of bytes the driver needs to DMA map. 312132f7629SAshley Lai */ 313132f7629SAshley Lai static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 314132f7629SAshley Lai { 3159e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 3169e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 31784eb186bSHon Ching (Vicky) Lo 318*93c12f29SWinkler, Tomas /* 319*93c12f29SWinkler, Tomas * ibmvtpm initializes at probe time, so the data we are 32084eb186bSHon Ching (Vicky) Lo * asking for may not be set yet. Estimate that 4K required 32184eb186bSHon Ching (Vicky) Lo * for TCE-mapped buffer in addition to CRQ. 32284eb186bSHon Ching (Vicky) Lo */ 32384eb186bSHon Ching (Vicky) Lo if (!ibmvtpm) 32484eb186bSHon Ching (Vicky) Lo return CRQ_RES_BUF_SIZE + PAGE_SIZE; 32584eb186bSHon Ching (Vicky) Lo 326132f7629SAshley Lai return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 327132f7629SAshley Lai } 328132f7629SAshley Lai 329132f7629SAshley Lai /** 330132f7629SAshley Lai * tpm_ibmvtpm_suspend - Suspend 331132f7629SAshley Lai * @dev: device struct 332132f7629SAshley Lai * 333*93c12f29SWinkler, Tomas * Return: Always 0. 334132f7629SAshley Lai */ 335132f7629SAshley Lai static int tpm_ibmvtpm_suspend(struct device *dev) 336132f7629SAshley Lai { 3379e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 3389e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 339132f7629SAshley Lai struct ibmvtpm_crq crq; 340132f7629SAshley Lai u64 *buf = (u64 *) &crq; 341132f7629SAshley Lai int rc = 0; 342132f7629SAshley Lai 343132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 344132f7629SAshley Lai crq.msg = (u8)VTPM_PREPARE_TO_SUSPEND; 345132f7629SAshley Lai 346eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 347eb71f8a5Shonclo cpu_to_be64(buf[1])); 348132f7629SAshley Lai if (rc != H_SUCCESS) 349132f7629SAshley Lai dev_err(ibmvtpm->dev, 350132f7629SAshley Lai "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 351132f7629SAshley Lai 352132f7629SAshley Lai return rc; 353132f7629SAshley Lai } 354132f7629SAshley Lai 355132f7629SAshley Lai /** 356132f7629SAshley Lai * ibmvtpm_reset_crq - Reset CRQ 357*93c12f29SWinkler, Tomas * 358132f7629SAshley Lai * @ibmvtpm: ibm vtpm struct 359132f7629SAshley Lai * 360*93c12f29SWinkler, Tomas * Return: 361*93c12f29SWinkler, Tomas * 0 on success. 362*93c12f29SWinkler, Tomas * Non-zero on failure. 363132f7629SAshley Lai */ 364132f7629SAshley Lai static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 365132f7629SAshley Lai { 366132f7629SAshley Lai int rc = 0; 367132f7629SAshley Lai 368132f7629SAshley Lai do { 369132f7629SAshley Lai if (rc) 370132f7629SAshley Lai msleep(100); 371132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, 372132f7629SAshley Lai ibmvtpm->vdev->unit_address); 373132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 374132f7629SAshley Lai 375132f7629SAshley Lai memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 376132f7629SAshley Lai ibmvtpm->crq_queue.index = 0; 377132f7629SAshley Lai 378132f7629SAshley Lai return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 379132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 380132f7629SAshley Lai } 381132f7629SAshley Lai 382132f7629SAshley Lai /** 383132f7629SAshley Lai * tpm_ibmvtpm_resume - Resume from suspend 384*93c12f29SWinkler, Tomas * 385132f7629SAshley Lai * @dev: device struct 386132f7629SAshley Lai * 387*93c12f29SWinkler, Tomas * Return: Always 0. 388132f7629SAshley Lai */ 389132f7629SAshley Lai static int tpm_ibmvtpm_resume(struct device *dev) 390132f7629SAshley Lai { 3919e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 3929e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 393132f7629SAshley Lai int rc = 0; 394132f7629SAshley Lai 395132f7629SAshley Lai do { 396132f7629SAshley Lai if (rc) 397132f7629SAshley Lai msleep(100); 398132f7629SAshley Lai rc = plpar_hcall_norets(H_ENABLE_CRQ, 399132f7629SAshley Lai ibmvtpm->vdev->unit_address); 400132f7629SAshley Lai } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); 401132f7629SAshley Lai 402132f7629SAshley Lai if (rc) { 403132f7629SAshley Lai dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc); 404132f7629SAshley Lai return rc; 405132f7629SAshley Lai } 406132f7629SAshley Lai 407b5666502SAshley Lai rc = vio_enable_interrupts(ibmvtpm->vdev); 408b5666502SAshley Lai if (rc) { 409b5666502SAshley Lai dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc); 410b5666502SAshley Lai return rc; 411b5666502SAshley Lai } 412132f7629SAshley Lai 413132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 414132f7629SAshley Lai if (rc) 415132f7629SAshley Lai dev_err(dev, "Error send_init rc=%d\n", rc); 416132f7629SAshley Lai 417132f7629SAshley Lai return rc; 418132f7629SAshley Lai } 419132f7629SAshley Lai 4201f866057SStefan Berger static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) 4211f866057SStefan Berger { 4221f866057SStefan Berger return (status == 0); 4231f866057SStefan Berger } 4241f866057SStefan Berger 42501ad1fa7SJason Gunthorpe static const struct tpm_class_ops tpm_ibmvtpm = { 426132f7629SAshley Lai .recv = tpm_ibmvtpm_recv, 427132f7629SAshley Lai .send = tpm_ibmvtpm_send, 428132f7629SAshley Lai .cancel = tpm_ibmvtpm_cancel, 429132f7629SAshley Lai .status = tpm_ibmvtpm_status, 430132f7629SAshley Lai .req_complete_mask = 0, 431132f7629SAshley Lai .req_complete_val = 0, 4321f866057SStefan Berger .req_canceled = tpm_ibmvtpm_req_canceled, 433132f7629SAshley Lai }; 434132f7629SAshley Lai 435132f7629SAshley Lai static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 436132f7629SAshley Lai .suspend = tpm_ibmvtpm_suspend, 437132f7629SAshley Lai .resume = tpm_ibmvtpm_resume, 438132f7629SAshley Lai }; 439132f7629SAshley Lai 440132f7629SAshley Lai /** 441132f7629SAshley Lai * ibmvtpm_crq_get_next - Get next responded crq 442132f7629SAshley Lai * 443*93c12f29SWinkler, Tomas * @ibmvtpm: vtpm device struct 444*93c12f29SWinkler, Tomas * 445*93c12f29SWinkler, Tomas * Return: vtpm crq pointer or NULL. 446132f7629SAshley Lai */ 447132f7629SAshley Lai static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 448132f7629SAshley Lai { 449132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 450132f7629SAshley Lai struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 451132f7629SAshley Lai 452132f7629SAshley Lai if (crq->valid & VTPM_MSG_RES) { 453132f7629SAshley Lai if (++crq_q->index == crq_q->num_entry) 454132f7629SAshley Lai crq_q->index = 0; 455b5666502SAshley Lai smp_rmb(); 456132f7629SAshley Lai } else 457132f7629SAshley Lai crq = NULL; 458132f7629SAshley Lai return crq; 459132f7629SAshley Lai } 460132f7629SAshley Lai 461132f7629SAshley Lai /** 462132f7629SAshley Lai * ibmvtpm_crq_process - Process responded crq 463132f7629SAshley Lai * 464*93c12f29SWinkler, Tomas * @crq: crq to be processed 465*93c12f29SWinkler, Tomas * @ibmvtpm: vtpm device struct 466*93c12f29SWinkler, Tomas * 467132f7629SAshley Lai */ 468132f7629SAshley Lai static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 469132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm) 470132f7629SAshley Lai { 471132f7629SAshley Lai int rc = 0; 472132f7629SAshley Lai 473132f7629SAshley Lai switch (crq->valid) { 474132f7629SAshley Lai case VALID_INIT_CRQ: 475132f7629SAshley Lai switch (crq->msg) { 476132f7629SAshley Lai case INIT_CRQ_RES: 477132f7629SAshley Lai dev_info(ibmvtpm->dev, "CRQ initialized\n"); 478132f7629SAshley Lai rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 479132f7629SAshley Lai if (rc) 480132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 481132f7629SAshley Lai return; 482132f7629SAshley Lai case INIT_CRQ_COMP_RES: 483132f7629SAshley Lai dev_info(ibmvtpm->dev, 484132f7629SAshley Lai "CRQ initialization completed\n"); 485132f7629SAshley Lai return; 486132f7629SAshley Lai default: 487132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 488132f7629SAshley Lai return; 489132f7629SAshley Lai } 490132f7629SAshley Lai case IBMVTPM_VALID_CMD: 491132f7629SAshley Lai switch (crq->msg) { 492132f7629SAshley Lai case VTPM_GET_RTCE_BUFFER_SIZE_RES: 493eb71f8a5Shonclo if (be16_to_cpu(crq->len) <= 0) { 494132f7629SAshley Lai dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 495132f7629SAshley Lai return; 496132f7629SAshley Lai } 497eb71f8a5Shonclo ibmvtpm->rtce_size = be16_to_cpu(crq->len); 498132f7629SAshley Lai ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 49960ecd86cSHon Ching \(Vicky\) Lo GFP_ATOMIC); 500132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 501132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 502132f7629SAshley Lai return; 503132f7629SAshley Lai } 504132f7629SAshley Lai 505132f7629SAshley Lai ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 506132f7629SAshley Lai ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 507132f7629SAshley Lai DMA_BIDIRECTIONAL); 508132f7629SAshley Lai 509132f7629SAshley Lai if (dma_mapping_error(ibmvtpm->dev, 510132f7629SAshley Lai ibmvtpm->rtce_dma_handle)) { 511132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 512132f7629SAshley Lai ibmvtpm->rtce_buf = NULL; 513132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 514132f7629SAshley Lai } 515132f7629SAshley Lai 516132f7629SAshley Lai return; 517132f7629SAshley Lai case VTPM_GET_VERSION_RES: 518eb71f8a5Shonclo ibmvtpm->vtpm_version = be32_to_cpu(crq->data); 519132f7629SAshley Lai return; 520132f7629SAshley Lai case VTPM_TPM_COMMAND_RES: 521b5666502SAshley Lai /* len of the data in rtce buffer */ 522eb71f8a5Shonclo ibmvtpm->res_len = be16_to_cpu(crq->len); 5236674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 524b5666502SAshley Lai wake_up_interruptible(&ibmvtpm->wq); 525132f7629SAshley Lai return; 526132f7629SAshley Lai default: 527132f7629SAshley Lai return; 528132f7629SAshley Lai } 529132f7629SAshley Lai } 530132f7629SAshley Lai return; 531132f7629SAshley Lai } 532132f7629SAshley Lai 533132f7629SAshley Lai /** 534132f7629SAshley Lai * ibmvtpm_interrupt - Interrupt handler 535*93c12f29SWinkler, Tomas * 536132f7629SAshley Lai * @irq: irq number to handle 537132f7629SAshley Lai * @vtpm_instance: vtpm that received interrupt 538132f7629SAshley Lai * 539132f7629SAshley Lai * Returns: 540132f7629SAshley Lai * IRQ_HANDLED 541132f7629SAshley Lai **/ 542132f7629SAshley Lai static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 543132f7629SAshley Lai { 544132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 545132f7629SAshley Lai struct ibmvtpm_crq *crq; 546132f7629SAshley Lai 547b5666502SAshley Lai /* while loop is needed for initial setup (get version and 548b5666502SAshley Lai * get rtce_size). There should be only one tpm request at any 549b5666502SAshley Lai * given time. 550b5666502SAshley Lai */ 551132f7629SAshley Lai while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 552132f7629SAshley Lai ibmvtpm_crq_process(crq, ibmvtpm); 553132f7629SAshley Lai crq->valid = 0; 554b5666502SAshley Lai smp_wmb(); 555132f7629SAshley Lai } 556132f7629SAshley Lai 557b5666502SAshley Lai return IRQ_HANDLED; 558132f7629SAshley Lai } 559132f7629SAshley Lai 560132f7629SAshley Lai /** 561132f7629SAshley Lai * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 562*93c12f29SWinkler, Tomas * 563132f7629SAshley Lai * @vio_dev: vio device struct 564132f7629SAshley Lai * @id: vio device id struct 565132f7629SAshley Lai * 566*93c12f29SWinkler, Tomas * Return: 567*93c12f29SWinkler, Tomas * 0 on success. 568*93c12f29SWinkler, Tomas * Non-zero on failure. 569132f7629SAshley Lai */ 570afc6d369SBill Pemberton static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 571132f7629SAshley Lai const struct vio_device_id *id) 572132f7629SAshley Lai { 573132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 574132f7629SAshley Lai struct device *dev = &vio_dev->dev; 575132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q; 576132f7629SAshley Lai struct tpm_chip *chip; 577132f7629SAshley Lai int rc = -ENOMEM, rc1; 578132f7629SAshley Lai 579afb5abc2SJarkko Sakkinen chip = tpmm_chip_alloc(dev, &tpm_ibmvtpm); 580afb5abc2SJarkko Sakkinen if (IS_ERR(chip)) 581afb5abc2SJarkko Sakkinen return PTR_ERR(chip); 582132f7629SAshley Lai 583132f7629SAshley Lai ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 584132f7629SAshley Lai if (!ibmvtpm) { 585132f7629SAshley Lai dev_err(dev, "kzalloc for ibmvtpm failed\n"); 586132f7629SAshley Lai goto cleanup; 587132f7629SAshley Lai } 588132f7629SAshley Lai 5899d75f089SHon Ching \(Vicky\) Lo ibmvtpm->dev = dev; 5909d75f089SHon Ching \(Vicky\) Lo ibmvtpm->vdev = vio_dev; 5919d75f089SHon Ching \(Vicky\) Lo 592132f7629SAshley Lai crq_q = &ibmvtpm->crq_queue; 593132f7629SAshley Lai crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 594132f7629SAshley Lai if (!crq_q->crq_addr) { 595132f7629SAshley Lai dev_err(dev, "Unable to allocate memory for crq_addr\n"); 596132f7629SAshley Lai goto cleanup; 597132f7629SAshley Lai } 598132f7629SAshley Lai 599132f7629SAshley Lai crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 600132f7629SAshley Lai ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 601132f7629SAshley Lai CRQ_RES_BUF_SIZE, 602132f7629SAshley Lai DMA_BIDIRECTIONAL); 603132f7629SAshley Lai 604132f7629SAshley Lai if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 605132f7629SAshley Lai dev_err(dev, "dma mapping failed\n"); 606132f7629SAshley Lai goto cleanup; 607132f7629SAshley Lai } 608132f7629SAshley Lai 609132f7629SAshley Lai rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 610132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 611132f7629SAshley Lai if (rc == H_RESOURCE) 612132f7629SAshley Lai rc = ibmvtpm_reset_crq(ibmvtpm); 613132f7629SAshley Lai 614132f7629SAshley Lai if (rc) { 615132f7629SAshley Lai dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 616132f7629SAshley Lai goto reg_crq_cleanup; 617132f7629SAshley Lai } 618132f7629SAshley Lai 619132f7629SAshley Lai rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 620132f7629SAshley Lai tpm_ibmvtpm_driver_name, ibmvtpm); 621132f7629SAshley Lai if (rc) { 622132f7629SAshley Lai dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 623132f7629SAshley Lai goto init_irq_cleanup; 624132f7629SAshley Lai } 625132f7629SAshley Lai 626132f7629SAshley Lai rc = vio_enable_interrupts(vio_dev); 627132f7629SAshley Lai if (rc) { 628132f7629SAshley Lai dev_err(dev, "Error %d enabling interrupts\n", rc); 629132f7629SAshley Lai goto init_irq_cleanup; 630132f7629SAshley Lai } 631132f7629SAshley Lai 632b5666502SAshley Lai init_waitqueue_head(&ibmvtpm->wq); 633b5666502SAshley Lai 634132f7629SAshley Lai crq_q->index = 0; 635132f7629SAshley Lai 63675254557SStephen Rothwell dev_set_drvdata(&chip->dev, ibmvtpm); 637132f7629SAshley Lai 638132f7629SAshley Lai spin_lock_init(&ibmvtpm->rtce_lock); 639132f7629SAshley Lai 640132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 641132f7629SAshley Lai if (rc) 642132f7629SAshley Lai goto init_irq_cleanup; 643132f7629SAshley Lai 644132f7629SAshley Lai rc = ibmvtpm_crq_get_version(ibmvtpm); 645132f7629SAshley Lai if (rc) 646132f7629SAshley Lai goto init_irq_cleanup; 647132f7629SAshley Lai 648132f7629SAshley Lai rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 649132f7629SAshley Lai if (rc) 650132f7629SAshley Lai goto init_irq_cleanup; 651132f7629SAshley Lai 652afb5abc2SJarkko Sakkinen return tpm_chip_register(chip); 653132f7629SAshley Lai init_irq_cleanup: 654132f7629SAshley Lai do { 655132f7629SAshley Lai rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 656132f7629SAshley Lai } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 657132f7629SAshley Lai reg_crq_cleanup: 658132f7629SAshley Lai dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 659132f7629SAshley Lai DMA_BIDIRECTIONAL); 660132f7629SAshley Lai cleanup: 661132f7629SAshley Lai if (ibmvtpm) { 662132f7629SAshley Lai if (crq_q->crq_addr) 663132f7629SAshley Lai free_page((unsigned long)crq_q->crq_addr); 664132f7629SAshley Lai kfree(ibmvtpm); 665132f7629SAshley Lai } 666132f7629SAshley Lai 667132f7629SAshley Lai return rc; 668132f7629SAshley Lai } 669132f7629SAshley Lai 670132f7629SAshley Lai static struct vio_driver ibmvtpm_driver = { 671132f7629SAshley Lai .id_table = tpm_ibmvtpm_device_table, 672132f7629SAshley Lai .probe = tpm_ibmvtpm_probe, 673132f7629SAshley Lai .remove = tpm_ibmvtpm_remove, 674132f7629SAshley Lai .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 675132f7629SAshley Lai .name = tpm_ibmvtpm_driver_name, 676132f7629SAshley Lai .pm = &tpm_ibmvtpm_pm_ops, 677132f7629SAshley Lai }; 678132f7629SAshley Lai 679132f7629SAshley Lai /** 680*93c12f29SWinkler, Tomas * ibmvtpm_module_init - Initialize ibm vtpm module. 681132f7629SAshley Lai * 682*93c12f29SWinkler, Tomas * 683*93c12f29SWinkler, Tomas * Return: 684*93c12f29SWinkler, Tomas * 0 on success. 685*93c12f29SWinkler, Tomas * Non-zero on failure. 686132f7629SAshley Lai */ 687132f7629SAshley Lai static int __init ibmvtpm_module_init(void) 688132f7629SAshley Lai { 689132f7629SAshley Lai return vio_register_driver(&ibmvtpm_driver); 690132f7629SAshley Lai } 691132f7629SAshley Lai 692132f7629SAshley Lai /** 693*93c12f29SWinkler, Tomas * ibmvtpm_module_exit - Tear down ibm vtpm module. 694132f7629SAshley Lai */ 695132f7629SAshley Lai static void __exit ibmvtpm_module_exit(void) 696132f7629SAshley Lai { 697132f7629SAshley Lai vio_unregister_driver(&ibmvtpm_driver); 698132f7629SAshley Lai } 699132f7629SAshley Lai 700132f7629SAshley Lai module_init(ibmvtpm_module_init); 701132f7629SAshley Lai module_exit(ibmvtpm_module_exit); 702132f7629SAshley Lai 703132f7629SAshley Lai MODULE_AUTHOR("adlai@us.ibm.com"); 704132f7629SAshley Lai MODULE_DESCRIPTION("IBM vTPM Driver"); 705132f7629SAshley Lai MODULE_VERSION("1.0"); 706132f7629SAshley Lai MODULE_LICENSE("GPL"); 707