[deliverable/linux.git] / drivers / usb / misc / rio500.c

/* -*- linux-c -*- */

/* 
 * Driver for USB Rio 500
 *
 * Cesar Miquel (miquel@df.uba.ar)
 * 
 * based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
 * 
 * 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; either version 2 of the
 * License, or (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
 *
 * Changelog:
 * 30/05/2003  replaced lock/unlock kernel with up/down
 *             Daniele Bellucci  bellucda@tiscali.it
 * */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <linux/wait.h>

#include "rio500_usb.h"

/*
 * Version Information
 */
#define DRIVER_VERSION "v1.1"
#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
#define DRIVER_DESC "USB Rio 500 driver"

#define RIO_MINOR	64

/* stall/wait timeout for rio */
#define NAK_TIMEOUT (HZ)

#define IBUF_SIZE 0x1000

/* Size of the rio buffer */
#define OBUF_SIZE 0x10000

struct rio_usb_data {
        struct usb_device *rio_dev;     /* init: probe_rio */
        unsigned int ifnum;             /* Interface number of the USB device */
        int isopen;                     /* nz if open */
        int present;                    /* Device is present on the bus */
        char *obuf, *ibuf;              /* transfer buffers */
        char bulk_in_ep, bulk_out_ep;   /* Endpoint assignments */
        wait_queue_head_t wait_q;       /* for timeouts */
	struct mutex lock;          /* general race avoidance */
};

static DEFINE_MUTEX(rio500_mutex);
static struct rio_usb_data rio_instance;

static int open_rio(struct inode *inode, struct file *file)
{
	struct rio_usb_data *rio = &rio_instance;

	/* against disconnect() */
	mutex_lock(&rio500_mutex);
	mutex_lock(&(rio->lock));

	if (rio->isopen || !rio->present) {
		mutex_unlock(&(rio->lock));
		mutex_unlock(&rio500_mutex);
		return -EBUSY;
	}
	rio->isopen = 1;

	init_waitqueue_head(&rio->wait_q);

	mutex_unlock(&(rio->lock));

	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
	mutex_unlock(&rio500_mutex);

	return 0;
}

static int close_rio(struct inode *inode, struct file *file)
{
	struct rio_usb_data *rio = &rio_instance;

	rio->isopen = 0;

	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
	return 0;
}

