rio500.c 12.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
L
Linus Torvalds 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/* -*- 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)
 *
 * 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>
21
#include <linux/sched/signal.h>
22
#include <linux/mutex.h>
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
#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"

#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 */
54
	struct mutex lock;          /* general race avoidance */
L
Linus Torvalds 已提交
55 56
};

57
static DEFINE_MUTEX(rio500_mutex);
L
Linus Torvalds 已提交
58 59 60 61 62
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 已提交
63 64

	/* against disconnect() */
65
	mutex_lock(&rio500_mutex);
66
	mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
67 68

	if (rio->isopen || !rio->present) {
69
		mutex_unlock(&(rio->lock));
70
		mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
71 72 73 74 75 76
		return -EBUSY;
	}
	rio->isopen = 1;

	init_waitqueue_head(&rio->wait_q);

77
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
78

79
	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
80
	mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
81 82 83 84 85 86 87 88 89 90

	return 0;
}

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

	rio->isopen = 0;

91
	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
L
Linus Torvalds 已提交
92 93 94
	return 0;
}

A
Alan Cox 已提交
95
static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
96 97 98 99 100 101 102 103 104
{
	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;

105
	mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
106
        /* Sanity check to make sure rio is connected, powered, etc */
107
        if (rio->present == 0 || rio->rio_dev == NULL) {
L
Linus Torvalds 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
		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;
138 139 140 141
		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 已提交
142 143 144 145 146 147 148 149 150 151 152 153 154 155
		/* 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) {
156 157 158
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
L
Linus Torvalds 已提交
159 160
				retries = 0;
			} else {
161 162 163
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d (data=%02x)\n",
					result, buffer[0]);
L
Linus Torvalds 已提交
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 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
				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;
209 210 211 212
		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 已提交
213 214 215 216 217 218 219 220 221 222 223 224 225 226
		/* 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) {
227 228 229
				dev_err(&rio->rio_dev->dev,
					"Error executing ioctrl. code = %d\n",
					result);
L
Linus Torvalds 已提交
230 231
				retries = 0;
			} else {
232 233
				dev_dbg(&rio->rio_dev->dev,
					"Executed ioctl. Result = %d\n", result);
L
Linus Torvalds 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
				retries = 0;

			}

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

	default:
		retval = -ENOTTY;
		break;
	}


err_out:
249
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
	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;
267
	int intr;
L
Linus Torvalds 已提交
268

269 270 271
	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
L
Linus Torvalds 已提交
272
        /* Sanity check to make sure rio is connected, powered, etc */
273
        if (rio->present == 0 || rio->rio_dev == NULL) {
274
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
		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)) {
297
				mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
298 299 300 301 302 303 304
				return bytes_written ? bytes_written : -EINTR;
			}

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

305 306 307
			dev_dbg(&rio->rio_dev->dev,
				"write stats: result:%d thistime:%lu partial:%u\n",
				result, thistime, partial);
L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

			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;
323
		}
L
Linus Torvalds 已提交
324
		if (result) {
325 326
			dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
				result);
L
Linus Torvalds 已提交
327 328 329 330 331 332 333 334
			errn = -EIO;
			goto error;
		}
		bytes_written += copy_size;
		count -= copy_size;
		buffer += copy_size;
	} while (count > 0);

335
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
336 337 338 339

	return bytes_written ? bytes_written : -EIO;

error:
340
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
341 342 343 344 345 346 347 348 349 350 351 352 353 354
	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;
355
	int intr;
L
Linus Torvalds 已提交
356

357 358 359
	intr = mutex_lock_interruptible(&(rio->lock));
	if (intr)
		return -EINTR;
L
Linus Torvalds 已提交
360
	/* Sanity check to make sure rio is connected, powered, etc */
