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