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