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 <asm/uaccess.h>
29 #ifdef CONFIG_USB_DEBUG
35 /* Use our own dbg macro */
37 #define dbg(lvl, format, arg...) \
40 printk(KERN_DEBUG __FILE__ " : " format " \n", ## arg); \
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)"
49 /* Module parameters */
50 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
51 MODULE_PARM_DESC(debug
, "Debug enabled or not");
53 /* Define these values to match your device */
54 #define ADU_VENDOR_ID 0x0a07
55 #define ADU_PRODUCT_ID 0x0064
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 */
68 MODULE_DEVICE_TABLE(usb
, device_table
);
70 #ifdef CONFIG_USB_DYNAMIC_MINORS
71 #define ADU_MINOR_BASE 0
73 #define ADU_MINOR_BASE 67
76 /* we can have up to this number of device plugged in at once */
77 #define MAX_DEVICES 16
79 #define COMMAND_TIMEOUT (2*HZ) /* 60 second timeout for a command */
81 /* Structure to hold all of our device specific stuff */
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];
89 int open_count
; /* number of times this port has been opened */
91 char* read_buffer_primary
;
92 int read_buffer_length
;
93 char* read_buffer_secondary
;
98 wait_queue_head_t read_wait
;
99 wait_queue_head_t write_wait
;
101 char* interrupt_in_buffer
;
102 struct usb_endpoint_descriptor
* interrupt_in_endpoint
;
103 struct urb
* interrupt_in_urb
;
104 int read_urb_finished
;
106 char* interrupt_out_buffer
;
107 struct usb_endpoint_descriptor
* interrupt_out_endpoint
;
108 struct urb
* interrupt_out_urb
;
111 static struct usb_driver adu_driver
;
113 static void adu_debug_data(int level
, const char *function
, int size
,
114 const unsigned char *data
)
121 printk(KERN_DEBUG __FILE__
": %s - length = %d, data = ",
123 for (i
= 0; i
< size
; ++i
)
124 printk("%.2x ", data
[i
]);
129 * adu_abort_transfers
130 * aborts transfers and frees associated data structures
132 static void adu_abort_transfers(struct adu_device
*dev
)
134 dbg(2," %s : enter", __FUNCTION__
);
137 dbg(1," %s : dev is null", __FUNCTION__
);
141 if (dev
->udev
== NULL
) {
142 dbg(1," %s : udev is null", __FUNCTION__
);
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__
);
152 /* shutdown transfer */
153 usb_unlink_urb(dev
->interrupt_in_urb
);
154 usb_unlink_urb(dev
->interrupt_out_urb
);
157 dbg(2," %s : leave", __FUNCTION__
);
160 static void adu_delete(struct adu_device
*dev
)
162 dbg(2, "%s enter", __FUNCTION__
);
164 adu_abort_transfers(dev
);
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
);
175 dbg(2, "%s : leave", __FUNCTION__
);
178 static void adu_interrupt_in_callback(struct urb
*urb
)
180 struct adu_device
*dev
= urb
->context
;
182 dbg(4," %s : enter, status %d", __FUNCTION__
, urb
->status
);
183 adu_debug_data(5, __FUNCTION__
, urb
->actual_length
,
184 urb
->transfer_buffer
);
186 spin_lock(&dev
->buflock
);
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
);
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
);
204 dev
->read_buffer_length
+= urb
->actual_length
;
205 dbg(2," %s reading %d ", __FUNCTION__
,
208 dbg(1," %s : read_buffer overflow", __FUNCTION__
);
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
);
222 static void adu_interrupt_out_callback(struct urb
*urb
)
224 struct adu_device
*dev
= urb
->context
;
226 dbg(4," %s : enter, status %d", __FUNCTION__
, urb
->status
);
227 adu_debug_data(5,__FUNCTION__
, urb
->actual_length
, urb
->transfer_buffer
);
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
);
238 wake_up_interruptible(&dev
->write_wait
);
241 adu_debug_data(5, __FUNCTION__
, urb
->actual_length
,
242 urb
->transfer_buffer
);
243 dbg(4," %s : leave, status %d", __FUNCTION__
, urb
->status
);
246 static int adu_open(struct inode
*inode
, struct file
*file
)
248 struct adu_device
*dev
= NULL
;
249 struct usb_interface
*interface
;
253 dbg(2,"%s : enter", __FUNCTION__
);
255 subminor
= iminor(inode
);
257 interface
= usb_find_interface(&adu_driver
, subminor
);
259 err("%s - error, can't find device for minor %d",
260 __FUNCTION__
, subminor
);
265 dev
= usb_get_intfdata(interface
);
271 /* lock this device */
272 if ((retval
= down_interruptible(&dev
->sem
))) {
273 dbg(2, "%s : sem down failed", __FUNCTION__
);
277 /* increment our usage count for the device */
279 dbg(2,"%s : open count %d", __FUNCTION__
, dev
->open_count
);
281 /* save device in the file's private structure */
282 file
->private_data
= dev
;
284 if (dev
->open_count
== 1) {
285 /* initialize in direction */
286 dev
->read_buffer_length
= 0;
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
);
305 dbg(2,"%s : leave, return value %d ", __FUNCTION__
, retval
);
310 static int adu_release_internal(struct adu_device
*dev
)
314 dbg(2," %s : enter", __FUNCTION__
);
316 /* decrement our usage count for the device */
318 dbg(2," %s : open count %d", __FUNCTION__
, dev
->open_count
);
319 if (dev
->open_count
<= 0) {
320 adu_abort_transfers(dev
);
324 dbg(2," %s : leave", __FUNCTION__
);
328 static int adu_release(struct inode
*inode
, struct file
*file
)
330 struct adu_device
*dev
= NULL
;
333 dbg(2," %s : enter", __FUNCTION__
);
336 dbg(1," %s : file is NULL", __FUNCTION__
);
341 dev
= file
->private_data
;
344 dbg(1," %s : object is NULL", __FUNCTION__
);
349 /* lock our device */
350 down(&dev
->sem
); /* not interruptible */
352 if (dev
->open_count
<= 0) {
353 dbg(1," %s : device not opened", __FUNCTION__
);
358 if (dev
->udev
== NULL
) {
359 /* the device was unplugged before the file was released */
365 retval
= adu_release_internal(dev
);
371 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
375 static ssize_t
adu_read(struct file
*file
, __user
char *buffer
, size_t count
,
378 struct adu_device
*dev
;
379 size_t bytes_read
= 0;
380 size_t bytes_to_read
= count
;
384 int should_submit
= 0;
386 DECLARE_WAITQUEUE(wait
, current
);
388 dbg(2," %s : enter, count = %Zd, file=%p", __FUNCTION__
, count
, file
);
390 dev
= file
->private_data
;
391 dbg(2," %s : dev=%p", __FUNCTION__
, dev
);
392 /* lock this object */
393 if (down_interruptible(&dev
->sem
))
396 /* verify that the device wasn't unplugged */
397 if (dev
->udev
== NULL
|| dev
->minor
== 0) {
399 err("No device or device unplugged %d", retval
);
403 /* verify that some data was requested */
405 dbg(1," %s : read request of 0 bytes", __FUNCTION__
);
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
);
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
);
425 dev
->secondary_head
+= (amount
- i
);
426 bytes_read
+= (amount
- i
);
427 bytes_to_read
-= (amount
- i
);
429 retval
= bytes_read
? bytes_read
: -EFAULT
;
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 */
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 */
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__
);
456 /* we must initiate input */
457 dbg(2," %s : initiate input", __FUNCTION__
);
458 dev
->read_urb_finished
= 0;
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
,
467 dev
->interrupt_in_endpoint
->bInterval
);
468 retval
= usb_submit_urb(dev
->interrupt_in_urb
, GFP_ATOMIC
);
470 spin_unlock_irqrestore(&dev
->buflock
, flags
);
471 dbg(2," %s : submitted OK", __FUNCTION__
);
473 if (retval
== -ENOMEM
) {
474 retval
= bytes_read
? bytes_read
: -ENOMEM
;
476 spin_unlock_irqrestore(&dev
->buflock
, flags
);
477 dbg(2," %s : submit failed", __FUNCTION__
);
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
);
488 set_current_state(TASK_RUNNING
);
489 remove_wait_queue(&dev
->read_wait
, &wait
);
492 dbg(2," %s : timeout", __FUNCTION__
);
493 retval
= bytes_read
? bytes_read
: -ETIMEDOUT
;
497 if (signal_pending(current
)) {
498 dbg(2," %s : signal pending", __FUNCTION__
);
499 retval
= bytes_read
? bytes_read
: -EINTR
;
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
,
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 */
524 /* unlock the device */
527 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
531 static ssize_t
adu_write(struct file
*file
, const __user
char *buffer
,
532 size_t count
, loff_t
*ppos
)
534 struct adu_device
*dev
;
535 size_t bytes_written
= 0;
536 size_t bytes_to_write
;
541 dbg(2," %s : enter, count = %Zd", __FUNCTION__
, count
);
543 dev
= file
->private_data
;
545 /* lock this object */
546 retval
= down_interruptible(&dev
->sem
);
550 /* verify that the device wasn't unplugged */
551 if (dev
->udev
== NULL
|| dev
->minor
== 0) {
553 err("No device or device unplugged %d", retval
);
557 /* verify that we actually have some data to write */
559 dbg(1," %s : write request of 0 bytes", __FUNCTION__
);
565 if (dev
->interrupt_out_urb
->status
== -EINPROGRESS
) {
566 timeout
= COMMAND_TIMEOUT
;
568 while (timeout
> 0) {
569 if (signal_pending(current
)) {
570 dbg(1," %s : interrupted", __FUNCTION__
);
575 timeout
= interruptible_sleep_on_timeout(&dev
->write_wait
, timeout
);
576 retval
= down_interruptible(&dev
->sem
);
578 retval
= bytes_written
? bytes_written
: retval
;
584 dbg(1," %s : interrupted timeout: %d", __FUNCTION__
, timeout
);
588 dbg(1," %s : final timeout: %d", __FUNCTION__
, timeout
);
591 dbg(1, "%s - command timed out.", __FUNCTION__
);
596 dbg(4," %s : in progress, count = %Zd", __FUNCTION__
, count
);
599 dbg(4," %s : sending, count = %Zd", __FUNCTION__
, count
);
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
);
607 if (copy_from_user(dev
->interrupt_out_buffer
, buffer
, bytes_to_write
) != 0) {
612 /* send off the urb */
614 dev
->interrupt_out_urb
,
616 usb_sndintpipe(dev
->udev
, dev
->interrupt_out_endpoint
->bEndpointAddress
),
617 dev
->interrupt_out_buffer
,
619 adu_interrupt_out_callback
,
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
);
626 err("Couldn't submit interrupt_out_urb %d", retval
);
630 buffer
+= bytes_to_write
;
631 count
-= bytes_to_write
;
633 bytes_written
+= bytes_to_write
;
637 retval
= bytes_written
;
640 /* unlock the device */
644 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
649 /* file operations needed when we register this driver */
650 static const struct file_operations adu_fops
= {
651 .owner
= THIS_MODULE
,
655 .release
= adu_release
,
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
662 static struct usb_class_driver adu_class
= {
663 .name
= "usb/adutux%d",
665 .minor_base
= ADU_MINOR_BASE
,
671 * Called by the usb core when a new device is connected that it thinks
672 * this driver might be interested in.
674 static int adu_probe(struct usb_interface
*interface
,
675 const struct usb_device_id
*id
)
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
;
686 dbg(2," %s : enter", __FUNCTION__
);
689 dev_err(&interface
->dev
, "udev is NULL.\n");
693 /* allocate memory for our device state and intialize it */
694 dev
= kzalloc(sizeof(struct adu_device
), GFP_KERNEL
);
696 dev_err(&interface
->dev
, "Out of memory\n");
701 init_MUTEX(&dev
->sem
);
702 spin_lock_init(&dev
->buflock
);
704 init_waitqueue_head(&dev
->read_wait
);
705 init_waitqueue_head(&dev
->write_wait
);
707 iface_desc
= &interface
->altsetting
[0];
709 /* set up the endpoint information */
710 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
711 endpoint
= &iface_desc
->endpoint
[i
].desc
;
713 if (usb_endpoint_is_int_in(endpoint
))
714 dev
->interrupt_in_endpoint
= endpoint
;
716 if (usb_endpoint_is_int_out(endpoint
))
717 dev
->interrupt_out_endpoint
= endpoint
;
719 if (dev
->interrupt_in_endpoint
== NULL
) {
720 dev_err(&interface
->dev
, "interrupt in endpoint not found\n");
723 if (dev
->interrupt_out_endpoint
== NULL
) {
724 dev_err(&interface
->dev
, "interrupt out endpoint not found\n");
728 in_end_size
= le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
);
729 out_end_size
= le16_to_cpu(dev
->interrupt_out_endpoint
->wMaxPacketSize
);
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");
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
);
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");
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
);
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");
763 /* debug code prime the buffer */
764 memset(dev
->interrupt_in_buffer
, 'i', in_end_size
);
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");
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");
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");
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");
787 dbg(2," %s : serial_number=%s", __FUNCTION__
, dev
->serial_number
);
789 /* we can register the device now, as it is ready */
790 usb_set_intfdata(interface
, dev
);
792 retval
= usb_register_dev(interface
, &adu_class
);
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
);
801 dev
->minor
= interface
->minor
;
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
));
808 dbg(2," %s : leave, return value %p (dev)", __FUNCTION__
, dev
);
820 * Called by the usb core when the device is removed from the system.
822 static void adu_disconnect(struct usb_interface
*interface
)
824 struct adu_device
*dev
;
827 dbg(2," %s : enter", __FUNCTION__
);
829 dev
= usb_get_intfdata(interface
);
830 usb_set_intfdata(interface
, NULL
);
834 /* give back our minor */
835 usb_deregister_dev(interface
, &adu_class
);
838 down(&dev
->sem
); /* not interruptible */
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
) {
850 dev_info(&interface
->dev
, "ADU device adutux%d now disconnected",
851 (minor
- ADU_MINOR_BASE
));
853 dbg(2," %s : leave", __FUNCTION__
);
856 /* usb specific object needed to register this driver with the usb subsystem */
857 static struct usb_driver adu_driver
= {
860 .disconnect
= adu_disconnect
,
861 .id_table
= device_table
,
864 static int __init
adu_init(void)
868 dbg(2," %s : enter", __FUNCTION__
);
870 /* register this driver with the USB subsystem */
871 result
= usb_register(&adu_driver
);
873 err("usb_register failed for the "__FILE__
" driver. "
874 "Error number %d", result
);
878 info("adutux " DRIVER_DESC
" " DRIVER_VERSION
);
879 info("adutux is an experimental driver. Use at your own risk");
882 dbg(2," %s : leave, return value %d", __FUNCTION__
, result
);
887 static void __exit
adu_exit(void)
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__
);
895 module_init(adu_init
);
896 module_exit(adu_exit
);
898 MODULE_AUTHOR(DRIVER_AUTHOR
);
899 MODULE_DESCRIPTION(DRIVER_DESC
);
900 MODULE_LICENSE("GPL");