[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / tpm / tpm.c

/*
 * Copyright (C) 2004 IBM Corporation
 *
 * Authors:
 * Leendert van Doorn <leendert@watson.ibm.com>
 * Dave Safford <safford@watson.ibm.com>
 * Reiner Sailer <sailer@watson.ibm.com>
 * Kylene Hall <kjhall@us.ibm.com>
 *
 * Maintained by: <tpmdd_devel@lists.sourceforge.net>
 *
 * Device driver for TCG/TCPA TPM (trusted platform module).
 * Specifications at www.trustedcomputinggroup.org	 
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, version 2 of the
 * License.
 * 
 * Note, the TPM chip is not interrupt driven (only polling)
 * and can have very long timeouts (minutes!). Hence the unusual
 * calls to msleep.
 *
 */

#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/spinlock.h>
#include "tpm.h"

enum tpm_const {
	TPM_MINOR = 224,	/* officially assigned */
	TPM_BUFSIZE = 2048,
	TPM_NUM_DEVICES = 256,
	TPM_NUM_MASK_ENTRIES = TPM_NUM_DEVICES / (8 * sizeof(int))
};

  /* PCI configuration addresses */
enum tpm_pci_config_addr {
	PCI_GEN_PMCON_1 = 0xA0,
	PCI_GEN1_DEC = 0xE4,
	PCI_LPC_EN = 0xE6,
	PCI_GEN2_DEC = 0xEC
};

enum tpm_config {
	TPM_LOCK_REG = 0x0D,
	TPM_INTERUPT_REG = 0x0A,
	TPM_BASE_ADDR_LO = 0x08,
	TPM_BASE_ADDR_HI = 0x09,
	TPM_UNLOCK_VALUE = 0x55,
	TPM_LOCK_VALUE = 0xAA,
	TPM_DISABLE_INTERUPT_VALUE = 0x00
};


static LIST_HEAD(tpm_chip_list);
static DEFINE_SPINLOCK(driver_lock);
static int dev_mask[TPM_NUM_MASK_ENTRIES];

static void user_reader_timeout(unsigned long ptr)
{
	struct tpm_chip *chip = (struct tpm_chip *) ptr;

	down(&chip->buffer_mutex);
	atomic_set(&chip->data_pending, 0);
	memset(chip->data_buffer, 0, TPM_BUFSIZE);
	up(&chip->buffer_mutex);
}

/*
 * Initialize the LPC bus and enable the TPM ports
 */
int tpm_lpc_bus_init(struct pci_dev *pci_dev, u16 base)
{
	u32 lpcenable, tmp;
	int is_lpcm = 0;

	switch (pci_dev->vendor) {
	case PCI_VENDOR_ID_INTEL:
		switch (pci_dev->device) {
		case PCI_DEVICE_ID_INTEL_82801CA_12:
		case PCI_DEVICE_ID_INTEL_82801DB_12:
			is_lpcm = 1;
			break;
		}
		/* init ICH (enable LPC) */
		pci_read_config_dword(pci_dev, PCI_GEN1_DEC, &lpcenable);
		lpcenable |= 0x20000000;
		pci_write_config_dword(pci_dev, PCI_GEN1_DEC, lpcenable);

		if (is_lpcm) {
			pci_read_config_dword(pci_dev, PCI_GEN1_DEC,
					      &lpcenable);
			if ((lpcenable & 0x20000000) == 0) {
				dev_err(&pci_dev->dev,
					"cannot enable LPC\n");
				return -ENODEV;
			}
		}

		/* initialize TPM registers */
		pci_read_config_dword(pci_dev, PCI_GEN2_DEC, &tmp);

		if (!is_lpcm)
			tmp = (tmp & 0xFFFF0000) | (base & 0xFFF0);
		else
			tmp =
			    (tmp & 0xFFFF0000) | (base & 0xFFF0) |
			    0x00000001;

		pci_write_config_dword(pci_dev, PCI_GEN2_DEC, tmp);

		if (is_lpcm) {
			pci_read_config_dword(pci_dev, PCI_GEN_PMCON_1,
					      &tmp);
			tmp |= 0x00000004;	/* enable CLKRUN */
			pci_write_config_dword(pci_dev, PCI_GEN_PMCON_1,
					       tmp);
		}
		break;
	case PCI_VENDOR_ID_AMD:
		/* nothing yet */
		break;
	}

	tpm_write_index(TPM_LOCK_REG, TPM_UNLOCK_VALUE);
	tpm_write_index(TPM_INTERUPT_REG, TPM_DISABLE_INTERUPT_VALUE);
	tpm_write_index(TPM_BASE_ADDR_LO, base);
	tpm_write_index(TPM_BASE_ADDR_HI, (base & 0xFF00) >> 8);
	tpm_write_index(TPM_LOCK_REG, TPM_LOCK_VALUE);

	return 0;
}

EXPORT_SYMBOL_GPL(tpm_lpc_bus_init);

/*
 * Internal kernel interface to transmit TPM commands
 */
static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
			    size_t bufsiz)
{
	ssize_t len;
	u32 count;
	unsigned long stop;

	count = be32_to_cpu(*((__be32 *) (buf + 2)));

	if (count == 0)
		return -ENODATA;
	if (count > bufsiz) {
		dev_err(&chip->pci_dev->dev,
			"invalid count value %x %zx \n", count, bufsiz);
		return -E2BIG;
	}

	down(&chip->tpm_mutex);

	if ((len = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
		dev_err(&chip->pci_dev->dev,
			"tpm_transmit: tpm_send: error %zd\n", len);
		return len;
	}

	stop = jiffies + 2 * 60 * HZ;
	do {
		u8 status = inb(chip->vendor->base + 1);
		if ((status & chip->vendor->req_complete_mask) ==
		    chip->vendor->req_complete_val) {
			goto out_recv;
		}
		msleep(TPM_TIMEOUT); /* CHECK */
		rmb();
	} while (time_before(jiffies, stop));


	chip->vendor->cancel(chip);
	dev_err(&chip->pci_dev->dev, "Time expired\n");
	up(&chip->tpm_mutex);
	return -EIO;

out_recv:
	len = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
	if (len < 0)
		dev_err(&chip->pci_dev->dev,
			"tpm_transmit: tpm_recv: error %zd\n", len);
	up(&chip->tpm_mutex);
	return len;
}

#define TPM_DIGEST_SIZE 20
#define CAP_PCR_RESULT_SIZE 18
static const u8 cap_pcr[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 22,		/* length */
	0, 0, 0, 101,		/* TPM_ORD_GetCapability */
	0, 0, 0, 5,
	0, 0, 0, 4,
	0, 0, 1, 1
};

#define READ_PCR_RESULT_SIZE 30
static const u8 pcrread[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 14,		/* length */
	0, 0, 0, 21,		/* TPM_ORD_PcrRead */
	0, 0, 0, 0		/* PCR index */
};

static ssize_t show_pcrs(struct device *dev, struct device_attribute *attr, char *buf)
{
	u8 data[READ_PCR_RESULT_SIZE];
	ssize_t len;
	int i, j, num_pcrs;
	__be32 index;
	char *str = buf;

	struct tpm_chip *chip =
	    pci_get_drvdata(to_pci_dev(dev));
	if (chip == NULL)
		return -ENODEV;

	memcpy(data, cap_pcr, sizeof(cap_pcr));
	if ((len = tpm_transmit(chip, data, sizeof(data)))
	    < CAP_PCR_RESULT_SIZE)
		return len;

	num_pcrs = be32_to_cpu(*((__be32 *) (data + 14)));

	for (i = 0; i < num_pcrs; i++) {
		memcpy(data, pcrread, sizeof(pcrread));
		index = cpu_to_be32(i);
		memcpy(data + 10, &index, 4);
		if ((len = tpm_transmit(chip, data, sizeof(data)))
		    < READ_PCR_RESULT_SIZE)
			return len;
		str += sprintf(str, "PCR-%02d: ", i);
		for (j = 0; j < TPM_DIGEST_SIZE; j++)
			str += sprintf(str, "%02X ", *(data + 10 + j));
		str += sprintf(str, "\n");
	}
	return str - buf;
}

static DEVICE_ATTR(pcrs, S_IRUGO, show_pcrs, NULL);

#define  READ_PUBEK_RESULT_SIZE 314
static const u8 readpubek[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 30,		/* length */
	0, 0, 0, 124,		/* TPM_ORD_ReadPubek */
};

static ssize_t show_pubek(struct device *dev, struct device_attribute *attr, char *buf)
{
	u8 *data;
	ssize_t len;
	int i, rc;
	char *str = buf;

	struct tpm_chip *chip =
	    pci_get_drvdata(to_pci_dev(dev));
	if (chip == NULL)
		return -ENODEV;

	data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	memcpy(data, readpubek, sizeof(readpubek));
	memset(data + sizeof(readpubek), 0, 20);	/* zero nonce */

	if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
	    READ_PUBEK_RESULT_SIZE) {
		rc = len;
		goto out;
	}

	/* 
	   ignore header 10 bytes
	   algorithm 32 bits (1 == RSA )
	   encscheme 16 bits
	   sigscheme 16 bits
	   parameters (RSA 12->bytes: keybit, #primes, expbit)  
	   keylenbytes 32 bits
	   256 byte modulus
	   ignore checksum 20 bytes
	 */

	str +=
	    sprintf(str,
		    "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
		    "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
		    " %02X %02X %02X %02X %02X %02X %02X %02X\n"
		    "Modulus length: %d\nModulus: \n",
		    data[10], data[11], data[12], data[13], data[14],
		    data[15], data[16], data[17], data[22], data[23],
		    data[24], data[25], data[26], data[27], data[28],
		    data[29], data[30], data[31], data[32], data[33],
		    be32_to_cpu(*((__be32 *) (data + 32))));

	for (i = 0; i < 256; i++) {
		str += sprintf(str, "%02X ", data[i + 39]);
		if ((i + 1) % 16 == 0)
			str += sprintf(str, "\n");
	}
	rc = str - buf;
out:
	kfree(data);
	return rc;
}

