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@ucw.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  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  28  */
  29
  30 #undef DEBUG
  31 #undef VERBOSE_DEBUG
  32
  33 #include <linux/kernel.h>
  34 #include <linux/errno.h>
  35 #include <linux/init.h>
  36 #include <linux/slab.h>
  37 #include <linux/tty.h>
  38 #include <linux/serial.h>
  39 #include <linux/tty_driver.h>
  40 #include <linux/tty_flip.h>
  41 #include <linux/module.h>
  42 #include <linux/mutex.h>
  43 #include <linux/uaccess.h>
  44 #include <linux/usb.h>
  45 #include <linux/usb/cdc.h>
  46 #include <asm/byteorder.h>
  47 #include <asm/unaligned.h>
  48 #include <linux/list.h>
  49
  50 #include "cdc-acm.h"
  51
  52
  53 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  54 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  55
  56 static struct usb_driver acm_driver;
  57 static struct tty_driver *acm_tty_driver;
  58 static struct acm *acm_table[ACM_TTY_MINORS];
  59
  60 static DEFINE_MUTEX(open_mutex);
  61
  62 #define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
  63
  64 static const struct tty_port_operations acm_port_ops = {
  65 };
  66
  67 /*
  68  * Functions for ACM control messages.
  69  */
  70
  71 static int acm_ctrl_msg(struct acm *acm, int request, int value,
  72                                                         void *buf, int len)
  73 {
  74         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  75                 request, USB_RT_ACM, value,
  76                 acm->control->altsetting[0].desc.bInterfaceNumber,
  77                 buf, len, 5000);
  78         dev_dbg(&acm->control->dev,
  79                         "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
  80                         __func__, request, value, len, retval);
  81         return retval < 0 ? retval : 0;
  82 }
  83
  84 /* devices aren't required to support these requests.
  85  * the cdc acm descriptor tells whether they do...
  86  */
  87 #define acm_set_control(acm, control) \
  88         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
  89 #define acm_set_line(acm, line) \
  90         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
  91 #define acm_send_break(acm, ms) \
  92         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
  93
  94 /*
  95  * Write buffer management.
  96  * All of these assume proper locks taken by the caller.
  97  */
  98
  99 static int acm_wb_alloc(struct acm *acm)
 100 {
 101         int i, wbn;
 102         struct acm_wb *wb;
 103
 104         wbn = 0;
 105         i = 0;
 106         for (;;) {
 107                 wb = &acm->wb[wbn];
 108                 if (!wb->use) {
 109                         wb->use = 1;
 110                         return wbn;
 111                 }
 112                 wbn = (wbn + 1) % ACM_NW;
 113                 if (++i >= ACM_NW)
 114                         return -1;
 115         }
 116 }
 117
 118 static int acm_wb_is_avail(struct acm *acm)
 119 {
 120         int i, n;
 121         unsigned long flags;
 122
 123         n = ACM_NW;
 124         spin_lock_irqsave(&acm->write_lock, flags);
 125         for (i = 0; i < ACM_NW; i++)
 126                 n -= acm->wb[i].use;
 127         spin_unlock_irqrestore(&acm->write_lock, flags);
 128         return n;
 129 }
 130
 131 /*
 132  * Finish write. Caller must hold acm->write_lock
 133  */
 134 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 135 {
 136         wb->use = 0;
 137         acm->transmitting--;
 138         usb_autopm_put_interface_async(acm->control);
 139 }
 140
 141 /*
 142  * Poke write.
 143  *
 144  * the caller is responsible for locking
 145  */
 146
 147 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 148 {
 149         int rc;
 150
 151         acm->transmitting++;
 152
 153         wb->urb->transfer_buffer = wb->buf;
 154         wb->urb->transfer_dma = wb->dmah;
 155         wb->urb->transfer_buffer_length = wb->len;
 156         wb->urb->dev = acm->dev;
 157
 158         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 159         if (rc < 0) {
 160                 dev_err(&acm->data->dev,
 161                         "%s - usb_submit_urb(write bulk) failed: %d\n",
 162                         __func__, rc);
 163                 acm_write_done(acm, wb);
 164         }
 165         return rc;
 166 }
 167
 168 static int acm_write_start(struct acm *acm, int wbn)
 169 {
 170         unsigned long flags;
 171         struct acm_wb *wb = &acm->wb[wbn];
 172         int rc;
 173
 174         spin_lock_irqsave(&acm->write_lock, flags);
 175         if (!acm->dev) {
 176                 wb->use = 0;
 177                 spin_unlock_irqrestore(&acm->write_lock, flags);
 178                 return -ENODEV;
 179         }
 180
 181         dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
 182                                                         acm->susp_count);
 183         usb_autopm_get_interface_async(acm->control);
 184         if (acm->susp_count) {
 185                 if (!acm->delayed_wb)
 186                         acm->delayed_wb = wb;
 187                 else
 188                         usb_autopm_put_interface_async(acm->control);
 189                 spin_unlock_irqrestore(&acm->write_lock, flags);
 190                 return 0;       /* A white lie */
 191         }
 192         usb_mark_last_busy(acm->dev);
 193
 194         rc = acm_start_wb(acm, wb);
 195         spin_unlock_irqrestore(&acm->write_lock, flags);
 196
 197         return rc;
 198
 199 }
 200 /*
 201  * attributes exported through sysfs
 202  */
 203 static ssize_t show_caps
 204 (struct device *dev, struct device_attribute *attr, char *buf)
 205 {
 206         struct usb_interface *intf = to_usb_interface(dev);
 207         struct acm *acm = usb_get_intfdata(intf);
 208
 209         return sprintf(buf, "%d", acm->ctrl_caps);
 210 }
 211 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 212
 213 static ssize_t show_country_codes
 214 (struct device *dev, struct device_attribute *attr, char *buf)
 215 {
 216         struct usb_interface *intf = to_usb_interface(dev);
 217         struct acm *acm = usb_get_intfdata(intf);
 218
 219         memcpy(buf, acm->country_codes, acm->country_code_size);
 220         return acm->country_code_size;
 221 }
 222
 223 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 224
 225 static ssize_t show_country_rel_date
 226 (struct device *dev, struct device_attribute *attr, char *buf)
 227 {
 228         struct usb_interface *intf = to_usb_interface(dev);
 229         struct acm *acm = usb_get_intfdata(intf);
 230
 231         return sprintf(buf, "%d", acm->country_rel_date);
 232 }
 233
 234 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 235 /*
 236  * Interrupt handlers for various ACM device responses
 237  */
 238
 239 /* control interface reports status changes with "interrupt" transfers */
 240 static void acm_ctrl_irq(struct urb *urb)
 241 {
 242         struct acm *acm = urb->context;
 243         struct usb_cdc_notification *dr = urb->transfer_buffer;
 244         struct tty_struct *tty;
 245         unsigned char *data;
 246         int newctrl;
 247         int retval;
 248         int status = urb->status;
 249
 250         switch (status) {
 251         case 0:
 252                 /* success */
 253                 break;
 254         case -ECONNRESET:
 255         case -ENOENT:
 256         case -ESHUTDOWN:
 257                 /* this urb is terminated, clean up */
 258                 dev_dbg(&acm->control->dev,
 259                                 "%s - urb shutting down with status: %d\n",
 260                                 __func__, status);
 261                 return;
 262         default:
 263                 dev_dbg(&acm->control->dev,
 264                                 "%s - nonzero urb status received: %d\n",
 265                                 __func__, status);
 266                 goto exit;
 267         }
 268
 269         if (!ACM_READY(acm))
 270                 goto exit;
 271
 272         usb_mark_last_busy(acm->dev);
 273
 274         data = (unsigned char *)(dr + 1);
 275         switch (dr->bNotificationType) {
 276         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 277                 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
 278                                                         __func__, dr->wValue);
 279                 break;
 280
 281         case USB_CDC_NOTIFY_SERIAL_STATE:
 282                 tty = tty_port_tty_get(&acm->port);
 283                 newctrl = get_unaligned_le16(data);
 284
 285                 if (tty) {
 286                         if (!acm->clocal &&
 287                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 288                                 dev_dbg(&acm->control->dev,
 289                                         "%s - calling hangup\n", __func__);
 290                                 tty_hangup(tty);
 291                         }
 292                         tty_kref_put(tty);
 293                 }
 294
 295                 acm->ctrlin = newctrl;
 296
 297                 dev_dbg(&acm->control->dev,
 298                         "%s - input control lines: dcd%c dsr%c break%c "
 299                         "ring%c framing%c parity%c overrun%c\n",
 300                         __func__,
 301                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
 302                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 303                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
 304                         acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 305                         acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
 306                         acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 307                         acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 308                         break;
 309
 310         default:
 311                 dev_dbg(&acm->control->dev,
 312                         "%s - unknown notification %d received: index %d "
 313                         "len %d data0 %d data1 %d\n",
 314                         __func__,
 315                         dr->bNotificationType, dr->wIndex,
 316                         dr->wLength, data[0], data[1]);
 317                 break;
 318         }
 319 exit:
 320         retval = usb_submit_urb(urb, GFP_ATOMIC);
 321         if (retval)
 322                 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
 323                                                         __func__, retval);
 324 }
 325
 326 /* data interface returns incoming bytes, or we got unthrottled */
 327 static void acm_read_bulk(struct urb *urb)
 328 {
 329         struct acm_rb *buf;
 330         struct acm_ru *rcv = urb->context;
 331         struct acm *acm = rcv->instance;
 332         int status = urb->status;
 333
 334         dev_vdbg(&acm->data->dev, "%s - status %d\n", __func__, status);
 335
 336         if (!ACM_READY(acm)) {
 337                 dev_dbg(&acm->data->dev, "%s - acm not ready\n", __func__);
 338                 return;
 339         }
 340         usb_mark_last_busy(acm->dev);
 341
 342         if (status)
 343                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
 344                                                         __func__, status);
 345
 346         buf = rcv->buffer;
 347         buf->size = urb->actual_length;
 348
 349         if (likely(status == 0)) {
 350                 spin_lock(&acm->read_lock);
 351                 acm->processing++;
 352                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 353                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 354                 spin_unlock(&acm->read_lock);
 355         } else {
 356                 /* we drop the buffer due to an error */
 357                 spin_lock(&acm->read_lock);
 358                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 359                 list_add(&buf->list, &acm->spare_read_bufs);
 360                 spin_unlock(&acm->read_lock);
 361                 /* nevertheless the tasklet must be kicked unconditionally
 362                 so the queue cannot dry up */
 363         }
 364         if (likely(!acm->susp_count))
 365                 tasklet_schedule(&acm->urb_task);
 366 }
 367
 368 static void acm_rx_tasklet(unsigned long _acm)
 369 {
 370         struct acm *acm = (void *)_acm;
 371         struct acm_rb *buf;
 372         struct tty_struct *tty;
 373         struct acm_ru *rcv;
 374         unsigned long flags;
 375         unsigned char throttled;
 376
 377         dev_vdbg(&acm->data->dev, "%s\n", __func__);
 378
 379         if (!ACM_READY(acm)) {
 380                 dev_dbg(&acm->data->dev, "%s - acm not ready\n", __func__);
 381                 return;
 382         }
 383
 384         spin_lock_irqsave(&acm->throttle_lock, flags);
 385         throttled = acm->throttle;
 386         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 387         if (throttled) {
 388                 dev_dbg(&acm->data->dev, "%s - throttled\n", __func__);
 389                 return;
 390         }
 391
 392         tty = tty_port_tty_get(&acm->port);
 393
 394 next_buffer:
 395         spin_lock_irqsave(&acm->read_lock, flags);
 396         if (list_empty(&acm->filled_read_bufs)) {
 397                 spin_unlock_irqrestore(&acm->read_lock, flags);
 398                 goto urbs;
 399         }
 400         buf = list_entry(acm->filled_read_bufs.next,
 401                          struct acm_rb, list);
 402         list_del(&buf->list);
 403         spin_unlock_irqrestore(&acm->read_lock, flags);
 404
 405         dev_vdbg(&acm->data->dev, "%s - processing buf 0x%p, size = %d\n",
 406                                                 __func__, buf, buf->size);
 407         if (tty) {
 408                 spin_lock_irqsave(&acm->throttle_lock, flags);
 409                 throttled = acm->throttle;
 410                 spin_unlock_irqrestore(&acm->throttle_lock, flags);
 411                 if (!throttled) {
 412                         tty_insert_flip_string(tty, buf->base, buf->size);
 413                         tty_flip_buffer_push(tty);
 414                 } else {
 415                         tty_kref_put(tty);
 416                         dev_dbg(&acm->data->dev, "%s - throttling noticed\n",
 417                                                                 __func__);
 418                         spin_lock_irqsave(&acm->read_lock, flags);
 419                         list_add(&buf->list, &acm->filled_read_bufs);
 420                         spin_unlock_irqrestore(&acm->read_lock, flags);
 421                         return;
 422                 }
 423         }
 424
 425         spin_lock_irqsave(&acm->read_lock, flags);
 426         list_add(&buf->list, &acm->spare_read_bufs);
 427         spin_unlock_irqrestore(&acm->read_lock, flags);
 428         goto next_buffer;
 429
 430 urbs:
 431         tty_kref_put(tty);
 432
 433         while (!list_empty(&acm->spare_read_bufs)) {
 434                 spin_lock_irqsave(&acm->read_lock, flags);
 435                 if (list_empty(&acm->spare_read_urbs)) {
 436                         acm->processing = 0;
 437                         spin_unlock_irqrestore(&acm->read_lock, flags);
 438                         return;
 439                 }
 440                 rcv = list_entry(acm->spare_read_urbs.next,
 441                                  struct acm_ru, list);
 442                 list_del(&rcv->list);
 443                 spin_unlock_irqrestore(&acm->read_lock, flags);
 444
 445                 buf = list_entry(acm->spare_read_bufs.next,
 446                                  struct acm_rb, list);
 447                 list_del(&buf->list);
 448
 449                 rcv->buffer = buf;
 450
 451                 if (acm->is_int_ep)
 452                         usb_fill_int_urb(rcv->urb, acm->dev,
 453                                          acm->rx_endpoint,
 454                                          buf->base,
 455                                          acm->readsize,
 456                                          acm_read_bulk, rcv, acm->bInterval);
 457                 else
 458                         usb_fill_bulk_urb(rcv->urb, acm->dev,
 459                                           acm->rx_endpoint,
 460                                           buf->base,
 461                                           acm->readsize,
 462                                           acm_read_bulk, rcv);
 463                 rcv->urb->transfer_dma = buf->dma;
 464                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 465
 466                 /* This shouldn't kill the driver as unsuccessful URBs are
 467                    returned to the free-urbs-pool and resubmited ASAP */
 468                 spin_lock_irqsave(&acm->read_lock, flags);
 469                 if (acm->susp_count ||
 470                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 471                         list_add(&buf->list, &acm->spare_read_bufs);
 472                         list_add(&rcv->list, &acm->spare_read_urbs);
 473                         acm->processing = 0;
 474                         spin_unlock_irqrestore(&acm->read_lock, flags);
 475                         return;
 476                 } else {
 477                         spin_unlock_irqrestore(&acm->read_lock, flags);
 478                         dev_vdbg(&acm->data->dev,
 479                                 "%s - sending urb 0x%p, rcv 0x%p, buf 0x%p\n",
 480                                 __func__, 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_wb *wb = urb->context;
 492         struct acm *acm = wb->instance;
 493         unsigned long flags;
 494
 495         if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
 496                 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
 497                         __func__,
 498                         urb->actual_length,
 499                         urb->transfer_buffer_length,
 500                         urb->status);
 501
 502         spin_lock_irqsave(&acm->write_lock, flags);
 503         acm_write_done(acm, wb);
 504         spin_unlock_irqrestore(&acm->write_lock, flags);
 505         if (ACM_READY(acm))
 506                 schedule_work(&acm->work);
 507 }
 508
 509 static void acm_softint(struct work_struct *work)
 510 {
 511         struct acm *acm = container_of(work, struct acm, work);
 512         struct tty_struct *tty;
 513
 514         dev_vdbg(&acm->data->dev, "%s\n", __func__);
 515
 516         if (!ACM_READY(acm))
 517                 return;
 518         tty = tty_port_tty_get(&acm->port);
 519         if (!tty)
 520                 return;
 521         tty_wakeup(tty);
 522         tty_kref_put(tty);
 523 }
 524
 525 /*
 526  * TTY handlers
 527  */
 528
 529 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 530 {
 531         struct acm *acm;
 532         int rv = -ENODEV;
 533         int i;
 534
 535         mutex_lock(&open_mutex);
 536
 537         acm = acm_table[tty->index];
 538         if (!acm || !acm->dev)
 539                 goto out;
 540         else
 541                 rv = 0;
 542
 543         dev_dbg(&acm->control->dev, "%s\n", __func__);
 544
 545         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 546
 547         tty->driver_data = acm;
 548         tty_port_tty_set(&acm->port, tty);
 549
 550         if (usb_autopm_get_interface(acm->control) < 0)
 551                 goto early_bail;
 552         else
 553                 acm->control->needs_remote_wakeup = 1;
 554
 555         mutex_lock(&acm->mutex);
 556         if (acm->port.count++) {
 557                 mutex_unlock(&acm->mutex);
 558                 usb_autopm_put_interface(acm->control);
 559                 goto out;
 560         }
 561
 562         acm->ctrlurb->dev = acm->dev;
 563         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 564                 dev_err(&acm->control->dev,
 565                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 566                 goto bail_out;
 567         }
 568
 569         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 570             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 571                 goto bail_out;
 572
 573         usb_autopm_put_interface(acm->control);
 574
 575         INIT_LIST_HEAD(&acm->spare_read_urbs);
 576         INIT_LIST_HEAD(&acm->spare_read_bufs);
 577         INIT_LIST_HEAD(&acm->filled_read_bufs);
 578
 579         for (i = 0; i < acm->rx_buflimit; i++)
 580                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 581         for (i = 0; i < acm->rx_buflimit; i++)
 582                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 583
 584         acm->throttle = 0;
 585
 586         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
 587         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 588         tasklet_schedule(&acm->urb_task);
 589
 590         mutex_unlock(&acm->mutex);
 591 out:
 592         mutex_unlock(&open_mutex);
 593         return rv;
 594
 595 bail_out:
 596         acm->port.count--;
 597         mutex_unlock(&acm->mutex);
 598         usb_autopm_put_interface(acm->control);
 599 early_bail:
 600         mutex_unlock(&open_mutex);
 601         tty_port_tty_set(&acm->port, NULL);
 602         return -EIO;
 603 }
 604
 605 static void acm_tty_unregister(struct acm *acm)
 606 {
 607         int i;
 608
 609         tty_unregister_device(acm_tty_driver, acm->minor);
 610         usb_put_intf(acm->control);
 611         acm_table[acm->minor] = NULL;
 612         usb_free_urb(acm->ctrlurb);
 613         for (i = 0; i < ACM_NW; i++)
 614                 usb_free_urb(acm->wb[i].urb);
 615         for (i = 0; i < acm->rx_buflimit; i++)
 616                 usb_free_urb(acm->ru[i].urb);
 617         kfree(acm->country_codes);
 618         kfree(acm);
 619 }
 620
 621 static void acm_port_down(struct acm *acm)
 622 {
 623         int i;
 624
 625         mutex_lock(&open_mutex);
 626         if (acm->dev) {
 627                 usb_autopm_get_interface(acm->control);
 628                 acm_set_control(acm, acm->ctrlout = 0);
 629                 usb_kill_urb(acm->ctrlurb);
 630                 for (i = 0; i < ACM_NW; i++)
 631                         usb_kill_urb(acm->wb[i].urb);
 632                 tasklet_disable(&acm->urb_task);
 633                 for (i = 0; i < acm->rx_buflimit; i++)
 634                         usb_kill_urb(acm->ru[i].urb);
 635                 tasklet_enable(&acm->urb_task);
 636                 acm->control->needs_remote_wakeup = 0;
 637                 usb_autopm_put_interface(acm->control);
 638         }
 639         mutex_unlock(&open_mutex);
 640 }
 641
 642 static void acm_tty_hangup(struct tty_struct *tty)
 643 {
 644         struct acm *acm = tty->driver_data;
 645         tty_port_hangup(&acm->port);
 646         acm_port_down(acm);
 647 }
 648
 649 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 650 {
 651         struct acm *acm = tty->driver_data;
 652
 653         /* Perform the closing process and see if we need to do the hardware
 654            shutdown */
 655         if (!acm)
 656                 return;
 657         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
 658                 mutex_lock(&open_mutex);
 659                 if (!acm->dev) {
 660                         tty_port_tty_set(&acm->port, NULL);
 661                         acm_tty_unregister(acm);
 662                         tty->driver_data = NULL;
 663                 }
 664                 mutex_unlock(&open_mutex);
 665                 return;
 666         }
 667         acm_port_down(acm);
 668         tty_port_close_end(&acm->port, tty);
 669         tty_port_tty_set(&acm->port, NULL);
 670 }
 671
 672 static int acm_tty_write(struct tty_struct *tty,
 673                                         const unsigned char *buf, int count)
 674 {
 675         struct acm *acm = tty->driver_data;
 676         int stat;
 677         unsigned long flags;
 678         int wbn;
 679         struct acm_wb *wb;
 680
 681         if (!ACM_READY(acm))
 682                 return -EINVAL;
 683         if (!count)
 684                 return 0;
 685
 686         dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
 687
 688         spin_lock_irqsave(&acm->write_lock, flags);
 689         wbn = acm_wb_alloc(acm);
 690         if (wbn < 0) {
 691                 spin_unlock_irqrestore(&acm->write_lock, flags);
 692                 return 0;
 693         }
 694         wb = &acm->wb[wbn];
 695
 696         count = (count > acm->writesize) ? acm->writesize : count;
 697         dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
 698         memcpy(wb->buf, buf, count);
 699         wb->len = count;
 700         spin_unlock_irqrestore(&acm->write_lock, flags);
 701
 702         stat = acm_write_start(acm, wbn);
 703         if (stat < 0)
 704                 return stat;
 705         return count;
 706 }
 707
 708 static int acm_tty_write_room(struct tty_struct *tty)
 709 {
 710         struct acm *acm = tty->driver_data;
 711         if (!ACM_READY(acm))
 712                 return -EINVAL;
 713         /*
 714          * Do not let the line discipline to know that we have a reserve,
 715          * or it might get too enthusiastic.
 716          */
 717         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 718 }
 719
 720 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 721 {
 722         struct acm *acm = tty->driver_data;
 723         if (!ACM_READY(acm))
 724                 return 0;
 725         /*
 726          * This is inaccurate (overcounts), but it works.
 727          */
 728         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 729 }
 730
 731 static void acm_tty_throttle(struct tty_struct *tty)
 732 {
 733         struct acm *acm = tty->driver_data;
 734         if (!ACM_READY(acm))
 735                 return;
 736         spin_lock_bh(&acm->throttle_lock);
 737         acm->throttle = 1;
 738         spin_unlock_bh(&acm->throttle_lock);
 739 }
 740
 741 static void acm_tty_unthrottle(struct tty_struct *tty)
 742 {
 743         struct acm *acm = tty->driver_data;
 744         if (!ACM_READY(acm))
 745                 return;
 746         spin_lock_bh(&acm->throttle_lock);
 747         acm->throttle = 0;
 748         spin_unlock_bh(&acm->throttle_lock);
 749         tasklet_schedule(&acm->urb_task);
 750 }
 751
 752 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 753 {
 754         struct acm *acm = tty->driver_data;
 755         int retval;
 756         if (!ACM_READY(acm))
 757                 return -EINVAL;
 758         retval = acm_send_break(acm, state ? 0xffff : 0);
 759         if (retval < 0)
 760                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
 761                                                                 __func__);
 762         return retval;
 763 }
 764
 765 static int acm_tty_tiocmget(struct tty_struct *tty)
 766 {
 767         struct acm *acm = tty->driver_data;
 768
 769         if (!ACM_READY(acm))
 770                 return -EINVAL;
 771
 772         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 773                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 774                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 775                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 776                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 777                TIOCM_CTS;
 778 }
 779
 780 static int acm_tty_tiocmset(struct tty_struct *tty,
 781                             unsigned int set, unsigned int clear)
 782 {
 783         struct acm *acm = tty->driver_data;
 784         unsigned int newctrl;
 785
 786         if (!ACM_READY(acm))
 787                 return -EINVAL;
 788
 789         newctrl = acm->ctrlout;
 790         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 791                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 792         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 793                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 794
 795         newctrl = (newctrl & ~clear) | set;
 796
 797         if (acm->ctrlout == newctrl)
 798                 return 0;
 799         return acm_set_control(acm, acm->ctrlout = newctrl);
 800 }
 801
 802 static int acm_tty_ioctl(struct tty_struct *tty,
 803                                         unsigned int cmd, unsigned long arg)
 804 {
 805         struct acm *acm = tty->driver_data;
 806
 807         if (!ACM_READY(acm))
 808                 return -EINVAL;
 809
 810         return -ENOIOCTLCMD;
 811 }
 812
 813 static const __u32 acm_tty_speed[] = {
 814         0, 50, 75, 110, 134, 150, 200, 300, 600,
 815         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 816         57600, 115200, 230400, 460800, 500000, 576000,
 817         921600, 1000000, 1152000, 1500000, 2000000,
 818         2500000, 3000000, 3500000, 4000000
 819 };
 820
 821 static const __u8 acm_tty_size[] = {
 822         5, 6, 7, 8
 823 };
 824
 825 static void acm_tty_set_termios(struct tty_struct *tty,
 826                                                 struct ktermios *termios_old)
 827 {
 828         struct acm *acm = tty->driver_data;
 829         struct ktermios *termios = tty->termios;
 830         struct usb_cdc_line_coding newline;
 831         int newctrl = acm->ctrlout;
 832
 833         if (!ACM_READY(acm))
 834                 return;
 835
 836         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 837         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 838         newline.bParityType = termios->c_cflag & PARENB ?
 839                                 (termios->c_cflag & PARODD ? 1 : 2) +
 840                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 841         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 842         /* FIXME: Needs to clear unsupported bits in the termios */
 843         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 844
 845         if (!newline.dwDTERate) {
 846                 newline.dwDTERate = acm->line.dwDTERate;
 847                 newctrl &= ~ACM_CTRL_DTR;
 848         } else
 849                 newctrl |=  ACM_CTRL_DTR;
 850
 851         if (newctrl != acm->ctrlout)
 852                 acm_set_control(acm, acm->ctrlout = newctrl);
 853
 854         if (memcmp(&acm->line, &newline, sizeof newline)) {
 855                 memcpy(&acm->line, &newline, sizeof newline);
 856                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 857                         __func__,
 858                         le32_to_cpu(newline.dwDTERate),
 859                         newline.bCharFormat, newline.bParityType,
 860                         newline.bDataBits);
 861                 acm_set_line(acm, &acm->line);
 862         }
 863 }
 864
 865 /*
 866  * USB probe and disconnect routines.
 867  */
 868
 869 /* Little helpers: write/read buffers free */
 870 static void acm_write_buffers_free(struct acm *acm)
 871 {
 872         int i;
 873         struct acm_wb *wb;
 874         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 875
 876         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 877                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 878 }
 879
 880 static void acm_read_buffers_free(struct acm *acm)
 881 {
 882         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 883         int i;
 884
 885         for (i = 0; i < acm->rx_buflimit; i++)
 886                 usb_free_coherent(usb_dev, acm->readsize,
 887                                   acm->rb[i].base, acm->rb[i].dma);
 888 }
 889
 890 /* Little helper: write buffers allocate */
 891 static int acm_write_buffers_alloc(struct acm *acm)
 892 {
 893         int i;
 894         struct acm_wb *wb;
 895
 896         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 897                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 898                     &wb->dmah);
 899                 if (!wb->buf) {
 900                         while (i != 0) {
 901                                 --i;
 902                                 --wb;
 903                                 usb_free_coherent(acm->dev, acm->writesize,
 904                                     wb->buf, wb->dmah);
 905                         }
 906                         return -ENOMEM;
 907                 }
 908         }
 909         return 0;
 910 }
 911
 912 static int acm_probe(struct usb_interface *intf,
 913                      const struct usb_device_id *id)
 914 {
 915         struct usb_cdc_union_desc *union_header = NULL;
 916         struct usb_cdc_country_functional_desc *cfd = NULL;
 917         unsigned char *buffer = intf->altsetting->extra;
 918         int buflen = intf->altsetting->extralen;
 919         struct usb_interface *control_interface;
 920         struct usb_interface *data_interface;
 921         struct usb_endpoint_descriptor *epctrl = NULL;
 922         struct usb_endpoint_descriptor *epread = NULL;
 923         struct usb_endpoint_descriptor *epwrite = NULL;
 924         struct usb_device *usb_dev = interface_to_usbdev(intf);
 925         struct acm *acm;
 926         int minor;
 927         int ctrlsize, readsize;
 928         u8 *buf;
 929         u8 ac_management_function = 0;
 930         u8 call_management_function = 0;
 931         int call_interface_num = -1;
 932         int data_interface_num;
 933         unsigned long quirks;
 934         int num_rx_buf;
 935         int i;
 936         int combined_interfaces = 0;
 937
 938         /* normal quirks */
 939         quirks = (unsigned long)id->driver_info;
 940         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 941
 942         /* handle quirks deadly to normal probing*/
 943         if (quirks == NO_UNION_NORMAL) {
 944                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 945                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 946                 goto skip_normal_probe;
 947         }
 948
 949         /* normal probing*/
 950         if (!buffer) {
 951                 dev_err(&intf->dev, "Weird descriptor references\n");
 952                 return -EINVAL;
 953         }
 954
 955         if (!buflen) {
 956                 if (intf->cur_altsetting->endpoint &&
 957                                 intf->cur_altsetting->endpoint->extralen &&
 958                                 intf->cur_altsetting->endpoint->extra) {
 959                         dev_dbg(&intf->dev,
 960                                 "Seeking extra descriptors on endpoint\n");
 961                         buflen = intf->cur_altsetting->endpoint->extralen;
 962                         buffer = intf->cur_altsetting->endpoint->extra;
 963                 } else {
 964                         dev_err(&intf->dev,
 965                                 "Zero length descriptor references\n");
 966                         return -EINVAL;
 967                 }
 968         }
 969
 970         while (buflen > 0) {
 971                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 972                         dev_err(&intf->dev, "skipping garbage\n");
 973                         goto next_desc;
 974                 }
 975
 976                 switch (buffer[2]) {
 977                 case USB_CDC_UNION_TYPE: /* we've found it */
 978                         if (union_header) {
 979                                 dev_err(&intf->dev, "More than one "
 980                                         "union descriptor, skipping ...\n");
 981                                 goto next_desc;
 982                         }
 983                         union_header = (struct usb_cdc_union_desc *)buffer;
 984                         break;
 985                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 986                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
 987                         break;
 988                 case USB_CDC_HEADER_TYPE: /* maybe check version */
 989                         break; /* for now we ignore it */
 990                 case USB_CDC_ACM_TYPE:
 991                         ac_management_function = buffer[3];
 992                         break;
 993                 case USB_CDC_CALL_MANAGEMENT_TYPE:
 994                         call_management_function = buffer[3];
 995                         call_interface_num = buffer[4];
 996                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
 997                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
 998                         break;
 999                 default:
1000                         /* there are LOTS more CDC descriptors that
1001                          * could legitimately be found here.
1002                          */
1003                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1004                                         "type %02x, length %d\n",
1005                                         buffer[2], buffer[0]);
1006                         break;
1007                 }
1008 next_desc:
1009                 buflen -= buffer[0];
1010                 buffer += buffer[0];
1011         }
1012
1013         if (!union_header) {
1014                 if (call_interface_num > 0) {
1015                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1016                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1017                         control_interface = intf;
1018                 } else {
1019                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1020                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1021                                 return -ENODEV;
1022                         } else {
1023                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1024                                 combined_interfaces = 1;
1025                                 control_interface = data_interface = intf;
1026                                 goto look_for_collapsed_interface;
1027                         }
1028                 }
1029         } else {
1030                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1031                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1032                 if (!control_interface || !data_interface) {
1033                         dev_dbg(&intf->dev, "no interfaces\n");
1034                         return -ENODEV;
1035                 }
1036         }
1037
1038         if (data_interface_num != call_interface_num)
1039                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1040
1041         if (control_interface == data_interface) {
1042                 /* some broken devices designed for windows work this way */
1043                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1044                 combined_interfaces = 1;
1045                 /* a popular other OS doesn't use it */
1046                 quirks |= NO_CAP_LINE;
1047                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1048                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1049                         return -EINVAL;
1050                 }
1051 look_for_collapsed_interface:
1052                 for (i = 0; i < 3; i++) {
1053                         struct usb_endpoint_descriptor *ep;
1054                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1055
1056                         if (usb_endpoint_is_int_in(ep))
1057                                 epctrl = ep;
1058                         else if (usb_endpoint_is_bulk_out(ep))
1059                                 epwrite = ep;
1060                         else if (usb_endpoint_is_bulk_in(ep))
1061                                 epread = ep;
1062                         else
1063                                 return -EINVAL;
1064                 }
1065                 if (!epctrl || !epread || !epwrite)
1066                         return -ENODEV;
1067                 else
1068                         goto made_compressed_probe;
1069         }
1070
1071 skip_normal_probe:
1072
1073         /*workaround for switched interfaces */
1074         if (data_interface->cur_altsetting->desc.bInterfaceClass
1075                                                 != CDC_DATA_INTERFACE_TYPE) {
1076                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1077                                                 == CDC_DATA_INTERFACE_TYPE) {
1078                         struct usb_interface *t;
1079                         dev_dbg(&intf->dev,
1080                                 "Your device has switched interfaces.\n");
1081                         t = control_interface;
1082                         control_interface = data_interface;
1083                         data_interface = t;
1084                 } else {
1085                         return -EINVAL;
1086                 }
1087         }
1088
1089         /* Accept probe requests only for the control interface */
1090         if (!combined_interfaces && intf != control_interface)
1091                 return -ENODEV;
1092
1093         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1094                 /* valid in this context */
1095                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1096                 return -EBUSY;
1097         }
1098
1099
1100         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1101                 return -EINVAL;
1102
1103         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1104         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1105         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1106
1107
1108         /* workaround for switched endpoints */
1109         if (!usb_endpoint_dir_in(epread)) {
1110                 /* descriptors are swapped */
1111                 struct usb_endpoint_descriptor *t;
1112                 dev_dbg(&intf->dev,
1113                         "The data interface has switched endpoints\n");
1114                 t = epread;
1115                 epread = epwrite;
1116                 epwrite = t;
1117         }
1118 made_compressed_probe:
1119         dev_dbg(&intf->dev, "interfaces are valid\n");
1120         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1121
1122         if (minor == ACM_TTY_MINORS) {
1123                 dev_err(&intf->dev, "no more free acm devices\n");
1124                 return -ENODEV;
1125         }
1126
1127         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1128         if (acm == NULL) {
1129                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1130                 goto alloc_fail;
1131         }
1132
1133         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1134         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1135                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1136         acm->combined_interfaces = combined_interfaces;
1137         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1138         acm->control = control_interface;
1139         acm->data = data_interface;
1140         acm->minor = minor;
1141         acm->dev = usb_dev;
1142         acm->ctrl_caps = ac_management_function;
1143         if (quirks & NO_CAP_LINE)
1144                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1145         acm->ctrlsize = ctrlsize;
1146         acm->readsize = readsize;
1147         acm->rx_buflimit = num_rx_buf;
1148         acm->urb_task.func = acm_rx_tasklet;
1149         acm->urb_task.data = (unsigned long) acm;
1150         INIT_WORK(&acm->work, acm_softint);
1151         spin_lock_init(&acm->throttle_lock);
1152         spin_lock_init(&acm->write_lock);
1153         spin_lock_init(&acm->read_lock);
1154         mutex_init(&acm->mutex);
1155         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1156         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1157         if (acm->is_int_ep)
1158                 acm->bInterval = epread->bInterval;
1159         tty_port_init(&acm->port);
1160         acm->port.ops = &acm_port_ops;
1161
1162         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1163         if (!buf) {
1164                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1165                 goto alloc_fail2;
1166         }
1167         acm->ctrl_buffer = buf;
1168
1169         if (acm_write_buffers_alloc(acm) < 0) {
1170                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1171                 goto alloc_fail4;
1172         }
1173
1174         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1175         if (!acm->ctrlurb) {
1176                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1177                 goto alloc_fail5;
1178         }
1179         for (i = 0; i < num_rx_buf; i++) {
1180                 struct acm_ru *rcv = &(acm->ru[i]);
1181
1182                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1183                 if (rcv->urb == NULL) {
1184                         dev_err(&intf->dev,
1185                                 "out of memory (read urbs usb_alloc_urb)\n");
1186                         goto alloc_fail6;
1187                 }
1188
1189                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1190                 rcv->instance = acm;
1191         }
1192         for (i = 0; i < num_rx_buf; i++) {
1193                 struct acm_rb *rb = &(acm->rb[i]);
1194
1195                 rb->base = usb_alloc_coherent(acm->dev, readsize,
1196                                 GFP_KERNEL, &rb->dma);
1197                 if (!rb->base) {
1198                         dev_err(&intf->dev,
1199                                 "out of memory (read bufs usb_alloc_coherent)\n");
1200                         goto alloc_fail7;
1201                 }
1202         }
1203         for (i = 0; i < ACM_NW; i++) {
1204                 struct acm_wb *snd = &(acm->wb[i]);
1205
1206                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1207                 if (snd->urb == NULL) {
1208                         dev_err(&intf->dev,
1209                                 "out of memory (write urbs usb_alloc_urb)\n");
1210                         goto alloc_fail8;
1211                 }
1212
1213                 if (usb_endpoint_xfer_int(epwrite))
1214                         usb_fill_int_urb(snd->urb, usb_dev,
1215                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1216                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1217                 else
1218                         usb_fill_bulk_urb(snd->urb, usb_dev,
1219                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1220                                 NULL, acm->writesize, acm_write_bulk, snd);
1221                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1222                 snd->instance = acm;
1223         }
1224
1225         usb_set_intfdata(intf, acm);
1226
1227         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1228         if (i < 0)
1229                 goto alloc_fail8;
1230
1231         if (cfd) { /* export the country data */
1232                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1233                 if (!acm->country_codes)
1234                         goto skip_countries;
1235                 acm->country_code_size = cfd->bLength - 4;
1236                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1237                                                         cfd->bLength - 4);
1238                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1239
1240                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1241                 if (i < 0) {
1242                         kfree(acm->country_codes);
1243                         goto skip_countries;
1244                 }
1245
1246                 i = device_create_file(&intf->dev,
1247                                                 &dev_attr_iCountryCodeRelDate);
1248                 if (i < 0) {
1249                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1250                         kfree(acm->country_codes);
1251                         goto skip_countries;
1252                 }
1253         }
1254
1255 skip_countries:
1256         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1257                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1258                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1259                          /* works around buggy devices */
1260                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1261         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1262         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1263
1264         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1265
1266         acm_set_control(acm, acm->ctrlout);
1267
1268         acm->line.dwDTERate = cpu_to_le32(9600);
1269         acm->line.bDataBits = 8;
1270         acm_set_line(acm, &acm->line);
1271
1272         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1273         usb_set_intfdata(data_interface, acm);
1274
1275         usb_get_intf(control_interface);
1276         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1277
1278         acm_table[minor] = acm;
1279
1280         return 0;
1281 alloc_fail8:
1282         for (i = 0; i < ACM_NW; i++)
1283                 usb_free_urb(acm->wb[i].urb);
1284 alloc_fail7:
1285         acm_read_buffers_free(acm);
1286 alloc_fail6:
1287         for (i = 0; i < num_rx_buf; i++)
1288                 usb_free_urb(acm->ru[i].urb);
1289         usb_free_urb(acm->ctrlurb);
1290 alloc_fail5:
1291         acm_write_buffers_free(acm);
1292 alloc_fail4:
1293         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1294 alloc_fail2:
1295         kfree(acm);
1296 alloc_fail:
1297         return -ENOMEM;
1298 }
1299
1300 static void stop_data_traffic(struct acm *acm)
1301 {
1302         int i;
1303
1304         dev_dbg(&acm->control->dev, "%s\n", __func__);
1305
1306         tasklet_disable(&acm->urb_task);
1307
1308         usb_kill_urb(acm->ctrlurb);
1309         for (i = 0; i < ACM_NW; i++)
1310                 usb_kill_urb(acm->wb[i].urb);
1311         for (i = 0; i < acm->rx_buflimit; i++)
1312                 usb_kill_urb(acm->ru[i].urb);
1313
1314         tasklet_enable(&acm->urb_task);
1315
1316         cancel_work_sync(&acm->work);
1317 }
1318
1319 static void acm_disconnect(struct usb_interface *intf)
1320 {
1321         struct acm *acm = usb_get_intfdata(intf);
1322         struct usb_device *usb_dev = interface_to_usbdev(intf);
1323         struct tty_struct *tty;
1324
1325         /* sibling interface is already cleaning up */
1326         if (!acm)
1327                 return;
1328
1329         mutex_lock(&open_mutex);
1330         if (acm->country_codes) {
1331                 device_remove_file(&acm->control->dev,
1332                                 &dev_attr_wCountryCodes);
1333                 device_remove_file(&acm->control->dev,
1334                                 &dev_attr_iCountryCodeRelDate);
1335         }
1336         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1337         acm->dev = NULL;
1338         usb_set_intfdata(acm->control, NULL);
1339         usb_set_intfdata(acm->data, NULL);
1340
1341         stop_data_traffic(acm);
1342
1343         acm_write_buffers_free(acm);
1344         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1345                           acm->ctrl_dma);
1346         acm_read_buffers_free(acm);
1347
1348         if (!acm->combined_interfaces)
1349                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1350                                         acm->data : acm->control);
1351
1352         if (acm->port.count == 0) {
1353                 acm_tty_unregister(acm);
1354                 mutex_unlock(&open_mutex);
1355                 return;
1356         }
1357
1358         mutex_unlock(&open_mutex);
1359         tty = tty_port_tty_get(&acm->port);
1360         if (tty) {
1361                 tty_hangup(tty);
1362                 tty_kref_put(tty);
1363         }
1364 }
1365
1366 #ifdef CONFIG_PM
1367 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1368 {
1369         struct acm *acm = usb_get_intfdata(intf);
1370         int cnt;
1371
1372         if (message.event & PM_EVENT_AUTO) {
1373                 int b;
1374
1375                 spin_lock_irq(&acm->read_lock);
1376                 spin_lock(&acm->write_lock);
1377                 b = acm->processing + acm->transmitting;
1378                 spin_unlock(&acm->write_lock);
1379                 spin_unlock_irq(&acm->read_lock);
1380                 if (b)
1381                         return -EBUSY;
1382         }
1383
1384         spin_lock_irq(&acm->read_lock);
1385         spin_lock(&acm->write_lock);
1386         cnt = acm->susp_count++;
1387         spin_unlock(&acm->write_lock);
1388         spin_unlock_irq(&acm->read_lock);
1389
1390         if (cnt)
1391                 return 0;
1392         /*
1393         we treat opened interfaces differently,
1394         we must guard against open
1395         */
1396         mutex_lock(&acm->mutex);
1397
1398         if (acm->port.count)
1399                 stop_data_traffic(acm);
1400
1401         mutex_unlock(&acm->mutex);
1402         return 0;
1403 }
1404
1405 static int acm_resume(struct usb_interface *intf)
1406 {
1407         struct acm *acm = usb_get_intfdata(intf);
1408         struct acm_wb *wb;
1409         int rv = 0;
1410         int cnt;
1411
1412         spin_lock_irq(&acm->read_lock);
1413         acm->susp_count -= 1;
1414         cnt = acm->susp_count;
1415         spin_unlock_irq(&acm->read_lock);
1416
1417         if (cnt)
1418                 return 0;
1419
1420         mutex_lock(&acm->mutex);
1421         if (acm->port.count) {
1422                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1423
1424                 spin_lock_irq(&acm->write_lock);
1425                 if (acm->delayed_wb) {
1426                         wb = acm->delayed_wb;
1427                         acm->delayed_wb = NULL;
1428                         spin_unlock_irq(&acm->write_lock);
1429                         acm_start_wb(acm, wb);
1430                 } else {
1431                         spin_unlock_irq(&acm->write_lock);
1432                 }
1433
1434                 /*
1435                  * delayed error checking because we must
1436                  * do the write path at all cost
1437                  */
1438                 if (rv < 0)
1439                         goto err_out;
1440
1441                 tasklet_schedule(&acm->urb_task);
1442         }
1443
1444 err_out:
1445         mutex_unlock(&acm->mutex);
1446         return rv;
1447 }
1448
1449 static int acm_reset_resume(struct usb_interface *intf)
1450 {
1451         struct acm *acm = usb_get_intfdata(intf);
1452         struct tty_struct *tty;
1453
1454         mutex_lock(&acm->mutex);
1455         if (acm->port.count) {
1456                 tty = tty_port_tty_get(&acm->port);
1457                 if (tty) {
1458                         tty_hangup(tty);
1459                         tty_kref_put(tty);
1460                 }
1461         }
1462         mutex_unlock(&acm->mutex);
1463         return acm_resume(intf);
1464 }
1465
1466 #endif /* CONFIG_PM */
1467
1468 #define NOKIA_PCSUITE_ACM_INFO(x) \
1469                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1470                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1471                 USB_CDC_ACM_PROTO_VENDOR)
1472
1473 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1474                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1475                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1476                 USB_CDC_ACM_PROTO_VENDOR)
1477
1478 /*
1479  * USB driver structure.
1480  */
1481
1482 static const struct usb_device_id acm_ids[] = {
1483         /* quirky and broken devices */
1484         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1485         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1486         },
1487         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1488         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1489         },
1490         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1491         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1492         },
1493         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1494         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495         },
1496         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1497         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498         },
1499         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1500         .driver_info = SINGLE_RX_URB,
1501         },
1502         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1503         .driver_info = SINGLE_RX_URB, /* firmware bug */
1504         },
1505         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1506         .driver_info = SINGLE_RX_URB, /* firmware bug */
1507         },
1508         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1509         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510         },
1511         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1512         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1513         },
1514         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1515         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1516         },
1517         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1518         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519         },
1520         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1521         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522         },
1523         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1524         },
1525         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1526         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1527                                            data interface instead of
1528                                            communications interface.
1529                                            Maybe we should define a new
1530                                            quirk for this. */
1531         },
1532         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1533         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1534         },
1535         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1536         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1537         },
1538
1539         /* Nokia S60 phones expose two ACM channels. The first is
1540          * a modem and is picked up by the standard AT-command
1541          * information below. The second is 'vendor-specific' but
1542          * is treated as a serial device at the S60 end, so we want
1543          * to expose it on Linux too. */
1544         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1545         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1546         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1547         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1548         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1549         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1550         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1551         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1552         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1554         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1556         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1558         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1559         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1561         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1562         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1563         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1564         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1565         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1566         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1567         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1568         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1570         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1571         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1573         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1574         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1575         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1576         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1577         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1579         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1580         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1581         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1582         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1583         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1584         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1585         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1586         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1588         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1589         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1591         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1592         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1594         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1595         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1596         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1597         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1598         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1599         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1600
1601         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1602
1603         /* Support Lego NXT using pbLua firmware */
1604         { USB_DEVICE(0x0694, 0xff00),
1605         .driver_info = NOT_A_MODEM,
1606         },
1607
1608         /* control interfaces without any protocol set */
1609         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1610                 USB_CDC_PROTO_NONE) },
1611
1612         /* control interfaces with various AT-command sets */
1613         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1614                 USB_CDC_ACM_PROTO_AT_V25TER) },
1615         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1616                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1617         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1618                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1619         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1620                 USB_CDC_ACM_PROTO_AT_GSM) },
1621         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1622                 USB_CDC_ACM_PROTO_AT_3G) },
1623         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1624                 USB_CDC_ACM_PROTO_AT_CDMA) },
1625
1626         { }
1627 };
1628
1629 MODULE_DEVICE_TABLE(usb, acm_ids);
1630
1631 static struct usb_driver acm_driver = {
1632         .name =         "cdc_acm",
1633         .probe =        acm_probe,
1634         .disconnect =   acm_disconnect,
1635 #ifdef CONFIG_PM
1636         .suspend =      acm_suspend,
1637         .resume =       acm_resume,
1638         .reset_resume = acm_reset_resume,
1639 #endif
1640         .id_table =     acm_ids,
1641 #ifdef CONFIG_PM
1642         .supports_autosuspend = 1,
1643 #endif
1644 };
1645
1646 /*
1647  * TTY driver structures.
1648  */
1649
1650 static const struct tty_operations acm_ops = {
1651         .open =                 acm_tty_open,
1652         .close =                acm_tty_close,
1653         .hangup =               acm_tty_hangup,
1654         .write =                acm_tty_write,
1655         .write_room =           acm_tty_write_room,
1656         .ioctl =                acm_tty_ioctl,
1657         .throttle =             acm_tty_throttle,
1658         .unthrottle =           acm_tty_unthrottle,
1659         .chars_in_buffer =      acm_tty_chars_in_buffer,
1660         .break_ctl =            acm_tty_break_ctl,
1661         .set_termios =          acm_tty_set_termios,
1662         .tiocmget =             acm_tty_tiocmget,
1663         .tiocmset =             acm_tty_tiocmset,
1664 };
1665
1666 /*
1667  * Init / exit.
1668  */
1669
1670 static int __init acm_init(void)
1671 {
1672         int retval;
1673         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1674         if (!acm_tty_driver)
1675                 return -ENOMEM;
1676         acm_tty_driver->owner = THIS_MODULE,
1677         acm_tty_driver->driver_name = "acm",
1678         acm_tty_driver->name = "ttyACM",
1679         acm_tty_driver->major = ACM_TTY_MAJOR,
1680         acm_tty_driver->minor_start = 0,
1681         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1682         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1683         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1684         acm_tty_driver->init_termios = tty_std_termios;
1685         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1686                                                                 HUPCL | CLOCAL;
1687         tty_set_operations(acm_tty_driver, &acm_ops);
1688
1689         retval = tty_register_driver(acm_tty_driver);
1690         if (retval) {
1691                 put_tty_driver(acm_tty_driver);
1692                 return retval;
1693         }
1694
1695         retval = usb_register(&acm_driver);
1696         if (retval) {
1697                 tty_unregister_driver(acm_tty_driver);
1698                 put_tty_driver(acm_tty_driver);
1699                 return retval;
1700         }
1701
1702         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1703
1704         return 0;
1705 }
1706
1707 static void __exit acm_exit(void)
1708 {
1709         usb_deregister(&acm_driver);
1710         tty_unregister_driver(acm_tty_driver);
1711         put_tty_driver(acm_tty_driver);
1712 }
1713
1714 module_init(acm_init);
1715 module_exit(acm_exit);
1716
1717 MODULE_AUTHOR(DRIVER_AUTHOR);
1718 MODULE_DESCRIPTION(DRIVER_DESC);
1719 MODULE_LICENSE("GPL");
1720 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);