static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct RioCommand rio_cmd;
	struct rio_usb_data *rio = &rio_instance;
	void __user *data;
	unsigned char *buffer;
	int result, requesttype;
	int retries;
	int retval=0;

	mutex_lock(&(rio->lock));
        /* Sanity check to make sure rio is connected, powered, etc */
        if (rio->present == 0 || rio->rio_dev == NULL) {
		retval = -ENODEV;
		goto err_out;
	}

	switch (cmd) {
	case RIO_RECV_COMMAND:
		data = (void __user *) arg;
		if (data == NULL)
			break;
		if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
			retval = -EFAULT;
			goto err_out;
		}
		if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
			retval = -EINVAL;
			goto err_out;
		}
		buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
		if (buffer == NULL) {
			retval = -ENOMEM;
			goto err_out;
		}
		if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
			retval = -EFAULT;
			free_page((unsigned long) buffer);
			goto err_out;
		}

		requesttype = rio_cmd.requesttype | USB_DIR_IN |
		    USB_TYPE_VENDOR | USB_RECIP_DEVICE;
		dev_dbg(&rio->rio_dev->dev,
			"sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
			requesttype, rio_cmd.request, rio_cmd.value,
			rio_cmd.index, rio_cmd.length);
		/* Send rio control message */
		retries = 3;
		while (retries) {
			result = usb_control_msg(rio->rio_dev,
						 usb_rcvctrlpipe(rio-> rio_dev, 0),
						 rio_cmd.request,
						 requesttype,
						 rio_cmd.value,
						 rio_cmd.index, buffer,
						 rio_cmd.length,
						 jiffies_to_msecs(rio_cmd.timeout));
			if (result == -ETIMEDOUT)
				retries--;
			else if (result < 0) {
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
				retries = 0;
			} else {
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d (data=%02x)\n",
					result, buffer[0]);
				if (copy_to_user(rio_cmd.buffer, buffer,
						 rio_cmd.length)) {
					free_page((unsigned long) buffer);
					retval = -EFAULT;
					goto err_out;
				}
				retries = 0;
			}

			/* rio_cmd.buffer contains a raw stream of single byte
			   data which has been returned from rio.  Data is
			   interpreted at application level.  For data that
			   will be cast to data types longer than 1 byte, data
			   will be little_endian and will potentially need to
			   be swapped at the app level */

		}
		free_page((unsigned long) buffer);
		break;

	case RIO_SEND_COMMAND:
		data = (void __user *) arg;
		if (data == NULL)
			break;
		if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
			retval = -EFAULT;
			goto err_out;
		}
		if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
			retval = -EINVAL;
			goto err_out;
		}
		buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
		if (buffer == NULL) {
			retval = -ENOMEM;
			goto err_out;
		}
		if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
			free_page((unsigned long)buffer);
			retval = -EFAULT;
			goto err_out;
		}

		requesttype = rio_cmd.requesttype | USB_DIR_OUT |
		    USB_TYPE_VENDOR | USB_RECIP_DEVICE;
		dev_dbg(&rio->rio_dev->dev,
			"sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
			requesttype, rio_cmd.request, rio_cmd.value,
			rio_cmd.index, rio_cmd.length);
		/* Send rio control message */
		retries = 3;
		while (retries) {
			result = usb_control_msg(rio->rio_dev,
						 usb_sndctrlpipe(rio-> rio_dev, 0),
						 rio_cmd.request,
						 requesttype,
						 rio_cmd.value,
						 rio_cmd.index, buffer,
						 rio_cmd.length,
						 jiffies_to_msecs(rio_cmd.timeout));
			if (result == -ETIMEDOUT)
				retries--;
			else if (result < 0) {
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
				retries = 0;
			} else {
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d\n", result);
				retries = 0;

			}

		}
		free_page((unsigned long) buffer);
		break;

	default:
		retval = -ENOTTY;
		break;
	}


err_out:
	mutex_unlock(&(rio->lock));
	return retval;
}

static ssize_t
write_rio(struct file *file, const char __user *buffer,
	  size_t count, loff_t * ppos)
{
	DEFINE_WAIT(wait);
	struct rio_usb_data *rio = &rio_instance;

	unsigned long copy_size;
	unsigned long bytes_written = 0;
	unsigned int partial;

	int result = 0;
	int maxretry;
	int errn = 0;
	int intr;

	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
        /* Sanity check to make sure rio is connected, powered, etc */
        if (rio->present == 0 || rio->rio_dev == NULL) {
		mutex_unlock(&(rio->lock));
		return -ENODEV;
	}


	do {
		unsigned long thistime;
		char *obuf = rio->obuf;

		thistime = copy_size =
		    (count >= OBUF_SIZE) ? OBUF_SIZE : count;
		if (copy_from_user(rio->obuf, buffer, copy_size)) {
			errn = -EFAULT;
			goto error;
		}
		maxretry = 5;
		while (thistime) {
			if (!rio->rio_dev) {
				errn = -ENODEV;
				goto error;
			}
			if (signal_pending(current)) {
				mutex_unlock(&(rio->lock));
				return bytes_written ? bytes_written : -EINTR;
			}

			result = usb_bulk_msg(rio->rio_dev,
					 usb_sndbulkpipe(rio->rio_dev, 2),
					 obuf, thistime, &partial, 5000);

			dev_dbg(&rio->rio_dev->dev,
				"write stats: result:%d thistime:%lu partial:%u\n",
				result, thistime, partial);

			if (result == -ETIMEDOUT) {	/* NAK - so hold for a while */
				if (!maxretry--) {
					errn = -ETIME;
					goto error;
				}
				prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
				schedule_timeout(NAK_TIMEOUT);
				finish_wait(&rio->wait_q, &wait);
				continue;
			} else if (!result && partial) {
				obuf += partial;
				thistime -= partial;
			} else
				break;
		};
		if (result) {
			dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
				result);
			errn = -EIO;
			goto error;
		}
		bytes_written += copy_size;
		count -= copy_size;
		buffer += copy_size;
	} while (count > 0);

	mutex_unlock(&(rio->lock));

	return bytes_written ? bytes_written : -EIO;