static DEVICE_ATTR(pubek, S_IRUGO, show_pubek, NULL);

#define CAP_VER_RESULT_SIZE 18
static const u8 cap_version[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 18,		/* length */
	0, 0, 0, 101,		/* TPM_ORD_GetCapability */
	0, 0, 0, 6,
	0, 0, 0, 0
};

#define CAP_MANUFACTURER_RESULT_SIZE 18
static const u8 cap_manufacturer[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 22,		/* length */
	0, 0, 0, 101,		/* TPM_ORD_GetCapability */
	0, 0, 0, 5,
	0, 0, 0, 4,
	0, 0, 1, 3
};

static ssize_t show_caps(struct device *dev, struct device_attribute *attr, char *buf)
{
	u8 data[sizeof(cap_manufacturer)];
	ssize_t len;
	char *str = buf;

	struct tpm_chip *chip =
	    pci_get_drvdata(to_pci_dev(dev));
	if (chip == NULL)
		return -ENODEV;

	memcpy(data, cap_manufacturer, sizeof(cap_manufacturer));

	if ((len = tpm_transmit(chip, data, sizeof(data))) <
	    CAP_MANUFACTURER_RESULT_SIZE)
		return len;

	str += sprintf(str, "Manufacturer: 0x%x\n",
		       be32_to_cpu(*((__be32 *) (data + 14))));

	memcpy(data, cap_version, sizeof(cap_version));

	if ((len = tpm_transmit(chip, data, sizeof(data))) <
	    CAP_VER_RESULT_SIZE)
		return len;

	str +=
	    sprintf(str, "TCG version: %d.%d\nFirmware version: %d.%d\n",
		    (int) data[14], (int) data[15], (int) data[16],
		    (int) data[17]);

	return str - buf;
}

