err.no Git - linux-2.6/blob - drivers/usb/class/cdc-acm.c

   1 /*
   2  * cdc-acm.c
   3  *
   4  * Copyright (c) 1999 Armin Fuerst      <fuerst@in.tum.de>
   5  * Copyright (c) 1999 Pavel Machek      <pavel@suse.cz>
   6  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
   7  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   8  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
   9  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  10  *
  11  * USB Abstract Control Model driver for USB modems and ISDN adapters
  12  *
  13  * Sponsored by SuSE
  14  *
  15  * ChangeLog:
  16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  17  *      v0.10 - some more cleanups
  18  *      v0.11 - fixed flow control, read error doesn't stop reads
  19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  20  *      v0.13 - added termios, added hangup
  21  *      v0.14 - sized down struct acm
  22  *      v0.15 - fixed flow control again - characters could be lost
  23  *      v0.16 - added code for modems with swapped data and control interfaces
  24  *      v0.17 - added new style probing
  25  *      v0.18 - fixed new style probing for devices with more configurations
  26  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  27  *      v0.20 - switched to probing on interface (rather than device) class
  28  *      v0.21 - revert to probing on device for devices with multiple configs
  29  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  30  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  31  *      v0.23 - use softirq for rx processing, as needed by tty layer
  32  *      v0.24 - change probe method to evaluate CDC union descriptor
  33  *      v0.25 - downstream tasks paralelized to maximize throughput
  34  *      v0.26 - multiple write urbs, writesize increased
  35  */
  36
  37 /*
  38  * This program is free software; you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation; either version 2 of the License, or
  41  * (at your option) any later version.
  42  *
  43  * This program is distributed in the hope that it will be useful,
  44  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  46  * GNU General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program; if not, write to the Free Software
  50  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  51  */
  52
  53 #undef DEBUG
  54
  55 #include <linux/kernel.h>
  56 #include <linux/errno.h>
  57 #include <linux/init.h>
  58 #include <linux/slab.h>
  59 #include <linux/tty.h>
  60 #include <linux/tty_driver.h>
  61 #include <linux/tty_flip.h>
  62 #include <linux/module.h>
  63 #include <linux/mutex.h>
  64 #include <asm/uaccess.h>
  65 #include <linux/usb.h>
  66 #include <linux/usb/cdc.h>
  67 #include <asm/byteorder.h>
  68 #include <asm/unaligned.h>
  69 #include <linux/list.h>
  70
  71 #include "cdc-acm.h"
  72
  73 /*
  74  * Version Information
  75  */
  76 #define DRIVER_VERSION "v0.26"
  77 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  78 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  79
  80 static struct usb_driver acm_driver;
  81 static struct tty_driver *acm_tty_driver;
  82 static struct acm *acm_table[ACM_TTY_MINORS];
  83
  84 static DEFINE_MUTEX(open_mutex);
  85
  86 #define ACM_READY(acm)  (acm && acm->dev && acm->used)
  87
  88 /*
  89  * Functions for ACM control messages.
  90  */
  91
  92 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  93 {
  94         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  95                 request, USB_RT_ACM, value,
  96                 acm->control->altsetting[0].desc.bInterfaceNumber,
  97                 buf, len, 5000);
  98         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  99         return retval < 0 ? retval : 0;
 100 }
 101
 102 /* devices aren't required to support these requests.
 103  * the cdc acm descriptor tells whether they do...
 104  */
 105 #define acm_set_control(acm, control) \
 106         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 107 #define acm_set_line(acm, line) \
 108         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 109 #define acm_send_break(acm, ms) \
 110         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 111
 112 /*
 113  * Write buffer management.
 114  * All of these assume proper locks taken by the caller.
 115  */
 116
 117 static int acm_wb_alloc(struct acm *acm)
 118 {
 119         int i, wbn;
 120         struct acm_wb *wb;
 121
 122         wbn = 0;
 123         i = 0;
 124         for (;;) {
 125                 wb = &acm->wb[wbn];
 126                 if (!wb->use) {
 127                         wb->use = 1;
 128                         return wbn;
 129                 }
 130                 wbn = (wbn + 1) % ACM_NW;
 131                 if (++i >= ACM_NW)
 132                         return -1;
 133         }
 134 }
 135
 136 static int acm_wb_is_avail(struct acm *acm)
 137 {
 138         int i, n;
 139
 140         n = ACM_NW;
 141         for (i = 0; i < ACM_NW; i++) {
 142                 n -= acm->wb[i].use;
 143         }
 144         return n;
 145 }
 146
 147 static inline int acm_wb_is_used(struct acm *acm, int wbn)
 148 {
 149         return acm->wb[wbn].use;
 150 }
 151
 152 /*
 153  * Finish write.
 154  */
 155 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 156 {
 157         unsigned long flags;
 158
 159         spin_lock_irqsave(&acm->write_lock, flags);
 160         acm->write_ready = 1;
 161         wb->use = 0;
 162         acm->transmitting--;
 163         spin_unlock_irqrestore(&acm->write_lock, flags);
 164 }
 165
 166 /*
 167  * Poke write.
 168  *
 169  * the caller is responsible for locking
 170  */
 171
 172 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 173 {
 174         int rc;
 175
 176         acm->transmitting++;
 177
 178         wb->urb->transfer_buffer = wb->buf;
 179         wb->urb->transfer_dma = wb->dmah;
 180         wb->urb->transfer_buffer_length = wb->len;
 181         wb->urb->dev = acm->dev;
 182
 183         if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
 184                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
 185                 acm_write_done(acm, wb);
 186         }
 187         return rc;
 188 }
 189
 190 static int acm_write_start(struct acm *acm, int wbn)
 191 {
 192         unsigned long flags;
 193         struct acm_wb *wb;
 194         int rc;
 195
 196         spin_lock_irqsave(&acm->write_lock, flags);
 197         if (!acm->dev) {
 198                 spin_unlock_irqrestore(&acm->write_lock, flags);
 199                 return -ENODEV;
 200         }
 201
 202         if (!acm->write_ready) {
 203                 spin_unlock_irqrestore(&acm->write_lock, flags);
 204                 return 0;       /* A white lie */
 205         }
 206
 207         wb = &acm->wb[wbn];
 208         if(acm_wb_is_avail(acm) <= 1)
 209                 acm->write_ready = 0;
 210
 211         dbg("%s susp_count: %d", __func__, acm->susp_count);
 212         if (acm->susp_count) {
 213                 acm->old_ready = acm->write_ready;
 214                 acm->delayed_wb = wb;
 215                 acm->write_ready = 0;
 216                 schedule_work(&acm->waker);
 217                 spin_unlock_irqrestore(&acm->write_lock, flags);
 218                 return 0;       /* A white lie */
 219         }
 220         usb_mark_last_busy(acm->dev);
 221
 222         if (!acm_wb_is_used(acm, wbn)) {
 223                 spin_unlock_irqrestore(&acm->write_lock, flags);
 224                 return 0;
 225         }
 226
 227         rc = acm_start_wb(acm, wb);
 228         spin_unlock_irqrestore(&acm->write_lock, flags);
 229
 230         return rc;
 231
 232 }
 233 /*
 234  * attributes exported through sysfs
 235  */
 236 static ssize_t show_caps
 237 (struct device *dev, struct device_attribute *attr, char *buf)
 238 {
 239         struct usb_interface *intf = to_usb_interface(dev);
 240         struct acm *acm = usb_get_intfdata(intf);
 241
 242         return sprintf(buf, "%d", acm->ctrl_caps);
 243 }
 244 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 245
 246 static ssize_t show_country_codes
 247 (struct device *dev, struct device_attribute *attr, char *buf)
 248 {
 249         struct usb_interface *intf = to_usb_interface(dev);
 250         struct acm *acm = usb_get_intfdata(intf);
 251
 252         memcpy(buf, acm->country_codes, acm->country_code_size);
 253         return acm->country_code_size;
 254 }
 255
 256 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 257
 258 static ssize_t show_country_rel_date
 259 (struct device *dev, struct device_attribute *attr, char *buf)
 260 {
 261         struct usb_interface *intf = to_usb_interface(dev);
 262         struct acm *acm = usb_get_intfdata(intf);
 263
 264         return sprintf(buf, "%d", acm->country_rel_date);
 265 }
 266
 267 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 268 /*
 269  * Interrupt handlers for various ACM device responses
 270  */
 271
 272 /* control interface reports status changes with "interrupt" transfers */
 273 static void acm_ctrl_irq(struct urb *urb)
 274 {
 275         struct acm *acm = urb->context;
 276         struct usb_cdc_notification *dr = urb->transfer_buffer;
 277         unsigned char *data;
 278         int newctrl;
 279         int retval;
 280         int status = urb->status;
 281
 282         switch (status) {
 283         case 0:
 284                 /* success */
 285                 break;
 286         case -ECONNRESET:
 287         case -ENOENT:
 288         case -ESHUTDOWN:
 289                 /* this urb is terminated, clean up */
 290                 dbg("%s - urb shutting down with status: %d", __func__, status);
 291                 return;
 292         default:
 293                 dbg("%s - nonzero urb status received: %d", __func__, status);
 294                 goto exit;
 295         }
 296
 297         if (!ACM_READY(acm))
 298                 goto exit;
 299
 300         data = (unsigned char *)(dr + 1);
 301         switch (dr->bNotificationType) {
 302
 303                 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 304
 305                         dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 306                         break;
 307
 308                 case USB_CDC_NOTIFY_SERIAL_STATE:
 309
 310                         newctrl = get_unaligned_le16(data);
 311
 312                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 313                                 dbg("calling hangup");
 314                                 tty_hangup(acm->tty);
 315                         }
 316
 317                         acm->ctrlin = newctrl;
 318
 319                         dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 320                                 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 321                                 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 322                                 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 323                                 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 324
 325                         break;
 326
 327                 default:
 328                         dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 329                                 dr->bNotificationType, dr->wIndex,
 330                                 dr->wLength, data[0], data[1]);
 331                         break;
 332         }
 333 exit:
 334         usb_mark_last_busy(acm->dev);
 335         retval = usb_submit_urb (urb, GFP_ATOMIC);
 336         if (retval)
 337                 err ("%s - usb_submit_urb failed with result %d",
 338                      __func__, retval);
 339 }
 340
 341 /* data interface returns incoming bytes, or we got unthrottled */
 342 static void acm_read_bulk(struct urb *urb)
 343 {
 344         struct acm_rb *buf;
 345         struct acm_ru *rcv = urb->context;
 346         struct acm *acm = rcv->instance;
 347         int status = urb->status;
 348
 349         dbg("Entering acm_read_bulk with status %d", status);
 350
 351         if (!ACM_READY(acm)) {
 352                 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
 353                 return;
 354         }
 355         usb_mark_last_busy(acm->dev);
 356
 357         if (status)
 358                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
 359
 360         buf = rcv->buffer;
 361         buf->size = urb->actual_length;
 362
 363         if (likely(status == 0)) {
 364                 spin_lock(&acm->read_lock);
 365                 acm->processing++;
 366                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 367                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 368                 spin_unlock(&acm->read_lock);
 369         } else {
 370                 /* we drop the buffer due to an error */
 371                 spin_lock(&acm->read_lock);
 372                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 373                 list_add(&buf->list, &acm->spare_read_bufs);
 374                 spin_unlock(&acm->read_lock);
 375                 /* nevertheless the tasklet must be kicked unconditionally
 376                 so the queue cannot dry up */
 377         }
 378         if (likely(!acm->susp_count))
 379                 tasklet_schedule(&acm->urb_task);
 380 }
 381
 382 static void acm_rx_tasklet(unsigned long _acm)
 383 {
 384         struct acm *acm = (void *)_acm;
 385         struct acm_rb *buf;
 386         struct tty_struct *tty = acm->tty;
 387         struct acm_ru *rcv;
 388         unsigned long flags;
 389         unsigned char throttled;
 390
 391         dbg("Entering acm_rx_tasklet");
 392
 393         if (!ACM_READY(acm))
 394         {
 395                 dbg("acm_rx_tasklet: ACM not ready");
 396                 return;
 397         }
 398
 399         spin_lock_irqsave(&acm->throttle_lock, flags);
 400         throttled = acm->throttle;
 401         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 402         if (throttled)
 403         {
 404                 dbg("acm_rx_tasklet: throttled");
 405                 return;
 406         }
 407
 408 next_buffer:
 409         spin_lock_irqsave(&acm->read_lock, flags);
 410         if (list_empty(&acm->filled_read_bufs)) {
 411                 spin_unlock_irqrestore(&acm->read_lock, flags);
 412                 goto urbs;
 413         }
 414         buf = list_entry(acm->filled_read_bufs.next,
 415                          struct acm_rb, list);
 416         list_del(&buf->list);
 417         spin_unlock_irqrestore(&acm->read_lock, flags);
 418
 419         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 420
 421         tty_buffer_request_room(tty, buf->size);
 422         spin_lock_irqsave(&acm->throttle_lock, flags);
 423         throttled = acm->throttle;
 424         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 425         if (!throttled)
 426                 tty_insert_flip_string(tty, buf->base, buf->size);
 427         tty_flip_buffer_push(tty);
 428
 429         if (throttled) {
 430                 dbg("Throttling noticed");
 431                 spin_lock_irqsave(&acm->read_lock, flags);
 432                 list_add(&buf->list, &acm->filled_read_bufs);
 433                 spin_unlock_irqrestore(&acm->read_lock, flags);
 434                 return;
 435         }
 436
 437         spin_lock_irqsave(&acm->read_lock, flags);
 438         list_add(&buf->list, &acm->spare_read_bufs);
 439         spin_unlock_irqrestore(&acm->read_lock, flags);
 440         goto next_buffer;
 441
 442 urbs:
 443         while (!list_empty(&acm->spare_read_bufs)) {
 444                 spin_lock_irqsave(&acm->read_lock, flags);
 445                 if (list_empty(&acm->spare_read_urbs)) {
 446                         acm->processing = 0;
 447                         spin_unlock_irqrestore(&acm->read_lock, flags);
 448                         return;
 449                 }
 450                 rcv = list_entry(acm->spare_read_urbs.next,
 451                                  struct acm_ru, list);
 452                 list_del(&rcv->list);
 453                 spin_unlock_irqrestore(&acm->read_lock, flags);
 454
 455                 buf = list_entry(acm->spare_read_bufs.next,
 456                                  struct acm_rb, list);
 457                 list_del(&buf->list);
 458
 459                 rcv->buffer = buf;
 460
 461                 usb_fill_bulk_urb(rcv->urb, acm->dev,
 462                                   acm->rx_endpoint,
 463                                   buf->base,
 464                                   acm->readsize,
 465                                   acm_read_bulk, rcv);
 466                 rcv->urb->transfer_dma = buf->dma;
 467                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 468
 469                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
 470                    free-urbs-pool and resubmited ASAP */
 471                 spin_lock_irqsave(&acm->read_lock, flags);
 472                 if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 473                         list_add(&buf->list, &acm->spare_read_bufs);
 474                         list_add(&rcv->list, &acm->spare_read_urbs);
 475                         acm->processing = 0;
 476                         spin_unlock_irqrestore(&acm->read_lock, flags);
 477                         return;
 478                 } else {
 479                         spin_unlock_irqrestore(&acm->read_lock, flags);
 480                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 481                 }
 482         }
 483         spin_lock_irqsave(&acm->read_lock, flags);
 484         acm->processing = 0;
 485         spin_unlock_irqrestore(&acm->read_lock, flags);
 486 }
 487
 488 /* data interface wrote those outgoing bytes */
 489 static void acm_write_bulk(struct urb *urb)
 490 {
 491         struct acm *acm;
 492         struct acm_wb *wb = urb->context;
 493
 494         dbg("Entering acm_write_bulk with status %d", urb->status);
 495
 496         acm = wb->instance;
 497         acm_write_done(acm, wb);
 498         if (ACM_READY(acm))
 499                 schedule_work(&acm->work);
 500 }
 501
 502 static void acm_softint(struct work_struct *work)
 503 {
 504         struct acm *acm = container_of(work, struct acm, work);
 505         dbg("Entering acm_softint.");
 506
 507         if (!ACM_READY(acm))
 508                 return;
 509         tty_wakeup(acm->tty);
 510 }
 511
 512 static void acm_waker(struct work_struct *waker)
 513 {
 514         struct acm *acm = container_of(waker, struct acm, waker);
 515         unsigned long flags;
 516         int rv;
 517
 518         rv = usb_autopm_get_interface(acm->control);
 519         if (rv < 0) {
 520                 err("Autopm failure in %s", __func__);
 521                 return;
 522         }
 523         if (acm->delayed_wb) {
 524                 acm_start_wb(acm, acm->delayed_wb);
 525                 acm->delayed_wb = NULL;
 526         }
 527         spin_lock_irqsave(&acm->write_lock, flags);
 528         acm->write_ready = acm->old_ready;
 529         spin_unlock_irqrestore(&acm->write_lock, flags);
 530         usb_autopm_put_interface(acm->control);
 531 }
 532
 533 /*
 534  * TTY handlers
 535  */
 536
 537 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 538 {
 539         struct acm *acm;
 540         int rv = -EINVAL;
 541         int i;
 542         dbg("Entering acm_tty_open.");
 543
 544         mutex_lock(&open_mutex);
 545
 546         acm = acm_table[tty->index];
 547         if (!acm || !acm->dev)
 548                 goto err_out;
 549         else
 550                 rv = 0;
 551
 552         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 553         tty->driver_data = acm;
 554         acm->tty = tty;
 555
 556         /* force low_latency on so that our tty_push actually forces the data through,
 557            otherwise it is scheduled, and with high data rates data can get lost. */
 558         tty->low_latency = 1;
 559
 560         if (usb_autopm_get_interface(acm->control) < 0)
 561                 goto early_bail;
 562         else
 563                 acm->control->needs_remote_wakeup = 1;
 564
 565         mutex_lock(&acm->mutex);
 566         if (acm->used++) {
 567                 usb_autopm_put_interface(acm->control);
 568                 goto done;
 569         }
 570
 571
 572         acm->ctrlurb->dev = acm->dev;
 573         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 574                 dbg("usb_submit_urb(ctrl irq) failed");
 575                 goto bail_out;
 576         }
 577
 578         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 579             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 580                 goto full_bailout;
 581         usb_autopm_put_interface(acm->control);
 582
 583         INIT_LIST_HEAD(&acm->spare_read_urbs);
 584         INIT_LIST_HEAD(&acm->spare_read_bufs);
 585         INIT_LIST_HEAD(&acm->filled_read_bufs);
 586         for (i = 0; i < acm->rx_buflimit; i++) {
 587                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 588         }
 589         for (i = 0; i < acm->rx_buflimit; i++) {
 590                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 591         }
 592
 593         acm->throttle = 0;
 594
 595         tasklet_schedule(&acm->urb_task);
 596
 597 done:
 598 err_out:
 599         mutex_unlock(&acm->mutex);
 600         mutex_unlock(&open_mutex);
 601         return rv;
 602
 603 full_bailout:
 604         usb_kill_urb(acm->ctrlurb);
 605 bail_out:
 606         usb_autopm_put_interface(acm->control);
 607         acm->used--;
 608         mutex_unlock(&acm->mutex);
 609 early_bail:
 610         mutex_unlock(&open_mutex);
 611         return -EIO;
 612 }
 613
 614 static void acm_tty_unregister(struct acm *acm)
 615 {
 616         int i,nr;
 617
 618         nr = acm->rx_buflimit;
 619         tty_unregister_device(acm_tty_driver, acm->minor);
 620         usb_put_intf(acm->control);
 621         acm_table[acm->minor] = NULL;
 622         usb_free_urb(acm->ctrlurb);
 623         for (i = 0; i < ACM_NW; i++)
 624                 usb_free_urb(acm->wb[i].urb);
 625         for (i = 0; i < nr; i++)
 626                 usb_free_urb(acm->ru[i].urb);
 627         kfree(acm->country_codes);
 628         kfree(acm);
 629 }
 630
 631 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 632 {
 633         struct acm *acm = tty->driver_data;
 634         int i,nr;
 635
 636         if (!acm || !acm->used)
 637                 return;
 638
 639         nr = acm->rx_buflimit;
 640         mutex_lock(&open_mutex);
 641         if (!--acm->used) {
 642                 if (acm->dev) {
 643                         usb_autopm_get_interface(acm->control);
 644                         acm_set_control(acm, acm->ctrlout = 0);
 645                         usb_kill_urb(acm->ctrlurb);
 646                         for (i = 0; i < ACM_NW; i++)
 647                                 usb_kill_urb(acm->wb[i].urb);
 648                         for (i = 0; i < nr; i++)
 649                                 usb_kill_urb(acm->ru[i].urb);
 650                         acm->control->needs_remote_wakeup = 0;
 651                         usb_autopm_put_interface(acm->control);
 652                 } else
 653                         acm_tty_unregister(acm);
 654         }
 655         mutex_unlock(&open_mutex);
 656 }
 657
 658 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 659 {
 660         struct acm *acm = tty->driver_data;
 661         int stat;
 662         unsigned long flags;
 663         int wbn;
 664         struct acm_wb *wb;
 665
 666         dbg("Entering acm_tty_write to write %d bytes,", count);
 667
 668         if (!ACM_READY(acm))
 669                 return -EINVAL;
 670         if (!count)
 671                 return 0;
 672
 673         spin_lock_irqsave(&acm->write_lock, flags);
 674         if ((wbn = acm_wb_alloc(acm)) < 0) {
 675                 spin_unlock_irqrestore(&acm->write_lock, flags);
 676                 return 0;
 677         }
 678         wb = &acm->wb[wbn];
 679
 680         count = (count > acm->writesize) ? acm->writesize : count;
 681         dbg("Get %d bytes...", count);
 682         memcpy(wb->buf, buf, count);
 683         wb->len = count;
 684         spin_unlock_irqrestore(&acm->write_lock, flags);
 685
 686         if ((stat = acm_write_start(acm, wbn)) < 0)
 687                 return stat;
 688         return count;
 689 }
 690
 691 static int acm_tty_write_room(struct tty_struct *tty)
 692 {
 693         struct acm *acm = tty->driver_data;
 694         if (!ACM_READY(acm))
 695                 return -EINVAL;
 696         /*
 697          * Do not let the line discipline to know that we have a reserve,
 698          * or it might get too enthusiastic.
 699          */
 700         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 701 }
 702
 703 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 704 {
 705         struct acm *acm = tty->driver_data;
 706         if (!ACM_READY(acm))
 707                 return -EINVAL;
 708         /*
 709          * This is inaccurate (overcounts), but it works.
 710          */
 711         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 712 }
 713
 714 static void acm_tty_throttle(struct tty_struct *tty)
 715 {
 716         struct acm *acm = tty->driver_data;
 717         if (!ACM_READY(acm))
 718                 return;
 719         spin_lock_bh(&acm->throttle_lock);
 720         acm->throttle = 1;
 721         spin_unlock_bh(&acm->throttle_lock);
 722 }
 723
 724 static void acm_tty_unthrottle(struct tty_struct *tty)
 725 {
 726         struct acm *acm = tty->driver_data;
 727         if (!ACM_READY(acm))
 728                 return;
 729         spin_lock_bh(&acm->throttle_lock);
 730         acm->throttle = 0;
 731         spin_unlock_bh(&acm->throttle_lock);
 732         tasklet_schedule(&acm->urb_task);
 733 }
 734
 735 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 736 {
 737         struct acm *acm = tty->driver_data;
 738         int retval;
 739         if (!ACM_READY(acm))
 740                 return -EINVAL;
 741         retval = acm_send_break(acm, state ? 0xffff : 0);
 742         if (retval < 0)
 743                 dbg("send break failed");
 744         return retval;
 745 }
 746
 747 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 748 {
 749         struct acm *acm = tty->driver_data;
 750
 751         if (!ACM_READY(acm))
 752                 return -EINVAL;
 753
 754         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 755                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 756                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 757                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 758                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 759                TIOCM_CTS;
 760 }
 761
 762 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 763                             unsigned int set, unsigned int clear)
 764 {
 765         struct acm *acm = tty->driver_data;
 766         unsigned int newctrl;
 767
 768         if (!ACM_READY(acm))
 769                 return -EINVAL;
 770
 771         newctrl = acm->ctrlout;
 772         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 773         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 774
 775         newctrl = (newctrl & ~clear) | set;
 776
 777         if (acm->ctrlout == newctrl)
 778                 return 0;
 779         return acm_set_control(acm, acm->ctrlout = newctrl);
 780 }
 781
 782 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 783 {
 784         struct acm *acm = tty->driver_data;
 785
 786         if (!ACM_READY(acm))
 787                 return -EINVAL;
 788
 789         return -ENOIOCTLCMD;
 790 }
 791
 792 static const __u32 acm_tty_speed[] = {
 793         0, 50, 75, 110, 134, 150, 200, 300, 600,
 794         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 795         57600, 115200, 230400, 460800, 500000, 576000,
 796         921600, 1000000, 1152000, 1500000, 2000000,
 797         2500000, 3000000, 3500000, 4000000
 798 };
 799
 800 static const __u8 acm_tty_size[] = {
 801         5, 6, 7, 8
 802 };
 803
 804 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 805 {
 806         struct acm *acm = tty->driver_data;
 807         struct ktermios *termios = tty->termios;
 808         struct usb_cdc_line_coding newline;
 809         int newctrl = acm->ctrlout;
 810
 811         if (!ACM_READY(acm))
 812                 return;
 813
 814         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 815                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 816         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 817         newline.bParityType = termios->c_cflag & PARENB ?
 818                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 819         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 820
 821         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 822
 823         if (!newline.dwDTERate) {
 824                 newline.dwDTERate = acm->line.dwDTERate;
 825                 newctrl &= ~ACM_CTRL_DTR;
 826         } else  newctrl |=  ACM_CTRL_DTR;
 827
 828         if (newctrl != acm->ctrlout)
 829                 acm_set_control(acm, acm->ctrlout = newctrl);
 830
 831         if (memcmp(&acm->line, &newline, sizeof newline)) {
 832                 memcpy(&acm->line, &newline, sizeof newline);
 833                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 834                         newline.bCharFormat, newline.bParityType,
 835                         newline.bDataBits);
 836                 acm_set_line(acm, &acm->line);
 837         }
 838 }
 839
 840 /*
 841  * USB probe and disconnect routines.
 842  */
 843
 844 /* Little helpers: write/read buffers free */
 845 static void acm_write_buffers_free(struct acm *acm)
 846 {
 847         int i;
 848         struct acm_wb *wb;
 849
 850         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 851                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 852         }
 853 }
 854
 855 static void acm_read_buffers_free(struct acm *acm)
 856 {
 857         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 858         int i, n = acm->rx_buflimit;
 859
 860         for (i = 0; i < n; i++)
 861                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
 862 }
 863
 864 /* Little helper: write buffers allocate */
 865 static int acm_write_buffers_alloc(struct acm *acm)
 866 {
 867         int i;
 868         struct acm_wb *wb;
 869
 870         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 871                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 872                     &wb->dmah);
 873                 if (!wb->buf) {
 874                         while (i != 0) {
 875                                 --i;
 876                                 --wb;
 877                                 usb_buffer_free(acm->dev, acm->writesize,
 878                                     wb->buf, wb->dmah);
 879                         }
 880                         return -ENOMEM;
 881                 }
 882         }
 883         return 0;
 884 }
 885
 886 static int acm_probe (struct usb_interface *intf,
 887                       const struct usb_device_id *id)
 888 {
 889         struct usb_cdc_union_desc *union_header = NULL;
 890         struct usb_cdc_country_functional_desc *cfd = NULL;
 891         unsigned char *buffer = intf->altsetting->extra;
 892         int buflen = intf->altsetting->extralen;
 893         struct usb_interface *control_interface;
 894         struct usb_interface *data_interface;
 895         struct usb_endpoint_descriptor *epctrl;
 896         struct usb_endpoint_descriptor *epread;
 897         struct usb_endpoint_descriptor *epwrite;
 898         struct usb_device *usb_dev = interface_to_usbdev(intf);
 899         struct acm *acm;
 900         int minor;
 901         int ctrlsize,readsize;
 902         u8 *buf;
 903         u8 ac_management_function = 0;
 904         u8 call_management_function = 0;
 905         int call_interface_num = -1;
 906         int data_interface_num;
 907         unsigned long quirks;
 908         int num_rx_buf;
 909         int i;
 910
 911         /* normal quirks */
 912         quirks = (unsigned long)id->driver_info;
 913         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 914
 915         /* handle quirks deadly to normal probing*/
 916         if (quirks == NO_UNION_NORMAL) {
 917                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 918                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 919                 goto skip_normal_probe;
 920         }
 921
 922         /* normal probing*/
 923         if (!buffer) {
 924                 err("Weird descriptor references\n");
 925                 return -EINVAL;
 926         }
 927
 928         if (!buflen) {
 929                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 930                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
 931                         buflen = intf->cur_altsetting->endpoint->extralen;
 932                         buffer = intf->cur_altsetting->endpoint->extra;
 933                 } else {
 934                         err("Zero length descriptor references\n");
 935                         return -EINVAL;
 936                 }
 937         }
 938
 939         while (buflen > 0) {
 940                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 941                         err("skipping garbage\n");
 942                         goto next_desc;
 943                 }
 944
 945                 switch (buffer [2]) {
 946                         case USB_CDC_UNION_TYPE: /* we've found it */
 947                                 if (union_header) {
 948                                         err("More than one union descriptor, skipping ...");
 949                                         goto next_desc;
 950                                 }
 951                                 union_header = (struct usb_cdc_union_desc *)
 952                                                         buffer;
 953                                 break;
 954                         case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 955                                 cfd = (struct usb_cdc_country_functional_desc *)buffer;
 956                                 break;
 957                         case USB_CDC_HEADER_TYPE: /* maybe check version */
 958                                 break; /* for now we ignore it */
 959                         case USB_CDC_ACM_TYPE:
 960                                 ac_management_function = buffer[3];
 961                                 break;
 962                         case USB_CDC_CALL_MANAGEMENT_TYPE:
 963                                 call_management_function = buffer[3];
 964                                 call_interface_num = buffer[4];
 965                                 if ((call_management_function & 3) != 3)
 966                                         err("This device cannot do calls on its own. It is no modem.");
 967                                 break;
 968                         default:
 969                                 /* there are LOTS more CDC descriptors that
 970                                  * could legitimately be found here.
 971                                  */
 972                                 dev_dbg(&intf->dev, "Ignoring descriptor: "
 973                                                 "type %02x, length %d\n",
 974                                                 buffer[2], buffer[0]);
 975                                 break;
 976                         }
 977 next_desc:
 978                 buflen -= buffer[0];
 979                 buffer += buffer[0];
 980         }
 981
 982         if (!union_header) {
 983                 if (call_interface_num > 0) {
 984                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
 985                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 986                         control_interface = intf;
 987                 } else {
 988                         dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 989                         return -ENODEV;
 990                 }
 991         } else {
 992                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 993                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 994                 if (!control_interface || !data_interface) {
 995                         dev_dbg(&intf->dev,"no interfaces\n");
 996                         return -ENODEV;
 997                 }
 998         }
 999
