[mirror_ubuntu-bionic-kernel.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) {
				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 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,
};

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) {
		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);
	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,
};

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

	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
	       DRIVER_DESC "\n");

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