static DEVICE_ATTR(caps, S_IRUGO, show_caps, NULL);

/*
 * Device file system interface to the TPM
 */
int tpm_open(struct inode *inode, struct file *file)
{
	int rc = 0, minor = iminor(inode);
	struct tpm_chip *chip = NULL, *pos;

	spin_lock(&driver_lock);

	list_for_each_entry(pos, &tpm_chip_list, list) {
		if (pos->vendor->miscdev.minor == minor) {
			chip = pos;
			break;
		}
	}

	if (chip == NULL) {
		rc = -ENODEV;
		goto err_out;
	}

	if (chip->num_opens) {
		dev_dbg(&chip->pci_dev->dev,
			"Another process owns this TPM\n");
		rc = -EBUSY;
		goto err_out;
	}

	chip->num_opens++;
	pci_dev_get(chip->pci_dev);

	spin_unlock(&driver_lock);

	chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
	if (chip->data_buffer == NULL) {
		chip->num_opens--;
		pci_dev_put(chip->pci_dev);
		return -ENOMEM;
	}

	atomic_set(&chip->data_pending, 0);

	file->private_data = chip;
	return 0;

err_out:
	spin_unlock(&driver_lock);
	return rc;
}

EXPORT_SYMBOL_GPL(tpm_open);

int tpm_release(struct inode *inode, struct file *file)
{
	struct tpm_chip *chip = file->private_data;
	
	file->private_data = NULL;

	spin_lock(&driver_lock);
	chip->num_opens--;
	del_singleshot_timer_sync(&chip->user_read_timer);
	atomic_set(&chip->data_pending, 0);

	pci_dev_put(chip->pci_dev);
	return 0;
}

EXPORT_SYMBOL_GPL(tpm_release);

ssize_t tpm_write(struct file * file, const char __user * buf,
		  size_t size, loff_t * off)
{
	struct tpm_chip *chip = file->private_data;
	int in_size = size, out_size;

	/* cannot perform a write until the read has cleared
	   either via tpm_read or a user_read_timer timeout */
	while (atomic_read(&chip->data_pending) != 0)
		msleep(TPM_TIMEOUT);

	down(&chip->buffer_mutex);

	if (in_size > TPM_BUFSIZE)
		in_size = TPM_BUFSIZE;

	if (copy_from_user
	    (chip->data_buffer, (void __user *) buf, in_size)) {
		up(&chip->buffer_mutex);
		return -EFAULT;
	}

	/* atomic tpm command send and result receive */
	out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);

	atomic_set(&chip->data_pending, out_size);
	up(&chip->buffer_mutex);

	/* Set a timeout by which the reader must come claim the result */
	mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));

	return in_size;
}

EXPORT_SYMBOL_GPL(tpm_write);

ssize_t tpm_read(struct file * file, char __user * buf,
		 size_t size, loff_t * off)
{
	struct tpm_chip *chip = file->private_data;
	int ret_size;

	del_singleshot_timer_sync(&chip->user_read_timer);
	ret_size = atomic_read(&chip->data_pending);
	atomic_set(&chip->data_pending, 0);
	if (ret_size > 0) {	/* relay data */
		if (size < ret_size)
			ret_size = size;

		down(&chip->buffer_mutex);
		if (copy_to_user
		    ((void __user *) buf, chip->data_buffer, ret_size))
			ret_size = -EFAULT;
		up(&chip->buffer_mutex);
	}

	return ret_size;
}

EXPORT_SYMBOL_GPL(tpm_read);

void __devexit tpm_remove(struct pci_dev *pci_dev)
{
	struct tpm_chip *chip = pci_get_drvdata(pci_dev);

	if (chip == NULL) {
		dev_err(&pci_dev->dev, "No device data found\n");
		return;
	}

	spin_lock(&driver_lock);

	list_del(&chip->list);

	spin_unlock(&driver_lock);

	pci_set_drvdata(pci_dev, NULL);
	misc_deregister(&chip->vendor->miscdev);

	device_remove_file(&pci_dev->dev, &dev_attr_pubek);
	device_remove_file(&pci_dev->dev, &dev_attr_pcrs);
	device_remove_file(&pci_dev->dev, &dev_attr_caps);

	pci_disable_device(pci_dev);

	dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));

	kfree(chip);

	pci_dev_put(pci_dev);
}

EXPORT_SYMBOL_GPL(tpm_remove);

static u8 savestate[] = {
	0, 193,			/* TPM_TAG_RQU_COMMAND */
	0, 0, 0, 10,		/* blob length (in bytes) */
	0, 0, 0, 152		/* TPM_ORD_SaveState */
};

/*
 * We are about to suspend. Save the TPM state
 * so that it can be restored.
 */
int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
{
	struct tpm_chip *chip = pci_get_drvdata(pci_dev);
	if (chip == NULL)
		return -ENODEV;

	tpm_transmit(chip, savestate, sizeof(savestate));
	return 0;
}

EXPORT_SYMBOL_GPL(tpm_pm_suspend);

/*
 * Resume from a power safe. The BIOS already restored
 * the TPM state.
 */
int tpm_pm_resume(struct pci_dev *pci_dev)
{
	struct tpm_chip *chip = pci_get_drvdata(pci_dev);

	if (chip == NULL)
		return -ENODEV;

	spin_lock(&driver_lock);
	tpm_lpc_bus_init(pci_dev, chip->vendor->base);
	spin_unlock(&driver_lock);

	return 0;
}

EXPORT_SYMBOL_GPL(tpm_pm_resume);

/*
 * Called from tpm_<specific>.c probe function only for devices 
 * the driver has determined it should claim.  Prior to calling
 * this function the specific probe function has called pci_enable_device
 * upon errant exit from this function specific probe function should call
 * pci_disable_device
 */
