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  * 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_insert_flip_string(tty, buf->base, buf->size);
 432                         tty_flip_buffer_push(tty);
 433                 } else {
 434                         tty_kref_put(tty);
 435                         dbg("Throttling noticed");
 436                         spin_lock_irqsave(&acm->read_lock, flags);
 437                         list_add(&buf->list, &acm->filled_read_bufs);
 438                         spin_unlock_irqrestore(&acm->read_lock, flags);
 439                         return;
 440                 }
 441         }
 442
 443         spin_lock_irqsave(&acm->read_lock, flags);
 444         list_add(&buf->list, &acm->spare_read_bufs);
 445         spin_unlock_irqrestore(&acm->read_lock, flags);
 446         goto next_buffer;
 447
 448 urbs:
 449         tty_kref_put(tty);
 450
 451         while (!list_empty(&acm->spare_read_bufs)) {
 452                 spin_lock_irqsave(&acm->read_lock, flags);
 453                 if (list_empty(&acm->spare_read_urbs)) {
 454                         acm->processing = 0;
 455                         spin_unlock_irqrestore(&acm->read_lock, flags);
 456                         return;
 457                 }
 458                 rcv = list_entry(acm->spare_read_urbs.next,
 459                                  struct acm_ru, list);
 460                 list_del(&rcv->list);
 461                 spin_unlock_irqrestore(&acm->read_lock, flags);
 462
 463                 buf = list_entry(acm->spare_read_bufs.next,
 464                                  struct acm_rb, list);
 465                 list_del(&buf->list);
 466
 467                 rcv->buffer = buf;
 468
 469                 if (acm->is_int_ep)
 470                         usb_fill_int_urb(rcv->urb, acm->dev,
 471                                          acm->rx_endpoint,
 472                                          buf->base,
 473                                          acm->readsize,
 474                                          acm_read_bulk, rcv, acm->bInterval);
 475                 else
 476                         usb_fill_bulk_urb(rcv->urb, acm->dev,
 477                                           acm->rx_endpoint,
 478                                           buf->base,
 479                                           acm->readsize,
 480                                           acm_read_bulk, rcv);
 481                 rcv->urb->transfer_dma = buf->dma;
 482                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 483
 484                 /* This shouldn't kill the driver as unsuccessful URBs are
 485                    returned to the free-urbs-pool and resubmited ASAP */
 486                 spin_lock_irqsave(&acm->read_lock, flags);
 487                 if (acm->susp_count ||
 488                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 489                         list_add(&buf->list, &acm->spare_read_bufs);
 490                         list_add(&rcv->list, &acm->spare_read_urbs);
 491                         acm->processing = 0;
 492                         spin_unlock_irqrestore(&acm->read_lock, flags);
 493                         return;
 494                 } else {
 495                         spin_unlock_irqrestore(&acm->read_lock, flags);
 496                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 497                 }
 498         }
 499         spin_lock_irqsave(&acm->read_lock, flags);
 500         acm->processing = 0;
 501         spin_unlock_irqrestore(&acm->read_lock, flags);
 502 }
 503
 504 /* data interface wrote those outgoing bytes */
 505 static void acm_write_bulk(struct urb *urb)
 506 {
 507         struct acm_wb *wb = urb->context;
 508         struct acm *acm = wb->instance;
 509         unsigned long flags;
 510
 511         if (verbose || urb->status
 512                         || (urb->actual_length != urb->transfer_buffer_length))
 513                 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
 514                         urb->actual_length,
 515                         urb->transfer_buffer_length,
 516                         urb->status);
 517
 518         spin_lock_irqsave(&acm->write_lock, flags);
 519         acm_write_done(acm, wb);
 520         spin_unlock_irqrestore(&acm->write_lock, flags);
 521         if (ACM_READY(acm))
 522                 schedule_work(&acm->work);
 523         else
 524                 wake_up_interruptible(&acm->drain_wait);
 525 }
 526
 527 static void acm_softint(struct work_struct *work)
 528 {
 529         struct acm *acm = container_of(work, struct acm, work);
 530         struct tty_struct *tty;
 531
 532         dev_vdbg(&acm->data->dev, "tx work\n");
 533         if (!ACM_READY(acm))
 534                 return;
 535         tty = tty_port_tty_get(&acm->port);
 536         tty_wakeup(tty);
 537         tty_kref_put(tty);
 538 }
 539
 540 /*
 541  * TTY handlers
 542  */
 543
 544 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 545 {
 546         struct acm *acm;
 547         int rv = -ENODEV;
 548         int i;
 549         dbg("Entering acm_tty_open.");
 550
 551         mutex_lock(&open_mutex);
 552
 553         acm = acm_table[tty->index];
 554         if (!acm || !acm->dev)
 555                 goto out;
 556         else
 557                 rv = 0;
 558
 559         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 560
 561         tty->driver_data = acm;
 562         tty_port_tty_set(&acm->port, tty);
 563
 564         if (usb_autopm_get_interface(acm->control) < 0)
 565                 goto early_bail;
 566         else
 567                 acm->control->needs_remote_wakeup = 1;
 568
 569         mutex_lock(&acm->mutex);
 570         if (acm->port.count++) {
 571                 mutex_unlock(&acm->mutex);
 572                 usb_autopm_put_interface(acm->control);
 573                 goto out;
 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
 603         mutex_unlock(&acm->mutex);
 604 out:
 605         mutex_unlock(&open_mutex);
 606         return rv;
 607
 608 full_bailout:
 609         usb_kill_urb(acm->ctrlurb);
 610 bail_out:
 611         acm->port.count--;
 612         mutex_unlock(&acm->mutex);
 613         usb_autopm_put_interface(acm->control);
 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)
 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                 usb_kill_urb(acm->ctrlurb);
 647                 for (i = 0; i < ACM_NW; i++)
 648                         usb_kill_urb(acm->wb[i].urb);
 649                 for (i = 0; i < nr; i++)
 650                         usb_kill_urb(acm->ru[i].urb);
 651                 acm->control->needs_remote_wakeup = 0;
 652                 usb_autopm_put_interface(acm->control);
 653         }
 654         mutex_unlock(&open_mutex);
 655 }
 656
 657 static void acm_tty_hangup(struct tty_struct *tty)
 658 {
 659         struct acm *acm = tty->driver_data;
 660         tty_port_hangup(&acm->port);
 661         acm_port_down(acm);
 662 }
 663
 664 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 665 {
 666         struct acm *acm = tty->driver_data;
 667
 668         /* Perform the closing process and see if we need to do the hardware
 669            shutdown */
 670         if (!acm)
 671                 return;
 672         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
 673                 mutex_lock(&open_mutex);
 674                 if (!acm->dev) {
 675                         tty_port_tty_set(&acm->port, NULL);
 676                         acm_tty_unregister(acm);
 677                         tty->driver_data = NULL;
 678                 }
 679                 mutex_unlock(&open_mutex);
 680                 return;
 681         }
 682         acm_port_down(acm);
 683         tty_port_close_end(&acm->port, tty);
 684         tty_port_tty_set(&acm->port, NULL);
 685 }
 686
 687 static int acm_tty_write(struct tty_struct *tty,
 688                                         const unsigned char *buf, int count)
 689 {
 690         struct acm *acm = tty->driver_data;
 691         int stat;
 692         unsigned long flags;
 693         int wbn;
 694         struct acm_wb *wb;
 695
 696         dbg("Entering acm_tty_write to write %d bytes,", count);
 697
 698         if (!ACM_READY(acm))
 699                 return -EINVAL;
 700         if (!count)
 701                 return 0;
 702
 703         spin_lock_irqsave(&acm->write_lock, flags);
 704         wbn = acm_wb_alloc(acm);
 705         if (wbn < 0) {
 706                 spin_unlock_irqrestore(&acm->write_lock, flags);
 707                 return 0;
 708         }
 709         wb = &acm->wb[wbn];
 710
 711         count = (count > acm->writesize) ? acm->writesize : count;
 712         dbg("Get %d bytes...", count);
 713         memcpy(wb->buf, buf, count);
 714         wb->len = count;
 715         spin_unlock_irqrestore(&acm->write_lock, flags);
 716
 717         stat = acm_write_start(acm, wbn);
 718         if (stat < 0)
 719                 return stat;
 720         return count;
 721 }
 722
 723 static int acm_tty_write_room(struct tty_struct *tty)
 724 {
 725         struct acm *acm = tty->driver_data;
 726         if (!ACM_READY(acm))
 727                 return -EINVAL;
 728         /*
 729          * Do not let the line discipline to know that we have a reserve,
 730          * or it might get too enthusiastic.
 731          */
 732         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 733 }
 734
 735 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 736 {
 737         struct acm *acm = tty->driver_data;
 738         if (!ACM_READY(acm))
 739                 return 0;
 740         /*
 741          * This is inaccurate (overcounts), but it works.
 742          */
 743         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 744 }
 745
 746 static void acm_tty_throttle(struct tty_struct *tty)
 747 {
 748         struct acm *acm = tty->driver_data;
 749         if (!ACM_READY(acm))
 750                 return;
 751         spin_lock_bh(&acm->throttle_lock);
 752         acm->throttle = 1;
 753         spin_unlock_bh(&acm->throttle_lock);
 754 }
 755
 756 static void acm_tty_unthrottle(struct tty_struct *tty)
 757 {
 758         struct acm *acm = tty->driver_data;
 759         if (!ACM_READY(acm))
 760                 return;
 761         spin_lock_bh(&acm->throttle_lock);
 762         acm->throttle = 0;
 763         spin_unlock_bh(&acm->throttle_lock);
 764         tasklet_schedule(&acm->urb_task);
 765 }
 766
 767 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 768 {
 769         struct acm *acm = tty->driver_data;
 770         int retval;
 771         if (!ACM_READY(acm))
 772                 return -EINVAL;
 773         retval = acm_send_break(acm, state ? 0xffff : 0);
 774         if (retval < 0)
 775                 dbg("send break failed");
 776         return retval;
 777 }
 778
 779 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 780 {
 781         struct acm *acm = tty->driver_data;
 782
 783         if (!ACM_READY(acm))
 784                 return -EINVAL;
 785
 786         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 787                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 788                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 789                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 790                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 791                TIOCM_CTS;
 792 }
 793
 794 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 795                             unsigned int set, unsigned int clear)
 796 {
 797         struct acm *acm = tty->driver_data;
 798         unsigned int newctrl;
 799
 800         if (!ACM_READY(acm))
 801                 return -EINVAL;
 802
 803         newctrl = acm->ctrlout;
 804         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 805                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 806         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 807                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 808
 809         newctrl = (newctrl & ~clear) | set;
 810
 811         if (acm->ctrlout == newctrl)
 812                 return 0;
 813         return acm_set_control(acm, acm->ctrlout = newctrl);
 814 }
 815
 816 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
 817                                         unsigned int cmd, unsigned long arg)
 818 {
 819         struct acm *acm = tty->driver_data;
 820
 821         if (!ACM_READY(acm))
 822                 return -EINVAL;
 823
 824         return -ENOIOCTLCMD;
 825 }
 826
 827 static const __u32 acm_tty_speed[] = {
 828         0, 50, 75, 110, 134, 150, 200, 300, 600,
 829         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 830         57600, 115200, 230400, 460800, 500000, 576000,
 831         921600, 1000000, 1152000, 1500000, 2000000,
 832         2500000, 3000000, 3500000, 4000000
 833 };
 834
 835 static const __u8 acm_tty_size[] = {
 836         5, 6, 7, 8
 837 };
 838
 839 static void acm_tty_set_termios(struct tty_struct *tty,
 840                                                 struct ktermios *termios_old)
 841 {
 842         struct acm *acm = tty->driver_data;
 843         struct ktermios *termios = tty->termios;
 844         struct usb_cdc_line_coding newline;
 845         int newctrl = acm->ctrlout;
 846
 847         if (!ACM_READY(acm))
 848                 return;
 849
 850         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 851         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 852         newline.bParityType = termios->c_cflag & PARENB ?
 853                                 (termios->c_cflag & PARODD ? 1 : 2) +
 854                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 855         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 856         /* FIXME: Needs to clear unsupported bits in the termios */
 857         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 858
 859         if (!newline.dwDTERate) {
 860                 newline.dwDTERate = acm->line.dwDTERate;
 861                 newctrl &= ~ACM_CTRL_DTR;
 862         } else
 863                 newctrl |=  ACM_CTRL_DTR;
 864
 865         if (newctrl != acm->ctrlout)
 866                 acm_set_control(acm, acm->ctrlout = newctrl);
 867
 868         if (memcmp(&acm->line, &newline, sizeof newline)) {
 869                 memcpy(&acm->line, &newline, sizeof newline);
 870                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 871                         newline.bCharFormat, newline.bParityType,
 872                         newline.bDataBits);
 873                 acm_set_line(acm, &acm->line);
 874         }
 875 }
 876
 877 /*
 878  * USB probe and disconnect routines.
 879  */
 880
 881 /* Little helpers: write/read buffers free */
 882 static void acm_write_buffers_free(struct acm *acm)
 883 {
 884         int i;
 885         struct acm_wb *wb;
 886         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 887
 888         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 889                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 890 }
 891
 892 static void acm_read_buffers_free(struct acm *acm)
 893 {
 894         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 895         int i, n = acm->rx_buflimit;
 896
 897         for (i = 0; i < n; i++)
 898                 usb_free_coherent(usb_dev, acm->readsize,
 899                                   acm->rb[i].base, acm->rb[i].dma);
 900 }
 901
 902 /* Little helper: write buffers allocate */
 903 static int acm_write_buffers_alloc(struct acm *acm)
 904 {
 905         int i;
 906         struct acm_wb *wb;
 907
 908         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 909                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 910                     &wb->dmah);
 911                 if (!wb->buf) {
 912                         while (i != 0) {
 913                                 --i;
 914                                 --wb;
 915                                 usb_free_coherent(acm->dev, acm->writesize,
 916                                     wb->buf, wb->dmah);
 917                         }
 918                         return -ENOMEM;
 919                 }
 920         }
 921         return 0;
 922 }
 923
 924 static int acm_probe(struct usb_interface *intf,
 925                      const struct usb_device_id *id)
 926 {
 927         struct usb_cdc_union_desc *union_header = NULL;
 928         struct usb_cdc_country_functional_desc *cfd = NULL;
 929         unsigned char *buffer = intf->altsetting->extra;
 930         int buflen = intf->altsetting->extralen;
 931         struct usb_interface *control_interface;
 932         struct usb_interface *data_interface;
 933         struct usb_endpoint_descriptor *epctrl = NULL;
 934         struct usb_endpoint_descriptor *epread = NULL;
 935         struct usb_endpoint_descriptor *epwrite = NULL;
 936         struct usb_device *usb_dev = interface_to_usbdev(intf);
 937         struct acm *acm;
 938         int minor;
 939         int ctrlsize, readsize;
 940         u8 *buf;
 941         u8 ac_management_function = 0;
 942         u8 call_management_function = 0;
 943         int call_interface_num = -1;
 944         int data_interface_num;
 945         unsigned long quirks;
 946         int num_rx_buf;
 947         int i;
 948         int combined_interfaces = 0;
 949
 950         /* normal quirks */
 951         quirks = (unsigned long)id->driver_info;
 952         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 953
 954         /* handle quirks deadly to normal probing*/
 955         if (quirks == NO_UNION_NORMAL) {
 956                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 957                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 958                 goto skip_normal_probe;
 959         }
 960
 961         /* normal probing*/
 962         if (!buffer) {
 963                 dev_err(&intf->dev, "Weird descriptor references\n");
 964                 return -EINVAL;
 965         }
 966
 967         if (!buflen) {
 968                 if (intf->cur_altsetting->endpoint &&
 969                                 intf->cur_altsetting->endpoint->extralen &&
 970                                 intf->cur_altsetting->endpoint->extra) {
 971                         dev_dbg(&intf->dev,
 972                                 "Seeking extra descriptors on endpoint\n");
 973                         buflen = intf->cur_altsetting->endpoint->extralen;
 974                         buffer = intf->cur_altsetting->endpoint->extra;
 975                 } else {
 976                         dev_err(&intf->dev,
 977                                 "Zero length descriptor references\n");
 978                         return -EINVAL;
 979                 }
 980         }
 981
 982         while (buflen > 0) {
 983                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 984                         dev_err(&intf->dev, "skipping garbage\n");
 985                         goto next_desc;
 986                 }
 987
 988                 switch (buffer[2]) {
 989                 case USB_CDC_UNION_TYPE: /* we've found it */
 990                         if (union_header) {
 991                                 dev_err(&intf->dev, "More than one "
 992                                         "union descriptor, skipping ...\n");
 993                                 goto next_desc;
 994                         }
 995                         union_header = (struct usb_cdc_union_desc *)buffer;
 996                         break;
 997                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 998                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
 999                         break;
1000                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1001                         break; /* for now we ignore it */
1002                 case USB_CDC_ACM_TYPE:
1003                         ac_management_function = buffer[3];
1004                         break;
1005                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1006                         call_management_function = buffer[3];
1007                         call_interface_num = buffer[4];
1008                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1009                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1010                         break;
1011                 default:
1012                         /* there are LOTS more CDC descriptors that
1013                          * could legitimately be found here.
1014                          */
1015                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1016                                         "type %02x, length %d\n",
1017                                         buffer[2], buffer[0]);
1018                         break;
1019                 }
1020 next_desc:
1021                 buflen -= buffer[0];
1022                 buffer += buffer[0];
1023         }
1024
1025         if (!union_header) {
1026                 if (call_interface_num > 0) {
1027                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1028                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1029                         control_interface = intf;
1030                 } else {
1031                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1032                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1033                                 return -ENODEV;
1034                         } else {
1035                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1036                                 combined_interfaces = 1;
1037                                 control_interface = data_interface = intf;
1038                                 goto look_for_collapsed_interface;
1039                         }
1040                 }
1041         } else {
1042                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1043                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1044                 if (!control_interface || !data_interface) {
1045                         dev_dbg(&intf->dev, "no interfaces\n");
1046                         return -ENODEV;
1047                 }
1048         }
1049
1050         if (data_interface_num != call_interface_num)
1051                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1052
1053         if (control_interface == data_interface) {
1054                 /* some broken devices designed for windows work this way */
1055                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1056                 combined_interfaces = 1;
1057                 /* a popular other OS doesn't use it */
1058                 quirks |= NO_CAP_LINE;
1059                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1060                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1061                         return -EINVAL;
1062                 }
1063 look_for_collapsed_interface:
1064                 for (i = 0; i < 3; i++) {
1065                         struct usb_endpoint_descriptor *ep;
1066                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1067
1068                         if (usb_endpoint_is_int_in(ep))
1069                                 epctrl = ep;
1070                         else if (usb_endpoint_is_bulk_out(ep))
1071                                 epwrite = ep;
1072                         else if (usb_endpoint_is_bulk_in(ep))
1073                                 epread = ep;
1074                         else
1075                                 return -EINVAL;
1076                 }
1077                 if (!epctrl || !epread || !epwrite)
1078                         return -ENODEV;
1079                 else
1080                         goto made_compressed_probe;
1081         }
1082
1083 skip_normal_probe:
1084
1085         /*workaround for switched interfaces */
1086         if (data_interface->cur_altsetting->desc.bInterfaceClass
1087                                                 != CDC_DATA_INTERFACE_TYPE) {
1088                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1089                                                 == CDC_DATA_INTERFACE_TYPE) {
1090                         struct usb_interface *t;
1091                         dev_dbg(&intf->dev,
1092                                 "Your device has switched interfaces.\n");
1093                         t = control_interface;
1094                         control_interface = data_interface;
1095                         data_interface = t;
1096                 } else {
1097                         return -EINVAL;
1098                 }
1099         }
1100
1101         /* Accept probe requests only for the control interface */
1102         if (!combined_interfaces && intf != control_interface)
1103                 return -ENODEV;
1104
1105         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1106                 /* valid in this context */
1107                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1108                 return -EBUSY;
1109         }
1110
1111
1112         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1113                 return -EINVAL;
1114
1115         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1116         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1117         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1118
1119
1120         /* workaround for switched endpoints */
1121         if (!usb_endpoint_dir_in(epread)) {
1122                 /* descriptors are swapped */
1123                 struct usb_endpoint_descriptor *t;
1124                 dev_dbg(&intf->dev,
1125                         "The data interface has switched endpoints\n");
1126                 t = epread;
1127                 epread = epwrite;
1128                 epwrite = t;
1129         }
1130 made_compressed_probe:
1131         dbg("interfaces are valid");
1132         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1133
1134         if (minor == ACM_TTY_MINORS) {
1135                 dev_err(&intf->dev, "no more free acm devices\n");
1136                 return -ENODEV;
1137         }
1138
1139         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1140         if (acm == NULL) {
1141                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1142                 goto alloc_fail;
1143         }
1144
1145         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1146         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1147                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1148         acm->combined_interfaces = combined_interfaces;
1149         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1150         acm->control = control_interface;
1151         acm->data = data_interface;
1152         acm->minor = minor;
1153         acm->dev = usb_dev;
1154         acm->ctrl_caps = ac_management_function;
1155         if (quirks & NO_CAP_LINE)
1156                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1157         acm->ctrlsize = ctrlsize;
1158         acm->readsize = readsize;
1159         acm->rx_buflimit = num_rx_buf;
1160         acm->urb_task.func = acm_rx_tasklet;
1161         acm->urb_task.data = (unsigned long) acm;
1162         INIT_WORK(&acm->work, acm_softint);
1163         init_waitqueue_head(&acm->drain_wait);
1164         spin_lock_init(&acm->throttle_lock);
1165         spin_lock_init(&acm->write_lock);
1166         spin_lock_init(&acm->read_lock);
1167         mutex_init(&acm->mutex);
1168         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1169         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1170         if (acm->is_int_ep)
1171                 acm->bInterval = epread->bInterval;
1172         tty_port_init(&acm->port);
1173         acm->port.ops = &acm_port_ops;
1174
1175         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1176         if (!buf) {
1177                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1178                 goto alloc_fail2;
1179         }
1180         acm->ctrl_buffer = buf;
1181
1182         if (acm_write_buffers_alloc(acm) < 0) {
1183                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1184                 goto alloc_fail4;
1185         }
1186
1187         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1188         if (!acm->ctrlurb) {
1189                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1190                 goto alloc_fail5;
1191         }
1192         for (i = 0; i < num_rx_buf; i++) {
1193                 struct acm_ru *rcv = &(acm->ru[i]);
1194
1195                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1196                 if (rcv->urb == NULL) {
1197                         dev_dbg(&intf->dev,
1198                                 "out of memory (read urbs usb_alloc_urb)\n");
1199                         goto alloc_fail6;
1200                 }
1201
1202                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1203                 rcv->instance = acm;
1204         }
1205         for (i = 0; i < num_rx_buf; i++) {
1206                 struct acm_rb *rb = &(acm->rb[i]);
1207
1208                 rb->base = usb_alloc_coherent(acm->dev, readsize,
1209                                 GFP_KERNEL, &rb->dma);
1210                 if (!rb->base) {
1211                         dev_dbg(&intf->dev,
1212                                 "out of memory (read bufs usb_alloc_coherent)\n");
1213                         goto alloc_fail7;
1214                 }
1215         }
1216         for (i = 0; i < ACM_NW; i++) {
1217                 struct acm_wb *snd = &(acm->wb[i]);
1218
1219                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1220                 if (snd->urb == NULL) {
1221                         dev_dbg(&intf->dev,
1222                                 "out of memory (write urbs usb_alloc_urb)");
1223                         goto alloc_fail8;
1224                 }
1225
1226                 if (usb_endpoint_xfer_int(epwrite))
1227                         usb_fill_int_urb(snd->urb, usb_dev,
1228                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1229                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1230                 else
1231                         usb_fill_bulk_urb(snd->urb, usb_dev,
1232                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1233                                 NULL, acm->writesize, acm_write_bulk, snd);
1234                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1235                 snd->instance = acm;
1236         }
1237
1238         usb_set_intfdata(intf, acm);
1239
1240         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1241         if (i < 0)
1242                 goto alloc_fail8;
1243
1244         if (cfd) { /* export the country data */
1245                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1246                 if (!acm->country_codes)
1247                         goto skip_countries;
1248                 acm->country_code_size = cfd->bLength - 4;
1249                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1250                                                         cfd->bLength - 4);
1251                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1252
1253                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1254                 if (i < 0) {
1255                         kfree(acm->country_codes);
1256                         goto skip_countries;
1257                 }
1258
1259                 i = device_create_file(&intf->dev,
1260                                                 &dev_attr_iCountryCodeRelDate);
1261                 if (i < 0) {
1262                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1263                         kfree(acm->country_codes);
1264                         goto skip_countries;
1265                 }
1266         }
1267
1268 skip_countries:
1269         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1270                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1271                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1272                          /* works around buggy devices */
1273                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1274         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1275         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1276
1277         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1278
1279         acm_set_control(acm, acm->ctrlout);
1280
1281         acm->line.dwDTERate = cpu_to_le32(9600);
1282         acm->line.bDataBits = 8;
1283         acm_set_line(acm, &acm->line);
1284
1285         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1286         usb_set_intfdata(data_interface, acm);
1287
1288         usb_get_intf(control_interface);
1289         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1290
1291         acm_table[minor] = acm;
1292
1293         return 0;
1294 alloc_fail8:
1295         for (i = 0; i < ACM_NW; i++)
1296                 usb_free_urb(acm->wb[i].urb);
1297 alloc_fail7:
1298         acm_read_buffers_free(acm);
1299 alloc_fail6:
1300         for (i = 0; i < num_rx_buf; i++)
1301                 usb_free_urb(acm->ru[i].urb);
1302         usb_free_urb(acm->ctrlurb);
1303 alloc_fail5:
1304         acm_write_buffers_free(acm);
1305 alloc_fail4:
1306         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1307 alloc_fail2:
1308         kfree(acm);
1309 alloc_fail:
1310         return -ENOMEM;
1311 }
1312
1313 static void stop_data_traffic(struct acm *acm)
1314 {
1315         int i;
1316         dbg("Entering stop_data_traffic");
1317
1318         tasklet_disable(&acm->urb_task);
1319
1320         usb_kill_urb(acm->ctrlurb);
1321         for (i = 0; i < ACM_NW; i++)
1322                 usb_kill_urb(acm->wb[i].urb);
1323         for (i = 0; i < acm->rx_buflimit; i++)
1324                 usb_kill_urb(acm->ru[i].urb);
1325
1326         tasklet_enable(&acm->urb_task);
1327
1328         cancel_work_sync(&acm->work);
1329 }
1330
1331 static void acm_disconnect(struct usb_interface *intf)
1332 {
1333         struct acm *acm = usb_get_intfdata(intf);
1334         struct usb_device *usb_dev = interface_to_usbdev(intf);
1335         struct tty_struct *tty;
1336
1337         /* sibling interface is already cleaning up */
1338         if (!acm)
1339                 return;
1340
1341         mutex_lock(&open_mutex);
1342         if (acm->country_codes) {
1343                 device_remove_file(&acm->control->dev,
1344                                 &dev_attr_wCountryCodes);
1345                 device_remove_file(&acm->control->dev,
1346                                 &dev_attr_iCountryCodeRelDate);
1347         }
1348         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1349         acm->dev = NULL;
1350         usb_set_intfdata(acm->control, NULL);
1351         usb_set_intfdata(acm->data, NULL);
1352
1353         stop_data_traffic(acm);
1354
1355         acm_write_buffers_free(acm);
1356         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1357                           acm->ctrl_dma);
1358         acm_read_buffers_free(acm);
1359
1360         if (!acm->combined_interfaces)
1361                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1362                                         acm->data : acm->control);
1363
1364         if (acm->port.count == 0) {
1365                 acm_tty_unregister(acm);
1366                 mutex_unlock(&open_mutex);
1367                 return;
1368         }
1369
1370         mutex_unlock(&open_mutex);
1371         tty = tty_port_tty_get(&acm->port);
1372         if (tty) {
1373                 tty_hangup(tty);
1374                 tty_kref_put(tty);
1375         }
1376 }
1377
1378 #ifdef CONFIG_PM
1379 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1380 {
1381         struct acm *acm = usb_get_intfdata(intf);
1382         int cnt;
1383
1384         if (message.event & PM_EVENT_AUTO) {
1385                 int b;
1386
1387                 spin_lock_irq(&acm->read_lock);
1388                 spin_lock(&acm->write_lock);
1389                 b = acm->processing + acm->transmitting;
1390                 spin_unlock(&acm->write_lock);
1391                 spin_unlock_irq(&acm->read_lock);
1392                 if (b)
1393                         return -EBUSY;
1394         }
1395
1396         spin_lock_irq(&acm->read_lock);
1397         spin_lock(&acm->write_lock);
1398         cnt = acm->susp_count++;
1399         spin_unlock(&acm->write_lock);
1400         spin_unlock_irq(&acm->read_lock);
1401
1402         if (cnt)
1403                 return 0;
1404         /*
1405         we treat opened interfaces differently,
1406         we must guard against open
1407         */
1408         mutex_lock(&acm->mutex);
1409
1410         if (acm->port.count)
1411                 stop_data_traffic(acm);
1412
1413         mutex_unlock(&acm->mutex);
1414         return 0;
1415 }
1416
1417 static int acm_resume(struct usb_interface *intf)
1418 {
1419         struct acm *acm = usb_get_intfdata(intf);
1420         struct acm_wb *wb;
1421         int rv = 0;
1422         int cnt;
1423
1424         spin_lock_irq(&acm->read_lock);
1425         acm->susp_count -= 1;
1426         cnt = acm->susp_count;
1427         spin_unlock_irq(&acm->read_lock);
1428
1429         if (cnt)
1430                 return 0;
1431
1432         mutex_lock(&acm->mutex);
1433         if (acm->port.count) {
1434                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1435
1436                 spin_lock_irq(&acm->write_lock);
1437                 if (acm->delayed_wb) {
1438                         wb = acm->delayed_wb;
1439                         acm->delayed_wb = NULL;
1440                         spin_unlock_irq(&acm->write_lock);
1441                         acm_start_wb(acm, wb);
1442                 } else {
1443                         spin_unlock_irq(&acm->write_lock);
1444                 }
1445
1446                 /*
1447                  * delayed error checking because we must
1448                  * do the write path at all cost
1449                  */
1450                 if (rv < 0)
1451                         goto err_out;
1452
1453                 tasklet_schedule(&acm->urb_task);
1454         }
1455
1456 err_out:
1457         mutex_unlock(&acm->mutex);
1458         return rv;
1459 }
1460
1461 static int acm_reset_resume(struct usb_interface *intf)
1462 {
1463         struct acm *acm = usb_get_intfdata(intf);
1464         struct tty_struct *tty;
1465
1466         mutex_lock(&acm->mutex);
1467         if (acm->port.count) {
1468                 tty = tty_port_tty_get(&acm->port);
1469                 if (tty) {
1470                         tty_hangup(tty);
1471                         tty_kref_put(tty);
1472                 }
1473         }
1474         mutex_unlock(&acm->mutex);
1475         return acm_resume(intf);
1476 }
1477
1478 #endif /* CONFIG_PM */
1479
1480 #define NOKIA_PCSUITE_ACM_INFO(x) \
1481                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1482                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1483                 USB_CDC_ACM_PROTO_VENDOR)
1484
1485 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1486                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1487                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1488                 USB_CDC_ACM_PROTO_VENDOR)
1489
1490 /*
1491  * USB driver structure.
1492  */
1493
1494 static const struct usb_device_id acm_ids[] = {
1495         /* quirky and broken devices */
1496         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1497         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498         },
1499         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1500         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501         },
1502         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1503         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504         },
1505         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1506         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507         },
1508         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1509         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510         },
1511         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1512         .driver_info = SINGLE_RX_URB,
1513         },
1514         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1515         .driver_info = SINGLE_RX_URB, /* firmware bug */
1516         },
1517         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1518         .driver_info = SINGLE_RX_URB, /* firmware bug */
1519         },
1520         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1521         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522         },
1523         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1524         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525         },
1526         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1527         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528         },
1529         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1530         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531         },
1532         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1533         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1534         },
1535         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1536         },
1537         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1538         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1539                                            data interface instead of
1540                                            communications interface.
1541                                            Maybe we should define a new
1542                                            quirk for this. */
1543         },
1544         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1545         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1546         },
1547         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1548         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1549         },
1550
1551         /* Nokia S60 phones expose two ACM channels. The first is
1552          * a modem and is picked up by the standard AT-command
1553          * information below. The second is 'vendor-specific' but
1554          * is treated as a serial device at the S60 end, so we want
1555          * to expose it on Linux too. */
1556         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1558         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1561         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1562         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1563         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1564         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1567         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1568         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1570         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1571         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1573         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1574         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1575         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1576         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1577         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1578         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1579         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1580         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1581         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1582         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1583         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1584         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1585         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1586         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1587         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1588         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1589         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1592         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1594         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1595         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1596         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1597         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1598         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1599         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1600         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1601         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1602         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1603         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1604         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1605         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1606         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1607         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1608         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1609         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1610         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1611         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1612
1613         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1614
1615         /* Support Lego NXT using pbLua firmware */
1616         { USB_DEVICE(0x0694, 0xff00),
1617         .driver_info = NOT_A_MODEM,
1618         },
1619
1620         /* control interfaces without any protocol set */
1621         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1622                 USB_CDC_PROTO_NONE) },
1623
1624         /* control interfaces with various AT-command sets */
1625         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1626                 USB_CDC_ACM_PROTO_AT_V25TER) },
1627         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1628                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1629         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1630                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1631         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1632                 USB_CDC_ACM_PROTO_AT_GSM) },
1633         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1634                 USB_CDC_ACM_PROTO_AT_3G) },
1635         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1636                 USB_CDC_ACM_PROTO_AT_CDMA) },
1637
1638         { }
1639 };
1640
1641 MODULE_DEVICE_TABLE(usb, acm_ids);
1642
1643 static struct usb_driver acm_driver = {
1644         .name =         "cdc_acm",
1645         .probe =        acm_probe,
1646         .disconnect =   acm_disconnect,
1647 #ifdef CONFIG_PM
1648         .suspend =      acm_suspend,
1649         .resume =       acm_resume,
1650         .reset_resume = acm_reset_resume,
1651 #endif
1652         .id_table =     acm_ids,
1653 #ifdef CONFIG_PM
1654         .supports_autosuspend = 1,
1655 #endif
1656 };
1657
1658 /*
1659  * TTY driver structures.
1660  */
1661
1662 static const struct tty_operations acm_ops = {
1663         .open =                 acm_tty_open,
1664         .close =                acm_tty_close,
1665         .hangup =               acm_tty_hangup,
1666         .write =                acm_tty_write,
1667         .write_room =           acm_tty_write_room,
1668         .ioctl =                acm_tty_ioctl,
1669         .throttle =             acm_tty_throttle,
1670         .unthrottle =           acm_tty_unthrottle,
1671         .chars_in_buffer =      acm_tty_chars_in_buffer,
1672         .break_ctl =            acm_tty_break_ctl,
1673         .set_termios =          acm_tty_set_termios,
1674         .tiocmget =             acm_tty_tiocmget,
1675         .tiocmset =             acm_tty_tiocmset,
1676 };
1677
1678 /*
1679  * Init / exit.
1680  */
1681
1682 static int __init acm_init(void)
1683 {
1684         int retval;
1685         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1686         if (!acm_tty_driver)
1687                 return -ENOMEM;
1688         acm_tty_driver->owner = THIS_MODULE,
1689         acm_tty_driver->driver_name = "acm",
1690         acm_tty_driver->name = "ttyACM",
1691         acm_tty_driver->major = ACM_TTY_MAJOR,
1692         acm_tty_driver->minor_start = 0,
1693         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1694         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1695         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1696         acm_tty_driver->init_termios = tty_std_termios;
1697         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1698                                                                 HUPCL | CLOCAL;
1699         tty_set_operations(acm_tty_driver, &acm_ops);
1700
1701         retval = tty_register_driver(acm_tty_driver);
1702         if (retval) {
1703                 put_tty_driver(acm_tty_driver);
1704                 return retval;
1705         }
1706
1707         retval = usb_register(&acm_driver);
1708         if (retval) {
1709                 tty_unregister_driver(acm_tty_driver);
1710                 put_tty_driver(acm_tty_driver);
1711                 return retval;
1712         }
1713
1714         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1715                DRIVER_DESC "\n");
1716
1717         return 0;
1718 }
1719
1720 static void __exit acm_exit(void)
1721 {
1722         usb_deregister(&acm_driver);
1723         tty_unregister_driver(acm_tty_driver);
1724         put_tty_driver(acm_tty_driver);
1725 }
1726
1727 module_init(acm_init);
1728 module_exit(acm_exit);
1729
1730 MODULE_AUTHOR(DRIVER_AUTHOR);
1731 MODULE_DESCRIPTION(DRIVER_DESC);
1732 MODULE_LICENSE("GPL");
1733 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);