1132f7629SAshley Lai /* 2132f7629SAshley Lai * Copyright (C) 2012 IBM Corporation 3132f7629SAshley Lai * 4132f7629SAshley Lai * Author: Ashley Lai <adlai@us.ibm.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 35*0bbed20eSBill 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 DECLARE_WAIT_QUEUE_HEAD(wq); 42132f7629SAshley Lai 43132f7629SAshley Lai /** 44132f7629SAshley Lai * ibmvtpm_send_crq - Send a CRQ request 45132f7629SAshley Lai * @vdev: vio device struct 46132f7629SAshley Lai * @w1: first word 47132f7629SAshley Lai * @w2: second word 48132f7629SAshley Lai * 49132f7629SAshley Lai * Return value: 50132f7629SAshley Lai * 0 -Sucess 51132f7629SAshley Lai * Non-zero - Failure 52132f7629SAshley Lai */ 53132f7629SAshley Lai static int ibmvtpm_send_crq(struct vio_dev *vdev, u64 w1, u64 w2) 54132f7629SAshley Lai { 55132f7629SAshley Lai return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, w2); 56132f7629SAshley Lai } 57132f7629SAshley Lai 58132f7629SAshley Lai /** 59132f7629SAshley Lai * ibmvtpm_get_data - Retrieve ibm vtpm data 60132f7629SAshley Lai * @dev: device struct 61132f7629SAshley Lai * 62132f7629SAshley Lai * Return value: 63132f7629SAshley Lai * vtpm device struct 64132f7629SAshley Lai */ 65132f7629SAshley Lai static struct ibmvtpm_dev *ibmvtpm_get_data(const struct device *dev) 66132f7629SAshley Lai { 67132f7629SAshley Lai struct tpm_chip *chip = dev_get_drvdata(dev); 68132f7629SAshley Lai if (chip) 69132f7629SAshley Lai return (struct ibmvtpm_dev *)chip->vendor.data; 70132f7629SAshley Lai return NULL; 71132f7629SAshley Lai } 72132f7629SAshley Lai 73132f7629SAshley Lai /** 74132f7629SAshley Lai * tpm_ibmvtpm_recv - Receive data after send 75132f7629SAshley Lai * @chip: tpm chip struct 76132f7629SAshley Lai * @buf: buffer to read 77132f7629SAshley Lai * count: size of buffer 78132f7629SAshley Lai * 79132f7629SAshley Lai * Return value: 80132f7629SAshley Lai * Number of bytes read 81132f7629SAshley Lai */ 82132f7629SAshley Lai static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) 83132f7629SAshley Lai { 84132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 85132f7629SAshley Lai u16 len; 86132f7629SAshley Lai 87132f7629SAshley Lai ibmvtpm = (struct ibmvtpm_dev *)chip->vendor.data; 88132f7629SAshley Lai 89132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 90132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 91132f7629SAshley Lai return 0; 92132f7629SAshley Lai } 93132f7629SAshley Lai 94132f7629SAshley Lai wait_event_interruptible(wq, ibmvtpm->crq_res.len != 0); 95132f7629SAshley Lai 96132f7629SAshley Lai if (count < ibmvtpm->crq_res.len) { 97132f7629SAshley Lai dev_err(ibmvtpm->dev, 98132f7629SAshley Lai "Invalid size in recv: count=%ld, crq_size=%d\n", 99132f7629SAshley Lai count, ibmvtpm->crq_res.len); 100132f7629SAshley Lai return -EIO; 101132f7629SAshley Lai } 102132f7629SAshley Lai 103132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 104132f7629SAshley Lai memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, ibmvtpm->crq_res.len); 105132f7629SAshley Lai memset(ibmvtpm->rtce_buf, 0, ibmvtpm->crq_res.len); 106132f7629SAshley Lai ibmvtpm->crq_res.valid = 0; 107132f7629SAshley Lai ibmvtpm->crq_res.msg = 0; 108132f7629SAshley Lai len = ibmvtpm->crq_res.len; 109132f7629SAshley Lai ibmvtpm->crq_res.len = 0; 110132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 111132f7629SAshley Lai return len; 112132f7629SAshley Lai } 113132f7629SAshley Lai 114132f7629SAshley Lai /** 115132f7629SAshley Lai * tpm_ibmvtpm_send - Send tpm request 116132f7629SAshley Lai * @chip: tpm chip struct 117132f7629SAshley Lai * @buf: buffer contains data to send 118132f7629SAshley Lai * count: size of buffer 119132f7629SAshley Lai * 120132f7629SAshley Lai * Return value: 121132f7629SAshley Lai * Number of bytes sent 122132f7629SAshley Lai */ 123132f7629SAshley Lai static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) 124132f7629SAshley Lai { 125132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 126132f7629SAshley Lai struct ibmvtpm_crq crq; 127132f7629SAshley Lai u64 *word = (u64 *) &crq; 128132f7629SAshley Lai int rc; 129132f7629SAshley Lai 130132f7629SAshley Lai ibmvtpm = (struct ibmvtpm_dev *)chip->vendor.data; 131132f7629SAshley Lai 132132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 133132f7629SAshley Lai dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n"); 134132f7629SAshley Lai return 0; 135132f7629SAshley Lai } 136132f7629SAshley Lai 137132f7629SAshley Lai if (count > ibmvtpm->rtce_size) { 138132f7629SAshley Lai dev_err(ibmvtpm->dev, 139132f7629SAshley Lai "Invalid size in send: count=%ld, rtce_size=%d\n", 140132f7629SAshley Lai count, ibmvtpm->rtce_size); 141132f7629SAshley Lai return -EIO; 142132f7629SAshley Lai } 143132f7629SAshley Lai 144132f7629SAshley Lai spin_lock(&ibmvtpm->rtce_lock); 145132f7629SAshley Lai memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); 146132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 147132f7629SAshley Lai crq.msg = (u8)VTPM_TPM_COMMAND; 148132f7629SAshley Lai crq.len = (u16)count; 149132f7629SAshley Lai crq.data = ibmvtpm->rtce_dma_handle; 150132f7629SAshley Lai 151132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, word[0], word[1]); 152132f7629SAshley Lai if (rc != H_SUCCESS) { 153132f7629SAshley Lai dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n", rc); 154132f7629SAshley Lai rc = 0; 155132f7629SAshley Lai } else 156132f7629SAshley Lai rc = count; 157132f7629SAshley Lai 158132f7629SAshley Lai spin_unlock(&ibmvtpm->rtce_lock); 159132f7629SAshley Lai return rc; 160132f7629SAshley Lai } 161132f7629SAshley Lai 162132f7629SAshley Lai static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) 163132f7629SAshley Lai { 164132f7629SAshley Lai return; 165132f7629SAshley Lai } 166132f7629SAshley Lai 167132f7629SAshley Lai static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) 168132f7629SAshley Lai { 169132f7629SAshley Lai return 0; 170132f7629SAshley Lai } 171132f7629SAshley Lai 172132f7629SAshley Lai /** 173132f7629SAshley Lai * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size 174132f7629SAshley Lai * @ibmvtpm: vtpm device struct 175132f7629SAshley Lai * 176132f7629SAshley Lai * Return value: 177132f7629SAshley Lai * 0 - Success 178132f7629SAshley Lai * Non-zero - Failure 179132f7629SAshley Lai */ 180132f7629SAshley Lai static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) 181132f7629SAshley Lai { 182132f7629SAshley Lai struct ibmvtpm_crq crq; 183132f7629SAshley Lai u64 *buf = (u64 *) &crq; 184132f7629SAshley Lai int rc; 185132f7629SAshley Lai 186132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 187132f7629SAshley Lai crq.msg = (u8)VTPM_GET_RTCE_BUFFER_SIZE; 188132f7629SAshley Lai 189132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], 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 215132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], buf[1]); 216132f7629SAshley Lai if (rc != H_SUCCESS) 217132f7629SAshley Lai dev_err(ibmvtpm->dev, 218132f7629SAshley Lai "ibmvtpm_crq_get_version failed rc=%d\n", rc); 219132f7629SAshley Lai 220132f7629SAshley Lai return rc; 221132f7629SAshley Lai } 222132f7629SAshley Lai 223132f7629SAshley Lai /** 224132f7629SAshley Lai * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message 225132f7629SAshley Lai * @ibmvtpm: vtpm device struct 226132f7629SAshley Lai * 227132f7629SAshley Lai * Return value: 228132f7629SAshley Lai * 0 - Success 229132f7629SAshley Lai * Non-zero - Failure 230132f7629SAshley Lai */ 231132f7629SAshley Lai static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) 232132f7629SAshley Lai { 233132f7629SAshley Lai int rc; 234132f7629SAshley Lai 235132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_COMP_CMD, 0); 236132f7629SAshley Lai if (rc != H_SUCCESS) 237132f7629SAshley Lai dev_err(ibmvtpm->dev, 238132f7629SAshley Lai "ibmvtpm_crq_send_init_complete failed rc=%d\n", rc); 239132f7629SAshley Lai 240132f7629SAshley Lai return rc; 241132f7629SAshley Lai } 242132f7629SAshley Lai 243132f7629SAshley Lai /** 244132f7629SAshley Lai * ibmvtpm_crq_send_init - Send a CRQ initialize message 245132f7629SAshley Lai * @ibmvtpm: vtpm device struct 246132f7629SAshley Lai * 247132f7629SAshley Lai * Return value: 248132f7629SAshley Lai * 0 - Success 249132f7629SAshley Lai * Non-zero - Failure 250132f7629SAshley Lai */ 251132f7629SAshley Lai static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) 252132f7629SAshley Lai { 253132f7629SAshley Lai int rc; 254132f7629SAshley Lai 255132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, INIT_CRQ_CMD, 0); 256132f7629SAshley Lai if (rc != H_SUCCESS) 257132f7629SAshley Lai dev_err(ibmvtpm->dev, 258132f7629SAshley Lai "ibmvtpm_crq_send_init failed rc=%d\n", rc); 259132f7629SAshley Lai 260132f7629SAshley Lai return rc; 261132f7629SAshley Lai } 262132f7629SAshley Lai 263132f7629SAshley Lai /** 264132f7629SAshley Lai * tpm_ibmvtpm_remove - ibm vtpm remove entry point 265132f7629SAshley Lai * @vdev: vio device struct 266132f7629SAshley Lai * 267132f7629SAshley Lai * Return value: 268132f7629SAshley Lai * 0 269132f7629SAshley Lai */ 270132f7629SAshley Lai static int __devexit tpm_ibmvtpm_remove(struct vio_dev *vdev) 271132f7629SAshley Lai { 272132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(&vdev->dev); 273132f7629SAshley Lai int rc = 0; 274132f7629SAshley Lai 275132f7629SAshley Lai free_irq(vdev->irq, ibmvtpm); 276132f7629SAshley Lai tasklet_kill(&ibmvtpm->tasklet); 277132f7629SAshley Lai 278132f7629SAshley Lai do { 279132f7629SAshley Lai if (rc) 280132f7629SAshley Lai msleep(100); 281132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 282132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 283132f7629SAshley Lai 284132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, 285132f7629SAshley Lai CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); 286132f7629SAshley Lai free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); 287132f7629SAshley Lai 288132f7629SAshley Lai if (ibmvtpm->rtce_buf) { 289132f7629SAshley Lai dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, 290132f7629SAshley Lai ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); 291132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 292132f7629SAshley Lai } 293132f7629SAshley Lai 294132f7629SAshley Lai tpm_remove_hardware(ibmvtpm->dev); 295132f7629SAshley Lai 296132f7629SAshley Lai kfree(ibmvtpm); 297132f7629SAshley Lai 298132f7629SAshley Lai return 0; 299132f7629SAshley Lai } 300132f7629SAshley Lai 301132f7629SAshley Lai /** 302132f7629SAshley Lai * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver 303132f7629SAshley Lai * @vdev: vio device struct 304132f7629SAshley Lai * 305132f7629SAshley Lai * Return value: 306132f7629SAshley Lai * Number of bytes the driver needs to DMA map 307132f7629SAshley Lai */ 308132f7629SAshley Lai static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) 309132f7629SAshley Lai { 310132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(&vdev->dev); 311132f7629SAshley Lai return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; 312132f7629SAshley Lai } 313132f7629SAshley Lai 314132f7629SAshley Lai /** 315132f7629SAshley Lai * tpm_ibmvtpm_suspend - Suspend 316132f7629SAshley Lai * @dev: device struct 317132f7629SAshley Lai * 318132f7629SAshley Lai * Return value: 319132f7629SAshley Lai * 0 320132f7629SAshley Lai */ 321132f7629SAshley Lai static int tpm_ibmvtpm_suspend(struct device *dev) 322132f7629SAshley Lai { 323132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(dev); 324132f7629SAshley Lai struct ibmvtpm_crq crq; 325132f7629SAshley Lai u64 *buf = (u64 *) &crq; 326132f7629SAshley Lai int rc = 0; 327132f7629SAshley Lai 328132f7629SAshley Lai crq.valid = (u8)IBMVTPM_VALID_CMD; 329132f7629SAshley Lai crq.msg = (u8)VTPM_PREPARE_TO_SUSPEND; 330132f7629SAshley Lai 331132f7629SAshley Lai rc = ibmvtpm_send_crq(ibmvtpm->vdev, buf[0], buf[1]); 332132f7629SAshley Lai if (rc != H_SUCCESS) 333132f7629SAshley Lai dev_err(ibmvtpm->dev, 334132f7629SAshley Lai "tpm_ibmvtpm_suspend failed rc=%d\n", rc); 335132f7629SAshley Lai 336132f7629SAshley Lai return rc; 337132f7629SAshley Lai } 338132f7629SAshley Lai 339132f7629SAshley Lai /** 340132f7629SAshley Lai * ibmvtpm_reset_crq - Reset CRQ 341132f7629SAshley Lai * @ibmvtpm: ibm vtpm struct 342132f7629SAshley Lai * 343132f7629SAshley Lai * Return value: 344132f7629SAshley Lai * 0 - Success 345132f7629SAshley Lai * Non-zero - Failure 346132f7629SAshley Lai */ 347132f7629SAshley Lai static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) 348132f7629SAshley Lai { 349132f7629SAshley Lai int rc = 0; 350132f7629SAshley Lai 351132f7629SAshley Lai do { 352132f7629SAshley Lai if (rc) 353132f7629SAshley Lai msleep(100); 354132f7629SAshley Lai rc = plpar_hcall_norets(H_FREE_CRQ, 355132f7629SAshley Lai ibmvtpm->vdev->unit_address); 356132f7629SAshley Lai } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); 357132f7629SAshley Lai 358132f7629SAshley Lai memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); 359132f7629SAshley Lai ibmvtpm->crq_queue.index = 0; 360132f7629SAshley Lai 361132f7629SAshley Lai return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, 362132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 363132f7629SAshley Lai } 364132f7629SAshley Lai 365132f7629SAshley Lai /** 366132f7629SAshley Lai * tpm_ibmvtpm_resume - Resume from suspend 367132f7629SAshley Lai * @dev: device struct 368132f7629SAshley Lai * 369132f7629SAshley Lai * Return value: 370132f7629SAshley Lai * 0 371132f7629SAshley Lai */ 372132f7629SAshley Lai static int tpm_ibmvtpm_resume(struct device *dev) 373132f7629SAshley Lai { 374132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = ibmvtpm_get_data(dev); 375132f7629SAshley Lai unsigned long flags; 376132f7629SAshley Lai int rc = 0; 377132f7629SAshley Lai 378132f7629SAshley Lai do { 379132f7629SAshley Lai if (rc) 380132f7629SAshley Lai msleep(100); 381132f7629SAshley Lai rc = plpar_hcall_norets(H_ENABLE_CRQ, 382132f7629SAshley Lai ibmvtpm->vdev->unit_address); 383132f7629SAshley Lai } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); 384132f7629SAshley Lai 385132f7629SAshley Lai if (rc) { 386132f7629SAshley Lai dev_err(dev, "Error enabling ibmvtpm rc=%d\n", rc); 387132f7629SAshley Lai return rc; 388132f7629SAshley Lai } 389132f7629SAshley Lai 390132f7629SAshley Lai spin_lock_irqsave(&ibmvtpm->lock, flags); 391132f7629SAshley Lai vio_disable_interrupts(ibmvtpm->vdev); 392132f7629SAshley Lai tasklet_schedule(&ibmvtpm->tasklet); 393132f7629SAshley Lai spin_unlock_irqrestore(&ibmvtpm->lock, flags); 394132f7629SAshley Lai 395132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 396132f7629SAshley Lai if (rc) 397132f7629SAshley Lai dev_err(dev, "Error send_init rc=%d\n", rc); 398132f7629SAshley Lai 399132f7629SAshley Lai return rc; 400132f7629SAshley Lai } 401132f7629SAshley Lai 402132f7629SAshley Lai static const struct file_operations ibmvtpm_ops = { 403132f7629SAshley Lai .owner = THIS_MODULE, 404132f7629SAshley Lai .llseek = no_llseek, 405132f7629SAshley Lai .open = tpm_open, 406132f7629SAshley Lai .read = tpm_read, 407132f7629SAshley Lai .write = tpm_write, 408132f7629SAshley Lai .release = tpm_release, 409132f7629SAshley Lai }; 410132f7629SAshley Lai 411132f7629SAshley Lai static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL); 412132f7629SAshley Lai static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL); 413132f7629SAshley Lai static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL); 414132f7629SAshley Lai static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL); 415132f7629SAshley Lai static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL); 416132f7629SAshley Lai static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, 417132f7629SAshley Lai NULL); 418132f7629SAshley Lai static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL); 419132f7629SAshley Lai static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel); 420132f7629SAshley Lai static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL); 421132f7629SAshley Lai static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL); 422132f7629SAshley Lai 423132f7629SAshley Lai static struct attribute *ibmvtpm_attrs[] = { 424132f7629SAshley Lai &dev_attr_pubek.attr, 425132f7629SAshley Lai &dev_attr_pcrs.attr, 426132f7629SAshley Lai &dev_attr_enabled.attr, 427132f7629SAshley Lai &dev_attr_active.attr, 428132f7629SAshley Lai &dev_attr_owned.attr, 429132f7629SAshley Lai &dev_attr_temp_deactivated.attr, 430132f7629SAshley Lai &dev_attr_caps.attr, 431132f7629SAshley Lai &dev_attr_cancel.attr, 432132f7629SAshley Lai &dev_attr_durations.attr, 433132f7629SAshley Lai &dev_attr_timeouts.attr, NULL, 434132f7629SAshley Lai }; 435132f7629SAshley Lai 436132f7629SAshley Lai static struct attribute_group ibmvtpm_attr_grp = { .attrs = ibmvtpm_attrs }; 437132f7629SAshley Lai 438132f7629SAshley Lai static const struct tpm_vendor_specific tpm_ibmvtpm = { 439132f7629SAshley Lai .recv = tpm_ibmvtpm_recv, 440132f7629SAshley Lai .send = tpm_ibmvtpm_send, 441132f7629SAshley Lai .cancel = tpm_ibmvtpm_cancel, 442132f7629SAshley Lai .status = tpm_ibmvtpm_status, 443132f7629SAshley Lai .req_complete_mask = 0, 444132f7629SAshley Lai .req_complete_val = 0, 445132f7629SAshley Lai .req_canceled = 0, 446132f7629SAshley Lai .attr_group = &ibmvtpm_attr_grp, 447132f7629SAshley Lai .miscdev = { .fops = &ibmvtpm_ops, }, 448132f7629SAshley Lai }; 449132f7629SAshley Lai 450132f7629SAshley Lai static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { 451132f7629SAshley Lai .suspend = tpm_ibmvtpm_suspend, 452132f7629SAshley Lai .resume = tpm_ibmvtpm_resume, 453132f7629SAshley Lai }; 454132f7629SAshley Lai 455132f7629SAshley Lai /** 456132f7629SAshley Lai * ibmvtpm_crq_get_next - Get next responded crq 457132f7629SAshley Lai * @ibmvtpm vtpm device struct 458132f7629SAshley Lai * 459132f7629SAshley Lai * Return value: 460132f7629SAshley Lai * vtpm crq pointer 461132f7629SAshley Lai */ 462132f7629SAshley Lai static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) 463132f7629SAshley Lai { 464132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; 465132f7629SAshley Lai struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; 466132f7629SAshley Lai 467132f7629SAshley Lai if (crq->valid & VTPM_MSG_RES) { 468132f7629SAshley Lai if (++crq_q->index == crq_q->num_entry) 469132f7629SAshley Lai crq_q->index = 0; 470132f7629SAshley Lai rmb(); 471132f7629SAshley Lai } else 472132f7629SAshley Lai crq = NULL; 473132f7629SAshley Lai return crq; 474132f7629SAshley Lai } 475132f7629SAshley Lai 476132f7629SAshley Lai /** 477132f7629SAshley Lai * ibmvtpm_crq_process - Process responded crq 478132f7629SAshley Lai * @crq crq to be processed 479132f7629SAshley Lai * @ibmvtpm vtpm device struct 480132f7629SAshley Lai * 481132f7629SAshley Lai * Return value: 482132f7629SAshley Lai * Nothing 483132f7629SAshley Lai */ 484132f7629SAshley Lai static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, 485132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm) 486132f7629SAshley Lai { 487132f7629SAshley Lai int rc = 0; 488132f7629SAshley Lai 489132f7629SAshley Lai switch (crq->valid) { 490132f7629SAshley Lai case VALID_INIT_CRQ: 491132f7629SAshley Lai switch (crq->msg) { 492132f7629SAshley Lai case INIT_CRQ_RES: 493132f7629SAshley Lai dev_info(ibmvtpm->dev, "CRQ initialized\n"); 494132f7629SAshley Lai rc = ibmvtpm_crq_send_init_complete(ibmvtpm); 495132f7629SAshley Lai if (rc) 496132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n", rc); 497132f7629SAshley Lai return; 498132f7629SAshley Lai case INIT_CRQ_COMP_RES: 499132f7629SAshley Lai dev_info(ibmvtpm->dev, 500132f7629SAshley Lai "CRQ initialization completed\n"); 501132f7629SAshley Lai return; 502132f7629SAshley Lai default: 503132f7629SAshley Lai dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n", crq->msg); 504132f7629SAshley Lai return; 505132f7629SAshley Lai } 506132f7629SAshley Lai return; 507132f7629SAshley Lai case IBMVTPM_VALID_CMD: 508132f7629SAshley Lai switch (crq->msg) { 509132f7629SAshley Lai case VTPM_GET_RTCE_BUFFER_SIZE_RES: 510132f7629SAshley Lai if (crq->len <= 0) { 511132f7629SAshley Lai dev_err(ibmvtpm->dev, "Invalid rtce size\n"); 512132f7629SAshley Lai return; 513132f7629SAshley Lai } 514132f7629SAshley Lai ibmvtpm->rtce_size = crq->len; 515132f7629SAshley Lai ibmvtpm->rtce_buf = kmalloc(ibmvtpm->rtce_size, 516132f7629SAshley Lai GFP_KERNEL); 517132f7629SAshley Lai if (!ibmvtpm->rtce_buf) { 518132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n"); 519132f7629SAshley Lai return; 520132f7629SAshley Lai } 521132f7629SAshley Lai 522132f7629SAshley Lai ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, 523132f7629SAshley Lai ibmvtpm->rtce_buf, ibmvtpm->rtce_size, 524132f7629SAshley Lai DMA_BIDIRECTIONAL); 525132f7629SAshley Lai 526132f7629SAshley Lai if (dma_mapping_error(ibmvtpm->dev, 527132f7629SAshley Lai ibmvtpm->rtce_dma_handle)) { 528132f7629SAshley Lai kfree(ibmvtpm->rtce_buf); 529132f7629SAshley Lai ibmvtpm->rtce_buf = NULL; 530132f7629SAshley Lai dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n"); 531132f7629SAshley Lai } 532132f7629SAshley Lai 533132f7629SAshley Lai return; 534132f7629SAshley Lai case VTPM_GET_VERSION_RES: 535132f7629SAshley Lai ibmvtpm->vtpm_version = crq->data; 536132f7629SAshley Lai return; 537132f7629SAshley Lai case VTPM_TPM_COMMAND_RES: 538132f7629SAshley Lai ibmvtpm->crq_res.valid = crq->valid; 539132f7629SAshley Lai ibmvtpm->crq_res.msg = crq->msg; 540132f7629SAshley Lai ibmvtpm->crq_res.len = crq->len; 541132f7629SAshley Lai ibmvtpm->crq_res.data = crq->data; 542132f7629SAshley Lai wake_up_interruptible(&wq); 543132f7629SAshley Lai return; 544132f7629SAshley Lai default: 545132f7629SAshley Lai return; 546132f7629SAshley Lai } 547132f7629SAshley Lai } 548132f7629SAshley Lai return; 549132f7629SAshley Lai } 550132f7629SAshley Lai 551132f7629SAshley Lai /** 552132f7629SAshley Lai * ibmvtpm_interrupt - Interrupt handler 553132f7629SAshley Lai * @irq: irq number to handle 554132f7629SAshley Lai * @vtpm_instance: vtpm that received interrupt 555132f7629SAshley Lai * 556132f7629SAshley Lai * Returns: 557132f7629SAshley Lai * IRQ_HANDLED 558132f7629SAshley Lai **/ 559132f7629SAshley Lai static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) 560132f7629SAshley Lai { 561132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; 562132f7629SAshley Lai unsigned long flags; 563132f7629SAshley Lai 564132f7629SAshley Lai spin_lock_irqsave(&ibmvtpm->lock, flags); 565132f7629SAshley Lai vio_disable_interrupts(ibmvtpm->vdev); 566132f7629SAshley Lai tasklet_schedule(&ibmvtpm->tasklet); 567132f7629SAshley Lai spin_unlock_irqrestore(&ibmvtpm->lock, flags); 568132f7629SAshley Lai 569132f7629SAshley Lai return IRQ_HANDLED; 570132f7629SAshley Lai } 571132f7629SAshley Lai 572132f7629SAshley Lai /** 573132f7629SAshley Lai * ibmvtpm_tasklet - Interrupt handler tasklet 574132f7629SAshley Lai * @data: ibm vtpm device struct 575132f7629SAshley Lai * 576132f7629SAshley Lai * Returns: 577132f7629SAshley Lai * Nothing 578132f7629SAshley Lai **/ 579132f7629SAshley Lai static void ibmvtpm_tasklet(void *data) 580132f7629SAshley Lai { 581132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm = data; 582132f7629SAshley Lai struct ibmvtpm_crq *crq; 583132f7629SAshley Lai unsigned long flags; 584132f7629SAshley Lai 585132f7629SAshley Lai spin_lock_irqsave(&ibmvtpm->lock, flags); 586132f7629SAshley Lai while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { 587132f7629SAshley Lai ibmvtpm_crq_process(crq, ibmvtpm); 588132f7629SAshley Lai crq->valid = 0; 589132f7629SAshley Lai wmb(); 590132f7629SAshley Lai } 591132f7629SAshley Lai 592132f7629SAshley Lai vio_enable_interrupts(ibmvtpm->vdev); 593132f7629SAshley Lai spin_unlock_irqrestore(&ibmvtpm->lock, flags); 594132f7629SAshley Lai } 595132f7629SAshley Lai 596132f7629SAshley Lai /** 597132f7629SAshley Lai * tpm_ibmvtpm_probe - ibm vtpm initialize entry point 598132f7629SAshley Lai * @vio_dev: vio device struct 599132f7629SAshley Lai * @id: vio device id struct 600132f7629SAshley Lai * 601132f7629SAshley Lai * Return value: 602132f7629SAshley Lai * 0 - Success 603132f7629SAshley Lai * Non-zero - Failure 604132f7629SAshley Lai */ 605132f7629SAshley Lai static int __devinit tpm_ibmvtpm_probe(struct vio_dev *vio_dev, 606132f7629SAshley Lai const struct vio_device_id *id) 607132f7629SAshley Lai { 608132f7629SAshley Lai struct ibmvtpm_dev *ibmvtpm; 609132f7629SAshley Lai struct device *dev = &vio_dev->dev; 610132f7629SAshley Lai struct ibmvtpm_crq_queue *crq_q; 611132f7629SAshley Lai struct tpm_chip *chip; 612132f7629SAshley Lai int rc = -ENOMEM, rc1; 613132f7629SAshley Lai 614132f7629SAshley Lai chip = tpm_register_hardware(dev, &tpm_ibmvtpm); 615132f7629SAshley Lai if (!chip) { 616132f7629SAshley Lai dev_err(dev, "tpm_register_hardware failed\n"); 617132f7629SAshley Lai return -ENODEV; 618132f7629SAshley Lai } 619132f7629SAshley Lai 620132f7629SAshley Lai ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL); 621132f7629SAshley Lai if (!ibmvtpm) { 622132f7629SAshley Lai dev_err(dev, "kzalloc for ibmvtpm failed\n"); 623132f7629SAshley Lai goto cleanup; 624132f7629SAshley Lai } 625132f7629SAshley Lai 626132f7629SAshley Lai crq_q = &ibmvtpm->crq_queue; 627132f7629SAshley Lai crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); 628132f7629SAshley Lai if (!crq_q->crq_addr) { 629132f7629SAshley Lai dev_err(dev, "Unable to allocate memory for crq_addr\n"); 630132f7629SAshley Lai goto cleanup; 631132f7629SAshley Lai } 632132f7629SAshley Lai 633132f7629SAshley Lai crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); 634132f7629SAshley Lai ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, 635132f7629SAshley Lai CRQ_RES_BUF_SIZE, 636132f7629SAshley Lai DMA_BIDIRECTIONAL); 637132f7629SAshley Lai 638132f7629SAshley Lai if (dma_mapping_error(dev, ibmvtpm->crq_dma_handle)) { 639132f7629SAshley Lai dev_err(dev, "dma mapping failed\n"); 640132f7629SAshley Lai goto cleanup; 641132f7629SAshley Lai } 642132f7629SAshley Lai 643132f7629SAshley Lai rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, 644132f7629SAshley Lai ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); 645132f7629SAshley Lai if (rc == H_RESOURCE) 646132f7629SAshley Lai rc = ibmvtpm_reset_crq(ibmvtpm); 647132f7629SAshley Lai 648132f7629SAshley Lai if (rc) { 649132f7629SAshley Lai dev_err(dev, "Unable to register CRQ rc=%d\n", rc); 650132f7629SAshley Lai goto reg_crq_cleanup; 651132f7629SAshley Lai } 652132f7629SAshley Lai 653132f7629SAshley Lai tasklet_init(&ibmvtpm->tasklet, (void *)ibmvtpm_tasklet, 654132f7629SAshley Lai (unsigned long)ibmvtpm); 655132f7629SAshley Lai 656132f7629SAshley Lai rc = request_irq(vio_dev->irq, ibmvtpm_interrupt, 0, 657132f7629SAshley Lai tpm_ibmvtpm_driver_name, ibmvtpm); 658132f7629SAshley Lai if (rc) { 659132f7629SAshley Lai dev_err(dev, "Error %d register irq 0x%x\n", rc, vio_dev->irq); 660132f7629SAshley Lai goto init_irq_cleanup; 661132f7629SAshley Lai } 662132f7629SAshley Lai 663132f7629SAshley Lai rc = vio_enable_interrupts(vio_dev); 664132f7629SAshley Lai if (rc) { 665132f7629SAshley Lai dev_err(dev, "Error %d enabling interrupts\n", rc); 666132f7629SAshley Lai goto init_irq_cleanup; 667132f7629SAshley Lai } 668132f7629SAshley Lai 669132f7629SAshley Lai crq_q->index = 0; 670132f7629SAshley Lai 671132f7629SAshley Lai ibmvtpm->dev = dev; 672132f7629SAshley Lai ibmvtpm->vdev = vio_dev; 673132f7629SAshley Lai chip->vendor.data = (void *)ibmvtpm; 674132f7629SAshley Lai 675132f7629SAshley Lai spin_lock_init(&ibmvtpm->lock); 676132f7629SAshley Lai spin_lock_init(&ibmvtpm->rtce_lock); 677132f7629SAshley Lai 678132f7629SAshley Lai rc = ibmvtpm_crq_send_init(ibmvtpm); 679132f7629SAshley Lai if (rc) 680132f7629SAshley Lai goto init_irq_cleanup; 681132f7629SAshley Lai 682132f7629SAshley Lai rc = ibmvtpm_crq_get_version(ibmvtpm); 683132f7629SAshley Lai if (rc) 684132f7629SAshley Lai goto init_irq_cleanup; 685132f7629SAshley Lai 686132f7629SAshley Lai rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); 687132f7629SAshley Lai if (rc) 688132f7629SAshley Lai goto init_irq_cleanup; 689132f7629SAshley Lai 690132f7629SAshley Lai return rc; 691132f7629SAshley Lai init_irq_cleanup: 692132f7629SAshley Lai tasklet_kill(&ibmvtpm->tasklet); 693132f7629SAshley Lai do { 694132f7629SAshley Lai rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); 695132f7629SAshley Lai } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); 696132f7629SAshley Lai reg_crq_cleanup: 697132f7629SAshley Lai dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, 698132f7629SAshley Lai DMA_BIDIRECTIONAL); 699132f7629SAshley Lai cleanup: 700132f7629SAshley Lai if (ibmvtpm) { 701132f7629SAshley Lai if (crq_q->crq_addr) 702132f7629SAshley Lai free_page((unsigned long)crq_q->crq_addr); 703132f7629SAshley Lai kfree(ibmvtpm); 704132f7629SAshley Lai } 705132f7629SAshley Lai 706132f7629SAshley Lai tpm_remove_hardware(dev); 707132f7629SAshley Lai 708132f7629SAshley Lai return rc; 709132f7629SAshley Lai } 710132f7629SAshley Lai 711132f7629SAshley Lai static struct vio_driver ibmvtpm_driver = { 712132f7629SAshley Lai .id_table = tpm_ibmvtpm_device_table, 713132f7629SAshley Lai .probe = tpm_ibmvtpm_probe, 714132f7629SAshley Lai .remove = tpm_ibmvtpm_remove, 715132f7629SAshley Lai .get_desired_dma = tpm_ibmvtpm_get_desired_dma, 716132f7629SAshley Lai .name = tpm_ibmvtpm_driver_name, 717132f7629SAshley Lai .pm = &tpm_ibmvtpm_pm_ops, 718132f7629SAshley Lai }; 719132f7629SAshley Lai 720132f7629SAshley Lai /** 721132f7629SAshley Lai * ibmvtpm_module_init - Initialize ibm vtpm module 722132f7629SAshley Lai * 723132f7629SAshley Lai * Return value: 724132f7629SAshley Lai * 0 -Success 725132f7629SAshley Lai * Non-zero - Failure 726132f7629SAshley Lai */ 727132f7629SAshley Lai static int __init ibmvtpm_module_init(void) 728132f7629SAshley Lai { 729132f7629SAshley Lai return vio_register_driver(&ibmvtpm_driver); 730132f7629SAshley Lai } 731132f7629SAshley Lai 732132f7629SAshley Lai /** 733132f7629SAshley Lai * ibmvtpm_module_exit - Teardown ibm vtpm module 734132f7629SAshley Lai * 735132f7629SAshley Lai * Return value: 736132f7629SAshley Lai * Nothing 737132f7629SAshley Lai */ 738132f7629SAshley Lai static void __exit ibmvtpm_module_exit(void) 739132f7629SAshley Lai { 740132f7629SAshley Lai vio_unregister_driver(&ibmvtpm_driver); 741132f7629SAshley Lai } 742132f7629SAshley Lai 743132f7629SAshley Lai module_init(ibmvtpm_module_init); 744132f7629SAshley Lai module_exit(ibmvtpm_module_exit); 745132f7629SAshley Lai 746132f7629SAshley Lai MODULE_AUTHOR("adlai@us.ibm.com"); 747132f7629SAshley Lai MODULE_DESCRIPTION("IBM vTPM Driver"); 748132f7629SAshley Lai MODULE_VERSION("1.0"); 749132f7629SAshley Lai MODULE_LICENSE("GPL"); 750