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/mutex.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 */
64 static DEFINE_MUTEX(iowarrior_mutex
);
66 module_param(debug
, bool, 0644);
67 MODULE_PARM_DESC(debug
, "debug=1 enables debugging messages");
69 static struct usb_driver iowarrior_driver
;
70 static DEFINE_MUTEX(iowarrior_open_disc_lock
);
76 /* Structure to hold all of our device specific stuff */
78 struct mutex mutex
; /* locks this structure */
79 struct usb_device
*udev
; /* save off the usb device pointer */
80 struct usb_interface
*interface
; /* the interface for this device */
81 unsigned char minor
; /* the starting minor number for this device */
82 struct usb_endpoint_descriptor
*int_out_endpoint
; /* endpoint for reading (needed for IOW56 only) */
83 struct usb_endpoint_descriptor
*int_in_endpoint
; /* endpoint for reading */
84 struct urb
*int_in_urb
; /* the urb for reading data */
85 unsigned char *int_in_buffer
; /* buffer for data to be read */
86 unsigned char serial_number
; /* to detect lost packages */
87 unsigned char *read_queue
; /* size is MAX_INTERRUPT_BUFFER * packet size */
88 wait_queue_head_t read_wait
;
89 wait_queue_head_t write_wait
; /* wait-queue for writing to the device */
90 atomic_t write_busy
; /* number of write-urbs submitted */
93 spinlock_t intr_idx_lock
; /* protects intr_idx */
94 atomic_t overflow_flag
; /* signals an index 'rollover' */
95 int present
; /* this is 1 as long as the device is connected */
96 int opened
; /* this is 1 if the device is currently open */
97 char chip_serial
[9]; /* the serial number string of the chip connected */
98 int report_size
; /* number of bytes in a report */
107 * USB spec identifies 5 second timeouts.
109 #define GET_TIMEOUT 5
110 #define USB_REQ_GET_REPORT 0x01
112 static int usb_get_report(struct usb_device
*dev
,
113 struct usb_host_interface
*inter
, unsigned char type
,
114 unsigned char id
, void *buf
, int size
)
116 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
118 USB_DIR_IN
| USB_TYPE_CLASS
|
119 USB_RECIP_INTERFACE
, (type
<< 8) + id
,
120 inter
->desc
.bInterfaceNumber
, buf
, size
,
125 #define USB_REQ_SET_REPORT 0x09
127 static int usb_set_report(struct usb_interface
*intf
, unsigned char type
,
128 unsigned char id
, void *buf
, int size
)
130 return usb_control_msg(interface_to_usbdev(intf
),
131 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
133 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
135 intf
->cur_altsetting
->desc
.bInterfaceNumber
, buf
,
139 /*---------------------*/
140 /* driver registration */
141 /*---------------------*/
142 /* table of devices that work with this driver */
143 static const struct usb_device_id iowarrior_ids
[] = {
144 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW40
)},
145 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW24
)},
146 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOWPV1
)},
147 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOWPV2
)},
148 {USB_DEVICE(USB_VENDOR_ID_CODEMERCS
, USB_DEVICE_ID_CODEMERCS_IOW56
)},
149 {} /* Terminating entry */
151 MODULE_DEVICE_TABLE(usb
, iowarrior_ids
);
154 * USB callback handler for reading data
156 static void iowarrior_callback(struct urb
*urb
)
158 struct iowarrior
*dev
= urb
->context
;
163 int status
= urb
->status
;
178 spin_lock(&dev
->intr_idx_lock
);
179 intr_idx
= atomic_read(&dev
->intr_idx
);
180 /* aux_idx become previous intr_idx */
181 aux_idx
= (intr_idx
== 0) ? (MAX_INTERRUPT_BUFFER
- 1) : (intr_idx
- 1);
182 read_idx
= atomic_read(&dev
->read_idx
);
184 /* queue is not empty and it's interface 0 */
185 if ((intr_idx
!= read_idx
)
186 && (dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0)) {
187 /* + 1 for serial number */
188 offset
= aux_idx
* (dev
->report_size
+ 1);
190 (dev
->read_queue
+ offset
, urb
->transfer_buffer
,
192 /* equal values on interface 0 will be ignored */
193 spin_unlock(&dev
->intr_idx_lock
);
198 /* aux_idx become next intr_idx */
199 aux_idx
= (intr_idx
== (MAX_INTERRUPT_BUFFER
- 1)) ? 0 : (intr_idx
+ 1);
200 if (read_idx
== aux_idx
) {
201 /* queue full, dropping oldest input */
202 read_idx
= (++read_idx
== MAX_INTERRUPT_BUFFER
) ? 0 : read_idx
;
203 atomic_set(&dev
->read_idx
, read_idx
);
204 atomic_set(&dev
->overflow_flag
, 1);
207 /* +1 for serial number */
208 offset
= intr_idx
* (dev
->report_size
+ 1);
209 memcpy(dev
->read_queue
+ offset
, urb
->transfer_buffer
,
211 *(dev
->read_queue
+ offset
+ (dev
->report_size
)) = dev
->serial_number
++;
213 atomic_set(&dev
->intr_idx
, aux_idx
);
214 spin_unlock(&dev
->intr_idx_lock
);
215 /* tell the blocking read about the new data */
216 wake_up_interruptible(&dev
->read_wait
);
219 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
221 dev_err(&dev
->interface
->dev
, "%s - usb_submit_urb failed with result %d\n",
227 * USB Callback handler for write-ops
229 static void iowarrior_write_callback(struct urb
*urb
)
231 struct iowarrior
*dev
;
232 int status
= urb
->status
;
235 /* sync/async unlink faults aren't errors */
237 !(status
== -ENOENT
||
238 status
== -ECONNRESET
|| status
== -ESHUTDOWN
)) {
239 dbg("%s - nonzero write bulk status received: %d",
242 /* free up our allocated buffer */
243 usb_free_coherent(urb
->dev
, urb
->transfer_buffer_length
,
244 urb
->transfer_buffer
, urb
->transfer_dma
);
245 /* tell a waiting writer the interrupt-out-pipe is available again */
246 atomic_dec(&dev
->write_busy
);
247 wake_up_interruptible(&dev
->write_wait
);
253 static inline void iowarrior_delete(struct iowarrior
*dev
)
255 dbg("%s - minor %d", __func__
, dev
->minor
);
256 kfree(dev
->int_in_buffer
);
257 usb_free_urb(dev
->int_in_urb
);
258 kfree(dev
->read_queue
);
262 /*---------------------*/
263 /* fops implementation */
264 /*---------------------*/
266 static int read_index(struct iowarrior
*dev
)
268 int intr_idx
, read_idx
;
270 read_idx
= atomic_read(&dev
->read_idx
);
271 intr_idx
= atomic_read(&dev
->intr_idx
);
273 return (read_idx
== intr_idx
? -1 : read_idx
);
279 static ssize_t
iowarrior_read(struct file
*file
, char __user
*buffer
,
280 size_t count
, loff_t
*ppos
)
282 struct iowarrior
*dev
;
286 dev
= file
->private_data
;
288 /* verify that the device wasn't unplugged */
289 if (dev
== NULL
|| !dev
->present
)
292 dbg("%s - minor %d, count = %zd", __func__
, dev
->minor
, count
);
294 /* read count must be packet size (+ time stamp) */
295 if ((count
!= dev
->report_size
)
296 && (count
!= (dev
->report_size
+ 1)))
299 /* repeat until no buffer overrun in callback handler occur */
301 atomic_set(&dev
->overflow_flag
, 0);
302 if ((read_idx
= read_index(dev
)) == -1) {
304 if (file
->f_flags
& O_NONBLOCK
)
307 //next line will return when there is either new data, or the device is unplugged
308 int r
= wait_event_interruptible(dev
->read_wait
,
315 //we were interrupted by a signal
319 //The device was unplugged
322 if (read_idx
== -1) {
323 // Can this happen ???
329 offset
= read_idx
* (dev
->report_size
+ 1);
330 if (copy_to_user(buffer
, dev
->read_queue
+ offset
, count
)) {
333 } while (atomic_read(&dev
->overflow_flag
));
335 read_idx
= ++read_idx
== MAX_INTERRUPT_BUFFER
? 0 : read_idx
;
336 atomic_set(&dev
->read_idx
, read_idx
);
343 static ssize_t
iowarrior_write(struct file
*file
,
344 const char __user
*user_buffer
,
345 size_t count
, loff_t
*ppos
)
347 struct iowarrior
*dev
;
349 char *buf
= NULL
; /* for IOW24 and IOW56 we need a buffer */
350 struct urb
*int_out_urb
= NULL
;
352 dev
= file
->private_data
;
354 mutex_lock(&dev
->mutex
);
355 /* verify that the device wasn't unplugged */
360 dbg("%s - minor %d, count = %zd", __func__
, dev
->minor
, count
);
361 /* if count is 0 we're already done */
366 /* We only accept full reports */
367 if (count
!= dev
->report_size
) {
371 switch (dev
->product_id
) {
372 case USB_DEVICE_ID_CODEMERCS_IOW24
:
373 case USB_DEVICE_ID_CODEMERCS_IOWPV1
:
374 case USB_DEVICE_ID_CODEMERCS_IOWPV2
:
375 case USB_DEVICE_ID_CODEMERCS_IOW40
:
376 /* IOW24 and IOW40 use a synchronous call */
377 buf
= kmalloc(count
, GFP_KERNEL
);
382 if (copy_from_user(buf
, user_buffer
, count
)) {
387 retval
= usb_set_report(dev
->interface
, 2, 0, buf
, count
);
391 case USB_DEVICE_ID_CODEMERCS_IOW56
:
392 /* The IOW56 uses asynchronous IO and more urbs */
393 if (atomic_read(&dev
->write_busy
) == MAX_WRITES_IN_FLIGHT
) {
394 /* Wait until we are below the limit for submitted urbs */
395 if (file
->f_flags
& O_NONBLOCK
) {
399 retval
= wait_event_interruptible(dev
->write_wait
,
400 (!dev
->present
|| (atomic_read (&dev
-> write_busy
) < MAX_WRITES_IN_FLIGHT
)));
402 /* we were interrupted by a signal */
407 /* The device was unplugged */
412 /* We were closed while waiting for an URB */
418 atomic_inc(&dev
->write_busy
);
419 int_out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
422 dbg("%s Unable to allocate urb ", __func__
);
425 buf
= usb_alloc_coherent(dev
->udev
, dev
->report_size
,
426 GFP_KERNEL
, &int_out_urb
->transfer_dma
);
429 dbg("%s Unable to allocate buffer ", __func__
);
430 goto error_no_buffer
;
432 usb_fill_int_urb(int_out_urb
, dev
->udev
,
433 usb_sndintpipe(dev
->udev
,
434 dev
->int_out_endpoint
->bEndpointAddress
),
435 buf
, dev
->report_size
,
436 iowarrior_write_callback
, dev
,
437 dev
->int_out_endpoint
->bInterval
);
438 int_out_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
439 if (copy_from_user(buf
, user_buffer
, count
)) {
443 retval
= usb_submit_urb(int_out_urb
, GFP_KERNEL
);
445 dbg("%s submit error %d for urb nr.%d", __func__
,
446 retval
, atomic_read(&dev
->write_busy
));
451 usb_free_urb(int_out_urb
);
455 /* what do we have here ? An unsupported Product-ID ? */
456 dev_err(&dev
->interface
->dev
, "%s - not supported for product=0x%x\n",
457 __func__
, dev
->product_id
);
463 usb_free_coherent(dev
->udev
, dev
->report_size
, buf
,
464 int_out_urb
->transfer_dma
);
466 usb_free_urb(int_out_urb
);
468 atomic_dec(&dev
->write_busy
);
469 wake_up_interruptible(&dev
->write_wait
);
471 mutex_unlock(&dev
->mutex
);
478 static long iowarrior_ioctl(struct file
*file
, unsigned int cmd
,
481 struct iowarrior
*dev
= NULL
;
483 __u8 __user
*user_buffer
;
485 int io_res
; /* checks for bytes read/written and copy_to/from_user results */
487 dev
= file
->private_data
;
492 buffer
= kzalloc(dev
->report_size
, GFP_KERNEL
);
496 /* lock this object */
497 mutex_lock(&iowarrior_mutex
);
498 mutex_lock(&dev
->mutex
);
500 /* verify that the device wasn't unplugged */
506 dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__
, dev
->minor
, cmd
,
513 if (dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW24
||
514 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOWPV1
||
515 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOWPV2
||
516 dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW40
) {
517 user_buffer
= (__u8 __user
*)arg
;
518 io_res
= copy_from_user(buffer
, user_buffer
,
523 io_res
= usb_set_report(dev
->interface
, 2, 0,
531 dev_err(&dev
->interface
->dev
,
532 "ioctl 'IOW_WRITE' is not supported for product=0x%x.\n",
537 user_buffer
= (__u8 __user
*)arg
;
538 io_res
= usb_get_report(dev
->udev
,
539 dev
->interface
->cur_altsetting
, 1, 0,
540 buffer
, dev
->report_size
);
544 io_res
= copy_to_user(user_buffer
, buffer
, dev
->report_size
);
551 /* Report available information for the device */
552 struct iowarrior_info info
;
553 /* needed for power consumption */
554 struct usb_config_descriptor
*cfg_descriptor
= &dev
->udev
->actconfig
->desc
;
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
);
589 mutex_unlock(&iowarrior_mutex
);
597 static int iowarrior_open(struct inode
*inode
, struct file
*file
)
599 struct iowarrior
*dev
= NULL
;
600 struct usb_interface
*interface
;
606 mutex_lock(&iowarrior_mutex
);
607 subminor
= iminor(inode
);
609 interface
= usb_find_interface(&iowarrior_driver
, subminor
);
611 mutex_unlock(&iowarrior_mutex
);
612 err("%s - error, can't find device for minor %d", __func__
,
617 mutex_lock(&iowarrior_open_disc_lock
);
618 dev
= usb_get_intfdata(interface
);
620 mutex_unlock(&iowarrior_open_disc_lock
);
621 mutex_unlock(&iowarrior_mutex
);
625 mutex_lock(&dev
->mutex
);
626 mutex_unlock(&iowarrior_open_disc_lock
);
628 /* Only one process can open each device, no sharing. */
634 /* setup interrupt handler for receiving values */
635 if ((retval
= usb_submit_urb(dev
->int_in_urb
, GFP_KERNEL
)) < 0) {
636 dev_err(&interface
->dev
, "Error %d while submitting URB\n", retval
);
640 /* increment our usage count for the driver */
642 /* save our object in the file's private structure */
643 file
->private_data
= dev
;
647 mutex_unlock(&dev
->mutex
);
648 mutex_unlock(&iowarrior_mutex
);
655 static int iowarrior_release(struct inode
*inode
, struct file
*file
)
657 struct iowarrior
*dev
;
660 dev
= file
->private_data
;
665 dbg("%s - minor %d", __func__
, dev
->minor
);
667 /* lock our device */
668 mutex_lock(&dev
->mutex
);
670 if (dev
->opened
<= 0) {
671 retval
= -ENODEV
; /* close called more than once */
672 mutex_unlock(&dev
->mutex
);
674 dev
->opened
= 0; /* we're closeing now */
678 The device is still connected so we only shutdown
679 pending read-/write-ops.
681 usb_kill_urb(dev
->int_in_urb
);
682 wake_up_interruptible(&dev
->read_wait
);
683 wake_up_interruptible(&dev
->write_wait
);
684 mutex_unlock(&dev
->mutex
);
686 /* The device was unplugged, cleanup resources */
687 mutex_unlock(&dev
->mutex
);
688 iowarrior_delete(dev
);
694 static unsigned iowarrior_poll(struct file
*file
, poll_table
* wait
)
696 struct iowarrior
*dev
= file
->private_data
;
697 unsigned int mask
= 0;
700 return POLLERR
| POLLHUP
;
702 poll_wait(file
, &dev
->read_wait
, wait
);
703 poll_wait(file
, &dev
->write_wait
, wait
);
706 return POLLERR
| POLLHUP
;
708 if (read_index(dev
) != -1)
709 mask
|= POLLIN
| POLLRDNORM
;
711 if (atomic_read(&dev
->write_busy
) < MAX_WRITES_IN_FLIGHT
)
712 mask
|= POLLOUT
| POLLWRNORM
;
717 * File operations needed when we register this driver.
718 * This assumes that this driver NEEDS file operations,
719 * of course, which means that the driver is expected
720 * to have a node in the /dev directory. If the USB
721 * device were for a network interface then the driver
722 * would use "struct net_driver" instead, and a serial
723 * device would use "struct tty_driver".
725 static const struct file_operations iowarrior_fops
= {
726 .owner
= THIS_MODULE
,
727 .write
= iowarrior_write
,
728 .read
= iowarrior_read
,
729 .unlocked_ioctl
= iowarrior_ioctl
,
730 .open
= iowarrior_open
,
731 .release
= iowarrior_release
,
732 .poll
= iowarrior_poll
,
733 .llseek
= noop_llseek
,
736 static char *iowarrior_devnode(struct device
*dev
, mode_t
*mode
)
738 return kasprintf(GFP_KERNEL
, "usb/%s", dev_name(dev
));
742 * usb class driver info in order to get a minor number from the usb core,
743 * and to have the device registered with devfs and the driver core
745 static struct usb_class_driver iowarrior_class
= {
746 .name
= "iowarrior%d",
747 .devnode
= iowarrior_devnode
,
748 .fops
= &iowarrior_fops
,
749 .minor_base
= IOWARRIOR_MINOR_BASE
,
752 /*---------------------------------*/
753 /* probe and disconnect functions */
754 /*---------------------------------*/
758 * Called by the usb core when a new device is connected that it thinks
759 * this driver might be interested in.
761 static int iowarrior_probe(struct usb_interface
*interface
,
762 const struct usb_device_id
*id
)
764 struct usb_device
*udev
= interface_to_usbdev(interface
);
765 struct iowarrior
*dev
= NULL
;
766 struct usb_host_interface
*iface_desc
;
767 struct usb_endpoint_descriptor
*endpoint
;
769 int retval
= -ENOMEM
;
771 /* allocate memory for our device state and initialize it */
772 dev
= kzalloc(sizeof(struct iowarrior
), GFP_KERNEL
);
774 dev_err(&interface
->dev
, "Out of memory\n");
778 mutex_init(&dev
->mutex
);
780 atomic_set(&dev
->intr_idx
, 0);
781 atomic_set(&dev
->read_idx
, 0);
782 spin_lock_init(&dev
->intr_idx_lock
);
783 atomic_set(&dev
->overflow_flag
, 0);
784 init_waitqueue_head(&dev
->read_wait
);
785 atomic_set(&dev
->write_busy
, 0);
786 init_waitqueue_head(&dev
->write_wait
);
789 dev
->interface
= interface
;
791 iface_desc
= interface
->cur_altsetting
;
792 dev
->product_id
= le16_to_cpu(udev
->descriptor
.idProduct
);
794 /* set up the endpoint information */
795 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
796 endpoint
= &iface_desc
->endpoint
[i
].desc
;
798 if (usb_endpoint_is_int_in(endpoint
))
799 dev
->int_in_endpoint
= endpoint
;
800 if (usb_endpoint_is_int_out(endpoint
))
801 /* this one will match for the IOWarrior56 only */
802 dev
->int_out_endpoint
= endpoint
;
804 /* we have to check the report_size often, so remember it in the endianess suitable for our machine */
805 dev
->report_size
= le16_to_cpu(dev
->int_in_endpoint
->wMaxPacketSize
);
806 if ((dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0) &&
807 (dev
->product_id
== USB_DEVICE_ID_CODEMERCS_IOW56
))
808 /* IOWarrior56 has wMaxPacketSize different from report size */
809 dev
->report_size
= 7;
811 /* create the urb and buffer for reading */
812 dev
->int_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
813 if (!dev
->int_in_urb
) {
814 dev_err(&interface
->dev
, "Couldn't allocate interrupt_in_urb\n");
817 dev
->int_in_buffer
= kmalloc(dev
->report_size
, GFP_KERNEL
);
818 if (!dev
->int_in_buffer
) {
819 dev_err(&interface
->dev
, "Couldn't allocate int_in_buffer\n");
822 usb_fill_int_urb(dev
->int_in_urb
, dev
->udev
,
823 usb_rcvintpipe(dev
->udev
,
824 dev
->int_in_endpoint
->bEndpointAddress
),
825 dev
->int_in_buffer
, dev
->report_size
,
826 iowarrior_callback
, dev
,
827 dev
->int_in_endpoint
->bInterval
);
828 /* create an internal buffer for interrupt data from the device */
830 kmalloc(((dev
->report_size
+ 1) * MAX_INTERRUPT_BUFFER
),
832 if (!dev
->read_queue
) {
833 dev_err(&interface
->dev
, "Couldn't allocate read_queue\n");
836 /* Get the serial-number of the chip */
837 memset(dev
->chip_serial
, 0x00, sizeof(dev
->chip_serial
));
838 usb_string(udev
, udev
->descriptor
.iSerialNumber
, dev
->chip_serial
,
839 sizeof(dev
->chip_serial
));
840 if (strlen(dev
->chip_serial
) != 8)
841 memset(dev
->chip_serial
, 0x00, sizeof(dev
->chip_serial
));
843 /* Set the idle timeout to 0, if this is interface 0 */
844 if (dev
->interface
->cur_altsetting
->desc
.bInterfaceNumber
== 0) {
845 usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
847 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
, 0,
848 0, NULL
, 0, USB_CTRL_SET_TIMEOUT
);
850 /* allow device read and ioctl */
853 /* we can register the device now, as it is ready */
854 usb_set_intfdata(interface
, dev
);
856 retval
= usb_register_dev(interface
, &iowarrior_class
);
858 /* something prevented us from registering this driver */
859 dev_err(&interface
->dev
, "Not able to get a minor for this device.\n");
860 usb_set_intfdata(interface
, NULL
);
864 dev
->minor
= interface
->minor
;
866 /* let the user know what node this device is now attached to */
867 dev_info(&interface
->dev
, "IOWarrior product=0x%x, serial=%s interface=%d "
868 "now attached to iowarrior%d\n", dev
->product_id
, dev
->chip_serial
,
869 iface_desc
->desc
.bInterfaceNumber
, dev
->minor
- IOWARRIOR_MINOR_BASE
);
873 iowarrior_delete(dev
);
878 * iowarrior_disconnect
880 * Called by the usb core when the device is removed from the system.
882 static void iowarrior_disconnect(struct usb_interface
*interface
)
884 struct iowarrior
*dev
;
887 dev
= usb_get_intfdata(interface
);
888 mutex_lock(&iowarrior_open_disc_lock
);
889 usb_set_intfdata(interface
, NULL
);
893 /* give back our minor */
894 usb_deregister_dev(interface
, &iowarrior_class
);
896 mutex_lock(&dev
->mutex
);
898 /* prevent device read, write and ioctl */
901 mutex_unlock(&dev
->mutex
);
902 mutex_unlock(&iowarrior_open_disc_lock
);
905 /* There is a process that holds a filedescriptor to the device ,
906 so we only shutdown read-/write-ops going on.
907 Deleting the device is postponed until close() was called.
909 usb_kill_urb(dev
->int_in_urb
);
910 wake_up_interruptible(&dev
->read_wait
);
911 wake_up_interruptible(&dev
->write_wait
);
913 /* no process is using the device, cleanup now */
914 iowarrior_delete(dev
);
917 dev_info(&interface
->dev
, "I/O-Warror #%d now disconnected\n",
918 minor
- IOWARRIOR_MINOR_BASE
);
921 /* usb specific object needed to register this driver with the usb subsystem */
922 static struct usb_driver iowarrior_driver
= {
924 .probe
= iowarrior_probe
,
925 .disconnect
= iowarrior_disconnect
,
926 .id_table
= iowarrior_ids
,
929 static int __init
iowarrior_init(void)
931 return usb_register(&iowarrior_driver
);
934 static void __exit
iowarrior_exit(void)
936 usb_deregister(&iowarrior_driver
);
939 module_init(iowarrior_init
);
940 module_exit(iowarrior_exit
);