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