1000         if (data_interface_num != call_interface_num)
1001                 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
1002
1003 skip_normal_probe:
1004
1005         /*workaround for switched interfaces */
1006         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
1007                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
1008                         struct usb_interface *t;
1009                         dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
1010
1011                         t = control_interface;
1012                         control_interface = data_interface;
1013                         data_interface = t;
1014                 } else {
1015                         return -EINVAL;
1016                 }
1017         }
1018
1019         /* Accept probe requests only for the control interface */
1020         if (intf != control_interface)
1021                 return -ENODEV;
1022
1023         if (usb_interface_claimed(data_interface)) { /* valid in this context */
1024                 dev_dbg(&intf->dev,"The data interface isn't available\n");
1025                 return -EBUSY;
1026         }
1027
1028
1029         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1030                 return -EINVAL;
1031
1032         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1033         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1034         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1035
1036
1037         /* workaround for switched endpoints */
1038         if (!usb_endpoint_dir_in(epread)) {
1039                 /* descriptors are swapped */
1040                 struct usb_endpoint_descriptor *t;
1041                 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
1042
1043                 t = epread;
1044                 epread = epwrite;
1045                 epwrite = t;
1046         }
1047         dbg("interfaces are valid");
1048         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1049
1050         if (minor == ACM_TTY_MINORS) {
1051                 err("no more free acm devices");
1052                 return -ENODEV;
1053         }
1054
1055         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
1056                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1057                 goto alloc_fail;
1058         }
1059
1060         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1061         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
1062         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1063         acm->control = control_interface;
1064         acm->data = data_interface;
1065         acm->minor = minor;
1066         acm->dev = usb_dev;
1067         acm->ctrl_caps = ac_management_function;
1068         acm->ctrlsize = ctrlsize;
1069         acm->readsize = readsize;
1070         acm->rx_buflimit = num_rx_buf;
1071         acm->urb_task.func = acm_rx_tasklet;
1072         acm->urb_task.data = (unsigned long) acm;
1073         INIT_WORK(&acm->work, acm_softint);
1074         INIT_WORK(&acm->waker, acm_waker);
1075         spin_lock_init(&acm->throttle_lock);
1076         spin_lock_init(&acm->write_lock);
1077         spin_lock_init(&acm->read_lock);
1078         mutex_init(&acm->mutex);
1079         acm->write_ready = 1;
1080         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1081
1082         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1083         if (!buf) {
1084                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1085                 goto alloc_fail2;
1086         }
1087         acm->ctrl_buffer = buf;
1088
1089         if (acm_write_buffers_alloc(acm) < 0) {
1090                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1091                 goto alloc_fail4;
1092         }
1093
1094         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1095         if (!acm->ctrlurb) {
1096                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1097                 goto alloc_fail5;
1098         }
1099         for (i = 0; i < num_rx_buf; i++) {
1100                 struct acm_ru *rcv = &(acm->ru[i]);
1101
1102                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1103                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1104                         goto alloc_fail7;
1105                 }
1106
1107                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1108                 rcv->instance = acm;
1109         }
1110         for (i = 0; i < num_rx_buf; i++) {
1111                 struct acm_rb *rb = &(acm->rb[i]);
1112
1113                 rb->base = usb_buffer_alloc(acm->dev, readsize,
1114                                 GFP_KERNEL, &rb->dma);
1115                 if (!rb->base) {
1116                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1117                         goto alloc_fail7;
1118                 }
1119         }
1120         for(i = 0; i < ACM_NW; i++)
1121         {
1122                 struct acm_wb *snd = &(acm->wb[i]);
1123
1124                 if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1125                         dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
1126                         goto alloc_fail7;
1127                 }
1128
1129                 usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1130                                 NULL, acm->writesize, acm_write_bulk, snd);
1131                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1132                 snd->instance = acm;
1133         }
1134
1135         usb_set_intfdata (intf, acm);
1136
1137         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1138         if (i < 0)
1139                 goto alloc_fail8;
1140
1141         if (cfd) { /* export the country data */
1142                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1143                 if (!acm->country_codes)
1144                         goto skip_countries;
1145                 acm->country_code_size = cfd->bLength - 4;
1146                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1147                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1148
1149                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1150                 if (i < 0) {
1151                         kfree(acm->country_codes);
1152                         goto skip_countries;
1153                 }
1154
1155                 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1156                 if (i < 0) {
1157                         kfree(acm->country_codes);
1158                         goto skip_countries;
1159                 }
1160         }
1161
1162 skip_countries:
1163         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1164                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1165         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1166         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1167
1168         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1169
1170         acm_set_control(acm, acm->ctrlout);
1171
1172         acm->line.dwDTERate = cpu_to_le32(9600);
1173         acm->line.bDataBits = 8;
1174         acm_set_line(acm, &acm->line);
1175
1176         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1177         usb_set_intfdata(data_interface, acm);
1178
1179         usb_get_intf(control_interface);
1180         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1181
1182         acm_table[minor] = acm;
1183
1184         return 0;
1185 alloc_fail8:
1186         for (i = 0; i < ACM_NW; i++)
1187                 usb_free_urb(acm->wb[i].urb);
1188 alloc_fail7:
1189         acm_read_buffers_free(acm);
1190         for (i = 0; i < num_rx_buf; i++)
1191                 usb_free_urb(acm->ru[i].urb);
1192         usb_free_urb(acm->ctrlurb);
1193 alloc_fail5:
1194         acm_write_buffers_free(acm);
1195 alloc_fail4:
1196         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1197 alloc_fail2:
1198         kfree(acm);
1199 alloc_fail:
1200         return -ENOMEM;
1201 }
1202
1203 static void stop_data_traffic(struct acm *acm)
1204 {
1205         int i;
1206         dbg("Entering stop_data_traffic");
1207
1208         tasklet_disable(&acm->urb_task);
1209
1210         usb_kill_urb(acm->ctrlurb);
1211         for(i = 0; i < ACM_NW; i++)
1212                 usb_kill_urb(acm->wb[i].urb);
1213         for (i = 0; i < acm->rx_buflimit; i++)
1214                 usb_kill_urb(acm->ru[i].urb);
1215
1216         tasklet_enable(&acm->urb_task);
1217
1218         cancel_work_sync(&acm->work);
1219         cancel_work_sync(&acm->waker);
1220 }
1221
1222 static void acm_disconnect(struct usb_interface *intf)
1223 {
1224         struct acm *acm = usb_get_intfdata(intf);
1225         struct usb_device *usb_dev = interface_to_usbdev(intf);
1226
1227         /* sibling interface is already cleaning up */
1228         if (!acm)
1229                 return;
1230
1231         mutex_lock(&open_mutex);
1232         if (acm->country_codes){
1233                 device_remove_file(&acm->control->dev,
1234                                 &dev_attr_wCountryCodes);
1235                 device_remove_file(&acm->control->dev,
1236                                 &dev_attr_iCountryCodeRelDate);
1237         }
1238         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1239         acm->dev = NULL;
1240         usb_set_intfdata(acm->control, NULL);
1241         usb_set_intfdata(acm->data, NULL);
1242
1243         stop_data_traffic(acm);
1244
1245         acm_write_buffers_free(acm);
1246         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1247         acm_read_buffers_free(acm);
1248
1249         usb_driver_release_interface(&acm_driver, intf == acm->control ?
1250                                         acm->data : acm->control);
1251
1252         if (!acm->used) {
1253                 acm_tty_unregister(acm);
1254                 mutex_unlock(&open_mutex);
1255                 return;
1256         }
1257
1258         mutex_unlock(&open_mutex);
1259
1260         if (acm->tty)
1261                 tty_hangup(acm->tty);
1262 }
1263
1264 #ifdef CONFIG_PM
1265 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1266 {
1267         struct acm *acm = usb_get_intfdata(intf);
1268         int cnt;
1269
1270         if (acm->dev->auto_pm) {
1271                 int b;
1272
1273                 spin_lock_irq(&acm->read_lock);
1274                 spin_lock(&acm->write_lock);
1275                 b = acm->processing + acm->transmitting;
1276                 spin_unlock(&acm->write_lock);
1277                 spin_unlock_irq(&acm->read_lock);
1278                 if (b)
1279                         return -EBUSY;
1280         }
1281
1282         spin_lock_irq(&acm->read_lock);
1283         spin_lock(&acm->write_lock);
1284         cnt = acm->susp_count++;
1285         spin_unlock(&acm->write_lock);
1286         spin_unlock_irq(&acm->read_lock);
1287
1288         if (cnt)
1289                 return 0;
1290         /*
1291         we treat opened interfaces differently,
1292         we must guard against open
1293         */
1294         mutex_lock(&acm->mutex);
1295
1296         if (acm->used)
1297                 stop_data_traffic(acm);
1298
1299         mutex_unlock(&acm->mutex);
1300         return 0;
1301 }
1302
1303 static int acm_resume(struct usb_interface *intf)
1304 {
1305         struct acm *acm = usb_get_intfdata(intf);
1306         int rv = 0;
1307         int cnt;
1308
1309         spin_lock_irq(&acm->read_lock);
1310         acm->susp_count -= 1;
1311         cnt = acm->susp_count;
1312         spin_unlock_irq(&acm->read_lock);
1313
1314         if (cnt)
1315                 return 0;
1316
1317         mutex_lock(&acm->mutex);
1318         if (acm->used) {
1319                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1320                 if (rv < 0)
1321                         goto err_out;
1322
1323                 tasklet_schedule(&acm->urb_task);
1324         }
1325
1326 err_out:
1327         mutex_unlock(&acm->mutex);
1328         return rv;
1329 }
1330
1331 #endif /* CONFIG_PM */
1332 /*
1333  * USB driver structure.
1334  */
1335
1336 static struct usb_device_id acm_ids[] = {
1337         /* quirky and broken devices */
1338         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1339         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1340         },
1341         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1342         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1343         },
1344         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1345         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1346         },
1347         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1348         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1349         },
1350         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1351         .driver_info = SINGLE_RX_URB, /* firmware bug */
1352         },
1353         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1354         .driver_info = SINGLE_RX_URB, /* firmware bug */
1355         },
1356         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1357         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1358         },
1359         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1360         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1361         },
1362
1363         /* control interfaces with various AT-command sets */
1364         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1365                 USB_CDC_ACM_PROTO_AT_V25TER) },
1366         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1367                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1368         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1369                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1370         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1371                 USB_CDC_ACM_PROTO_AT_GSM) },
1372         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1373                 USB_CDC_ACM_PROTO_AT_3G ) },
1374         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1375                 USB_CDC_ACM_PROTO_AT_CDMA) },
1376
1377         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1378         { }
1379 };
1380
1381 MODULE_DEVICE_TABLE (usb, acm_ids);
1382
1383 static struct usb_driver acm_driver = {
1384         .name =         "cdc_acm",
1385         .probe =        acm_probe,
1386         .disconnect =   acm_disconnect,
1387 #ifdef CONFIG_PM
1388         .suspend =      acm_suspend,
1389         .resume =       acm_resume,
1390 #endif
1391         .id_table =     acm_ids,
1392 #ifdef CONFIG_PM
1393         .supports_autosuspend = 1,
1394 #endif
1395 };
1396
1397 /*
1398  * TTY driver structures.
1399  */
1400
1401 static const struct tty_operations acm_ops = {
1402         .open =                 acm_tty_open,
1403         .close =                acm_tty_close,
1404         .write =                acm_tty_write,
1405         .write_room =           acm_tty_write_room,
1406         .ioctl =                acm_tty_ioctl,
1407         .throttle =             acm_tty_throttle,
1408         .unthrottle =           acm_tty_unthrottle,
1409         .chars_in_buffer =      acm_tty_chars_in_buffer,
1410         .break_ctl =            acm_tty_break_ctl,
1411         .set_termios =          acm_tty_set_termios,
1412         .tiocmget =             acm_tty_tiocmget,
1413         .tiocmset =             acm_tty_tiocmset,
1414 };
1415
1416 /*
1417  * Init / exit.
1418  */
1419
1420 static int __init acm_init(void)
1421 {
1422         int retval;
1423         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1424         if (!acm_tty_driver)
1425                 return -ENOMEM;
1426         acm_tty_driver->owner = THIS_MODULE,
1427         acm_tty_driver->driver_name = "acm",
1428         acm_tty_driver->name = "ttyACM",
1429         acm_tty_driver->major = ACM_TTY_MAJOR,
1430         acm_tty_driver->minor_start = 0,
1431         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1432         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1433         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1434         acm_tty_driver->init_termios = tty_std_termios;
1435         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1436         tty_set_operations(acm_tty_driver, &acm_ops);
1437
1438         retval = tty_register_driver(acm_tty_driver);
1439         if (retval) {
1440                 put_tty_driver(acm_tty_driver);
1441                 return retval;
1442         }
1443
1444         retval = usb_register(&acm_driver);
1445         if (retval) {
1446                 tty_unregister_driver(acm_tty_driver);
1447                 put_tty_driver(acm_tty_driver);
1448                 return retval;
1449         }
1450
1451         info(DRIVER_VERSION ":" DRIVER_DESC);
1452
1453         return 0;
1454 }
1455
1456 static void __exit acm_exit(void)
1457 {
1458         usb_deregister(&acm_driver);
1459         tty_unregister_driver(acm_tty_driver);
1460         put_tty_driver(acm_tty_driver);
1461 }
1462
1463 module_init(acm_init);
1464 module_exit(acm_exit);
1465
1466 MODULE_AUTHOR( DRIVER_AUTHOR );
1467 MODULE_DESCRIPTION( DRIVER_DESC );
1468 MODULE_LICENSE("GPL");
1469