int tpm_register_hardware(struct pci_dev *pci_dev,
			  struct tpm_vendor_specific *entry)
{
	char devname[7];
	struct tpm_chip *chip;
	int i, j;

	/* Driver specific per-device data */
	chip = kmalloc(sizeof(*chip), GFP_KERNEL);
	if (chip == NULL)
		return -ENOMEM;

	memset(chip, 0, sizeof(struct tpm_chip));

	init_MUTEX(&chip->buffer_mutex);
	init_MUTEX(&chip->tpm_mutex);
	INIT_LIST_HEAD(&chip->list);

	init_timer(&chip->user_read_timer);
	chip->user_read_timer.function = user_reader_timeout;
	chip->user_read_timer.data = (unsigned long) chip;

	chip->vendor = entry;

	chip->dev_num = -1;

	for (i = 0; i < TPM_NUM_MASK_ENTRIES; i++)
		for (j = 0; j < 8 * sizeof(int); j++)
			if ((dev_mask[i] & (1 << j)) == 0) {
				chip->dev_num =
				    i * TPM_NUM_MASK_ENTRIES + j;
				dev_mask[i] |= 1 << j;
				goto dev_num_search_complete;
			}

dev_num_search_complete:
	if (chip->dev_num < 0) {
		dev_err(&pci_dev->dev,
			"No available tpm device numbers\n");
		kfree(chip);
		return -ENODEV;
	} else if (chip->dev_num == 0)
		chip->vendor->miscdev.minor = TPM_MINOR;
	else
		chip->vendor->miscdev.minor = MISC_DYNAMIC_MINOR;

	snprintf(devname, sizeof(devname), "%s%d", "tpm", chip->dev_num);
	chip->vendor->miscdev.name = devname;

	chip->vendor->miscdev.dev = &(pci_dev->dev);
	chip->pci_dev = pci_dev_get(pci_dev);

	if (misc_register(&chip->vendor->miscdev)) {
		dev_err(&chip->pci_dev->dev,
			"unable to misc_register %s, minor %d\n",
			chip->vendor->miscdev.name,
			chip->vendor->miscdev.minor);
		pci_dev_put(pci_dev);
		kfree(chip);
		dev_mask[i] &= !(1 << j);
		return -ENODEV;
	}

	pci_set_drvdata(pci_dev, chip);

	list_add(&chip->list, &tpm_chip_list);

	device_create_file(&pci_dev->dev, &dev_attr_pubek);
	device_create_file(&pci_dev->dev, &dev_attr_pcrs);
	device_create_file(&pci_dev->dev, &dev_attr_caps);

	return 0;
}

EXPORT_SYMBOL_GPL(tpm_register_hardware);

MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
MODULE_DESCRIPTION("TPM Driver");
MODULE_VERSION("2.0");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2004 IBM Corporation
	3	*
	4	* Authors:
	5	* Leendert van Doorn <leendert@watson.ibm.com>
	6	* Dave Safford <safford@watson.ibm.com>
	7	* Reiner Sailer <sailer@watson.ibm.com>
	8	* Kylene Hall <kjhall@us.ibm.com>
	9	*
	10	* Maintained by: <tpmdd_devel@lists.sourceforge.net>
	11	*
	12	* Device driver for TCG/TCPA TPM (trusted platform module).
	13	* Specifications at www.trustedcomputinggroup.org
	14	*
	15	* This program is free software; you can redistribute it and/or
	16	* modify it under the terms of the GNU General Public License as
	17	* published by the Free Software Foundation, version 2 of the
	18	* License.
	19	*
	20	* Note, the TPM chip is not interrupt driven (only polling)
	21	* and can have very long timeouts (minutes!). Hence the unusual
700d8bdc	22	* calls to msleep.
1da177e4 LT	23	*
	24	*/
	25
	26	#include <linux/sched.h>
	27	#include <linux/poll.h>
	28	#include <linux/spinlock.h>
	29	#include "tpm.h"
	30
3122a88a KH	31	enum tpm_const {
	32	TPM_MINOR = 224, /* officially assigned */
	33	TPM_BUFSIZE = 2048,
	34	TPM_NUM_DEVICES = 256,
	35	TPM_NUM_MASK_ENTRIES = TPM_NUM_DEVICES / (8 * sizeof(int))
	36	};
1da177e4	37
3122a88a KH	38	/* PCI configuration addresses */
	39	enum tpm_pci_config_addr {
	40	PCI_GEN_PMCON_1 = 0xA0,
	41	PCI_GEN1_DEC = 0xE4,
	42	PCI_LPC_EN = 0xE6,
	43	PCI_GEN2_DEC = 0xEC
	44	};
	45
	46	enum tpm_config {
	47	TPM_LOCK_REG = 0x0D,
	48	TPM_INTERUPT_REG = 0x0A,
	49	TPM_BASE_ADDR_LO = 0x08,
	50	TPM_BASE_ADDR_HI = 0x09,
	51	TPM_UNLOCK_VALUE = 0x55,
	52	TPM_LOCK_VALUE = 0xAA,
	53	TPM_DISABLE_INTERUPT_VALUE = 0x00
	54	};
1da177e4	55
1da177e4 LT	56
	57	static LIST_HEAD(tpm_chip_list);
	58	static DEFINE_SPINLOCK(driver_lock);
3122a88a	59	static int dev_mask[TPM_NUM_MASK_ENTRIES];
1da177e4 LT	60
	61	static void user_reader_timeout(unsigned long ptr)
	62	{
	63	struct tpm_chip chip = (struct tpm_chip ) ptr;
	64
	65	down(&chip->buffer_mutex);
	66	atomic_set(&chip->data_pending, 0);
	67	memset(chip->data_buffer, 0, TPM_BUFSIZE);
	68	up(&chip->buffer_mutex);
	69	}
	70
