drivers/usb/class/cdc-acm.c

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