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_rb *rb = &(acm->rb[i]);
1181                 struct acm_ru *rcv = &(acm->ru[i]);
1182
1183                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1184                                                                 &rb->dma);
1185                 if (!rb->base) {
1186                         dev_err(&intf->dev, "out of memory "
1187                                         "(read bufs usb_alloc_coherent)\n");
1188                         goto alloc_fail6;
1189                 }
1190
1191                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1192                 if (rcv->urb == NULL) {
1193                         dev_err(&intf->dev,
1194                                 "out of memory (read urbs usb_alloc_urb)\n");
1195                         goto alloc_fail6;
1196                 }
1197
1198                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1199                 rcv->instance = acm;
1200         }
1201         for (i = 0; i < ACM_NW; i++) {
1202                 struct acm_wb *snd = &(acm->wb[i]);
1203
1204                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1205                 if (snd->urb == NULL) {
1206                         dev_err(&intf->dev,
1207                                 "out of memory (write urbs usb_alloc_urb)\n");
1208                         goto alloc_fail7;
1209                 }
1210
1211                 if (usb_endpoint_xfer_int(epwrite))
1212                         usb_fill_int_urb(snd->urb, usb_dev,
1213                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1214                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1215                 else
1216                         usb_fill_bulk_urb(snd->urb, usb_dev,
1217                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1218                                 NULL, acm->writesize, acm_write_bulk, snd);
1219                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1220                 snd->instance = acm;
1221         }
1222
1223         usb_set_intfdata(intf, acm);
1224
1225         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1226         if (i < 0)
1227                 goto alloc_fail7;
1228
1229         if (cfd) { /* export the country data */
1230                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1231                 if (!acm->country_codes)
1232                         goto skip_countries;
1233                 acm->country_code_size = cfd->bLength - 4;
1234                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1235                                                         cfd->bLength - 4);
1236                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1237
1238                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1239                 if (i < 0) {
1240                         kfree(acm->country_codes);
1241                         goto skip_countries;
1242                 }
1243
1244                 i = device_create_file(&intf->dev,
1245                                                 &dev_attr_iCountryCodeRelDate);
1246                 if (i < 0) {
1247                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1248                         kfree(acm->country_codes);
1249                         goto skip_countries;
1250                 }
1251         }
1252
1253 skip_countries:
1254         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1255                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1256                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1257                          /* works around buggy devices */
1258                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1259         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1260         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1261
1262         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1263
1264         acm_set_control(acm, acm->ctrlout);
1265
1266         acm->line.dwDTERate = cpu_to_le32(9600);
1267         acm->line.bDataBits = 8;
1268         acm_set_line(acm, &acm->line);
1269
1270         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1271         usb_set_intfdata(data_interface, acm);
1272
1273         usb_get_intf(control_interface);
1274         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1275
1276         acm_table[minor] = acm;
1277
1278         return 0;
1279 alloc_fail7:
1280         for (i = 0; i < ACM_NW; i++)
1281                 usb_free_urb(acm->wb[i].urb);
1282 alloc_fail6:
1283         for (i = 0; i < num_rx_buf; i++)
1284                 usb_free_urb(acm->ru[i].urb);
1285         acm_read_buffers_free(acm);
1286         usb_free_urb(acm->ctrlurb);
1287 alloc_fail5:
1288         acm_write_buffers_free(acm);
1289 alloc_fail4:
1290         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1291 alloc_fail2:
1292         kfree(acm);
1293 alloc_fail:
1294         return -ENOMEM;
1295 }
1296
1297 static void stop_data_traffic(struct acm *acm)
1298 {
1299         int i;
1300
1301         dev_dbg(&acm->control->dev, "%s\n", __func__);
1302
1303         tasklet_disable(&acm->urb_task);
1304
1305         usb_kill_urb(acm->ctrlurb);
1306         for (i = 0; i < ACM_NW; i++)
1307                 usb_kill_urb(acm->wb[i].urb);
1308         for (i = 0; i < acm->rx_buflimit; i++)
1309                 usb_kill_urb(acm->ru[i].urb);
1310
1311         tasklet_enable(&acm->urb_task);
1312
1313         cancel_work_sync(&acm->work);
1314 }
1315
1316 static void acm_disconnect(struct usb_interface *intf)
1317 {
1318         struct acm *acm = usb_get_intfdata(intf);
1319         struct usb_device *usb_dev = interface_to_usbdev(intf);
1320         struct tty_struct *tty;
1321
1322         /* sibling interface is already cleaning up */
1323         if (!acm)
1324                 return;
1325
1326         mutex_lock(&open_mutex);
1327         if (acm->country_codes) {
1328                 device_remove_file(&acm->control->dev,
1329                                 &dev_attr_wCountryCodes);
1330                 device_remove_file(&acm->control->dev,
1331                                 &dev_attr_iCountryCodeRelDate);
1332         }
1333         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1334         acm->dev = NULL;
1335         usb_set_intfdata(acm->control, NULL);
1336         usb_set_intfdata(acm->data, NULL);
1337
1338         stop_data_traffic(acm);
1339
1340         acm_write_buffers_free(acm);
1341         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1342                           acm->ctrl_dma);
1343         acm_read_buffers_free(acm);
1344
1345         if (!acm->combined_interfaces)
1346                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1347                                         acm->data : acm->control);
1348
1349         if (acm->port.count == 0) {
1350                 acm_tty_unregister(acm);
1351                 mutex_unlock(&open_mutex);
1352                 return;
1353         }
1354
1355         mutex_unlock(&open_mutex);
1356         tty = tty_port_tty_get(&acm->port);
1357         if (tty) {
1358                 tty_hangup(tty);
1359                 tty_kref_put(tty);
1360         }
1361 }
1362
1363 #ifdef CONFIG_PM
1364 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1365 {
1366         struct acm *acm = usb_get_intfdata(intf);
1367         int cnt;
1368
1369         if (message.event & PM_EVENT_AUTO) {
1370                 int b;
1371
1372                 spin_lock_irq(&acm->read_lock);
1373                 spin_lock(&acm->write_lock);
1374                 b = acm->processing + acm->transmitting;
1375                 spin_unlock(&acm->write_lock);
1376                 spin_unlock_irq(&acm->read_lock);
1377                 if (b)
1378                         return -EBUSY;
1379         }
1380
1381         spin_lock_irq(&acm->read_lock);
1382         spin_lock(&acm->write_lock);
1383         cnt = acm->susp_count++;
1384         spin_unlock(&acm->write_lock);
1385         spin_unlock_irq(&acm->read_lock);
1386
1387         if (cnt)
1388                 return 0;
1389         /*
1390         we treat opened interfaces differently,
1391         we must guard against open
1392         */
1393         mutex_lock(&acm->mutex);
1394
1395         if (acm->port.count)
1396                 stop_data_traffic(acm);
1397
1398         mutex_unlock(&acm->mutex);
1399         return 0;
1400 }
1401
1402 static int acm_resume(struct usb_interface *intf)
1403 {
1404         struct acm *acm = usb_get_intfdata(intf);
1405         struct acm_wb *wb;
1406         int rv = 0;
1407         int cnt;
1408
1409         spin_lock_irq(&acm->read_lock);
1410         acm->susp_count -= 1;
1411         cnt = acm->susp_count;
1412         spin_unlock_irq(&acm->read_lock);
1413
1414         if (cnt)
1415                 return 0;
1416
1417         mutex_lock(&acm->mutex);
1418         if (acm->port.count) {
1419                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1420
1421                 spin_lock_irq(&acm->write_lock);
1422                 if (acm->delayed_wb) {
1423                         wb = acm->delayed_wb;
1424                         acm->delayed_wb = NULL;
1425                         spin_unlock_irq(&acm->write_lock);
1426                         acm_start_wb(acm, wb);
1427                 } else {
1428                         spin_unlock_irq(&acm->write_lock);
1429                 }
1430
1431                 /*
1432                  * delayed error checking because we must
1433                  * do the write path at all cost
1434                  */
1435                 if (rv < 0)
1436                         goto err_out;
1437
1438                 tasklet_schedule(&acm->urb_task);
1439         }
1440
1441 err_out:
1442         mutex_unlock(&acm->mutex);
1443         return rv;
1444 }
1445
1446 static int acm_reset_resume(struct usb_interface *intf)
1447 {
1448         struct acm *acm = usb_get_intfdata(intf);
1449         struct tty_struct *tty;
1450
1451         mutex_lock(&acm->mutex);
1452         if (acm->port.count) {
1453                 tty = tty_port_tty_get(&acm->port);
1454                 if (tty) {
1455                         tty_hangup(tty);
1456                         tty_kref_put(tty);
1457                 }
1458         }
1459         mutex_unlock(&acm->mutex);
1460         return acm_resume(intf);
1461 }
1462
1463 #endif /* CONFIG_PM */
1464
1465 #define NOKIA_PCSUITE_ACM_INFO(x) \
1466                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1467                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1468                 USB_CDC_ACM_PROTO_VENDOR)
1469
1470 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1471                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1472                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1473                 USB_CDC_ACM_PROTO_VENDOR)
1474
1475 /*
1476  * USB driver structure.
1477  */
1478
1479 static const struct usb_device_id acm_ids[] = {
1480         /* quirky and broken devices */
1481         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1482         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1483         },
1484         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1485         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1486         },
1487         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1488         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1489         },
1490         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1491         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1492         },
1493         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1494         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495         },
1496         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1497         .driver_info = SINGLE_RX_URB,
1498         },
1499         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1500         .driver_info = SINGLE_RX_URB, /* firmware bug */
1501         },
1502         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1503         .driver_info = SINGLE_RX_URB, /* firmware bug */
1504         },
1505         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1506         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507         },
1508         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1509         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510         },
1511         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1512         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1513         },
1514         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1515         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1516         },
1517         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1518         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519         },
1520         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1521         },
1522         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1523         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1524                                            data interface instead of
1525                                            communications interface.
1526                                            Maybe we should define a new
1527                                            quirk for this. */
1528         },
1529         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1530         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1531         },
1532         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1533         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1534         },
1535
1536         /* Nokia S60 phones expose two ACM channels. The first is
1537          * a modem and is picked up by the standard AT-command
1538          * information below. The second is 'vendor-specific' but
1539          * is treated as a serial device at the S60 end, so we want
1540          * to expose it on Linux too. */
1541         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1542         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1543         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1544         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1545         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1546         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1547         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1548         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1549         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1550         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1551         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1552         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1554         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1556         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1558         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1559         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1560         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1561         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1562         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1563         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1564         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1567         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1568         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1570         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1571         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1573         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1574         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1575         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1576         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1577         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1579         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1580         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1581         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1582         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1583         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1584         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1585         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1586         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1588         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1589         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1592         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1593         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1594         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1595         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1596         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1597
1598         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1599
1600         /* Support Lego NXT using pbLua firmware */
1601         { USB_DEVICE(0x0694, 0xff00),
1602         .driver_info = NOT_A_MODEM,
1603         },
1604
1605         /* control interfaces without any protocol set */
1606         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1607                 USB_CDC_PROTO_NONE) },
1608
1609         /* control interfaces with various AT-command sets */
1610         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1611                 USB_CDC_ACM_PROTO_AT_V25TER) },
1612         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1613                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1614         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1615                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1616         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1617                 USB_CDC_ACM_PROTO_AT_GSM) },
1618         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1619                 USB_CDC_ACM_PROTO_AT_3G) },
1620         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1621                 USB_CDC_ACM_PROTO_AT_CDMA) },
1622
1623         { }
1624 };
1625
1626 MODULE_DEVICE_TABLE(usb, acm_ids);
1627
1628 static struct usb_driver acm_driver = {
1629         .name =         "cdc_acm",
1630         .probe =        acm_probe,
1631         .disconnect =   acm_disconnect,
1632 #ifdef CONFIG_PM
1633         .suspend =      acm_suspend,
1634         .resume =       acm_resume,
1635         .reset_resume = acm_reset_resume,
1636 #endif
1637         .id_table =     acm_ids,
1638 #ifdef CONFIG_PM
1639         .supports_autosuspend = 1,
1640 #endif
1641 };
1642
1643 /*
1644  * TTY driver structures.
1645  */
1646
1647 static const struct tty_operations acm_ops = {
1648         .open =                 acm_tty_open,
1649         .close =                acm_tty_close,
1650         .hangup =               acm_tty_hangup,
1651         .write =                acm_tty_write,
1652         .write_room =           acm_tty_write_room,
1653         .ioctl =                acm_tty_ioctl,
1654         .throttle =             acm_tty_throttle,
1655         .unthrottle =           acm_tty_unthrottle,
1656         .chars_in_buffer =      acm_tty_chars_in_buffer,
1657         .break_ctl =            acm_tty_break_ctl,
1658         .set_termios =          acm_tty_set_termios,
1659         .tiocmget =             acm_tty_tiocmget,
1660         .tiocmset =             acm_tty_tiocmset,
1661 };
1662
1663 /*
1664  * Init / exit.
1665  */
1666
1667 static int __init acm_init(void)
1668 {
1669         int retval;
1670         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1671         if (!acm_tty_driver)
1672                 return -ENOMEM;
1673         acm_tty_driver->owner = THIS_MODULE,
1674         acm_tty_driver->driver_name = "acm",
1675         acm_tty_driver->name = "ttyACM",
1676         acm_tty_driver->major = ACM_TTY_MAJOR,
1677         acm_tty_driver->minor_start = 0,
1678         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1679         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1680         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1681         acm_tty_driver->init_termios = tty_std_termios;
1682         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1683                                                                 HUPCL | CLOCAL;
1684         tty_set_operations(acm_tty_driver, &acm_ops);
1685
1686         retval = tty_register_driver(acm_tty_driver);
1687         if (retval) {
1688                 put_tty_driver(acm_tty_driver);
1689                 return retval;
1690         }
1691
1692         retval = usb_register(&acm_driver);
1693         if (retval) {
1694                 tty_unregister_driver(acm_tty_driver);
1695                 put_tty_driver(acm_tty_driver);
1696                 return retval;
1697         }
1698
1699         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1700
1701         return 0;
1702 }
1703
1704 static void __exit acm_exit(void)
1705 {
1706         usb_deregister(&acm_driver);
1707         tty_unregister_driver(acm_tty_driver);
1708         put_tty_driver(acm_tty_driver);
1709 }
1710
1711 module_init(acm_init);
1712 module_exit(acm_exit);
1713
1714 MODULE_AUTHOR(DRIVER_AUTHOR);
1715 MODULE_DESCRIPTION(DRIVER_DESC);
1716 MODULE_LICENSE("GPL");
1717 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);