drivers/char/tpm/tpm_st_i2c.c - kernel/msm - Gitiles

 /* Copyright (c) 2010, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/slab.h>
 #include <linux/i2c.h>
 #include <linux/irq.h>
 #include <mach/gpio.h>
 #include <mach/tpm_st_i2c.h>
 #include <mach/msm_iomap.h>
 #include "tpm.h"

 #define DEVICE_NAME "tpm_st_i2c"

 #define TPM_HEADER_LEN sizeof(struct tpm_input_header)
 #define TPM_ST_I2C_BLOCK_MAX 40

 struct tpm_st_i2c_dev {
 	struct i2c_client *client;
 	struct tpm_st_i2c_platform_data *pd;
 	struct completion com[2];
 };

 /* for completion array */
 #define ACCEPT_CMD_INDEX 0
 #define DATA_AVAIL_INDEX 1

 static struct tpm_st_i2c_dev *tpm_st_i2c_dev;

 #define TPM_ST_I2C_REQ_COMPLETE_MASK 1

 static u8 tpm_st_i2c_status(struct tpm_chip *chip)
 {
 	int gpio = tpm_st_i2c_dev->pd->data_avail_gpio;
 	return gpio_get_value(gpio);
 }

 static void tpm_st_i2c_cancel(struct tpm_chip *chip)
 {
 	/* not supported */
 	return;
 }

 static int tpm_st_i2c_transfer_buf(struct tpm_chip *chip, u8 *buf, size_t count,
 				   int recv)
 {
 	struct i2c_msg msg = {
 		.addr = tpm_st_i2c_dev->client->addr,
 		.flags = 0,
 		.buf = buf,
 		.len = TPM_HEADER_LEN, /* must read/write header first */
 	};
 	int gpio;
 	int irq;
 	struct completion *com;
 	__be32 *native_size;
 	int read_header = 0;
 	int rc = 0;
 	int len = count;
 	uint32_t size = count;
 	int tmp;

 	if (recv) {
 		msg.flags |= I2C_M_RD;
 		read_header = 1;
 		gpio = tpm_st_i2c_dev->pd->data_avail_gpio;
 		irq = tpm_st_i2c_dev->pd->data_avail_irq;
 		com = &tpm_st_i2c_dev->com[DATA_AVAIL_INDEX];
 	} else {
 		gpio = tpm_st_i2c_dev->pd->accept_cmd_gpio;
 		irq = tpm_st_i2c_dev->pd->accept_cmd_irq;
 		com = &tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX];
 	}

 	if (len < TPM_HEADER_LEN) {
 		dev_dbg(chip->dev, "%s: invalid len\n", __func__);
 		return -EINVAL;
 	}

 	do {
 		if (!gpio_get_value(gpio)) {
 			/* reset the completion in case the irq fired
 			 * during the probe
 			 */
 			init_completion(com);
 			enable_irq(irq);
 			tmp = wait_for_completion_interruptible_timeout(
 				com, HZ/2);
 			if (!tmp) {
 				dev_dbg(chip->dev, "%s timeout\n",
 					__func__);
 				return -EBUSY;
 			}
 		}
 		rc = i2c_transfer(tpm_st_i2c_dev->client->adapter,
 				  &msg, 1);
 		if (rc < 0) {
 			dev_dbg(chip->dev, "Error in I2C transfer\n");
 			return rc;
 		}
 		if (read_header) {
 			read_header = 0;
 			native_size = (__force __be32 *) (buf + 2);
 			size = be32_to_cpu(*native_size);
 			if (count < size) {
 				dev_dbg(chip->dev,
 					"%s: invalid count\n",
 					__func__);
 				rc = -EIO;
 			}
 			len = size;
 		}
 		len -= msg.len;
 		if (len) {
 			buf += msg.len;
 			msg.buf = buf;
 			if (len > TPM_ST_I2C_BLOCK_MAX)
 				msg.len = TPM_ST_I2C_BLOCK_MAX;
 			else
 				msg.len = len;
 		}
 	} while (len > 0);

 	if (rc >= 0)
 		return size;
 	else
 		return rc;
 }

 static int tpm_st_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 {
 	return tpm_st_i2c_transfer_buf(chip, buf, count, 1);
 }

 static int tpm_st_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
 {
 	return tpm_st_i2c_transfer_buf(chip, buf, len, 0);
 }

 #ifdef CONFIG_PM
 static int tpm_st_i2c_suspend(struct i2c_client *client, pm_message_t msg)
 {
 	return tpm_pm_suspend(&client->dev, msg);
 }

 static int tpm_st_i2c_resume(struct i2c_client *client)
 {
 	return tpm_pm_resume(&client->dev);
 }
 #endif

 static const struct file_operations tpm_st_i2c_fs_ops = {
 	.owner = THIS_MODULE,
 	.llseek = no_llseek,
 	.open = tpm_open,
 	.read = tpm_read,
 	.write = tpm_write,
 	.release = tpm_release,
 };

 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
 static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
 static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
 static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated,
 		   NULL);
 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);

 static struct attribute *tpm_st_i2c_attrs[] = {
 	&dev_attr_pubek.attr,
 	&dev_attr_pcrs.attr,
 	&dev_attr_enabled.attr,
 	&dev_attr_active.attr,
 	&dev_attr_owned.attr,
 	&dev_attr_temp_deactivated.attr,
 	&dev_attr_caps.attr,
 	NULL,
 };

 static struct attribute_group tpm_st_i2c_attr_grp = {
 	.attrs = tpm_st_i2c_attrs
 };

 static struct tpm_vendor_specific tpm_st_i2c_vendor = {
 	.status = tpm_st_i2c_status,
 	.recv = tpm_st_i2c_recv,
 	.send = tpm_st_i2c_send,
 	.cancel = tpm_st_i2c_cancel,
 	.req_complete_mask = TPM_ST_I2C_REQ_COMPLETE_MASK,
 	.req_complete_val = TPM_ST_I2C_REQ_COMPLETE_MASK,
 	.req_canceled = 0xff,  /* not supported */
 	.attr_group = &tpm_st_i2c_attr_grp,
 	.miscdev = {
 		    .fops = &tpm_st_i2c_fs_ops,},
 };

 static irqreturn_t tpm_st_i2c_isr(int irq, void *dev_id)
 {
 	disable_irq_nosync(irq);
 	if (irq == tpm_st_i2c_dev->pd->accept_cmd_irq)
 		complete(&tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX]);
 	else
 		complete(&tpm_st_i2c_dev->com[DATA_AVAIL_INDEX]);
 	return IRQ_HANDLED;
 }

 static int tpm_st_i2c_probe(struct i2c_client *client,
 			    const struct i2c_device_id *id)
 {
 	int rc = 0;
 	struct tpm_st_i2c_platform_data *pd;
 	struct  tpm_chip *chip;
 	int high;

 	dev_dbg(&client->dev, "%s()\n", __func__);

 	if (!i2c_check_functionality(client->adapter,
 				     I2C_FUNC_SMBUS_BYTE |
 				     I2C_FUNC_SMBUS_I2C_BLOCK |
 				     I2C_FUNC_I2C)) {
 		dev_err(&client->dev, "incompatible adapter\n");
 		return -ENODEV;
 	}

 	pd = client->dev.platform_data;
 	if (!pd || !pd->gpio_setup || !pd->gpio_release) {
 		dev_err(&client->dev, "platform data not setup\n");
 		rc = -EFAULT;
 		goto no_platform_data;
 	}
 	rc = pd->gpio_setup();
 	if (rc) {
 		dev_err(&client->dev, "gpio_setup failed\n");
 		goto gpio_setup_fail;
 	}

 	gpio_direction_input(pd->accept_cmd_gpio);
 	gpio_direction_input(pd->data_avail_gpio);

 	tpm_st_i2c_dev = kzalloc(sizeof(struct tpm_st_i2c_dev), GFP_KERNEL);
 	if (!tpm_st_i2c_dev) {
 		printk(KERN_ERR "%s Unable to allocate memory for struct\n",
 		       __func__);
 		rc = -ENOMEM;
 		goto kzalloc_fail;
 	}

 	tpm_st_i2c_dev->client = client;
 	tpm_st_i2c_dev->pd = pd;

 	init_completion(&tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX]);
 	init_completion(&tpm_st_i2c_dev->com[DATA_AVAIL_INDEX]);
 	/* This logic allows us to setup irq but not have it enabled, in
 	 * case the lines are already active
 	 */
 	high = gpio_get_value(pd->data_avail_gpio);
 	rc = request_irq(pd->data_avail_irq, tpm_st_i2c_isr, IRQF_TRIGGER_HIGH,
 			 DEVICE_NAME "-data", NULL);
 	if (rc) {
 		dev_err(&client->dev, "request for data irq failed\n");
 		goto data_irq_fail;
 	}
 	if (!high)
 		disable_irq(pd->data_avail_irq);
 	high = gpio_get_value(pd->accept_cmd_gpio);
 	rc = request_irq(pd->accept_cmd_irq, tpm_st_i2c_isr, IRQF_TRIGGER_HIGH,
 			 DEVICE_NAME "-cmd", NULL);
 	if (rc) {
 		dev_err(&client->dev, "request for cmd irq failed\n");
 		goto cmd_irq_fail;
 	}
 	if (!high)
 		disable_irq(pd->accept_cmd_irq);

 	tpm_st_i2c_vendor.irq = pd->data_avail_irq;

 	chip = tpm_register_hardware(&client->dev, &tpm_st_i2c_vendor);
 	if (!chip) {
 		dev_err(&client->dev, "Could not register tpm hardware\n");
 		rc = -ENODEV;
 		goto tpm_reg_fail;
 	}

 	dev_info(&client->dev, "added\n");

 	return 0;

 tpm_reg_fail:
 	free_irq(pd->accept_cmd_irq, NULL);
 cmd_irq_fail:
 	free_irq(pd->data_avail_irq, NULL);
 data_irq_fail:
 kzalloc_fail:
 	pd->gpio_release();
 gpio_setup_fail:
 no_platform_data:

 	return rc;
 }

 static int __exit tpm_st_i2c_remove(struct i2c_client *client)
 {
 	free_irq(tpm_st_i2c_dev->pd->accept_cmd_irq, NULL);
 	free_irq(tpm_st_i2c_dev->pd->data_avail_irq, NULL);
 	tpm_remove_hardware(&client->dev);
 	tpm_st_i2c_dev->pd->gpio_release();
 	kfree(tpm_st_i2c_dev);

 	return 0;
 }

 static const struct i2c_device_id tpm_st_i2c_id[] = {
 	{ DEVICE_NAME, 0 },
 	{ }
 };

 static struct i2c_driver tpm_st_i2c_driver = {
 	.driver = {
 		.name = DEVICE_NAME,
 		.owner = THIS_MODULE,
 	},
 	.probe = tpm_st_i2c_probe,
 	.remove =  __exit_p(tpm_st_i2c_remove),
 #ifdef CONFIG_PM
 	.suspend = tpm_st_i2c_suspend,
 	.resume = tpm_st_i2c_resume,
 #endif
 	.id_table = tpm_st_i2c_id,
 };

 static int __init tpm_st_i2c_init(void)
 {
 	int ret;

 	ret = i2c_add_driver(&tpm_st_i2c_driver);
 	if (ret)
 		printk(KERN_ERR "%s: failed to add i2c driver\n", __func__);

 	return ret;
 }

 static void __exit tpm_st_i2c_exit(void)
 {
 	i2c_del_driver(&tpm_st_i2c_driver);
 }

 module_init(tpm_st_i2c_init);
 module_exit(tpm_st_i2c_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_VERSION("1.0");
 MODULE_AUTHOR("Qualcomm Innovation Center, Inc.");
 MODULE_DESCRIPTION("ST19NP18-TPM-I2C driver");
	/* Copyright (c) 2010, The Linux Foundation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/slab.h>
	#include <linux/i2c.h>
	#include <linux/irq.h>
	#include <mach/gpio.h>
	#include <mach/tpm_st_i2c.h>
	#include <mach/msm_iomap.h>
	#include "tpm.h"

	#define DEVICE_NAME "tpm_st_i2c"

	#define TPM_HEADER_LEN sizeof(struct tpm_input_header)
	#define TPM_ST_I2C_BLOCK_MAX 40

	struct tpm_st_i2c_dev {
	struct i2c_client *client;
	struct tpm_st_i2c_platform_data *pd;
	struct completion com[2];
	};

	/* for completion array */
	#define ACCEPT_CMD_INDEX 0
	#define DATA_AVAIL_INDEX 1

	static struct tpm_st_i2c_dev *tpm_st_i2c_dev;

	#define TPM_ST_I2C_REQ_COMPLETE_MASK 1

	static u8 tpm_st_i2c_status(struct tpm_chip *chip)
	{
	int gpio = tpm_st_i2c_dev->pd->data_avail_gpio;
	return gpio_get_value(gpio);
	}

	static void tpm_st_i2c_cancel(struct tpm_chip *chip)
	{
	/* not supported */
	return;
	}

	static int tpm_st_i2c_transfer_buf(struct tpm_chip chip, u8 buf, size_t count,
	int recv)
	{
	struct i2c_msg msg = {
	.addr = tpm_st_i2c_dev->client->addr,
	.flags = 0,
	.buf = buf,
	.len = TPM_HEADER_LEN, /* must read/write header first */
	};
	int gpio;
	int irq;
	struct completion *com;
	__be32 *native_size;
	int read_header = 0;
	int rc = 0;
	int len = count;
	uint32_t size = count;
	int tmp;

	if (recv) {
	msg.flags \|= I2C_M_RD;
	read_header = 1;
	gpio = tpm_st_i2c_dev->pd->data_avail_gpio;
	irq = tpm_st_i2c_dev->pd->data_avail_irq;
	com = &tpm_st_i2c_dev->com[DATA_AVAIL_INDEX];
	} else {
	gpio = tpm_st_i2c_dev->pd->accept_cmd_gpio;
	irq = tpm_st_i2c_dev->pd->accept_cmd_irq;
	com = &tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX];
	}

	if (len < TPM_HEADER_LEN) {
	dev_dbg(chip->dev, "%s: invalid len\n", __func__);
	return -EINVAL;
	}

	do {
	if (!gpio_get_value(gpio)) {
	/* reset the completion in case the irq fired
	* during the probe
	*/
	init_completion(com);
	enable_irq(irq);
	tmp = wait_for_completion_interruptible_timeout(
	com, HZ/2);
	if (!tmp) {
	dev_dbg(chip->dev, "%s timeout\n",
	__func__);
	return -EBUSY;
	}
	}
	rc = i2c_transfer(tpm_st_i2c_dev->client->adapter,
	&msg, 1);
	if (rc < 0) {
	dev_dbg(chip->dev, "Error in I2C transfer\n");
	return rc;
	}
	if (read_header) {
	read_header = 0;
	native_size = (__force __be32 *) (buf + 2);
	size = be32_to_cpu(*native_size);
	if (count < size) {
	dev_dbg(chip->dev,
	"%s: invalid count\n",
	__func__);
	rc = -EIO;
	}
	len = size;
	}
	len -= msg.len;
	if (len) {
	buf += msg.len;
	msg.buf = buf;
	if (len > TPM_ST_I2C_BLOCK_MAX)
	msg.len = TPM_ST_I2C_BLOCK_MAX;
	else
	msg.len = len;
	}
	} while (len > 0);

	if (rc >= 0)
	return size;
	else
	return rc;
	}

	static int tpm_st_i2c_recv(struct tpm_chip chip, u8 buf, size_t count)
	{
	return tpm_st_i2c_transfer_buf(chip, buf, count, 1);
	}

	static int tpm_st_i2c_send(struct tpm_chip chip, u8 buf, size_t len)
	{
	return tpm_st_i2c_transfer_buf(chip, buf, len, 0);
	}

	#ifdef CONFIG_PM
	static int tpm_st_i2c_suspend(struct i2c_client *client, pm_message_t msg)
	{
	return tpm_pm_suspend(&client->dev, msg);
	}

	static int tpm_st_i2c_resume(struct i2c_client *client)
	{
	return tpm_pm_resume(&client->dev);
	}
	#endif

	static const struct file_operations tpm_st_i2c_fs_ops = {
	.owner = THIS_MODULE,
	.llseek = no_llseek,
	.open = tpm_open,
	.read = tpm_read,
	.write = tpm_write,
	.release = tpm_release,
	};

	static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
	static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
	static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
	static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
	static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
	static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated,
	NULL);
	static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);

	static struct attribute *tpm_st_i2c_attrs[] = {
	&dev_attr_pubek.attr,
	&dev_attr_pcrs.attr,
	&dev_attr_enabled.attr,
	&dev_attr_active.attr,
	&dev_attr_owned.attr,
	&dev_attr_temp_deactivated.attr,
	&dev_attr_caps.attr,
	NULL,
	};

	static struct attribute_group tpm_st_i2c_attr_grp = {
	.attrs = tpm_st_i2c_attrs
	};

	static struct tpm_vendor_specific tpm_st_i2c_vendor = {
	.status = tpm_st_i2c_status,
	.recv = tpm_st_i2c_recv,
	.send = tpm_st_i2c_send,
	.cancel = tpm_st_i2c_cancel,
	.req_complete_mask = TPM_ST_I2C_REQ_COMPLETE_MASK,
	.req_complete_val = TPM_ST_I2C_REQ_COMPLETE_MASK,
	.req_canceled = 0xff, /* not supported */
	.attr_group = &tpm_st_i2c_attr_grp,
	.miscdev = {
	.fops = &tpm_st_i2c_fs_ops,},
	};

	static irqreturn_t tpm_st_i2c_isr(int irq, void *dev_id)
	{
	disable_irq_nosync(irq);
	if (irq == tpm_st_i2c_dev->pd->accept_cmd_irq)
	complete(&tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX]);
	else
	complete(&tpm_st_i2c_dev->com[DATA_AVAIL_INDEX]);
	return IRQ_HANDLED;
	}

	static int tpm_st_i2c_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	int rc = 0;
	struct tpm_st_i2c_platform_data *pd;
	struct tpm_chip *chip;
	int high;

	dev_dbg(&client->dev, "%s()\n", __func__);

	if (!i2c_check_functionality(client->adapter,
	I2C_FUNC_SMBUS_BYTE \|
	I2C_FUNC_SMBUS_I2C_BLOCK \|
	I2C_FUNC_I2C)) {
	dev_err(&client->dev, "incompatible adapter\n");
	return -ENODEV;
	}

	pd = client->dev.platform_data;
	if (!pd \|\| !pd->gpio_setup \|\| !pd->gpio_release) {
	dev_err(&client->dev, "platform data not setup\n");
	rc = -EFAULT;
	goto no_platform_data;
	}
	rc = pd->gpio_setup();
	if (rc) {
	dev_err(&client->dev, "gpio_setup failed\n");
	goto gpio_setup_fail;
	}

	gpio_direction_input(pd->accept_cmd_gpio);
	gpio_direction_input(pd->data_avail_gpio);

	tpm_st_i2c_dev = kzalloc(sizeof(struct tpm_st_i2c_dev), GFP_KERNEL);
	if (!tpm_st_i2c_dev) {
	printk(KERN_ERR "%s Unable to allocate memory for struct\n",
	__func__);
	rc = -ENOMEM;
	goto kzalloc_fail;
	}

	tpm_st_i2c_dev->client = client;
	tpm_st_i2c_dev->pd = pd;

	init_completion(&tpm_st_i2c_dev->com[ACCEPT_CMD_INDEX]);
	init_completion(&tpm_st_i2c_dev->com[DATA_AVAIL_INDEX]);
	/* This logic allows us to setup irq but not have it enabled, in
	* case the lines are already active
	*/
	high = gpio_get_value(pd->data_avail_gpio);
	rc = request_irq(pd->data_avail_irq, tpm_st_i2c_isr, IRQF_TRIGGER_HIGH,
	DEVICE_NAME "-data", NULL);
	if (rc) {
	dev_err(&client->dev, "request for data irq failed\n");
	goto data_irq_fail;
	}
	if (!high)
	disable_irq(pd->data_avail_irq);
	high = gpio_get_value(pd->accept_cmd_gpio);
	rc = request_irq(pd->accept_cmd_irq, tpm_st_i2c_isr, IRQF_TRIGGER_HIGH,
	DEVICE_NAME "-cmd", NULL);
	if (rc) {
	dev_err(&client->dev, "request for cmd irq failed\n");
	goto cmd_irq_fail;
	}
	if (!high)
	disable_irq(pd->accept_cmd_irq);

	tpm_st_i2c_vendor.irq = pd->data_avail_irq;

	chip = tpm_register_hardware(&client->dev, &tpm_st_i2c_vendor);
	if (!chip) {
	dev_err(&client->dev, "Could not register tpm hardware\n");
	rc = -ENODEV;
	goto tpm_reg_fail;
	}

	dev_info(&client->dev, "added\n");

	return 0;

	tpm_reg_fail:
	free_irq(pd->accept_cmd_irq, NULL);
	cmd_irq_fail:
	free_irq(pd->data_avail_irq, NULL);
	data_irq_fail:
	kzalloc_fail:
	pd->gpio_release();
	gpio_setup_fail:
	no_platform_data:

	return rc;
	}

	static int __exit tpm_st_i2c_remove(struct i2c_client *client)
	{
	free_irq(tpm_st_i2c_dev->pd->accept_cmd_irq, NULL);
	free_irq(tpm_st_i2c_dev->pd->data_avail_irq, NULL);
	tpm_remove_hardware(&client->dev);
	tpm_st_i2c_dev->pd->gpio_release();
	kfree(tpm_st_i2c_dev);

	return 0;
	}

	static const struct i2c_device_id tpm_st_i2c_id[] = {
	{ DEVICE_NAME, 0 },
	{ }
	};

	static struct i2c_driver tpm_st_i2c_driver = {
	.driver = {
	.name = DEVICE_NAME,
	.owner = THIS_MODULE,
	},
	.probe = tpm_st_i2c_probe,
	.remove = __exit_p(tpm_st_i2c_remove),
	#ifdef CONFIG_PM
	.suspend = tpm_st_i2c_suspend,
	.resume = tpm_st_i2c_resume,
	#endif
	.id_table = tpm_st_i2c_id,
	};

	static int __init tpm_st_i2c_init(void)
	{
	int ret;

	ret = i2c_add_driver(&tpm_st_i2c_driver);
	if (ret)
	printk(KERN_ERR "%s: failed to add i2c driver\n", __func__);

	return ret;
	}

	static void __exit tpm_st_i2c_exit(void)
	{
	i2c_del_driver(&tpm_st_i2c_driver);
	}

	module_init(tpm_st_i2c_init);
	module_exit(tpm_st_i2c_exit);
	MODULE_LICENSE("GPL v2");
	MODULE_VERSION("1.0");
	MODULE_AUTHOR("Qualcomm Innovation Center, Inc.");
	MODULE_DESCRIPTION("ST19NP18-TPM-I2C driver");