2 * Native support for the I/O-Warrior USB devices
4 * Copyright (c) 2003-2005 Code Mercenaries GmbH
5 * written by Christian Lucht <lucht@codemercs.com>
9 * usb-skeleton.c by Greg Kroah-Hartman <greg@kroah.com>
10 * brlvger.c by Stephane Dalton <sdalton@videotron.ca>
11 * and St�hane Doyon <s.doyon@videotron.ca>
13 * Released under the GPLv2.
16 #include <linux/module.h>
17 #include <linux/usb.h>
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include <linux/sched.h>
21 #include <linux/smp_lock.h>
22 #include <linux/poll.h>
23 #include <linux/usb/iowarrior.h>
25 /* Version Information */
26 #define DRIVER_VERSION "v0.4.0"
27 #define DRIVER_AUTHOR "Christian Lucht <lucht@codemercs.com>"
28 #define DRIVER_DESC "USB IO-Warrior driver (Linux 2.6.x)"
30 #define USB_VENDOR_ID_CODEMERCS 1984
31 /* low speed iowarrior */
32 #define USB_DEVICE_ID_CODEMERCS_IOW40 0x1500
33 #define USB_DEVICE_ID_CODEMERCS_IOW24 0x1501
34 #define USB_DEVICE_ID_CODEMERCS_IOWPV1 0x1511
35 #define USB_DEVICE_ID_CODEMERCS_IOWPV2 0x1512
36 /* full speed iowarrior */
37 #define USB_DEVICE_ID_CODEMERCS_IOW56 0x1503
39 /* Get a minor range for your devices from the usb maintainer */
40 #ifdef CONFIG_USB_DYNAMIC_MINORS
41 #define IOWARRIOR_MINOR_BASE 0
43 #define IOWARRIOR_MINOR_BASE 208 // SKELETON_MINOR_BASE 192 + 16, not offical yet
46 /* interrupt input queue size */
47 #define MAX_INTERRUPT_BUFFER 16
49 maximum number of urbs that are submitted for writes at the same time,
50 this applies to the IOWarrior56 only!
51 IOWarrior24 and IOWarrior40 use synchronous usb_control_msg calls.
53 #define MAX_WRITES_IN_FLIGHT 4
55 /* Use our own dbg macro */
57 #define dbg( format, arg... ) do { if( debug ) printk( KERN_DEBUG __FILE__ ": " format "\n" , ## arg ); } while ( 0 )
59 MODULE_AUTHOR(DRIVER_AUTHOR
);
60 MODULE_DESCRIPTION(DRIVER_DESC
);
61 MODULE_LICENSE("GPL");
63 /* Module parameters */
65 module_param(debug
, bool, 0644);
66 MODULE_PARM_DESC(debug
, "debug=1 enables debugging messages");
68 static struct usb_driver iowarrior_driver
;
69 static DEFINE_MUTEX(iowarrior_open_disc_lock
);
75 /* Structure to hold all of our device specific stuff */
77 struct mutex mutex
; /* locks this structure */
78 struct usb_device
*udev
; /* save off the usb device pointer */
79 struct usb_interface
*interface
; /* the interface for this device */
80 unsigned char minor
; /* the starting minor number for this device */
81 struct usb_endpoint_descriptor
*int_out_endpoint
; /* endpoint for reading (needed for IOW56 only) */
82 struct usb_endpoint_descriptor
*int_in_endpoint
; /* endpoint for reading */
83 struct urb
*int_in_urb
; /* the urb for reading data */
84 unsigned char *int_in_buffer
; /* buffer for data to be read */
85 unsigned char serial_number
; /* to detect lost packages */
86 unsigned char *read_queue
; /* size is MAX_INTERRUPT_BUFFER * packet size */
87 wait_queue_head_t read_wait
;
88 wait_queue_head_t write_wait
; /* wait-queue for writing to the device */
89 atomic_t write_busy
; /* number of write-urbs submitted */
92 spinlock_t intr_idx_lock
; /* protects intr_idx */
93 atomic_t overflow_flag
; /* signals an index 'rollover' */
94 int present
; /* this is 1 as long as the device is connected */
95 int opened
; /* this is 1 if the device is currently open */
96 char chip_serial
[9]; /* the serial number string of the chip connected */
97 int report_size
; /* number of bytes in a report */
106 * USB spec identifies 5 second timeouts.
108 #define GET_TIMEOUT 5
109 #define USB_REQ_GET_REPORT 0x01
111 static int usb_get_report(struct usb_device
*dev
,
112 struct usb_host_interface
*inter
, unsigned char type
,
113 unsigned char id
, void *buf
, int size
)
115 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
117 USB_DIR_IN
| USB_TYPE_CLASS
|
118 USB_RECIP_INTERFACE
, (type
<< 8) + id
,
119 inter
->desc
.bInterfaceNumber
, buf
, size
,
124 #define USB_REQ_SET_REPORT 0x09
126 static int usb_set_report(struct usb_interface
*intf
, unsigned char type
,
127 unsigned char id
, void *buf
, int size
)
129 return usb_control_msg(interface_to_usbdev(intf
),
130 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
132 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
134 intf
->cur_altsetting
->desc
.bInterfaceNumber
, buf
,
138 /*---------------------*/
139 /* driver registration */
140 /*---------------------*/
141 /* table of devices that work with this driver */
142 static struct usb_device_id iowarrior_ids
[] = {
143 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW40
)},
144 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW24
)},
145 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOWPV1
)},
146 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOWPV2
)},
147 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW56
)},
148 {} /* Terminating entry */
150 MODULE_DEVICE_TABLE(usb
, iowarrior_ids
);
153 * USB callback handler for reading data
155 static void iowarrior_callback(struct urb
*urb
)
157 struct iowarrior
*dev
= urb
->context
;
162 int status
= urb
->status
;
177 spin_lock(&dev
->intr_idx_lock
);
178 intr_idx
= atomic_read(&dev
->intr_idx
);
179 /* aux_idx become previous intr_idx */
180 aux_idx
= (intr_idx
== 0) ? (MAX_INTERRUPT_BUFFER
- 1) : (intr_idx
- 1);
181 read_idx
= atomic_read(&dev
->read_idx
);
183 /* queue is not empty and it's interface 0 */
184 if ((intr_idx
!= read_idx
)
185 && (dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0)) {
186 /* + 1 for serial number */
187 offset
= aux_idx
* (dev
->report_size
+ 1);
189 (dev
->read_queue
+ offset
, urb
->transfer_buffer
,
191 /* equal values on interface 0 will be ignored */
192 spin_unlock(&dev
->intr_idx_lock
);
197 /* aux_idx become next intr_idx */
198 aux_idx
= (intr_idx
== (MAX_INTERRUPT_BUFFER
- 1)) ? 0 : (intr_idx
+ 1);
199 if (read_idx
== aux_idx
) {
200 /* queue full, dropping oldest input */
201 read_idx
= (++read_idx
== MAX_INTERRUPT_BUFFER
) ? 0 : read_idx
;
202 atomic_set(&dev
->read_idx
, read_idx
);
203 atomic_set(&dev
->overflow_flag
, 1);
206 /* +1 for serial number */
207 offset
= intr_idx
* (dev
->report_size
+ 1);
208 memcpy(dev
->read_queue
+ offset
, urb
->transfer_buffer
,
210 *(dev
->read_queue
+ offset
+ (dev
->report_size
)) = dev
->serial_number
++;
212 atomic_set(&dev
->intr_idx
, aux_idx
);
213 spin_unlock(&dev
->intr_idx_lock
);
214 /* tell the blocking read about the new data */
215 wake_up_interruptible(&dev
->read_wait
);
218 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
220 dev_err(&dev
->interface
->dev
, "%s - usb_submit_urb failed with result %d\n",
226 * USB Callback handler for write-ops
228 static void iowarrior_write_callback(struct urb
*urb
)
230 struct iowarrior
*dev
;
231 int status
= urb
->status
;
234 /* sync/async unlink faults aren't errors */
236 !(status
== -ENOENT
||
237 status
== -ECONNRESET
|| status
== -ESHUTDOWN
)) {
238 dbg("%s - nonzero write bulk status received: %d",
241 /* free up our allocated buffer */
242 usb_buffer_free(urb
->dev
, urb
->transfer_buffer_length
,
243 urb
->transfer_buffer
, urb
->transfer_dma
);
244 /* tell a waiting writer the interrupt-out-pipe is available again */
245 atomic_dec(&dev
->write_busy
);
246 wake_up_interruptible(&dev
->write_wait
);
252 static inline void iowarrior_delete(struct iowarrior
*dev
)
254 dbg("%s - minor %d", __func__
, dev
->minor
);
255 kfree(dev
->int_in_buffer
);
256 usb_free_urb(dev
->int_in_urb
);
257 kfree(dev
->read_queue
);
261 /*---------------------*/
262 /* fops implementation */
263 /*---------------------*/
265 static int read_index(struct iowarrior
*dev
)
267 int intr_idx
, read_idx
;
269 read_idx
= atomic_read(&dev
->read_idx
);
270 intr_idx
= atomic_read(&dev
->intr_idx
);
272 return (read_idx
== intr_idx
? -1 : read_idx
);
278 static ssize_t
iowarrior_read(struct file
*file
, char __user
*buffer
,
279 size_t count
, loff_t
*ppos
)
281 struct iowarrior
*dev
;
285 dev
= (struct iowarrior
*)file
->private_data
;
287 /* verify that the device wasn't unplugged */
288 if (dev
== NULL
|| !dev
->present
)
291 dbg("%s - minor %d, count = %zd", __func__
, dev
->minor
, count
);
293 /* read count must be packet size (+ time stamp) */
294 if ((count
!= dev
->report_size
)
295 && (count
!= (dev
->report_size
+ 1)))
298 /* repeat until no buffer overrun in callback handler occur */
300 atomic_set(&dev
->overflow_flag
, 0);
301 if ((read_idx
= read_index(dev
)) == -1) {
303 if (file
->f_flags
& O_NONBLOCK
)
306 //next line will return when there is either new data, or the device is unplugged
307 int r
= wait_event_interruptible(dev
->read_wait
,
314 //we were interrupted by a signal
318 //The device was unplugged
321 if (read_idx
== -1) {
322 // Can this happen ???
328 offset
= read_idx
* (dev
->report_size
+ 1);
329 if (copy_to_user(buffer
, dev
->read_queue
+ offset
, count
)) {
332 } while (atomic_read(&dev
->overflow_flag
));
334 read_idx
= ++read_idx
== MAX_INTERRUPT_BUFFER
? 0 : read_idx
;
335 atomic_set(&dev
->read_idx
, read_idx
);
342 static ssize_t
iowarrior_write(struct file
*file
,
343 const char __user
*user_buffer
,
344 size_t count
, loff_t
*ppos
)
346 struct iowarrior
*dev
;
348 char *buf
= NULL
; /* for IOW24 and IOW56 we need a buffer */
349 struct urb
*int_out_urb
= NULL
;
351 dev
= (struct iowarrior
*)file
->private_data
;
353 mutex_lock(&dev
->mutex
);
354 /* verify that the device wasn't unplugged */
359 dbg("%s - minor %d, count = %zd", __func__
, dev
->minor
, count
);
360 /* if count is 0 we're already done */
365 /* We only accept full reports */
366 if (count
!= dev
->report_size
) {
370 switch (dev
->product_id
) {
371 case USB_DEVICE_ID_CODEMERCS_IOW24
:
372 case USB_DEVICE_ID_CODEMERCS_IOWPV1
:
373 case USB_DEVICE_ID_CODEMERCS_IOWPV2
:
374 case USB_DEVICE_ID_CODEMERCS_IOW40
:
375 /* IOW24 and IOW40 use a synchronous call */
376 buf
= kmalloc(8, GFP_KERNEL
); /* 8 bytes are enough for both products */
381 if (copy_from_user(buf
, user_buffer
, count
)) {
386 retval
= usb_set_report(dev
->interface
, 2, 0, buf
, count
);
390 case USB_DEVICE_ID_CODEMERCS_IOW56
:
391 /* The IOW56 uses asynchronous IO and more urbs */
392 if (atomic_read(&dev
->write_busy
) == MAX_WRITES_IN_FLIGHT
) {
393 /* Wait until we are below the limit for submitted urbs */
394 if (file
->f_flags
& O_NONBLOCK
) {
398 retval
= wait_event_interruptible(dev
->write_wait
,
399 (!dev
->present
|| (atomic_read (&dev
-> write_busy
) < MAX_WRITES_IN_FLIGHT
)));
401 /* we were interrupted by a signal */
406 /* The device was unplugged */
411 /* We were closed while waiting for an URB */
417 atomic_inc(&dev
->write_busy
);
418 int_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
421 dbg("%s Unable to allocate urb ", __func__
);
424 buf
= usb_buffer_alloc(dev
->udev
, dev
->report_size
,
425 GFP_KERNEL
, &int_out_urb
->transfer_dma
);
428 dbg("%s Unable to allocate buffer ", __func__
);
429 goto error_no_buffer
;
431 usb_fill_int_urb(int_out_urb
, dev
->udev
,
432 usb_sndintpipe(dev
->udev
,
433 dev
->int_out_endpoint
->bEndpointAddress
),
434 buf
, dev
->report_size
,
435 iowarrior_write_callback
, dev
,
436 dev
->int_out_endpoint
->bInterval
);
437 int_out_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
438 if (copy_from_user(buf
, user_buffer
, count
)) {
442 retval
= usb_submit_urb(int_out_urb
, GFP_KERNEL
);
444 dbg("%s submit error %d for urb nr.%d", __func__
,
445 retval
, atomic_read(&dev
->write_busy
));
450 usb_free_urb(int_out_urb
);
454 /* what do we have here ? An unsupported Product-ID ? */
455 dev_err(&dev
->interface
->dev
, "%s - not supported for product=0x%x\n",
456 __func__
, dev
->product_id
);
462 usb_buffer_free(dev
->udev
, dev
->report_size
, buf
,
463 int_out_urb
->transfer_dma
);
465 usb_free_urb(int_out_urb
);
467 atomic_dec(&dev
->write_busy
);
468 wake_up_interruptible(&dev
->write_wait
);
470 mutex_unlock(&dev
->mutex
);
477 static long iowarrior_ioctl(struct file
*file
, unsigned int cmd
,
480 struct iowarrior
*dev
= NULL
;
482 __u8 __user
*user_buffer
;
484 int io_res
; /* checks for bytes read/written and copy_to/from_user results */
486 dev
= (struct iowarrior
*)file
->private_data
;
491 buffer
= kzalloc(dev
->report_size
, GFP_KERNEL
);
495 /* lock this object */
497 mutex_lock(&dev
->mutex
);
499 /* verify that the device wasn't unplugged */
505 dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__
, dev
->minor
, cmd
,
512 if (dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW24
||
513 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOWPV1
||
514 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOWPV2
||
515 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW40
) {
516 user_buffer
= (__u8 __user
*)arg
;
517 io_res
= copy_from_user(buffer
, user_buffer
,
522 io_res
= usb_set_report(dev
->interface
, 2, 0,
530 dev_err(&dev
->interface
->dev
,
531 "ioctl 'IOW_WRITE' is not supported for product=0x%x.\n",
536 user_buffer
= (__u8 __user
*)arg
;
537 io_res
= usb_get_report(dev
->udev
,
538 dev
->interface
->cur_altsetting
, 1, 0,
539 buffer
, dev
->report_size
);
543 io_res
= copy_to_user(user_buffer
, buffer
, dev
->report_size
);
550 /* Report available information for the device */
551 struct iowarrior_info info
;
552 /* needed for power consumption */
553 struct usb_config_descriptor
*cfg_descriptor
= &dev
->udev
->actconfig
->desc
;
555 memset(&info
, 0, sizeof(info
));
556 /* directly from the descriptor */
557 info
.vendor
= le16_to_cpu(dev
->udev
->descriptor
.idVendor
);
558 info
.product
= dev
->product_id
;
559 info
.revision
= le16_to_cpu(dev
->udev
->descriptor
.bcdDevice
);
561 /* 0==UNKNOWN, 1==LOW(usb1.1) ,2=FULL(usb1.1), 3=HIGH(usb2.0) */
562 info
.speed
= le16_to_cpu(dev
->udev
->speed
);
563 info
.if_num
= dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
;
564 info
.report_size
= dev
->report_size
;
566 /* serial number string has been read earlier 8 chars or empty string */
567 memcpy(info
.serial
, dev
->chip_serial
,
568 sizeof(dev
->chip_serial
));
569 if (cfg_descriptor
== NULL
) {
570 info
.power
= -1; /* no information available */
572 /* the MaxPower is stored in units of 2mA to make it fit into a byte-value */
573 info
.power
= cfg_descriptor
->bMaxPower
* 2;
575 io_res
= copy_to_user((struct iowarrior_info __user
*)arg
, &info
,
576 sizeof(struct iowarrior_info
));
582 /* return that we did not understand this ioctl call */
587 /* unlock the device */
588 mutex_unlock(&dev
->mutex
);
597 static int iowarrior_open(struct inode
*inode
, struct file
*file
)
599 struct iowarrior
*dev
= NULL
;
600 struct usb_interface
*interface
;
606 subminor
= iminor(inode
);
608 interface
= usb_find_interface(&iowarrior_driver
, subminor
);
610 err("%s - error, can't find device for minor %d", __func__
,
615 mutex_lock(&iowarrior_open_disc_lock
);
616 dev
= usb_get_intfdata(interface
);
618 mutex_unlock(&iowarrior_open_disc_lock
);
622 mutex_lock(&dev
->mutex
);
623 mutex_unlock(&iowarrior_open_disc_lock
);
625 /* Only one process can open each device, no sharing. */
631 /* setup interrupt handler for receiving values */
632 if ((retval
= usb_submit_urb(dev
->int_in_urb
, GFP_KERNEL
)) < 0) {
633 dev_err(&interface
->dev
, "Error %d while submitting URB\n", retval
);
637 /* increment our usage count for the driver */
639 /* save our object in the file's private structure */
640 file
->private_data
= dev
;
644 mutex_unlock(&dev
->mutex
);
651 static int iowarrior_release(struct inode
*inode
, struct file
*file
)
653 struct iowarrior
*dev
;
656 dev
= (struct iowarrior
*)file
->private_data
;
661 dbg("%s - minor %d", __func__
, dev
->minor
);
663 /* lock our device */
664 mutex_lock(&dev
->mutex
);
666 if (dev
->opened
<= 0) {
667 retval
= -ENODEV
; /* close called more than once */
668 mutex_unlock(&dev
->mutex
);
670 dev
->opened
= 0; /* we're closeing now */
674 The device is still connected so we only shutdown
675 pending read-/write-ops.
677 usb_kill_urb(dev
->int_in_urb
);
678 wake_up_interruptible(&dev
->read_wait
);
679 wake_up_interruptible(&dev
->write_wait
);
680 mutex_unlock(&dev
->mutex
);
682 /* The device was unplugged, cleanup resources */
683 mutex_unlock(&dev
->mutex
);
684 iowarrior_delete(dev
);
690 static unsigned iowarrior_poll(struct file
*file
, poll_table
* wait
)
692 struct iowarrior
*dev
= file
->private_data
;
693 unsigned int mask
= 0;
696 return POLLERR
| POLLHUP
;
698 poll_wait(file
, &dev
->read_wait
, wait
);
699 poll_wait(file
, &dev
->write_wait
, wait
);
702 return POLLERR
| POLLHUP
;
704 if (read_index(dev
) != -1)
705 mask
|= POLLIN
| POLLRDNORM
;
707 if (atomic_read(&dev
->write_busy
) < MAX_WRITES_IN_FLIGHT
)
708 mask
|= POLLOUT
| POLLWRNORM
;
713 * File operations needed when we register this driver.
714 * This assumes that this driver NEEDS file operations,
715 * of course, which means that the driver is expected
716 * to have a node in the /dev directory. If the USB
717 * device were for a network interface then the driver
718 * would use "struct net_driver" instead, and a serial
719 * device would use "struct tty_driver".
721 static const struct file_operations iowarrior_fops
= {
722 .owner
= THIS_MODULE
,
723 .write
= iowarrior_write
,
724 .read
= iowarrior_read
,
725 .unlocked_ioctl
= iowarrior_ioctl
,
726 .open
= iowarrior_open
,
727 .release
= iowarrior_release
,
728 .poll
= iowarrior_poll
,
731 static char *iowarrior_devnode(struct device
*dev
, mode_t
*mode
)
733 return kasprintf(GFP_KERNEL
, "usb/%s", dev_name(dev
));
737 * usb class driver info in order to get a minor number from the usb core,
738 * and to have the device registered with devfs and the driver core
740 static struct usb_class_driver iowarrior_class
= {
741 .name
= "iowarrior%d",
742 .devnode
= iowarrior_devnode
,
743 .fops
= &iowarrior_fops
,
744 .minor_base
= IOWARRIOR_MINOR_BASE
,
747 /*---------------------------------*/
748 /* probe and disconnect functions */
749 /*---------------------------------*/
753 * Called by the usb core when a new device is connected that it thinks
754 * this driver might be interested in.
756 static int iowarrior_probe(struct usb_interface
*interface
,
757 const struct usb_device_id
*id
)
759 struct usb_device
*udev
= interface_to_usbdev(interface
);
760 struct iowarrior
*dev
= NULL
;
761 struct usb_host_interface
*iface_desc
;
762 struct usb_endpoint_descriptor
*endpoint
;
764 int retval
= -ENOMEM
;
766 /* allocate memory for our device state and intialize it */
767 dev
= kzalloc(sizeof(struct iowarrior
), GFP_KERNEL
);
769 dev_err(&interface
->dev
, "Out of memory\n");
773 mutex_init(&dev
->mutex
);
775 atomic_set(&dev
->intr_idx
, 0);
776 atomic_set(&dev
->read_idx
, 0);
777 spin_lock_init(&dev
->intr_idx_lock
);
778 atomic_set(&dev
->overflow_flag
, 0);
779 init_waitqueue_head(&dev
->read_wait
);
780 atomic_set(&dev
->write_busy
, 0);
781 init_waitqueue_head(&dev
->write_wait
);
784 dev
->interface
= interface
;
786 iface_desc
= interface
->cur_altsetting
;
787 dev
->product_id
= le16_to_cpu(udev
->descriptor
.idProduct
);
789 /* set up the endpoint information */
790 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
791 endpoint
= &iface_desc
->endpoint
[i
].desc
;
793 if (usb_endpoint_is_int_in(endpoint
))
794 dev
->int_in_endpoint
= endpoint
;
795 if (usb_endpoint_is_int_out(endpoint
))
796 /* this one will match for the IOWarrior56 only */
797 dev
->int_out_endpoint
= endpoint
;
799 /* we have to check the report_size often, so remember it in the endianess suitable for our machine */
800 dev
->report_size
= le16_to_cpu(dev
->int_in_endpoint
->wMaxPacketSize
);
801 if ((dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0) &&
802 (dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW56
))
803 /* IOWarrior56 has wMaxPacketSize different from report size */
804 dev
->report_size
= 7;
806 /* create the urb and buffer for reading */
807 dev
->int_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
808 if (!dev
->int_in_urb
) {
809 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_urb\n");
812 dev
->int_in_buffer
= kmalloc(dev
->report_size
, GFP_KERNEL
);
813 if (!dev
->int_in_buffer
) {
814 dev_err(&interface
->dev
, "Couldn't allocate int_in_buffer\n");
817 usb_fill_int_urb(dev
->int_in_urb
, dev
->udev
,
818 usb_rcvintpipe(dev
->udev
,
819 dev
->int_in_endpoint
->bEndpointAddress
),
820 dev
->int_in_buffer
, dev
->report_size
,
821 iowarrior_callback
, dev
,
822 dev
->int_in_endpoint
->bInterval
);
823 /* create an internal buffer for interrupt data from the device */
825 kmalloc(((dev
->report_size
+ 1) * MAX_INTERRUPT_BUFFER
),
827 if (!dev
->read_queue
) {
828 dev_err(&interface
->dev
, "Couldn't allocate read_queue\n");
831 /* Get the serial-number of the chip */
832 memset(dev
->chip_serial
, 0x00, sizeof(dev
->chip_serial
));
833 usb_string(udev
, udev
->descriptor
.iSerialNumber
, dev
->chip_serial
,
834 sizeof(dev
->chip_serial
));
835 if (strlen(dev
->chip_serial
) != 8)
836 memset(dev
->chip_serial
, 0x00, sizeof(dev
->chip_serial
));
838 /* Set the idle timeout to 0, if this is interface 0 */
839 if (dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0) {
840 usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
842 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
, 0,
843 0, NULL
, 0, USB_CTRL_SET_TIMEOUT
);
845 /* allow device read and ioctl */
848 /* we can register the device now, as it is ready */
849 usb_set_intfdata(interface
, dev
);
851 retval
= usb_register_dev(interface
, &iowarrior_class
);
853 /* something prevented us from registering this driver */
854 dev_err(&interface
->dev
, "Not able to get a minor for this device.\n");
855 usb_set_intfdata(interface
, NULL
);
859 dev
->minor
= interface
->minor
;
861 /* let the user know what node this device is now attached to */
862 dev_info(&interface
->dev
, "IOWarrior product=0x%x, serial=%s interface=%d "
863 "now attached to iowarrior%d\n", dev
->product_id
, dev
->chip_serial
,
864 iface_desc
->desc
.bInterfaceNumber
, dev
->minor
- IOWARRIOR_MINOR_BASE
);
868 iowarrior_delete(dev
);
873 * iowarrior_disconnect
875 * Called by the usb core when the device is removed from the system.
877 static void iowarrior_disconnect(struct usb_interface
*interface
)
879 struct iowarrior
*dev
;
882 dev
= usb_get_intfdata(interface
);
883 mutex_lock(&iowarrior_open_disc_lock
);
884 usb_set_intfdata(interface
, NULL
);
888 /* give back our minor */
889 usb_deregister_dev(interface
, &iowarrior_class
);
891 mutex_lock(&dev
->mutex
);
893 /* prevent device read, write and ioctl */
896 mutex_unlock(&dev
->mutex
);
897 mutex_unlock(&iowarrior_open_disc_lock
);
900 /* There is a process that holds a filedescriptor to the device ,
901 so we only shutdown read-/write-ops going on.
902 Deleting the device is postponed until close() was called.
904 usb_kill_urb(dev
->int_in_urb
);
905 wake_up_interruptible(&dev
->read_wait
);
906 wake_up_interruptible(&dev
->write_wait
);
908 /* no process is using the device, cleanup now */
909 iowarrior_delete(dev
);
912 dev_info(&interface
->dev
, "I/O-Warror #%d now disconnected\n",
913 minor
- IOWARRIOR_MINOR_BASE
);
916 /* usb specific object needed to register this driver with the usb subsystem */
917 static struct usb_driver iowarrior_driver
= {
919 .probe
= iowarrior_probe
,
920 .disconnect
= iowarrior_disconnect
,
921 .id_table
= iowarrior_ids
,
924 static int __init
iowarrior_init(void)
926 return usb_register(&iowarrior_driver
);
929 static void __exit
iowarrior_exit(void)
931 usb_deregister(&iowarrior_driver
);
934 module_init(iowarrior_init
);
935 module_exit(iowarrior_exit
);