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/smp_lock.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 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
  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
 318         if (!file->f_flags && O_NONBLOCK)
 319                 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
 320                                                                 &desc->flags));
 321         else
 322                 if (test_bit(WDM_IN_USE, &desc->flags))
 323                         r = -EAGAIN;
 324         if (r < 0)
 325                 goto out;
 326
 327         if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 328                 rv = -ENODEV;
 329                 goto out;
 330         }
 331
 332         desc->outbuf = buf = kmalloc(count, GFP_KERNEL);
 333         if (!buf) {
 334                 rv = -ENOMEM;
 335                 goto out;
 336         }
 337
 338         r = copy_from_user(buf, buffer, count);
 339         if (r > 0) {
 340                 kfree(buf);
 341                 rv = -EFAULT;
 342                 goto out;
 343         }
 344
 345         req = desc->orq;
 346         usb_fill_control_urb(
 347                 desc->command,
 348                 interface_to_usbdev(desc->intf),
 349                 /* using common endpoint 0 */
 350                 usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
 351                 (unsigned char *)req,
 352                 buf,
 353                 count,
 354                 wdm_out_callback,
 355                 desc
 356         );
 357
 358         req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
 359                              USB_RECIP_INTERFACE);
 360         req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
 361         req->wValue = 0;
 362         req->wIndex = desc->inum;
 363         req->wLength = cpu_to_le16(count);
 364         set_bit(WDM_IN_USE, &desc->flags);
 365
 366         rv = usb_submit_urb(desc->command, GFP_KERNEL);
 367         if (rv < 0) {
 368                 kfree(buf);
 369                 clear_bit(WDM_IN_USE, &desc->flags);
 370                 dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
 371         } else {
 372                 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
 373                         req->wIndex);
 374         }
 375 out:
 376         usb_autopm_put_interface(desc->intf);
 377 outnp:
 378         mutex_unlock(&desc->wlock);
 379 outnl:
 380         return rv < 0 ? rv : count;
 381 }
 382
 383 static ssize_t wdm_read
 384 (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 385 {
 386         int rv, cntr = 0;
 387         int i = 0;
 388         struct wdm_device *desc = file->private_data;
 389
 390
 391         rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
 392         if (rv < 0)
 393                 return -ERESTARTSYS;
 394
 395         if (desc->length == 0) {
 396                 desc->read = 0;
 397 retry:
 398                 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 399                         rv = -ENODEV;
 400                         goto err;
 401                 }
 402                 i++;
 403                 if (file->f_flags & O_NONBLOCK) {
 404                         if (!test_bit(WDM_READ, &desc->flags)) {
 405                                 rv = cntr ? cntr : -EAGAIN;
 406                                 goto err;
 407                         }
 408                         rv = 0;
 409                 } else {
 410                         rv = wait_event_interruptible(desc->wait,
 411                                 test_bit(WDM_READ, &desc->flags));
 412                 }
 413
 414                 /* may have happened while we slept */
 415                 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 416                         rv = -ENODEV;
 417                         goto err;
 418                 }
 419                 usb_mark_last_busy(interface_to_usbdev(desc->intf));
 420                 if (rv < 0) {
 421                         rv = -ERESTARTSYS;
 422                         goto err;
 423                 }
 424
 425                 spin_lock_irq(&desc->iuspin);
 426
 427                 if (desc->rerr) { /* read completed, error happened */
 428                         int t = desc->rerr;
 429                         desc->rerr = 0;
 430                         spin_unlock_irq(&desc->iuspin);
 431                         dev_err(&desc->intf->dev,
 432                                 "reading had resulted in %d\n", t);
 433                         rv = -EIO;
 434                         goto err;
 435                 }
 436                 /*
 437                  * recheck whether we've lost the race
 438                  * against the completion handler
 439                  */
 440                 if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
 441                         spin_unlock_irq(&desc->iuspin);
 442                         goto retry;
 443                 }
 444                 if (!desc->reslength) { /* zero length read */
 445                         spin_unlock_irq(&desc->iuspin);
 446                         goto retry;
 447                 }
 448                 clear_bit(WDM_READ, &desc->flags);
 449                 spin_unlock_irq(&desc->iuspin);
 450         }
 451
 452         cntr = count > desc->length ? desc->length : count;
 453         rv = copy_to_user(buffer, desc->ubuf, cntr);
 454         if (rv > 0) {
 455                 rv = -EFAULT;
 456                 goto err;
 457         }
 458
 459         for (i = 0; i < desc->length - cntr; i++)
 460                 desc->ubuf[i] = desc->ubuf[i + cntr];
 461
 462         desc->length -= cntr;
 463         /* in case we had outstanding data */
 464         if (!desc->length)
 465                 clear_bit(WDM_READ, &desc->flags);
 466         rv = cntr;
 467
 468 err:
 469         mutex_unlock(&desc->rlock);
 470         if (rv < 0 && rv != -EAGAIN)
 471                 dev_err(&desc->intf->dev, "wdm_read: exit error\n");
 472         return rv;
 473 }
 474
 475 static int wdm_flush(struct file *file, fl_owner_t id)
 476 {
 477         struct wdm_device *desc = file->private_data;
 478
 479         wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags));
 480         if (desc->werr < 0)
 481                 dev_err(&desc->intf->dev, "Error in flush path: %d\n",
 482                         desc->werr);
 483
 484         return desc->werr;
 485 }
 486
 487 static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait)
 488 {
 489         struct wdm_device *desc = file->private_data;
 490         unsigned long flags;
 491         unsigned int mask = 0;
 492
 493         spin_lock_irqsave(&desc->iuspin, flags);
 494         if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 495                 mask = POLLERR;
 496                 spin_unlock_irqrestore(&desc->iuspin, flags);
 497                 goto desc_out;
 498         }
 499         if (test_bit(WDM_READ, &desc->flags))
 500                 mask = POLLIN | POLLRDNORM;
 501         if (desc->rerr || desc->werr)
 502                 mask |= POLLERR;
 503         if (!test_bit(WDM_IN_USE, &desc->flags))
 504                 mask |= POLLOUT | POLLWRNORM;
 505         spin_unlock_irqrestore(&desc->iuspin, flags);
 506
 507         poll_wait(file, &desc->wait, wait);
 508
 509 desc_out:
 510         return mask;
 511 }
 512
 513 static int wdm_open(struct inode *inode, struct file *file)
 514 {
 515         int minor = iminor(inode);
 516         int rv = -ENODEV;
 517         struct usb_interface *intf;
 518         struct wdm_device *desc;
 519
 520         lock_kernel();
 521         mutex_lock(&wdm_mutex);
 522         intf = usb_find_interface(&wdm_driver, minor);
 523         if (!intf)
 524                 goto out;
 525
 526         desc = usb_get_intfdata(intf);
 527         if (test_bit(WDM_DISCONNECTING, &desc->flags))
 528                 goto out;
 529         file->private_data = desc;
 530
 531         rv = usb_autopm_get_interface(desc->intf);
 532         if (rv < 0) {
 533                 dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
 534                 goto out;
 535         }
 536         intf->needs_remote_wakeup = 1;
 537
 538         mutex_lock(&desc->plock);
 539         if (!desc->count++) {
 540                 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
 541                 if (rv < 0) {
 542                         desc->count--;
 543                         dev_err(&desc->intf->dev,
 544                                 "Error submitting int urb - %d\n", rv);
 545                 }
 546         } else {
 547                 rv = 0;
 548         }
 549         mutex_unlock(&desc->plock);
 550         usb_autopm_put_interface(desc->intf);
 551 out:
 552         mutex_unlock(&wdm_mutex);
 553         unlock_kernel();
 554         return rv;
 555 }
 556
 557 static int wdm_release(struct inode *inode, struct file *file)
 558 {
 559         struct wdm_device *desc = file->private_data;
 560
 561         mutex_lock(&wdm_mutex);
 562         mutex_lock(&desc->plock);
 563         desc->count--;
 564         mutex_unlock(&desc->plock);
 565
 566         if (!desc->count) {
 567                 dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
 568                 kill_urbs(desc);
 569                 if (!test_bit(WDM_DISCONNECTING, &desc->flags))
 570                         desc->intf->needs_remote_wakeup = 0;
 571         }
 572         mutex_unlock(&wdm_mutex);
 573         return 0;
 574 }
 575
 576 static const struct file_operations wdm_fops = {
 577         .owner =        THIS_MODULE,
 578         .read =         wdm_read,
 579         .write =        wdm_write,
 580         .open =         wdm_open,
 581         .flush =        wdm_flush,
 582         .release =      wdm_release,
 583         .poll =         wdm_poll
 584 };
 585
 586 static struct usb_class_driver wdm_class = {
 587         .name =         "cdc-wdm%d",
 588         .fops =         &wdm_fops,
 589         .minor_base =   WDM_MINOR_BASE,
 590 };
 591
 592 /* --- error handling --- */
 593 static void wdm_rxwork(struct work_struct *work)
 594 {
 595         struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
 596         unsigned long flags;
 597         int rv;
 598
 599         spin_lock_irqsave(&desc->iuspin, flags);
 600         if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
 601                 spin_unlock_irqrestore(&desc->iuspin, flags);
 602         } else {
 603                 spin_unlock_irqrestore(&desc->iuspin, flags);
 604                 rv = usb_submit_urb(desc->response, GFP_KERNEL);
 605                 if (rv < 0 && rv != -EPERM) {
 606                         spin_lock_irqsave(&desc->iuspin, flags);
 607                         if (!test_bit(WDM_DISCONNECTING, &desc->flags))
 608                                 schedule_work(&desc->rxwork);
 609                         spin_unlock_irqrestore(&desc->iuspin, flags);
 610                 }
 611         }
 612 }
 613
 614 /* --- hotplug --- */
 615
 616 static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
 617 {
 618         int rv = -EINVAL;
 619         struct usb_device *udev = interface_to_usbdev(intf);
 620         struct wdm_device *desc;
 621         struct usb_host_interface *iface;
 622         struct usb_endpoint_descriptor *ep;
 623         struct usb_cdc_dmm_desc *dmhd;
 624         u8 *buffer = intf->altsetting->extra;
 625         int buflen = intf->altsetting->extralen;
 626         u16 maxcom = 0;
 627
 628         if (!buffer)
 629                 goto out;
 630
 631         while (buflen > 2) {
 632                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 633                         dev_err(&intf->dev, "skipping garbage\n");
 634                         goto next_desc;
 635                 }
 636
 637                 switch (buffer [2]) {
 638                 case USB_CDC_HEADER_TYPE:
 639                         break;
 640                 case USB_CDC_DMM_TYPE:
 641                         dmhd = (struct usb_cdc_dmm_desc *)buffer;
 642                         maxcom = le16_to_cpu(dmhd->wMaxCommand);
 643                         dev_dbg(&intf->dev,
 644                                 "Finding maximum buffer length: %d", maxcom);
 645                         break;
 646                 default:
 647                         dev_err(&intf->dev,
 648                                 "Ignoring extra header, type %d, length %d\n",
 649                                 buffer[2], buffer[0]);
 650                         break;
 651                 }
 652 next_desc:
 653                 buflen -= buffer[0];
 654                 buffer += buffer[0];
 655         }
 656
 657         rv = -ENOMEM;
 658         desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
 659         if (!desc)
 660                 goto out;
 661         mutex_init(&desc->wlock);
 662         mutex_init(&desc->rlock);
 663         mutex_init(&desc->plock);
 664         spin_lock_init(&desc->iuspin);
 665         init_waitqueue_head(&desc->wait);
 666         desc->wMaxCommand = maxcom;
 667         /* this will be expanded and needed in hardware endianness */
 668         desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
 669         desc->intf = intf;
 670         INIT_WORK(&desc->rxwork, wdm_rxwork);
 671
 672         rv = -EINVAL;
 673         iface = intf->cur_altsetting;
 674         if (iface->desc.bNumEndpoints != 1)
 675                 goto err;
 676         ep = &iface->endpoint[0].desc;
 677         if (!ep || !usb_endpoint_is_int_in(ep))
 678                 goto err;
 679
 680         desc->wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
 681         desc->bMaxPacketSize0 = udev->descriptor.bMaxPacketSize0;
 682
 683         desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 684         if (!desc->orq)
 685                 goto err;
 686         desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 687         if (!desc->irq)
 688                 goto err;
 689
 690         desc->validity = usb_alloc_urb(0, GFP_KERNEL);
 691         if (!desc->validity)
 692                 goto err;
 693
 694         desc->response = usb_alloc_urb(0, GFP_KERNEL);
 695         if (!desc->response)
 696                 goto err;
 697
 698         desc->command = usb_alloc_urb(0, GFP_KERNEL);
 699         if (!desc->command)
 700                 goto err;
 701
 702         desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
 703         if (!desc->ubuf)
 704                 goto err;
 705
 706         desc->sbuf = usb_buffer_alloc(interface_to_usbdev(intf),
 707                                         desc->wMaxPacketSize,
 708                                         GFP_KERNEL,
 709                                         &desc->validity->transfer_dma);
 710         if (!desc->sbuf)
 711                 goto err;
 712
 713         desc->inbuf = usb_buffer_alloc(interface_to_usbdev(intf),
 714                                         desc->bMaxPacketSize0,
 715                                         GFP_KERNEL,
 716                                         &desc->response->transfer_dma);
 717         if (!desc->inbuf)
 718                 goto err2;
 719
 720         usb_fill_int_urb(
 721                 desc->validity,
 722                 interface_to_usbdev(intf),
 723                 usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),
 724                 desc->sbuf,
 725                 desc->wMaxPacketSize,
 726                 wdm_int_callback,
 727                 desc,
 728                 ep->bInterval
 729         );
 730         desc->validity->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 731
 732         usb_set_intfdata(intf, desc);
 733         rv = usb_register_dev(intf, &wdm_class);
 734         if (rv < 0)
 735                 goto err3;
 736         else
 737                 dev_info(&intf->dev, "cdc-wdm%d: USB WDM device\n",
 738                         intf->minor - WDM_MINOR_BASE);
 739 out:
 740         return rv;
 741 err3:
 742         usb_set_intfdata(intf, NULL);
 743         usb_buffer_free(interface_to_usbdev(desc->intf),
 744                         desc->bMaxPacketSize0,
 745                         desc->inbuf,
 746                         desc->response->transfer_dma);
 747 err2:
 748         usb_buffer_free(interface_to_usbdev(desc->intf),
 749                         desc->wMaxPacketSize,
 750                         desc->sbuf,
 751                         desc->validity->transfer_dma);
 752 err:
 753         free_urbs(desc);
 754         kfree(desc->ubuf);
 755         kfree(desc->orq);
 756         kfree(desc->irq);
 757         kfree(desc);
 758         return rv;
 759 }
 760
 761 static void wdm_disconnect(struct usb_interface *intf)
 762 {
 763         struct wdm_device *desc;
 764         unsigned long flags;
 765
 766         usb_deregister_dev(intf, &wdm_class);
 767         mutex_lock(&wdm_mutex);
 768         desc = usb_get_intfdata(intf);
 769
 770         /* the spinlock makes sure no new urbs are generated in the callbacks */
 771         spin_lock_irqsave(&desc->iuspin, flags);
 772         set_bit(WDM_DISCONNECTING, &desc->flags);
 773         set_bit(WDM_READ, &desc->flags);
 774         /* to terminate pending flushes */
 775         clear_bit(WDM_IN_USE, &desc->flags);
 776         spin_unlock_irqrestore(&desc->iuspin, flags);
 777         cancel_work_sync(&desc->rxwork);
 778         kill_urbs(desc);
 779         wake_up_all(&desc->wait);
 780         if (!desc->count)
 781                 cleanup(desc);
 782         mutex_unlock(&wdm_mutex);
 783 }
 784
 785 static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
 786 {
 787         struct wdm_device *desc = usb_get_intfdata(intf);
 788         int rv = 0;
 789
 790         dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
 791
 792         mutex_lock(&desc->plock);
 793 #ifdef CONFIG_PM
 794         if ((message.event & PM_EVENT_AUTO) &&
 795                         test_bit(WDM_IN_USE, &desc->flags)) {
 796                 rv = -EBUSY;
 797         } else {
 798 #endif
 799                 cancel_work_sync(&desc->rxwork);
 800                 kill_urbs(desc);
 801 #ifdef CONFIG_PM
 802         }
 803 #endif
 804         mutex_unlock(&desc->plock);
 805
 806         return rv;
 807 }
 808
 809 static int recover_from_urb_loss(struct wdm_device *desc)
 810 {
 811         int rv = 0;
 812
 813         if (desc->count) {
 814                 rv = usb_submit_urb(desc->validity, GFP_NOIO);
 815                 if (rv < 0)
 816                         dev_err(&desc->intf->dev,
 817                                 "Error resume submitting int urb - %d\n", rv);
 818         }
 819         return rv;
 820 }
 821 static int wdm_resume(struct usb_interface *intf)
 822 {
 823         struct wdm_device *desc = usb_get_intfdata(intf);
 824         int rv;
 825
 826         dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
 827         mutex_lock(&desc->plock);
 828         rv = recover_from_urb_loss(desc);
 829         mutex_unlock(&desc->plock);
 830         return rv;
 831 }
 832
 833 static int wdm_pre_reset(struct usb_interface *intf)
 834 {
 835         struct wdm_device *desc = usb_get_intfdata(intf);
 836
 837         mutex_lock(&desc->plock);
 838         return 0;
 839 }
 840
 841 static int wdm_post_reset(struct usb_interface *intf)
 842 {
 843         struct wdm_device *desc = usb_get_intfdata(intf);
 844         int rv;
 845
 846         rv = recover_from_urb_loss(desc);
 847         mutex_unlock(&desc->plock);
 848         return 0;
 849 }
 850
 851 static struct usb_driver wdm_driver = {
 852         .name =         "cdc_wdm",
 853         .probe =        wdm_probe,
 854         .disconnect =   wdm_disconnect,
 855         .suspend =      wdm_suspend,
 856         .resume =       wdm_resume,
 857         .reset_resume = wdm_resume,
 858         .pre_reset =    wdm_pre_reset,
 859         .post_reset =   wdm_post_reset,
 860         .id_table =     wdm_ids,
 861         .supports_autosuspend = 1,
 862 };
 863
 864 /* --- low level module stuff --- */
 865
 866 static int __init wdm_init(void)
 867 {
 868         int rv;
 869
 870         rv = usb_register(&wdm_driver);
 871
 872         return rv;
 873 }
 874
 875 static void __exit wdm_exit(void)
 876 {
 877         usb_deregister(&wdm_driver);
 878 }
 879
 880 module_init(wdm_init);
 881 module_exit(wdm_exit);
 882
 883 MODULE_AUTHOR(DRIVER_AUTHOR);
 884 MODULE_DESCRIPTION(DRIVER_DESC);
 885 MODULE_LICENSE("GPL");