rio500.c 13.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/* -*- 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>
35
#include <linux/mutex.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/poll.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 */
71
	struct mutex lock;          /* general race avoidance */
L
Linus Torvalds 已提交
72 73
};

74
static DEFINE_MUTEX(rio500_mutex);
L
Linus Torvalds 已提交
75 76 77 78 79
static struct rio_usb_data rio_instance;

static int open_rio(struct inode *inode, struct file *file)
{
	struct rio_usb_data *rio = &rio_instance;
O
Oliver Neukum 已提交
80 81

	/* against disconnect() */
82
	mutex_lock(&rio500_mutex);
83
	mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
84 85

	if (rio->isopen || !rio->present) {
86
		mutex_unlock(&(rio->lock));
87
		mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
88 89 90 91 92 93
		return -EBUSY;
	}
	rio->isopen = 1;

	init_waitqueue_head(&rio->wait_q);

94
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
95

96
	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
97
	mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
98 99 100 101 102 103 104 105 106 107

	return 0;
}

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

	rio->isopen = 0;

108
	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
L
Linus Torvalds 已提交
109 110 111
	return 0;
}

A
Alan Cox 已提交
112
static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
113 114 115 116 117 118 119 120 121
{
	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;

122
	mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
123
        /* Sanity check to make sure rio is connected, powered, etc */
124
        if (rio->present == 0 || rio->rio_dev == NULL) {
L
Linus Torvalds 已提交
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
		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;
155 156 157 158
		dev_dbg(&rio->rio_dev->dev,
			"sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
			requesttype, rio_cmd.request, rio_cmd.value,
			rio_cmd.index, rio_cmd.length);
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172
		/* 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) {
173 174 175
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
L
Linus Torvalds 已提交
176 177
				retries = 0;
			} else {
178 179 180
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d (data=%02x)\n",
					result, buffer[0]);
L
Linus Torvalds 已提交
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
				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;
226 227 228 229
		dev_dbg(&rio->rio_dev->dev,
			"sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
			requesttype, rio_cmd.request, rio_cmd.value,
			rio_cmd.index, rio_cmd.length);
L
Linus Torvalds 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243
		/* 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) {
244 245 246
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
L
Linus Torvalds 已提交
247 248
				retries = 0;
			} else {
249 250
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d\n", result);
L
Linus Torvalds 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
				retries = 0;

			}

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

	default:
		retval = -ENOTTY;
		break;
	}


err_out:
266
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
	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;
284
	int intr;
L
Linus Torvalds 已提交
285

286 287 288
	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
L
Linus Torvalds 已提交
289
        /* Sanity check to make sure rio is connected, powered, etc */
290
        if (rio->present == 0 || rio->rio_dev == NULL) {
291
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
		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)) {
314
				mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
315 316 317 318 319 320 321
				return bytes_written ? bytes_written : -EINTR;
			}

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

322 323 324
			dev_dbg(&rio->rio_dev->dev,
				"write stats: result:%d thistime:%lu partial:%u\n",
				result, thistime, partial);
L
Linus Torvalds 已提交
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

			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;
340
		}
L
Linus Torvalds 已提交
341
		if (result) {
342 343
			dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
				result);
L
Linus Torvalds 已提交
344 345 346 347 348 349 350 351
			errn = -EIO;
			goto error;
		}
		bytes_written += copy_size;
		count -= copy_size;
		buffer += copy_size;
	} while (count > 0);

352
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
353 354 355 356

	return bytes_written ? bytes_written : -EIO;

error:
357
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
358 359 360 361 362 363 364 365 366 367 368 369 370 371
	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;
372
	int intr;
L
Linus Torvalds 已提交
373

374 375 376
	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
L
Linus Torvalds 已提交
377
	/* Sanity check to make sure rio is connected, powered, etc */
