Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 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

Linux/drivers/usb/misc/ldusb.c

  1 /**
  2  * Generic USB driver for report based interrupt in/out devices
  3  * like LD Didactic's USB devices. LD Didactic's USB devices are
  4  * HID devices which do not use HID report definitons (they use
  5  * raw interrupt in and our reports only for communication).
  6  *
  7  * This driver uses a ring buffer for time critical reading of
  8  * interrupt in reports and provides read and write methods for
  9  * raw interrupt reports (similar to the Windows HID driver).
 10  * Devices based on the book USB COMPLETE by Jan Axelson may need
 11  * such a compatibility to the Windows HID driver.
 12  *
 13  * Copyright (C) 2005 Michael Hund <mhund@ld-didactic.de>
 14  *
 15  *      This program is free software; you can redistribute it and/or
 16  *      modify it under the terms of the GNU General Public License as
 17  *      published by the Free Software Foundation; either version 2 of
 18  *      the License, or (at your option) any later version.
 19  *
 20  * Derived from Lego USB Tower driver
 21  * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net>
 22  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
 23  */
 24 
 25 #include <linux/kernel.h>
 26 #include <linux/errno.h>
 27 #include <linux/slab.h>
 28 #include <linux/module.h>
 29 #include <linux/mutex.h>
 30 
 31 #include <asm/uaccess.h>
 32 #include <linux/input.h>
 33 #include <linux/usb.h>
 34 #include <linux/poll.h>
 35 
 36 /* Define these values to match your devices */
 37 #define USB_VENDOR_ID_LD                0x0f11  /* USB Vendor ID of LD Didactic GmbH */
 38 #define USB_DEVICE_ID_LD_CASSY          0x1000  /* USB Product ID of CASSY-S modules with 8 bytes endpoint size */
 39 #define USB_DEVICE_ID_LD_CASSY2         0x1001  /* USB Product ID of CASSY-S modules with 64 bytes endpoint size */
 40 #define USB_DEVICE_ID_LD_POCKETCASSY    0x1010  /* USB Product ID of Pocket-CASSY */
 41 #define USB_DEVICE_ID_LD_POCKETCASSY2   0x1011  /* USB Product ID of Pocket-CASSY 2 (reserved) */
 42 #define USB_DEVICE_ID_LD_MOBILECASSY    0x1020  /* USB Product ID of Mobile-CASSY */
 43 #define USB_DEVICE_ID_LD_MOBILECASSY2   0x1021  /* USB Product ID of Mobile-CASSY 2 (reserved) */
 44 #define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE      0x1031  /* USB Product ID of Micro-CASSY Voltage */
 45 #define USB_DEVICE_ID_LD_MICROCASSYCURRENT      0x1032  /* USB Product ID of Micro-CASSY Current */
 46 #define USB_DEVICE_ID_LD_MICROCASSYTIME         0x1033  /* USB Product ID of Micro-CASSY Time (reserved) */
 47 #define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE  0x1035  /* USB Product ID of Micro-CASSY Temperature */
 48 #define USB_DEVICE_ID_LD_MICROCASSYPH           0x1038  /* USB Product ID of Micro-CASSY pH */
 49 #define USB_DEVICE_ID_LD_JWM            0x1080  /* USB Product ID of Joule and Wattmeter */
 50 #define USB_DEVICE_ID_LD_DMMP           0x1081  /* USB Product ID of Digital Multimeter P (reserved) */
 51 #define USB_DEVICE_ID_LD_UMIP           0x1090  /* USB Product ID of UMI P */
 52 #define USB_DEVICE_ID_LD_UMIC           0x10A0  /* USB Product ID of UMI C */
 53 #define USB_DEVICE_ID_LD_UMIB           0x10B0  /* USB Product ID of UMI B */
 54 #define USB_DEVICE_ID_LD_XRAY           0x1100  /* USB Product ID of X-Ray Apparatus 55481 */
 55 #define USB_DEVICE_ID_LD_XRAY2          0x1101  /* USB Product ID of X-Ray Apparatus 554800 */
 56 #define USB_DEVICE_ID_LD_XRAYCT         0x1110  /* USB Product ID of X-Ray Apparatus CT 554821*/
 57 #define USB_DEVICE_ID_LD_VIDEOCOM       0x1200  /* USB Product ID of VideoCom */
 58 #define USB_DEVICE_ID_LD_MOTOR          0x1210  /* USB Product ID of Motor (reserved) */
 59 #define USB_DEVICE_ID_LD_COM3LAB        0x2000  /* USB Product ID of COM3LAB */
 60 #define USB_DEVICE_ID_LD_TELEPORT       0x2010  /* USB Product ID of Terminal Adapter */
 61 #define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020 /* USB Product ID of Network Analyser */
 62 #define USB_DEVICE_ID_LD_POWERCONTROL   0x2030  /* USB Product ID of Converter Control Unit */
 63 #define USB_DEVICE_ID_LD_MACHINETEST    0x2040  /* USB Product ID of Machine Test System */
 64 #define USB_DEVICE_ID_LD_MOSTANALYSER   0x2050  /* USB Product ID of MOST Protocol Analyser */
 65 #define USB_DEVICE_ID_LD_MOSTANALYSER2  0x2051  /* USB Product ID of MOST Protocol Analyser 2 */
 66 #define USB_DEVICE_ID_LD_ABSESP         0x2060  /* USB Product ID of ABS ESP */
 67 #define USB_DEVICE_ID_LD_AUTODATABUS    0x2070  /* USB Product ID of Automotive Data Buses */
 68 #define USB_DEVICE_ID_LD_MCT            0x2080  /* USB Product ID of Microcontroller technique */
 69 #define USB_DEVICE_ID_LD_HYBRID         0x2090  /* USB Product ID of Automotive Hybrid */
 70 #define USB_DEVICE_ID_LD_HEATCONTROL    0x20A0  /* USB Product ID of Heat control */
 71 
 72 #define USB_VENDOR_ID_VERNIER           0x08f7
 73 #define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
 74 #define USB_DEVICE_ID_VERNIER_SKIP      0x0003
 75 #define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
 76 #define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
 77 
 78 #ifdef CONFIG_USB_DYNAMIC_MINORS
 79 #define USB_LD_MINOR_BASE       0
 80 #else
 81 #define USB_LD_MINOR_BASE       176
 82 #endif
 83 
 84 /* table of devices that work with this driver */
 85 static const struct usb_device_id ld_usb_table[] = {
 86         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
 87         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
 88         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
 89         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
 90         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
 91         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
 92         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
 93         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
 94         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
 95         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
 96         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
 97         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
 98         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
 99         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
100         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
101         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
102         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
103         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
104         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
105         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
106         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
107         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
108         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
109         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
110         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
111         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
112         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
113         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
114         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
115         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
116         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
117         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
118         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
119         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
120         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
121         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
122         { }                                     /* Terminating entry */
123 };
124 MODULE_DEVICE_TABLE(usb, ld_usb_table);
125 MODULE_VERSION("V0.14");
126 MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");
127 MODULE_DESCRIPTION("LD USB Driver");
128 MODULE_LICENSE("GPL");
129 MODULE_SUPPORTED_DEVICE("LD USB Devices");
130 
131 /* All interrupt in transfers are collected in a ring buffer to
132  * avoid racing conditions and get better performance of the driver.
133  */
134 static int ring_buffer_size = 128;
135 module_param(ring_buffer_size, int, 0);
136 MODULE_PARM_DESC(ring_buffer_size, "Read ring buffer size in reports");
137 
138 /* The write_buffer can contain more than one interrupt out transfer.
139  */
140 static int write_buffer_size = 10;
141 module_param(write_buffer_size, int, 0);
142 MODULE_PARM_DESC(write_buffer_size, "Write buffer size in reports");
143 
144 /* As of kernel version 2.6.4 ehci-hcd uses an
145  * "only one interrupt transfer per frame" shortcut
146  * to simplify the scheduling of periodic transfers.
147  * This conflicts with our standard 1ms intervals for in and out URBs.
148  * We use default intervals of 2ms for in and 2ms for out transfers,
149  * which should be fast enough.
150  * Increase the interval to allow more devices that do interrupt transfers,
151  * or set to 1 to use the standard interval from the endpoint descriptors.
152  */
153 static int min_interrupt_in_interval = 2;
154 module_param(min_interrupt_in_interval, int, 0);
155 MODULE_PARM_DESC(min_interrupt_in_interval, "Minimum interrupt in interval in ms");
156 
157 static int min_interrupt_out_interval = 2;
158 module_param(min_interrupt_out_interval, int, 0);
159 MODULE_PARM_DESC(min_interrupt_out_interval, "Minimum interrupt out interval in ms");
160 
161 /* Structure to hold all of our device specific stuff */
162 struct ld_usb {
163         struct mutex            mutex;          /* locks this structure */
164         struct usb_interface*   intf;           /* save off the usb interface pointer */
165 
166         int                     open_count;     /* number of times this port has been opened */
167 
168         char*                   ring_buffer;
169         unsigned int            ring_head;
170         unsigned int            ring_tail;
171 
172         wait_queue_head_t       read_wait;
173         wait_queue_head_t       write_wait;
174 
175         char*                   interrupt_in_buffer;
176         struct usb_endpoint_descriptor* interrupt_in_endpoint;
177         struct urb*             interrupt_in_urb;
178         int                     interrupt_in_interval;
179         size_t                  interrupt_in_endpoint_size;
180         int                     interrupt_in_running;
181         int                     interrupt_in_done;
182         int                     buffer_overflow;
183         spinlock_t              rbsl;
184 
185         char*                   interrupt_out_buffer;
186         struct usb_endpoint_descriptor* interrupt_out_endpoint;
187         struct urb*             interrupt_out_urb;
188         int                     interrupt_out_interval;
189         size_t                  interrupt_out_endpoint_size;
190         int                     interrupt_out_busy;
191 };
192 
193 static struct usb_driver ld_usb_driver;
194 
195 /**
196  *      ld_usb_abort_transfers
197  *      aborts transfers and frees associated data structures
198  */
199 static void ld_usb_abort_transfers(struct ld_usb *dev)
200 {
201         /* shutdown transfer */
202         if (dev->interrupt_in_running) {
203                 dev->interrupt_in_running = 0;
204                 if (dev->intf)
205                         usb_kill_urb(dev->interrupt_in_urb);
206         }
207         if (dev->interrupt_out_busy)
208                 if (dev->intf)
209                         usb_kill_urb(dev->interrupt_out_urb);
210 }
211 
212 /**
213  *      ld_usb_delete
214  */
215 static void ld_usb_delete(struct ld_usb *dev)
216 {
217         ld_usb_abort_transfers(dev);
218 
219         /* free data structures */
220         usb_free_urb(dev->interrupt_in_urb);
221         usb_free_urb(dev->interrupt_out_urb);
222         kfree(dev->ring_buffer);
223         kfree(dev->interrupt_in_buffer);
224         kfree(dev->interrupt_out_buffer);
225         kfree(dev);
226 }
227 
228 /**
229  *      ld_usb_interrupt_in_callback
230  */
231 static void ld_usb_interrupt_in_callback(struct urb *urb)
232 {
233         struct ld_usb *dev = urb->context;
234         size_t *actual_buffer;
235         unsigned int next_ring_head;
236         int status = urb->status;
237         int retval;
238 
239         if (status) {
240                 if (status == -ENOENT ||
241                     status == -ECONNRESET ||
242                     status == -ESHUTDOWN) {
243                         goto exit;
244                 } else {
245                         dev_dbg(&dev->intf->dev,
246                                 "%s: nonzero status received: %d\n", __func__,
247                                 status);
248                         spin_lock(&dev->rbsl);
249                         goto resubmit; /* maybe we can recover */
250                 }
251         }
252 
253         spin_lock(&dev->rbsl);
254         if (urb->actual_length > 0) {
255                 next_ring_head = (dev->ring_head+1) % ring_buffer_size;
256                 if (next_ring_head != dev->ring_tail) {
257                         actual_buffer = (size_t*)(dev->ring_buffer + dev->ring_head*(sizeof(size_t)+dev->interrupt_in_endpoint_size));
258                         /* actual_buffer gets urb->actual_length + interrupt_in_buffer */
259                         *actual_buffer = urb->actual_length;
260                         memcpy(actual_buffer+1, dev->interrupt_in_buffer, urb->actual_length);
261                         dev->ring_head = next_ring_head;
262                         dev_dbg(&dev->intf->dev, "%s: received %d bytes\n",
263                                 __func__, urb->actual_length);
264                 } else {
265                         dev_warn(&dev->intf->dev,
266                                  "Ring buffer overflow, %d bytes dropped\n",
267                                  urb->actual_length);
268                         dev->buffer_overflow = 1;
269                 }
270         }
271 
272 resubmit:
273         /* resubmit if we're still running */
274         if (dev->interrupt_in_running && !dev->buffer_overflow && dev->intf) {
275                 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
276                 if (retval) {
277                         dev_err(&dev->intf->dev,
278                                 "usb_submit_urb failed (%d)\n", retval);
279                         dev->buffer_overflow = 1;
280                 }
281         }
282         spin_unlock(&dev->rbsl);
283 exit:
284         dev->interrupt_in_done = 1;
285         wake_up_interruptible(&dev->read_wait);
286 }
287 
288 /**
289  *      ld_usb_interrupt_out_callback
290  */
291 static void ld_usb_interrupt_out_callback(struct urb *urb)
292 {
293         struct ld_usb *dev = urb->context;
294         int status = urb->status;
295 
296         /* sync/async unlink faults aren't errors */
297         if (status && !(status == -ENOENT ||
298                         status == -ECONNRESET ||
299                         status == -ESHUTDOWN))
300                 dev_dbg(&dev->intf->dev,
301                         "%s - nonzero write interrupt status received: %d\n",
302                         __func__, status);
303 
304         dev->interrupt_out_busy = 0;
305         wake_up_interruptible(&dev->write_wait);
306 }
307 
308 /**
309  *      ld_usb_open
310  */
311 static int ld_usb_open(struct inode *inode, struct file *file)
312 {
313         struct ld_usb *dev;
314         int subminor;
315         int retval;
316         struct usb_interface *interface;
317 
318         nonseekable_open(inode, file);
319         subminor = iminor(inode);
320 
321         interface = usb_find_interface(&ld_usb_driver, subminor);
322 
323         if (!interface) {
324                 printk(KERN_ERR "%s - error, can't find device for minor %d\n",
325                        __func__, subminor);
326                 return -ENODEV;
327         }
328 
329         dev = usb_get_intfdata(interface);
330 
331         if (!dev)
332                 return -ENODEV;
333 
334         /* lock this device */
335         if (mutex_lock_interruptible(&dev->mutex))
336                 return -ERESTARTSYS;
337 
338         /* allow opening only once */
339         if (dev->open_count) {
340                 retval = -EBUSY;
341                 goto unlock_exit;
342         }
343         dev->open_count = 1;
344 
345         /* initialize in direction */
346         dev->ring_head = 0;
347         dev->ring_tail = 0;
348         dev->buffer_overflow = 0;
349         usb_fill_int_urb(dev->interrupt_in_urb,
350                          interface_to_usbdev(interface),
351                          usb_rcvintpipe(interface_to_usbdev(interface),
352                                         dev->interrupt_in_endpoint->bEndpointAddress),
353                          dev->interrupt_in_buffer,
354                          dev->interrupt_in_endpoint_size,
355                          ld_usb_interrupt_in_callback,
356                          dev,
357                          dev->interrupt_in_interval);
358 
359         dev->interrupt_in_running = 1;
360         dev->interrupt_in_done = 0;
361 
362         retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
363         if (retval) {
364                 dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d\n", retval);
365                 dev->interrupt_in_running = 0;
366                 dev->open_count = 0;
367                 goto unlock_exit;
368         }
369 
370         /* save device in the file's private structure */
371         file->private_data = dev;
372 
373 unlock_exit:
374         mutex_unlock(&dev->mutex);
375 
376         return retval;
377 }
378 
379 /**
380  *      ld_usb_release
381  */
382 static int ld_usb_release(struct inode *inode, struct file *file)
383 {
384         struct ld_usb *dev;
385         int retval = 0;
386 
387         dev = file->private_data;
388 
389         if (dev == NULL) {
390                 retval = -ENODEV;
391                 goto exit;
392         }
393 
394         if (mutex_lock_interruptible(&dev->mutex)) {
395                 retval = -ERESTARTSYS;
396                 goto exit;
397         }
398 
399         if (dev->open_count != 1) {
400                 retval = -ENODEV;
401                 goto unlock_exit;
402         }
403         if (dev->intf == NULL) {
404                 /* the device was unplugged before the file was released */
405                 mutex_unlock(&dev->mutex);
406                 /* unlock here as ld_usb_delete frees dev */
407                 ld_usb_delete(dev);
408                 goto exit;
409         }
410 
411         /* wait until write transfer is finished */
412         if (dev->interrupt_out_busy)
413                 wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);
414         ld_usb_abort_transfers(dev);
415         dev->open_count = 0;
416 
417 unlock_exit:
418         mutex_unlock(&dev->mutex);
419 
420 exit:
421         return retval;
422 }
423 
424 /**
425  *      ld_usb_poll
426  */
427 static unsigned int ld_usb_poll(struct file *file, poll_table *wait)
428 {
429         struct ld_usb *dev;
430         unsigned int mask = 0;
431 
432         dev = file->private_data;
433 
434         if (!dev->intf)
435                 return POLLERR | POLLHUP;
436 
437         poll_wait(file, &dev->read_wait, wait);
438         poll_wait(file, &dev->write_wait, wait);
439 
440         if (dev->ring_head != dev->ring_tail)
441                 mask |= POLLIN | POLLRDNORM;
442         if (!dev->interrupt_out_busy)
443                 mask |= POLLOUT | POLLWRNORM;
444 
445         return mask;
446 }
447 
448 /**
449  *      ld_usb_read
450  */
451 static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
452                            loff_t *ppos)
453 {
454         struct ld_usb *dev;
455         size_t *actual_buffer;
456         size_t bytes_to_read;
457         int retval = 0;
458         int rv;
459 
460         dev = file->private_data;
461 
462         /* verify that we actually have some data to read */
463         if (count == 0)
464                 goto exit;
465 
466         /* lock this object */
467         if (mutex_lock_interruptible(&dev->mutex)) {
468                 retval = -ERESTARTSYS;
469                 goto exit;
470         }
471 
472         /* verify that the device wasn't unplugged */
473         if (dev->intf == NULL) {
474                 retval = -ENODEV;
475                 printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
476                 goto unlock_exit;
477         }
478 
479         /* wait for data */
480         spin_lock_irq(&dev->rbsl);
481         if (dev->ring_head == dev->ring_tail) {
482                 dev->interrupt_in_done = 0;
483                 spin_unlock_irq(&dev->rbsl);
484                 if (file->f_flags & O_NONBLOCK) {
485                         retval = -EAGAIN;
486                         goto unlock_exit;
487                 }
488                 retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done);
489                 if (retval < 0)
490                         goto unlock_exit;
491         } else {
492                 spin_unlock_irq(&dev->rbsl);
493         }
494 
495         /* actual_buffer contains actual_length + interrupt_in_buffer */
496         actual_buffer = (size_t*)(dev->ring_buffer + dev->ring_tail*(sizeof(size_t)+dev->interrupt_in_endpoint_size));
497         bytes_to_read = min(count, *actual_buffer);
498         if (bytes_to_read < *actual_buffer)
499                 dev_warn(&dev->intf->dev, "Read buffer overflow, %zd bytes dropped\n",
500                          *actual_buffer-bytes_to_read);
501 
502         /* copy one interrupt_in_buffer from ring_buffer into userspace */
503         if (copy_to_user(buffer, actual_buffer+1, bytes_to_read)) {
504                 retval = -EFAULT;
505                 goto unlock_exit;
506         }
507         dev->ring_tail = (dev->ring_tail+1) % ring_buffer_size;
508 
509         retval = bytes_to_read;
510 
511         spin_lock_irq(&dev->rbsl);
512         if (dev->buffer_overflow) {
513                 dev->buffer_overflow = 0;
514                 spin_unlock_irq(&dev->rbsl);
515                 rv = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
516                 if (rv < 0)
517                         dev->buffer_overflow = 1;
518         } else {
519                 spin_unlock_irq(&dev->rbsl);
520         }
521 
522 unlock_exit:
523         /* unlock the device */
524         mutex_unlock(&dev->mutex);
525 
526 exit:
527         return retval;
528 }
529 
530 /**
531  *      ld_usb_write
532  */
533 static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
534                             size_t count, loff_t *ppos)
535 {
536         struct ld_usb *dev;
537         size_t bytes_to_write;
538         int retval = 0;
539 
540         dev = file->private_data;
541 
542         /* verify that we actually have some data to write */
543         if (count == 0)
544                 goto exit;
545 
546         /* lock this object */
547         if (mutex_lock_interruptible(&dev->mutex)) {
548                 retval = -ERESTARTSYS;
549                 goto exit;
550         }
551 
552         /* verify that the device wasn't unplugged */
553         if (dev->intf == NULL) {
554                 retval = -ENODEV;
555                 printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
556                 goto unlock_exit;
557         }
558 
559         /* wait until previous transfer is finished */
560         if (dev->interrupt_out_busy) {
561                 if (file->f_flags & O_NONBLOCK) {
562                         retval = -EAGAIN;
563                         goto unlock_exit;
564                 }
565                 retval = wait_event_interruptible(dev->write_wait, !dev->interrupt_out_busy);
566                 if (retval < 0) {
567                         goto unlock_exit;
568                 }
569         }
570 
571         /* write the data into interrupt_out_buffer from userspace */
572         bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size);
573         if (bytes_to_write < count)
574                 dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write);
575         dev_dbg(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n",
576                 __func__, count, bytes_to_write);
577 
578         if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
579                 retval = -EFAULT;
580                 goto unlock_exit;
581         }
582 
583         if (dev->interrupt_out_endpoint == NULL) {
584                 /* try HID_REQ_SET_REPORT=9 on control_endpoint instead of interrupt_out_endpoint */
585                 retval = usb_control_msg(interface_to_usbdev(dev->intf),
586                                          usb_sndctrlpipe(interface_to_usbdev(dev->intf), 0),
587                                          9,
588                                          USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
589                                          1 << 8, 0,
590                                          dev->interrupt_out_buffer,
591                                          bytes_to_write,
592                                          USB_CTRL_SET_TIMEOUT * HZ);
593                 if (retval < 0)
594                         dev_err(&dev->intf->dev,
595                                 "Couldn't submit HID_REQ_SET_REPORT %d\n",
596                                 retval);
597                 goto unlock_exit;
598         }
599 
600         /* send off the urb */
601         usb_fill_int_urb(dev->interrupt_out_urb,
602                          interface_to_usbdev(dev->intf),
603                          usb_sndintpipe(interface_to_usbdev(dev->intf),
604                                         dev->interrupt_out_endpoint->bEndpointAddress),
605                          dev->interrupt_out_buffer,
606                          bytes_to_write,
607                          ld_usb_interrupt_out_callback,
608                          dev,
609                          dev->interrupt_out_interval);
610 
611         dev->interrupt_out_busy = 1;
612         wmb();
613 
614         retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
615         if (retval) {
616                 dev->interrupt_out_busy = 0;
617                 dev_err(&dev->intf->dev,
618                         "Couldn't submit interrupt_out_urb %d\n", retval);
619                 goto unlock_exit;
620         }
621         retval = bytes_to_write;
622 
623 unlock_exit:
624         /* unlock the device */
625         mutex_unlock(&dev->mutex);
626 
627 exit:
628         return retval;
629 }
630 
631 /* file operations needed when we register this driver */
632 static const struct file_operations ld_usb_fops = {
633         .owner =        THIS_MODULE,
634         .read  =        ld_usb_read,
635         .write =        ld_usb_write,
636         .open =         ld_usb_open,
637         .release =      ld_usb_release,
638         .poll =         ld_usb_poll,
639         .llseek =       no_llseek,
640 };
641 
642 /*
643  * usb class driver info in order to get a minor number from the usb core,
644  * and to have the device registered with the driver core
645  */
646 static struct usb_class_driver ld_usb_class = {
647         .name =         "ldusb%d",
648         .fops =         &ld_usb_fops,
649         .minor_base =   USB_LD_MINOR_BASE,
650 };
651 
652 /**
653  *      ld_usb_probe
654  *
655  *      Called by the usb core when a new device is connected that it thinks
656  *      this driver might be interested in.
657  */
658 static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
659 {
660         struct usb_device *udev = interface_to_usbdev(intf);
661         struct ld_usb *dev = NULL;
662         struct usb_host_interface *iface_desc;
663         struct usb_endpoint_descriptor *endpoint;
664         char *buffer;
665         int i;
666         int retval = -ENOMEM;
667 
668         /* allocate memory for our device state and initialize it */
669 
670         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
671         if (dev == NULL) {
672                 dev_err(&intf->dev, "Out of memory\n");
673                 goto exit;
674         }
675         mutex_init(&dev->mutex);
676         spin_lock_init(&dev->rbsl);
677         dev->intf = intf;
678         init_waitqueue_head(&dev->read_wait);
679         init_waitqueue_head(&dev->write_wait);
680 
681         /* workaround for early firmware versions on fast computers */
682         if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VENDOR_ID_LD) &&
683             ((le16_to_cpu(udev->descriptor.idProduct) == USB_DEVICE_ID_LD_CASSY) ||
684              (le16_to_cpu(udev->descriptor.idProduct) == USB_DEVICE_ID_LD_COM3LAB)) &&
685             (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x103)) {
686                 buffer = kmalloc(256, GFP_KERNEL);
687                 if (buffer == NULL) {
688                         dev_err(&intf->dev, "Couldn't allocate string buffer\n");
689                         goto error;
690                 }
691                 /* usb_string makes SETUP+STALL to leave always ControlReadLoop */
692                 usb_string(udev, 255, buffer, 256);
693                 kfree(buffer);
694         }
695 
696         iface_desc = intf->cur_altsetting;
697 
698         /* set up the endpoint information */
699         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
700                 endpoint = &iface_desc->endpoint[i].desc;
701 
702                 if (usb_endpoint_is_int_in(endpoint))
703                         dev->interrupt_in_endpoint = endpoint;
704 
705                 if (usb_endpoint_is_int_out(endpoint))
706                         dev->interrupt_out_endpoint = endpoint;
707         }
708         if (dev->interrupt_in_endpoint == NULL) {
709                 dev_err(&intf->dev, "Interrupt in endpoint not found\n");
710                 goto error;
711         }
712         if (dev->interrupt_out_endpoint == NULL)
713                 dev_warn(&intf->dev, "Interrupt out endpoint not found (using control endpoint instead)\n");
714 
715         dev->interrupt_in_endpoint_size = usb_endpoint_maxp(dev->interrupt_in_endpoint);
716         dev->ring_buffer = kmalloc(ring_buffer_size*(sizeof(size_t)+dev->interrupt_in_endpoint_size), GFP_KERNEL);
717         if (!dev->ring_buffer) {
718                 dev_err(&intf->dev, "Couldn't allocate ring_buffer\n");
719                 goto error;
720         }
721         dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
722         if (!dev->interrupt_in_buffer) {
723                 dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n");
724                 goto error;
725         }
726         dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
727         if (!dev->interrupt_in_urb) {
728                 dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n");
729                 goto error;
730         }
731         dev->interrupt_out_endpoint_size = dev->interrupt_out_endpoint ? usb_endpoint_maxp(dev->interrupt_out_endpoint) :
732                                                                          udev->descriptor.bMaxPacketSize0;
733         dev->interrupt_out_buffer = kmalloc(write_buffer_size*dev->interrupt_out_endpoint_size, GFP_KERNEL);
734         if (!dev->interrupt_out_buffer) {
735                 dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n");
736                 goto error;
737         }
738         dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
739         if (!dev->interrupt_out_urb) {
740                 dev_err(&intf->dev, "Couldn't allocate interrupt_out_urb\n");
741                 goto error;
742         }
743         dev->interrupt_in_interval = min_interrupt_in_interval > dev->interrupt_in_endpoint->bInterval ? min_interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
744         if (dev->interrupt_out_endpoint)
745                 dev->interrupt_out_interval = min_interrupt_out_interval > dev->interrupt_out_endpoint->bInterval ? min_interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
746 
747         /* we can register the device now, as it is ready */
748         usb_set_intfdata(intf, dev);
749 
750         retval = usb_register_dev(intf, &ld_usb_class);
751         if (retval) {
752                 /* something prevented us from registering this driver */
753                 dev_err(&intf->dev, "Not able to get a minor for this device.\n");
754                 usb_set_intfdata(intf, NULL);
755                 goto error;
756         }
757 
758         /* let the user know what node this device is now attached to */
759         dev_info(&intf->dev, "LD USB Device #%d now attached to major %d minor %d\n",
760                 (intf->minor - USB_LD_MINOR_BASE), USB_MAJOR, intf->minor);
761 
762 exit:
763         return retval;
764 
765 error:
766         ld_usb_delete(dev);
767 
768         return retval;
769 }
770 
771 /**
772  *      ld_usb_disconnect
773  *
774  *      Called by the usb core when the device is removed from the system.
775  */
776 static void ld_usb_disconnect(struct usb_interface *intf)
777 {
778         struct ld_usb *dev;
779         int minor;
780 
781         dev = usb_get_intfdata(intf);
782         usb_set_intfdata(intf, NULL);
783 
784         minor = intf->minor;
785 
786         /* give back our minor */
787         usb_deregister_dev(intf, &ld_usb_class);
788 
789         mutex_lock(&dev->mutex);
790 
791         /* if the device is not opened, then we clean up right now */
792         if (!dev->open_count) {
793                 mutex_unlock(&dev->mutex);
794                 ld_usb_delete(dev);
795         } else {
796                 dev->intf = NULL;
797                 /* wake up pollers */
798                 wake_up_interruptible_all(&dev->read_wait);
799                 wake_up_interruptible_all(&dev->write_wait);
800                 mutex_unlock(&dev->mutex);
801         }
802 
803         dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
804                  (minor - USB_LD_MINOR_BASE));
805 }
806 
807 /* usb specific object needed to register this driver with the usb subsystem */
808 static struct usb_driver ld_usb_driver = {
809         .name =         "ldusb",
810         .probe =        ld_usb_probe,
811         .disconnect =   ld_usb_disconnect,
812         .id_table =     ld_usb_table,
813 };
814 
815 module_usb_driver(ld_usb_driver);
816 
817 

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