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/errno.h>
36 #include <linux/random.h>
37 #include <linux/poll.h>
38 #include <linux/init.h>
39 #include <linux/slab.h>
40 #include <linux/spinlock.h>
41 #include <linux/usb.h>
42 #include <linux/smp_lock.h>
44 #include "rio500_usb.h"
49 #define DRIVER_VERSION "v1.1"
50 #define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
51 #define DRIVER_DESC "USB Rio 500 driver"
55 /* stall/wait timeout for rio */
56 #define NAK_TIMEOUT (HZ)
58 #define IBUF_SIZE 0x1000
60 /* Size of the rio buffer */
61 #define OBUF_SIZE 0x10000
64 struct usb_device *rio_dev; /* init: probe_rio */
65 unsigned int ifnum; /* Interface number of the USB device */
66 int isopen; /* nz if open */
67 int present; /* Device is present on the bus */
68 char *obuf, *ibuf; /* transfer buffers */
69 char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
70 wait_queue_head_t wait_q; /* for timeouts */
71 struct semaphore lock; /* general race avoidance */
74 static struct rio_usb_data rio_instance;
76 static int open_rio(struct inode *inode, struct file *file)
78 struct rio_usb_data *rio = &rio_instance;
82 if (rio->isopen || !rio->present) {
88 init_waitqueue_head(&rio->wait_q);
97 static int close_rio(struct inode *inode, struct file *file)
99 struct rio_usb_data *rio = &rio_instance;
108 ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
111 struct RioCommand rio_cmd;
112 struct rio_usb_data *rio = &rio_instance;
114 unsigned char *buffer;
115 int result, requesttype;
120 /* Sanity check to make sure rio is connected, powered, etc */
123 rio->rio_dev == NULL )
130 case RIO_RECV_COMMAND:
131 data = (void __user *) arg;
134 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
138 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
142 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
143 if (buffer == NULL) {
147 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
149 free_page((unsigned long) buffer);
153 requesttype = rio_cmd.requesttype | USB_DIR_IN |
154 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
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 */
162 result = usb_control_msg(rio->rio_dev,
163 usb_rcvctrlpipe(rio-> rio_dev, 0),
167 rio_cmd.index, buffer,
170 if (result == -ETIMEDOUT)
172 else if (result < 0) {
173 err("Error executing ioctrl. code = %d", result);
176 dbg("Executed ioctl. Result = %d (data=%02x)",
178 if (copy_to_user(rio_cmd.buffer, buffer,
180 free_page((unsigned long) buffer);
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 */
195 free_page((unsigned long) buffer);
198 case RIO_SEND_COMMAND:
199 data = (void __user *) arg;
202 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
206 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
210 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
211 if (buffer == NULL) {
215 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
216 free_page((unsigned long)buffer);
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 */
229 result = usb_control_msg(rio->rio_dev,
230 usb_sndctrlpipe(rio-> rio_dev, 0),
234 rio_cmd.index, buffer,
237 if (result == -ETIMEDOUT)
239 else if (result < 0) {
240 err("Error executing ioctrl. code = %d", result);
243 dbg("Executed ioctl. Result = %d", result);
249 free_page((unsigned long) buffer);
264 write_rio(struct file *file, const char __user *buffer,
265 size_t count, loff_t * ppos)
267 struct rio_usb_data *rio = &rio_instance;
269 unsigned long copy_size;
270 unsigned long bytes_written = 0;
271 unsigned int partial;
278 /* Sanity check to make sure rio is connected, powered, etc */
281 rio->rio_dev == NULL )
290 unsigned long thistime;
291 char *obuf = rio->obuf;
293 thistime = copy_size =
294 (count >= OBUF_SIZE) ? OBUF_SIZE : count;
295 if (copy_from_user(rio->obuf, buffer, copy_size)) {
305 if (signal_pending(current)) {
307 return bytes_written ? bytes_written : -EINTR;
310 result = usb_bulk_msg(rio->rio_dev,
311 usb_sndbulkpipe(rio->rio_dev, 2),
312 obuf, thistime, &partial, 5 * HZ);
314 dbg("write stats: result:%d thistime:%lu partial:%u",
315 result, thistime, partial);
317 if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
322 interruptible_sleep_on_timeout(&rio-> wait_q, NAK_TIMEOUT);
324 } else if (!result && partial) {
331 err("Write Whoops - %x", result);
335 bytes_written += copy_size;
342 return bytes_written ? bytes_written : -EIO;
350 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
352 struct rio_usb_data *rio = &rio_instance;
354 unsigned int partial;
361 /* Sanity check to make sure rio is connected, powered, etc */
364 rio->rio_dev == NULL )
376 if (signal_pending(current)) {
378 return read_count ? read_count : -EINTR;
384 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
386 result = usb_bulk_msg(rio->rio_dev,
387 usb_rcvbulkpipe(rio->rio_dev, 1),
388 ibuf, this_read, &partial,
391 dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",
392 result, this_read, partial);
395 count = this_read = partial;
396 } else if (result == -ETIMEDOUT || result == 15) { /* FIXME: 15 ??? */
399 err("read_rio: maxretry timeout");
402 interruptible_sleep_on_timeout(&rio->wait_q,
405 } else if (result != -EREMOTEIO) {
407 err("Read Whoops - result:%u partial:%u this_read:%u",
408 result, partial, this_read);
416 if (copy_to_user(buffer, ibuf, this_read)) {
421 read_count += this_read;
430 file_operations usb_rio_fops = {
431 .owner = THIS_MODULE,
436 .release = close_rio,
439 static struct usb_class_driver usb_rio_class = {
440 .name = "usb/rio500%d",
441 .fops = &usb_rio_fops,
442 .mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
443 .minor_base = RIO_MINOR,
446 static int probe_rio(struct usb_interface *intf,
447 const struct usb_device_id *id)
449 struct usb_device *dev = interface_to_usbdev(intf);
450 struct rio_usb_data *rio = &rio_instance;
453 info("USB Rio found at address %d", dev->devnum);
455 retval = usb_register_dev(intf, &usb_rio_class);
457 err("Not able to get a minor for this device.");
463 if (!(rio->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {
464 err("probe_rio: Not enough memory for the output buffer");
465 usb_deregister_dev(intf, &usb_rio_class);
468 dbg("probe_rio: obuf address:%p", rio->obuf);
470 if (!(rio->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {
471 err("probe_rio: Not enough memory for the input buffer");
472 usb_deregister_dev(intf, &usb_rio_class);
476 dbg("probe_rio: ibuf address:%p", rio->ibuf);
478 init_MUTEX(&(rio->lock));
480 usb_set_intfdata (intf, rio);
486 static void disconnect_rio(struct usb_interface *intf)
488 struct rio_usb_data *rio = usb_get_intfdata (intf);
490 usb_set_intfdata (intf, NULL);
492 usb_deregister_dev(intf, &usb_rio_class);
497 /* better let it finish - the release will do whats needed */
505 info("USB Rio disconnected.");
512 static struct usb_device_id rio_table [] = {
513 { USB_DEVICE(0x0841, 1) }, /* Rio 500 */
514 { } /* Terminating entry */
517 MODULE_DEVICE_TABLE (usb, rio_table);
519 static struct usb_driver rio_driver = {
520 .owner = THIS_MODULE,
523 .disconnect = disconnect_rio,
524 .id_table = rio_table,
527 static int __init usb_rio_init(void)
530 retval = usb_register(&rio_driver);
534 info(DRIVER_VERSION ":" DRIVER_DESC);
541 static void __exit usb_rio_cleanup(void)
543 struct rio_usb_data *rio = &rio_instance;
546 usb_deregister(&rio_driver);
551 module_init(usb_rio_init);
552 module_exit(usb_rio_cleanup);
554 MODULE_AUTHOR( DRIVER_AUTHOR );
555 MODULE_DESCRIPTION( DRIVER_DESC );
556 MODULE_LICENSE("GPL");