]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/usb/class/cdc-wdm.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
HID: i2c-hid: fix length for set/get report in i2c hid
[mirror_ubuntu-artful-kernel.git] / drivers / usb / class / cdc-wdm.c
1 /*
2 * cdc-wdm.c
3 *
4 * This driver supports USB CDC WCM Device Management.
5 *
6 * Copyright (c) 2007-2009 Oliver Neukum
7 *
8 * Some code taken from cdc-acm.c
9 *
10 * Released under the GPLv2.
11 *
12 * Many thanks to Carl Nordbeck
13 */
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/mutex.h>
19 #include <linux/uaccess.h>
20 #include <linux/bitops.h>
21 #include <linux/poll.h>
22 #include <linux/usb.h>
23 #include <linux/usb/cdc.h>
24 #include <asm/byteorder.h>
25 #include <asm/unaligned.h>
26 #include <linux/usb/cdc-wdm.h>
27
28 /*
29 * Version Information
30 */
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"
34
35 static const struct usb_device_id wdm_ids[] = {
36 {
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
41 },
42 { }
43 };
44
45 MODULE_DEVICE_TABLE (usb, wdm_ids);
46
47 #define WDM_MINOR_BASE 176
48
49
50 #define WDM_IN_USE 1
51 #define WDM_DISCONNECTING 2
52 #define WDM_RESULT 3
53 #define WDM_READ 4
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
60 #define WDM_MAX 16
61
62 /* CDC-WMC r1.1 requires wMaxCommand to be "at least 256 decimal (0x100)" */
63 #define WDM_DEFAULT_BUFSIZE 256
64
65 static DEFINE_MUTEX(wdm_mutex);
66 static DEFINE_SPINLOCK(wdm_device_list_lock);
67 static LIST_HEAD(wdm_device_list);
68
69 /* --- method tables --- */
70
71 struct wdm_device {
72 u8 *inbuf; /* buffer for response */
73 u8 *outbuf; /* buffer for command */
74 u8 *sbuf; /* buffer for status */
75 u8 *ubuf; /* buffer for copy to user space */
76
77 struct urb *command;
78 struct urb *response;
79 struct urb *validity;
80 struct usb_interface *intf;
81 struct usb_ctrlrequest *orq;
82 struct usb_ctrlrequest *irq;
83 spinlock_t iuspin;
84
85 unsigned long flags;
86 u16 bufsize;
87 u16 wMaxCommand;
88 u16 wMaxPacketSize;
89 __le16 inum;
90 int reslength;
91 int length;
92 int read;
93 int count;
94 dma_addr_t shandle;
95 dma_addr_t ihandle;
96 struct mutex wlock;
97 struct mutex rlock;
98 wait_queue_head_t wait;
99 struct work_struct rxwork;
100 int werr;
101 int rerr;
102
103 struct list_head device_list;
104 int (*manage_power)(struct usb_interface *, int);
105 };
106
107 static struct usb_driver wdm_driver;
108
109 /* return intfdata if we own the interface, else look up intf in the list */
110 static struct wdm_device *wdm_find_device(struct usb_interface *intf)
111 {
112 struct wdm_device *desc;
113
114 spin_lock(&wdm_device_list_lock);
115 list_for_each_entry(desc, &wdm_device_list, device_list)
116 if (desc->intf == intf)
117 goto found;
118 desc = NULL;
119 found:
120 spin_unlock(&wdm_device_list_lock);
121
122 return desc;
123 }
124
125 static struct wdm_device *wdm_find_device_by_minor(int minor)
126 {
127 struct wdm_device *desc;
128
129 spin_lock(&wdm_device_list_lock);
130 list_for_each_entry(desc, &wdm_device_list, device_list)
131 if (desc->intf->minor == minor)
132 goto found;
133 desc = NULL;
134 found:
135 spin_unlock(&wdm_device_list_lock);
136
137 return desc;
138 }
139
140 /* --- callbacks --- */
141 static void wdm_out_callback(struct urb *urb)
142 {
143 struct wdm_device *desc;
144 desc = urb->context;
145 spin_lock(&desc->iuspin);
146 desc->werr = urb->status;
147 spin_unlock(&desc->iuspin);
148 kfree(desc->outbuf);
149 desc->outbuf = NULL;
150 clear_bit(WDM_IN_USE, &desc->flags);
151 wake_up(&desc->wait);
152 }
153
154 static void wdm_in_callback(struct urb *urb)
155 {
156 struct wdm_device *desc = urb->context;
157 int status = urb->status;
158
159 spin_lock(&desc->iuspin);
160 clear_bit(WDM_RESPONDING, &desc->flags);
161
162 if (status) {
163 switch (status) {
164 case -ENOENT:
165 dev_dbg(&desc->intf->dev,
166 "nonzero urb status received: -ENOENT");
167 goto skip_error;
168 case -ECONNRESET:
169 dev_dbg(&desc->intf->dev,
170 "nonzero urb status received: -ECONNRESET");
171 goto skip_error;
172 case -ESHUTDOWN:
173 dev_dbg(&desc->intf->dev,
174 "nonzero urb status received: -ESHUTDOWN");
175 goto skip_error;
176 case -EPIPE:
177 dev_err(&desc->intf->dev,
178 "nonzero urb status received: -EPIPE\n");
179 break;
180 default:
181 dev_err(&desc->intf->dev,
182 "Unexpected error %d\n", status);
183 break;
184 }
185 }
186
187 desc->rerr = status;
188 desc->reslength = urb->actual_length;
189 memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength);
190 desc->length += desc->reslength;
191 skip_error:
192 wake_up(&desc->wait);
193
194 set_bit(WDM_READ, &desc->flags);
195 spin_unlock(&desc->iuspin);
196 }
197
198 static void wdm_int_callback(struct urb *urb)
199 {
200 int rv = 0;
201 int status = urb->status;
202 struct wdm_device *desc;
203 struct usb_cdc_notification *dr;
204
205 desc = urb->context;
206 dr = (struct usb_cdc_notification *)desc->sbuf;
207
208 if (status) {
209 switch (status) {
210 case -ESHUTDOWN:
211 case -ENOENT:
212 case -ECONNRESET:
213 return; /* unplug */
214 case -EPIPE:
215 set_bit(WDM_INT_STALL, &desc->flags);
216 dev_err(&desc->intf->dev, "Stall on int endpoint\n");
217 goto sw; /* halt is cleared in work */
218 default:
219 dev_err(&desc->intf->dev,
220 "nonzero urb status received: %d\n", status);
221 break;
222 }
223 }
224
225 if (urb->actual_length < sizeof(struct usb_cdc_notification)) {
226 dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n",
227 urb->actual_length);
228 goto exit;
229 }
230
231 switch (dr->bNotificationType) {
232 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
233 dev_dbg(&desc->intf->dev,
234 "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
235 dr->wIndex, dr->wLength);
236 break;
237
238 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
239
240 dev_dbg(&desc->intf->dev,
241 "NOTIFY_NETWORK_CONNECTION %s network",
242 dr->wValue ? "connected to" : "disconnected from");
243 goto exit;
244 default:
245 clear_bit(WDM_POLL_RUNNING, &desc->flags);
246 dev_err(&desc->intf->dev,
247 "unknown notification %d received: index %d len %d\n",
248 dr->bNotificationType, dr->wIndex, dr->wLength);
249 goto exit;
250 }
251
252 spin_lock(&desc->iuspin);
253 clear_bit(WDM_READ, &desc->flags);
254 set_bit(WDM_RESPONDING, &desc->flags);
255 if (!test_bit(WDM_DISCONNECTING, &desc->flags)
256 && !test_bit(WDM_SUSPENDING, &desc->flags)) {
257 rv = usb_submit_urb(desc->response, GFP_ATOMIC);
258 dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d",
259 __func__, rv);
260 }
261 spin_unlock(&desc->iuspin);
262 if (rv < 0) {
263 clear_bit(WDM_RESPONDING, &desc->flags);
264 if (rv == -EPERM)
265 return;
266 if (rv == -ENOMEM) {
267 sw:
268 rv = schedule_work(&desc->rxwork);
269 if (rv)
270 dev_err(&desc->intf->dev,
271 "Cannot schedule work\n");
272 }
273 }
274 exit:
275 rv = usb_submit_urb(urb, GFP_ATOMIC);
276 if (rv)
277 dev_err(&desc->intf->dev,
278 "%s - usb_submit_urb failed with result %d\n",
279 __func__, rv);
280
281 }
282
283 static void kill_urbs(struct wdm_device *desc)
284 {
285 /* the order here is essential */
286 usb_kill_urb(desc->command);
287 usb_kill_urb(desc->validity);
288 usb_kill_urb(desc->response);
289 }
290
291 static void free_urbs(struct wdm_device *desc)
292 {
293 usb_free_urb(desc->validity);
294 usb_free_urb(desc->response);
295 usb_free_urb(desc->command);
296 }
297
298 static void cleanup(struct wdm_device *desc)
299 {
300 kfree(desc->sbuf);
301 kfree(desc->inbuf);
302 kfree(desc->orq);
303 kfree(desc->irq);
304 kfree(desc->ubuf);
305 free_urbs(desc);
306 kfree(desc);
307 }
308
309 static ssize_t wdm_write
310 (struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
311 {
312 u8 *buf;
313 int rv = -EMSGSIZE, r, we;
314 struct wdm_device *desc = file->private_data;
315 struct usb_ctrlrequest *req;
316
317 if (count > desc->wMaxCommand)
318 count = desc->wMaxCommand;
319
320 spin_lock_irq(&desc->iuspin);
321 we = desc->werr;
322 desc->werr = 0;
323 spin_unlock_irq(&desc->iuspin);
324 if (we < 0)
325 return -EIO;
326
327 buf = kmalloc(count, GFP_KERNEL);
328 if (!buf) {
329 rv = -ENOMEM;
330 goto outnl;
331 }
332
333 r = copy_from_user(buf, buffer, count);
334 if (r > 0) {
335 kfree(buf);
336 rv = -EFAULT;
337 goto outnl;
338 }
339
340 /* concurrent writes and disconnect */
341 r = mutex_lock_interruptible(&desc->wlock);
342 rv = -ERESTARTSYS;
343 if (r) {
344 kfree(buf);
345 goto outnl;
346 }
347
348 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
349 kfree(buf);
350 rv = -ENODEV;
351 goto outnp;
352 }
353
354 r = usb_autopm_get_interface(desc->intf);
355 if (r < 0) {
356 kfree(buf);
357 rv = usb_translate_errors(r);
358 goto outnp;
359 }
360
361 if (!(file->f_flags & O_NONBLOCK))
362 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
363 &desc->flags));
364 else
365 if (test_bit(WDM_IN_USE, &desc->flags))
366 r = -EAGAIN;
367
368 if (test_bit(WDM_RESETTING, &desc->flags))
369 r = -EIO;
370
371 if (r < 0) {
372 kfree(buf);
373 rv = r;
374 goto out;
375 }
376
377 req = desc->orq;
378 usb_fill_control_urb(
379 desc->command,
380 interface_to_usbdev(desc->intf),
381 /* using common endpoint 0 */
382 usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
383 (unsigned char *)req,
384 buf,
385 count,
386 wdm_out_callback,
387 desc
388 );
389
390 req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
391 USB_RECIP_INTERFACE);
392 req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
393 req->wValue = 0;
394 req->wIndex = desc->inum;
395 req->wLength = cpu_to_le16(count);
396 set_bit(WDM_IN_USE, &desc->flags);
397 desc->outbuf = buf;
398
399 rv = usb_submit_urb(desc->command, GFP_KERNEL);
400 if (rv < 0) {
401 kfree(buf);
402 desc->outbuf = NULL;
403 clear_bit(WDM_IN_USE, &desc->flags);
404 dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
405 rv = usb_translate_errors(rv);
406 } else {
407 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
408 req->wIndex);
409 }
410 out:
411 usb_autopm_put_interface(desc->intf);
412 outnp:
413 mutex_unlock(&desc->wlock);
414 outnl:
415 return rv < 0 ? rv : count;
416 }
417
418 static ssize_t wdm_read
419 (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
420 {
421 int rv, cntr;
422 int i = 0;
423 struct wdm_device *desc = file->private_data;
424
425
426 rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
427 if (rv < 0)
428 return -ERESTARTSYS;
429
430 cntr = ACCESS_ONCE(desc->length);
431 if (cntr == 0) {
432 desc->read = 0;
433 retry:
434 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
435 rv = -ENODEV;
436 goto err;
437 }
438 i++;
439 if (file->f_flags & O_NONBLOCK) {
440 if (!test_bit(WDM_READ, &desc->flags)) {
441 rv = cntr ? cntr : -EAGAIN;
442 goto err;
443 }
444 rv = 0;
445 } else {
446 rv = wait_event_interruptible(desc->wait,
447 test_bit(WDM_READ, &desc->flags));
448 }
449
450 /* may have happened while we slept */
451 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
452 rv = -ENODEV;
453 goto err;
454 }
455 if (test_bit(WDM_RESETTING, &desc->flags)) {
456 rv = -EIO;
457 goto err;
458 }
459 usb_mark_last_busy(interface_to_usbdev(desc->intf));
460 if (rv < 0) {
461 rv = -ERESTARTSYS;
462 goto err;
463 }
464
465 spin_lock_irq(&desc->iuspin);
466
467 if (desc->rerr) { /* read completed, error happened */
468 desc->rerr = 0;
469 spin_unlock_irq(&desc->iuspin);
470 rv = -EIO;
471 goto err;
472 }
473 /*
474 * recheck whether we've lost the race
475 * against the completion handler
476 */
477 if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
478 spin_unlock_irq(&desc->iuspin);
479 goto retry;
480 }
481 if (!desc->reslength) { /* zero length read */
482 dev_dbg(&desc->intf->dev, "%s: zero length - clearing WDM_READ\n", __func__);
483 clear_bit(WDM_READ, &desc->flags);
484 spin_unlock_irq(&desc->iuspin);
485 goto retry;
486 }
487 cntr = desc->length;
488 spin_unlock_irq(&desc->iuspin);
489 }
490
491 if (cntr > count)
492 cntr = count;
493 rv = copy_to_user(buffer, desc->ubuf, cntr);
494 if (rv > 0) {
495 rv = -EFAULT;
496 goto err;
497 }
498
499 spin_lock_irq(&desc->iuspin);
500
501 for (i = 0; i < desc->length - cntr; i++)
502 desc->ubuf[i] = desc->ubuf[i + cntr];
503
504 desc->length -= cntr;
505 /* in case we had outstanding data */
506 if (!desc->length)
507 clear_bit(WDM_READ, &desc->flags);
508
509 spin_unlock_irq(&desc->iuspin);
510
511 rv = cntr;
512
513 err:
514 mutex_unlock(&desc->rlock);
515 return rv;
516 }
517
518 static int wdm_flush(struct file *file, fl_owner_t id)
519 {
520 struct wdm_device *desc = file->private_data;
521
522 wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags));
523
524 /* cannot dereference desc->intf if WDM_DISCONNECTING */
525 if (desc->werr < 0 && !test_bit(WDM_DISCONNECTING, &desc->flags))
526 dev_err(&desc->intf->dev, "Error in flush path: %d\n",
527 desc->werr);
528
529 return usb_translate_errors(desc->werr);
530 }
531
532 static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait)
533 {
534 struct wdm_device *desc = file->private_data;
535 unsigned long flags;
536 unsigned int mask = 0;
537
538 spin_lock_irqsave(&desc->iuspin, flags);
539 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
540 mask = POLLHUP | POLLERR;
541 spin_unlock_irqrestore(&desc->iuspin, flags);
542 goto desc_out;
543 }
544 if (test_bit(WDM_READ, &desc->flags))
545 mask = POLLIN | POLLRDNORM;
546 if (desc->rerr || desc->werr)
547 mask |= POLLERR;
548 if (!test_bit(WDM_IN_USE, &desc->flags))
549 mask |= POLLOUT | POLLWRNORM;
550 spin_unlock_irqrestore(&desc->iuspin, flags);
551
552 poll_wait(file, &desc->wait, wait);
553
554 desc_out:
555 return mask;
556 }
557
558 static int wdm_open(struct inode *inode, struct file *file)
559 {
560 int minor = iminor(inode);
561 int rv = -ENODEV;
562 struct usb_interface *intf;
563 struct wdm_device *desc;
564
565 mutex_lock(&wdm_mutex);
566 desc = wdm_find_device_by_minor(minor);
567 if (!desc)
568 goto out;
569
570 intf = desc->intf;
571 if (test_bit(WDM_DISCONNECTING, &desc->flags))
572 goto out;
573 file->private_data = desc;
574
575 rv = usb_autopm_get_interface(desc->intf);
576 if (rv < 0) {
577 dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
578 goto out;
579 }
580
581 /* using write lock to protect desc->count */
582 mutex_lock(&desc->wlock);
583 if (!desc->count++) {
584 desc->werr = 0;
585 desc->rerr = 0;
586 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
587 if (rv < 0) {
588 desc->count--;
589 dev_err(&desc->intf->dev,
590 "Error submitting int urb - %d\n", rv);
591 rv = usb_translate_errors(rv);
592 }
593 } else {
594 rv = 0;
595 }
596 mutex_unlock(&desc->wlock);
597 if (desc->count == 1)
598 desc->manage_power(intf, 1);
599 usb_autopm_put_interface(desc->intf);
600 out:
601 mutex_unlock(&wdm_mutex);
602 return rv;
603 }
604
605 static int wdm_release(struct inode *inode, struct file *file)
606 {
607 struct wdm_device *desc = file->private_data;
608
609 mutex_lock(&wdm_mutex);
610
611 /* using write lock to protect desc->count */
612 mutex_lock(&desc->wlock);
613 desc->count--;
614 mutex_unlock(&desc->wlock);
615
616 if (!desc->count) {
617 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
618 dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
619 kill_urbs(desc);
620 desc->manage_power(desc->intf, 0);
621 } else {
622 /* must avoid dev_printk here as desc->intf is invalid */
623 pr_debug(KBUILD_MODNAME " %s: device gone - cleaning up\n", __func__);
624 cleanup(desc);
625 }
626 }
627 mutex_unlock(&wdm_mutex);
628 return 0;
629 }
630
631 static const struct file_operations wdm_fops = {
632 .owner = THIS_MODULE,
633 .read = wdm_read,
634 .write = wdm_write,
635 .open = wdm_open,
636 .flush = wdm_flush,
637 .release = wdm_release,
638 .poll = wdm_poll,
639 .llseek = noop_llseek,
640 };
641
642 static struct usb_class_driver wdm_class = {
643 .name = "cdc-wdm%d",
644 .fops = &wdm_fops,
645 .minor_base = WDM_MINOR_BASE,
646 };
647
648 /* --- error handling --- */
649 static void wdm_rxwork(struct work_struct *work)
650 {
651 struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
652 unsigned long flags;
653 int rv;
654
655 spin_lock_irqsave(&desc->iuspin, flags);
656 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
657 spin_unlock_irqrestore(&desc->iuspin, flags);
658 } else {
659 spin_unlock_irqrestore(&desc->iuspin, flags);
660 rv = usb_submit_urb(desc->response, GFP_KERNEL);
661 if (rv < 0 && rv != -EPERM) {
662 spin_lock_irqsave(&desc->iuspin, flags);
663 if (!test_bit(WDM_DISCONNECTING, &desc->flags))
664 schedule_work(&desc->rxwork);
665 spin_unlock_irqrestore(&desc->iuspin, flags);
666 }
667 }
668 }
669
670 /* --- hotplug --- */
671
672 static int wdm_create(struct usb_interface *intf, struct usb_endpoint_descriptor *ep,
673 u16 bufsize, int (*manage_power)(struct usb_interface *, int))
674 {
675 int rv = -ENOMEM;
676 struct wdm_device *desc;
677
678 desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
679 if (!desc)
680 goto out;
681 INIT_LIST_HEAD(&desc->device_list);
682 mutex_init(&desc->rlock);
683 mutex_init(&desc->wlock);
684 spin_lock_init(&desc->iuspin);
685 init_waitqueue_head(&desc->wait);
686 desc->wMaxCommand = bufsize;
687 /* this will be expanded and needed in hardware endianness */
688 desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
689 desc->intf = intf;
690 INIT_WORK(&desc->rxwork, wdm_rxwork);
691
692 rv = -EINVAL;
693 if (!usb_endpoint_is_int_in(ep))
694 goto err;
695
696 desc->wMaxPacketSize = usb_endpoint_maxp(ep);
697
698 desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
699 if (!desc->orq)
700 goto err;
701 desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
702 if (!desc->irq)
703 goto err;
704
705 desc->validity = usb_alloc_urb(0, GFP_KERNEL);
706 if (!desc->validity)
707 goto err;
708
709 desc->response = usb_alloc_urb(0, GFP_KERNEL);
710 if (!desc->response)
711 goto err;
712
713 desc->command = usb_alloc_urb(0, GFP_KERNEL);
714 if (!desc->command)
715 goto err;
716
717 desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
718 if (!desc->ubuf)
719 goto err;
720
721 desc->sbuf = kmalloc(desc->wMaxPacketSize, GFP_KERNEL);
722 if (!desc->sbuf)
723 goto err;
724
725 desc->inbuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
726 if (!desc->inbuf)
727 goto err;
728
729 usb_fill_int_urb(
730 desc->validity,
731 interface_to_usbdev(intf),
732 usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),
733 desc->sbuf,
734 desc->wMaxPacketSize,
735 wdm_int_callback,
736 desc,
737 ep->bInterval
738 );
739
740 desc->irq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
741 desc->irq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
742 desc->irq->wValue = 0;
743 desc->irq->wIndex = desc->inum;
744 desc->irq->wLength = cpu_to_le16(desc->wMaxCommand);
745
746 usb_fill_control_urb(
747 desc->response,
748 interface_to_usbdev(intf),
749 /* using common endpoint 0 */
750 usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
751 (unsigned char *)desc->irq,
752 desc->inbuf,
753 desc->wMaxCommand,
754 wdm_in_callback,
755 desc
756 );
757
758 desc->manage_power = manage_power;
759
760 spin_lock(&wdm_device_list_lock);
761 list_add(&desc->device_list, &wdm_device_list);
762 spin_unlock(&wdm_device_list_lock);
763
764 rv = usb_register_dev(intf, &wdm_class);
765 if (rv < 0)
766 goto err;
767 else
768 dev_info(&intf->dev, "%s: USB WDM device\n", dev_name(intf->usb_dev));
769 out:
770 return rv;
771 err:
772 spin_lock(&wdm_device_list_lock);
773 list_del(&desc->device_list);
774 spin_unlock(&wdm_device_list_lock);
775 cleanup(desc);
776 return rv;
777 }
778
779 static int wdm_manage_power(struct usb_interface *intf, int on)
780 {
781 /* need autopm_get/put here to ensure the usbcore sees the new value */
782 int rv = usb_autopm_get_interface(intf);
783 if (rv < 0)
784 goto err;
785
786 intf->needs_remote_wakeup = on;
787 usb_autopm_put_interface(intf);
788 err:
789 return rv;
790 }
791
792 static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
793 {
794 int rv = -EINVAL;
795 struct usb_host_interface *iface;
796 struct usb_endpoint_descriptor *ep;
797 struct usb_cdc_dmm_desc *dmhd;
798 u8 *buffer = intf->altsetting->extra;
799 int buflen = intf->altsetting->extralen;
800 u16 maxcom = WDM_DEFAULT_BUFSIZE;
801
802 if (!buffer)
803 goto err;
804 while (buflen > 2) {
805 if (buffer[1] != USB_DT_CS_INTERFACE) {
806 dev_err(&intf->dev, "skipping garbage\n");
807 goto next_desc;
808 }
809
810 switch (buffer[2]) {
811 case USB_CDC_HEADER_TYPE:
812 break;
813 case USB_CDC_DMM_TYPE:
814 dmhd = (struct usb_cdc_dmm_desc *)buffer;
815 maxcom = le16_to_cpu(dmhd->wMaxCommand);
816 dev_dbg(&intf->dev,
817 "Finding maximum buffer length: %d", maxcom);
818 break;
819 default:
820 dev_err(&intf->dev,
821 "Ignoring extra header, type %d, length %d\n",
822 buffer[2], buffer[0]);
823 break;
824 }
825 next_desc:
826 buflen -= buffer[0];
827 buffer += buffer[0];
828 }
829
830 iface = intf->cur_altsetting;
831 if (iface->desc.bNumEndpoints != 1)
832 goto err;
833 ep = &iface->endpoint[0].desc;
834
835 rv = wdm_create(intf, ep, maxcom, &wdm_manage_power);
836
837 err:
838 return rv;
839 }
840
841 /**
842 * usb_cdc_wdm_register - register a WDM subdriver
843 * @intf: usb interface the subdriver will associate with
844 * @ep: interrupt endpoint to monitor for notifications
845 * @bufsize: maximum message size to support for read/write
846 *
847 * Create WDM usb class character device and associate it with intf
848 * without binding, allowing another driver to manage the interface.
849 *
850 * The subdriver will manage the given interrupt endpoint exclusively
851 * and will issue control requests referring to the given intf. It
852 * will otherwise avoid interferring, and in particular not do
853 * usb_set_intfdata/usb_get_intfdata on intf.
854 *
855 * The return value is a pointer to the subdriver's struct usb_driver.
856 * The registering driver is responsible for calling this subdriver's
857 * disconnect, suspend, resume, pre_reset and post_reset methods from
858 * its own.
859 */
860 struct usb_driver *usb_cdc_wdm_register(struct usb_interface *intf,
861 struct usb_endpoint_descriptor *ep,
862 int bufsize,
863 int (*manage_power)(struct usb_interface *, int))
864 {
865 int rv = -EINVAL;
866
867 rv = wdm_create(intf, ep, bufsize, manage_power);
868 if (rv < 0)
869 goto err;
870
871 return &wdm_driver;
872 err:
873 return ERR_PTR(rv);
874 }
875 EXPORT_SYMBOL(usb_cdc_wdm_register);
876
877 static void wdm_disconnect(struct usb_interface *intf)
878 {
879 struct wdm_device *desc;
880 unsigned long flags;
881
882 usb_deregister_dev(intf, &wdm_class);
883 desc = wdm_find_device(intf);
884 mutex_lock(&wdm_mutex);
885
886 /* the spinlock makes sure no new urbs are generated in the callbacks */
887 spin_lock_irqsave(&desc->iuspin, flags);
888 set_bit(WDM_DISCONNECTING, &desc->flags);
889 set_bit(WDM_READ, &desc->flags);
890 /* to terminate pending flushes */
891 clear_bit(WDM_IN_USE, &desc->flags);
892 spin_unlock_irqrestore(&desc->iuspin, flags);
893 wake_up_all(&desc->wait);
894 mutex_lock(&desc->rlock);
895 mutex_lock(&desc->wlock);
896 kill_urbs(desc);
897 cancel_work_sync(&desc->rxwork);
898 mutex_unlock(&desc->wlock);
899 mutex_unlock(&desc->rlock);
900
901 /* the desc->intf pointer used as list key is now invalid */
902 spin_lock(&wdm_device_list_lock);
903 list_del(&desc->device_list);
904 spin_unlock(&wdm_device_list_lock);
905
906 if (!desc->count)
907 cleanup(desc);
908 else
909 dev_dbg(&intf->dev, "%s: %d open files - postponing cleanup\n", __func__, desc->count);
910 mutex_unlock(&wdm_mutex);
911 }
912
913 #ifdef CONFIG_PM
914 static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
915 {
916 struct wdm_device *desc = wdm_find_device(intf);
917 int rv = 0;
918
919 dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
920
921 /* if this is an autosuspend the caller does the locking */
922 if (!PMSG_IS_AUTO(message)) {
923 mutex_lock(&desc->rlock);
924 mutex_lock(&desc->wlock);
925 }
926 spin_lock_irq(&desc->iuspin);
927
928 if (PMSG_IS_AUTO(message) &&
929 (test_bit(WDM_IN_USE, &desc->flags)
930 || test_bit(WDM_RESPONDING, &desc->flags))) {
931 spin_unlock_irq(&desc->iuspin);
932 rv = -EBUSY;
933 } else {
934
935 set_bit(WDM_SUSPENDING, &desc->flags);
936 spin_unlock_irq(&desc->iuspin);
937 /* callback submits work - order is essential */
938 kill_urbs(desc);
939 cancel_work_sync(&desc->rxwork);
940 }
941 if (!PMSG_IS_AUTO(message)) {
942 mutex_unlock(&desc->wlock);
943 mutex_unlock(&desc->rlock);
944 }
945
946 return rv;
947 }
948 #endif
949
950 static int recover_from_urb_loss(struct wdm_device *desc)
951 {
952 int rv = 0;
953
954 if (desc->count) {
955 rv = usb_submit_urb(desc->validity, GFP_NOIO);
956 if (rv < 0)
957 dev_err(&desc->intf->dev,
958 "Error resume submitting int urb - %d\n", rv);
959 }
960 return rv;
961 }
962
963 #ifdef CONFIG_PM
964 static int wdm_resume(struct usb_interface *intf)
965 {
966 struct wdm_device *desc = wdm_find_device(intf);
967 int rv;
968
969 dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
970
971 clear_bit(WDM_SUSPENDING, &desc->flags);
972 rv = recover_from_urb_loss(desc);
973
974 return rv;
975 }
976 #endif
977
978 static int wdm_pre_reset(struct usb_interface *intf)
979 {
980 struct wdm_device *desc = wdm_find_device(intf);
981
982 /*
983 * we notify everybody using poll of
984 * an exceptional situation
985 * must be done before recovery lest a spontaneous
986 * message from the device is lost
987 */
988 spin_lock_irq(&desc->iuspin);
989 set_bit(WDM_RESETTING, &desc->flags); /* inform read/write */
990 set_bit(WDM_READ, &desc->flags); /* unblock read */
991 clear_bit(WDM_IN_USE, &desc->flags); /* unblock write */
992 desc->rerr = -EINTR;
993 spin_unlock_irq(&desc->iuspin);
994 wake_up_all(&desc->wait);
995 mutex_lock(&desc->rlock);
996 mutex_lock(&desc->wlock);
997 kill_urbs(desc);
998 cancel_work_sync(&desc->rxwork);
999 return 0;
1000 }
1001
1002 static int wdm_post_reset(struct usb_interface *intf)
1003 {
1004 struct wdm_device *desc = wdm_find_device(intf);
1005 int rv;
1006
1007 clear_bit(WDM_RESETTING, &desc->flags);
1008 rv = recover_from_urb_loss(desc);
1009 mutex_unlock(&desc->wlock);
1010 mutex_unlock(&desc->rlock);
1011 return 0;
1012 }
1013
1014 static struct usb_driver wdm_driver = {
1015 .name = "cdc_wdm",
1016 .probe = wdm_probe,
1017 .disconnect = wdm_disconnect,
1018 #ifdef CONFIG_PM
1019 .suspend = wdm_suspend,
1020 .resume = wdm_resume,
1021 .reset_resume = wdm_resume,
1022 #endif
1023 .pre_reset = wdm_pre_reset,
1024 .post_reset = wdm_post_reset,
1025 .id_table = wdm_ids,
1026 .supports_autosuspend = 1,
1027 .disable_hub_initiated_lpm = 1,
1028 };
1029
1030 module_usb_driver(wdm_driver);
1031
1032 MODULE_AUTHOR(DRIVER_AUTHOR);
1033 MODULE_DESCRIPTION(DRIVER_DESC);
1034 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror