Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us