error:
	mutex_unlock(&(rio->lock));
	return errn;
}

static ssize_t
read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
{
	DEFINE_WAIT(wait);
	struct rio_usb_data *rio = &rio_instance;
	ssize_t read_count;
	unsigned int partial;
	int this_read;
	int result;
	int maxretry = 10;
	char *ibuf;
	int intr;

	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
	/* Sanity check to make sure rio is connected, powered, etc */
        if (rio->present == 0 || rio->rio_dev == NULL) {
		mutex_unlock(&(rio->lock));
		return -ENODEV;
	}

	ibuf = rio->ibuf;

	read_count = 0;


	while (count > 0) {
		if (signal_pending(current)) {
			mutex_unlock(&(rio->lock));
			return read_count ? read_count : -EINTR;
		}
		if (!rio->rio_dev) {
			mutex_unlock(&(rio->lock));
			return -ENODEV;
		}
		this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;

		result = usb_bulk_msg(rio->rio_dev,
				      usb_rcvbulkpipe(rio->rio_dev, 1),
				      ibuf, this_read, &partial,
				      8000);

		dev_dbg(&rio->rio_dev->dev,
			"read stats: result:%d this_read:%u partial:%u\n",
			result, this_read, partial);

		if (partial) {
			count = this_read = partial;
		} else if (result == -ETIMEDOUT || result == 15) {	/* FIXME: 15 ??? */
			if (!maxretry--) {
				mutex_unlock(&(rio->lock));
				dev_err(&rio->rio_dev->dev,
					"read_rio: maxretry timeout\n");
				return -ETIME;
			}
			prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
			schedule_timeout(NAK_TIMEOUT);
			finish_wait(&rio->wait_q, &wait);
			continue;
		} else if (result != -EREMOTEIO) {
			mutex_unlock(&(rio->lock));
			dev_err(&rio->rio_dev->dev,
				"Read Whoops - result:%u partial:%u this_read:%u\n",
				result, partial, this_read);
			return -EIO;
		} else {
			mutex_unlock(&(rio->lock));
			return (0);
		}

		if (this_read) {
			if (copy_to_user(buffer, ibuf, this_read)) {
				mutex_unlock(&(rio->lock));
				return -EFAULT;
			}
			count -= this_read;
			read_count += this_read;
			buffer += this_read;
		}
	}
	mutex_unlock(&(rio->lock));
	return read_count;
}

static const struct file_operations usb_rio_fops = {
	.owner =	THIS_MODULE,
	.read =		read_rio,
	.write =	write_rio,
	.unlocked_ioctl = ioctl_rio,
	.open =		open_rio,
	.release =	close_rio,
	.llseek =	noop_llseek,
};

static struct usb_class_driver usb_rio_class = {
	.name =		"rio500%d",
	.fops =		&usb_rio_fops,
	.minor_base =	RIO_MINOR,
};

static int probe_rio(struct usb_interface *intf,
		     const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	struct rio_usb_data *rio = &rio_instance;
	int retval;

	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);

	retval = usb_register_dev(intf, &usb_rio_class);
	if (retval) {
		dev_err(&dev->dev,
			"Not able to get a minor for this device.\n");
		return -ENOMEM;
	}

	rio->rio_dev = dev;

	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the output buffer\n");
		usb_deregister_dev(intf, &usb_rio_class);
		return -ENOMEM;
	}
	dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);

	if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the input buffer\n");
		usb_deregister_dev(intf, &usb_rio_class);
		kfree(rio->obuf);
		return -ENOMEM;
	}
	dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);

	mutex_init(&(rio->lock));

	usb_set_intfdata (intf, rio);
	rio->present = 1;

	return 0;
}

