projects / GitHub / MotorolaMobilityLLC / kernel-slsi.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
libata: implement EH fast drain
[GitHub/MotorolaMobilityLLC/kernel-slsi.git] / drivers / usb / misc / adutux.c
1 /*
2 * adutux - driver for ADU devices from Ontrak Control Systems
3 * This is an experimental driver. Use at your own risk.
4 * This driver is not supported by Ontrak Control Systems.
5 *
6 * Copyright (c) 2003 John Homppi (SCO, leave this notice here)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * derived from the Lego USB Tower driver 0.56:
14 * Copyright (c) 2003 David Glance <davidgsf@sourceforge.net>
15 * 2001 Juergen Stuber <stuber@loria.fr>
16 * that was derived from USB Skeleton driver - 0.5
17 * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com)
18 *
19 */
20
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <linux/usb.h>
27 #include <asm/uaccess.h>
28
29 #ifdef CONFIG_USB_DEBUG
30 static int debug = 5;
31 #else
32 static int debug = 1;
33 #endif
34
35 /* Use our own dbg macro */
36 #undef dbg
37 #define dbg(lvl, format, arg...) \
38 do { \
39 if (debug >= lvl) \
40 printk(KERN_DEBUG __FILE__ " : " format " \n", ## arg); \
41 } while (0)
42
43
44 /* Version Information */
45 #define DRIVER_VERSION "v0.0.13"
46 #define DRIVER_AUTHOR "John Homppi"
47 #define DRIVER_DESC "adutux (see www.ontrak.net)"
48
49 /* Module parameters */
50 module_param(debug, int, S_IRUGO | S_IWUSR);
51 MODULE_PARM_DESC(debug, "Debug enabled or not");
52
53 /* Define these values to match your device */
54 #define ADU_VENDOR_ID 0x0a07
55 #define ADU_PRODUCT_ID 0x0064
56
57 /* table of devices that work with this driver */
58 static struct usb_device_id device_table [] = {
59 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID) }, /* ADU100 */
60 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+20) }, /* ADU120 */
61 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+30) }, /* ADU130 */
62 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+100) }, /* ADU200 */
63 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+108) }, /* ADU208 */
64 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+118) }, /* ADU218 */
65 { }/* Terminating entry */
66 };
67
68 MODULE_DEVICE_TABLE(usb, device_table);
69
70 #ifdef CONFIG_USB_DYNAMIC_MINORS
71 #define ADU_MINOR_BASE 0
72 #else
73 #define ADU_MINOR_BASE 67
74 #endif
75
76 /* we can have up to this number of device plugged in at once */
77 #define MAX_DEVICES 16
78
79 #define COMMAND_TIMEOUT (2*HZ) /* 60 second timeout for a command */
80
81 /* Structure to hold all of our device specific stuff */
82 struct adu_device {
83 struct semaphore sem; /* locks this structure */
84 struct usb_device* udev; /* save off the usb device pointer */
85 struct usb_interface* interface;
86 unsigned char minor; /* the starting minor number for this device */
87 char serial_number[8];
88
89 int open_count; /* number of times this port has been opened */
90
91 char* read_buffer_primary;
92 int read_buffer_length;
93 char* read_buffer_secondary;
94 int secondary_head;
95 int secondary_tail;
96 spinlock_t buflock;
97
98 wait_queue_head_t read_wait;
99 wait_queue_head_t write_wait;
100
101 char* interrupt_in_buffer;
102 struct usb_endpoint_descriptor* interrupt_in_endpoint;
103 struct urb* interrupt_in_urb;
104 int read_urb_finished;
105
106 char* interrupt_out_buffer;
107 struct usb_endpoint_descriptor* interrupt_out_endpoint;
108 struct urb* interrupt_out_urb;
109 };
110
111 static struct usb_driver adu_driver;
112
113 static void adu_debug_data(int level, const char *function, int size,
114 const unsigned char *data)
115 {
116 int i;
117
118 if (debug < level)
119 return;
120
121 printk(KERN_DEBUG __FILE__": %s - length = %d, data = ",
122 function, size);
123 for (i = 0; i < size; ++i)
124 printk("%.2x ", data[i]);
125 printk("\n");
126 }
127
128 /**
129 * adu_abort_transfers
130 * aborts transfers and frees associated data structures
131 */
132 static void adu_abort_transfers(struct adu_device *dev)
133 {
134 dbg(2," %s : enter", __FUNCTION__);
135
136 if (dev == NULL) {
137 dbg(1," %s : dev is null", __FUNCTION__);
138 goto exit;
139 }
140
141 if (dev->udev == NULL) {
142 dbg(1," %s : udev is null", __FUNCTION__);
143 goto exit;
144 }
145
146 dbg(2," %s : udev state %d", __FUNCTION__, dev->udev->state);
147 if (dev->udev->state == USB_STATE_NOTATTACHED) {
148 dbg(1," %s : udev is not attached", __FUNCTION__);
149 goto exit;
150 }
151
152 /* shutdown transfer */
153 usb_unlink_urb(dev->interrupt_in_urb);
154 usb_unlink_urb(dev->interrupt_out_urb);
155
156 exit:
157 dbg(2," %s : leave", __FUNCTION__);
158 }
159
160 static void adu_delete(struct adu_device *dev)
161 {
162 dbg(2, "%s enter", __FUNCTION__);
163
164 adu_abort_transfers(dev);
165
166 /* free data structures */
167 usb_free_urb(dev->interrupt_in_urb);
168 usb_free_urb(dev->interrupt_out_urb);
169 kfree(dev->read_buffer_primary);
170 kfree(dev->read_buffer_secondary);
171 kfree(dev->interrupt_in_buffer);
172 kfree(dev->interrupt_out_buffer);
173 kfree(dev);
174
175 dbg(2, "%s : leave", __FUNCTION__);
176 }
177
178 static void adu_interrupt_in_callback(struct urb *urb)
179 {
180 struct adu_device *dev = urb->context;
181
182 dbg(4," %s : enter, status %d", __FUNCTION__, urb->status);
183 adu_debug_data(5, __FUNCTION__, urb->actual_length,
184 urb->transfer_buffer);
185
186 spin_lock(&dev->buflock);
187
188 if (urb->status != 0) {
189 if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)) {
190 dbg(1," %s : nonzero status received: %d",
191 __FUNCTION__, urb->status);
192 }
193 goto exit;
194 }
195
196 if (urb->actual_length > 0 && dev->interrupt_in_buffer[0] != 0x00) {
197 if (dev->read_buffer_length <
198 (4 * le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize)) -
199 (urb->actual_length)) {
200 memcpy (dev->read_buffer_primary +
201 dev->read_buffer_length,
202 dev->interrupt_in_buffer, urb->actual_length);
203
204 dev->read_buffer_length += urb->actual_length;
205 dbg(2," %s reading %d ", __FUNCTION__,
206 urb->actual_length);
207 } else {
208 dbg(1," %s : read_buffer overflow", __FUNCTION__);
209 }
210 }
211
212 exit:
213 dev->read_urb_finished = 1;
214 spin_unlock(&dev->buflock);
215 /* always wake up so we recover from errors */
216 wake_up_interruptible(&dev->read_wait);
217 adu_debug_data(5, __FUNCTION__, urb->actual_length,
218 urb->transfer_buffer);
219 dbg(4," %s : leave, status %d", __FUNCTION__, urb->status);
220 }
221
222 static void adu_interrupt_out_callback(struct urb *urb)
223 {
224 struct adu_device *dev = urb->context;
225
226 dbg(4," %s : enter, status %d", __FUNCTION__, urb->status);
227 adu_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer);
228
229 if (urb->status != 0) {
230 if ((urb->status != -ENOENT) &&
231 (urb->status != -ECONNRESET)) {
232 dbg(1, " %s :nonzero status received: %d",
233 __FUNCTION__, urb->status);
234 }
235 goto exit;
236 }
237
238 wake_up_interruptible(&dev->write_wait);
239 exit:
240
241 adu_debug_data(5, __FUNCTION__, urb->actual_length,
242 urb->transfer_buffer);
243 dbg(4," %s : leave, status %d", __FUNCTION__, urb->status);
244 }
245
246 static int adu_open(struct inode *inode, struct file *file)
247 {
248 struct adu_device *dev = NULL;
249 struct usb_interface *interface;
250 int subminor;
251 int retval = 0;
252
253 dbg(2,"%s : enter", __FUNCTION__);
254
255 subminor = iminor(inode);
256
257 interface = usb_find_interface(&adu_driver, subminor);
258 if (!interface) {
259 err("%s - error, can't find device for minor %d",
260 __FUNCTION__, subminor);
261 retval = -ENODEV;
262 goto exit_no_device;
263 }
264
265 dev = usb_get_intfdata(interface);
266 if (!dev) {
267 retval = -ENODEV;
268 goto exit_no_device;
269 }
270
271 /* lock this device */
272 if ((retval = down_interruptible(&dev->sem))) {
273 dbg(2, "%s : sem down failed", __FUNCTION__);
274 goto exit_no_device;
275 }
276
277 /* increment our usage count for the device */
278 ++dev->open_count;
279 dbg(2,"%s : open count %d", __FUNCTION__, dev->open_count);
280
281 /* save device in the file's private structure */
282 file->private_data = dev;
283
284 if (dev->open_count == 1) {
285 /* initialize in direction */
286 dev->read_buffer_length = 0;
287
288 /* fixup first read by having urb waiting for it */
289 usb_fill_int_urb(dev->interrupt_in_urb,dev->udev,
290 usb_rcvintpipe(dev->udev,
291 dev->interrupt_in_endpoint->bEndpointAddress),
292 dev->interrupt_in_buffer,
293 le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize),
294 adu_interrupt_in_callback, dev,
295 dev->interrupt_in_endpoint->bInterval);
296 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
297 dev->read_urb_finished = 0;
298 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
299 if (retval)
300 --dev->open_count;
301 }
302 up(&dev->sem);
303
304 exit_no_device:
305 dbg(2,"%s : leave, return value %d ", __FUNCTION__, retval);
306
307 return retval;
308 }
309
310 static int adu_release_internal(struct adu_device *dev)
311 {
312 int retval = 0;
313
314 dbg(2," %s : enter", __FUNCTION__);
315
316 /* decrement our usage count for the device */
317 --dev->open_count;
318 dbg(2," %s : open count %d", __FUNCTION__, dev->open_count);
319 if (dev->open_count <= 0) {
320 adu_abort_transfers(dev);
321 dev->open_count = 0;
322 }
323
324 dbg(2," %s : leave", __FUNCTION__);
325 return retval;
326 }
327
328 static int adu_release(struct inode *inode, struct file *file)
329 {
330 struct adu_device *dev = NULL;
331 int retval = 0;
332
333 dbg(2," %s : enter", __FUNCTION__);
334
335 if (file == NULL) {
336 dbg(1," %s : file is NULL", __FUNCTION__);
337 retval = -ENODEV;
338 goto exit;
339 }
340
341 dev = file->private_data;
342
343 if (dev == NULL) {
344 dbg(1," %s : object is NULL", __FUNCTION__);
345 retval = -ENODEV;
346 goto exit;
347 }
348
349 /* lock our device */
350 down(&dev->sem); /* not interruptible */
351
352 if (dev->open_count <= 0) {
353 dbg(1," %s : device not opened", __FUNCTION__);
354 retval = -ENODEV;
355 goto exit;
356 }
357
358 if (dev->udev == NULL) {
359 /* the device was unplugged before the file was released */
360 up(&dev->sem);
361 adu_delete(dev);
362 dev = NULL;
363 } else {
364 /* do the work */
365 retval = adu_release_internal(dev);
366 }
367
368 exit:
369 if (dev)
370 up(&dev->sem);
371 dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
372 return retval;
373 }
374
375 static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
376 loff_t *ppos)
377 {
378 struct adu_device *dev;
379 size_t bytes_read = 0;
380 size_t bytes_to_read = count;
381 int i;
382 int retval = 0;
383 int timeout = 0;
384 int should_submit = 0;
385 unsigned long flags;
386 DECLARE_WAITQUEUE(wait, current);
387
388 dbg(2," %s : enter, count = %Zd, file=%p", __FUNCTION__, count, file);
389
390 dev = file->private_data;
391 dbg(2," %s : dev=%p", __FUNCTION__, dev);
392 /* lock this object */
393 if (down_interruptible(&dev->sem))
394 return -ERESTARTSYS;
395
396 /* verify that the device wasn't unplugged */
397 if (dev->udev == NULL || dev->minor == 0) {
398 retval = -ENODEV;
399 err("No device or device unplugged %d", retval);
400 goto exit;
401 }
402
403 /* verify that some data was requested */
404 if (count == 0) {
405 dbg(1," %s : read request of 0 bytes", __FUNCTION__);
406 goto exit;
407 }
408
409 timeout = COMMAND_TIMEOUT;
410 dbg(2," %s : about to start looping", __FUNCTION__);
411 while (bytes_to_read) {
412 int data_in_secondary = dev->secondary_tail - dev->secondary_head;
413 dbg(2," %s : while, data_in_secondary=%d, status=%d",
414 __FUNCTION__, data_in_secondary,
415 dev->interrupt_in_urb->status);
416
417 if (data_in_secondary) {
418 /* drain secondary buffer */
419 int amount = bytes_to_read < data_in_secondary ? bytes_to_read : data_in_secondary;
420 i = copy_to_user(buffer, dev->read_buffer_secondary+dev->secondary_head, amount);
421 if (i < 0) {
422 retval = -EFAULT;
423 goto exit;
424 }
425 dev->secondary_head += (amount - i);
426 bytes_read += (amount - i);
427 bytes_to_read -= (amount - i);
428 if (i) {
429 retval = bytes_read ? bytes_read : -EFAULT;
430 goto exit;
431 }
432 } else {
433 /* we check the primary buffer */
434 spin_lock_irqsave (&dev->buflock, flags);
435 if (dev->read_buffer_length) {
436 /* we secure access to the primary */
437 char *tmp;
438 dbg(2," %s : swap, read_buffer_length = %d",
439 __FUNCTION__, dev->read_buffer_length);
440 tmp = dev->read_buffer_secondary;
441 dev->read_buffer_secondary = dev->read_buffer_primary;
442 dev->read_buffer_primary = tmp;
443 dev->secondary_head = 0;
444 dev->secondary_tail = dev->read_buffer_length;
445 dev->read_buffer_length = 0;
446 spin_unlock_irqrestore(&dev->buflock, flags);
447 /* we have a free buffer so use it */
448 should_submit = 1;
449 } else {
450 /* even the primary was empty - we may need to do IO */
451 if (dev->interrupt_in_urb->status == -EINPROGRESS) {
452 /* somebody is doing IO */
453 spin_unlock_irqrestore(&dev->buflock, flags);
454 dbg(2," %s : submitted already", __FUNCTION__);
455 } else {
456 /* we must initiate input */
457 dbg(2," %s : initiate input", __FUNCTION__);
458 dev->read_urb_finished = 0;
459
460 usb_fill_int_urb(dev->interrupt_in_urb,dev->udev,
461 usb_rcvintpipe(dev->udev,
462 dev->interrupt_in_endpoint->bEndpointAddress),
463 dev->interrupt_in_buffer,
464 le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize),
465 adu_interrupt_in_callback,
466 dev,
467 dev->interrupt_in_endpoint->bInterval);
468 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
469 if (!retval) {
470 spin_unlock_irqrestore(&dev->buflock, flags);
471 dbg(2," %s : submitted OK", __FUNCTION__);
472 } else {
473 if (retval == -ENOMEM) {
474 retval = bytes_read ? bytes_read : -ENOMEM;
475 }
476 spin_unlock_irqrestore(&dev->buflock, flags);
477 dbg(2," %s : submit failed", __FUNCTION__);
478 goto exit;
479 }
480 }
481
482 /* we wait for I/O to complete */
483 set_current_state(TASK_INTERRUPTIBLE);
484 add_wait_queue(&dev->read_wait, &wait);
485 if (!dev->read_urb_finished)
486 timeout = schedule_timeout(COMMAND_TIMEOUT);
487 else
488 set_current_state(TASK_RUNNING);
489 remove_wait_queue(&dev->read_wait, &wait);
490
491 if (timeout <= 0) {
492 dbg(2," %s : timeout", __FUNCTION__);
493 retval = bytes_read ? bytes_read : -ETIMEDOUT;
494 goto exit;
495 }
496
497 if (signal_pending(current)) {
498 dbg(2," %s : signal pending", __FUNCTION__);
499 retval = bytes_read ? bytes_read : -EINTR;
500 goto exit;
501 }
502 }
503 }
504 }
505
506 retval = bytes_read;
507 /* if the primary buffer is empty then use it */
508 if (should_submit && !dev->interrupt_in_urb->status==-EINPROGRESS) {
509 usb_fill_int_urb(dev->interrupt_in_urb,dev->udev,
510 usb_rcvintpipe(dev->udev,
511 dev->interrupt_in_endpoint->bEndpointAddress),
512 dev->interrupt_in_buffer,
513 le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize),
514 adu_interrupt_in_callback,
515 dev,
516 dev->interrupt_in_endpoint->bInterval);
517 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
518 dev->read_urb_finished = 0;
519 usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
520 /* we ignore failure */
521 }
522
523 exit:
524 /* unlock the device */
525 up(&dev->sem);
526
527 dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
528 return retval;
529 }
530
531 static ssize_t adu_write(struct file *file, const __user char *buffer,
532 size_t count, loff_t *ppos)
533 {
534 struct adu_device *dev;
535 size_t bytes_written = 0;
536 size_t bytes_to_write;
537 size_t buffer_size;
538 int retval;
539 int timeout = 0;
540
541 dbg(2," %s : enter, count = %Zd", __FUNCTION__, count);
542
543 dev = file->private_data;
544
545 /* lock this object */
546 retval = down_interruptible(&dev->sem);
547 if (retval)
548 goto exit_nolock;
549
550 /* verify that the device wasn't unplugged */
551 if (dev->udev == NULL || dev->minor == 0) {
552 retval = -ENODEV;
553 err("No device or device unplugged %d", retval);
554 goto exit;
555 }
556
557 /* verify that we actually have some data to write */
558 if (count == 0) {
559 dbg(1," %s : write request of 0 bytes", __FUNCTION__);
560 goto exit;
561 }
562
563
564 while (count > 0) {
565 if (dev->interrupt_out_urb->status == -EINPROGRESS) {
566 timeout = COMMAND_TIMEOUT;
567
568 while (timeout > 0) {
569 if (signal_pending(current)) {
570 dbg(1," %s : interrupted", __FUNCTION__);
571 retval = -EINTR;
572 goto exit;
573 }
574 up(&dev->sem);
575 timeout = interruptible_sleep_on_timeout(&dev->write_wait, timeout);
576 retval = down_interruptible(&dev->sem);
577 if (retval) {
578 retval = bytes_written ? bytes_written : retval;
579 goto exit_nolock;
580 }
581 if (timeout > 0) {
582 break;
583 }
584 dbg(1," %s : interrupted timeout: %d", __FUNCTION__, timeout);
585 }
586
587
588 dbg(1," %s : final timeout: %d", __FUNCTION__, timeout);
589
590 if (timeout == 0) {
591 dbg(1, "%s - command timed out.", __FUNCTION__);
592 retval = -ETIMEDOUT;
593 goto exit;
594 }
595
596 dbg(4," %s : in progress, count = %Zd", __FUNCTION__, count);
597
598 } else {
599 dbg(4," %s : sending, count = %Zd", __FUNCTION__, count);
600
601 /* write the data into interrupt_out_buffer from userspace */
602 buffer_size = le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize);
603 bytes_to_write = count > buffer_size ? buffer_size : count;
604 dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
605 __FUNCTION__, buffer_size, count, bytes_to_write);
606
607 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
608 retval = -EFAULT;
609 goto exit;
610 }
611
612 /* send off the urb */
613 usb_fill_int_urb(
614 dev->interrupt_out_urb,
615 dev->udev,
616 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
617 dev->interrupt_out_buffer,
618 bytes_to_write,
619 adu_interrupt_out_callback,
620 dev,
621 dev->interrupt_in_endpoint->bInterval);
622 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
623 dev->interrupt_out_urb->actual_length = bytes_to_write;
624 retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
625 if (retval < 0) {
626 err("Couldn't submit interrupt_out_urb %d", retval);
627 goto exit;
628 }
629
630 buffer += bytes_to_write;
631 count -= bytes_to_write;
632
633 bytes_written += bytes_to_write;
634 }
635 }
636
637 retval = bytes_written;
638
639 exit:
640 /* unlock the device */
641 up(&dev->sem);
642 exit_nolock:
643
644 dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
645
646 return retval;
647 }
648
649 /* file operations needed when we register this driver */
650 static const struct file_operations adu_fops = {
651 .owner = THIS_MODULE,
652 .read = adu_read,
653 .write = adu_write,
654 .open = adu_open,
655 .release = adu_release,
656 };
657
658 /*
659 * usb class driver info in order to get a minor number from the usb core,
660 * and to have the device registered with devfs and the driver core
661 */
662 static struct usb_class_driver adu_class = {
663 .name = "usb/adutux%d",
664 .fops = &adu_fops,
665 .minor_base = ADU_MINOR_BASE,
666 };
667
668 /**
669 * adu_probe
670 *
671 * Called by the usb core when a new device is connected that it thinks
672 * this driver might be interested in.
673 */
674 static int adu_probe(struct usb_interface *interface,
675 const struct usb_device_id *id)
676 {
677 struct usb_device *udev = interface_to_usbdev(interface);
678 struct adu_device *dev = NULL;
679 struct usb_host_interface *iface_desc;
680 struct usb_endpoint_descriptor *endpoint;
681 int retval = -ENODEV;
682 int in_end_size;
683 int out_end_size;
684 int i;
685
686 dbg(2," %s : enter", __FUNCTION__);
687
688 if (udev == NULL) {
689 dev_err(&interface->dev, "udev is NULL.\n");
690 goto exit;
691 }
692
693 /* allocate memory for our device state and intialize it */
694 dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
695 if (dev == NULL) {
696 dev_err(&interface->dev, "Out of memory\n");
697 retval = -ENOMEM;
698 goto exit;
699 }
700
701 init_MUTEX(&dev->sem);
702 spin_lock_init(&dev->buflock);
703 dev->udev = udev;
704 init_waitqueue_head(&dev->read_wait);
705 init_waitqueue_head(&dev->write_wait);
706
707 iface_desc = &interface->altsetting[0];
708
709 /* set up the endpoint information */
710 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
711 endpoint = &iface_desc->endpoint[i].desc;
712
713 if (usb_endpoint_is_int_in(endpoint))
714 dev->interrupt_in_endpoint = endpoint;
715
716 if (usb_endpoint_is_int_out(endpoint))
717 dev->interrupt_out_endpoint = endpoint;
718 }
719 if (dev->interrupt_in_endpoint == NULL) {
720 dev_err(&interface->dev, "interrupt in endpoint not found\n");
721 goto error;
722 }
723 if (dev->interrupt_out_endpoint == NULL) {
724 dev_err(&interface->dev, "interrupt out endpoint not found\n");
725 goto error;
726 }
727
728 in_end_size = le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize);
729 out_end_size = le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize);
730
731 dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL);
732 if (!dev->read_buffer_primary) {
733 dev_err(&interface->dev, "Couldn't allocate read_buffer_primary\n");
734 retval = -ENOMEM;
735 goto error;
736 }
737
738 /* debug code prime the buffer */
739 memset(dev->read_buffer_primary, 'a', in_end_size);
740 memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size);
741 memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size);
742 memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size);
743
744 dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL);
745 if (!dev->read_buffer_secondary) {
746 dev_err(&interface->dev, "Couldn't allocate read_buffer_secondary\n");
747 retval = -ENOMEM;
748 goto error;
749 }
750
751 /* debug code prime the buffer */
752 memset(dev->read_buffer_secondary, 'e', in_end_size);
753 memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size);
754 memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size);
755 memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size);
756
757 dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL);
758 if (!dev->interrupt_in_buffer) {
759 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
760 goto error;
761 }
762
763 /* debug code prime the buffer */
764 memset(dev->interrupt_in_buffer, 'i', in_end_size);
765
766 dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
767 if (!dev->interrupt_in_urb) {
768 dev_err(&interface->dev, "Couldn't allocate interrupt_in_urb\n");
769 goto error;
770 }
771 dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL);
772 if (!dev->interrupt_out_buffer) {
773 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
774 goto error;
775 }
776 dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
777 if (!dev->interrupt_out_urb) {
778 dev_err(&interface->dev, "Couldn't allocate interrupt_out_urb\n");
779 goto error;
780 }
781
782 if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number,
783 sizeof(dev->serial_number))) {
784 dev_err(&interface->dev, "Could not retrieve serial number\n");
785 goto error;
786 }
787 dbg(2," %s : serial_number=%s", __FUNCTION__, dev->serial_number);
788
789 /* we can register the device now, as it is ready */
790 usb_set_intfdata(interface, dev);
791
792 retval = usb_register_dev(interface, &adu_class);
793
794 if (retval) {
795 /* something prevented us from registering this driver */
796 dev_err(&interface->dev, "Not able to get a minor for this device.\n");
797 usb_set_intfdata(interface, NULL);
798 goto error;
799 }
800
801 dev->minor = interface->minor;
802
803 /* let the user know what node this device is now attached to */
804 dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d",
805 udev->descriptor.idProduct, dev->serial_number,
806 (dev->minor - ADU_MINOR_BASE));
807 exit:
808 dbg(2," %s : leave, return value %p (dev)", __FUNCTION__, dev);
809
810 return retval;
811
812 error:
813 adu_delete(dev);
814 return retval;
815 }
816
817 /**
818 * adu_disconnect
819 *
820 * Called by the usb core when the device is removed from the system.
821 */
822 static void adu_disconnect(struct usb_interface *interface)
823 {
824 struct adu_device *dev;
825 int minor;
826
827 dbg(2," %s : enter", __FUNCTION__);
828
829 dev = usb_get_intfdata(interface);
830 usb_set_intfdata(interface, NULL);
831
832 minor = dev->minor;
833
834 /* give back our minor */
835 usb_deregister_dev(interface, &adu_class);
836 dev->minor = 0;
837
838 down(&dev->sem); /* not interruptible */
839
840 /* if the device is not opened, then we clean up right now */
841 dbg(2," %s : open count %d", __FUNCTION__, dev->open_count);
842 if (!dev->open_count) {
843 up(&dev->sem);
844 adu_delete(dev);
845 } else {
846 dev->udev = NULL;
847 up(&dev->sem);
848 }
849
850 dev_info(&interface->dev, "ADU device adutux%d now disconnected",
851 (minor - ADU_MINOR_BASE));
852
853 dbg(2," %s : leave", __FUNCTION__);
854 }
855
856 /* usb specific object needed to register this driver with the usb subsystem */
857 static struct usb_driver adu_driver = {
858 .name = "adutux",
859 .probe = adu_probe,
860 .disconnect = adu_disconnect,
861 .id_table = device_table,
862 };
863
864 static int __init adu_init(void)
865 {
866 int result;
867
868 dbg(2," %s : enter", __FUNCTION__);
869
870 /* register this driver with the USB subsystem */
871 result = usb_register(&adu_driver);
872 if (result < 0) {
873 err("usb_register failed for the "__FILE__" driver. "
874 "Error number %d", result);
875 goto exit;
876 }
877
878 info("adutux " DRIVER_DESC " " DRIVER_VERSION);
879 info("adutux is an experimental driver. Use at your own risk");
880
881 exit:
882 dbg(2," %s : leave, return value %d", __FUNCTION__, result);
883
884 return result;
885 }
886
887 static void __exit adu_exit(void)
888 {
889 dbg(2," %s : enter", __FUNCTION__);
890 /* deregister this driver with the USB subsystem */
891 usb_deregister(&adu_driver);
892 dbg(2," %s : leave", __FUNCTION__);
893 }
894
895 module_init(adu_init);
896 module_exit(adu_exit);
897
898 MODULE_AUTHOR(DRIVER_AUTHOR);
899 MODULE_DESCRIPTION(DRIVER_DESC);
900 MODULE_LICENSE("GPL");
Motorola kernel-slsi