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