static void disconnect_rio(struct usb_interface *intf)
{
	struct rio_usb_data *rio = usb_get_intfdata (intf);

	usb_set_intfdata (intf, NULL);
	mutex_lock(&rio500_mutex);
	if (rio) {
		usb_deregister_dev(intf, &usb_rio_class);

		mutex_lock(&(rio->lock));
		if (rio->isopen) {
			rio->isopen = 0;
			/* better let it finish - the release will do whats needed */
			rio->rio_dev = NULL;
			mutex_unlock(&(rio->lock));
			mutex_unlock(&rio500_mutex);
			return;
		}
		kfree(rio->ibuf);
		kfree(rio->obuf);

		dev_info(&intf->dev, "USB Rio disconnected.\n");

		rio->present = 0;
		mutex_unlock(&(rio->lock));
	}
	mutex_unlock(&rio500_mutex);
}

static const struct usb_device_id rio_table[] = {
	{ USB_DEVICE(0x0841, 1) }, 		/* Rio 500 */
	{ }					/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, rio_table);

static struct usb_driver rio_driver = {
	.name =		"rio500",
	.probe =	probe_rio,
	.disconnect =	disconnect_rio,
	.id_table =	rio_table,
};

module_usb_driver(rio_driver);

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/* -- linux-c -- */
	2
	3	/*
	4	* Driver for USB Rio 500
	5	*
	6	* Cesar Miquel (miquel@df.uba.ar)
	7	*
	8	* based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License as
	12	* published by the Free Software Foundation; either version 2 of the
	13	* License, or (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful, but
	16	* WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	23	*
	24	* Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
	25	*
	26	* Changelog:
	27	* 30/05/2003 replaced lock/unlock kernel with up/down
	28	* Daniele Bellucci bellucda@tiscali.it
	29	* */
	30
	31	#include <linux/module.h>
	32	#include <linux/kernel.h>
	33	#include <linux/signal.h>
	34	#include <linux/sched.h>
925ce689	35	#include <linux/mutex.h>
1da177e4 LT	36	#include <linux/errno.h>
	37	#include <linux/random.h>
	38	#include <linux/poll.h>
	39	#include <linux/init.h>
	40	#include <linux/slab.h>
	41	#include <linux/spinlock.h>
	42	#include <linux/usb.h>
1da177e4 LT	43	#include <linux/wait.h>
	44
	45	#include "rio500_usb.h"
	46
	47	/*
	48	* Version Information
	49	*/
	50	#define DRIVER_VERSION "v1.1"
	51	#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
	52	#define DRIVER_DESC "USB Rio 500 driver"
	53
	54	#define RIO_MINOR 64
	55
	56	/* stall/wait timeout for rio */
	57	#define NAK_TIMEOUT (HZ)
	58
	59	#define IBUF_SIZE 0x1000
	60
	61	/* Size of the rio buffer */
	62	#define OBUF_SIZE 0x10000
	63
	64	struct rio_usb_data {
	65	struct usb_device rio_dev; / init: probe_rio */
	66	unsigned int ifnum; /* Interface number of the USB device */
	67	int isopen; /* nz if open */
	68	int present; /* Device is present on the bus */
	69	char obuf, ibuf; /* transfer buffers */
	70	char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
	71	wait_queue_head_t wait_q; /* for timeouts */
2cba72f0	72	struct mutex lock; /* general race avoidance */
1da177e4 LT	73	};
1da177e4 LT	74
925ce689	75	static DEFINE_MUTEX(rio500_mutex);
1da177e4 LT	76	static struct rio_usb_data rio_instance;
	77
	78	static int open_rio(struct inode inode, struct file file)
	79	{
	80	struct rio_usb_data *rio = &rio_instance;
511e2d02 ON	81
511e2d02 ON	82	/* against disconnect() */
925ce689	83	mutex_lock(&rio500_mutex);
2cba72f0	84	mutex_lock(&(rio->lock));
1da177e4 LT	85
1da177e4 LT	86	if (rio->isopen \|\| !rio->present) {
2cba72f0	87	mutex_unlock(&(rio->lock));
925ce689	88	mutex_unlock(&rio500_mutex);
1da177e4 LT	89	return -EBUSY;
	90	}
	91	rio->isopen = 1;
	92
	93	init_waitqueue_head(&rio->wait_q);
	94
2cba72f0	95	mutex_unlock(&(rio->lock));
1da177e4	96
1b29a375	97	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
925ce689	98	mutex_unlock(&rio500_mutex);
1da177e4 LT	99
	100	return 0;
	101	}
	102
	103	static int close_rio(struct inode inode, struct file file)
	104	{
	105	struct rio_usb_data *rio = &rio_instance;
	106
	107	rio->isopen = 0;
	108
1b29a375	109	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
1da177e4 LT	110	return 0;
	111	}
	112
