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 module_usb_driver(rio_driver
);
536 MODULE_AUTHOR( DRIVER_AUTHOR
);
537 MODULE_DESCRIPTION( DRIVER_DESC
);
538 MODULE_LICENSE("GPL");