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