54592157	113	static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
1da177e4 LT	114	{
	115	struct RioCommand rio_cmd;
	116	struct rio_usb_data *rio = &rio_instance;
	117	void __user *data;
	118	unsigned char *buffer;
	119	int result, requesttype;
	120	int retries;
	121	int retval=0;
	122
2cba72f0	123	mutex_lock(&(rio->lock));
1da177e4	124	/* Sanity check to make sure rio is connected, powered, etc */
3328d975	125	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
1da177e4 LT	126	retval = -ENODEV;
	127	goto err_out;
	128	}
	129
	130	switch (cmd) {
	131	case RIO_RECV_COMMAND:
	132	data = (void __user *) arg;
	133	if (data == NULL)
	134	break;
	135	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
	136	retval = -EFAULT;
	137	goto err_out;
	138	}
	139	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
	140	retval = -EINVAL;
	141	goto err_out;
	142	}
	143	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
	144	if (buffer == NULL) {
	145	retval = -ENOMEM;
	146	goto err_out;
	147	}
	148	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
	149	retval = -EFAULT;
	150	free_page((unsigned long) buffer);
	151	goto err_out;
	152	}
	153
	154	requesttype = rio_cmd.requesttype \| USB_DIR_IN \|
	155	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
e1a344d3 GKH	156	dev_dbg(&rio->rio_dev->dev,
	157	"sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
	158	requesttype, rio_cmd.request, rio_cmd.value,
	159	rio_cmd.index, rio_cmd.length);
1da177e4 LT	160	/* Send rio control message */
	161	retries = 3;
	162	while (retries) {
	163	result = usb_control_msg(rio->rio_dev,
	164	usb_rcvctrlpipe(rio-> rio_dev, 0),
	165	rio_cmd.request,
	166	requesttype,
	167	rio_cmd.value,
	168	rio_cmd.index, buffer,
	169	rio_cmd.length,
	170	jiffies_to_msecs(rio_cmd.timeout));
	171	if (result == -ETIMEDOUT)
	172	retries--;
	173	else if (result < 0) {
c41fba13 GKH	174	dev_err(&rio->rio_dev->dev,
	175	"Error executing ioctrl. code = %d\n",
	176	result);
1da177e4 LT	177	retries = 0;
1da177e4 LT	178	} else {
e1a344d3 GKH	179	dev_dbg(&rio->rio_dev->dev,
	180	"Executed ioctl. Result = %d (data=%02x)\n",
	181	result, buffer[0]);
1da177e4 LT	182	if (copy_to_user(rio_cmd.buffer, buffer,
	183	rio_cmd.length)) {
	184	free_page((unsigned long) buffer);
	185	retval = -EFAULT;
	186	goto err_out;
	187	}
	188	retries = 0;
	189	}
	190
	191	/* rio_cmd.buffer contains a raw stream of single byte
	192	data which has been returned from rio. Data is
	193	interpreted at application level. For data that
	194	will be cast to data types longer than 1 byte, data
	195	will be little_endian and will potentially need to
	196	be swapped at the app level */
	197
	198	}
	199	free_page((unsigned long) buffer);
	200	break;
	201
	202	case RIO_SEND_COMMAND:
	203	data = (void __user *) arg;
	204	if (data == NULL)
	205	break;
	206	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
	207	retval = -EFAULT;
	208	goto err_out;
	209	}
	210	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
	211	retval = -EINVAL;
	212	goto err_out;
	213	}
	214	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
	215	if (buffer == NULL) {
	216	retval = -ENOMEM;
	217	goto err_out;
	218	}
	219	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
	220	free_page((unsigned long)buffer);
	221	retval = -EFAULT;
	222	goto err_out;
	223	}
	224
	225	requesttype = rio_cmd.requesttype \| USB_DIR_OUT \|
	226	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
