/*
 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/mutex.h>
#include <linux/time.h>

#include "nv-usb.h"

#ifdef DEBUG
#define INFO(stuff...)	pr_info("nv-usb: " stuff)
#else
#define INFO(stuff...)	do {} while (0)
#endif


#define NV_USB_BULK_VENDOR_ID 0x0955
#define NV_USB_BULK_PRODUCT_ID 0xffff

/* table of devices that work with this driver */
static const struct usb_device_id nv_usb_table[] = {
	{ USB_DEVICE(NV_USB_BULK_VENDOR_ID, NV_USB_BULK_PRODUCT_ID) },
	{}
};

MODULE_DEVICE_TABLE(usb, nv_usb_table);

/* Need to check if the below minor id is ok */
#define NV_USB_BULK_MINOR_BASE	192

static struct usb_driver nv_usb_driver;

static void nv_usb_delete(struct kref *kref)
{
	struct nv_usb *dev = to_nv_usb_dev(kref);

	usb_put_dev(dev->udev);
}

static int nv_usb_open(struct inode *inode, struct file *file)
{
	struct nv_usb *dev;
	struct usb_interface *interface;
	int subminor;

	subminor = iminor(inode);

	interface = usb_find_interface(&nv_usb_driver, subminor);
	if (interface == NULL) {
		INFO("%s(%d) failed to get interface\n", __func__, __LINE__);
		return -ENODEV;
	}

	dev = usb_get_intfdata(interface);
	if (dev == NULL) {
		INFO("%s(%d) failed to get interface\n", __func__, __LINE__);
		return -ENODEV;
	}

	kref_get(&dev->kref);

	mutex_lock(&dev->mutex);
	file->private_data = dev;
	mutex_unlock(&dev->mutex);

	return 0;
}

static int nv_usb_release(struct inode *inode, struct file *file)
{
	struct nv_usb *dev;

	dev = file->private_data;
	if (dev == NULL) {
		INFO("%s(%d) failed to get interface\n", __func__, __LINE__);
		return -ENODEV;
	}

	kref_put(&dev->kref, nv_usb_delete);
	return 0;
}

static int nv_usb_flush(struct file *file, fl_owner_t id)
{
	return 0;
}

static int nv_usb_transfer(struct bulk_data *data);

static ssize_t nv_usb_read(struct file *file, char *buffer, size_t count,
		loff_t *ppos)
{
	return 0;
}

unsigned long
nv_usb_calc_time(struct timeval g_sttime, struct timeval g_entime)
{

	unsigned int num_sec = g_entime.tv_sec - g_sttime.tv_sec;

	if (num_sec)
		return (g_entime.tv_usec +
			(1000000 - g_sttime.tv_usec) +
			((num_sec - 1) * 1000000));
	else
		return g_entime.tv_usec - g_sttime.tv_usec;

}

static void nv_usb_callback(struct urb *urb)
{
	struct completion *urb_done_ptr = urb->context;

	complete(urb_done_ptr);
}

