[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/smp_lock.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;

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

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

	init_waitqueue_head(&rio->wait_q);

	mutex_unlock(&(rio->lock));

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

	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);
	lock_kernel();
	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));
			unlock_kernel();
			return;
		}
		kfree(rio->ibuf);
		kfree(rio->obuf);

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

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

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