e1a344d3 GKH	227	dev_dbg(&rio->rio_dev->dev,
	228	"sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
	229	requesttype, rio_cmd.request, rio_cmd.value,
	230	rio_cmd.index, rio_cmd.length);
1da177e4 LT	231	/* Send rio control message */
	232	retries = 3;
	233	while (retries) {
	234	result = usb_control_msg(rio->rio_dev,
	235	usb_sndctrlpipe(rio-> rio_dev, 0),
	236	rio_cmd.request,
	237	requesttype,
	238	rio_cmd.value,
	239	rio_cmd.index, buffer,
	240	rio_cmd.length,
	241	jiffies_to_msecs(rio_cmd.timeout));
	242	if (result == -ETIMEDOUT)
	243	retries--;
	244	else if (result < 0) {
c41fba13 GKH	245	dev_err(&rio->rio_dev->dev,
	246	"Error executing ioctrl. code = %d\n",
	247	result);
1da177e4 LT	248	retries = 0;
1da177e4 LT	249	} else {
e1a344d3 GKH	250	dev_dbg(&rio->rio_dev->dev,
e1a344d3 GKH	251	"Executed ioctl. Result = %d\n", result);
1da177e4 LT	252	retries = 0;
	253
	254	}
	255
	256	}
	257	free_page((unsigned long) buffer);
	258	break;
	259
	260	default:
	261	retval = -ENOTTY;
	262	break;
	263	}
	264
	265
	266	err_out:
2cba72f0	267	mutex_unlock(&(rio->lock));
1da177e4 LT	268	return retval;
	269	}
	270
	271	static ssize_t
	272	write_rio(struct file file, const char __user buffer,
	273	size_t count, loff_t * ppos)
	274	{
	275	DEFINE_WAIT(wait);
	276	struct rio_usb_data *rio = &rio_instance;
	277
	278	unsigned long copy_size;
	279	unsigned long bytes_written = 0;
	280	unsigned int partial;
	281
	282	int result = 0;
	283	int maxretry;
	284	int errn = 0;
2cba72f0	285	int intr;
1da177e4	286
2cba72f0 ON	287	intr = mutex_lock_interruptible(&(rio->lock));
	288	if (intr)
	289	return -EINTR;
1da177e4	290	/* Sanity check to make sure rio is connected, powered, etc */
3328d975	291	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
2cba72f0	292	mutex_unlock(&(rio->lock));
1da177e4 LT	293	return -ENODEV;
	294	}
	295
	296
	297
	298	do {
	299	unsigned long thistime;
	300	char *obuf = rio->obuf;
	301
	302	thistime = copy_size =
	303	(count >= OBUF_SIZE) ? OBUF_SIZE : count;
	304	if (copy_from_user(rio->obuf, buffer, copy_size)) {
	305	errn = -EFAULT;
	306	goto error;
	307	}
	308	maxretry = 5;
	309	while (thistime) {
	310	if (!rio->rio_dev) {
	311	errn = -ENODEV;
	312	goto error;
	313	}
	314	if (signal_pending(current)) {
2cba72f0	315	mutex_unlock(&(rio->lock));
1da177e4 LT	316	return bytes_written ? bytes_written : -EINTR;
	317	}
	318
	319	result = usb_bulk_msg(rio->rio_dev,
	320	usb_sndbulkpipe(rio->rio_dev, 2),
	321	obuf, thistime, &partial, 5000);
	322
e1a344d3 GKH	323	dev_dbg(&rio->rio_dev->dev,
	324	"write stats: result:%d thistime:%lu partial:%u\n",
	325	result, thistime, partial);
1da177e4 LT	326
	327	if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
	328	if (!maxretry--) {
	329	errn = -ETIME;
	330	goto error;
	331	}
	332	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
	333	schedule_timeout(NAK_TIMEOUT);
	334	finish_wait(&rio->wait_q, &wait);
	335	continue;
	336	} else if (!result && partial) {
	337	obuf += partial;
	338	thistime -= partial;
	339	} else
	340	break;
	341	};
	342	if (result) {
c41fba13 GKH	343	dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
c41fba13 GKH	344	result);
1da177e4 LT	345	errn = -EIO;
	346	goto error;
	347	}
	348	bytes_written += copy_size;
	349	count -= copy_size;
	350	buffer += copy_size;
	351	} while (count > 0);
	352
