4
* Driver for USB Rio 500
6
* Cesar Miquel (miquel@df.uba.ar)
8
* based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
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.
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.
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.
24
* Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
27
* 30/05/2003 replaced lock/unlock kernel with up/down
28
* Daniele Bellucci bellucda@tiscali.it
31
#include <linux/module.h>
32
#include <linux/kernel.h>
33
#include <linux/signal.h>
34
#include <linux/sched.h>
35
#include <linux/mutex.h>
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>
43
#include <linux/wait.h>
45
#include "rio500_usb.h"
50
#define DRIVER_VERSION "v1.1"
51
#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
52
#define DRIVER_DESC "USB Rio 500 driver"
56
/* stall/wait timeout for rio */
57
#define NAK_TIMEOUT (HZ)
59
#define IBUF_SIZE 0x1000
61
/* Size of the rio buffer */
62
#define OBUF_SIZE 0x10000
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 */
72
struct mutex lock; /* general race avoidance */
75
static DEFINE_MUTEX(rio500_mutex);
76
static struct rio_usb_data rio_instance;
78
static int open_rio(struct inode *inode, struct file *file)
80
struct rio_usb_data *rio = &rio_instance;
82
/* against disconnect() */
83
mutex_lock(&rio500_mutex);
84
mutex_lock(&(rio->lock));
86
if (rio->isopen || !rio->present) {
87
mutex_unlock(&(rio->lock));
88
mutex_unlock(&rio500_mutex);
93
init_waitqueue_head(&rio->wait_q);
95
mutex_unlock(&(rio->lock));
97
dev_info(&rio->rio_dev->dev, "Rio opened.\n");
98
mutex_unlock(&rio500_mutex);
103
static int close_rio(struct inode *inode, struct file *file)
105
struct rio_usb_data *rio = &rio_instance;
109
dev_info(&rio->rio_dev->dev, "Rio closed.\n");
113
static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
115
struct RioCommand rio_cmd;
116
struct rio_usb_data *rio = &rio_instance;
118
unsigned char *buffer;
119
int result, requesttype;
123
mutex_lock(&(rio->lock));
124
/* Sanity check to make sure rio is connected, powered, etc */
125
if (rio->present == 0 || rio->rio_dev == NULL) {
131
case RIO_RECV_COMMAND:
132
data = (void __user *) arg;
135
if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
139
if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
143
buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
144
if (buffer == NULL) {
148
if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
150
free_page((unsigned long) buffer);
154
requesttype = rio_cmd.requesttype | USB_DIR_IN |
155
USB_TYPE_VENDOR | USB_RECIP_DEVICE;
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 */
163
result = usb_control_msg(rio->rio_dev,
164
usb_rcvctrlpipe(rio-> rio_dev, 0),
168
rio_cmd.index, buffer,
170
jiffies_to_msecs(rio_cmd.timeout));
171
if (result == -ETIMEDOUT)
173
else if (result < 0) {
174
err("Error executing ioctrl. code = %d", result);
177
dbg("Executed ioctl. Result = %d (data=%02x)",
179
if (copy_to_user(rio_cmd.buffer, buffer,
181
free_page((unsigned long) buffer);
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 */
196
free_page((unsigned long) buffer);
199
case RIO_SEND_COMMAND:
200
data = (void __user *) arg;
203
if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
207
if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
211
buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
212
if (buffer == NULL) {
216
if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
217
free_page((unsigned long)buffer);
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 */
230
result = usb_control_msg(rio->rio_dev,
231
usb_sndctrlpipe(rio-> rio_dev, 0),
235
rio_cmd.index, buffer,
237
jiffies_to_msecs(rio_cmd.timeout));
238
if (result == -ETIMEDOUT)
240
else if (result < 0) {
241
err("Error executing ioctrl. code = %d", result);
244
dbg("Executed ioctl. Result = %d", result);
250
free_page((unsigned long) buffer);
260
mutex_unlock(&(rio->lock));
265
write_rio(struct file *file, const char __user *buffer,
266
size_t count, loff_t * ppos)
269
struct rio_usb_data *rio = &rio_instance;
271
unsigned long copy_size;
272
unsigned long bytes_written = 0;
273
unsigned int partial;
280
intr = mutex_lock_interruptible(&(rio->lock));
283
/* Sanity check to make sure rio is connected, powered, etc */
284
if (rio->present == 0 || rio->rio_dev == NULL) {
285
mutex_unlock(&(rio->lock));
292
unsigned long thistime;
293
char *obuf = rio->obuf;
295
thistime = copy_size =
296
(count >= OBUF_SIZE) ? OBUF_SIZE : count;
297
if (copy_from_user(rio->obuf, buffer, copy_size)) {
307
if (signal_pending(current)) {
308
mutex_unlock(&(rio->lock));
309
return bytes_written ? bytes_written : -EINTR;
312
result = usb_bulk_msg(rio->rio_dev,
313
usb_sndbulkpipe(rio->rio_dev, 2),
314
obuf, thistime, &partial, 5000);
316
dbg("write stats: result:%d thistime:%lu partial:%u",
317
result, thistime, partial);
319
if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
324
prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
325
schedule_timeout(NAK_TIMEOUT);
326
finish_wait(&rio->wait_q, &wait);
328
} else if (!result && partial) {
335
err("Write Whoops - %x", result);
339
bytes_written += copy_size;
344
mutex_unlock(&(rio->lock));
346
return bytes_written ? bytes_written : -EIO;
349
mutex_unlock(&(rio->lock));
354
read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
357
struct rio_usb_data *rio = &rio_instance;
359
unsigned int partial;
366
intr = mutex_lock_interruptible(&(rio->lock));
369
/* Sanity check to make sure rio is connected, powered, etc */
370
if (rio->present == 0 || rio->rio_dev == NULL) {
371
mutex_unlock(&(rio->lock));
381
if (signal_pending(current)) {
382
mutex_unlock(&(rio->lock));
383
return read_count ? read_count : -EINTR;
386
mutex_unlock(&(rio->lock));
389
this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
391
result = usb_bulk_msg(rio->rio_dev,
392
usb_rcvbulkpipe(rio->rio_dev, 1),
393
ibuf, this_read, &partial,
396
dbg("read stats: result:%d this_read:%u partial:%u",
397
result, this_read, partial);
400
count = this_read = partial;
401
} else if (result == -ETIMEDOUT || result == 15) { /* FIXME: 15 ??? */
403
mutex_unlock(&(rio->lock));
404
err("read_rio: maxretry timeout");
407
prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
408
schedule_timeout(NAK_TIMEOUT);
409
finish_wait(&rio->wait_q, &wait);
411
} else if (result != -EREMOTEIO) {
412
mutex_unlock(&(rio->lock));
413
err("Read Whoops - result:%u partial:%u this_read:%u",
414
result, partial, this_read);
417
mutex_unlock(&(rio->lock));
422
if (copy_to_user(buffer, ibuf, this_read)) {
423
mutex_unlock(&(rio->lock));
427
read_count += this_read;
431
mutex_unlock(&(rio->lock));
435
static const struct file_operations usb_rio_fops = {
436
.owner = THIS_MODULE,
439
.unlocked_ioctl = ioctl_rio,
441
.release = close_rio,
442
.llseek = noop_llseek,
445
static struct usb_class_driver usb_rio_class = {
447
.fops = &usb_rio_fops,
448
.minor_base = RIO_MINOR,
451
static int probe_rio(struct usb_interface *intf,
452
const struct usb_device_id *id)
454
struct usb_device *dev = interface_to_usbdev(intf);
455
struct rio_usb_data *rio = &rio_instance;
458
dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
460
retval = usb_register_dev(intf, &usb_rio_class);
462
err("Not able to get a minor for this device.");
468
if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
469
err("probe_rio: Not enough memory for the output buffer");
470
usb_deregister_dev(intf, &usb_rio_class);
473
dbg("probe_rio: obuf address:%p", rio->obuf);
475
if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
476
err("probe_rio: Not enough memory for the input buffer");
477
usb_deregister_dev(intf, &usb_rio_class);
481
dbg("probe_rio: ibuf address:%p", rio->ibuf);
483
mutex_init(&(rio->lock));
485
usb_set_intfdata (intf, rio);
491
static void disconnect_rio(struct usb_interface *intf)
493
struct rio_usb_data *rio = usb_get_intfdata (intf);
495
usb_set_intfdata (intf, NULL);
496
mutex_lock(&rio500_mutex);
498
usb_deregister_dev(intf, &usb_rio_class);
500
mutex_lock(&(rio->lock));
503
/* better let it finish - the release will do whats needed */
505
mutex_unlock(&(rio->lock));
506
mutex_unlock(&rio500_mutex);
512
dev_info(&intf->dev, "USB Rio disconnected.\n");
515
mutex_unlock(&(rio->lock));
517
mutex_unlock(&rio500_mutex);
520
static const struct usb_device_id rio_table[] = {
521
{ USB_DEVICE(0x0841, 1) }, /* Rio 500 */
522
{ } /* Terminating entry */
525
MODULE_DEVICE_TABLE (usb, rio_table);
527
static struct usb_driver rio_driver = {
530
.disconnect = disconnect_rio,
531
.id_table = rio_table,
534
static int __init usb_rio_init(void)
537
retval = usb_register(&rio_driver);
541
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
549
static void __exit usb_rio_cleanup(void)
551
struct rio_usb_data *rio = &rio_instance;
554
usb_deregister(&rio_driver);
559
module_init(usb_rio_init);
560
module_exit(usb_rio_cleanup);
562
MODULE_AUTHOR( DRIVER_AUTHOR );
563
MODULE_DESCRIPTION( DRIVER_DESC );
564
MODULE_LICENSE("GPL");