static int nv_usb_transfer(struct bulk_data *data)
{
	struct nv_usb *dev = data->dev;
	struct nvusb_cb_wrap *bcb = NULL;
	struct nvusb_cs_wrap *bcs = NULL;
	struct urb *urb = NULL;
	unsigned int transfer_length = data->length;
	struct completion urb_done;
	int retval = 0;
	unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
	unsigned int cswlen = US_BULK_CS_WRAP_LEN;
	char *buf = NULL;
	struct timeval g_sttime, g_entime;
	unsigned long data_transfer_time = 0;

	init_completion(&urb_done);

	mutex_lock(&dev->mutex);

	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb) {
		INFO("%s(%d) failed to alloc urb\n", __func__, __LINE__);
		return -ENOMEM;
	}

	bcb = usb_alloc_coherent(dev->udev, cbwlen, GFP_KERNEL,
			&urb->transfer_dma);

	if (!bcb) {
		INFO("%s(%d) failed to alloc bcb\n", __func__, __LINE__);
		retval = -ENOMEM;
		goto out;
	}

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = cpu_to_le32(transfer_length);
	/*0 --> write 1 --> read*/
	bcb->Flags = data->data_direction ? 1 << 7 : 0;
	bcb->Tag = ++dev->tag;
	bcb->Length = data->sub_cmd_length;

	memset(bcb->CDB, 0, sizeof(bcb->CDB));
	memcpy(bcb->CDB, data->sub_cmd, bcb->Length);

	if (!dev->interface) {
		INFO("%s(%d) interface disconnected\n", __func__, __LINE__);
		usb_free_coherent(dev->udev, cbwlen, bcb, urb->transfer_dma);
		retval = -ENODEV;
		goto out;
	}

	INFO("cbwlen = %d\n", cbwlen);
	usb_fill_bulk_urb(urb, dev->udev,
		usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
		 bcb, cbwlen, nv_usb_callback, dev);

	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
	urb->context = &urb_done;
	retval = usb_submit_urb(urb, GFP_KERNEL);

	if (retval) {
		usb_free_coherent(dev->udev, cbwlen, bcb, urb->transfer_dma);
		INFO("%s(%d) urb submit failed\n", __func__, __LINE__);
		goto out;
	}

	wait_for_completion_interruptible_timeout(
		&urb_done, 20000);


	usb_free_coherent(dev->udev, cbwlen, bcb, urb->transfer_dma);
	INFO("%s(%d)\n", __func__, __LINE__);


	if (transfer_length) {
		INFO("%s(%d) Transfering Data = %d\n",
			__func__, __LINE__, transfer_length);
		buf = usb_alloc_coherent(dev->udev, transfer_length, GFP_KERNEL,
			&urb->transfer_dma);

		if (!buf) {
			INFO("%s(%d)failed to alloc buffer for data transfer\n",
			__func__, __LINE__);
			retval = -ENOMEM;
			goto out;
		}

		if (!data->data_direction) {
			memset(buf, data->write_char, transfer_length);
			usb_fill_bulk_urb(urb, dev->udev,
			usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
			buf, transfer_length, nv_usb_callback, dev);
		} else {
			memset(buf, 0, transfer_length);
			usb_fill_bulk_urb(urb, dev->udev,
			usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
			buf, transfer_length, nv_usb_callback, dev);
		}

		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
		urb->context = &urb_done;

		do_gettimeofday(&g_sttime);
		retval = usb_submit_urb(urb, GFP_KERNEL);
		if (retval) {
			usb_free_coherent(dev->udev, transfer_length, buf,
				urb->transfer_dma);
			INFO("%s(%d) urb submit failed\n", __func__, __LINE__);
			goto out;
		}

		wait_for_completion_interruptible_timeout(
			&urb_done, 20000);
		do_gettimeofday(&g_entime);
		if (data->data_direction)
			memcpy(data->buf, buf , transfer_length);

		usb_free_coherent(dev->udev,
			transfer_length, buf, urb->transfer_dma);
		data_transfer_time = nv_usb_calc_time(g_sttime, g_entime);
	}

	bcs = usb_alloc_coherent(dev->udev, cswlen, GFP_KERNEL,
		&urb->transfer_dma);
	if (!bcs) {
		INFO("%s(%d) failed to alloc bcs\n", __func__, __LINE__);
		retval = -ENOMEM;
		goto out;
	}
	memset(bcs, 0, cswlen);
	usb_fill_bulk_urb(urb, dev->udev,
		usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
		bcs, cswlen, nv_usb_callback, dev);

	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
	urb->context = &urb_done;
	retval = usb_submit_urb(urb, GFP_KERNEL);
	if (retval) {
		usb_free_coherent(dev->udev, cswlen, bcs, urb->transfer_dma);
		INFO("%s(%d) urb submit failed\n", __func__, __LINE__);
		goto out;
	}

	wait_for_completion_interruptible_timeout(
		&urb_done, 20000);

	INFO(
	"%s(%d) dCSWSignature = %x dCSWTag = %x Dataresidur = %d status = %d\n",
				__func__, __LINE__, bcs->Signature,
				bcs->Tag, bcs->Residue, bcs->Status);

	if (bcs->Status)
		data_transfer_time = 0;

	INFO("time taken is  %lu\n", data_transfer_time);

	data->data_transfer_time = data_transfer_time;
	data->g_data_transfer_time = bcs->Residue;

	usb_free_coherent(dev->udev, cswlen, bcs, urb->transfer_dma);
	usb_free_urb(urb);
	mutex_unlock(&dev->mutex);
	return 0;
