[linux-2.6-block.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;
		dbg
		    ("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
		     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 {
				dbg("Executed ioctl. Result = %d (data=%02x)",
				     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;
		dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
		     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 {
				dbg("Executed ioctl. Result = %d", 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);

			dbg("write stats: result:%d thistime:%lu partial:%u",
			     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);

		dbg("read stats: result:%d this_read:%u partial:%u",
		       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;
	}
	dbg("probe_rio: obuf address:%p", 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;
	}
	dbg("probe_rio: ibuf address:%p", 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;
	156	dbg
	157	("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
	158	requesttype, rio_cmd.request, rio_cmd.value,
	159	rio_cmd.index, rio_cmd.length);
	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;
	178	} else {
	179	dbg("Executed ioctl. Result = %d (data=%02x)",
	180	result, buffer[0]);
	181	if (copy_to_user(rio_cmd.buffer, buffer,
	182	rio_cmd.length)) {
	183	free_page((unsigned long) buffer);
	184	retval = -EFAULT;
	185	goto err_out;
	186	}
	187	retries = 0;
	188	}
	189
	190	/* rio_cmd.buffer contains a raw stream of single byte
	191	data which has been returned from rio. Data is
	192	interpreted at application level. For data that
	193	will be cast to data types longer than 1 byte, data
	194	will be little_endian and will potentially need to
	195	be swapped at the app level */
	196
	197	}
	198	free_page((unsigned long) buffer);
	199	break;
	200
	201	case RIO_SEND_COMMAND:
	202	data = (void __user *) arg;
	203	if (data == NULL)
	204	break;
	205	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
	206	retval = -EFAULT;
	207	goto err_out;
	208	}
	209	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
	210	retval = -EINVAL;
	211	goto err_out;
	212	}
	213	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
	214	if (buffer == NULL) {
	215	retval = -ENOMEM;
	216	goto err_out;
	217	}
	218	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
	219	free_page((unsigned long)buffer);
	220	retval = -EFAULT;
	221	goto err_out;
	222	}
	223
	224	requesttype = rio_cmd.requesttype \| USB_DIR_OUT \|
	225	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
	226	dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
	227	requesttype, rio_cmd.request, rio_cmd.value,
	228	rio_cmd.index, rio_cmd.length);
	229	/* Send rio control message */
	230	retries = 3;
	231	while (retries) {
	232	result = usb_control_msg(rio->rio_dev,
	233	usb_sndctrlpipe(rio-> rio_dev, 0),
	234	rio_cmd.request,
	235	requesttype,
	236	rio_cmd.value,
	237	rio_cmd.index, buffer,
	238	rio_cmd.length,
	239	jiffies_to_msecs(rio_cmd.timeout));
	240	if (result == -ETIMEDOUT)
241	retries--;
242	else if (result < 0) {
c41fba13 GKH	243	dev_err(&rio->rio_dev->dev,
	244	"Error executing ioctrl. code = %d\n",
	245	result);
1da177e4 LT	246	retries = 0;
	247	} else {
	248	dbg("Executed ioctl. Result = %d", result);
	249	retries = 0;
	250
	251	}
	252
	253	}
	254	free_page((unsigned long) buffer);
	255	break;
	256
	257	default:
	258	retval = -ENOTTY;
	259	break;
	260	}
	261
	262
	263	err_out:
2cba72f0	264	mutex_unlock(&(rio->lock));
1da177e4 LT	265	return retval;
	266	}
	267
	268	static ssize_t
	269	write_rio(struct file file, const char __user buffer,
	270	size_t count, loff_t * ppos)
	271	{
	272	DEFINE_WAIT(wait);
	273	struct rio_usb_data *rio = &rio_instance;
	274
	275	unsigned long copy_size;
	276	unsigned long bytes_written = 0;
	277	unsigned int partial;
	278
	279	int result = 0;
	280	int maxretry;
	281	int errn = 0;
2cba72f0	282	int intr;
1da177e4	283
2cba72f0 ON	284	intr = mutex_lock_interruptible(&(rio->lock));
	285	if (intr)
	286	return -EINTR;
1da177e4	287	/* Sanity check to make sure rio is connected, powered, etc */
3328d975	288	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
2cba72f0	289	mutex_unlock(&(rio->lock));
1da177e4 LT	290	return -ENODEV;
	291	}
	292
	293
	294
	295	do {
	296	unsigned long thistime;
	297	char *obuf = rio->obuf;
	298
	299	thistime = copy_size =
	300	(count >= OBUF_SIZE) ? OBUF_SIZE : count;
	301	if (copy_from_user(rio->obuf, buffer, copy_size)) {
	302	errn = -EFAULT;
	303	goto error;
	304	}
	305	maxretry = 5;
	306	while (thistime) {
	307	if (!rio->rio_dev) {
	308	errn = -ENODEV;
	309	goto error;
	310	}
	311	if (signal_pending(current)) {
2cba72f0	312	mutex_unlock(&(rio->lock));
1da177e4 LT	313	return bytes_written ? bytes_written : -EINTR;
	314	}
	315
	316	result = usb_bulk_msg(rio->rio_dev,
	317	usb_sndbulkpipe(rio->rio_dev, 2),
	318	obuf, thistime, &partial, 5000);
	319
	320	dbg("write stats: result:%d thistime:%lu partial:%u",
	321	result, thistime, partial);
	322
	323	if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
	324	if (!maxretry--) {
	325	errn = -ETIME;
	326	goto error;
	327	}
	328	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
	329	schedule_timeout(NAK_TIMEOUT);
	330	finish_wait(&rio->wait_q, &wait);
	331	continue;
	332	} else if (!result && partial) {
	333	obuf += partial;
	334	thistime -= partial;
	335	} else
	336	break;
	337	};
	338	if (result) {
c41fba13 GKH	339	dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
c41fba13 GKH	340	result);
1da177e4 LT	341	errn = -EIO;
	342	goto error;
	343	}
	344	bytes_written += copy_size;
	345	count -= copy_size;
	346	buffer += copy_size;
	347	} while (count > 0);
	348
