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 <asm/uaccess.h>
30 #ifdef CONFIG_USB_DEBUG
36 /* Use our own dbg macro */
38 #define dbg(lvl, format, arg...) \
41 printk(KERN_DEBUG __FILE__ " : " format " \n", ## 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 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 */
82 /* Structure to hold all of our device specific stuff */
84 struct mutex mtx
; /* locks this structure */
85 struct usb_device
* udev
; /* save off the usb device pointer */
86 struct usb_interface
* interface
;
87 unsigned char minor
; /* the starting minor number for this device */
88 char serial_number
[8];
90 int open_count
; /* number of times this port has been opened */
92 char* read_buffer_primary
;
93 int read_buffer_length
;
94 char* read_buffer_secondary
;
99 wait_queue_head_t read_wait
;
100 wait_queue_head_t write_wait
;
102 char* interrupt_in_buffer
;
103 struct usb_endpoint_descriptor
* interrupt_in_endpoint
;
104 struct urb
* interrupt_in_urb
;
105 int read_urb_finished
;
107 char* interrupt_out_buffer
;
108 struct usb_endpoint_descriptor
* interrupt_out_endpoint
;
109 struct urb
* interrupt_out_urb
;
112 static struct usb_driver adu_driver
;
114 static void adu_debug_data(int level
, const char *function
, int size
,
115 const unsigned char *data
)
122 printk(KERN_DEBUG __FILE__
": %s - length = %d, data = ",
124 for (i
= 0; i
< size
; ++i
)
125 printk("%.2x ", data
[i
]);
130 * adu_abort_transfers
131 * aborts transfers and frees associated data structures
133 static void adu_abort_transfers(struct adu_device
*dev
)
135 dbg(2," %s : enter", __FUNCTION__
);
138 dbg(1," %s : dev is null", __FUNCTION__
);
142 if (dev
->udev
== NULL
) {
143 dbg(1," %s : udev is null", __FUNCTION__
);
147 dbg(2," %s : udev state %d", __FUNCTION__
, dev
->udev
->state
);
148 if (dev
->udev
->state
== USB_STATE_NOTATTACHED
) {
149 dbg(1," %s : udev is not attached", __FUNCTION__
);
153 /* shutdown transfer */
154 usb_unlink_urb(dev
->interrupt_in_urb
);
155 usb_unlink_urb(dev
->interrupt_out_urb
);
158 dbg(2," %s : leave", __FUNCTION__
);
161 static void adu_delete(struct adu_device
*dev
)
163 dbg(2, "%s enter", __FUNCTION__
);
165 adu_abort_transfers(dev
);
167 /* free data structures */
168 usb_free_urb(dev
->interrupt_in_urb
);
169 usb_free_urb(dev
->interrupt_out_urb
);
170 kfree(dev
->read_buffer_primary
);
171 kfree(dev
->read_buffer_secondary
);
172 kfree(dev
->interrupt_in_buffer
);
173 kfree(dev
->interrupt_out_buffer
);
176 dbg(2, "%s : leave", __FUNCTION__
);
179 static void adu_interrupt_in_callback(struct urb
*urb
)
181 struct adu_device
*dev
= urb
->context
;
182 int status
= urb
->status
;
184 dbg(4," %s : enter, status %d", __FUNCTION__
, status
);
185 adu_debug_data(5, __FUNCTION__
, urb
->actual_length
,
186 urb
->transfer_buffer
);
188 spin_lock(&dev
->buflock
);
191 if ((status
!= -ENOENT
) && (status
!= -ECONNRESET
)) {
192 dbg(1," %s : nonzero status received: %d",
193 __FUNCTION__
, status
);
198 if (urb
->actual_length
> 0 && dev
->interrupt_in_buffer
[0] != 0x00) {
199 if (dev
->read_buffer_length
<
200 (4 * le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
)) -
201 (urb
->actual_length
)) {
202 memcpy (dev
->read_buffer_primary
+
203 dev
->read_buffer_length
,
204 dev
->interrupt_in_buffer
, urb
->actual_length
);
206 dev
->read_buffer_length
+= urb
->actual_length
;
207 dbg(2," %s reading %d ", __FUNCTION__
,
210 dbg(1," %s : read_buffer overflow", __FUNCTION__
);
215 dev
->read_urb_finished
= 1;
216 spin_unlock(&dev
->buflock
);
217 /* always wake up so we recover from errors */
218 wake_up_interruptible(&dev
->read_wait
);
219 adu_debug_data(5, __FUNCTION__
, urb
->actual_length
,
220 urb
->transfer_buffer
);
221 dbg(4," %s : leave, status %d", __FUNCTION__
, status
);
224 static void adu_interrupt_out_callback(struct urb
*urb
)
226 struct adu_device
*dev
= urb
->context
;
227 int status
= urb
->status
;
229 dbg(4," %s : enter, status %d", __FUNCTION__
, status
);
230 adu_debug_data(5,__FUNCTION__
, urb
->actual_length
, urb
->transfer_buffer
);
233 if ((status
!= -ENOENT
) &&
234 (status
!= -ECONNRESET
)) {
235 dbg(1, " %s :nonzero status received: %d",
236 __FUNCTION__
, status
);
241 wake_up_interruptible(&dev
->write_wait
);
244 adu_debug_data(5, __FUNCTION__
, urb
->actual_length
,
245 urb
->transfer_buffer
);
246 dbg(4," %s : leave, status %d", __FUNCTION__
, status
);
249 static int adu_open(struct inode
*inode
, struct file
*file
)
251 struct adu_device
*dev
= NULL
;
252 struct usb_interface
*interface
;
256 dbg(2,"%s : enter", __FUNCTION__
);
258 subminor
= iminor(inode
);
260 interface
= usb_find_interface(&adu_driver
, subminor
);
262 err("%s - error, can't find device for minor %d",
263 __FUNCTION__
, subminor
);
268 dev
= usb_get_intfdata(interface
);
274 /* lock this device */
275 if ((retval
= mutex_lock_interruptible(&dev
->mtx
))) {
276 dbg(2, "%s : mutex lock failed", __FUNCTION__
);
280 /* increment our usage count for the device */
282 dbg(2,"%s : open count %d", __FUNCTION__
, dev
->open_count
);
284 /* save device in the file's private structure */
285 file
->private_data
= dev
;
287 if (dev
->open_count
== 1) {
288 /* initialize in direction */
289 dev
->read_buffer_length
= 0;
291 /* fixup first read by having urb waiting for it */
292 usb_fill_int_urb(dev
->interrupt_in_urb
,dev
->udev
,
293 usb_rcvintpipe(dev
->udev
,
294 dev
->interrupt_in_endpoint
->bEndpointAddress
),
295 dev
->interrupt_in_buffer
,
296 le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
),
297 adu_interrupt_in_callback
, dev
,
298 dev
->interrupt_in_endpoint
->bInterval
);
299 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
300 dev
->read_urb_finished
= 0;
301 retval
= usb_submit_urb(dev
->interrupt_in_urb
, GFP_KERNEL
);
305 mutex_unlock(&dev
->mtx
);
308 dbg(2,"%s : leave, return value %d ", __FUNCTION__
, retval
);
313 static int adu_release_internal(struct adu_device
*dev
)
317 dbg(2," %s : enter", __FUNCTION__
);
319 /* decrement our usage count for the device */
321 dbg(2," %s : open count %d", __FUNCTION__
, dev
->open_count
);
322 if (dev
->open_count
<= 0) {
323 adu_abort_transfers(dev
);
327 dbg(2," %s : leave", __FUNCTION__
);
331 static int adu_release(struct inode
*inode
, struct file
*file
)
333 struct adu_device
*dev
= NULL
;
336 dbg(2," %s : enter", __FUNCTION__
);
339 dbg(1," %s : file is NULL", __FUNCTION__
);
344 dev
= file
->private_data
;
347 dbg(1," %s : object is NULL", __FUNCTION__
);
352 /* lock our device */
353 mutex_lock(&dev
->mtx
); /* not interruptible */
355 if (dev
->open_count
<= 0) {
356 dbg(1," %s : device not opened", __FUNCTION__
);
361 if (dev
->udev
== NULL
) {
362 /* the device was unplugged before the file was released */
363 mutex_unlock(&dev
->mtx
);
368 retval
= adu_release_internal(dev
);
373 mutex_unlock(&dev
->mtx
);
374 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
378 static ssize_t
adu_read(struct file
*file
, __user
char *buffer
, size_t count
,
381 struct adu_device
*dev
;
382 size_t bytes_read
= 0;
383 size_t bytes_to_read
= count
;
387 int should_submit
= 0;
389 DECLARE_WAITQUEUE(wait
, current
);
391 dbg(2," %s : enter, count = %Zd, file=%p", __FUNCTION__
, count
, file
);
393 dev
= file
->private_data
;
394 dbg(2," %s : dev=%p", __FUNCTION__
, dev
);
395 /* lock this object */
396 if (mutex_lock_interruptible(&dev
->mtx
))
399 /* verify that the device wasn't unplugged */
400 if (dev
->udev
== NULL
|| dev
->minor
== 0) {
402 err("No device or device unplugged %d", retval
);
406 /* verify that some data was requested */
408 dbg(1," %s : read request of 0 bytes", __FUNCTION__
);
412 timeout
= COMMAND_TIMEOUT
;
413 dbg(2," %s : about to start looping", __FUNCTION__
);
414 while (bytes_to_read
) {
415 int data_in_secondary
= dev
->secondary_tail
- dev
->secondary_head
;
416 dbg(2," %s : while, data_in_secondary=%d, status=%d",
417 __FUNCTION__
, data_in_secondary
,
418 dev
->interrupt_in_urb
->status
);
420 if (data_in_secondary
) {
421 /* drain secondary buffer */
422 int amount
= bytes_to_read
< data_in_secondary
? bytes_to_read
: data_in_secondary
;
423 i
= copy_to_user(buffer
, dev
->read_buffer_secondary
+dev
->secondary_head
, amount
);
428 dev
->secondary_head
+= (amount
- i
);
429 bytes_read
+= (amount
- i
);
430 bytes_to_read
-= (amount
- i
);
432 retval
= bytes_read
? bytes_read
: -EFAULT
;
436 /* we check the primary buffer */
437 spin_lock_irqsave (&dev
->buflock
, flags
);
438 if (dev
->read_buffer_length
) {
439 /* we secure access to the primary */
441 dbg(2," %s : swap, read_buffer_length = %d",
442 __FUNCTION__
, dev
->read_buffer_length
);
443 tmp
= dev
->read_buffer_secondary
;
444 dev
->read_buffer_secondary
= dev
->read_buffer_primary
;
445 dev
->read_buffer_primary
= tmp
;
446 dev
->secondary_head
= 0;
447 dev
->secondary_tail
= dev
->read_buffer_length
;
448 dev
->read_buffer_length
= 0;
449 spin_unlock_irqrestore(&dev
->buflock
, flags
);
450 /* we have a free buffer so use it */
453 /* even the primary was empty - we may need to do IO */
454 if (dev
->interrupt_in_urb
->status
== -EINPROGRESS
) {
455 /* somebody is doing IO */
456 spin_unlock_irqrestore(&dev
->buflock
, flags
);
457 dbg(2," %s : submitted already", __FUNCTION__
);
459 /* we must initiate input */
460 dbg(2," %s : initiate input", __FUNCTION__
);
461 dev
->read_urb_finished
= 0;
463 usb_fill_int_urb(dev
->interrupt_in_urb
,dev
->udev
,
464 usb_rcvintpipe(dev
->udev
,
465 dev
->interrupt_in_endpoint
->bEndpointAddress
),
466 dev
->interrupt_in_buffer
,
467 le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
),
468 adu_interrupt_in_callback
,
470 dev
->interrupt_in_endpoint
->bInterval
);
471 retval
= usb_submit_urb(dev
->interrupt_in_urb
, GFP_ATOMIC
);
473 spin_unlock_irqrestore(&dev
->buflock
, flags
);
474 dbg(2," %s : submitted OK", __FUNCTION__
);
476 if (retval
== -ENOMEM
) {
477 retval
= bytes_read
? bytes_read
: -ENOMEM
;
479 spin_unlock_irqrestore(&dev
->buflock
, flags
);
480 dbg(2," %s : submit failed", __FUNCTION__
);
485 /* we wait for I/O to complete */
486 set_current_state(TASK_INTERRUPTIBLE
);
487 add_wait_queue(&dev
->read_wait
, &wait
);
488 if (!dev
->read_urb_finished
)
489 timeout
= schedule_timeout(COMMAND_TIMEOUT
);
491 set_current_state(TASK_RUNNING
);
492 remove_wait_queue(&dev
->read_wait
, &wait
);
495 dbg(2," %s : timeout", __FUNCTION__
);
496 retval
= bytes_read
? bytes_read
: -ETIMEDOUT
;
500 if (signal_pending(current
)) {
501 dbg(2," %s : signal pending", __FUNCTION__
);
502 retval
= bytes_read
? bytes_read
: -EINTR
;
510 /* if the primary buffer is empty then use it */
511 if (should_submit
&& !dev
->interrupt_in_urb
->status
==-EINPROGRESS
) {
512 usb_fill_int_urb(dev
->interrupt_in_urb
,dev
->udev
,
513 usb_rcvintpipe(dev
->udev
,
514 dev
->interrupt_in_endpoint
->bEndpointAddress
),
515 dev
->interrupt_in_buffer
,
516 le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
),
517 adu_interrupt_in_callback
,
519 dev
->interrupt_in_endpoint
->bInterval
);
520 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
521 dev
->read_urb_finished
= 0;
522 usb_submit_urb(dev
->interrupt_in_urb
, GFP_KERNEL
);
523 /* we ignore failure */
527 /* unlock the device */
528 mutex_unlock(&dev
->mtx
);
530 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
534 static ssize_t
adu_write(struct file
*file
, const __user
char *buffer
,
535 size_t count
, loff_t
*ppos
)
537 struct adu_device
*dev
;
538 size_t bytes_written
= 0;
539 size_t bytes_to_write
;
544 dbg(2," %s : enter, count = %Zd", __FUNCTION__
, count
);
546 dev
= file
->private_data
;
548 /* lock this object */
549 retval
= mutex_lock_interruptible(&dev
->mtx
);
553 /* verify that the device wasn't unplugged */
554 if (dev
->udev
== NULL
|| dev
->minor
== 0) {
556 err("No device or device unplugged %d", retval
);
560 /* verify that we actually have some data to write */
562 dbg(1," %s : write request of 0 bytes", __FUNCTION__
);
568 if (dev
->interrupt_out_urb
->status
== -EINPROGRESS
) {
569 timeout
= COMMAND_TIMEOUT
;
571 while (timeout
> 0) {
572 if (signal_pending(current
)) {
573 dbg(1," %s : interrupted", __FUNCTION__
);
577 mutex_unlock(&dev
->mtx
);
578 timeout
= interruptible_sleep_on_timeout(&dev
->write_wait
, timeout
);
579 retval
= mutex_lock_interruptible(&dev
->mtx
);
581 retval
= bytes_written
? bytes_written
: retval
;
587 dbg(1," %s : interrupted timeout: %d", __FUNCTION__
, timeout
);
591 dbg(1," %s : final timeout: %d", __FUNCTION__
, timeout
);
594 dbg(1, "%s - command timed out.", __FUNCTION__
);
599 dbg(4," %s : in progress, count = %Zd", __FUNCTION__
, count
);
602 dbg(4," %s : sending, count = %Zd", __FUNCTION__
, count
);
604 /* write the data into interrupt_out_buffer from userspace */
605 buffer_size
= le16_to_cpu(dev
->interrupt_out_endpoint
->wMaxPacketSize
);
606 bytes_to_write
= count
> buffer_size
? buffer_size
: count
;
607 dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
608 __FUNCTION__
, buffer_size
, count
, bytes_to_write
);
610 if (copy_from_user(dev
->interrupt_out_buffer
, buffer
, bytes_to_write
) != 0) {
615 /* send off the urb */
617 dev
->interrupt_out_urb
,
619 usb_sndintpipe(dev
->udev
, dev
->interrupt_out_endpoint
->bEndpointAddress
),
620 dev
->interrupt_out_buffer
,
622 adu_interrupt_out_callback
,
624 dev
->interrupt_in_endpoint
->bInterval
);
625 /* dev->interrupt_in_urb->transfer_flags |= URB_ASYNC_UNLINK; */
626 dev
->interrupt_out_urb
->actual_length
= bytes_to_write
;
627 retval
= usb_submit_urb(dev
->interrupt_out_urb
, GFP_KERNEL
);
629 err("Couldn't submit interrupt_out_urb %d", retval
);
633 buffer
+= bytes_to_write
;
634 count
-= bytes_to_write
;
636 bytes_written
+= bytes_to_write
;
640 retval
= bytes_written
;
643 /* unlock the device */
644 mutex_unlock(&dev
->mtx
);
647 dbg(2," %s : leave, return value %d", __FUNCTION__
, retval
);
652 /* file operations needed when we register this driver */
653 static const struct file_operations adu_fops
= {
654 .owner
= THIS_MODULE
,
658 .release
= adu_release
,
662 * usb class driver info in order to get a minor number from the usb core,
663 * and to have the device registered with devfs and the driver core
665 static struct usb_class_driver adu_class
= {
666 .name
= "usb/adutux%d",
668 .minor_base
= ADU_MINOR_BASE
,
674 * Called by the usb core when a new device is connected that it thinks
675 * this driver might be interested in.
677 static int adu_probe(struct usb_interface
*interface
,
678 const struct usb_device_id
*id
)
680 struct usb_device
*udev
= interface_to_usbdev(interface
);
681 struct adu_device
*dev
= NULL
;
682 struct usb_host_interface
*iface_desc
;
683 struct usb_endpoint_descriptor
*endpoint
;
684 int retval
= -ENODEV
;
689 dbg(2," %s : enter", __FUNCTION__
);
692 dev_err(&interface
->dev
, "udev is NULL.\n");
696 /* allocate memory for our device state and intialize it */
697 dev
= kzalloc(sizeof(struct adu_device
), GFP_KERNEL
);
699 dev_err(&interface
->dev
, "Out of memory\n");
704 mutex_init(&dev
->mtx
);
705 spin_lock_init(&dev
->buflock
);
707 init_waitqueue_head(&dev
->read_wait
);
708 init_waitqueue_head(&dev
->write_wait
);
710 iface_desc
= &interface
->altsetting
[0];
712 /* set up the endpoint information */
713 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
714 endpoint
= &iface_desc
->endpoint
[i
].desc
;
716 if (usb_endpoint_is_int_in(endpoint
))
717 dev
->interrupt_in_endpoint
= endpoint
;
719 if (usb_endpoint_is_int_out(endpoint
))
720 dev
->interrupt_out_endpoint
= endpoint
;
722 if (dev
->interrupt_in_endpoint
== NULL
) {
723 dev_err(&interface
->dev
, "interrupt in endpoint not found\n");
726 if (dev
->interrupt_out_endpoint
== NULL
) {
727 dev_err(&interface
->dev
, "interrupt out endpoint not found\n");
731 in_end_size
= le16_to_cpu(dev
->interrupt_in_endpoint
->wMaxPacketSize
);
732 out_end_size
= le16_to_cpu(dev
->interrupt_out_endpoint
->wMaxPacketSize
);
734 dev
->read_buffer_primary
= kmalloc((4 * in_end_size
), GFP_KERNEL
);
735 if (!dev
->read_buffer_primary
) {
736 dev_err(&interface
->dev
, "Couldn't allocate read_buffer_primary\n");
741 /* debug code prime the buffer */
742 memset(dev
->read_buffer_primary
, 'a', in_end_size
);
743 memset(dev
->read_buffer_primary
+ in_end_size
, 'b', in_end_size
);
744 memset(dev
->read_buffer_primary
+ (2 * in_end_size
), 'c', in_end_size
);
745 memset(dev
->read_buffer_primary
+ (3 * in_end_size
), 'd', in_end_size
);
747 dev
->read_buffer_secondary
= kmalloc((4 * in_end_size
), GFP_KERNEL
);
748 if (!dev
->read_buffer_secondary
) {
749 dev_err(&interface
->dev
, "Couldn't allocate read_buffer_secondary\n");
754 /* debug code prime the buffer */
755 memset(dev
->read_buffer_secondary
, 'e', in_end_size
);
756 memset(dev
->read_buffer_secondary
+ in_end_size
, 'f', in_end_size
);
757 memset(dev
->read_buffer_secondary
+ (2 * in_end_size
), 'g', in_end_size
);
758 memset(dev
->read_buffer_secondary
+ (3 * in_end_size
), 'h', in_end_size
);
760 dev
->interrupt_in_buffer
= kmalloc(in_end_size
, GFP_KERNEL
);
761 if (!dev
->interrupt_in_buffer
) {
762 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_buffer\n");
766 /* debug code prime the buffer */
767 memset(dev
->interrupt_in_buffer
, 'i', in_end_size
);
769 dev
->interrupt_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
770 if (!dev
->interrupt_in_urb
) {
771 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_urb\n");
774 dev
->interrupt_out_buffer
= kmalloc(out_end_size
, GFP_KERNEL
);
775 if (!dev
->interrupt_out_buffer
) {
776 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_buffer\n");
779 dev
->interrupt_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
780 if (!dev
->interrupt_out_urb
) {
781 dev_err(&interface
->dev
, "Couldn't allocate interrupt_out_urb\n");
785 if (!usb_string(udev
, udev
->descriptor
.iSerialNumber
, dev
->serial_number
,
786 sizeof(dev
->serial_number
))) {
787 dev_err(&interface
->dev
, "Could not retrieve serial number\n");
790 dbg(2," %s : serial_number=%s", __FUNCTION__
, dev
->serial_number
);
792 /* we can register the device now, as it is ready */
793 usb_set_intfdata(interface
, dev
);
795 retval
= usb_register_dev(interface
, &adu_class
);
798 /* something prevented us from registering this driver */
799 dev_err(&interface
->dev
, "Not able to get a minor for this device.\n");
800 usb_set_intfdata(interface
, NULL
);
804 dev
->minor
= interface
->minor
;
806 /* let the user know what node this device is now attached to */
807 dev_info(&interface
->dev
, "ADU%d %s now attached to /dev/usb/adutux%d",
808 udev
->descriptor
.idProduct
, dev
->serial_number
,
809 (dev
->minor
- ADU_MINOR_BASE
));
811 dbg(2," %s : leave, return value %p (dev)", __FUNCTION__
, dev
);
823 * Called by the usb core when the device is removed from the system.
825 static void adu_disconnect(struct usb_interface
*interface
)
827 struct adu_device
*dev
;
830 dbg(2," %s : enter", __FUNCTION__
);
832 dev
= usb_get_intfdata(interface
);
833 usb_set_intfdata(interface
, NULL
);
837 /* give back our minor */
838 usb_deregister_dev(interface
, &adu_class
);
841 mutex_lock(&dev
->mtx
); /* not interruptible */
843 /* if the device is not opened, then we clean up right now */
844 dbg(2," %s : open count %d", __FUNCTION__
, dev
->open_count
);
845 if (!dev
->open_count
) {
846 mutex_unlock(&dev
->mtx
);
850 mutex_unlock(&dev
->mtx
);
853 dev_info(&interface
->dev
, "ADU device adutux%d now disconnected",
854 (minor
- ADU_MINOR_BASE
));
856 dbg(2," %s : leave", __FUNCTION__
);
859 /* usb specific object needed to register this driver with the usb subsystem */
860 static struct usb_driver adu_driver
= {
863 .disconnect
= adu_disconnect
,
864 .id_table
= device_table
,
867 static int __init
adu_init(void)
871 dbg(2," %s : enter", __FUNCTION__
);
873 /* register this driver with the USB subsystem */
874 result
= usb_register(&adu_driver
);
876 err("usb_register failed for the "__FILE__
" driver. "
877 "Error number %d", result
);
881 info("adutux " DRIVER_DESC
" " DRIVER_VERSION
);
882 info("adutux is an experimental driver. Use at your own risk");
885 dbg(2," %s : leave, return value %d", __FUNCTION__
, result
);
890 static void __exit
adu_exit(void)
892 dbg(2," %s : enter", __FUNCTION__
);
893 /* deregister this driver with the USB subsystem */
894 usb_deregister(&adu_driver
);
895 dbg(2," %s : leave", __FUNCTION__
);
898 module_init(adu_init
);
899 module_exit(adu_exit
);
901 MODULE_AUTHOR(DRIVER_AUTHOR
);
902 MODULE_DESCRIPTION(DRIVER_DESC
);
903 MODULE_LICENSE("GPL");