2cba72f0	353	mutex_unlock(&(rio->lock));
1da177e4 LT	354
	355	return bytes_written ? bytes_written : -EIO;
	356
	357	error:
2cba72f0	358	mutex_unlock(&(rio->lock));
1da177e4 LT	359	return errn;
	360	}
	361
	362	static ssize_t
	363	read_rio(struct file file, char __user buffer, size_t count, loff_t * ppos)
	364	{
	365	DEFINE_WAIT(wait);
	366	struct rio_usb_data *rio = &rio_instance;
	367	ssize_t read_count;
	368	unsigned int partial;
	369	int this_read;
	370	int result;
	371	int maxretry = 10;
	372	char *ibuf;
2cba72f0	373	int intr;
1da177e4	374
2cba72f0 ON	375	intr = mutex_lock_interruptible(&(rio->lock));
	376	if (intr)
	377	return -EINTR;
1da177e4	378	/* Sanity check to make sure rio is connected, powered, etc */
3328d975	379	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
2cba72f0	380	mutex_unlock(&(rio->lock));
1da177e4 LT	381	return -ENODEV;
	382	}
	383
	384	ibuf = rio->ibuf;
	385
	386	read_count = 0;
	387
	388
	389	while (count > 0) {
	390	if (signal_pending(current)) {
2cba72f0	391	mutex_unlock(&(rio->lock));
1da177e4 LT	392	return read_count ? read_count : -EINTR;
	393	}
	394	if (!rio->rio_dev) {
2cba72f0	395	mutex_unlock(&(rio->lock));
1da177e4 LT	396	return -ENODEV;
	397	}
	398	this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
	399
	400	result = usb_bulk_msg(rio->rio_dev,
	401	usb_rcvbulkpipe(rio->rio_dev, 1),
	402	ibuf, this_read, &partial,
	403	8000);
	404
e1a344d3 GKH	405	dev_dbg(&rio->rio_dev->dev,
	406	"read stats: result:%d this_read:%u partial:%u\n",
	407	result, this_read, partial);
1da177e4 LT	408
	409	if (partial) {
	410	count = this_read = partial;
	411	} else if (result == -ETIMEDOUT \|\| result == 15) { /* FIXME: 15 ??? */
	412	if (!maxretry--) {
2cba72f0	413	mutex_unlock(&(rio->lock));
c41fba13 GKH	414	dev_err(&rio->rio_dev->dev,
c41fba13 GKH	415	"read_rio: maxretry timeout\n");
1da177e4 LT	416	return -ETIME;
	417	}
	418	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
	419	schedule_timeout(NAK_TIMEOUT);
	420	finish_wait(&rio->wait_q, &wait);
	421	continue;
	422	} else if (result != -EREMOTEIO) {
2cba72f0	423	mutex_unlock(&(rio->lock));
c41fba13 GKH	424	dev_err(&rio->rio_dev->dev,
	425	"Read Whoops - result:%u partial:%u this_read:%u\n",
	426	result, partial, this_read);
1da177e4 LT	427	return -EIO;
1da177e4 LT	428	} else {
2cba72f0	429	mutex_unlock(&(rio->lock));
1da177e4 LT	430	return (0);
	431	}
	432
	433	if (this_read) {
	434	if (copy_to_user(buffer, ibuf, this_read)) {
2cba72f0	435	mutex_unlock(&(rio->lock));
1da177e4 LT	436	return -EFAULT;
	437	}
	438	count -= this_read;
	439	read_count += this_read;
	440	buffer += this_read;
	441	}
	442	}
2cba72f0	443	mutex_unlock(&(rio->lock));
1da177e4 LT	444	return read_count;
	445	}
	446
