1 // SPDX-License-Identifier: GPL-2.0
5 * This driver supports USB CDC WCM Device Management.
7 * Copyright (c) 2007-2009 Oliver Neukum
9 * Some code taken from cdc-acm.c
11 * Released under the GPLv2.
13 * Many thanks to Carl Nordbeck
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/ioctl.h>
18 #include <linux/slab.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/uaccess.h>
22 #include <linux/bitops.h>
23 #include <linux/poll.h>
24 #include <linux/skbuff.h>
25 #include <linux/usb.h>
26 #include <linux/usb/cdc.h>
27 #include <linux/wwan.h>
28 #include <asm/byteorder.h>
29 #include <asm/unaligned.h>
30 #include <linux/usb/cdc-wdm.h>
32 #define DRIVER_AUTHOR "Oliver Neukum"
33 #define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
35 static const 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 MODULE_DEVICE_TABLE (usb
, wdm_ids
);
47 #define WDM_MINOR_BASE 176
51 #define WDM_DISCONNECTING 2
54 #define WDM_INT_STALL 5
55 #define WDM_POLL_RUNNING 6
56 #define WDM_RESPONDING 7
57 #define WDM_SUSPENDING 8
58 #define WDM_RESETTING 9
59 #define WDM_OVERFLOW 10
60 #define WDM_WWAN_IN_USE 11
64 /* we cannot wait forever at flush() */
65 #define WDM_FLUSH_TIMEOUT (30 * HZ)
67 /* CDC-WMC r1.1 requires wMaxCommand to be "at least 256 decimal (0x100)" */
68 #define WDM_DEFAULT_BUFSIZE 256
70 static DEFINE_MUTEX(wdm_mutex
);
71 static DEFINE_SPINLOCK(wdm_device_list_lock
);
72 static LIST_HEAD(wdm_device_list
);
74 /* --- method tables --- */
77 u8
*inbuf
; /* buffer for response */
78 u8
*outbuf
; /* buffer for command */
79 u8
*sbuf
; /* buffer for status */
80 u8
*ubuf
; /* buffer for copy to user space */
85 struct usb_interface
*intf
;
86 struct usb_ctrlrequest
*orq
;
87 struct usb_ctrlrequest
*irq
;
103 wait_queue_head_t wait
;
104 struct work_struct rxwork
;
105 struct work_struct service_outs_intr
;
110 struct list_head device_list
;
111 int (*manage_power
)(struct usb_interface
*, int);
113 enum wwan_port_type wwanp_type
;
114 struct wwan_port
*wwanp
;
117 static struct usb_driver wdm_driver
;
119 /* return intfdata if we own the interface, else look up intf in the list */
120 static struct wdm_device
*wdm_find_device(struct usb_interface
*intf
)
122 struct wdm_device
*desc
;
124 spin_lock(&wdm_device_list_lock
);
125 list_for_each_entry(desc
, &wdm_device_list
, device_list
)
126 if (desc
->intf
== intf
)
130 spin_unlock(&wdm_device_list_lock
);
135 static struct wdm_device
*wdm_find_device_by_minor(int minor
)
137 struct wdm_device
*desc
;
139 spin_lock(&wdm_device_list_lock
);
140 list_for_each_entry(desc
, &wdm_device_list
, device_list
)
141 if (desc
->intf
->minor
== minor
)
145 spin_unlock(&wdm_device_list_lock
);
150 /* --- callbacks --- */
151 static void wdm_out_callback(struct urb
*urb
)
153 struct wdm_device
*desc
;
157 spin_lock_irqsave(&desc
->iuspin
, flags
);
158 desc
->werr
= urb
->status
;
159 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
162 clear_bit(WDM_IN_USE
, &desc
->flags
);
163 wake_up_all(&desc
->wait
);
166 static void wdm_wwan_rx(struct wdm_device
*desc
, int length
);
168 static void wdm_in_callback(struct urb
*urb
)
171 struct wdm_device
*desc
= urb
->context
;
172 int status
= urb
->status
;
173 int length
= urb
->actual_length
;
175 spin_lock_irqsave(&desc
->iuspin
, flags
);
176 clear_bit(WDM_RESPONDING
, &desc
->flags
);
181 dev_dbg(&desc
->intf
->dev
,
182 "nonzero urb status received: -ENOENT\n");
185 dev_dbg(&desc
->intf
->dev
,
186 "nonzero urb status received: -ECONNRESET\n");
189 dev_dbg(&desc
->intf
->dev
,
190 "nonzero urb status received: -ESHUTDOWN\n");
193 dev_err(&desc
->intf
->dev
,
194 "nonzero urb status received: -EPIPE\n");
197 dev_err(&desc
->intf
->dev
,
198 "Unexpected error %d\n", status
);
203 if (test_bit(WDM_WWAN_IN_USE
, &desc
->flags
)) {
204 wdm_wwan_rx(desc
, length
);
209 * only set a new error if there is no previous error.
210 * Errors are only cleared during read/open
211 * Avoid propagating -EPIPE (stall) to userspace since it is
212 * better handled as an empty read
214 if (desc
->rerr
== 0 && status
!= -EPIPE
)
217 if (length
+ desc
->length
> desc
->wMaxCommand
) {
218 /* The buffer would overflow */
219 set_bit(WDM_OVERFLOW
, &desc
->flags
);
221 /* we may already be in overflow */
222 if (!test_bit(WDM_OVERFLOW
, &desc
->flags
)) {
223 memmove(desc
->ubuf
+ desc
->length
, desc
->inbuf
, length
);
224 desc
->length
+= length
;
225 desc
->reslength
= length
;
232 * Since there was an error, userspace may decide to not read
233 * any data after poll'ing.
234 * We should respond to further attempts from the device to send
235 * data, so that we can get unstuck.
237 schedule_work(&desc
->service_outs_intr
);
239 set_bit(WDM_READ
, &desc
->flags
);
240 wake_up(&desc
->wait
);
243 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
246 static void wdm_int_callback(struct urb
*urb
)
251 int status
= urb
->status
;
252 struct wdm_device
*desc
;
253 struct usb_cdc_notification
*dr
;
256 dr
= (struct usb_cdc_notification
*)desc
->sbuf
;
265 set_bit(WDM_INT_STALL
, &desc
->flags
);
266 dev_err(&desc
->intf
->dev
, "Stall on int endpoint\n");
267 goto sw
; /* halt is cleared in work */
269 dev_err(&desc
->intf
->dev
,
270 "nonzero urb status received: %d\n", status
);
275 if (urb
->actual_length
< sizeof(struct usb_cdc_notification
)) {
276 dev_err(&desc
->intf
->dev
, "wdm_int_callback - %d bytes\n",
281 switch (dr
->bNotificationType
) {
282 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE
:
283 dev_dbg(&desc
->intf
->dev
,
284 "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d\n",
285 le16_to_cpu(dr
->wIndex
), le16_to_cpu(dr
->wLength
));
288 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
290 dev_dbg(&desc
->intf
->dev
,
291 "NOTIFY_NETWORK_CONNECTION %s network\n",
292 dr
->wValue
? "connected to" : "disconnected from");
294 case USB_CDC_NOTIFY_SPEED_CHANGE
:
295 dev_dbg(&desc
->intf
->dev
, "SPEED_CHANGE received (len %u)\n",
299 clear_bit(WDM_POLL_RUNNING
, &desc
->flags
);
300 dev_err(&desc
->intf
->dev
,
301 "unknown notification %d received: index %d len %d\n",
302 dr
->bNotificationType
,
303 le16_to_cpu(dr
->wIndex
),
304 le16_to_cpu(dr
->wLength
));
308 spin_lock_irqsave(&desc
->iuspin
, flags
);
309 responding
= test_and_set_bit(WDM_RESPONDING
, &desc
->flags
);
310 if (!desc
->resp_count
++ && !responding
311 && !test_bit(WDM_DISCONNECTING
, &desc
->flags
)
312 && !test_bit(WDM_SUSPENDING
, &desc
->flags
)) {
313 rv
= usb_submit_urb(desc
->response
, GFP_ATOMIC
);
314 dev_dbg(&desc
->intf
->dev
, "submit response URB %d\n", rv
);
316 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
318 clear_bit(WDM_RESPONDING
, &desc
->flags
);
323 rv
= schedule_work(&desc
->rxwork
);
325 dev_err(&desc
->intf
->dev
,
326 "Cannot schedule work\n");
330 rv
= usb_submit_urb(urb
, GFP_ATOMIC
);
332 dev_err(&desc
->intf
->dev
,
333 "%s - usb_submit_urb failed with result %d\n",
338 static void poison_urbs(struct wdm_device
*desc
)
340 /* the order here is essential */
341 usb_poison_urb(desc
->command
);
342 usb_poison_urb(desc
->validity
);
343 usb_poison_urb(desc
->response
);
346 static void unpoison_urbs(struct wdm_device
*desc
)
349 * the order here is not essential
350 * it is symmetrical just to be nice
352 usb_unpoison_urb(desc
->response
);
353 usb_unpoison_urb(desc
->validity
);
354 usb_unpoison_urb(desc
->command
);
357 static void free_urbs(struct wdm_device
*desc
)
359 usb_free_urb(desc
->validity
);
360 usb_free_urb(desc
->response
);
361 usb_free_urb(desc
->command
);
364 static void cleanup(struct wdm_device
*desc
)
375 static ssize_t wdm_write
376 (struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
379 int rv
= -EMSGSIZE
, r
, we
;
380 struct wdm_device
*desc
= file
->private_data
;
381 struct usb_ctrlrequest
*req
;
383 if (count
> desc
->wMaxCommand
)
384 count
= desc
->wMaxCommand
;
386 spin_lock_irq(&desc
->iuspin
);
389 spin_unlock_irq(&desc
->iuspin
);
391 return usb_translate_errors(we
);
393 buf
= memdup_user(buffer
, count
);
397 /* concurrent writes and disconnect */
398 r
= mutex_lock_interruptible(&desc
->wlock
);
403 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
405 goto out_free_mem_lock
;
408 r
= usb_autopm_get_interface(desc
->intf
);
410 rv
= usb_translate_errors(r
);
411 goto out_free_mem_lock
;
414 if (!(file
->f_flags
& O_NONBLOCK
))
415 r
= wait_event_interruptible(desc
->wait
, !test_bit(WDM_IN_USE
,
418 if (test_bit(WDM_IN_USE
, &desc
->flags
))
421 if (test_bit(WDM_RESETTING
, &desc
->flags
))
424 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
))
429 goto out_free_mem_pm
;
433 usb_fill_control_urb(
435 interface_to_usbdev(desc
->intf
),
436 /* using common endpoint 0 */
437 usb_sndctrlpipe(interface_to_usbdev(desc
->intf
), 0),
438 (unsigned char *)req
,
445 req
->bRequestType
= (USB_DIR_OUT
| USB_TYPE_CLASS
|
446 USB_RECIP_INTERFACE
);
447 req
->bRequest
= USB_CDC_SEND_ENCAPSULATED_COMMAND
;
449 req
->wIndex
= desc
->inum
; /* already converted */
450 req
->wLength
= cpu_to_le16(count
);
451 set_bit(WDM_IN_USE
, &desc
->flags
);
454 rv
= usb_submit_urb(desc
->command
, GFP_KERNEL
);
457 clear_bit(WDM_IN_USE
, &desc
->flags
);
458 wake_up_all(&desc
->wait
); /* for wdm_wait_for_response() */
459 dev_err(&desc
->intf
->dev
, "Tx URB error: %d\n", rv
);
460 rv
= usb_translate_errors(rv
);
461 goto out_free_mem_pm
;
463 dev_dbg(&desc
->intf
->dev
, "Tx URB has been submitted index=%d\n",
464 le16_to_cpu(req
->wIndex
));
467 usb_autopm_put_interface(desc
->intf
);
468 mutex_unlock(&desc
->wlock
);
472 usb_autopm_put_interface(desc
->intf
);
474 mutex_unlock(&desc
->wlock
);
481 * Submit the read urb if resp_count is non-zero.
483 * Called with desc->iuspin locked
485 static int service_outstanding_interrupt(struct wdm_device
*desc
)
489 /* submit read urb only if the device is waiting for it */
490 if (!desc
->resp_count
|| !--desc
->resp_count
)
493 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
497 if (test_bit(WDM_RESETTING
, &desc
->flags
)) {
502 set_bit(WDM_RESPONDING
, &desc
->flags
);
503 spin_unlock_irq(&desc
->iuspin
);
504 rv
= usb_submit_urb(desc
->response
, GFP_KERNEL
);
505 spin_lock_irq(&desc
->iuspin
);
507 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
))
508 dev_err(&desc
->intf
->dev
,
509 "usb_submit_urb failed with result %d\n", rv
);
511 /* make sure the next notification trigger a submit */
512 clear_bit(WDM_RESPONDING
, &desc
->flags
);
513 desc
->resp_count
= 0;
519 static ssize_t wdm_read
520 (struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
524 struct wdm_device
*desc
= file
->private_data
;
527 rv
= mutex_lock_interruptible(&desc
->rlock
); /*concurrent reads */
531 cntr
= READ_ONCE(desc
->length
);
535 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
539 if (test_bit(WDM_OVERFLOW
, &desc
->flags
)) {
540 clear_bit(WDM_OVERFLOW
, &desc
->flags
);
545 if (file
->f_flags
& O_NONBLOCK
) {
546 if (!test_bit(WDM_READ
, &desc
->flags
)) {
552 rv
= wait_event_interruptible(desc
->wait
,
553 test_bit(WDM_READ
, &desc
->flags
));
556 /* may have happened while we slept */
557 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
561 if (test_bit(WDM_RESETTING
, &desc
->flags
)) {
565 usb_mark_last_busy(interface_to_usbdev(desc
->intf
));
571 spin_lock_irq(&desc
->iuspin
);
573 if (desc
->rerr
) { /* read completed, error happened */
574 rv
= usb_translate_errors(desc
->rerr
);
576 spin_unlock_irq(&desc
->iuspin
);
580 * recheck whether we've lost the race
581 * against the completion handler
583 if (!test_bit(WDM_READ
, &desc
->flags
)) { /* lost race */
584 spin_unlock_irq(&desc
->iuspin
);
588 if (!desc
->reslength
) { /* zero length read */
589 dev_dbg(&desc
->intf
->dev
, "zero length - clearing WDM_READ\n");
590 clear_bit(WDM_READ
, &desc
->flags
);
591 rv
= service_outstanding_interrupt(desc
);
592 spin_unlock_irq(&desc
->iuspin
);
598 spin_unlock_irq(&desc
->iuspin
);
603 rv
= copy_to_user(buffer
, desc
->ubuf
, cntr
);
609 spin_lock_irq(&desc
->iuspin
);
611 for (i
= 0; i
< desc
->length
- cntr
; i
++)
612 desc
->ubuf
[i
] = desc
->ubuf
[i
+ cntr
];
614 desc
->length
-= cntr
;
615 /* in case we had outstanding data */
617 clear_bit(WDM_READ
, &desc
->flags
);
618 service_outstanding_interrupt(desc
);
620 spin_unlock_irq(&desc
->iuspin
);
624 mutex_unlock(&desc
->rlock
);
628 static int wdm_wait_for_response(struct file
*file
, long timeout
)
630 struct wdm_device
*desc
= file
->private_data
;
631 long rv
; /* Use long here because (int) MAX_SCHEDULE_TIMEOUT < 0. */
634 * Needs both flags. We cannot do with one because resetting it would
635 * cause a race with write() yet we need to signal a disconnect.
637 rv
= wait_event_interruptible_timeout(desc
->wait
,
638 !test_bit(WDM_IN_USE
, &desc
->flags
) ||
639 test_bit(WDM_DISCONNECTING
, &desc
->flags
),
643 * To report the correct error. This is best effort.
644 * We are inevitably racing with the hardware.
646 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
))
653 spin_lock_irq(&desc
->iuspin
);
656 spin_unlock_irq(&desc
->iuspin
);
658 return usb_translate_errors(rv
);
663 * You need to send a signal when you react to malicious or defective hardware.
664 * Also, don't abort when fsync() returned -EINVAL, for older kernels which do
665 * not implement wdm_flush() will return -EINVAL.
667 static int wdm_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
669 return wdm_wait_for_response(file
, MAX_SCHEDULE_TIMEOUT
);
673 * Same with wdm_fsync(), except it uses finite timeout in order to react to
674 * malicious or defective hardware which ceased communication after close() was
675 * implicitly called due to process termination.
677 static int wdm_flush(struct file
*file
, fl_owner_t id
)
679 return wdm_wait_for_response(file
, WDM_FLUSH_TIMEOUT
);
682 static __poll_t
wdm_poll(struct file
*file
, struct poll_table_struct
*wait
)
684 struct wdm_device
*desc
= file
->private_data
;
688 spin_lock_irqsave(&desc
->iuspin
, flags
);
689 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
690 mask
= EPOLLHUP
| EPOLLERR
;
691 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
694 if (test_bit(WDM_READ
, &desc
->flags
))
695 mask
= EPOLLIN
| EPOLLRDNORM
;
696 if (desc
->rerr
|| desc
->werr
)
698 if (!test_bit(WDM_IN_USE
, &desc
->flags
))
699 mask
|= EPOLLOUT
| EPOLLWRNORM
;
700 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
702 poll_wait(file
, &desc
->wait
, wait
);
708 static int wdm_open(struct inode
*inode
, struct file
*file
)
710 int minor
= iminor(inode
);
712 struct usb_interface
*intf
;
713 struct wdm_device
*desc
;
715 mutex_lock(&wdm_mutex
);
716 desc
= wdm_find_device_by_minor(minor
);
721 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
))
723 file
->private_data
= desc
;
725 if (test_bit(WDM_WWAN_IN_USE
, &desc
->flags
)) {
730 rv
= usb_autopm_get_interface(desc
->intf
);
732 dev_err(&desc
->intf
->dev
, "Error autopm - %d\n", rv
);
736 /* using write lock to protect desc->count */
737 mutex_lock(&desc
->wlock
);
738 if (!desc
->count
++) {
741 rv
= usb_submit_urb(desc
->validity
, GFP_KERNEL
);
744 dev_err(&desc
->intf
->dev
,
745 "Error submitting int urb - %d\n", rv
);
746 rv
= usb_translate_errors(rv
);
751 mutex_unlock(&desc
->wlock
);
752 if (desc
->count
== 1)
753 desc
->manage_power(intf
, 1);
754 usb_autopm_put_interface(desc
->intf
);
756 mutex_unlock(&wdm_mutex
);
760 static int wdm_release(struct inode
*inode
, struct file
*file
)
762 struct wdm_device
*desc
= file
->private_data
;
764 mutex_lock(&wdm_mutex
);
766 /* using write lock to protect desc->count */
767 mutex_lock(&desc
->wlock
);
769 mutex_unlock(&desc
->wlock
);
772 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
773 dev_dbg(&desc
->intf
->dev
, "wdm_release: cleanup\n");
775 spin_lock_irq(&desc
->iuspin
);
776 desc
->resp_count
= 0;
777 spin_unlock_irq(&desc
->iuspin
);
778 desc
->manage_power(desc
->intf
, 0);
781 /* must avoid dev_printk here as desc->intf is invalid */
782 pr_debug(KBUILD_MODNAME
" %s: device gone - cleaning up\n", __func__
);
786 mutex_unlock(&wdm_mutex
);
790 static long wdm_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
792 struct wdm_device
*desc
= file
->private_data
;
796 case IOCTL_WDM_MAX_COMMAND
:
797 if (copy_to_user((void __user
*)arg
, &desc
->wMaxCommand
, sizeof(desc
->wMaxCommand
)))
806 static const struct file_operations wdm_fops
= {
807 .owner
= THIS_MODULE
,
813 .release
= wdm_release
,
815 .unlocked_ioctl
= wdm_ioctl
,
816 .compat_ioctl
= compat_ptr_ioctl
,
817 .llseek
= noop_llseek
,
820 static struct usb_class_driver wdm_class
= {
823 .minor_base
= WDM_MINOR_BASE
,
826 /* --- WWAN framework integration --- */
828 static int wdm_wwan_port_start(struct wwan_port
*port
)
830 struct wdm_device
*desc
= wwan_port_get_drvdata(port
);
832 /* The interface is both exposed via the WWAN framework and as a
833 * legacy usbmisc chardev. If chardev is already open, just fail
834 * to prevent concurrent usage. Otherwise, switch to WWAN mode.
836 mutex_lock(&wdm_mutex
);
838 mutex_unlock(&wdm_mutex
);
841 set_bit(WDM_WWAN_IN_USE
, &desc
->flags
);
842 mutex_unlock(&wdm_mutex
);
844 desc
->manage_power(desc
->intf
, 1);
847 wwan_port_txon(port
);
849 /* Start getting events */
850 return usb_submit_urb(desc
->validity
, GFP_KERNEL
);
853 static void wdm_wwan_port_stop(struct wwan_port
*port
)
855 struct wdm_device
*desc
= wwan_port_get_drvdata(port
);
857 /* Stop all transfers and disable WWAN mode */
859 desc
->manage_power(desc
->intf
, 0);
860 clear_bit(WDM_READ
, &desc
->flags
);
861 clear_bit(WDM_WWAN_IN_USE
, &desc
->flags
);
865 static void wdm_wwan_port_tx_complete(struct urb
*urb
)
867 struct sk_buff
*skb
= urb
->context
;
868 struct wdm_device
*desc
= skb_shinfo(skb
)->destructor_arg
;
870 usb_autopm_put_interface(desc
->intf
);
871 wwan_port_txon(desc
->wwanp
);
875 static int wdm_wwan_port_tx(struct wwan_port
*port
, struct sk_buff
*skb
)
877 struct wdm_device
*desc
= wwan_port_get_drvdata(port
);
878 struct usb_interface
*intf
= desc
->intf
;
879 struct usb_ctrlrequest
*req
= desc
->orq
;
882 rv
= usb_autopm_get_interface(intf
);
886 usb_fill_control_urb(
888 interface_to_usbdev(intf
),
889 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
890 (unsigned char *)req
,
893 wdm_wwan_port_tx_complete
,
897 req
->bRequestType
= (USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
);
898 req
->bRequest
= USB_CDC_SEND_ENCAPSULATED_COMMAND
;
900 req
->wIndex
= desc
->inum
;
901 req
->wLength
= cpu_to_le16(skb
->len
);
903 skb_shinfo(skb
)->destructor_arg
= desc
;
905 rv
= usb_submit_urb(desc
->command
, GFP_KERNEL
);
907 usb_autopm_put_interface(intf
);
908 else /* One transfer at a time, stop TX until URB completion */
909 wwan_port_txoff(port
);
914 static struct wwan_port_ops wdm_wwan_port_ops
= {
915 .start
= wdm_wwan_port_start
,
916 .stop
= wdm_wwan_port_stop
,
917 .tx
= wdm_wwan_port_tx
,
920 static void wdm_wwan_init(struct wdm_device
*desc
)
922 struct usb_interface
*intf
= desc
->intf
;
923 struct wwan_port
*port
;
925 /* Only register to WWAN core if protocol/type is known */
926 if (desc
->wwanp_type
== WWAN_PORT_UNKNOWN
) {
927 dev_info(&intf
->dev
, "Unknown control protocol\n");
931 port
= wwan_create_port(&intf
->dev
, desc
->wwanp_type
, &wdm_wwan_port_ops
, desc
);
933 dev_err(&intf
->dev
, "%s: Unable to create WWAN port\n",
934 dev_name(intf
->usb_dev
));
941 static void wdm_wwan_deinit(struct wdm_device
*desc
)
946 wwan_remove_port(desc
->wwanp
);
950 static void wdm_wwan_rx(struct wdm_device
*desc
, int length
)
952 struct wwan_port
*port
= desc
->wwanp
;
955 /* Forward data to WWAN port */
956 skb
= alloc_skb(length
, GFP_ATOMIC
);
960 memcpy(skb_put(skb
, length
), desc
->inbuf
, length
);
961 wwan_port_rx(port
, skb
);
963 /* inbuf has been copied, it is safe to check for outstanding data */
964 schedule_work(&desc
->service_outs_intr
);
966 #else /* CONFIG_WWAN */
967 static void wdm_wwan_init(struct wdm_device
*desc
) {}
968 static void wdm_wwan_deinit(struct wdm_device
*desc
) {}
969 static void wdm_wwan_rx(struct wdm_device
*desc
, int length
) {}
970 #endif /* CONFIG_WWAN */
972 /* --- error handling --- */
973 static void wdm_rxwork(struct work_struct
*work
)
975 struct wdm_device
*desc
= container_of(work
, struct wdm_device
, rxwork
);
980 spin_lock_irqsave(&desc
->iuspin
, flags
);
981 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
982 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
984 responding
= test_and_set_bit(WDM_RESPONDING
, &desc
->flags
);
985 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
987 rv
= usb_submit_urb(desc
->response
, GFP_KERNEL
);
988 if (rv
< 0 && rv
!= -EPERM
) {
989 spin_lock_irqsave(&desc
->iuspin
, flags
);
990 clear_bit(WDM_RESPONDING
, &desc
->flags
);
991 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
))
992 schedule_work(&desc
->rxwork
);
993 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
998 static void service_interrupt_work(struct work_struct
*work
)
1000 struct wdm_device
*desc
;
1002 desc
= container_of(work
, struct wdm_device
, service_outs_intr
);
1004 spin_lock_irq(&desc
->iuspin
);
1005 service_outstanding_interrupt(desc
);
1006 if (!desc
->resp_count
) {
1007 set_bit(WDM_READ
, &desc
->flags
);
1008 wake_up(&desc
->wait
);
1010 spin_unlock_irq(&desc
->iuspin
);
1013 /* --- hotplug --- */
1015 static int wdm_create(struct usb_interface
*intf
, struct usb_endpoint_descriptor
*ep
,
1016 u16 bufsize
, enum wwan_port_type type
,
1017 int (*manage_power
)(struct usb_interface
*, int))
1020 struct wdm_device
*desc
;
1022 desc
= kzalloc(sizeof(struct wdm_device
), GFP_KERNEL
);
1025 INIT_LIST_HEAD(&desc
->device_list
);
1026 mutex_init(&desc
->rlock
);
1027 mutex_init(&desc
->wlock
);
1028 spin_lock_init(&desc
->iuspin
);
1029 init_waitqueue_head(&desc
->wait
);
1030 desc
->wMaxCommand
= bufsize
;
1031 /* this will be expanded and needed in hardware endianness */
1032 desc
->inum
= cpu_to_le16((u16
)intf
->cur_altsetting
->desc
.bInterfaceNumber
);
1034 desc
->wwanp_type
= type
;
1035 INIT_WORK(&desc
->rxwork
, wdm_rxwork
);
1036 INIT_WORK(&desc
->service_outs_intr
, service_interrupt_work
);
1038 if (!usb_endpoint_is_int_in(ep
)) {
1043 desc
->wMaxPacketSize
= usb_endpoint_maxp(ep
);
1045 desc
->orq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
1048 desc
->irq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
1052 desc
->validity
= usb_alloc_urb(0, GFP_KERNEL
);
1053 if (!desc
->validity
)
1056 desc
->response
= usb_alloc_urb(0, GFP_KERNEL
);
1057 if (!desc
->response
)
1060 desc
->command
= usb_alloc_urb(0, GFP_KERNEL
);
1064 desc
->ubuf
= kmalloc(desc
->wMaxCommand
, GFP_KERNEL
);
1068 desc
->sbuf
= kmalloc(desc
->wMaxPacketSize
, GFP_KERNEL
);
1072 desc
->inbuf
= kmalloc(desc
->wMaxCommand
, GFP_KERNEL
);
1078 interface_to_usbdev(intf
),
1079 usb_rcvintpipe(interface_to_usbdev(intf
), ep
->bEndpointAddress
),
1081 desc
->wMaxPacketSize
,
1087 desc
->irq
->bRequestType
= (USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
);
1088 desc
->irq
->bRequest
= USB_CDC_GET_ENCAPSULATED_RESPONSE
;
1089 desc
->irq
->wValue
= 0;
1090 desc
->irq
->wIndex
= desc
->inum
; /* already converted */
1091 desc
->irq
->wLength
= cpu_to_le16(desc
->wMaxCommand
);
1093 usb_fill_control_urb(
1095 interface_to_usbdev(intf
),
1096 /* using common endpoint 0 */
1097 usb_rcvctrlpipe(interface_to_usbdev(desc
->intf
), 0),
1098 (unsigned char *)desc
->irq
,
1105 desc
->manage_power
= manage_power
;
1107 spin_lock(&wdm_device_list_lock
);
1108 list_add(&desc
->device_list
, &wdm_device_list
);
1109 spin_unlock(&wdm_device_list_lock
);
1111 rv
= usb_register_dev(intf
, &wdm_class
);
1115 dev_info(&intf
->dev
, "%s: USB WDM device\n", dev_name(intf
->usb_dev
));
1117 wdm_wwan_init(desc
);
1122 spin_lock(&wdm_device_list_lock
);
1123 list_del(&desc
->device_list
);
1124 spin_unlock(&wdm_device_list_lock
);
1129 static int wdm_manage_power(struct usb_interface
*intf
, int on
)
1131 /* need autopm_get/put here to ensure the usbcore sees the new value */
1132 int rv
= usb_autopm_get_interface(intf
);
1134 intf
->needs_remote_wakeup
= on
;
1136 usb_autopm_put_interface(intf
);
1140 static int wdm_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1143 struct usb_host_interface
*iface
;
1144 struct usb_endpoint_descriptor
*ep
;
1145 struct usb_cdc_parsed_header hdr
;
1146 u8
*buffer
= intf
->altsetting
->extra
;
1147 int buflen
= intf
->altsetting
->extralen
;
1148 u16 maxcom
= WDM_DEFAULT_BUFSIZE
;
1153 cdc_parse_cdc_header(&hdr
, intf
, buffer
, buflen
);
1155 if (hdr
.usb_cdc_dmm_desc
)
1156 maxcom
= le16_to_cpu(hdr
.usb_cdc_dmm_desc
->wMaxCommand
);
1158 iface
= intf
->cur_altsetting
;
1159 if (iface
->desc
.bNumEndpoints
!= 1)
1161 ep
= &iface
->endpoint
[0].desc
;
1163 rv
= wdm_create(intf
, ep
, maxcom
, WWAN_PORT_UNKNOWN
, &wdm_manage_power
);
1170 * usb_cdc_wdm_register - register a WDM subdriver
1171 * @intf: usb interface the subdriver will associate with
1172 * @ep: interrupt endpoint to monitor for notifications
1173 * @bufsize: maximum message size to support for read/write
1174 * @type: Type/protocol of the transported data (MBIM, QMI...)
1175 * @manage_power: call-back invoked during open and release to
1176 * manage the device's power
1177 * Create WDM usb class character device and associate it with intf
1178 * without binding, allowing another driver to manage the interface.
1180 * The subdriver will manage the given interrupt endpoint exclusively
1181 * and will issue control requests referring to the given intf. It
1182 * will otherwise avoid interferring, and in particular not do
1183 * usb_set_intfdata/usb_get_intfdata on intf.
1185 * The return value is a pointer to the subdriver's struct usb_driver.
1186 * The registering driver is responsible for calling this subdriver's
1187 * disconnect, suspend, resume, pre_reset and post_reset methods from
1190 struct usb_driver
*usb_cdc_wdm_register(struct usb_interface
*intf
,
1191 struct usb_endpoint_descriptor
*ep
,
1192 int bufsize
, enum wwan_port_type type
,
1193 int (*manage_power
)(struct usb_interface
*, int))
1197 rv
= wdm_create(intf
, ep
, bufsize
, type
, manage_power
);
1205 EXPORT_SYMBOL(usb_cdc_wdm_register
);
1207 static void wdm_disconnect(struct usb_interface
*intf
)
1209 struct wdm_device
*desc
;
1210 unsigned long flags
;
1212 usb_deregister_dev(intf
, &wdm_class
);
1213 desc
= wdm_find_device(intf
);
1214 mutex_lock(&wdm_mutex
);
1216 wdm_wwan_deinit(desc
);
1218 /* the spinlock makes sure no new urbs are generated in the callbacks */
1219 spin_lock_irqsave(&desc
->iuspin
, flags
);
1220 set_bit(WDM_DISCONNECTING
, &desc
->flags
);
1221 set_bit(WDM_READ
, &desc
->flags
);
1222 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
1223 wake_up_all(&desc
->wait
);
1224 mutex_lock(&desc
->rlock
);
1225 mutex_lock(&desc
->wlock
);
1227 cancel_work_sync(&desc
->rxwork
);
1228 cancel_work_sync(&desc
->service_outs_intr
);
1229 mutex_unlock(&desc
->wlock
);
1230 mutex_unlock(&desc
->rlock
);
1232 /* the desc->intf pointer used as list key is now invalid */
1233 spin_lock(&wdm_device_list_lock
);
1234 list_del(&desc
->device_list
);
1235 spin_unlock(&wdm_device_list_lock
);
1240 dev_dbg(&intf
->dev
, "%d open files - postponing cleanup\n", desc
->count
);
1241 mutex_unlock(&wdm_mutex
);
1245 static int wdm_suspend(struct usb_interface
*intf
, pm_message_t message
)
1247 struct wdm_device
*desc
= wdm_find_device(intf
);
1250 dev_dbg(&desc
->intf
->dev
, "wdm%d_suspend\n", intf
->minor
);
1252 /* if this is an autosuspend the caller does the locking */
1253 if (!PMSG_IS_AUTO(message
)) {
1254 mutex_lock(&desc
->rlock
);
1255 mutex_lock(&desc
->wlock
);
1257 spin_lock_irq(&desc
->iuspin
);
1259 if (PMSG_IS_AUTO(message
) &&
1260 (test_bit(WDM_IN_USE
, &desc
->flags
)
1261 || test_bit(WDM_RESPONDING
, &desc
->flags
))) {
1262 spin_unlock_irq(&desc
->iuspin
);
1266 set_bit(WDM_SUSPENDING
, &desc
->flags
);
1267 spin_unlock_irq(&desc
->iuspin
);
1268 /* callback submits work - order is essential */
1270 cancel_work_sync(&desc
->rxwork
);
1271 cancel_work_sync(&desc
->service_outs_intr
);
1272 unpoison_urbs(desc
);
1274 if (!PMSG_IS_AUTO(message
)) {
1275 mutex_unlock(&desc
->wlock
);
1276 mutex_unlock(&desc
->rlock
);
1283 static int recover_from_urb_loss(struct wdm_device
*desc
)
1288 rv
= usb_submit_urb(desc
->validity
, GFP_NOIO
);
1290 dev_err(&desc
->intf
->dev
,
1291 "Error resume submitting int urb - %d\n", rv
);
1297 static int wdm_resume(struct usb_interface
*intf
)
1299 struct wdm_device
*desc
= wdm_find_device(intf
);
1302 dev_dbg(&desc
->intf
->dev
, "wdm%d_resume\n", intf
->minor
);
1304 clear_bit(WDM_SUSPENDING
, &desc
->flags
);
1305 rv
= recover_from_urb_loss(desc
);
1311 static int wdm_pre_reset(struct usb_interface
*intf
)
1313 struct wdm_device
*desc
= wdm_find_device(intf
);
1316 * we notify everybody using poll of
1317 * an exceptional situation
1318 * must be done before recovery lest a spontaneous
1319 * message from the device is lost
1321 spin_lock_irq(&desc
->iuspin
);
1322 set_bit(WDM_RESETTING
, &desc
->flags
); /* inform read/write */
1323 set_bit(WDM_READ
, &desc
->flags
); /* unblock read */
1324 clear_bit(WDM_IN_USE
, &desc
->flags
); /* unblock write */
1325 desc
->rerr
= -EINTR
;
1326 spin_unlock_irq(&desc
->iuspin
);
1327 wake_up_all(&desc
->wait
);
1328 mutex_lock(&desc
->rlock
);
1329 mutex_lock(&desc
->wlock
);
1331 cancel_work_sync(&desc
->rxwork
);
1332 cancel_work_sync(&desc
->service_outs_intr
);
1336 static int wdm_post_reset(struct usb_interface
*intf
)
1338 struct wdm_device
*desc
= wdm_find_device(intf
);
1341 unpoison_urbs(desc
);
1342 clear_bit(WDM_OVERFLOW
, &desc
->flags
);
1343 clear_bit(WDM_RESETTING
, &desc
->flags
);
1344 rv
= recover_from_urb_loss(desc
);
1345 mutex_unlock(&desc
->wlock
);
1346 mutex_unlock(&desc
->rlock
);
1350 static struct usb_driver wdm_driver
= {
1353 .disconnect
= wdm_disconnect
,
1355 .suspend
= wdm_suspend
,
1356 .resume
= wdm_resume
,
1357 .reset_resume
= wdm_resume
,
1359 .pre_reset
= wdm_pre_reset
,
1360 .post_reset
= wdm_post_reset
,
1361 .id_table
= wdm_ids
,
1362 .supports_autosuspend
= 1,
1363 .disable_hub_initiated_lpm
= 1,
1366 module_usb_driver(wdm_driver
);
1368 MODULE_AUTHOR(DRIVER_AUTHOR
);
1369 MODULE_DESCRIPTION(DRIVER_DESC
);
1370 MODULE_LICENSE("GPL");