1da177e4 LT	71	/*
	72	* Initialize the LPC bus and enable the TPM ports
	73	*/
	74	int tpm_lpc_bus_init(struct pci_dev *pci_dev, u16 base)
	75	{
	76	u32 lpcenable, tmp;
	77	int is_lpcm = 0;
	78
	79	switch (pci_dev->vendor) {
	80	case PCI_VENDOR_ID_INTEL:
	81	switch (pci_dev->device) {
	82	case PCI_DEVICE_ID_INTEL_82801CA_12:
	83	case PCI_DEVICE_ID_INTEL_82801DB_12:
	84	is_lpcm = 1;
	85	break;
	86	}
	87	/* init ICH (enable LPC) */
	88	pci_read_config_dword(pci_dev, PCI_GEN1_DEC, &lpcenable);
	89	lpcenable \|= 0x20000000;
	90	pci_write_config_dword(pci_dev, PCI_GEN1_DEC, lpcenable);
	91
	92	if (is_lpcm) {
	93	pci_read_config_dword(pci_dev, PCI_GEN1_DEC,
	94	&lpcenable);
	95	if ((lpcenable & 0x20000000) == 0) {
	96	dev_err(&pci_dev->dev,
	97	"cannot enable LPC\n");
	98	return -ENODEV;
	99	}
	100	}
	101
	102	/* initialize TPM registers */
	103	pci_read_config_dword(pci_dev, PCI_GEN2_DEC, &tmp);
	104
	105	if (!is_lpcm)
	106	tmp = (tmp & 0xFFFF0000) \| (base & 0xFFF0);
	107	else
	108	tmp =
	109	(tmp & 0xFFFF0000) \| (base & 0xFFF0) \|
	110	0x00000001;
	111
	112	pci_write_config_dword(pci_dev, PCI_GEN2_DEC, tmp);
	113
	114	if (is_lpcm) {
	115	pci_read_config_dword(pci_dev, PCI_GEN_PMCON_1,
	116	&tmp);
	117	tmp \|= 0x00000004; /* enable CLKRUN */
	118	pci_write_config_dword(pci_dev, PCI_GEN_PMCON_1,
	119	tmp);
	120	}
1da177e4 LT	121	break;
	122	case PCI_VENDOR_ID_AMD:
	123	/* nothing yet */
	124	break;
	125	}
	126
3122a88a KH	127	tpm_write_index(TPM_LOCK_REG, TPM_UNLOCK_VALUE);
	128	tpm_write_index(TPM_INTERUPT_REG, TPM_DISABLE_INTERUPT_VALUE);
	129	tpm_write_index(TPM_BASE_ADDR_LO, base);
	130	tpm_write_index(TPM_BASE_ADDR_HI, (base & 0xFF00) >> 8);
	131	tpm_write_index(TPM_LOCK_REG, TPM_LOCK_VALUE);
	132
1da177e4 LT	133	return 0;
	134	}
	135
	136	EXPORT_SYMBOL_GPL(tpm_lpc_bus_init);
	137
	138	/*
	139	* Internal kernel interface to transmit TPM commands
	140	*/
	141	static ssize_t tpm_transmit(struct tpm_chip chip, const char buf,
	142	size_t bufsiz)
	143	{
	144	ssize_t len;
	145	u32 count;
700d8bdc	146	unsigned long stop;
1da177e4	147
81179bb6	148	count = be32_to_cpu(((__be32 ) (buf + 2)));
1da177e4 LT	149
	150	if (count == 0)
	151	return -ENODATA;
	152	if (count > bufsiz) {
	153	dev_err(&chip->pci_dev->dev,
b76be681	154	"invalid count value %x %zx \n", count, bufsiz);
1da177e4 LT	155	return -E2BIG;
	156	}
	157
	158	down(&chip->tpm_mutex);
	159
	160	if ((len = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
	161	dev_err(&chip->pci_dev->dev,
b76be681	162	"tpm_transmit: tpm_send: error %zd\n", len);
1da177e4 LT	163	return len;
	164	}
	165
700d8bdc	166	stop = jiffies + 2 * 60 * HZ;
1da177e4 LT	167	do {
	168	u8 status = inb(chip->vendor->base + 1);
	169	if ((status & chip->vendor->req_complete_mask) ==
	170	chip->vendor->req_complete_val) {
1da177e4 LT	171	goto out_recv;
1da177e4 LT	172	}
700d8bdc	173	msleep(TPM_TIMEOUT); /* CHECK */
1da177e4	174	rmb();
700d8bdc	175	} while (time_before(jiffies, stop));
1da177e4 LT	176
	177
	178	chip->vendor->cancel(chip);
	179	dev_err(&chip->pci_dev->dev, "Time expired\n");
	180	up(&chip->tpm_mutex);
	181	return -EIO;
	182
	183	out_recv:
	184	len = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
	185	if (len < 0)
	186	dev_err(&chip->pci_dev->dev,
b76be681	187	"tpm_transmit: tpm_recv: error %zd\n", len);
1da177e4 LT	188	up(&chip->tpm_mutex);
	189	return len;
	190	}
	191
	192	#define TPM_DIGEST_SIZE 20
	193	#define CAP_PCR_RESULT_SIZE 18
dff37e4b	194	static const u8 cap_pcr[] = {
1da177e4 LT	195	0, 193, /* TPM_TAG_RQU_COMMAND */
	196	0, 0, 0, 22, /* length */
	197	0, 0, 0, 101, /* TPM_ORD_GetCapability */
	198	0, 0, 0, 5,
	199	0, 0, 0, 4,
	200	0, 0, 1, 1
	201	};
	202
	203	#define READ_PCR_RESULT_SIZE 30
dff37e4b	204	static const u8 pcrread[] = {
1da177e4 LT	205	0, 193, /* TPM_TAG_RQU_COMMAND */
	206	0, 0, 0, 14, /* length */
	207	0, 0, 0, 21, /* TPM_ORD_PcrRead */
	208	0, 0, 0, 0 /* PCR index */
	209	};
	210
74880c06	211	static ssize_t show_pcrs(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	212	{
	213	u8 data[READ_PCR_RESULT_SIZE];
	214	ssize_t len;
81179bb6 KH	215	int i, j, num_pcrs;
81179bb6 KH	216	__be32 index;
1da177e4 LT	217	char *str = buf;
	218
	219	struct tpm_chip *chip =
e2fe9066	220	pci_get_drvdata(to_pci_dev(dev));
1da177e4 LT	221	if (chip == NULL)
	222	return -ENODEV;
	223
	224	memcpy(data, cap_pcr, sizeof(cap_pcr));
	225	if ((len = tpm_transmit(chip, data, sizeof(data)))
	226	< CAP_PCR_RESULT_SIZE)
	227	return len;
	228
81179bb6	229	num_pcrs = be32_to_cpu(((__be32 ) (data + 14)));
1da177e4 LT	230
	231	for (i = 0; i < num_pcrs; i++) {
	232	memcpy(data, pcrread, sizeof(pcrread));
	233	index = cpu_to_be32(i);
	234	memcpy(data + 10, &index, 4);
	235	if ((len = tpm_transmit(chip, data, sizeof(data)))
	236	< READ_PCR_RESULT_SIZE)
	237	return len;
	238	str += sprintf(str, "PCR-%02d: ", i);
	239	for (j = 0; j < TPM_DIGEST_SIZE; j++)
	240	str += sprintf(str, "%02X ", *(data + 10 + j));
	241	str += sprintf(str, "\n");
	242	}
	243	return str - buf;
	244	}
	245
	246	static DEVICE_ATTR(pcrs, S_IRUGO, show_pcrs, NULL);
	247
	248	#define READ_PUBEK_RESULT_SIZE 314
dff37e4b	249	static const u8 readpubek[] = {
1da177e4 LT	250	0, 193, /* TPM_TAG_RQU_COMMAND */
	251	0, 0, 0, 30, /* length */
	252	0, 0, 0, 124, /* TPM_ORD_ReadPubek */
	253	};
	254
74880c06	255	static ssize_t show_pubek(struct device dev, struct device_attribute attr, char *buf)
1da177e4	256	{
2df7111f	257	u8 *data;
1da177e4	258	ssize_t len;
81179bb6	259	int i, rc;
1da177e4 LT	260	char *str = buf;
	261
	262	struct tpm_chip *chip =
e2fe9066	263	pci_get_drvdata(to_pci_dev(dev));
1da177e4 LT	264	if (chip == NULL)
	265	return -ENODEV;
	266
2df7111f KH	267	data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
	268	if (!data)
	269	return -ENOMEM;
	270
1da177e4 LT	271	memcpy(data, readpubek, sizeof(readpubek));
	272	memset(data + sizeof(readpubek), 0, 20); /* zero nonce */
	273
2df7111f KH	274	if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
	275	READ_PUBEK_RESULT_SIZE) {
	276	rc = len;
	277	goto out;
	278	}
1da177e4 LT	279
	280	/*
	281	ignore header 10 bytes
	282	algorithm 32 bits (1 == RSA )
	283	encscheme 16 bits
	284	sigscheme 16 bits
	285	parameters (RSA 12->bytes: keybit, #primes, expbit)
	286	keylenbytes 32 bits
	287	256 byte modulus
	288	ignore checksum 20 bytes
	289	*/
	290
1da177e4 LT	291	str +=
	292	sprintf(str,
	293	"Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
	294	"Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
	295	" %02X %02X %02X %02X %02X %02X %02X %02X\n"
	296	"Modulus length: %d\nModulus: \n",
	297	data[10], data[11], data[12], data[13], data[14],
	298	data[15], data[16], data[17], data[22], data[23],
	299	data[24], data[25], data[26], data[27], data[28],
	300	data[29], data[30], data[31], data[32], data[33],
81179bb6	301	be32_to_cpu(((__be32 ) (data + 32))));
1da177e4 LT	302
	303	for (i = 0; i < 256; i++) {
	304	str += sprintf(str, "%02X ", data[i + 39]);
	305	if ((i + 1) % 16 == 0)
	306	str += sprintf(str, "\n");
	307	}
2df7111f KH	308	rc = str - buf;
	309	out:
	310	kfree(data);
	311	return rc;
1da177e4 LT	312	}
	313
	314	static DEVICE_ATTR(pubek, S_IRUGO, show_pubek, NULL);
	315
	316	#define CAP_VER_RESULT_SIZE 18
dff37e4b	317	static const u8 cap_version[] = {
1da177e4 LT	318	0, 193, /* TPM_TAG_RQU_COMMAND */
	319	0, 0, 0, 18, /* length */
	320	0, 0, 0, 101, /* TPM_ORD_GetCapability */
	321	0, 0, 0, 6,
	322	0, 0, 0, 0
	323	};
	324
	325	#define CAP_MANUFACTURER_RESULT_SIZE 18
dff37e4b	326	static const u8 cap_manufacturer[] = {
1da177e4 LT	327	0, 193, /* TPM_TAG_RQU_COMMAND */
	328	0, 0, 0, 22, /* length */
	329	0, 0, 0, 101, /* TPM_ORD_GetCapability */
	330	0, 0, 0, 5,
	331	0, 0, 0, 4,
	332	0, 0, 1, 3
	333	};
	334
74880c06	335	static ssize_t show_caps(struct device dev, struct device_attribute attr, char *buf)
1da177e4	336	{
2df7111f	337	u8 data[sizeof(cap_manufacturer)];
1da177e4 LT	338	ssize_t len;
	339	char *str = buf;
	340
	341	struct tpm_chip *chip =
e2fe9066	342	pci_get_drvdata(to_pci_dev(dev));
1da177e4 LT	343	if (chip == NULL)
	344	return -ENODEV;
	345
	346	memcpy(data, cap_manufacturer, sizeof(cap_manufacturer));
	347
	348	if ((len = tpm_transmit(chip, data, sizeof(data))) <
	349	CAP_MANUFACTURER_RESULT_SIZE)
	350	return len;
	351
	352	str += sprintf(str, "Manufacturer: 0x%x\n",
81179bb6	353	be32_to_cpu(((__be32 ) (data + 14))));
1da177e4 LT	354
	355	memcpy(data, cap_version, sizeof(cap_version));
	356
	357	if ((len = tpm_transmit(chip, data, sizeof(data))) <
	358	CAP_VER_RESULT_SIZE)
	359	return len;
	360
	361	str +=
	362	sprintf(str, "TCG version: %d.%d\nFirmware version: %d.%d\n",
	363	(int) data[14], (int) data[15], (int) data[16],
	364	(int) data[17]);
	365
	366	return str - buf;
	367	}
	368
	369	static DEVICE_ATTR(caps, S_IRUGO, show_caps, NULL);
	370
	371	/*
	372	* Device file system interface to the TPM
	373	*/
	374	int tpm_open(struct inode inode, struct file file)
	375	{
	376	int rc = 0, minor = iminor(inode);
	377	struct tpm_chip chip = NULL, pos;
	378
	379	spin_lock(&driver_lock);
	380
	381	list_for_each_entry(pos, &tpm_chip_list, list) {
	382	if (pos->vendor->miscdev.minor == minor) {
	383	chip = pos;
	384	break;
	385	}
	386	}
	387
	388	if (chip == NULL) {
	389	rc = -ENODEV;
	390	goto err_out;
	391	}
	392
	393	if (chip->num_opens) {
	394	dev_dbg(&chip->pci_dev->dev,
	395	"Another process owns this TPM\n");
	396	rc = -EBUSY;
	397	goto err_out;
	398	}
	399
	400	chip->num_opens++;
	401	pci_dev_get(chip->pci_dev);
	402
	403	spin_unlock(&driver_lock);
	404
	405	chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
	406	if (chip->data_buffer == NULL) {
	407	chip->num_opens--;
	408	pci_dev_put(chip->pci_dev);
	409	return -ENOMEM;
	410	}
	411
	412	atomic_set(&chip->data_pending, 0);
	413
	414	file->private_data = chip;
	415	return 0;
	416
	417	err_out:
418	spin_unlock(&driver_lock);
419	return rc;
420	}
421
422	EXPORT_SYMBOL_GPL(tpm_open);
423
424	int tpm_release(struct inode inode, struct file file)
425	{
426	struct tpm_chip *chip = file->private_data;
427
428	file->private_data = NULL;
429
430	spin_lock(&driver_lock);
431	chip->num_opens--;
fe3fd483	432	del_singleshot_timer_sync(&chip->user_read_timer);
1da177e4 LT	433	atomic_set(&chip->data_pending, 0);
	434
	435	pci_dev_put(chip->pci_dev);
	436	return 0;
	437	}
	438
	439	EXPORT_SYMBOL_GPL(tpm_release);
	440
	441	ssize_t tpm_write(struct file * file, const char __user * buf,
	442	size_t size, loff_t * off)
	443	{
	444	struct tpm_chip *chip = file->private_data;
	445	int in_size = size, out_size;
	446
	447	/* cannot perform a write until the read has cleared
	448	either via tpm_read or a user_read_timer timeout */
700d8bdc NA	449	while (atomic_read(&chip->data_pending) != 0)
700d8bdc NA	450	msleep(TPM_TIMEOUT);
1da177e4 LT	451
	452	down(&chip->buffer_mutex);
	453
	454	if (in_size > TPM_BUFSIZE)
	455	in_size = TPM_BUFSIZE;
	456
	457	if (copy_from_user
	458	(chip->data_buffer, (void __user *) buf, in_size)) {
	459	up(&chip->buffer_mutex);
	460	return -EFAULT;
	461	}
	462
	463	/* atomic tpm command send and result receive */
	464	out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);
	465
	466	atomic_set(&chip->data_pending, out_size);
	467	up(&chip->buffer_mutex);
	468
	469	/* Set a timeout by which the reader must come claim the result */
fe3fd483	470	mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));
1da177e4 LT	471
	472	return in_size;
	473	}
	474
	475	EXPORT_SYMBOL_GPL(tpm_write);
	476
	477	ssize_t tpm_read(struct file * file, char __user * buf,
	478	size_t size, loff_t * off)
	479	{
	480	struct tpm_chip *chip = file->private_data;
5b44bd58	481	int ret_size;
1da177e4	482
5b44bd58 KH	483	del_singleshot_timer_sync(&chip->user_read_timer);
	484	ret_size = atomic_read(&chip->data_pending);
	485	atomic_set(&chip->data_pending, 0);
	486	if (ret_size > 0) { /* relay data */
	487	if (size < ret_size)
	488	ret_size = size;
1da177e4 LT	489
1da177e4 LT	490	down(&chip->buffer_mutex);
5b44bd58 KH	491	if (copy_to_user
	492	((void __user *) buf, chip->data_buffer, ret_size))
	493	ret_size = -EFAULT;
1da177e4 LT	494	up(&chip->buffer_mutex);
	495	}
	496
	497	return ret_size;
	498	}
	499
	500	EXPORT_SYMBOL_GPL(tpm_read);
	501
	502	void __devexit tpm_remove(struct pci_dev *pci_dev)
	503	{
	504	struct tpm_chip *chip = pci_get_drvdata(pci_dev);
	505
	506	if (chip == NULL) {
	507	dev_err(&pci_dev->dev, "No device data found\n");
	508	return;
	509	}
	510
	511	spin_lock(&driver_lock);
	512
	513	list_del(&chip->list);
	514
	515	spin_unlock(&driver_lock);
	516
	517	pci_set_drvdata(pci_dev, NULL);
	518	misc_deregister(&chip->vendor->miscdev);
	519
	520	device_remove_file(&pci_dev->dev, &dev_attr_pubek);
	521	device_remove_file(&pci_dev->dev, &dev_attr_pcrs);
	522	device_remove_file(&pci_dev->dev, &dev_attr_caps);
	523
	524	pci_disable_device(pci_dev);
	525
3122a88a	526	dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
1da177e4 LT	527
	528	kfree(chip);
	529
	530	pci_dev_put(pci_dev);
	531	}
	532
	533	EXPORT_SYMBOL_GPL(tpm_remove);
	534
	535	static u8 savestate[] = {
	536	0, 193, /* TPM_TAG_RQU_COMMAND */
	537	0, 0, 0, 10, /* blob length (in bytes) */
	538	0, 0, 0, 152 /* TPM_ORD_SaveState */
	539	};
	540
	541	/*
	542	* We are about to suspend. Save the TPM state
	543	* so that it can be restored.
	544	*/
