[linux-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/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 struct rio_usb_data rio_instance;

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

	mutex_lock(&(rio->lock));

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

	init_waitqueue_head(&rio->wait_q);

	mutex_unlock(&(rio->lock));

	info("Rio opened.");

	return 0;
}

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

	rio->isopen = 0;

	info("Rio closed.");
	return 0;
}

static int
ioctl_rio(struct inode *inode, 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) {
				err("Error executing ioctrl. code = %d", 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) {
				err("Error executing ioctrl. code = %d", 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) {
			err("Write Whoops - %x", 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));
				err("read_rio: maxretry timeout");
				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));
			err("Read Whoops - result:%u partial:%u this_read:%u",
			     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 struct
file_operations usb_rio_fops = {
	.owner =	THIS_MODULE,
	.read =		read_rio,
	.write =	write_rio,
	.ioctl =	ioctl_rio,
	.open =		open_rio,
	.release =	close_rio,
};

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;

	info("USB Rio found at address %d", dev->devnum);

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

	rio->rio_dev = dev;

	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
		err("probe_rio: Not enough memory for the output buffer");
		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))) {
		err("probe_rio: Not enough memory for the input buffer");
		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);
	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));
			return;
		}
		kfree(rio->ibuf);
		kfree(rio->obuf);

		info("USB Rio disconnected.");

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

static 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,
};

static int __init usb_rio_init(void)
{
	int retval;
	retval = usb_register(&rio_driver);
	if (retval)
		goto out;

	info(DRIVER_VERSION ":" DRIVER_DESC);

out:
	return retval;
}


static void __exit usb_rio_cleanup(void)
{
	struct rio_usb_data *rio = &rio_instance;

	rio->present = 0;
	usb_deregister(&rio_driver);


}

module_init(usb_rio_init);
module_exit(usb_rio_cleanup);

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