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