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