378
        if (rio->present == 0 || rio->rio_dev == NULL) {
379
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
380 381 382 383 384 385 386 387 388 389
		return -ENODEV;
	}

	ibuf = rio->ibuf;

	read_count = 0;


	while (count > 0) {
		if (signal_pending(current)) {
390
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
391 392 393
			return read_count ? read_count : -EINTR;
		}
		if (!rio->rio_dev) {
394
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
395 396 397 398 399 400 401 402 403
			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);

404 405 406
		dev_dbg(&rio->rio_dev->dev,
			"read stats: result:%d this_read:%u partial:%u\n",
			result, this_read, partial);
L
Linus Torvalds 已提交
407 408 409 410 411

		if (partial) {
			count = this_read = partial;
		} else if (result == -ETIMEDOUT || result == 15) {	/* FIXME: 15 ??? */
			if (!maxretry--) {
412
				mutex_unlock(&(rio->lock));
413 414
				dev_err(&rio->rio_dev->dev,
					"read_rio: maxretry timeout\n");
L
Linus Torvalds 已提交
415 416 417 418 419 420 421
				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) {
422
			mutex_unlock(&(rio->lock));
423 424 425
			dev_err(&rio->rio_dev->dev,
				"Read Whoops - result:%u partial:%u this_read:%u\n",
				result, partial, this_read);
L
Linus Torvalds 已提交
426 427
			return -EIO;
		} else {
428
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
429 430 431 432 433
			return (0);
		}

		if (this_read) {
			if (copy_to_user(buffer, ibuf, this_read)) {
434
				mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
435 436 437 438 439 440 441
				return -EFAULT;
			}
			count -= this_read;
			read_count += this_read;
			buffer += this_read;
		}
	}
442
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
443 444 445
	return read_count;
}

446
static const struct file_operations usb_rio_fops = {
L
Linus Torvalds 已提交
447 448 449
	.owner =	THIS_MODULE,
	.read =		read_rio,
	.write =	write_rio,
A
Alan Cox 已提交
450
	.unlocked_ioctl = ioctl_rio,
L
Linus Torvalds 已提交
451 452
	.open =		open_rio,
	.release =	close_rio,
453
	.llseek =	noop_llseek,
L
Linus Torvalds 已提交
454 455 456
};

static struct usb_class_driver usb_rio_class = {
457
	.name =		"rio500%d",
L
Linus Torvalds 已提交
458 459 460 461 462 463 464 465 466 467 468
	.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;

469
	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
L
Linus Torvalds 已提交
470 471 472

	retval = usb_register_dev(intf, &usb_rio_class);
	if (retval) {
473 474
		dev_err(&dev->dev,
			"Not able to get a minor for this device.\n");
L
Linus Torvalds 已提交
475 476 477 478 479
		return -ENOMEM;
	}

	rio->rio_dev = dev;

480
	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
481 482
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the output buffer\n");
L
Linus Torvalds 已提交
483 484 485
		usb_deregister_dev(intf, &usb_rio_class);
		return -ENOMEM;
	}
486
	dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
L
Linus Torvalds 已提交
487

488
	if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
489 490
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the input buffer\n");
L
Linus Torvalds 已提交
491 492 493 494
		usb_deregister_dev(intf, &usb_rio_class);
		kfree(rio->obuf);
		return -ENOMEM;
	}
495
	dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
L
Linus Torvalds 已提交
496

497
	mutex_init(&(rio->lock));
L
Linus Torvalds 已提交
498 499 500 501 502 503 504 505 506 507 508 509

	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);
510
	mutex_lock(&rio500_mutex);
L
Linus Torvalds 已提交
511 512 513
	if (rio) {
		usb_deregister_dev(intf, &usb_rio_class);

514
		mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
515 516 517 518
		if (rio->isopen) {
			rio->isopen = 0;
			/* better let it finish - the release will do whats needed */
			rio->rio_dev = NULL;
519
			mutex_unlock(&(rio->lock));
520
			mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
521 522 523 524 525
			return;
		}
		kfree(rio->ibuf);
		kfree(rio->obuf);

526
		dev_info(&intf->dev, "USB Rio disconnected.\n");
L
Linus Torvalds 已提交
527 528

		rio->present = 0;
529
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
530
	}
531
	mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
532 533
}

534
static const struct usb_device_id rio_table[] = {
L
Linus Torvalds 已提交
535 536 537 538 539 540 541 542 543 544 545 546 547
	{ 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,
};

548
module_usb_driver(rio_driver);
L
Linus Torvalds 已提交
549 550 551 552 553

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部