out:
	usb_free_urb(urb);
	mutex_unlock(&dev->mutex);
	return retval;
}

static ssize_t nv_usb_write(struct file *file, const char *user_buffer,
		size_t count, loff_t *ppos)
{
	return count;
}

static long nv_usb_ioctl(struct file *file, unsigned int cmd_in,
		unsigned long arg, struct nv_usb *dev)
{
	void __user *p = (void __user *)arg;
	struct bulk_data *data = NULL;
	struct user_bulk_data *user_data = NULL;
	int ret = 0;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data) {
		INFO("%s(%d) No Memory\n", __func__, __LINE__);
		return -ENOMEM;
	}

	user_data = kzalloc(sizeof(*user_data), GFP_KERNEL);
	if (!user_data) {
		INFO("%s(%d) No Memory\n", __func__, __LINE__);
		kfree(data);
		return -ENOMEM;
	}

	if (__copy_from_user(user_data, p, sizeof(*user_data))) {
		INFO("%s(%d) copy from user failed\n", __func__, __LINE__);
		kfree(user_data);
		kfree(data);
		return -EFAULT;
	}

	data->dev = file->private_data;
	data->sub_cmd_length = user_data->sub_cmd_length;

	data->sub_cmd = kzalloc(data->sub_cmd_length, GFP_KERNEL);
	if (!data->sub_cmd) {
		INFO("%s(%d) No Memory\n", __func__, __LINE__);
		kfree(user_data);
		kfree(data);
		return -ENOMEM;
	}
	if (__copy_from_user(data->sub_cmd,
		user_data->sub_cmd, data->sub_cmd_length)) {
		INFO("%s(%d) copy from user failed\n", __func__, __LINE__);
		kfree(data->sub_cmd);
		kfree(user_data);
		kfree(data);
		return -EFAULT;
	}

	data->length = user_data->length;
	data->buf = kzalloc(data->length, GFP_KERNEL);
	if (!data->buf) {
		INFO("%s(%d) No Memory\n", __func__, __LINE__);
		kfree(data->sub_cmd);
		kfree(user_data);
		kfree(data);
		return -ENOMEM;
	}

	data->write_char = user_data->write_char;

	switch (cmd_in) {
	case NVUSB_BULK_WRITE:
		if (__copy_from_user(data->buf, user_data->buf, data->length)) {
			INFO("%s(%d) copy from user failed\n",
						__func__, __LINE__);
			ret = -EFAULT;
			goto error;
		}
		data->data_direction = 0;
		ret = nv_usb_transfer(data);
		if (ret) {
			INFO("%s(%d) nv_usb_transfer failed\n",
						__func__, __LINE__);
			goto error;
		}
		break;
	case NVUSB_BULK_READ:
		data->data_direction = 1;
		INFO("%s(%d)\n", __func__, __LINE__);
		ret = nv_usb_transfer(data);
		if (ret) {
			INFO("%s(%d) nv_usb_transfer failed\n",
						__func__, __LINE__);
			goto error;
		}

		if (__copy_to_user(user_data->buf, data->buf, data->length)) {
			INFO("%s(%d) copy to user failed\n",
						__func__, __LINE__);
			ret = -EFAULT;
			goto error;
		}
		break;
	default:
		INFO("%s(%d) Invalid ioctl command %x\n",
					__func__, __LINE__, cmd_in);
		ret = -EINVAL;
		goto error;
	}

	user_data->data_transfer_time = data->data_transfer_time;
	user_data->g_data_transfer_time = data->g_data_transfer_time;

	if (copy_to_user(p, user_data, sizeof(*user_data))) {
		INFO("%s(%d) copy to user failed\n", __func__, __LINE__);
		ret = -EFAULT;
	}

