Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 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         mutex_lock(&(rio->lock));
120         /* Sanity check to make sure rio is connected, powered, etc */
121         if (rio->present == 0 || rio->rio_dev == NULL) {
122                 retval = -ENODEV;
123                 goto err_out;
124         }
125 
126         switch (cmd) {
127         case RIO_RECV_COMMAND:
128                 data = (void __user *) arg;
129                 if (data == NULL)
130                         break;
131                 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
132                         retval = -EFAULT;
133                         goto err_out;
134                 }
135                 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
136                         retval = -EINVAL;
137                         goto err_out;
138                 }
139                 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
140                 if (buffer == NULL) {
141                         retval = -ENOMEM;
142                         goto err_out;
143                 }
144                 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
145                         retval = -EFAULT;
146                         free_page((unsigned long) buffer);
147                         goto err_out;
148                 }
149 
150                 requesttype = rio_cmd.requesttype | USB_DIR_IN |
151                     USB_TYPE_VENDOR | USB_RECIP_DEVICE;
152                 dbg
153                     ("sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
154                      requesttype, rio_cmd.request, rio_cmd.value,
155                      rio_cmd.index, rio_cmd.length);
156                 /* Send rio control message */
157                 retries = 3;
158                 while (retries) {
159                         result = usb_control_msg(rio->rio_dev,
160                                                  usb_rcvctrlpipe(rio-> rio_dev, 0),
161                                                  rio_cmd.request,
162                                                  requesttype,
163                                                  rio_cmd.value,
164                                                  rio_cmd.index, buffer,
165                                                  rio_cmd.length,
166                                                  jiffies_to_msecs(rio_cmd.timeout));
167                         if (result == -ETIMEDOUT)
168                                 retries--;
169                         else if (result < 0) {
170                                 err("Error executing ioctrl. code = %d", result);
171                                 retries = 0;
172                         } else {
173                                 dbg("Executed ioctl. Result = %d (data=%02x)",
174                                      result, buffer[0]);
175                                 if (copy_to_user(rio_cmd.buffer, buffer,
176                                                  rio_cmd.length)) {
177                                         free_page((unsigned long) buffer);
178                                         retval = -EFAULT;
179                                         goto err_out;
180                                 }
181                                 retries = 0;
182                         }
183 
184                         /* rio_cmd.buffer contains a raw stream of single byte
185                            data which has been returned from rio.  Data is
186                            interpreted at application level.  For data that
187                            will be cast to data types longer than 1 byte, data
188                            will be little_endian and will potentially need to
189                            be swapped at the app level */
190 
191                 }
192                 free_page((unsigned long) buffer);
193                 break;
194 
195         case RIO_SEND_COMMAND:
196                 data = (void __user *) arg;
197                 if (data == NULL)
198                         break;
199                 if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
200                         retval = -EFAULT;
201                         goto err_out;
202                 }
203                 if (rio_cmd.length < 0 || rio_cmd.length > PAGE_SIZE) {
204                         retval = -EINVAL;
205                         goto err_out;
206                 }
207                 buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
208                 if (buffer == NULL) {
209                         retval = -ENOMEM;
210                         goto err_out;
211                 }
212                 if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
213                         free_page((unsigned long)buffer);
214                         retval = -EFAULT;
215                         goto err_out;
216                 }
217 
218                 requesttype = rio_cmd.requesttype | USB_DIR_OUT |
219                     USB_TYPE_VENDOR | USB_RECIP_DEVICE;
220                 dbg("sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x",
221                      requesttype, rio_cmd.request, rio_cmd.value,
222                      rio_cmd.index, rio_cmd.length);
223                 /* Send rio control message */
224                 retries = 3;
225                 while (retries) {
226                         result = usb_control_msg(rio->rio_dev,
227                                                  usb_sndctrlpipe(rio-> rio_dev, 0),
228                                                  rio_cmd.request,
229                                                  requesttype,
230                                                  rio_cmd.value,
231                                                  rio_cmd.index, buffer,
232                                                  rio_cmd.length,
233                                                  jiffies_to_msecs(rio_cmd.timeout));
234                         if (result == -ETIMEDOUT)
235                                 retries--;
236                         else if (result < 0) {
237                                 err("Error executing ioctrl. code = %d", result);
238                                 retries = 0;
239                         } else {
240                                 dbg("Executed ioctl. Result = %d", result);
241                                 retries = 0;
242 
243                         }
244 
245                 }
246                 free_page((unsigned long) buffer);
247                 break;
248 
249         default:
250                 retval = -ENOTTY;
251                 break;
252         }
253 
254 
255 err_out:
256         mutex_unlock(&(rio->lock));
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         .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 
558 
  This page was automatically generated by the LXR engine.