828c0950	447	static const struct file_operations usb_rio_fops = {
1da177e4 LT	448	.owner = THIS_MODULE,
	449	.read = read_rio,
	450	.write = write_rio,
54592157	451	.unlocked_ioctl = ioctl_rio,
1da177e4 LT	452	.open = open_rio,
1da177e4 LT	453	.release = close_rio,
6038f373	454	.llseek = noop_llseek,
1da177e4 LT	455	};
	456
	457	static struct usb_class_driver usb_rio_class = {
d6e5bcf4	458	.name = "rio500%d",
1da177e4	459	.fops = &usb_rio_fops,
1da177e4 LT	460	.minor_base = RIO_MINOR,
	461	};
	462
	463	static int probe_rio(struct usb_interface *intf,
	464	const struct usb_device_id *id)
	465	{
	466	struct usb_device *dev = interface_to_usbdev(intf);
	467	struct rio_usb_data *rio = &rio_instance;
	468	int retval;
	469
1b29a375	470	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
1da177e4 LT	471
	472	retval = usb_register_dev(intf, &usb_rio_class);
	473	if (retval) {
c41fba13 GKH	474	dev_err(&dev->dev,
c41fba13 GKH	475	"Not able to get a minor for this device.\n");
1da177e4 LT	476	return -ENOMEM;
	477	}
	478
	479	rio->rio_dev = dev;
	480
0e8eb0f0	481	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
c41fba13 GKH	482	dev_err(&dev->dev,
c41fba13 GKH	483	"probe_rio: Not enough memory for the output buffer\n");
1da177e4 LT	484	usb_deregister_dev(intf, &usb_rio_class);
	485	return -ENOMEM;
	486	}
e1a344d3	487	dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
1da177e4	488
0e8eb0f0	489	if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
c41fba13 GKH	490	dev_err(&dev->dev,
c41fba13 GKH	491	"probe_rio: Not enough memory for the input buffer\n");
1da177e4 LT	492	usb_deregister_dev(intf, &usb_rio_class);
	493	kfree(rio->obuf);
	494	return -ENOMEM;
	495	}
e1a344d3	496	dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
1da177e4	497
2cba72f0	498	mutex_init(&(rio->lock));
1da177e4 LT	499
	500	usb_set_intfdata (intf, rio);
	501	rio->present = 1;
	502
	503	return 0;
	504	}
	505
	506	static void disconnect_rio(struct usb_interface *intf)
	507	{
	508	struct rio_usb_data *rio = usb_get_intfdata (intf);
	509
	510	usb_set_intfdata (intf, NULL);
925ce689	511	mutex_lock(&rio500_mutex);
1da177e4 LT	512	if (rio) {
	513	usb_deregister_dev(intf, &usb_rio_class);
	514
2cba72f0	515	mutex_lock(&(rio->lock));
1da177e4 LT	516	if (rio->isopen) {
	517	rio->isopen = 0;
	518	/* better let it finish - the release will do whats needed */
	519	rio->rio_dev = NULL;
2cba72f0	520	mutex_unlock(&(rio->lock));
925ce689	521	mutex_unlock(&rio500_mutex);
1da177e4 LT	522	return;
	523	}
	524	kfree(rio->ibuf);
	525	kfree(rio->obuf);
	526
1b29a375	527	dev_info(&intf->dev, "USB Rio disconnected.\n");
1da177e4 LT	528
1da177e4 LT	529	rio->present = 0;
2cba72f0	530	mutex_unlock(&(rio->lock));
1da177e4	531	}
925ce689	532	mutex_unlock(&rio500_mutex);
1da177e4 LT	533	}
1da177e4 LT	534
33b9e162	535	static const struct usb_device_id rio_table[] = {
1da177e4 LT	536	{ USB_DEVICE(0x0841, 1) }, /* Rio 500 */
	537	{ } /* Terminating entry */
	538	};
	539
	540	MODULE_DEVICE_TABLE (usb, rio_table);
	541
	542	static struct usb_driver rio_driver = {
1da177e4 LT	543	.name = "rio500",
	544	.probe = probe_rio,
	545	.disconnect = disconnect_rio,
	546	.id_table = rio_table,
	547	};
	548
65db4305	549	module_usb_driver(rio_driver);
1da177e4 LT	550
	551	MODULE_AUTHOR( DRIVER_AUTHOR );
	552	MODULE_DESCRIPTION( DRIVER_DESC );
	553	MODULE_LICENSE("GPL");
	554