?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / usb / misc / rio500.c
blobe90a334f7287f49f3e35500bd58f0c443decbf72
1 /* -*- linux-c -*- */
2
3 /*
4 * Driver for USB Rio 500
5 *
6 * Cesar Miquel (miquel@df.uba.ar)
7 *
8 * based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
9 *
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.
14 *
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.
19 *
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.
23 *
24 * Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
25 *
26 * Changelog:
27 * 30/05/2003 replaced lock/unlock kernel with up/down
28 * Daniele Bellucci bellucda@tiscali.it
29 * */
30
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>
43
44 #include "rio500_usb.h"
45
46 /*
47 * Version Information
48 */
49 #define DRIVER_VERSION "v1.1"
50 #define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
51 #define DRIVER_DESC "USB Rio 500 driver"
52
53 #define RIO_MINOR 64
54
55 /* stall/wait timeout for rio */
56 #define NAK_TIMEOUT (HZ)
57
58 #define IBUF_SIZE 0x1000
59
60 /* Size of the rio buffer */
61 #define OBUF_SIZE 0x10000
62
63 struct rio_usb_data {
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 */
72 };
73
74 static struct rio_usb_data rio_instance;
75
76 static int open_rio(struct inode *inode, struct file *file)
77 {
78 struct rio_usb_data *rio = &rio_instance;
79
80 down(&(rio->lock));
81
82 if (rio->isopen || !rio->present) {
83 up(&(rio->lock));
84 return -EBUSY;
85 }
86 rio->isopen = 1;
87
88 init_waitqueue_head(&rio->wait_q);
89
90 up(&(rio->lock));
91
92 info("Rio opened.");
93
94 return 0;
95 }
96
97 static int close_rio(struct inode *inode, struct file *file)
98 {
99 struct rio_usb_data *rio = &rio_instance;
100
101 rio->isopen = 0;
102
103 info("Rio closed.");
104 return 0;
105 }
106
107 static int
108 ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
109 unsigned long arg)
110 {
111 struct RioCommand rio_cmd;
112 struct rio_usb_data *rio = &rio_instance;
113 void __user *data;
114 unsigned char *buffer;
115 int result, requesttype;
116 int retries;
117 int retval=0;
118
119 down(&(rio->lock));
120 /* Sanity check to make sure rio is connected, powered, etc */
121 if ( rio == NULL ||
122 rio->present == 0 ||
123 rio->rio_dev == NULL )
124 {
125 retval = -ENODEV;
126 goto err_out;
127 }
128
129 switch (cmd) {
130 case RIO_RECV_COMMAND:
131 data = (void __user *) arg;
132 if (data == NULL)
133 break;
134 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
135 retval = -EFAULT;
136 goto err_out;
137 }
138 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
139 retval = -EINVAL;
140 goto err_out;
141 }
142 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
143 if (buffer == NULL) {
144 retval = -ENOMEM;
145 goto err_out;
146 }
147 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
148 retval = -EFAULT;
149 free_page((unsigned long) buffer);
150 goto err_out;
151 }
152
153 requesttype = rio_cmd.requesttype | USB_DIR_IN |
154 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
155 dbg
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 */
160 retries = 3;
161 while (retries) {
162 result = usb_control_msg(rio->rio_dev,
163 usb_rcvctrlpipe(rio-> rio_dev, 0),
164 rio_cmd.request,
165 requesttype,
166 rio_cmd.value,
167 rio_cmd.index, buffer,
168 rio_cmd.length,
169 rio_cmd.timeout);
170 if (result == -ETIMEDOUT)
171 retries--;
172 else if (result < 0) {
173 err("Error executing ioctrl. code = %d",
174 le32_to_cpu(result));
175 retries = 0;
176 } else {
177 dbg("Executed ioctl. Result = %d (data=%04x)",
178 le32_to_cpu(result),
179 le32_to_cpu(*((long *) buffer)));
180 if (copy_to_user(rio_cmd.buffer, buffer,
181 rio_cmd.length)) {
182 free_page((unsigned long) buffer);
183 retval = -EFAULT;
184 goto err_out;
185 }
186 retries = 0;
187 }
188
189 /* rio_cmd.buffer contains a raw stream of single byte
190 data which has been returned from rio. Data is
191 interpreted at application level. For data that
192 will be cast to data types longer than 1 byte, data
193 will be little_endian and will potentially need to
194 be swapped at the app level */
195
196 }
197 free_page((unsigned long) buffer);
198 break;
199
200 case RIO_SEND_COMMAND:
201 data = (void __user *) arg;
202 if (data == NULL)
203 break;
204 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
205 retval = -EFAULT;
206 goto err_out;
207 }
208 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
209 retval = -EINVAL;
210 goto err_out;
211 }
212 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
213 if (buffer == NULL) {
214 retval = -ENOMEM;
215 goto err_out;
216 }
217 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
218 free_page((unsigned long)buffer);
219 retval = -EFAULT;
220 goto err_out;
221 }
222
223 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
224 USB_TYPE_VENDOR | USB_RECIP_DEVICE;
225 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
226 requesttype, rio_cmd.request, rio_cmd.value,
227 rio_cmd.index, rio_cmd.length);
228 /* Send rio control message */
229 retries = 3;
230 while (retries) {
231 result = usb_control_msg(rio->rio_dev,
232 usb_sndctrlpipe(rio-> rio_dev, 0),
233 rio_cmd.request,
234 requesttype,
235 rio_cmd.value,
236 rio_cmd.index, buffer,
237 rio_cmd.length,
238 rio_cmd.timeout);
239 if (result == -ETIMEDOUT)
240 retries--;
241 else if (result < 0) {
242 err("Error executing ioctrl. code = %d",
243 le32_to_cpu(result));
244 retries = 0;
245 } else {
246 dbg("Executed ioctl. Result = %d",
247 le32_to_cpu(result));
248 retries = 0;
249
250 }
251
252 }
253 free_page((unsigned long) buffer);
254 break;
255
256 default:
257 retval = -ENOTTY;
258 break;
259 }
260
261
262 err_out:
263 up(&(rio->lock));
264 return retval;
265 }
266
267 static ssize_t
268 write_rio(struct file *file, const char __user *buffer,
269 size_t count, loff_t * ppos)
270 {
271 struct rio_usb_data *rio = &rio_instance;
272
273 unsigned long copy_size;
274 unsigned long bytes_written = 0;
275 unsigned int partial;
276
277 int result = 0;
278 int maxretry;
279 int errn = 0;
280
281 down(&(rio->lock));
282 /* Sanity check to make sure rio is connected, powered, etc */
283 if ( rio == NULL ||
284 rio->present == 0 ||
285 rio->rio_dev == NULL )
286 {
287 up(&(rio->lock));
288 return -ENODEV;
289 }
290
291
292
293 do {
294 unsigned long thistime;
295 char *obuf = rio->obuf;
296
297 thistime = copy_size =
298 (count >= OBUF_SIZE) ? OBUF_SIZE : count;
299 if (copy_from_user(rio->obuf, buffer, copy_size)) {
300 errn = -EFAULT;
301 goto error;
302 }
303 maxretry = 5;
304 while (thistime) {
305 if (!rio->rio_dev) {
306 errn = -ENODEV;
307 goto error;
308 }
309 if (signal_pending(current)) {
310 up(&(rio->lock));
311 return bytes_written ? bytes_written : -EINTR;
312 }
313
314 result = usb_bulk_msg(rio->rio_dev,
315 usb_sndbulkpipe(rio->rio_dev, 2),
316 obuf, thistime, &partial, 5 * HZ);
317
318 dbg("write stats: result:%d thistime:%lu partial:%u",
319 result, thistime, partial);
320
321 if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
322 if (!maxretry--) {
323 errn = -ETIME;
324 goto error;
325 }
326 interruptible_sleep_on_timeout(&rio-> wait_q, NAK_TIMEOUT);
327 continue;
328 } else if (!result && partial) {
329 obuf += partial;
330 thistime -= partial;
331 } else
332 break;
333 };
334 if (result) {
335 err("Write Whoops - %x", result);
336 errn = -EIO;
337 goto error;
338 }
339 bytes_written += copy_size;
340 count -= copy_size;
341 buffer += copy_size;
342 } while (count > 0);
343
344 up(&(rio->lock));
345
346 return bytes_written ? bytes_written : -EIO;
347
348 error:
349 up(&(rio->lock));
350 return errn;
351 }
352
353 static ssize_t
354 read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
355 {
356 struct rio_usb_data *rio = &rio_instance;
357 ssize_t read_count;
358 unsigned int partial;
359 int this_read;
360 int result;
361 int maxretry = 10;
362 char *ibuf;
363
364 down(&(rio->lock));
365 /* Sanity check to make sure rio is connected, powered, etc */
366 if ( rio == NULL ||
367 rio->present == 0 ||
368 rio->rio_dev == NULL )
369 {
370 up(&(rio->lock));
371 return -ENODEV;
372 }
373
374 ibuf = rio->ibuf;
375
376 read_count = 0;
377
378
379 while (count > 0) {
380 if (signal_pending(current)) {
381 up(&(rio->lock));
382 return read_count ? read_count : -EINTR;
383 }
384 if (!rio->rio_dev) {
385 up(&(rio->lock));
386 return -ENODEV;
387 }
388 this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
389
390 result = usb_bulk_msg(rio->rio_dev,
391 usb_rcvbulkpipe(rio->rio_dev, 1),
392 ibuf, this_read, &partial,
393 (int) (HZ * 8));
394
395 dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",
396 result, this_read, partial);
397
398 if (partial) {
399 count = this_read = partial;
400 } else if (result == -ETIMEDOUT || result == 15) { /* FIXME: 15 ??? */
401 if (!maxretry--) {
402 up(&(rio->lock));
403 err("read_rio: maxretry timeout");
404 return -ETIME;
405 }
406 interruptible_sleep_on_timeout(&rio->wait_q,
407 NAK_TIMEOUT);
408 continue;
409 } else if (result != -EREMOTEIO) {
410 up(&(rio->lock));
411 err("Read Whoops - result:%u partial:%u this_read:%u",
412 result, partial, this_read);
413 return -EIO;
414 } else {
415 up(&(rio->lock));
416 return (0);
417 }
418
419 if (this_read) {
420 if (copy_to_user(buffer, ibuf, this_read)) {
421 up(&(rio->lock));
422 return -EFAULT;
423 }
424 count -= this_read;
425 read_count += this_read;
426 buffer += this_read;
427 }
428 }
429 up(&(rio->lock));
430 return read_count;
431 }
432
433 static struct
434 file_operations usb_rio_fops = {
435 .owner = THIS_MODULE,
436 .read = read_rio,
437 .write = write_rio,
438 .ioctl = ioctl_rio,
439 .open = open_rio,
440 .release = close_rio,
441 };
442
443 static struct usb_class_driver usb_rio_class = {
444 .name = "usb/rio500%d",
445 .fops = &usb_rio_fops,
446 .mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
447 .minor_base = RIO_MINOR,
448 };
449
450 static int probe_rio(struct usb_interface *intf,
451 const struct usb_device_id *id)
452 {
453 struct usb_device *dev = interface_to_usbdev(intf);
454 struct rio_usb_data *rio = &rio_instance;
455 int retval;
456
457 info("USB Rio found at address %d", dev->devnum);
458
459 retval = usb_register_dev(intf, &usb_rio_class);
460 if (retval) {
461 err("Not able to get a minor for this device.");
462 return -ENOMEM;
463 }
464
465 rio->rio_dev = dev;
466
467 if (!(rio->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {
468 err("probe_rio: Not enough memory for the output buffer");
469 usb_deregister_dev(intf, &usb_rio_class);
470 return -ENOMEM;
471 }
472 dbg("probe_rio: obuf address:%p", rio->obuf);
473
474 if (!(rio->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {
475 err("probe_rio: Not enough memory for the input buffer");
476 usb_deregister_dev(intf, &usb_rio_class);
477 kfree(rio->obuf);
478 return -ENOMEM;
479 }
480 dbg("probe_rio: ibuf address:%p", rio->ibuf);
481
482 init_MUTEX(&(rio->lock));
483
484 usb_set_intfdata (intf, rio);
485 rio->present = 1;
486
487 return 0;
488 }
489
490 static void disconnect_rio(struct usb_interface *intf)
491 {
492 struct rio_usb_data *rio = usb_get_intfdata (intf);
493
494 usb_set_intfdata (intf, NULL);
495 if (rio) {
496 usb_deregister_dev(intf, &usb_rio_class);
497
498 down(&(rio->lock));
499 if (rio->isopen) {
500 rio->isopen = 0;
501 /* better let it finish - the release will do whats needed */
502 rio->rio_dev = NULL;
503 up(&(rio->lock));
504 return;
505 }
506 kfree(rio->ibuf);
507 kfree(rio->obuf);
508
509 info("USB Rio disconnected.");
510
511 rio->present = 0;
512 up(&(rio->lock));
513 }
514 }
515
516 static struct usb_device_id rio_table [] = {
517 { USB_DEVICE(0x0841, 1) }, /* Rio 500 */
518 { } /* Terminating entry */
519 };
520
521 MODULE_DEVICE_TABLE (usb, rio_table);
522
523 static struct usb_driver rio_driver = {
524 .owner = THIS_MODULE,
525 .name = "rio500",
526 .probe = probe_rio,
527 .disconnect = disconnect_rio,
528 .id_table = rio_table,
529 };
530
531 static int __init usb_rio_init(void)
532 {
533 int retval;
534 retval = usb_register(&rio_driver);
535 if (retval)
536 goto out;
537
538 info(DRIVER_VERSION ":" DRIVER_DESC);
539
540 out:
541 return retval;
542 }
543
544
545 static void __exit usb_rio_cleanup(void)
546 {
547 struct rio_usb_data *rio = &rio_instance;
548
549 rio->present = 0;
550 usb_deregister(&rio_driver);
551
552
553 }
554
555 module_init(usb_rio_init);
556 module_exit(usb_rio_cleanup);
557
558 MODULE_AUTHOR( DRIVER_AUTHOR );
559 MODULE_DESCRIPTION( DRIVER_DESC );
560 MODULE_LICENSE("GPL");
561
MOXA 2.6.9 from sdlinux-moxaart.tgz