error:
	kfree(data->buf);
	kfree(data->sub_cmd);
	kfree(user_data);
	kfree(data);

	return ret;

}
static long nv_usb_unlocked_ioctl(struct file *file, unsigned int cmd_in,
		unsigned long arg)
{
	int ret;
	struct nv_usb *dev;

	dev = file->private_data;

	ret = nv_usb_ioctl(file, cmd_in, arg, dev);

	return ret;
}

static const struct file_operations nv_usb_fops = {
	.owner		= THIS_MODULE,
	.read		= nv_usb_read,
	.write		= nv_usb_write,
	.open		= nv_usb_open,
	.unlocked_ioctl = nv_usb_unlocked_ioctl,
	.release	= nv_usb_release,
	.flush		= nv_usb_flush,
	.llseek		= noop_llseek,
};

static struct usb_class_driver nv_usb_class = {
	.name		= "nvbulk%d",
	.fops		= &nv_usb_fops,
	.minor_base	= NV_USB_BULK_MINOR_BASE,
};

static int nv_usb_probe(struct usb_interface *interface,
		const struct usb_device_id *id)
{
	struct usb_host_interface *iface_desc;
	struct usb_endpoint_descriptor *endpoint;
	struct nv_usb *dev;
	struct usb_device *udev;
	int retval = 0;
	int i;

	udev = usb_get_dev(interface_to_usbdev(interface));
	/* allocate memory for our device state and initialize it */
	dev = devm_kzalloc(&udev->dev, sizeof(*dev), GFP_KERNEL);
	if (!dev) {
		INFO("%s(%d) Out of Memory\n", __func__, __LINE__);
		return -ENOMEM;
	}

	kref_init(&dev->kref);
	init_usb_anchor(&dev->submitted);
	mutex_init(&dev->mutex);

	dev->udev = udev;
	dev->interface = interface;

	/*Set up the Endpoint Information */
	/* use only the first bulk-in and bulk-out endpoints*/
	iface_desc = interface->cur_altsetting;
	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
		endpoint = &iface_desc->endpoint[i].desc;

		if (usb_endpoint_is_bulk_in(endpoint)) {
			/*We found a bulk_in endpoint */
			dev->bulk_in_size = usb_endpoint_maxp(endpoint);
			dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
		}

		if (usb_endpoint_is_bulk_out(endpoint)) {
			/*We found a buld_out endpoint */
			dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
		}
	}

	if (dev->bulk_in_endpointAddr == 0
		|| dev->bulk_out_endpointAddr == 0) {
		INFO("%s(%d) Count not find bulk point infomations\n",
							__func__, __LINE__);
		goto error;
	}

	/* save our data pointer in this interface device */
	usb_set_intfdata(interface, dev);

	/* we can register the device now, as it is ready */
	retval = usb_register_dev(interface, &nv_usb_class);

	if (retval) {
		INFO("%s(%d) usb_register_dev failed\n", __func__, __LINE__);
		usb_set_intfdata(interface, NULL);
		goto error;
	}

	INFO("%s(%d) device now attached to USB\n", __func__, __LINE__);
	return 0;
error:
	if (dev) {
		kref_put(&dev->kref, nv_usb_delete);
		retval = -EFAULT;
	}

	return retval;

}

static void nv_usb_disconnect(struct usb_interface *interface)
{
	struct nv_usb *dev;
	int minor = interface->minor;

	dev = usb_get_intfdata(interface);
	usb_set_intfdata(interface, NULL);

	usb_deregister_dev(interface, &nv_usb_class);

	mutex_lock(&dev->mutex);
	dev->interface = NULL;
	mutex_unlock(&dev->mutex);

	usb_kill_anchored_urbs(&dev->submitted);

	kref_put(&dev->kref, nv_usb_delete);

	INFO("%s(%d) disconnected minor = %d\n", __func__, __LINE__, minor);

}

static struct usb_driver nv_usb_driver = {
	.name		= "nv-usb",
	.probe		= nv_usb_probe,
	.disconnect	= nv_usb_disconnect,
	.id_table	= nv_usb_table,
};

module_usb_driver(nv_usb_driver);
MODULE_AUTHOR("NVIDIA");
MODULE_LICENSE("GPL");