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/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> 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 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 57 58 #define WDM_MAX 16 59 60 61 static DEFINE_MUTEX(wdm_mutex); 62 63 /* --- method tables --- */ 64 65 struct wdm_device { 66 u8 *inbuf; /* buffer for response */ 67 u8 *outbuf; /* buffer for command */ 68 u8 *sbuf; /* buffer for status */ 69 u8 *ubuf; /* buffer for copy to user space */ 70 71 struct urb *command; 72 struct urb *response; 73 struct urb *validity; 74 struct usb_interface *intf; 75 struct usb_ctrlrequest *orq; 76 struct usb_ctrlrequest *irq; 77 spinlock_t iuspin; 78 79 unsigned long flags; 80 u16 bufsize; 81 u16 wMaxCommand; 82 u16 wMaxPacketSize; 83 u16 bMaxPacketSize0; 84 __le16 inum; 85 int reslength; 86 int length; 87 int read; 88 int count; 89 dma_addr_t shandle; 90 dma_addr_t ihandle; 91 struct mutex wlock; 92 struct mutex rlock; 93 struct mutex plock; 94 wait_queue_head_t wait; 95 struct work_struct rxwork; 96 int werr; 97 int rerr; 98 }; 99 100 static struct usb_driver wdm_driver; 101 102 /* --- callbacks --- */ 103 static void wdm_out_callback(struct urb *urb) 104 { 105 struct wdm_device *desc; 106 desc = urb->context; 107 spin_lock(&desc->iuspin); 108 desc->werr = urb->status; 109 spin_unlock(&desc->iuspin); 110 clear_bit(WDM_IN_USE, &desc->flags); 111 kfree(desc->outbuf); 112 wake_up(&desc->wait); 113 } 114 115 static void wdm_in_callback(struct urb *urb) 116 { 117 struct wdm_device *desc = urb->context; 118 int status = urb->status; 119 120 spin_lock(&desc->iuspin); 121 122 if (status) { 123 switch (status) { 124 case -ENOENT: 125 dev_dbg(&desc->intf->dev, 126 "nonzero urb status received: -ENOENT"); 127 break; 128 case -ECONNRESET: 129 dev_dbg(&desc->intf->dev, 130 "nonzero urb status received: -ECONNRESET"); 131 break; 132 case -ESHUTDOWN: 133 dev_dbg(&desc->intf->dev, 134 "nonzero urb status received: -ESHUTDOWN"); 135 break; 136 case -EPIPE: 137 dev_err(&desc->intf->dev, 138 "nonzero urb status received: -EPIPE\n"); 139 break; 140 default: 141 dev_err(&desc->intf->dev, 142 "Unexpected error %d\n", status); 143 break; 144 } 145 } 146 147 desc->rerr = status; 148 desc->reslength = urb->actual_length; 149 memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength); 150 desc->length += desc->reslength; 151 wake_up(&desc->wait); 152 153 set_bit(WDM_READ, &desc->flags); 154 spin_unlock(&desc->iuspin); 155 } 156 157 static void wdm_int_callback(struct urb *urb) 158 { 159 int rv = 0; 160 int status = urb->status; 161 struct wdm_device *desc; 162 struct usb_ctrlrequest *req; 163 struct usb_cdc_notification *dr; 164 165 desc = urb->context; 166 req = desc->irq; 167 dr = (struct usb_cdc_notification *)desc->sbuf; 168 169 if (status) { 170 switch (status) { 171 case -ESHUTDOWN: 172 case -ENOENT: 173 case -ECONNRESET: 174 return; /* unplug */ 175 case -EPIPE: 176 set_bit(WDM_INT_STALL, &desc->flags); 177 dev_err(&desc->intf->dev, "Stall on int endpoint\n"); 178 goto sw; /* halt is cleared in work */ 179 default: 180 dev_err(&desc->intf->dev, 181 "nonzero urb status received: %d\n", status); 182 break; 183 } 184 } 185 186 if (urb->actual_length < sizeof(struct usb_cdc_notification)) { 187 dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n", 188 urb->actual_length); 189 goto exit; 190 } 191 192 switch (dr->bNotificationType) { 193 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE: 194 dev_dbg(&desc->intf->dev, 195 "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d", 196 dr->wIndex, dr->wLength); 197 break; 198 199 case USB_CDC_NOTIFY_NETWORK_CONNECTION: 200 201 dev_dbg(&desc->intf->dev, 202 "NOTIFY_NETWORK_CONNECTION %s network", 203 dr->wValue ? "connected to" : "disconnected from"); 204 goto exit; 205 default: 206 clear_bit(WDM_POLL_RUNNING, &desc->flags); 207 dev_err(&desc->intf->dev, 208 "unknown notification %d received: index %d len %d\n", 209 dr->bNotificationType, dr->wIndex, dr->wLength); 210 goto exit; 211 } 212 213 req->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE); 214 req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE; 215 req->wValue = 0; 216 req->wIndex = desc->inum; 217 req->wLength = cpu_to_le16(desc->wMaxCommand); 218 219 usb_fill_control_urb( 220 desc->response, 221 interface_to_usbdev(desc->intf), 222 /* using common endpoint 0 */ 223 usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0), 224 (unsigned char *)req, 225 desc->inbuf, 226 desc->wMaxCommand, 227 wdm_in_callback, 228 desc 229 ); 230 desc->response->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 231 spin_lock(&desc->iuspin); 232 clear_bit(WDM_READ, &desc->flags); 233 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) { 234 rv = usb_submit_urb(desc->response, GFP_ATOMIC); 235 dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d", 236 __func__, rv); 237 } 238 spin_unlock(&desc->iuspin); 239 if (rv < 0) { 240 if (rv == -EPERM) 241 return; 242 if (rv == -ENOMEM) { 243 sw: 244 rv = schedule_work(&desc->rxwork); 245 if (rv) 246 dev_err(&desc->intf->dev, 247 "Cannot schedule work\n"); 248 } 249 } 250 exit: 251 rv = usb_submit_urb(urb, GFP_ATOMIC); 252 if (rv) 253 dev_err(&desc->intf->dev, 254 "%s - usb_submit_urb failed with result %d\n", 255 __func__, rv); 256 257 } 258 259 static void kill_urbs(struct wdm_device *desc) 260 { 261 /* the order here is essential */ 262 usb_kill_urb(desc->command); 263 usb_kill_urb(desc->validity); 264 usb_kill_urb(desc->response); 265 } 266 267 static void free_urbs(struct wdm_device *desc) 268 { 269 usb_free_urb(desc->validity); 270 usb_free_urb(desc->response); 271 usb_free_urb(desc->command); 272 } 273 274 static void cleanup(struct wdm_device *desc) 275 { 276 usb_buffer_free(interface_to_usbdev(desc->intf), 277 desc->wMaxPacketSize, 278 desc->sbuf, 279 desc->validity->transfer_dma); 280 usb_buffer_free(interface_to_usbdev(desc->intf), 281 desc->wMaxCommand, 282 desc->inbuf, 283 desc->response->transfer_dma); 284 kfree(desc->orq); 285 kfree(desc->irq); 286 kfree(desc->ubuf); 287 free_urbs(desc); 288 kfree(desc); 289 } 290 291 static ssize_t wdm_write 292 (struct file *file, const char __user *buffer, size_t count, loff_t *ppos) 293 { 294 u8 *buf; 295 int rv = -EMSGSIZE, r, we; 296 struct wdm_device *desc = file->private_data; 297 struct usb_ctrlrequest *req; 298 299 if (count > desc->wMaxCommand) 300 count = desc->wMaxCommand; 301 302 spin_lock_irq(&desc->iuspin); 303 we = desc->werr; 304 desc->werr = 0; 305 spin_unlock_irq(&desc->iuspin); 306 if (we < 0) 307 return -EIO; 308 309 r = mutex_lock_interruptible(&desc->wlock); /* concurrent writes */ 310 rv = -ERESTARTSYS; 311 if (r) 312 goto outnl; 313 314 r = usb_autopm_get_interface(desc->intf); 315 if (r < 0) 316 goto outnp; 317 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE, 318 &desc->flags)); 319 if (r < 0) 320 goto out; 321 322 if (test_bit(WDM_DISCONNECTING, &desc->flags)) { 323 rv = -ENODEV; 324 goto out; 325 } 326 327 desc->outbuf = buf = kmalloc(count, GFP_KERNEL); 328 if (!buf) { 329 rv = -ENOMEM; 330 goto out; 331 } 332 333 r = copy_from_user(buf, buffer, count); 334 if (r > 0) { 335 kfree(buf); 336 rv = -EFAULT; 337 goto out; 338 } 339 340 req = desc->orq; 341 usb_fill_control_urb( 342 desc->command, 343 interface_to_usbdev(desc->intf), 344 /* using common endpoint 0 */ 345 usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0), 346 (unsigned char *)req, 347 buf, 348 count, 349 wdm_out_callback, 350 desc 351 ); 352 353 req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS | 354 USB_RECIP_INTERFACE); 355 req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND; 356 req->wValue = 0; 357 req->wIndex = desc->inum; 358 req->wLength = cpu_to_le16(count); 359 set_bit(WDM_IN_USE, &desc->flags); 360 361 rv = usb_submit_urb(desc->command, GFP_KERNEL); 362 if (rv < 0) { 363 kfree(buf); 364 clear_bit(WDM_IN_USE, &desc->flags); 365 dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv); 366 } else { 367 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d", 368 req->wIndex); 369 } 370 out: 371 usb_autopm_put_interface(desc->intf); 372 outnp: 373 mutex_unlock(&desc->wlock); 374 outnl: 375 return rv < 0 ? rv : count; 376 } 377 378 static ssize_t wdm_read 379 (struct file *file, char __user *buffer, size_t count, loff_t *ppos) 380 { 381 int rv, cntr; 382 int i = 0; 383 struct wdm_device *desc = file->private_data; 384 385 386 rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */ 387 if (rv < 0) 388 return -ERESTARTSYS; 389 390 if (desc->length == 0) { 391 desc->read = 0; 392 retry: 393 i++; 394 rv = wait_event_interruptible(desc->wait, 395 test_bit(WDM_READ, &desc->flags)); 396 397 if (test_bit(WDM_DISCONNECTING, &desc->flags)) { 398 rv = -ENODEV; 399 goto err; 400 } 401 usb_mark_last_busy(interface_to_usbdev(desc->intf)); 402 if (rv < 0) { 403 rv = -ERESTARTSYS; 404 goto err; 405 } 406 407 spin_lock_irq(&desc->iuspin); 408 409 if (desc->rerr) { /* read completed, error happened */ 410 int t = desc->rerr; 411 desc->rerr = 0; 412 spin_unlock_irq(&desc->iuspin); 413 dev_err(&desc->intf->dev, 414 "reading had resulted in %d\n", t); 415 rv = -EIO; 416 goto err; 417 } 418 /* 419 * recheck whether we've lost the race 420 * against the completion handler 421 */ 422 if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */ 423 spin_unlock_irq(&desc->iuspin); 424 goto retry; 425 } 426 if (!desc->reslength) { /* zero length read */ 427 spin_unlock_irq(&desc->iuspin); 428 goto retry; 429 } 430 clear_bit(WDM_READ, &desc->flags); 431 spin_unlock_irq(&desc->iuspin); 432 } 433 434 cntr = count > desc->length ? desc->length : count; 435 rv = copy_to_user(buffer, desc->ubuf, cntr); 436 if (rv > 0) { 437 rv = -EFAULT; 438 goto err; 439 } 440 441 for (i = 0; i < desc->length - cntr; i++) 442 desc->ubuf[i] = desc->ubuf[i + cntr]; 443 444 desc->length -= cntr; 445 /* in case we had outstanding data */ 446 if (!desc->length) 447 clear_bit(WDM_READ, &desc->flags); 448 rv = cntr; 449 450 err: 451 mutex_unlock(&desc->rlock); 452 if (rv < 0) 453 dev_err(&desc->intf->dev, "wdm_read: exit error\n"); 454 return rv; 455 } 456 457 static int wdm_flush(struct file *file, fl_owner_t id) 458 { 459 struct wdm_device *desc = file->private_data; 460 461 wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags)); 462 if (desc->werr < 0) 463 dev_err(&desc->intf->dev, "Error in flush path: %d\n", 464 desc->werr); 465 466 return desc->werr; 467 } 468 469 static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait) 470 { 471 struct wdm_device *desc = file->private_data; 472 unsigned long flags; 473 unsigned int mask = 0; 474 475 spin_lock_irqsave(&desc->iuspin, flags); 476 if (test_bit(WDM_DISCONNECTING, &desc->flags)) { 477 mask = POLLERR; 478 spin_unlock_irqrestore(&desc->iuspin, flags); 479 goto desc_out; 480 } 481 if (test_bit(WDM_READ, &desc->flags)) 482 mask = POLLIN | POLLRDNORM; 483 if (desc->rerr || desc->werr) 484 mask |= POLLERR; 485 if (!test_bit(WDM_IN_USE, &desc->flags)) 486 mask |= POLLOUT | POLLWRNORM; 487 spin_unlock_irqrestore(&desc->iuspin, flags); 488 489 poll_wait(file, &desc->wait, wait); 490 491 desc_out: 492 return mask; 493 } 494 495 static int wdm_open(struct inode *inode, struct file *file) 496 { 497 int minor = iminor(inode); 498 int rv = -ENODEV; 499 struct usb_interface *intf; 500 struct wdm_device *desc; 501 502 mutex_lock(&wdm_mutex); 503 intf = usb_find_interface(&wdm_driver, minor); 504 if (!intf) 505 goto out; 506 507 desc = usb_get_intfdata(intf); 508 if (test_bit(WDM_DISCONNECTING, &desc->flags)) 509 goto out; 510 511 ; 512 file->private_data = desc; 513 514 rv = usb_autopm_get_interface(desc->intf); 515 if (rv < 0) { 516 dev_err(&desc->intf->dev, "Error autopm - %d\n", rv); 517 goto out; 518 } 519 intf->needs_remote_wakeup = 1; 520 521 mutex_lock(&desc->plock); 522 if (!desc->count++) { 523 rv = usb_submit_urb(desc->validity, GFP_KERNEL); 524 if (rv < 0) { 525 desc->count--; 526 dev_err(&desc->intf->dev, 527 "Error submitting int urb - %d\n", rv); 528 } 529 } else { 530 rv = 0; 531 } 532 mutex_unlock(&desc->plock); 533 usb_autopm_put_interface(desc->intf); 534 out: 535 mutex_unlock(&wdm_mutex); 536 return rv; 537 } 538 539 static int wdm_release(struct inode *inode, struct file *file) 540 { 541 struct wdm_device *desc = file->private_data; 542 543 mutex_lock(&wdm_mutex); 544 mutex_lock(&desc->plock); 545 desc->count--; 546 mutex_unlock(&desc->plock); 547 548 if (!desc->count) { 549 dev_dbg(&desc->intf->dev, "wdm_release: cleanup"); 550 kill_urbs(desc); 551 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) 552 desc->intf->needs_remote_wakeup = 0; 553 } 554 mutex_unlock(&wdm_mutex); 555 return 0; 556 } 557 558 static const struct file_operations wdm_fops = { 559 .owner = THIS_MODULE, 560 .read = wdm_read, 561 .write = wdm_write, 562 .open = wdm_open, 563 .flush = wdm_flush, 564 .release = wdm_release, 565 .poll = wdm_poll 566 }; 567 568 static struct usb_class_driver wdm_class = { 569 .name = "cdc-wdm%d", 570 .fops = &wdm_fops, 571 .minor_base = WDM_MINOR_BASE, 572 }; 573 574 /* --- error handling --- */ 575 static void wdm_rxwork(struct work_struct *work) 576 { 577 struct wdm_device *desc = container_of(work, struct wdm_device, rxwork); 578 unsigned long flags; 579 int rv; 580 581 spin_lock_irqsave(&desc->iuspin, flags); 582 if (test_bit(WDM_DISCONNECTING, &desc->flags)) { 583 spin_unlock_irqrestore(&desc->iuspin, flags); 584 } else { 585 spin_unlock_irqrestore(&desc->iuspin, flags); 586 rv = usb_submit_urb(desc->response, GFP_KERNEL); 587 if (rv < 0 && rv != -EPERM) { 588 spin_lock_irqsave(&desc->iuspin, flags); 589 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) 590 schedule_work(&desc->rxwork); 591 spin_unlock_irqrestore(&desc->iuspin, flags); 592 } 593 } 594 } 595 596 /* --- hotplug --- */ 597 598 static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id) 599 { 600 int rv = -EINVAL; 601 struct usb_device *udev = interface_to_usbdev(intf); 602 struct wdm_device *desc; 603 struct usb_host_interface *iface; 604 struct usb_endpoint_descriptor *ep; 605 struct usb_cdc_dmm_desc *dmhd; 606 u8 *buffer = intf->altsetting->extra; 607 int buflen = intf->altsetting->extralen; 608 u16 maxcom = 0; 609 610 if (!buffer) 611 goto out; 612 613 while (buflen > 2) { 614 if (buffer [1] != USB_DT_CS_INTERFACE) { 615 dev_err(&intf->dev, "skipping garbage\n"); 616 goto next_desc; 617 } 618 619 switch (buffer [2]) { 620 case USB_CDC_HEADER_TYPE: 621 break; 622 case USB_CDC_DMM_TYPE: 623 dmhd = (struct usb_cdc_dmm_desc *)buffer; 624 maxcom = le16_to_cpu(dmhd->wMaxCommand); 625 dev_dbg(&intf->dev, 626 "Finding maximum buffer length: %d", maxcom); 627 break; 628 default: 629 dev_err(&intf->dev, 630 "Ignoring extra header, type %d, length %d\n", 631 buffer[2], buffer[0]); 632 break; 633 } 634 next_desc: 635 buflen -= buffer[0]; 636 buffer += buffer[0]; 637 } 638 639 rv = -ENOMEM; 640 desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL); 641 if (!desc) 642 goto out; 643 mutex_init(&desc->wlock); 644 mutex_init(&desc->rlock); 645 mutex_init(&desc->plock); 646 spin_lock_init(&desc->iuspin); 647 init_waitqueue_head(&desc->wait); 648 desc->wMaxCommand = maxcom; 649 /* this will be expanded and needed in hardware endianness */ 650 desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber); 651 desc->intf = intf; 652 INIT_WORK(&desc->rxwork, wdm_rxwork); 653 654 rv = -EINVAL; 655 iface = intf->cur_altsetting; 656 if (iface->desc.bNumEndpoints != 1) 657 goto err; 658 ep = &iface->endpoint[0].desc; 659 if (!ep || !usb_endpoint_is_int_in(ep)) 660 goto err; 661 662 desc->wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize); 663 desc->bMaxPacketSize0 = udev->descriptor.bMaxPacketSize0; 664 665 desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL); 666 if (!desc->orq) 667 goto err; 668 desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL); 669 if (!desc->irq) 670 goto err; 671 672 desc->validity = usb_alloc_urb(0, GFP_KERNEL); 673 if (!desc->validity) 674 goto err; 675 676 desc->response = usb_alloc_urb(0, GFP_KERNEL); 677 if (!desc->response) 678 goto err; 679 680 desc->command = usb_alloc_urb(0, GFP_KERNEL); 681 if (!desc->command) 682 goto err; 683 684 desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL); 685 if (!desc->ubuf) 686 goto err; 687 688 desc->sbuf = usb_buffer_alloc(interface_to_usbdev(intf), 689 desc->wMaxPacketSize, 690 GFP_KERNEL, 691 &desc->validity->transfer_dma); 692 if (!desc->sbuf) 693 goto err; 694 695 desc->inbuf = usb_buffer_alloc(interface_to_usbdev(intf), 696 desc->bMaxPacketSize0, 697 GFP_KERNEL, 698 &desc->response->transfer_dma); 699 if (!desc->inbuf) 700 goto err2; 701 702 usb_fill_int_urb( 703 desc->validity, 704 interface_to_usbdev(intf), 705 usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress), 706 desc->sbuf, 707 desc->wMaxPacketSize, 708 wdm_int_callback, 709 desc, 710 ep->bInterval 711 ); 712 desc->validity->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 713 714 usb_set_intfdata(intf, desc); 715 rv = usb_register_dev(intf, &wdm_class); 716 if (rv < 0) 717 goto err3; 718 else 719 dev_info(&intf->dev, "cdc-wdm%d: USB WDM device\n", 720 intf->minor - WDM_MINOR_BASE); 721 out: 722 return rv; 723 err3: 724 usb_set_intfdata(intf, NULL); 725 usb_buffer_free(interface_to_usbdev(desc->intf), 726 desc->bMaxPacketSize0, 727 desc->inbuf, 728 desc->response->transfer_dma); 729 err2: 730 usb_buffer_free(interface_to_usbdev(desc->intf), 731 desc->wMaxPacketSize, 732 desc->sbuf, 733 desc->validity->transfer_dma); 734 err: 735 free_urbs(desc); 736 kfree(desc->ubuf); 737 kfree(desc->orq); 738 kfree(desc->irq); 739 kfree(desc); 740 return rv; 741 } 742 743 static void wdm_disconnect(struct usb_interface *intf) 744 { 745 struct wdm_device *desc; 746 unsigned long flags; 747 748 usb_deregister_dev(intf, &wdm_class); 749 mutex_lock(&wdm_mutex); 750 desc = usb_get_intfdata(intf); 751 752 /* the spinlock makes sure no new urbs are generated in the callbacks */ 753 spin_lock_irqsave(&desc->iuspin, flags); 754 set_bit(WDM_DISCONNECTING, &desc->flags); 755 set_bit(WDM_READ, &desc->flags); 756 /* to terminate pending flushes */ 757 clear_bit(WDM_IN_USE, &desc->flags); 758 spin_unlock_irqrestore(&desc->iuspin, flags); 759 cancel_work_sync(&desc->rxwork); 760 kill_urbs(desc); 761 wake_up_all(&desc->wait); 762 if (!desc->count) 763 cleanup(desc); 764 mutex_unlock(&wdm_mutex); 765 } 766 767 static int wdm_suspend(struct usb_interface *intf, pm_message_t message) 768 { 769 struct wdm_device *desc = usb_get_intfdata(intf); 770 int rv = 0; 771 772 dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor); 773 774 mutex_lock(&desc->plock); 775 #ifdef CONFIG_PM 776 if ((message.event & PM_EVENT_AUTO) && 777 test_bit(WDM_IN_USE, &desc->flags)) { 778 rv = -EBUSY; 779 } else { 780 #endif 781 cancel_work_sync(&desc->rxwork); 782 kill_urbs(desc); 783 #ifdef CONFIG_PM 784 } 785 #endif 786 mutex_unlock(&desc->plock); 787 788 return rv; 789 } 790 791 static int recover_from_urb_loss(struct wdm_device *desc) 792 { 793 int rv = 0; 794 795 if (desc->count) { 796 rv = usb_submit_urb(desc->validity, GFP_NOIO); 797 if (rv < 0) 798 dev_err(&desc->intf->dev, 799 "Error resume submitting int urb - %d\n", rv); 800 } 801 return rv; 802 } 803 static int wdm_resume(struct usb_interface *intf) 804 { 805 struct wdm_device *desc = usb_get_intfdata(intf); 806 int rv; 807 808 dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor); 809 mutex_lock(&desc->plock); 810 rv = recover_from_urb_loss(desc); 811 mutex_unlock(&desc->plock); 812 return rv; 813 } 814 815 static int wdm_pre_reset(struct usb_interface *intf) 816 { 817 struct wdm_device *desc = usb_get_intfdata(intf); 818 819 mutex_lock(&desc->plock); 820 return 0; 821 } 822 823 static int wdm_post_reset(struct usb_interface *intf) 824 { 825 struct wdm_device *desc = usb_get_intfdata(intf); 826 int rv; 827 828 rv = recover_from_urb_loss(desc); 829 mutex_unlock(&desc->plock); 830 return 0; 831 } 832 833 static struct usb_driver wdm_driver = { 834 .name = "cdc_wdm", 835 .probe = wdm_probe, 836 .disconnect = wdm_disconnect, 837 .suspend = wdm_suspend, 838 .resume = wdm_resume, 839 .reset_resume = wdm_resume, 840 .pre_reset = wdm_pre_reset, 841 .post_reset = wdm_post_reset, 842 .id_table = wdm_ids, 843 .supports_autosuspend = 1, 844 }; 845 846 /* --- low level module stuff --- */ 847 848 static int __init wdm_init(void) 849 { 850 int rv; 851 852 rv = usb_register(&wdm_driver); 853 854 return rv; 855 } 856 857 static void __exit wdm_exit(void) 858 { 859 usb_deregister(&wdm_driver); 860 } 861 862 module_init(wdm_init); 863 module_exit(wdm_exit); 864 865 MODULE_AUTHOR(DRIVER_AUTHOR); 866 MODULE_DESCRIPTION(DRIVER_DESC); 867 MODULE_LICENSE("GPL"); 868