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.
6 * Copyright (c) 2003 John Homppi (SCO, leave this notice here)
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.
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)
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 <linux/mutex.h>
28 #include <linux/uaccess.h>
30 #ifdef CONFIG_USB_DEBUG
36 /* Use our own dbg macro */
38 #define dbg(lvl, format, arg...) \
41 printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
45 /* Version Information */
46 #define DRIVER_VERSION "v0.0.13"
47 #define DRIVER_AUTHOR "John Homppi"
48 #define DRIVER_DESC "adutux (see www.ontrak.net)"
50 /* Module parameters */
51 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
52 MODULE_PARM_DESC(debug
, "Debug enabled or not");
54 /* Define these values to match your device */
55 #define ADU_VENDOR_ID 0x0a07
56 #define ADU_PRODUCT_ID 0x0064
58 /* table of devices that work with this driver */
59 static const struct usb_device_id device_table
[] = {
60 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
) }, /* ADU100 */
61 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
+20) }, /* ADU120 */
62 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
+30) }, /* ADU130 */
63 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
+100) }, /* ADU200 */
64 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
+108) }, /* ADU208 */
65 { USB_DEVICE(ADU_VENDOR_ID
, ADU_PRODUCT_ID
+118) }, /* ADU218 */
66 { } /* Terminating entry */
69 MODULE_DEVICE_TABLE(usb
, device_table
);
71 #ifdef CONFIG_USB_DYNAMIC_MINORS
72 #define ADU_MINOR_BASE 0
74 #define ADU_MINOR_BASE 67
77 /* we can have up to this number of device plugged in at once */
78 #define MAX_DEVICES 16
80 #define COMMAND_TIMEOUT (2*HZ) /* 60 second timeout for a command */
83 * The locking scheme is a vanilla 3-lock:
84 * adu_device.buflock: A spinlock, covers what IRQs touch.
85 * adutux_mutex: A Static lock to cover open_count. It would also cover
86 * any globals, but we don't have them in 2.6.
87 * adu_device.mtx: A mutex to hold across sleepers like copy_from_user.
88 * It covers all of adu_device, except the open_count
89 * and what .buflock covers.
92 /* Structure to hold all of our device specific stuff */
95 struct usb_device
*udev
; /* save off the usb device pointer */
96 struct usb_interface
*interface
;
97 unsigned int minor
; /* the starting minor number for this device */
98 char serial_number
[8];
100 int open_count
; /* number of times this port has been opened */
102 char *read_buffer_primary
;
103 int read_buffer_length
;
104 char *read_buffer_secondary
;
109 wait_queue_head_t read_wait
;
110 wait_queue_head_t write_wait
;
112 char *interrupt_in_buffer
;
113 struct usb_endpoint_descriptor
*interrupt_in_endpoint
;
114 struct urb
*interrupt_in_urb
;
115 int read_urb_finished
;
117 char *interrupt_out_buffer
;
118 struct usb_endpoint_descriptor
*interrupt_out_endpoint
;
119 struct urb
*interrupt_out_urb
;
120 int out_urb_finished
;
123 static DEFINE_MUTEX(adutux_mutex
);
125 static struct usb_driver adu_driver
;
127 static void adu_debug_data(int level
, const char *function
, int size
,
128 const unsigned char *data
)
135 printk(KERN_DEBUG
"%s: %s - length = %d, data = ",
136 __FILE__
, function
, size
);
137 for (i
= 0; i
< size
; ++i
)
138 printk("%.2x ", data
[i
]);
143 * adu_abort_transfers
144 * aborts transfers and frees associated data structures
146 static void adu_abort_transfers(struct adu_device
*dev
)
150 dbg(2, " %s : enter", __func__
);
152 if (dev
->udev
== NULL
) {
153 dbg(1, " %s : udev is null", __func__
);
157 /* shutdown transfer */
159 /* XXX Anchor these instead */
160 spin_lock_irqsave(&dev
->buflock
, flags
);
161 if (!dev
->read_urb_finished
) {
162 spin_unlock_irqrestore(&dev
->buflock
, flags
);
163 usb_kill_urb(dev
->interrupt_in_urb
);
165 spin_unlock_irqrestore(&dev
->buflock
, flags
);
167 spin_lock_irqsave(&dev
->buflock
, flags
);
168 if (!dev
->out_urb_finished
) {
169 spin_unlock_irqrestore(&dev
->buflock
, flags
);
170 usb_kill_urb(dev
->interrupt_out_urb
);
172 spin_unlock_irqrestore(&dev
->buflock
, flags
);
175 dbg(2, " %s : leave", __func__
);
178 static void adu_delete(struct adu_device
*dev
)
180 dbg(2, "%s enter", __func__
);
182 /* free data structures */
183 usb_free_urb(dev
->interrupt_in_urb
);
184 usb_free_urb(dev
->interrupt_out_urb
);
185 kfree(dev
->read_buffer_primary
);
186 kfree(dev
->read_buffer_secondary
);
187 kfree(dev
->interrupt_in_buffer
);
188 kfree(dev
->interrupt_out_buffer
);
191 dbg(2, "%s : leave", __func__
);
194 static void adu_interrupt_in_callback(struct urb
*urb
)
196 struct adu_device
*dev
= urb
->context
;
197 int status
= urb
->status
;
199 dbg(4, " %s : enter, status %d", __func__
, status
);
200 adu_debug_data(5, __func__
, urb
->actual_length
,
201 urb
->transfer_buffer
);
203 spin_lock(&dev
->buflock
);
206 if ((status
!= -ENOENT
) && (status
!= -ECONNRESET
) &&
207 (status
!= -ESHUTDOWN
)) {
208 dbg(1, " %s : nonzero status received: %d",
214 if (urb
->actual_length
> 0 && dev
->interrupt_in_buffer
[0] != 0x00) {
215 if (dev
->read_buffer_length
<
216 (4 * usb_endpoint_maxp(dev
->interrupt_in_endpoint
)) -
217 (urb
->actual_length
)) {
218 memcpy (dev
->read_buffer_primary
+
219 dev
->read_buffer_length
,
220 dev
->interrupt_in_buffer
, urb
->actual_length
);
222 dev
->read_buffer_length
+= urb
->actual_length
;
223 dbg(2, " %s reading %d ", __func__
,
226 dbg(1, " %s : read_buffer overflow", __func__
);
231 dev
->read_urb_finished
= 1;
232 spin_unlock(&dev
->buflock
);
233 /* always wake up so we recover from errors */
234 wake_up_interruptible(&dev
->read_wait
);
235 adu_debug_data(5, __func__
, urb
->actual_length
,
236 urb
->transfer_buffer
);
237 dbg(4, " %s : leave, status %d", __func__
, status
);
240 static void adu_interrupt_out_callback(struct urb
*urb
)
242 struct adu_device
*dev
= urb
->context
;
243 int status
= urb
->status
;
245 dbg(4, " %s : enter, status %d", __func__
, status
);
246 adu_debug_data(5, __func__
, urb
->actual_length
, urb
->transfer_buffer
);
249 if ((status
!= -ENOENT
) &&
250 (status
!= -ECONNRESET
)) {
251 dbg(1, " %s :nonzero status received: %d",
257 spin_lock(&dev
->buflock
);
258 dev
->out_urb_finished
= 1;
259 wake_up(&dev
->write_wait
);
260 spin_unlock(&dev
->buflock
);
263 adu_debug_data(5, __func__
, urb
->actual_length
,
264 urb
->transfer_buffer
);
265 dbg(4, " %s : leave, status %d", __func__
, status
);
268 static int adu_open(struct inode
*inode
, struct file
*file
)
270 struct adu_device
*dev
= NULL
;
271 struct usb_interface
*interface
;
275 dbg(2, "%s : enter", __func__
);
277 subminor
= iminor(inode
);
279 retval
= mutex_lock_interruptible(&adutux_mutex
);
281 dbg(2, "%s : mutex lock failed", __func__
);
285 interface
= usb_find_interface(&adu_driver
, subminor
);
287 printk(KERN_ERR
"adutux: %s - error, can't find device for "
288 "minor %d\n", __func__
, subminor
);
293 dev
= usb_get_intfdata(interface
);
294 if (!dev
|| !dev
->udev
) {
299 /* check that nobody else is using the device */
300 if (dev
->open_count
) {
306 dbg(2, "%s : open count %d", __func__
, dev
->open_count
);
308 /* save device in the file's private structure */
309 file
->private_data
= dev
;
311 /* initialize in direction */
312 dev
->read_buffer_length
= 0;
314 /* fixup first read by having urb waiting for it */
315 usb_fill_int_urb(dev
->interrupt_in_urb
, dev
->udev
,
316 usb_rcvintpipe(dev
->udev
,
317 dev
->interrupt_in_endpoint
->bEndpointAddress
),
318 dev
->interrupt_in_buffer
,
319 usb_endpoint_maxp(dev
->interrupt_in_endpoint
),
320 adu_interrupt_in_callback
, dev
,
321 dev
->interrupt_in_endpoint
->bInterval
);
322 dev
->read_urb_finished
= 0;
323 if (usb_submit_urb(dev
->interrupt_in_urb
, GFP_KERNEL
))
324 dev
->read_urb_finished
= 1;
325 /* we ignore failure */
326 /* end of fixup for first read */
328 /* initialize out direction */
329 dev
->out_urb_finished
= 1;
334 mutex_unlock(&adutux_mutex
);
336 dbg(2, "%s : leave, return value %d ", __func__
, retval
);
340 static void adu_release_internal(struct adu_device
*dev
)
342 dbg(2, " %s : enter", __func__
);
344 /* decrement our usage count for the device */
346 dbg(2, " %s : open count %d", __func__
, dev
->open_count
);
347 if (dev
->open_count
<= 0) {
348 adu_abort_transfers(dev
);
352 dbg(2, " %s : leave", __func__
);
355 static int adu_release(struct inode
*inode
, struct file
*file
)
357 struct adu_device
*dev
;
360 dbg(2, " %s : enter", __func__
);
363 dbg(1, " %s : file is NULL", __func__
);
368 dev
= file
->private_data
;
370 dbg(1, " %s : object is NULL", __func__
);
375 mutex_lock(&adutux_mutex
); /* not interruptible */
377 if (dev
->open_count
<= 0) {
378 dbg(1, " %s : device not opened", __func__
);
383 adu_release_internal(dev
);
384 if (dev
->udev
== NULL
) {
385 /* the device was unplugged before the file was released */
386 if (!dev
->open_count
) /* ... and we're the last user */
390 mutex_unlock(&adutux_mutex
);
392 dbg(2, " %s : leave, return value %d", __func__
, retval
);
396 static ssize_t
adu_read(struct file
*file
, __user
char *buffer
, size_t count
,
399 struct adu_device
*dev
;
400 size_t bytes_read
= 0;
401 size_t bytes_to_read
= count
;
405 int should_submit
= 0;
407 DECLARE_WAITQUEUE(wait
, current
);
409 dbg(2, " %s : enter, count = %Zd, file=%p", __func__
, count
, file
);
411 dev
= file
->private_data
;
412 dbg(2, " %s : dev=%p", __func__
, dev
);
414 if (mutex_lock_interruptible(&dev
->mtx
))
417 /* verify that the device wasn't unplugged */
418 if (dev
->udev
== NULL
) {
420 printk(KERN_ERR
"adutux: No device or device unplugged %d\n",
425 /* verify that some data was requested */
427 dbg(1, " %s : read request of 0 bytes", __func__
);
431 timeout
= COMMAND_TIMEOUT
;
432 dbg(2, " %s : about to start looping", __func__
);
433 while (bytes_to_read
) {
434 int data_in_secondary
= dev
->secondary_tail
- dev
->secondary_head
;
435 dbg(2, " %s : while, data_in_secondary=%d, status=%d",
436 __func__
, data_in_secondary
,
437 dev
->interrupt_in_urb
->status
);
439 if (data_in_secondary
) {
440 /* drain secondary buffer */
441 int amount
= bytes_to_read
< data_in_secondary
? bytes_to_read
: data_in_secondary
;
442 i
= copy_to_user(buffer
, dev
->read_buffer_secondary
+dev
->secondary_head
, amount
);
447 dev
->secondary_head
+= (amount
- i
);
448 bytes_read
+= (amount
- i
);
449 bytes_to_read
-= (amount
- i
);
451 retval
= bytes_read
? bytes_read
: -EFAULT
;
455 /* we check the primary buffer */
456 spin_lock_irqsave (&dev
->buflock
, flags
);
457 if (dev
->read_buffer_length
) {
458 /* we secure access to the primary */
460 dbg(2, " %s : swap, read_buffer_length = %d",
461 __func__
, dev
->read_buffer_length
);
462 tmp
= dev
->read_buffer_secondary
;
463 dev
->read_buffer_secondary
= dev
->read_buffer_primary
;
464 dev
->read_buffer_primary
= tmp
;
465 dev
->secondary_head
= 0;
466 dev
->secondary_tail
= dev
->read_buffer_length
;
467 dev
->read_buffer_length
= 0;
468 spin_unlock_irqrestore(&dev
->buflock
, flags
);
469 /* we have a free buffer so use it */
472 /* even the primary was empty - we may need to do IO */
473 if (!dev
->read_urb_finished
) {
474 /* somebody is doing IO */
475 spin_unlock_irqrestore(&dev
->buflock
, flags
);
476 dbg(2, " %s : submitted already", __func__
);
478 /* we must initiate input */
479 dbg(2, " %s : initiate input", __func__
);
480 dev
->read_urb_finished
= 0;
481 spin_unlock_irqrestore(&dev
->buflock
, flags
);
483 usb_fill_int_urb(dev
->interrupt_in_urb
, dev
->udev
,
484 usb_rcvintpipe(dev
->udev
,
485 dev
->interrupt_in_endpoint
->bEndpointAddress
),
486 dev
->interrupt_in_buffer
,
487 usb_endpoint_maxp(dev
->interrupt_in_endpoint
),
488 adu_interrupt_in_callback
,
490 dev
->interrupt_in_endpoint
->bInterval
);
491 retval
= usb_submit_urb(dev
->interrupt_in_urb
, GFP_KERNEL
);
493 dev
->read_urb_finished
= 1;
494 if (retval
== -ENOMEM
) {
495 retval
= bytes_read
? bytes_read
: -ENOMEM
;
497 dbg(2, " %s : submit failed", __func__
);
502 /* we wait for I/O to complete */
503 set_current_state(TASK_INTERRUPTIBLE
);
504 add_wait_queue(&dev
->read_wait
, &wait
);
505 spin_lock_irqsave(&dev
->buflock
, flags
);
506 if (!dev
->read_urb_finished
) {
507 spin_unlock_irqrestore(&dev
->buflock
, flags
);
508 timeout
= schedule_timeout(COMMAND_TIMEOUT
);
510 spin_unlock_irqrestore(&dev
->buflock
, flags
);
511 set_current_state(TASK_RUNNING
);
513 remove_wait_queue(&dev
->read_wait
, &wait
);
516 dbg(2, " %s : timeout", __func__
);
517 retval
= bytes_read
? bytes_read
: -ETIMEDOUT
;
521 if (signal_pending(current
)) {
522 dbg(2, " %s : signal pending", __func__
);
523 retval
= bytes_read
? bytes_read
: -EINTR
;
531 /* if the primary buffer is empty then use it */
532 spin_lock_irqsave(&dev
->buflock
, flags
);
533 if (should_submit
&& dev
->read_urb_finished
) {
534 dev
->read_urb_finished
= 0;
535 spin_unlock_irqrestore(&dev
->buflock
, flags
);
536 usb_fill_int_urb(dev
->interrupt_in_urb
, dev
->udev
,
537 usb_rcvintpipe(dev
->udev
,
538 dev
->interrupt_in_endpoint
->bEndpointAddress
),
539 dev
->interrupt_in_buffer
,
540 usb_endpoint_maxp(dev
->interrupt_in_endpoint
),
541 adu_interrupt_in_callback
,
543 dev
->interrupt_in_endpoint
->bInterval
);
544 if (usb_submit_urb(dev
->interrupt_in_urb
, GFP_KERNEL
) != 0)
545 dev
->read_urb_finished
= 1;
546 /* we ignore failure */
548 spin_unlock_irqrestore(&dev
->buflock
, flags
);
552 /* unlock the device */
553 mutex_unlock(&dev
->mtx
);
555 dbg(2, " %s : leave, return value %d", __func__
, retval
);
559 static ssize_t
adu_write(struct file
*file
, const __user
char *buffer
,
560 size_t count
, loff_t
*ppos
)
562 DECLARE_WAITQUEUE(waita
, current
);
563 struct adu_device
*dev
;
564 size_t bytes_written
= 0;
565 size_t bytes_to_write
;
570 dbg(2, " %s : enter, count = %Zd", __func__
, count
);
572 dev
= file
->private_data
;
574 retval
= mutex_lock_interruptible(&dev
->mtx
);
578 /* verify that the device wasn't unplugged */
579 if (dev
->udev
== NULL
) {
581 printk(KERN_ERR
"adutux: No device or device unplugged %d\n",
586 /* verify that we actually have some data to write */
588 dbg(1, " %s : write request of 0 bytes", __func__
);
593 add_wait_queue(&dev
->write_wait
, &waita
);
594 set_current_state(TASK_INTERRUPTIBLE
);
595 spin_lock_irqsave(&dev
->buflock
, flags
);
596 if (!dev
->out_urb_finished
) {
597 spin_unlock_irqrestore(&dev
->buflock
, flags
);
599 mutex_unlock(&dev
->mtx
);
600 if (signal_pending(current
)) {
601 dbg(1, " %s : interrupted", __func__
);
602 set_current_state(TASK_RUNNING
);
606 if (schedule_timeout(COMMAND_TIMEOUT
) == 0) {
607 dbg(1, "%s - command timed out.", __func__
);
611 remove_wait_queue(&dev
->write_wait
, &waita
);
612 retval
= mutex_lock_interruptible(&dev
->mtx
);
614 retval
= bytes_written
? bytes_written
: retval
;
618 dbg(4, " %s : in progress, count = %Zd", __func__
, count
);
620 spin_unlock_irqrestore(&dev
->buflock
, flags
);
621 set_current_state(TASK_RUNNING
);
622 remove_wait_queue(&dev
->write_wait
, &waita
);
623 dbg(4, " %s : sending, count = %Zd", __func__
, count
);
625 /* write the data into interrupt_out_buffer from userspace */
626 buffer_size
= usb_endpoint_maxp(dev
->interrupt_out_endpoint
);
627 bytes_to_write
= count
> buffer_size
? buffer_size
: count
;
628 dbg(4, " %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
629 __func__
, buffer_size
, count
, bytes_to_write
);
631 if (copy_from_user(dev
->interrupt_out_buffer
, buffer
, bytes_to_write
) != 0) {
636 /* send off the urb */
638 dev
->interrupt_out_urb
,
640 usb_sndintpipe(dev
->udev
, dev
->interrupt_out_endpoint
->bEndpointAddress
),
641 dev
->interrupt_out_buffer
,
643 adu_interrupt_out_callback
,
645 dev
->interrupt_out_endpoint
->bInterval
);
646 dev
->interrupt_out_urb
->actual_length
= bytes_to_write
;
647 dev
->out_urb_finished
= 0;
648 retval
= usb_submit_urb(dev
->interrupt_out_urb
, GFP_KERNEL
);
650 dev
->out_urb_finished
= 1;
651 dev_err(&dev
->udev
->dev
, "Couldn't submit "
652 "interrupt_out_urb %d\n", retval
);
656 buffer
+= bytes_to_write
;
657 count
-= bytes_to_write
;
659 bytes_written
+= bytes_to_write
;
662 mutex_unlock(&dev
->mtx
);
663 return bytes_written
;
666 mutex_unlock(&dev
->mtx
);
668 dbg(2, " %s : leave, return value %d", __func__
, retval
);
672 remove_wait_queue(&dev
->write_wait
, &waita
);
676 /* file operations needed when we register this driver */
677 static const struct file_operations adu_fops
= {
678 .owner
= THIS_MODULE
,
682 .release
= adu_release
,
683 .llseek
= noop_llseek
,
687 * usb class driver info in order to get a minor number from the usb core,
688 * and to have the device registered with devfs and the driver core
690 static struct usb_class_driver adu_class
= {
691 .name
= "usb/adutux%d",
693 .minor_base
= ADU_MINOR_BASE
,
699 * Called by the usb core when a new device is connected that it thinks
700 * this driver might be interested in.
702 static int adu_probe(struct usb_interface
*interface
,
703 const struct usb_device_id
*id
)
705 struct usb_device
*udev
= interface_to_usbdev(interface
);
706 struct adu_device
*dev
= NULL
;
707 struct usb_host_interface
*iface_desc
;
708 struct usb_endpoint_descriptor
*endpoint
;
709 int retval
= -ENODEV
;
714 dbg(2, " %s : enter", __func__
);
717 dev_err(&interface
->dev
, "udev is NULL.\n");
721 /* allocate memory for our device state and initialize it */
722 dev
= kzalloc(sizeof(struct adu_device
), GFP_KERNEL
);
724 dev_err(&interface
->dev
, "Out of memory\n");
729 mutex_init(&dev
->mtx
);
730 spin_lock_init(&dev
->buflock
);
732 init_waitqueue_head(&dev
->read_wait
);
733 init_waitqueue_head(&dev
->write_wait
);
735 iface_desc
= &interface
->altsetting
[0];
737 /* set up the endpoint information */
738 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
739 endpoint
= &iface_desc
->endpoint
[i
].desc
;
741 if (usb_endpoint_is_int_in(endpoint
))
742 dev
->interrupt_in_endpoint
= endpoint
;
744 if (usb_endpoint_is_int_out(endpoint
))
745 dev
->interrupt_out_endpoint
= endpoint
;
747 if (dev
->interrupt_in_endpoint
== NULL
) {
748 dev_err(&interface
->dev
, "interrupt in endpoint not found\n");
751 if (dev
->interrupt_out_endpoint
== NULL
) {
752 dev_err(&interface
->dev
, "interrupt out endpoint not found\n");
756 in_end_size
= usb_endpoint_maxp(dev
->interrupt_in_endpoint
);
757 out_end_size
= usb_endpoint_maxp(dev
->interrupt_out_endpoint
);
759 dev
->read_buffer_primary
= kmalloc((4 * in_end_size
), GFP_KERNEL
);
760 if (!dev
->read_buffer_primary
) {
761 dev_err(&interface
->dev
, "Couldn't allocate read_buffer_primary\n");
766 /* debug code prime the buffer */
767 memset(dev
->read_buffer_primary
, 'a', in_end_size
);
768 memset(dev
->read_buffer_primary
+ in_end_size
, 'b', in_end_size
);
769 memset(dev
->read_buffer_primary
+ (2 * in_end_size
), 'c', in_end_size
);
770 memset(dev
->read_buffer_primary
+ (3 * in_end_size
), 'd', in_end_size
);
772 dev
->read_buffer_secondary
= kmalloc((4 * in_end_size
), GFP_KERNEL
);
773 if (!dev
->read_buffer_secondary
) {
774 dev_err(&interface
->dev
, "Couldn't allocate read_buffer_secondary\n");
779 /* debug code prime the buffer */
780 memset(dev
->read_buffer_secondary
, 'e', in_end_size
);
781 memset(dev
->read_buffer_secondary
+ in_end_size
, 'f', in_end_size
);
782 memset(dev
->read_buffer_secondary
+ (2 * in_end_size
), 'g', in_end_size
);
783 memset(dev
->read_buffer_secondary
+ (3 * in_end_size
), 'h', in_end_size
);
785 dev
->interrupt_in_buffer
= kmalloc(in_end_size
, GFP_KERNEL
);
786 if (!dev
->interrupt_in_buffer
) {
787 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_buffer\n");
791 /* debug code prime the buffer */
792 memset(dev
->interrupt_in_buffer
, 'i', in_end_size
);
794 dev
->interrupt_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
795 if (!dev
->interrupt_in_urb
) {
796 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_urb\n");
799 dev
->interrupt_out_buffer
= kmalloc(out_end_size
, GFP_KERNEL
);
800 if (!dev
->interrupt_out_buffer
) {
801 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_buffer\n");
804 dev
->interrupt_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
805 if (!dev
->interrupt_out_urb
) {
806 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_urb\n");
810 if (!usb_string(udev
, udev
->descriptor
.iSerialNumber
, dev
->serial_number
,
811 sizeof(dev
->serial_number
))) {
812 dev_err(&interface
->dev
, "Could not retrieve serial number\n");
815 dbg(2, " %s : serial_number=%s", __func__
, dev
->serial_number
);
817 /* we can register the device now, as it is ready */
818 usb_set_intfdata(interface
, dev
);
820 retval
= usb_register_dev(interface
, &adu_class
);
823 /* something prevented us from registering this driver */
824 dev_err(&interface
->dev
, "Not able to get a minor for this device.\n");
825 usb_set_intfdata(interface
, NULL
);
829 dev
->minor
= interface
->minor
;
831 /* let the user know what node this device is now attached to */
832 dev_info(&interface
->dev
, "ADU%d %s now attached to /dev/usb/adutux%d\n",
833 udev
->descriptor
.idProduct
, dev
->serial_number
,
834 (dev
->minor
- ADU_MINOR_BASE
));
836 dbg(2, " %s : leave, return value %p (dev)", __func__
, dev
);
848 * Called by the usb core when the device is removed from the system.
850 static void adu_disconnect(struct usb_interface
*interface
)
852 struct adu_device
*dev
;
855 dbg(2, " %s : enter", __func__
);
857 dev
= usb_get_intfdata(interface
);
859 mutex_lock(&dev
->mtx
); /* not interruptible */
860 dev
->udev
= NULL
; /* poison */
862 usb_deregister_dev(interface
, &adu_class
);
863 mutex_unlock(&dev
->mtx
);
865 mutex_lock(&adutux_mutex
);
866 usb_set_intfdata(interface
, NULL
);
868 /* if the device is not opened, then we clean up right now */
869 dbg(2, " %s : open count %d", __func__
, dev
->open_count
);
870 if (!dev
->open_count
)
873 mutex_unlock(&adutux_mutex
);
875 dev_info(&interface
->dev
, "ADU device adutux%d now disconnected\n",
876 (minor
- ADU_MINOR_BASE
));
878 dbg(2, " %s : leave", __func__
);
881 /* usb specific object needed to register this driver with the usb subsystem */
882 static struct usb_driver adu_driver
= {
885 .disconnect
= adu_disconnect
,
886 .id_table
= device_table
,
889 module_usb_driver(adu_driver
);
891 MODULE_AUTHOR(DRIVER_AUTHOR
);
892 MODULE_DESCRIPTION(DRIVER_DESC
);
893 MODULE_LICENSE("GPL");