361
        if (rio->present == 0 || rio->rio_dev == NULL) {
362
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
363 364 365 366 367 368 369 370 371 372
		return -ENODEV;
	}

	ibuf = rio->ibuf;

	read_count = 0;


	while (count > 0) {
		if (signal_pending(current)) {
373
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
374 375 376
			return read_count ? read_count : -EINTR;
		}
		if (!rio->rio_dev) {
377
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385 386
			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);

387 388 389
		dev_dbg(&rio->rio_dev->dev,
			"read stats: result:%d this_read:%u partial:%u\n",
			result, this_read, partial);
L
Linus Torvalds 已提交
390 391 392 393 394

		if (partial) {
			count = this_read = partial;
		} else if (result == -ETIMEDOUT || result == 15) {	/* FIXME: 15 ??? */
			if (!maxretry--) {
395
				mutex_unlock(&(rio->lock));
396 397
				dev_err(&rio->rio_dev->dev,
					"read_rio: maxretry timeout\n");
L
Linus Torvalds 已提交
398 399 400 401 402 403 404
				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) {
405
			mutex_unlock(&(rio->lock));
406
			dev_err(&rio->rio_dev->dev,
407
				"Read Whoops - result:%d partial:%u this_read:%u\n",
408
				result, partial, this_read);
L
Linus Torvalds 已提交
409 410
			return -EIO;
		} else {
411
			mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
412 413 414 415 416
			return (0);
		}

		if (this_read) {
			if (copy_to_user(buffer, ibuf, this_read)) {
417
				mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
418 419 420 421 422 423 424
				return -EFAULT;
			}
			count -= this_read;
			read_count += this_read;
			buffer += this_read;
		}
	}
425
	mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
426 427 428
	return read_count;
}

429
static const struct file_operations usb_rio_fops = {
L
Linus Torvalds 已提交
430 431 432
	.owner =	THIS_MODULE,
	.read =		read_rio,
	.write =	write_rio,
A
Alan Cox 已提交
433
	.unlocked_ioctl = ioctl_rio,
L
Linus Torvalds 已提交
434 435
	.open =		open_rio,
	.release =	close_rio,
436
	.llseek =	noop_llseek,
L
Linus Torvalds 已提交
437 438 439
};

static struct usb_class_driver usb_rio_class = {
440
	.name =		"rio500%d",
L
Linus Torvalds 已提交
441 442 443 444 445 446 447 448 449 450 451
	.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;

452
	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
L
Linus Torvalds 已提交
453 454 455

	retval = usb_register_dev(intf, &usb_rio_class);
	if (retval) {
456 457
		dev_err(&dev->dev,
			"Not able to get a minor for this device.\n");
L
Linus Torvalds 已提交
458 459 460 461 462
		return -ENOMEM;
	}

	rio->rio_dev = dev;

463
	if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
464 465
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the output buffer\n");
L
Linus Torvalds 已提交
466 467 468
		usb_deregister_dev(intf, &usb_rio_class);
		return -ENOMEM;
	}
469
	dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
L
Linus Torvalds 已提交
470

471
	if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
472 473
		dev_err(&dev->dev,
			"probe_rio: Not enough memory for the input buffer\n");
L
Linus Torvalds 已提交
474 475 476 477
		usb_deregister_dev(intf, &usb_rio_class);
		kfree(rio->obuf);
		return -ENOMEM;
	}
478
	dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
L
Linus Torvalds 已提交
479

480
	mutex_init(&(rio->lock));
L
Linus Torvalds 已提交
481 482 483 484 485 486 487 488 489 490 491 492

	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);
493
	mutex_lock(&rio500_mutex);
L
Linus Torvalds 已提交
494 495 496
	if (rio) {
		usb_deregister_dev(intf, &usb_rio_class);

497
		mutex_lock(&(rio->lock));
L
Linus Torvalds 已提交
498 499 500 501
		if (rio->isopen) {
			rio->isopen = 0;
			/* better let it finish - the release will do whats needed */
			rio->rio_dev = NULL;
502
			mutex_unlock(&(rio->lock));
503
			mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
504 505 506 507 508
			return;
		}
		kfree(rio->ibuf);
		kfree(rio->obuf);

509
		dev_info(&intf->dev, "USB Rio disconnected.\n");
L
Linus Torvalds 已提交
510 511

		rio->present = 0;
512
		mutex_unlock(&(rio->lock));
L
Linus Torvalds 已提交
513
	}
514
	mutex_unlock(&rio500_mutex);
L
Linus Torvalds 已提交
515 516
}

517
static const struct usb_device_id rio_table[] = {
L
Linus Torvalds 已提交
518 519 520 521 522 523 524 525 526 527 528 529 530
	{ 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,
};

531
module_usb_driver(rio_driver);
L
Linus Torvalds 已提交
532 533 534 535 536

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