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 43132f7629SAshley Lai * @vdev: vio device struct 44132f7629SAshley Lai * @w1: first word 45132f7629SAshley Lai * @w2: second word 46132f7629SAshley Lai * 47132f7629SAshley Lai * Return value: 48132f7629SAshley Lai * 0 -Sucess 49132f7629SAshley Lai * Non-zero - Failure 50132f7629SAshley Lai */ 51132f7629SAshley Lai static int ibmvtpm_send_crq(struct vio_dev *vdev, u64 w1, u64 w2) 52132f7629SAshley Lai { 53132f7629SAshley Lai return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, w2); 54132f7629SAshley Lai } 55132f7629SAshley Lai 56132f7629SAshley Lai /** 57132f7629SAshley Lai * tpm_ibmvtpm_recv - Receive data after send 58132f7629SAshley Lai * @chip: tpm chip struct 59132f7629SAshley Lai * @buf: buffer to read 60132f7629SAshley Lai * count: size of buffer 61132f7629SAshley Lai * 62132f7629SAshley Lai * Return value: 63132f7629SAshley Lai * Number of bytes read 64132f7629SAshley Lai */ 65132f7629SAshley Lai static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) 66132f7629SAshley Lai { 67*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 68132f7629SAshley Lai u16 len; 69b5666502SAshley Lai int sig; 70132f7629SAshley Lai 71132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 72132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 73132f7629SAshley Lai return 0; 74132f7629SAshley Lai } 75132f7629SAshley Lai 766674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 77b5666502SAshley Lai if (sig) 78b5666502SAshley Lai return -EINTR; 79132f7629SAshley Lai 80b5666502SAshley Lai len = ibmvtpm->res_len; 81b5666502SAshley Lai 82b5666502SAshley Lai if (count < len) { 83132f7629SAshley Lai dev_err(ibmvtpm->dev, 8437ab0341SJason Gunthorpe "Invalid size in recv: count=%zd, crq_size=%d\n", 85b5666502SAshley Lai count, len); 86132f7629SAshley Lai return -EIO; 87132f7629SAshley Lai } 88132f7629SAshley Lai 89132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 90b5666502SAshley Lai memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len); 91b5666502SAshley Lai memset(ibmvtpm->rtce_buf, 0, len); 92b5666502SAshley Lai ibmvtpm->res_len = 0; 93132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 94132f7629SAshley Lai return len; 95132f7629SAshley Lai } 96132f7629SAshley Lai 97132f7629SAshley Lai /** 98132f7629SAshley Lai * tpm_ibmvtpm_send - Send tpm request 99132f7629SAshley Lai * @chip: tpm chip struct 100132f7629SAshley Lai * @buf: buffer contains data to send 101132f7629SAshley Lai * count: size of buffer 102132f7629SAshley Lai * 103132f7629SAshley Lai * Return value: 104132f7629SAshley Lai * Number of bytes sent 105132f7629SAshley Lai */ 106132f7629SAshley Lai static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) 107132f7629SAshley Lai { 108*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 109132f7629SAshley Lai struct ibmvtpm_crq crq; 11062dfd912Sjmlatten@linux.vnet.ibm.com __be64 *word = (__be64 *)&crq; 1116674ff14SStefan Berger int rc, sig; 112132f7629SAshley Lai 113132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 114132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 115132f7629SAshley Lai return 0; 116132f7629SAshley Lai } 117132f7629SAshley Lai 118132f7629SAshley Lai if (count > ibmvtpm->rtce_size) { 119132f7629SAshley Lai dev_err(ibmvtpm->dev, 12037ab0341SJason Gunthorpe "Invalid size in send: count=%zd, rtce_size=%d\n", 121132f7629SAshley Lai count, ibmvtpm->rtce_size); 122132f7629SAshley Lai return -EIO; 123132f7629SAshley Lai } 124132f7629SAshley Lai 1256674ff14SStefan Berger if (ibmvtpm->tpm_processing_cmd) { 1266674ff14SStefan Berger dev_info(ibmvtpm->dev, 1276674ff14SStefan Berger "Need to wait for TPM to finish\n"); 1286674ff14SStefan Berger /* wait for previous command to finish */ 1296674ff14SStefan Berger sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); 1306674ff14SStefan Berger if (sig) 1316674ff14SStefan Berger return -EINTR; 1326674ff14SStefan Berger } 1336674ff14SStefan Berger 134132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 1356674ff14SStefan Berger ibmvtpm->res_len = 0; 136132f7629SAshley Lai memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); 137132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 138132f7629SAshley Lai crq.msg = (u8)VTPM_TPM_COMMAND; 13962dfd912Sjmlatten@linux.vnet.ibm.com crq.len = cpu_to_be16(count); 14062dfd912Sjmlatten@linux.vnet.ibm.com crq.data = cpu_to_be32(ibmvtpm->rtce_dma_handle); 141132f7629SAshley Lai 1426674ff14SStefan Berger /* 1436674ff14SStefan Berger * set the processing flag before the Hcall, since we may get the 1446674ff14SStefan Berger * result (interrupt) before even being able to check rc. 1456674ff14SStefan Berger */ 1466674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = true; 1476674ff14SStefan Berger 14862dfd912Sjmlatten@linux.vnet.ibm.com rc = ibmvtpm_send_crq(ibmvtpm->vdev, be64_to_cpu(word[0]), 14962dfd912Sjmlatten@linux.vnet.ibm.com be64_to_cpu(word[1])); 150132f7629SAshley Lai if (rc != H_SUCCESS) { 151132f7629SAshley Lai dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc); 152132f7629SAshley Lai rc = 0; 1536674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 154132f7629SAshley Lai } else 155132f7629SAshley Lai rc = count; 156132f7629SAshley Lai 157132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 158132f7629SAshley Lai return rc; 159132f7629SAshley Lai } 160132f7629SAshley Lai 161132f7629SAshley Lai static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) 162132f7629SAshley Lai { 163132f7629SAshley Lai return; 164132f7629SAshley Lai } 165132f7629SAshley Lai 166132f7629SAshley Lai static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) 167132f7629SAshley Lai { 168132f7629SAshley Lai return 0; 169132f7629SAshley Lai } 170132f7629SAshley Lai 171132f7629SAshley Lai /** 172132f7629SAshley Lai * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size 173132f7629SAshley Lai * @ibmvtpm: vtpm device struct 174132f7629SAshley Lai * 175132f7629SAshley Lai * Return value: 176132f7629SAshley Lai * 0 - Success 177132f7629SAshley Lai * Non-zero - Failure 178132f7629SAshley Lai */ 179132f7629SAshley Lai static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) 180132f7629SAshley Lai { 181132f7629SAshley Lai struct ibmvtpm_crq crq; 182132f7629SAshley Lai u64 *buf = (u64 *) &crq; 183132f7629SAshley Lai int rc; 184132f7629SAshley Lai 185132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 186132f7629SAshley Lai crq.msg = (u8)VTPM_GET_RTCE_BUFFER_SIZE; 187132f7629SAshley Lai 188eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 189eb71f8a5Shonclo cpu_to_be64(buf[1])); 190132f7629SAshley Lai if (rc != H_SUCCESS) 191132f7629SAshley Lai dev_err(ibmvtpm->dev, 192132f7629SAshley Lai "ibmvtpm_crq_get_rtce_size failed rc=%d\n", rc); 193132f7629SAshley Lai 194132f7629SAshley Lai return rc; 195132f7629SAshley Lai } 196132f7629SAshley Lai 197132f7629SAshley Lai /** 198132f7629SAshley Lai * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version 199132f7629SAshley Lai * - Note that this is vtpm version and not tpm version 200132f7629SAshley Lai * @ibmvtpm: vtpm device struct 201132f7629SAshley Lai * 202132f7629SAshley Lai * Return value: 203132f7629SAshley Lai * 0 - Success 204132f7629SAshley Lai * Non-zero - Failure 205132f7629SAshley Lai */ 206132f7629SAshley Lai static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm) 207132f7629SAshley Lai { 208132f7629SAshley Lai struct ibmvtpm_crq crq; 209132f7629SAshley Lai u64 *buf = (u64 *) &crq; 210132f7629SAshley Lai int rc; 211132f7629SAshley Lai 212132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 213132f7629SAshley Lai crq.msg = (u8)VTPM_GET_VERSION; 214132f7629SAshley Lai 215eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 216eb71f8a5Shonclo cpu_to_be64(buf[1])); 217132f7629SAshley Lai if (rc != H_SUCCESS) 218132f7629SAshley Lai dev_err(ibmvtpm->dev, 219132f7629SAshley Lai "ibmvtpm_crq_get_version failed rc=%d\n", rc); 220132f7629SAshley Lai 221132f7629SAshley Lai return rc; 222132f7629SAshley Lai } 223132f7629SAshley Lai 224132f7629SAshley Lai /** 225132f7629SAshley Lai * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message 226132f7629SAshley Lai * @ibmvtpm: vtpm device struct 227132f7629SAshley Lai * 228132f7629SAshley Lai * Return value: 229132f7629SAshley Lai * 0 - Success 230132f7629SAshley Lai * Non-zero - Failure 231132f7629SAshley Lai */ 232132f7629SAshley Lai static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) 233132f7629SAshley Lai { 234132f7629SAshley Lai int rc; 235132f7629SAshley Lai 236132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_COMP_CMD, 0); 237132f7629SAshley Lai if (rc != H_SUCCESS) 238132f7629SAshley Lai dev_err(ibmvtpm->dev, 239132f7629SAshley Lai "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc); 240132f7629SAshley Lai 241132f7629SAshley Lai return rc; 242132f7629SAshley Lai } 243132f7629SAshley Lai 244132f7629SAshley Lai /** 245132f7629SAshley Lai * ibmvtpm_crq_send_init - Send a CRQ initialize message 246132f7629SAshley Lai * @ibmvtpm: vtpm device struct 247132f7629SAshley Lai * 248132f7629SAshley Lai * Return value: 249132f7629SAshley Lai * 0 - Success 250132f7629SAshley Lai * Non-zero - Failure 251132f7629SAshley Lai */ 252132f7629SAshley Lai static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) 253132f7629SAshley Lai { 254132f7629SAshley Lai int rc; 255132f7629SAshley Lai 256132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_CMD, 0); 257132f7629SAshley Lai if (rc != H_SUCCESS) 258132f7629SAshley Lai dev_err(ibmvtpm->dev, 259132f7629SAshley Lai "ibmvtpm_crq_send_init failed rc=%d\n", rc); 260132f7629SAshley Lai 261132f7629SAshley Lai return rc; 262132f7629SAshley Lai } 263132f7629SAshley Lai 264132f7629SAshley Lai /** 265132f7629SAshley Lai * tpm_ibmvtpm_remove - ibm vtpm remove entry point 266132f7629SAshley Lai * @vdev: vio device struct 267132f7629SAshley Lai * 268132f7629SAshley Lai * Return value: 269132f7629SAshley Lai * 0 270132f7629SAshley Lai */ 27139af33fcSBill Pemberton static int tpm_ibmvtpm_remove(struct vio_dev *vdev) 272132f7629SAshley Lai { 273*9e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 274*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 275132f7629SAshley Lai int rc = 0; 276132f7629SAshley Lai 277afb5abc2SJarkko Sakkinen tpm_chip_unregister(chip); 278afb5abc2SJarkko Sakkinen 279132f7629SAshley Lai free_irq(vdev->irq, ibmvtpm); 280132f7629SAshley Lai 281132f7629SAshley Lai do { 282132f7629SAshley Lai if (rc) 283132f7629SAshley Lai msleep(100); 284132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 285132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 286132f7629SAshley Lai 287132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, 288132f7629SAshley Lai CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); 289132f7629SAshley Lai free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); 290132f7629SAshley Lai 291132f7629SAshley Lai if (ibmvtpm->rtce_buf) { 292132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, 293132f7629SAshley Lai ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); 294132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 295132f7629SAshley Lai } 296132f7629SAshley Lai 297132f7629SAshley Lai kfree(ibmvtpm); 298132f7629SAshley Lai 299132f7629SAshley Lai return 0; 300132f7629SAshley Lai } 301132f7629SAshley Lai 302132f7629SAshley Lai /** 303132f7629SAshley Lai * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 304132f7629SAshley Lai * @vdev: vio device struct 305132f7629SAshley Lai * 306132f7629SAshley Lai * Return value: 307132f7629SAshley Lai * Number of bytes the driver needs to DMA map 308132f7629SAshley Lai */ 309132f7629SAshley Lai static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 310132f7629SAshley Lai { 311*9e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(&vdev->dev); 312*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 31384eb186bSHon Ching (Vicky) Lo 31484eb186bSHon Ching (Vicky) Lo /* ibmvtpm initializes at probe time, so the data we are 31584eb186bSHon Ching (Vicky) Lo * asking for may not be set yet. Estimate that 4K required 31684eb186bSHon Ching (Vicky) Lo * for TCE-mapped buffer in addition to CRQ. 31784eb186bSHon Ching (Vicky) Lo */ 31884eb186bSHon Ching (Vicky) Lo if (!ibmvtpm) 31984eb186bSHon Ching (Vicky) Lo return CRQ_RES_BUF_SIZE + PAGE_SIZE; 32084eb186bSHon Ching (Vicky) Lo 321132f7629SAshley Lai return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 322132f7629SAshley Lai } 323132f7629SAshley Lai 324132f7629SAshley Lai /** 325132f7629SAshley Lai * tpm_ibmvtpm_suspend - Suspend 326132f7629SAshley Lai * @dev: device struct 327132f7629SAshley Lai * 328132f7629SAshley Lai * Return value: 329132f7629SAshley Lai * 0 330132f7629SAshley Lai */ 331132f7629SAshley Lai static int tpm_ibmvtpm_suspend(struct device *dev) 332132f7629SAshley Lai { 333*9e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 334*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 335132f7629SAshley Lai struct ibmvtpm_crq crq; 336132f7629SAshley Lai u64 *buf = (u64 *) &crq; 337132f7629SAshley Lai int rc = 0; 338132f7629SAshley Lai 339132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 340132f7629SAshley Lai crq.msg = (u8)VTPM_PREPARE_TO_SUSPEND; 341132f7629SAshley Lai 342eb71f8a5Shonclo rc = ibmvtpm_send_crq(ibmvtpm->vdev, cpu_to_be64(buf[0]), 343eb71f8a5Shonclo cpu_to_be64(buf[1])); 344132f7629SAshley Lai if (rc != H_SUCCESS) 345132f7629SAshley Lai dev_err(ibmvtpm->dev, 346132f7629SAshley Lai "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 347132f7629SAshley Lai 348132f7629SAshley Lai return rc; 349132f7629SAshley Lai } 350132f7629SAshley Lai 351132f7629SAshley Lai /** 352132f7629SAshley Lai * ibmvtpm_reset_crq - Reset CRQ 353132f7629SAshley Lai * @ibmvtpm: ibm vtpm struct 354132f7629SAshley Lai * 355132f7629SAshley Lai * Return value: 356132f7629SAshley Lai * 0 - Success 357132f7629SAshley Lai * Non-zero - Failure 358132f7629SAshley Lai */ 359132f7629SAshley Lai static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 360132f7629SAshley Lai { 361132f7629SAshley Lai int rc = 0; 362132f7629SAshley Lai 363132f7629SAshley Lai do { 364132f7629SAshley Lai if (rc) 365132f7629SAshley Lai msleep(100); 366132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, 367132f7629SAshley Lai ibmvtpm->vdev->unit_address); 368132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 369132f7629SAshley Lai 370132f7629SAshley Lai memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 371132f7629SAshley Lai ibmvtpm->crq_queue.index = 0; 372132f7629SAshley Lai 373132f7629SAshley Lai return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 374132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 375132f7629SAshley Lai } 376132f7629SAshley Lai 377132f7629SAshley Lai /** 378132f7629SAshley Lai * tpm_ibmvtpm_resume - Resume from suspend 379132f7629SAshley Lai * @dev: device struct 380132f7629SAshley Lai * 381132f7629SAshley Lai * Return value: 382132f7629SAshley Lai * 0 383132f7629SAshley Lai */ 384132f7629SAshley Lai static int tpm_ibmvtpm_resume(struct device *dev) 385132f7629SAshley Lai { 386*9e0d39d8SChristophe Ricard struct tpm_chip *chip = dev_get_drvdata(dev); 387*9e0d39d8SChristophe Ricard struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(&chip->dev); 388132f7629SAshley Lai int rc = 0; 389132f7629SAshley Lai 390132f7629SAshley Lai do { 391132f7629SAshley Lai if (rc) 392132f7629SAshley Lai msleep(100); 393132f7629SAshley Lai rc = plpar_hcall_norets(H_ENABLE_CRQ, 394132f7629SAshley Lai ibmvtpm->vdev->unit_address); 395132f7629SAshley Lai } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); 396132f7629SAshley Lai 397132f7629SAshley Lai if (rc) { 398132f7629SAshley Lai dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc); 399132f7629SAshley Lai return rc; 400132f7629SAshley Lai } 401132f7629SAshley Lai 402b5666502SAshley Lai rc = vio_enable_interrupts(ibmvtpm->vdev); 403b5666502SAshley Lai if (rc) { 404b5666502SAshley Lai dev_err(dev, "Error vio_enable_interrupts rc=%d\n", rc); 405b5666502SAshley Lai return rc; 406b5666502SAshley Lai } 407132f7629SAshley Lai 408132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 409132f7629SAshley Lai if (rc) 410132f7629SAshley Lai dev_err(dev, "Error send_init rc=%d\n", rc); 411132f7629SAshley Lai 412132f7629SAshley Lai return rc; 413132f7629SAshley Lai } 414132f7629SAshley Lai 4151f866057SStefan Berger static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) 4161f866057SStefan Berger { 4171f866057SStefan Berger return (status == 0); 4181f866057SStefan Berger } 4191f866057SStefan Berger 42001ad1fa7SJason Gunthorpe static const struct tpm_class_ops tpm_ibmvtpm = { 421132f7629SAshley Lai .recv = tpm_ibmvtpm_recv, 422132f7629SAshley Lai .send = tpm_ibmvtpm_send, 423132f7629SAshley Lai .cancel = tpm_ibmvtpm_cancel, 424132f7629SAshley Lai .status = tpm_ibmvtpm_status, 425132f7629SAshley Lai .req_complete_mask = 0, 426132f7629SAshley Lai .req_complete_val = 0, 4271f866057SStefan Berger .req_canceled = tpm_ibmvtpm_req_canceled, 428132f7629SAshley Lai }; 429132f7629SAshley Lai 430132f7629SAshley Lai static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 431132f7629SAshley Lai .suspend = tpm_ibmvtpm_suspend, 432132f7629SAshley Lai .resume = tpm_ibmvtpm_resume, 433132f7629SAshley Lai }; 434132f7629SAshley Lai 435132f7629SAshley Lai /** 436132f7629SAshley Lai * ibmvtpm_crq_get_next - Get next responded crq 437132f7629SAshley Lai * @ibmvtpm vtpm device struct 438132f7629SAshley Lai * 439132f7629SAshley Lai * Return value: 440132f7629SAshley Lai * vtpm crq pointer 441132f7629SAshley Lai */ 442132f7629SAshley Lai static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 443132f7629SAshley Lai { 444132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 445132f7629SAshley Lai struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 446132f7629SAshley Lai 447132f7629SAshley Lai if (crq->valid & VTPM_MSG_RES) { 448132f7629SAshley Lai if (++crq_q->index == crq_q->num_entry) 449132f7629SAshley Lai crq_q->index = 0; 450b5666502SAshley Lai smp_rmb(); 451132f7629SAshley Lai } else 452132f7629SAshley Lai crq = NULL; 453132f7629SAshley Lai return crq; 454132f7629SAshley Lai } 455132f7629SAshley Lai 456132f7629SAshley Lai /** 457132f7629SAshley Lai * ibmvtpm_crq_process - Process responded crq 458132f7629SAshley Lai * @crq crq to be processed 459132f7629SAshley Lai * @ibmvtpm vtpm device struct 460132f7629SAshley Lai * 461132f7629SAshley Lai * Return value: 462132f7629SAshley Lai * Nothing 463132f7629SAshley Lai */ 464132f7629SAshley Lai static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 465132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm) 466132f7629SAshley Lai { 467132f7629SAshley Lai int rc = 0; 468132f7629SAshley Lai 469132f7629SAshley Lai switch (crq->valid) { 470132f7629SAshley Lai case VALID_INIT_CRQ: 471132f7629SAshley Lai switch (crq->msg) { 472132f7629SAshley Lai case INIT_CRQ_RES: 473132f7629SAshley Lai dev_info(ibmvtpm->dev, "CRQ initialized\n"); 474132f7629SAshley Lai rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 475132f7629SAshley Lai if (rc) 476132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 477132f7629SAshley Lai return; 478132f7629SAshley Lai case INIT_CRQ_COMP_RES: 479132f7629SAshley Lai dev_info(ibmvtpm->dev, 480132f7629SAshley Lai "CRQ initialization completed\n"); 481132f7629SAshley Lai return; 482132f7629SAshley Lai default: 483132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 484132f7629SAshley Lai return; 485132f7629SAshley Lai } 486132f7629SAshley Lai case IBMVTPM_VALID_CMD: 487132f7629SAshley Lai switch (crq->msg) { 488132f7629SAshley Lai case VTPM_GET_RTCE_BUFFER_SIZE_RES: 489eb71f8a5Shonclo if (be16_to_cpu(crq->len) <= 0) { 490132f7629SAshley Lai dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 491132f7629SAshley Lai return; 492132f7629SAshley Lai } 493eb71f8a5Shonclo ibmvtpm->rtce_size = be16_to_cpu(crq->len); 494132f7629SAshley Lai ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 49560ecd86cSHon Ching \(Vicky\) Lo GFP_ATOMIC); 496132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 497132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 498132f7629SAshley Lai return; 499132f7629SAshley Lai } 500132f7629SAshley Lai 501132f7629SAshley Lai ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 502132f7629SAshley Lai ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 503132f7629SAshley Lai DMA_BIDIRECTIONAL); 504132f7629SAshley Lai 505132f7629SAshley Lai if (dma_mapping_error(ibmvtpm->dev, 506132f7629SAshley Lai ibmvtpm->rtce_dma_handle)) { 507132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 508132f7629SAshley Lai ibmvtpm->rtce_buf = NULL; 509132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 510132f7629SAshley Lai } 511132f7629SAshley Lai 512132f7629SAshley Lai return; 513132f7629SAshley Lai case VTPM_GET_VERSION_RES: 514eb71f8a5Shonclo ibmvtpm->vtpm_version = be32_to_cpu(crq->data); 515132f7629SAshley Lai return; 516132f7629SAshley Lai case VTPM_TPM_COMMAND_RES: 517b5666502SAshley Lai /* len of the data in rtce buffer */ 518eb71f8a5Shonclo ibmvtpm->res_len = be16_to_cpu(crq->len); 5196674ff14SStefan Berger ibmvtpm->tpm_processing_cmd = false; 520b5666502SAshley Lai wake_up_interruptible(&ibmvtpm->wq); 521132f7629SAshley Lai return; 522132f7629SAshley Lai default: 523132f7629SAshley Lai return; 524132f7629SAshley Lai } 525132f7629SAshley Lai } 526132f7629SAshley Lai return; 527132f7629SAshley Lai } 528132f7629SAshley Lai 529132f7629SAshley Lai /** 530132f7629SAshley Lai * ibmvtpm_interrupt - Interrupt handler 531132f7629SAshley Lai * @irq: irq number to handle 532132f7629SAshley Lai * @vtpm_instance: vtpm that received interrupt 533132f7629SAshley Lai * 534132f7629SAshley Lai * Returns: 535132f7629SAshley Lai * IRQ_HANDLED 536132f7629SAshley Lai **/ 537132f7629SAshley Lai static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 538132f7629SAshley Lai { 539132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 540132f7629SAshley Lai struct ibmvtpm_crq *crq; 541132f7629SAshley Lai 542b5666502SAshley Lai /* while loop is needed for initial setup (get version and 543b5666502SAshley Lai * get rtce_size). There should be only one tpm request at any 544b5666502SAshley Lai * given time. 545b5666502SAshley Lai */ 546132f7629SAshley Lai while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 547132f7629SAshley Lai ibmvtpm_crq_process(crq, ibmvtpm); 548132f7629SAshley Lai crq->valid = 0; 549b5666502SAshley Lai smp_wmb(); 550132f7629SAshley Lai } 551132f7629SAshley Lai 552b5666502SAshley Lai return IRQ_HANDLED; 553132f7629SAshley Lai } 554132f7629SAshley Lai 555132f7629SAshley Lai /** 556132f7629SAshley Lai * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 557132f7629SAshley Lai * @vio_dev: vio device struct 558132f7629SAshley Lai * @id: vio device id struct 559132f7629SAshley Lai * 560132f7629SAshley Lai * Return value: 561132f7629SAshley Lai * 0 - Success 562132f7629SAshley Lai * Non-zero - Failure 563132f7629SAshley Lai */ 564afc6d369SBill Pemberton static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 565132f7629SAshley Lai const struct vio_device_id *id) 566132f7629SAshley Lai { 567132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 568132f7629SAshley Lai struct device *dev = &vio_dev->dev; 569132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q; 570132f7629SAshley Lai struct tpm_chip *chip; 571132f7629SAshley Lai int rc = -ENOMEM, rc1; 572132f7629SAshley Lai 573afb5abc2SJarkko Sakkinen chip = tpmm_chip_alloc(dev, &tpm_ibmvtpm); 574afb5abc2SJarkko Sakkinen if (IS_ERR(chip)) 575afb5abc2SJarkko Sakkinen return PTR_ERR(chip); 576132f7629SAshley Lai 577132f7629SAshley Lai ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 578132f7629SAshley Lai if (!ibmvtpm) { 579132f7629SAshley Lai dev_err(dev, "kzalloc for ibmvtpm failed\n"); 580132f7629SAshley Lai goto cleanup; 581132f7629SAshley Lai } 582132f7629SAshley Lai 5839d75f089SHon Ching \(Vicky\) Lo ibmvtpm->dev = dev; 5849d75f089SHon Ching \(Vicky\) Lo ibmvtpm->vdev = vio_dev; 5859d75f089SHon Ching \(Vicky\) Lo 586132f7629SAshley Lai crq_q = &ibmvtpm->crq_queue; 587132f7629SAshley Lai crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 588132f7629SAshley Lai if (!crq_q->crq_addr) { 589132f7629SAshley Lai dev_err(dev, "Unable to allocate memory for crq_addr\n"); 590132f7629SAshley Lai goto cleanup; 591132f7629SAshley Lai } 592132f7629SAshley Lai 593132f7629SAshley Lai crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 594132f7629SAshley Lai ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 595132f7629SAshley Lai CRQ_RES_BUF_SIZE, 596132f7629SAshley Lai DMA_BIDIRECTIONAL); 597132f7629SAshley Lai 598132f7629SAshley Lai if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 599132f7629SAshley Lai dev_err(dev, "dma mapping failed\n"); 600132f7629SAshley Lai goto cleanup; 601132f7629SAshley Lai } 602132f7629SAshley Lai 603132f7629SAshley Lai rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 604132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 605132f7629SAshley Lai if (rc == H_RESOURCE) 606132f7629SAshley Lai rc = ibmvtpm_reset_crq(ibmvtpm); 607132f7629SAshley Lai 608132f7629SAshley Lai if (rc) { 609132f7629SAshley Lai dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 610132f7629SAshley Lai goto reg_crq_cleanup; 611132f7629SAshley Lai } 612132f7629SAshley Lai 613132f7629SAshley Lai rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 614132f7629SAshley Lai tpm_ibmvtpm_driver_name, ibmvtpm); 615132f7629SAshley Lai if (rc) { 616132f7629SAshley Lai dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 617132f7629SAshley Lai goto init_irq_cleanup; 618132f7629SAshley Lai } 619132f7629SAshley Lai 620132f7629SAshley Lai rc = vio_enable_interrupts(vio_dev); 621132f7629SAshley Lai if (rc) { 622132f7629SAshley Lai dev_err(dev, "Error %d enabling interrupts\n", rc); 623132f7629SAshley Lai goto init_irq_cleanup; 624132f7629SAshley Lai } 625132f7629SAshley Lai 626b5666502SAshley Lai init_waitqueue_head(&ibmvtpm->wq); 627b5666502SAshley Lai 628132f7629SAshley Lai crq_q->index = 0; 629132f7629SAshley Lai 630*9e0d39d8SChristophe Ricard dev_set_drvdata(&chip->dev, ibmvtpm) 631132f7629SAshley Lai 632132f7629SAshley Lai spin_lock_init(&ibmvtpm->rtce_lock); 633132f7629SAshley Lai 634132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 635132f7629SAshley Lai if (rc) 636132f7629SAshley Lai goto init_irq_cleanup; 637132f7629SAshley Lai 638132f7629SAshley Lai rc = ibmvtpm_crq_get_version(ibmvtpm); 639132f7629SAshley Lai if (rc) 640132f7629SAshley Lai goto init_irq_cleanup; 641132f7629SAshley Lai 642132f7629SAshley Lai rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 643132f7629SAshley Lai if (rc) 644132f7629SAshley Lai goto init_irq_cleanup; 645132f7629SAshley Lai 646afb5abc2SJarkko Sakkinen return tpm_chip_register(chip); 647132f7629SAshley Lai init_irq_cleanup: 648132f7629SAshley Lai do { 649132f7629SAshley Lai rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 650132f7629SAshley Lai } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 651132f7629SAshley Lai reg_crq_cleanup: 652132f7629SAshley Lai dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 653132f7629SAshley Lai DMA_BIDIRECTIONAL); 654132f7629SAshley Lai cleanup: 655132f7629SAshley Lai if (ibmvtpm) { 656132f7629SAshley Lai if (crq_q->crq_addr) 657132f7629SAshley Lai free_page((unsigned long)crq_q->crq_addr); 658132f7629SAshley Lai kfree(ibmvtpm); 659132f7629SAshley Lai } 660132f7629SAshley Lai 661132f7629SAshley Lai return rc; 662132f7629SAshley Lai } 663132f7629SAshley Lai 664132f7629SAshley Lai static struct vio_driver ibmvtpm_driver = { 665132f7629SAshley Lai .id_table = tpm_ibmvtpm_device_table, 666132f7629SAshley Lai .probe = tpm_ibmvtpm_probe, 667132f7629SAshley Lai .remove = tpm_ibmvtpm_remove, 668132f7629SAshley Lai .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 669132f7629SAshley Lai .name = tpm_ibmvtpm_driver_name, 670132f7629SAshley Lai .pm = &tpm_ibmvtpm_pm_ops, 671132f7629SAshley Lai }; 672132f7629SAshley Lai 673132f7629SAshley Lai /** 674132f7629SAshley Lai * ibmvtpm_module_init - Initialize ibm vtpm module 675132f7629SAshley Lai * 676132f7629SAshley Lai * Return value: 677132f7629SAshley Lai * 0 -Success 678132f7629SAshley Lai * Non-zero - Failure 679132f7629SAshley Lai */ 680132f7629SAshley Lai static int __init ibmvtpm_module_init(void) 681132f7629SAshley Lai { 682132f7629SAshley Lai return vio_register_driver(&ibmvtpm_driver); 683132f7629SAshley Lai } 684132f7629SAshley Lai 685132f7629SAshley Lai /** 686132f7629SAshley Lai * ibmvtpm_module_exit - Teardown ibm vtpm module 687132f7629SAshley Lai * 688132f7629SAshley Lai * Return value: 689132f7629SAshley Lai * Nothing 690132f7629SAshley Lai */ 691132f7629SAshley Lai static void __exit ibmvtpm_module_exit(void) 692132f7629SAshley Lai { 693132f7629SAshley Lai vio_unregister_driver(&ibmvtpm_driver); 694132f7629SAshley Lai } 695132f7629SAshley Lai 696132f7629SAshley Lai module_init(ibmvtpm_module_init); 697132f7629SAshley Lai module_exit(ibmvtpm_module_exit); 698132f7629SAshley Lai 699132f7629SAshley Lai MODULE_AUTHOR("adlai@us.ibm.com"); 700132f7629SAshley Lai MODULE_DESCRIPTION("IBM vTPM Driver"); 701132f7629SAshley Lai MODULE_VERSION("1.0"); 702132f7629SAshley Lai MODULE_LICENSE("GPL"); 703