4 * This driver supports USB CDC WCM Device Management.
6 * Copyright (c) 2007-2008 Oliver Neukum
8 * Some code taken from cdc-acm.c
10 * Released under the GPLv2.
12 * Many thanks to Carl Nordbeck
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/smp_lock.h>
19 #include <linux/mutex.h>
20 #include <linux/uaccess.h>
21 #include <linux/bitops.h>
22 #include <linux/poll.h>
23 #include <linux/usb.h>
24 #include <linux/usb/cdc.h>
25 #include <asm/byteorder.h>
26 #include <asm/unaligned.h>
31 #define DRIVER_VERSION "v0.03"
32 #define DRIVER_AUTHOR "Oliver Neukum"
33 #define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
35 static struct usb_device_id wdm_ids
[] = {
37 .match_flags
= USB_DEVICE_ID_MATCH_INT_CLASS
|
38 USB_DEVICE_ID_MATCH_INT_SUBCLASS
,
39 .bInterfaceClass
= USB_CLASS_COMM
,
40 .bInterfaceSubClass
= USB_CDC_SUBCLASS_DMM
45 #define WDM_MINOR_BASE 176
49 #define WDM_DISCONNECTING 2
52 #define WDM_INT_STALL 5
53 #define WDM_POLL_RUNNING 6
59 static DEFINE_MUTEX(wdm_mutex
);
61 /* --- method tables --- */
64 u8
*inbuf
; /* buffer for response */
65 u8
*outbuf
; /* buffer for command */
66 u8
*sbuf
; /* buffer for status */
67 u8
*ubuf
; /* buffer for copy to user space */
72 struct usb_interface
*intf
;
73 struct usb_ctrlrequest
*orq
;
74 struct usb_ctrlrequest
*irq
;
91 wait_queue_head_t wait
;
92 struct work_struct rxwork
;
97 static struct usb_driver wdm_driver
;
99 /* --- callbacks --- */
100 static void wdm_out_callback(struct urb
*urb
)
102 struct wdm_device
*desc
;
104 spin_lock(&desc
->iuspin
);
105 desc
->werr
= urb
->status
;
106 spin_unlock(&desc
->iuspin
);
107 clear_bit(WDM_IN_USE
, &desc
->flags
);
109 wake_up(&desc
->wait
);
112 static void wdm_in_callback(struct urb
*urb
)
114 struct wdm_device
*desc
= urb
->context
;
115 int status
= urb
->status
;
117 spin_lock(&desc
->iuspin
);
122 dev_dbg(&desc
->intf
->dev
,
123 "nonzero urb status received: -ENOENT");
126 dev_dbg(&desc
->intf
->dev
,
127 "nonzero urb status received: -ECONNRESET");
130 dev_dbg(&desc
->intf
->dev
,
131 "nonzero urb status received: -ESHUTDOWN");
134 err("nonzero urb status received: -EPIPE");
137 err("Unexpected error %d", status
);
143 desc
->reslength
= urb
->actual_length
;
144 memmove(desc
->ubuf
+ desc
->length
, desc
->inbuf
, desc
->reslength
);
145 desc
->length
+= desc
->reslength
;
146 wake_up(&desc
->wait
);
148 set_bit(WDM_READ
, &desc
->flags
);
149 spin_unlock(&desc
->iuspin
);
152 static void wdm_int_callback(struct urb
*urb
)
155 int status
= urb
->status
;
156 struct wdm_device
*desc
;
157 struct usb_ctrlrequest
*req
;
158 struct usb_cdc_notification
*dr
;
162 dr
= (struct usb_cdc_notification
*)desc
->sbuf
;
171 set_bit(WDM_INT_STALL
, &desc
->flags
);
172 err("Stall on int endpoint");
173 goto sw
; /* halt is cleared in work */
175 err("nonzero urb status received: %d", status
);
180 if (urb
->actual_length
< sizeof(struct usb_cdc_notification
)) {
181 err("wdm_int_callback - %d bytes", urb
->actual_length
);
185 switch (dr
->bNotificationType
) {
186 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE
:
187 dev_dbg(&desc
->intf
->dev
,
188 "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
189 dr
->wIndex
, dr
->wLength
);
192 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
194 dev_dbg(&desc
->intf
->dev
,
195 "NOTIFY_NETWORK_CONNECTION %s network",
196 dr
->wValue
? "connected to" : "disconnected from");
199 clear_bit(WDM_POLL_RUNNING
, &desc
->flags
);
200 err("unknown notification %d received: index %d len %d",
201 dr
->bNotificationType
, dr
->wIndex
, dr
->wLength
);
205 req
->bRequestType
= (USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
);
206 req
->bRequest
= USB_CDC_GET_ENCAPSULATED_RESPONSE
;
208 req
->wIndex
= desc
->inum
;
209 req
->wLength
= cpu_to_le16(desc
->wMaxCommand
);
211 usb_fill_control_urb(
213 interface_to_usbdev(desc
->intf
),
214 /* using common endpoint 0 */
215 usb_rcvctrlpipe(interface_to_usbdev(desc
->intf
), 0),
216 (unsigned char *)req
,
222 desc
->response
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
223 spin_lock(&desc
->iuspin
);
224 clear_bit(WDM_READ
, &desc
->flags
);
225 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
226 rv
= usb_submit_urb(desc
->response
, GFP_ATOMIC
);
227 dev_dbg(&desc
->intf
->dev
, "%s: usb_submit_urb %d",
230 spin_unlock(&desc
->iuspin
);
236 rv
= schedule_work(&desc
->rxwork
);
238 err("Cannot schedule work");
242 rv
= usb_submit_urb(urb
, GFP_ATOMIC
);
244 err("%s - usb_submit_urb failed with result %d",
249 static void kill_urbs(struct wdm_device
*desc
)
251 usb_kill_urb(desc
->command
);
252 usb_kill_urb(desc
->validity
);
253 usb_kill_urb(desc
->response
);
256 static void free_urbs(struct wdm_device
*desc
)
258 usb_free_urb(desc
->validity
);
259 usb_free_urb(desc
->response
);
260 usb_free_urb(desc
->command
);
263 static void cleanup(struct wdm_device
*desc
)
265 usb_buffer_free(interface_to_usbdev(desc
->intf
),
266 desc
->wMaxPacketSize
,
268 desc
->validity
->transfer_dma
);
269 usb_buffer_free(interface_to_usbdev(desc
->intf
),
272 desc
->response
->transfer_dma
);
280 static ssize_t wdm_write
281 (struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
284 int rv
= -EMSGSIZE
, r
, we
;
285 struct wdm_device
*desc
= file
->private_data
;
286 struct usb_ctrlrequest
*req
;
288 if (count
> desc
->wMaxCommand
)
289 count
= desc
->wMaxCommand
;
291 spin_lock_irq(&desc
->iuspin
);
294 spin_unlock_irq(&desc
->iuspin
);
298 r
= mutex_lock_interruptible(&desc
->wlock
); /* concurrent writes */
303 r
= wait_event_interruptible(desc
->wait
, !test_bit(WDM_IN_USE
,
308 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
313 desc
->outbuf
= buf
= kmalloc(count
, GFP_KERNEL
);
319 r
= copy_from_user(buf
, buffer
, count
);
327 usb_fill_control_urb(
329 interface_to_usbdev(desc
->intf
),
330 /* using common endpoint 0 */
331 usb_sndctrlpipe(interface_to_usbdev(desc
->intf
), 0),
332 (unsigned char *)req
,
339 req
->bRequestType
= (USB_DIR_OUT
| USB_TYPE_CLASS
|
340 USB_RECIP_INTERFACE
);
341 req
->bRequest
= USB_CDC_SEND_ENCAPSULATED_COMMAND
;
343 req
->wIndex
= desc
->inum
;
344 req
->wLength
= cpu_to_le16(count
);
345 set_bit(WDM_IN_USE
, &desc
->flags
);
347 rv
= usb_submit_urb(desc
->command
, GFP_KERNEL
);
350 clear_bit(WDM_IN_USE
, &desc
->flags
);
351 err("Tx URB error: %d", rv
);
353 dev_dbg(&desc
->intf
->dev
, "Tx URB has been submitted index=%d",
357 mutex_unlock(&desc
->wlock
);
359 return rv
< 0 ? rv
: count
;
362 static ssize_t wdm_read
363 (struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
367 struct wdm_device
*desc
= file
->private_data
;
370 rv
= mutex_lock_interruptible(&desc
->rlock
); /*concurrent reads */
374 if (desc
->length
== 0) {
378 rv
= wait_event_interruptible(desc
->wait
,
379 test_bit(WDM_READ
, &desc
->flags
));
386 spin_lock_irq(&desc
->iuspin
);
388 if (desc
->rerr
) { /* read completed, error happened */
391 spin_unlock_irq(&desc
->iuspin
);
392 err("reading had resulted in %d", t
);
397 * recheck whether we've lost the race
398 * against the completion handler
400 if (!test_bit(WDM_READ
, &desc
->flags
)) { /* lost race */
401 spin_unlock_irq(&desc
->iuspin
);
404 if (!desc
->reslength
) { /* zero length read */
405 spin_unlock_irq(&desc
->iuspin
);
408 clear_bit(WDM_READ
, &desc
->flags
);
409 spin_unlock_irq(&desc
->iuspin
);
412 cntr
= count
> desc
->length
? desc
->length
: count
;
413 rv
= copy_to_user(buffer
, desc
->ubuf
, cntr
);
419 for (i
= 0; i
< desc
->length
- cntr
; i
++)
420 desc
->ubuf
[i
] = desc
->ubuf
[i
+ cntr
];
422 desc
->length
-= cntr
;
423 /* in case we had outstanding data */
425 clear_bit(WDM_READ
, &desc
->flags
);
429 mutex_unlock(&desc
->rlock
);
431 err("wdm_read: exit error");
435 static int wdm_flush(struct file
*file
, fl_owner_t id
)
437 struct wdm_device
*desc
= file
->private_data
;
439 wait_event(desc
->wait
, !test_bit(WDM_IN_USE
, &desc
->flags
));
441 err("Error in flush path: %d", desc
->werr
);
446 static unsigned int wdm_poll(struct file
*file
, struct poll_table_struct
*wait
)
448 struct wdm_device
*desc
= file
->private_data
;
450 unsigned int mask
= 0;
452 spin_lock_irqsave(&desc
->iuspin
, flags
);
453 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
455 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
458 if (test_bit(WDM_READ
, &desc
->flags
))
459 mask
= POLLIN
| POLLRDNORM
;
460 if (desc
->rerr
|| desc
->werr
)
462 if (!test_bit(WDM_IN_USE
, &desc
->flags
))
463 mask
|= POLLOUT
| POLLWRNORM
;
464 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
466 poll_wait(file
, &desc
->wait
, wait
);
472 static int wdm_open(struct inode
*inode
, struct file
*file
)
474 int minor
= iminor(inode
);
476 struct usb_interface
*intf
;
477 struct wdm_device
*desc
;
479 mutex_lock(&wdm_mutex
);
480 intf
= usb_find_interface(&wdm_driver
, minor
);
484 desc
= usb_get_intfdata(intf
);
485 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
))
489 file
->private_data
= desc
;
491 rv
= usb_submit_urb(desc
->validity
, GFP_KERNEL
);
495 err("Error submitting int urb - %d", rv
);
501 mutex_unlock(&wdm_mutex
);
505 static int wdm_release(struct inode
*inode
, struct file
*file
)
507 struct wdm_device
*desc
= file
->private_data
;
509 mutex_lock(&wdm_mutex
);
512 dev_dbg(&desc
->intf
->dev
, "wdm_release: cleanup");
515 mutex_unlock(&wdm_mutex
);
519 static const struct file_operations wdm_fops
= {
520 .owner
= THIS_MODULE
,
525 .release
= wdm_release
,
529 static struct usb_class_driver wdm_class
= {
532 .minor_base
= WDM_MINOR_BASE
,
535 /* --- error handling --- */
536 static void wdm_rxwork(struct work_struct
*work
)
538 struct wdm_device
*desc
= container_of(work
, struct wdm_device
, rxwork
);
542 spin_lock_irqsave(&desc
->iuspin
, flags
);
543 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
544 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
546 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
547 rv
= usb_submit_urb(desc
->response
, GFP_KERNEL
);
548 if (rv
< 0 && rv
!= -EPERM
) {
549 spin_lock_irqsave(&desc
->iuspin
, flags
);
550 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
))
551 schedule_work(&desc
->rxwork
);
552 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
557 /* --- hotplug --- */
559 static int wdm_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
562 struct usb_device
*udev
= interface_to_usbdev(intf
);
563 struct wdm_device
*desc
;
564 struct usb_host_interface
*iface
;
565 struct usb_endpoint_descriptor
*ep
;
566 struct usb_cdc_dmm_desc
*dmhd
;
567 u8
*buffer
= intf
->altsetting
->extra
;
568 int buflen
= intf
->altsetting
->extralen
;
575 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
576 err("skipping garbage");
580 switch (buffer
[2]) {
581 case USB_CDC_HEADER_TYPE
:
583 case USB_CDC_DMM_TYPE
:
584 dmhd
= (struct usb_cdc_dmm_desc
*)buffer
;
585 maxcom
= le16_to_cpu(dmhd
->wMaxCommand
);
587 "Finding maximum buffer length: %d", maxcom
);
590 err("Ignoring extra header, type %d, length %d",
591 buffer
[2], buffer
[0]);
600 desc
= kzalloc(sizeof(struct wdm_device
), GFP_KERNEL
);
603 mutex_init(&desc
->wlock
);
604 mutex_init(&desc
->rlock
);
605 spin_lock_init(&desc
->iuspin
);
606 init_waitqueue_head(&desc
->wait
);
607 desc
->wMaxCommand
= maxcom
;
608 desc
->inum
= cpu_to_le16((u16
)intf
->cur_altsetting
->desc
.bInterfaceNumber
);
610 INIT_WORK(&desc
->rxwork
, wdm_rxwork
);
612 iface
= &intf
->altsetting
[0];
613 ep
= &iface
->endpoint
[0].desc
;
614 if (!usb_endpoint_is_int_in(ep
)) {
619 desc
->wMaxPacketSize
= le16_to_cpu(ep
->wMaxPacketSize
);
620 desc
->bMaxPacketSize0
= udev
->descriptor
.bMaxPacketSize0
;
622 desc
->orq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
625 desc
->irq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
629 desc
->validity
= usb_alloc_urb(0, GFP_KERNEL
);
633 desc
->response
= usb_alloc_urb(0, GFP_KERNEL
);
637 desc
->command
= usb_alloc_urb(0, GFP_KERNEL
);
641 desc
->ubuf
= kmalloc(desc
->wMaxCommand
, GFP_KERNEL
);
645 desc
->sbuf
= usb_buffer_alloc(interface_to_usbdev(intf
),
646 desc
->wMaxPacketSize
,
648 &desc
->validity
->transfer_dma
);
652 desc
->inbuf
= usb_buffer_alloc(interface_to_usbdev(intf
),
653 desc
->bMaxPacketSize0
,
655 &desc
->response
->transfer_dma
);
661 interface_to_usbdev(intf
),
662 usb_rcvintpipe(interface_to_usbdev(intf
), ep
->bEndpointAddress
),
664 desc
->wMaxPacketSize
,
669 desc
->validity
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
671 usb_set_intfdata(intf
, desc
);
672 rv
= usb_register_dev(intf
, &wdm_class
);
673 dev_info(&intf
->dev
, "cdc-wdm%d: USB WDM device\n",
674 intf
->minor
- WDM_MINOR_BASE
);
680 usb_buffer_free(interface_to_usbdev(desc
->intf
),
681 desc
->wMaxPacketSize
,
683 desc
->validity
->transfer_dma
);
693 static void wdm_disconnect(struct usb_interface
*intf
)
695 struct wdm_device
*desc
;
698 usb_deregister_dev(intf
, &wdm_class
);
699 mutex_lock(&wdm_mutex
);
700 desc
= usb_get_intfdata(intf
);
702 /* the spinlock makes sure no new urbs are generated in the callbacks */
703 spin_lock_irqsave(&desc
->iuspin
, flags
);
704 set_bit(WDM_DISCONNECTING
, &desc
->flags
);
705 set_bit(WDM_READ
, &desc
->flags
);
706 clear_bit(WDM_IN_USE
, &desc
->flags
);
707 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
708 cancel_work_sync(&desc
->rxwork
);
710 wake_up_all(&desc
->wait
);
713 mutex_unlock(&wdm_mutex
);
716 static struct usb_driver wdm_driver
= {
719 .disconnect
= wdm_disconnect
,
723 /* --- low level module stuff --- */
725 static int __init
wdm_init(void)
729 rv
= usb_register(&wdm_driver
);
734 static void __exit
wdm_exit(void)
736 usb_deregister(&wdm_driver
);
739 module_init(wdm_init
);
740 module_exit(wdm_exit
);
742 MODULE_AUTHOR(DRIVER_AUTHOR
);
743 MODULE_DESCRIPTION(DRIVER_DESC
);
744 MODULE_LICENSE("GPL");