4fd416c1	545	int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
1da177e4 LT	546	{
	547	struct tpm_chip *chip = pci_get_drvdata(pci_dev);
	548	if (chip == NULL)
	549	return -ENODEV;
	550
	551	tpm_transmit(chip, savestate, sizeof(savestate));
	552	return 0;
	553	}
	554
	555	EXPORT_SYMBOL_GPL(tpm_pm_suspend);
	556
	557	/*
	558	* Resume from a power safe. The BIOS already restored
	559	* the TPM state.
	560	*/
	561	int tpm_pm_resume(struct pci_dev *pci_dev)
	562	{
	563	struct tpm_chip *chip = pci_get_drvdata(pci_dev);
	564
	565	if (chip == NULL)
	566	return -ENODEV;
	567
	568	spin_lock(&driver_lock);
	569	tpm_lpc_bus_init(pci_dev, chip->vendor->base);
	570	spin_unlock(&driver_lock);
	571
	572	return 0;
	573	}
	574
	575	EXPORT_SYMBOL_GPL(tpm_pm_resume);
	576
	577	/*
	578	* Called from tpm_<specific>.c probe function only for devices
	579	* the driver has determined it should claim. Prior to calling
	580	* this function the specific probe function has called pci_enable_device
	581	* upon errant exit from this function specific probe function should call
	582	* pci_disable_device
	583	*/
	584	int tpm_register_hardware(struct pci_dev *pci_dev,
	585	struct tpm_vendor_specific *entry)
	586	{
	587	char devname[7];
	588	struct tpm_chip *chip;
	589	int i, j;
	590
	591	/* Driver specific per-device data */
	592	chip = kmalloc(sizeof(*chip), GFP_KERNEL);
	593	if (chip == NULL)
	594	return -ENOMEM;
	595
	596	memset(chip, 0, sizeof(struct tpm_chip));
	597
	598	init_MUTEX(&chip->buffer_mutex);
	599	init_MUTEX(&chip->tpm_mutex);
1da177e4 LT	600	INIT_LIST_HEAD(&chip->list);
1da177e4 LT	601
fe3fd483 KH	602	init_timer(&chip->user_read_timer);
	603	chip->user_read_timer.function = user_reader_timeout;
	604	chip->user_read_timer.data = (unsigned long) chip;
	605
1da177e4 LT	606	chip->vendor = entry;
	607
	608	chip->dev_num = -1;
	609
3122a88a KH	610	for (i = 0; i < TPM_NUM_MASK_ENTRIES; i++)
3122a88a KH	611	for (j = 0; j < 8 * sizeof(int); j++)
1da177e4	612	if ((dev_mask[i] & (1 << j)) == 0) {
3122a88a KH	613	chip->dev_num =
3122a88a KH	614	i * TPM_NUM_MASK_ENTRIES + j;
1da177e4 LT	615	dev_mask[i] \|= 1 << j;
	616	goto dev_num_search_complete;
	617	}
	618
	619	dev_num_search_complete:
	620	if (chip->dev_num < 0) {
	621	dev_err(&pci_dev->dev,
	622	"No available tpm device numbers\n");
	623	kfree(chip);
	624	return -ENODEV;
	625	} else if (chip->dev_num == 0)
	626	chip->vendor->miscdev.minor = TPM_MINOR;
	627	else
	628	chip->vendor->miscdev.minor = MISC_DYNAMIC_MINOR;
	629
	630	snprintf(devname, sizeof(devname), "%s%d", "tpm", chip->dev_num);
	631	chip->vendor->miscdev.name = devname;
	632
	633	chip->vendor->miscdev.dev = &(pci_dev->dev);
	634	chip->pci_dev = pci_dev_get(pci_dev);
	635
	636	if (misc_register(&chip->vendor->miscdev)) {
	637	dev_err(&chip->pci_dev->dev,
	638	"unable to misc_register %s, minor %d\n",
	639	chip->vendor->miscdev.name,
	640	chip->vendor->miscdev.minor);
	641	pci_dev_put(pci_dev);
	642	kfree(chip);
	643	dev_mask[i] &= !(1 << j);
	644	return -ENODEV;
	645	}
	646
	647	pci_set_drvdata(pci_dev, chip);
	648
	649	list_add(&chip->list, &tpm_chip_list);
	650
	651	device_create_file(&pci_dev->dev, &dev_attr_pubek);
	652	device_create_file(&pci_dev->dev, &dev_attr_pcrs);
	653	device_create_file(&pci_dev->dev, &dev_attr_caps);
	654
	655	return 0;
	656	}
	657
	658	EXPORT_SYMBOL_GPL(tpm_register_hardware);
	659
1da177e4 LT	660	MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
	661	MODULE_DESCRIPTION("TPM Driver");
	662	MODULE_VERSION("2.0");
	663	MODULE_LICENSE("GPL");