/* 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");