2cba72f0	349	mutex_unlock(&(rio->lock));
1da177e4 LT	350
	351	return bytes_written ? bytes_written : -EIO;
	352
	353	error:
2cba72f0	354	mutex_unlock(&(rio->lock));
1da177e4 LT	355	return errn;
	356	}
	357
	358	static ssize_t
	359	read_rio(struct file file, char __user buffer, size_t count, loff_t * ppos)
	360	{
	361	DEFINE_WAIT(wait);
	362	struct rio_usb_data *rio = &rio_instance;
	363	ssize_t read_count;
	364	unsigned int partial;
	365	int this_read;
	366	int result;
	367	int maxretry = 10;
	368	char *ibuf;
2cba72f0	369	int intr;
1da177e4	370
2cba72f0 ON	371	intr = mutex_lock_interruptible(&(rio->lock));
	372	if (intr)
	373	return -EINTR;
1da177e4	374	/* Sanity check to make sure rio is connected, powered, etc */
3328d975	375	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
2cba72f0	376	mutex_unlock(&(rio->lock));
1da177e4 LT	377	return -ENODEV;
	378	}
	379
	380	ibuf = rio->ibuf;
	381
	382	read_count = 0;
	383
	384
	385	while (count > 0) {
	386	if (signal_pending(current)) {
2cba72f0	387	mutex_unlock(&(rio->lock));
1da177e4 LT	388	return read_count ? read_count : -EINTR;
	389	}
	390	if (!rio->rio_dev) {
2cba72f0	391	mutex_unlock(&(rio->lock));
1da177e4 LT	392	return -ENODEV;
	393	}
	394	this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
	395
	396	result = usb_bulk_msg(rio->rio_dev,
	397	usb_rcvbulkpipe(rio->rio_dev, 1),
	398	ibuf, this_read, &partial,
	399	8000);
	400
654f3118	401	dbg("read stats: result:%d this_read:%u partial:%u",
1da177e4 LT	402	result, this_read, partial);
	403
	404	if (partial) {
	405	count = this_read = partial;
	406	} else if (result == -ETIMEDOUT \|\| result == 15) { /* FIXME: 15 ??? */
	407	if (!maxretry--) {
2cba72f0	408	mutex_unlock(&(rio->lock));
c41fba13 GKH	409	dev_err(&rio->rio_dev->dev,
c41fba13 GKH	410	"read_rio: maxretry timeout\n");
1da177e4 LT	411	return -ETIME;
	412	}
	413	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
	414	schedule_timeout(NAK_TIMEOUT);
	415	finish_wait(&rio->wait_q, &wait);
	416	continue;
	417	} else if (result != -EREMOTEIO) {
2cba72f0	418	mutex_unlock(&(rio->lock));
c41fba13 GKH	419	dev_err(&rio->rio_dev->dev,
	420	"Read Whoops - result:%u partial:%u this_read:%u\n",
	421	result, partial, this_read);
1da177e4 LT	422	return -EIO;
1da177e4 LT	423	} else {
2cba72f0	424	mutex_unlock(&(rio->lock));
1da177e4 LT	425	return (0);
	426	}
	427
	428	if (this_read) {
	429	if (copy_to_user(buffer, ibuf, this_read)) {
2cba72f0	430	mutex_unlock(&(rio->lock));
1da177e4 LT	431	return -EFAULT;
	432	}
	433	count -= this_read;
	434	read_count += this_read;
	435	buffer += this_read;
	436	}
	437	}
2cba72f0	438	mutex_unlock(&(rio->lock));
1da177e4 LT	439	return read_count;
	440	}
	441
828c0950	442	static const struct file_operations usb_rio_fops = {
1da177e4 LT	443	.owner = THIS_MODULE,
	444	.read = read_rio,
	445	.write = write_rio,
54592157	446	.unlocked_ioctl = ioctl_rio,
1da177e4 LT	447	.open = open_rio,
1da177e4 LT	448	.release = close_rio,
6038f373	449	.llseek = noop_llseek,
1da177e4 LT	450	};
	451
	452	static struct usb_class_driver usb_rio_class = {
d6e5bcf4	453	.name = "rio500%d",
1da177e4	454	.fops = &usb_rio_fops,
1da177e4 LT	455	.minor_base = RIO_MINOR,
	456	};
	457
	458	static int probe_rio(struct usb_interface *intf,
	459	const struct usb_device_id *id)
	460	{
	461	struct usb_device *dev = interface_to_usbdev(intf);
	462	struct rio_usb_data *rio = &rio_instance;
	463	int retval;
	464
1b29a375	465	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
1da177e4 LT	466
	467	retval = usb_register_dev(intf, &usb_rio_class);
	468	if (retval) {
c41fba13 GKH	469	dev_err(&dev->dev,
c41fba13 GKH	470	"Not able to get a minor for this device.\n");
1da177e4 LT	471	return -ENOMEM;
	472	}
	473
	474	rio->rio_dev = dev;
	475
0e8eb0f0	476	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
c41fba13 GKH	477	dev_err(&dev->dev,
c41fba13 GKH	478	"probe_rio: Not enough memory for the output buffer\n");
1da177e4 LT	479	usb_deregister_dev(intf, &usb_rio_class);
	480	return -ENOMEM;
	481	}
	482	dbg("probe_rio: obuf address:%p", rio->obuf);
	483
0e8eb0f0	484	if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
c41fba13 GKH	485	dev_err(&dev->dev,
c41fba13 GKH	486	"probe_rio: Not enough memory for the input buffer\n");
1da177e4 LT	487	usb_deregister_dev(intf, &usb_rio_class);
	488	kfree(rio->obuf);
	489	return -ENOMEM;
	490	}
	491	dbg("probe_rio: ibuf address:%p", rio->ibuf);
	492
2cba72f0	493	mutex_init(&(rio->lock));
1da177e4 LT	494
	495	usb_set_intfdata (intf, rio);
	496	rio->present = 1;
	497
	498	return 0;
	499	}
	500
	501	static void disconnect_rio(struct usb_interface *intf)
	502	{
	503	struct rio_usb_data *rio = usb_get_intfdata (intf);
	504
	505	usb_set_intfdata (intf, NULL);
925ce689	506	mutex_lock(&rio500_mutex);
1da177e4 LT	507	if (rio) {
	508	usb_deregister_dev(intf, &usb_rio_class);
	509
2cba72f0	510	mutex_lock(&(rio->lock));
1da177e4 LT	511	if (rio->isopen) {
	512	rio->isopen = 0;
	513	/* better let it finish - the release will do whats needed */
	514	rio->rio_dev = NULL;
2cba72f0	515	mutex_unlock(&(rio->lock));
925ce689	516	mutex_unlock(&rio500_mutex);
1da177e4 LT	517	return;
	518	}
	519	kfree(rio->ibuf);
	520	kfree(rio->obuf);
	521
1b29a375	522	dev_info(&intf->dev, "USB Rio disconnected.\n");
1da177e4 LT	523
1da177e4 LT	524	rio->present = 0;
2cba72f0	525	mutex_unlock(&(rio->lock));
1da177e4	526	}
925ce689	527	mutex_unlock(&rio500_mutex);
1da177e4 LT	528	}
1da177e4 LT	529
33b9e162	530	static const struct usb_device_id rio_table[] = {
1da177e4 LT	531	{ USB_DEVICE(0x0841, 1) }, /* Rio 500 */
	532	{ } /* Terminating entry */
	533	};
	534
	535	MODULE_DEVICE_TABLE (usb, rio_table);
	536
	537	static struct usb_driver rio_driver = {
1da177e4 LT	538	.name = "rio500",
	539	.probe = probe_rio,
	540	.disconnect = disconnect_rio,
	541	.id_table = rio_table,
	542	};
	543
65db4305	544	module_usb_driver(rio_driver);
1da177e4 LT	545
	546	MODULE_AUTHOR( DRIVER_AUTHOR );
	547	MODULE_DESCRIPTION( DRIVER_DESC );
	548	MODULE_LICENSE("GPL");
	549