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         if (!urb->actual_length)
 414                 return;
 415
 416         tty_insert_flip_string(&acm->port, urb->transfer_buffer,
 417                         urb->actual_length);
 418         tty_flip_buffer_push(&acm->port);
 419 }
 420
 421 static void acm_read_bulk_callback(struct urb *urb)
 422 {
 423         struct acm_rb *rb = urb->context;
 424         struct acm *acm = rb->instance;
 425         unsigned long flags;
 426
 427         dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
 428                                         rb->index, urb->actual_length);
 429         set_bit(rb->index, &acm->read_urbs_free);
 430
 431         if (!acm->dev) {
 432                 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
 433                 return;
 434         }
 435         usb_mark_last_busy(acm->dev);
 436
 437         if (urb->status) {
 438                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
 439                                                         __func__, urb->status);
 440                 return;
 441         }
 442         acm_process_read_urb(acm, urb);
 443
 444         /* throttle device if requested by tty */
 445         spin_lock_irqsave(&acm->read_lock, flags);
 446         acm->throttled = acm->throttle_req;
 447         if (!acm->throttled && !acm->susp_count) {
 448                 spin_unlock_irqrestore(&acm->read_lock, flags);
 449                 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
 450         } else {
 451                 spin_unlock_irqrestore(&acm->read_lock, flags);
 452         }
 453 }
 454
 455 /* data interface wrote those outgoing bytes */
 456 static void acm_write_bulk(struct urb *urb)
 457 {
 458         struct acm_wb *wb = urb->context;
 459         struct acm *acm = wb->instance;
 460         unsigned long flags;
 461
 462         if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
 463                 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
 464                         __func__,
 465                         urb->actual_length,
 466                         urb->transfer_buffer_length,
 467                         urb->status);
 468
 469         spin_lock_irqsave(&acm->write_lock, flags);
 470         acm_write_done(acm, wb);
 471         spin_unlock_irqrestore(&acm->write_lock, flags);
 472         schedule_work(&acm->work);
 473 }
 474
 475 static void acm_softint(struct work_struct *work)
 476 {
 477         struct acm *acm = container_of(work, struct acm, work);
 478         struct tty_struct *tty;
 479
 480         dev_vdbg(&acm->data->dev, "%s\n", __func__);
 481
 482         tty = tty_port_tty_get(&acm->port);
 483         if (!tty)
 484                 return;
 485         tty_wakeup(tty);
 486         tty_kref_put(tty);
 487 }
 488
 489 /*
 490  * TTY handlers
 491  */
 492
 493 static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 494 {
 495         struct acm *acm;
 496         int retval;
 497
 498         dev_dbg(tty->dev, "%s\n", __func__);
 499
 500         acm = acm_get_by_index(tty->index);
 501         if (!acm)
 502                 return -ENODEV;
 503
 504         retval = tty_standard_install(driver, tty);
 505         if (retval)
 506                 goto error_init_termios;
 507
 508         tty->driver_data = acm;
 509
 510         return 0;
 511
 512 error_init_termios:
 513         tty_port_put(&acm->port);
 514         return retval;
 515 }
 516
 517 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 518 {
 519         struct acm *acm = tty->driver_data;
 520
 521         dev_dbg(tty->dev, "%s\n", __func__);
 522
 523         return tty_port_open(&acm->port, tty, filp);
 524 }
 525
 526 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 527 {
 528         struct acm *acm = container_of(port, struct acm, port);
 529         int retval = -ENODEV;
 530
 531         dev_dbg(&acm->control->dev, "%s\n", __func__);
 532
 533         mutex_lock(&acm->mutex);
 534         if (acm->disconnected)
 535                 goto disconnected;
 536
 537         retval = usb_autopm_get_interface(acm->control);
 538         if (retval)
 539                 goto error_get_interface;
 540
 541         /*
 542          * FIXME: Why do we need this? Allocating 64K of physically contiguous
 543          * memory is really nasty...
 544          */
 545         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 546         acm->control->needs_remote_wakeup = 1;
 547
 548         acm->ctrlurb->dev = acm->dev;
 549         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 550                 dev_err(&acm->control->dev,
 551                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 552                 goto error_submit_urb;
 553         }
 554
 555         acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
 556         if (acm_set_control(acm, acm->ctrlout) < 0 &&
 557             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 558                 goto error_set_control;
 559
 560         usb_autopm_put_interface(acm->control);
 561
 562         /*
 563          * Unthrottle device in case the TTY was closed while throttled.
 564          */
 565         spin_lock_irq(&acm->read_lock);
 566         acm->throttled = 0;
 567         acm->throttle_req = 0;
 568         spin_unlock_irq(&acm->read_lock);
 569
 570         if (acm_submit_read_urbs(acm, GFP_KERNEL))
 571                 goto error_submit_read_urbs;
 572
 573         mutex_unlock(&acm->mutex);
 574
 575         return 0;
 576
 577 error_submit_read_urbs:
 578         acm->ctrlout = 0;
 579         acm_set_control(acm, acm->ctrlout);
 580 error_set_control:
 581         usb_kill_urb(acm->ctrlurb);
 582 error_submit_urb:
 583         usb_autopm_put_interface(acm->control);
 584 error_get_interface:
 585 disconnected:
 586         mutex_unlock(&acm->mutex);
 587         return retval;
 588 }
 589
 590 static void acm_port_destruct(struct tty_port *port)
 591 {
 592         struct acm *acm = container_of(port, struct acm, port);
 593
 594         dev_dbg(&acm->control->dev, "%s\n", __func__);
 595
 596         tty_unregister_device(acm_tty_driver, acm->minor);
 597         acm_release_minor(acm);
 598         usb_put_intf(acm->control);
 599         kfree(acm->country_codes);
 600         kfree(acm);
 601 }
 602
 603 static void acm_port_shutdown(struct tty_port *port)
 604 {
 605         struct acm *acm = container_of(port, struct acm, port);
 606         int i;
 607
 608         dev_dbg(&acm->control->dev, "%s\n", __func__);
 609
 610         mutex_lock(&acm->mutex);
 611         if (!acm->disconnected) {
 612                 usb_autopm_get_interface(acm->control);
 613                 acm_set_control(acm, acm->ctrlout = 0);
 614                 usb_kill_urb(acm->ctrlurb);
 615                 for (i = 0; i < ACM_NW; i++)
 616                         usb_kill_urb(acm->wb[i].urb);
 617                 for (i = 0; i < acm->rx_buflimit; i++)
 618                         usb_kill_urb(acm->read_urbs[i]);
 619                 acm->control->needs_remote_wakeup = 0;
 620                 usb_autopm_put_interface(acm->control);
 621         }
 622         mutex_unlock(&acm->mutex);
 623 }
 624
 625 static void acm_tty_cleanup(struct tty_struct *tty)
 626 {
 627         struct acm *acm = tty->driver_data;
 628         dev_dbg(&acm->control->dev, "%s\n", __func__);
 629         tty_port_put(&acm->port);
 630 }
 631
 632 static void acm_tty_hangup(struct tty_struct *tty)
 633 {
 634         struct acm *acm = tty->driver_data;
 635         dev_dbg(&acm->control->dev, "%s\n", __func__);
 636         tty_port_hangup(&acm->port);
 637 }
 638
 639 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 640 {
 641         struct acm *acm = tty->driver_data;
 642         dev_dbg(&acm->control->dev, "%s\n", __func__);
 643         tty_port_close(&acm->port, tty, filp);
 644 }
 645
 646 static int acm_tty_write(struct tty_struct *tty,
 647                                         const unsigned char *buf, int count)
 648 {
 649         struct acm *acm = tty->driver_data;
 650         int stat;
 651         unsigned long flags;
 652         int wbn;
 653         struct acm_wb *wb;
 654
 655         if (!count)
 656                 return 0;
 657
 658         dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
 659
 660         spin_lock_irqsave(&acm->write_lock, flags);
 661         wbn = acm_wb_alloc(acm);
 662         if (wbn < 0) {
 663                 spin_unlock_irqrestore(&acm->write_lock, flags);
 664                 return 0;
 665         }
 666         wb = &acm->wb[wbn];
 667
 668         count = (count > acm->writesize) ? acm->writesize : count;
 669         dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
 670         memcpy(wb->buf, buf, count);
 671         wb->len = count;
 672         spin_unlock_irqrestore(&acm->write_lock, flags);
 673
 674         stat = acm_write_start(acm, wbn);
 675         if (stat < 0)
 676                 return stat;
 677         return count;
 678 }
 679
 680 static int acm_tty_write_room(struct tty_struct *tty)
 681 {
 682         struct acm *acm = tty->driver_data;
 683         /*
 684          * Do not let the line discipline to know that we have a reserve,
 685          * or it might get too enthusiastic.
 686          */
 687         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 688 }
 689
 690 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 691 {
 692         struct acm *acm = tty->driver_data;
 693         /*
 694          * if the device was unplugged then any remaining characters fell out
 695          * of the connector ;)
 696          */
 697         if (acm->disconnected)
 698                 return 0;
 699         /*
 700          * This is inaccurate (overcounts), but it works.
 701          */
 702         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 703 }
 704
 705 static void acm_tty_throttle(struct tty_struct *tty)
 706 {
 707         struct acm *acm = tty->driver_data;
 708
 709         spin_lock_irq(&acm->read_lock);
 710         acm->throttle_req = 1;
 711         spin_unlock_irq(&acm->read_lock);
 712 }
 713
 714 static void acm_tty_unthrottle(struct tty_struct *tty)
 715 {
 716         struct acm *acm = tty->driver_data;
 717         unsigned int was_throttled;
 718
 719         spin_lock_irq(&acm->read_lock);
 720         was_throttled = acm->throttled;
 721         acm->throttled = 0;
 722         acm->throttle_req = 0;
 723         spin_unlock_irq(&acm->read_lock);
 724
 725         if (was_throttled)
 726                 acm_submit_read_urbs(acm, GFP_KERNEL);
 727 }
 728
 729 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 730 {
 731         struct acm *acm = tty->driver_data;
 732         int retval;
 733
 734         retval = acm_send_break(acm, state ? 0xffff : 0);
 735         if (retval < 0)
 736                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
 737                                                                 __func__);
 738         return retval;
 739 }
 740
 741 static int acm_tty_tiocmget(struct tty_struct *tty)
 742 {
 743         struct acm *acm = tty->driver_data;
 744
 745         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 746                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 747                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 748                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 749                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 750                TIOCM_CTS;
 751 }
 752
 753 static int acm_tty_tiocmset(struct tty_struct *tty,
 754                             unsigned int set, unsigned int clear)
 755 {
 756         struct acm *acm = tty->driver_data;
 757         unsigned int newctrl;
 758
 759         newctrl = acm->ctrlout;
 760         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 761                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 762         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 763                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 764
 765         newctrl = (newctrl & ~clear) | set;
 766
 767         if (acm->ctrlout == newctrl)
 768                 return 0;
 769         return acm_set_control(acm, acm->ctrlout = newctrl);
 770 }
 771
 772 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
 773 {
 774         struct serial_struct tmp;
 775
 776         if (!info)
 777                 return -EINVAL;
 778
 779         memset(&tmp, 0, sizeof(tmp));
 780         tmp.flags = ASYNC_LOW_LATENCY;
 781         tmp.xmit_fifo_size = acm->writesize;
 782         tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
 783         tmp.close_delay = acm->port.close_delay / 10;
 784         tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 785                                 ASYNC_CLOSING_WAIT_NONE :
 786                                 acm->port.closing_wait / 10;
 787
 788         if (copy_to_user(info, &tmp, sizeof(tmp)))
 789                 return -EFAULT;
 790         else
 791                 return 0;
 792 }
 793
 794 static int set_serial_info(struct acm *acm,
 795                                 struct serial_struct __user *newinfo)
 796 {
 797         struct serial_struct new_serial;
 798         unsigned int closing_wait, close_delay;
 799         int retval = 0;
 800
 801         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
 802                 return -EFAULT;
 803
 804         close_delay = new_serial.close_delay * 10;
 805         closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 806                         ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
 807
 808         mutex_lock(&acm->port.mutex);
 809
 810         if (!capable(CAP_SYS_ADMIN)) {
 811                 if ((close_delay != acm->port.close_delay) ||
 812                     (closing_wait != acm->port.closing_wait))
 813                         retval = -EPERM;
 814                 else
 815                         retval = -EOPNOTSUPP;
 816         } else {
 817                 acm->port.close_delay  = close_delay;
 818                 acm->port.closing_wait = closing_wait;
 819         }
 820
 821         mutex_unlock(&acm->port.mutex);
 822         return retval;
 823 }
 824
 825 static int acm_tty_ioctl(struct tty_struct *tty,
 826                                         unsigned int cmd, unsigned long arg)
 827 {
 828         struct acm *acm = tty->driver_data;
 829         int rv = -ENOIOCTLCMD;
 830
 831         switch (cmd) {
 832         case TIOCGSERIAL: /* gets serial port data */
 833                 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
 834                 break;
 835         case TIOCSSERIAL:
 836                 rv = set_serial_info(acm, (struct serial_struct __user *) arg);
 837                 break;
 838         }
 839
 840         return rv;
 841 }
 842
 843 static const __u32 acm_tty_speed[] = {
 844         0, 50, 75, 110, 134, 150, 200, 300, 600,
 845         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 846         57600, 115200, 230400, 460800, 500000, 576000,
 847         921600, 1000000, 1152000, 1500000, 2000000,
 848         2500000, 3000000, 3500000, 4000000
 849 };
 850
 851 static void acm_tty_set_termios(struct tty_struct *tty,
 852                                                 struct ktermios *termios_old)
 853 {
 854         struct acm *acm = tty->driver_data;
 855         struct ktermios *termios = &tty->termios;
 856         struct usb_cdc_line_coding newline;
 857         int newctrl = acm->ctrlout;
 858
 859         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 860         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 861         newline.bParityType = termios->c_cflag & PARENB ?
 862                                 (termios->c_cflag & PARODD ? 1 : 2) +
 863                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 864         switch (termios->c_cflag & CSIZE) {
 865         case CS5:
 866                 newline.bDataBits = 5;
 867                 break;
 868         case CS6:
 869                 newline.bDataBits = 6;
 870                 break;
 871         case CS7:
 872                 newline.bDataBits = 7;
 873                 break;
 874         case CS8:
 875         default:
 876                 newline.bDataBits = 8;
 877                 break;
 878         }
 879         /* FIXME: Needs to clear unsupported bits in the termios */
 880         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 881
 882         if (!newline.dwDTERate) {
 883                 newline.dwDTERate = acm->line.dwDTERate;
 884                 newctrl &= ~ACM_CTRL_DTR;
 885         } else
 886                 newctrl |=  ACM_CTRL_DTR;
 887
 888         if (newctrl != acm->ctrlout)
 889                 acm_set_control(acm, acm->ctrlout = newctrl);
 890
 891         if (memcmp(&acm->line, &newline, sizeof newline)) {
 892                 memcpy(&acm->line, &newline, sizeof newline);
 893                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 894                         __func__,
 895                         le32_to_cpu(newline.dwDTERate),
 896                         newline.bCharFormat, newline.bParityType,
 897                         newline.bDataBits);
 898                 acm_set_line(acm, &acm->line);
 899         }
 900 }
 901
 902 static const struct tty_port_operations acm_port_ops = {
 903         .shutdown = acm_port_shutdown,
 904         .activate = acm_port_activate,
 905         .destruct = acm_port_destruct,
 906 };
 907
 908 /*
 909  * USB probe and disconnect routines.
 910  */
 911
 912 /* Little helpers: write/read buffers free */
 913 static void acm_write_buffers_free(struct acm *acm)
 914 {
 915         int i;
 916         struct acm_wb *wb;
 917         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 918
 919         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 920                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 921 }
 922
 923 static void acm_read_buffers_free(struct acm *acm)
 924 {
 925         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 926         int i;
 927
 928         for (i = 0; i < acm->rx_buflimit; i++)
 929                 usb_free_coherent(usb_dev, acm->readsize,
 930                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
 931 }
 932
 933 /* Little helper: write buffers allocate */
 934 static int acm_write_buffers_alloc(struct acm *acm)
 935 {
 936         int i;
 937         struct acm_wb *wb;
 938
 939         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 940                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 941                     &wb->dmah);
 942                 if (!wb->buf) {
 943                         while (i != 0) {
 944                                 --i;
 945                                 --wb;
 946                                 usb_free_coherent(acm->dev, acm->writesize,
 947                                     wb->buf, wb->dmah);
 948                         }
 949                         return -ENOMEM;
 950                 }
 951         }
 952         return 0;
 953 }
 954
 955 static int acm_probe(struct usb_interface *intf,
 956                      const struct usb_device_id *id)
 957 {
 958         struct usb_cdc_union_desc *union_header = NULL;
 959         struct usb_cdc_country_functional_desc *cfd = NULL;
 960         unsigned char *buffer = intf->altsetting->extra;
 961         int buflen = intf->altsetting->extralen;
 962         struct usb_interface *control_interface;
 963         struct usb_interface *data_interface;
 964         struct usb_endpoint_descriptor *epctrl = NULL;
 965         struct usb_endpoint_descriptor *epread = NULL;
 966         struct usb_endpoint_descriptor *epwrite = NULL;
 967         struct usb_device *usb_dev = interface_to_usbdev(intf);
 968         struct acm *acm;
 969         int minor;
 970         int ctrlsize, readsize;
 971         u8 *buf;
 972         u8 ac_management_function = 0;
 973         u8 call_management_function = 0;
 974         int call_interface_num = -1;
 975         int data_interface_num = -1;
 976         unsigned long quirks;
 977         int num_rx_buf;
 978         int i;
 979         int combined_interfaces = 0;
 980
 981         /* normal quirks */
 982         quirks = (unsigned long)id->driver_info;
 983
 984         if (quirks == IGNORE_DEVICE)
 985                 return -ENODEV;
 986
 987         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 988
 989         /* handle quirks deadly to normal probing*/
 990         if (quirks == NO_UNION_NORMAL) {
 991                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 992                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 993                 goto skip_normal_probe;
 994         }
 995
 996         /* normal probing*/
 997         if (!buffer) {
 998                 dev_err(&intf->dev, "Weird descriptor references\n");
 999                 return -EINVAL;
1000         }
1001
1002         if (!buflen) {
1003                 if (intf->cur_altsetting->endpoint &&
1004                                 intf->cur_altsetting->endpoint->extralen &&
1005                                 intf->cur_altsetting->endpoint->extra) {
1006                         dev_dbg(&intf->dev,
1007                                 "Seeking extra descriptors on endpoint\n");
1008                         buflen = intf->cur_altsetting->endpoint->extralen;
1009                         buffer = intf->cur_altsetting->endpoint->extra;
1010                 } else {
1011                         dev_err(&intf->dev,
1012                                 "Zero length descriptor references\n");
1013                         return -EINVAL;
1014                 }
1015         }
1016
1017         while (buflen > 0) {
1018                 if (buffer[1] != USB_DT_CS_INTERFACE) {
1019                         dev_err(&intf->dev, "skipping garbage\n");
1020                         goto next_desc;
1021                 }
1022
1023                 switch (buffer[2]) {
1024                 case USB_CDC_UNION_TYPE: /* we've found it */
1025                         if (union_header) {
1026                                 dev_err(&intf->dev, "More than one "
1027                                         "union descriptor, skipping ...\n");
1028                                 goto next_desc;
1029                         }
1030                         union_header = (struct usb_cdc_union_desc *)buffer;
1031                         break;
1032                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1033                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1034                         break;
1035                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1036                         break; /* for now we ignore it */
1037                 case USB_CDC_ACM_TYPE:
1038                         ac_management_function = buffer[3];
1039                         break;
1040                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1041                         call_management_function = buffer[3];
1042                         call_interface_num = buffer[4];
1043                         if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1044                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1045                         break;
1046                 default:
1047                         /* there are LOTS more CDC descriptors that
1048                          * could legitimately be found here.
1049                          */
1050                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1051                                         "type %02x, length %d\n",
1052                                         buffer[2], buffer[0]);
1053                         break;
1054                 }
1055 next_desc:
1056                 buflen -= buffer[0];
1057                 buffer += buffer[0];
1058         }
1059
1060         if (!union_header) {
1061                 if (call_interface_num > 0) {
1062                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1063                         /* quirks for Droids MuIn LCD */
1064                         if (quirks & NO_DATA_INTERFACE)
1065                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
1066                         else
1067                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1068                         control_interface = intf;
1069                 } else {
1070                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1071                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1072                                 return -ENODEV;
1073                         } else {
1074                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1075                                 combined_interfaces = 1;
1076                                 control_interface = data_interface = intf;
1077                                 goto look_for_collapsed_interface;
1078                         }
1079                 }
1080         } else {
1081                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1082                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1083                 if (!control_interface || !data_interface) {
1084                         dev_dbg(&intf->dev, "no interfaces\n");
1085                         return -ENODEV;
1086                 }
1087         }
1088
1089         if (data_interface_num != call_interface_num)
1090                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1091
1092         if (control_interface == data_interface) {
1093                 /* some broken devices designed for windows work this way */
1094                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1095                 combined_interfaces = 1;
1096                 /* a popular other OS doesn't use it */
1097                 quirks |= NO_CAP_LINE;
1098                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1099                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1100                         return -EINVAL;
1101                 }
1102 look_for_collapsed_interface:
1103                 for (i = 0; i < 3; i++) {
1104                         struct usb_endpoint_descriptor *ep;
1105                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1106
1107                         if (usb_endpoint_is_int_in(ep))
1108                                 epctrl = ep;
1109                         else if (usb_endpoint_is_bulk_out(ep))
1110                                 epwrite = ep;
1111                         else if (usb_endpoint_is_bulk_in(ep))
1112                                 epread = ep;
1113                         else
1114                                 return -EINVAL;
1115                 }
1116                 if (!epctrl || !epread || !epwrite)
1117                         return -ENODEV;
1118                 else
1119                         goto made_compressed_probe;
1120         }
1121
1122 skip_normal_probe:
1123
1124         /*workaround for switched interfaces */
1125         if (data_interface->cur_altsetting->desc.bInterfaceClass
1126                                                 != CDC_DATA_INTERFACE_TYPE) {
1127                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1128                                                 == CDC_DATA_INTERFACE_TYPE) {
1129                         struct usb_interface *t;
1130                         dev_dbg(&intf->dev,
1131                                 "Your device has switched interfaces.\n");
1132                         t = control_interface;
1133                         control_interface = data_interface;
1134                         data_interface = t;
1135                 } else {
1136                         return -EINVAL;
1137                 }
1138         }
1139
1140         /* Accept probe requests only for the control interface */
1141         if (!combined_interfaces && intf != control_interface)
1142                 return -ENODEV;
1143
1144         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1145                 /* valid in this context */
1146                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1147                 return -EBUSY;
1148         }
1149
1150
1151         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1152             control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1153                 return -EINVAL;
1154
1155         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1156         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1157         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1158
1159
1160         /* workaround for switched endpoints */
1161         if (!usb_endpoint_dir_in(epread)) {
1162                 /* descriptors are swapped */
1163                 struct usb_endpoint_descriptor *t;
1164                 dev_dbg(&intf->dev,
1165                         "The data interface has switched endpoints\n");
1166                 t = epread;
1167                 epread = epwrite;
1168                 epwrite = t;
1169         }
1170 made_compressed_probe:
1171         dev_dbg(&intf->dev, "interfaces are valid\n");
1172
1173         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1174         if (acm == NULL) {
1175                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1176                 goto alloc_fail;
1177         }
1178
1179         minor = acm_alloc_minor(acm);
1180         if (minor == ACM_TTY_MINORS) {
1181                 dev_err(&intf->dev, "no more free acm devices\n");
1182                 kfree(acm);
1183                 return -ENODEV;
1184         }
1185
1186         ctrlsize = usb_endpoint_maxp(epctrl);
1187         readsize = usb_endpoint_maxp(epread) *
1188                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1189         acm->combined_interfaces = combined_interfaces;
1190         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1191         acm->control = control_interface;
1192         acm->data = data_interface;
1193         acm->minor = minor;
1194         acm->dev = usb_dev;
1195         acm->ctrl_caps = ac_management_function;
1196         if (quirks & NO_CAP_LINE)
1197                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1198         acm->ctrlsize = ctrlsize;
1199         acm->readsize = readsize;
1200         acm->rx_buflimit = num_rx_buf;
1201         INIT_WORK(&acm->work, acm_softint);
1202         spin_lock_init(&acm->write_lock);
1203         spin_lock_init(&acm->read_lock);
1204         mutex_init(&acm->mutex);
1205         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1206         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1207         if (acm->is_int_ep)
1208                 acm->bInterval = epread->bInterval;
1209         tty_port_init(&acm->port);
1210         acm->port.ops = &acm_port_ops;
1211
1212         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1213         if (!buf) {
1214                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1215                 goto alloc_fail2;
1216         }
1217         acm->ctrl_buffer = buf;
1218
1219         if (acm_write_buffers_alloc(acm) < 0) {
1220                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1221                 goto alloc_fail4;
1222         }
1223
1224         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1225         if (!acm->ctrlurb) {
1226                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1227                 goto alloc_fail5;
1228         }
1229         for (i = 0; i < num_rx_buf; i++) {
1230                 struct acm_rb *rb = &(acm->read_buffers[i]);
1231                 struct urb *urb;
1232
1233                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1234                                                                 &rb->dma);
1235                 if (!rb->base) {
1236                         dev_err(&intf->dev, "out of memory "
1237                                         "(read bufs usb_alloc_coherent)\n");
1238                         goto alloc_fail6;
1239                 }
1240                 rb->index = i;
1241                 rb->instance = acm;
1242
1243                 urb = usb_alloc_urb(0, GFP_KERNEL);
1244                 if (!urb) {
1245                         dev_err(&intf->dev,
1246                                 "out of memory (read urbs usb_alloc_urb)\n");
1247                         goto alloc_fail6;
1248                 }
1249                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1250                 urb->transfer_dma = rb->dma;
1251                 if (acm->is_int_ep) {
1252                         usb_fill_int_urb(urb, acm->dev,
1253                                          acm->rx_endpoint,
1254                                          rb->base,
1255                                          acm->readsize,
1256                                          acm_read_bulk_callback, rb,
1257                                          acm->bInterval);
1258                 } else {
1259                         usb_fill_bulk_urb(urb, acm->dev,
1260                                           acm->rx_endpoint,
1261                                           rb->base,
1262                                           acm->readsize,
1263                                           acm_read_bulk_callback, rb);
1264                 }
1265
1266                 acm->read_urbs[i] = urb;
1267                 __set_bit(i, &acm->read_urbs_free);
1268         }
1269         for (i = 0; i < ACM_NW; i++) {
1270                 struct acm_wb *snd = &(acm->wb[i]);
1271
1272                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1273                 if (snd->urb == NULL) {
1274                         dev_err(&intf->dev,
1275                                 "out of memory (write urbs usb_alloc_urb)\n");
1276                         goto alloc_fail7;
1277                 }
1278
1279                 if (usb_endpoint_xfer_int(epwrite))
1280                         usb_fill_int_urb(snd->urb, usb_dev,
1281                                 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1282                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1283                 else
1284                         usb_fill_bulk_urb(snd->urb, usb_dev,
1285                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1286                                 NULL, acm->writesize, acm_write_bulk, snd);
1287                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288                 snd->instance = acm;
1289         }
1290
1291         usb_set_intfdata(intf, acm);
1292
1293         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1294         if (i < 0)
1295                 goto alloc_fail7;
1296
1297         if (cfd) { /* export the country data */
1298                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1299                 if (!acm->country_codes)
1300                         goto skip_countries;
1301                 acm->country_code_size = cfd->bLength - 4;
1302                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1303                                                         cfd->bLength - 4);
1304                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1305
1306                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1307                 if (i < 0) {
1308                         kfree(acm->country_codes);
1309                         acm->country_codes = NULL;
1310                         acm->country_code_size = 0;
1311                         goto skip_countries;
1312                 }
1313
1314                 i = device_create_file(&intf->dev,
1315                                                 &dev_attr_iCountryCodeRelDate);
1316                 if (i < 0) {
1317                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1318                         kfree(acm->country_codes);
1319                         acm->country_codes = NULL;
1320                         acm->country_code_size = 0;
1321                         goto skip_countries;
1322                 }
1323         }
1324
1325 skip_countries:
1326         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1327                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1328                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1329                          /* works around buggy devices */
1330                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1331         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1332         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1333
1334         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1335
1336         acm_set_control(acm, acm->ctrlout);
1337
1338         acm->line.dwDTERate = cpu_to_le32(9600);
1339         acm->line.bDataBits = 8;
1340         acm_set_line(acm, &acm->line);
1341
1342         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1343         usb_set_intfdata(data_interface, acm);
1344
1345         usb_get_intf(control_interface);
1346         tty_port_register_device(&acm->port, acm_tty_driver, minor,
1347                         &control_interface->dev);
1348
1349         return 0;
1350 alloc_fail7:
1351         for (i = 0; i < ACM_NW; i++)
1352                 usb_free_urb(acm->wb[i].urb);
1353 alloc_fail6:
1354         for (i = 0; i < num_rx_buf; i++)
1355                 usb_free_urb(acm->read_urbs[i]);
1356         acm_read_buffers_free(acm);
1357         usb_free_urb(acm->ctrlurb);
1358 alloc_fail5:
1359         acm_write_buffers_free(acm);
1360 alloc_fail4:
1361         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1362 alloc_fail2:
1363         acm_release_minor(acm);
1364         kfree(acm);
1365 alloc_fail:
1366         return -ENOMEM;
1367 }
1368
1369 static void stop_data_traffic(struct acm *acm)
1370 {
1371         int i;
1372
1373         dev_dbg(&acm->control->dev, "%s\n", __func__);
1374
1375         usb_kill_urb(acm->ctrlurb);
1376         for (i = 0; i < ACM_NW; i++)
1377                 usb_kill_urb(acm->wb[i].urb);
1378         for (i = 0; i < acm->rx_buflimit; i++)
1379                 usb_kill_urb(acm->read_urbs[i]);
1380
1381         cancel_work_sync(&acm->work);
1382 }
1383
1384 static void acm_disconnect(struct usb_interface *intf)
1385 {
1386         struct acm *acm = usb_get_intfdata(intf);
1387         struct usb_device *usb_dev = interface_to_usbdev(intf);
1388         struct tty_struct *tty;
1389         int i;
1390
1391         dev_dbg(&intf->dev, "%s\n", __func__);
1392
1393         /* sibling interface is already cleaning up */
1394         if (!acm)
1395                 return;
1396
1397         mutex_lock(&acm->mutex);
1398         acm->disconnected = true;
1399         if (acm->country_codes) {
1400                 device_remove_file(&acm->control->dev,
1401                                 &dev_attr_wCountryCodes);
1402                 device_remove_file(&acm->control->dev,
1403                                 &dev_attr_iCountryCodeRelDate);
1404         }
1405         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1406         usb_set_intfdata(acm->control, NULL);
1407         usb_set_intfdata(acm->data, NULL);
1408         mutex_unlock(&acm->mutex);
1409
1410         tty = tty_port_tty_get(&acm->port);
1411         if (tty) {
1412                 tty_vhangup(tty);
1413                 tty_kref_put(tty);
1414         }
1415
1416         stop_data_traffic(acm);
1417
1418         usb_free_urb(acm->ctrlurb);
1419         for (i = 0; i < ACM_NW; i++)
1420                 usb_free_urb(acm->wb[i].urb);
1421         for (i = 0; i < acm->rx_buflimit; i++)
1422                 usb_free_urb(acm->read_urbs[i]);
1423         acm_write_buffers_free(acm);
1424         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1425         acm_read_buffers_free(acm);
1426
1427         if (!acm->combined_interfaces)
1428                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1429                                         acm->data : acm->control);
1430
1431         tty_port_put(&acm->port);
1432 }
1433
1434 #ifdef CONFIG_PM
1435 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1436 {
1437         struct acm *acm = usb_get_intfdata(intf);
1438         int cnt;
1439
1440         if (PMSG_IS_AUTO(message)) {
1441                 int b;
1442
1443                 spin_lock_irq(&acm->write_lock);
1444                 b = acm->transmitting;
1445                 spin_unlock_irq(&acm->write_lock);
1446                 if (b)
1447                         return -EBUSY;
1448         }
1449
1450         spin_lock_irq(&acm->read_lock);
1451         spin_lock(&acm->write_lock);
1452         cnt = acm->susp_count++;
1453         spin_unlock(&acm->write_lock);
1454         spin_unlock_irq(&acm->read_lock);
1455
1456         if (cnt)
1457                 return 0;
1458
1459         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1460                 stop_data_traffic(acm);
1461
1462         return 0;
1463 }
1464
1465 static int acm_resume(struct usb_interface *intf)
1466 {
1467         struct acm *acm = usb_get_intfdata(intf);
1468         struct acm_wb *wb;
1469         int rv = 0;
1470         int cnt;
1471
1472         spin_lock_irq(&acm->read_lock);
1473         acm->susp_count -= 1;
1474         cnt = acm->susp_count;
1475         spin_unlock_irq(&acm->read_lock);
1476
1477         if (cnt)
1478                 return 0;
1479
1480         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1481                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1482
1483                 spin_lock_irq(&acm->write_lock);
1484                 if (acm->delayed_wb) {
1485                         wb = acm->delayed_wb;
1486                         acm->delayed_wb = NULL;
1487                         spin_unlock_irq(&acm->write_lock);
1488                         acm_start_wb(acm, wb);
1489                 } else {
1490                         spin_unlock_irq(&acm->write_lock);
1491                 }
1492
1493                 /*
1494                  * delayed error checking because we must
1495                  * do the write path at all cost
1496                  */
1497                 if (rv < 0)
1498                         goto err_out;
1499
1500                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1501         }
1502
1503 err_out:
1504         return rv;
1505 }
1506
1507 static int acm_reset_resume(struct usb_interface *intf)
1508 {
1509         struct acm *acm = usb_get_intfdata(intf);
1510         struct tty_struct *tty;
1511
1512         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1513                 tty = tty_port_tty_get(&acm->port);
1514                 if (tty) {
1515                         tty_hangup(tty);
1516                         tty_kref_put(tty);
1517                 }
1518         }
1519
1520         return acm_resume(intf);
1521 }
1522
1523 #endif /* CONFIG_PM */
1524
1525 #define NOKIA_PCSUITE_ACM_INFO(x) \
1526                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1527                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1528                 USB_CDC_ACM_PROTO_VENDOR)
1529
1530 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1531                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1532                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1533                 USB_CDC_ACM_PROTO_VENDOR)
1534
1535 /*
1536  * USB driver structure.
1537  */
1538
1539 static const struct usb_device_id acm_ids[] = {
1540         /* quirky and broken devices */
1541         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1542         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1543         },
1544         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1545         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1546         },
1547         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1548         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1549         },
1550         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1551         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1552         },
1553         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1554         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1555         },
1556         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1557         .driver_info = SINGLE_RX_URB,
1558         },
1559         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1560         .driver_info = SINGLE_RX_URB, /* firmware bug */
1561         },
1562         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1563         .driver_info = SINGLE_RX_URB, /* firmware bug */
1564         },
1565         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1566         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1567         },
1568         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1569         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1570         },
1571         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1572         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1573         },
1574         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1575         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1576         },
1577         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1578         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1579         },
1580         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1581         },
1582         /* Motorola H24 HSPA module: */
1583         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1584         { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1585         { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1586         { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1587         { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1588         { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1589         { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1590         { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1591
1592         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1593         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1594                                            data interface instead of
1595                                            communications interface.
1596                                            Maybe we should define a new
1597                                            quirk for this. */
1598         },
1599         { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1600         .driver_info = NO_UNION_NORMAL,
1601         },
1602         { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
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 #if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1692         { USB_DEVICE(0x04d8, 0x0082),   /* Application mode */
1693         .driver_info = IGNORE_DEVICE,
1694         },
1695         { USB_DEVICE(0x04d8, 0x0083),   /* Bootloader mode */
1696         .driver_info = IGNORE_DEVICE,
1697         },
1698 #endif
1699
1700         /* control interfaces without any protocol set */
1701         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1702                 USB_CDC_PROTO_NONE) },
1703
1704         /* control interfaces with various AT-command sets */
1705         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1706                 USB_CDC_ACM_PROTO_AT_V25TER) },
1707         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1708                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1709         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1710                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1711         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1712                 USB_CDC_ACM_PROTO_AT_GSM) },
1713         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1714                 USB_CDC_ACM_PROTO_AT_3G) },
1715         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1716                 USB_CDC_ACM_PROTO_AT_CDMA) },
1717
1718         { }
1719 };
1720
1721 MODULE_DEVICE_TABLE(usb, acm_ids);
1722
1723 static struct usb_driver acm_driver = {
1724         .name =         "cdc_acm",
1725         .probe =        acm_probe,
1726         .disconnect =   acm_disconnect,
1727 #ifdef CONFIG_PM
1728         .suspend =      acm_suspend,
1729         .resume =       acm_resume,
1730         .reset_resume = acm_reset_resume,
1731 #endif
1732         .id_table =     acm_ids,
1733 #ifdef CONFIG_PM
1734         .supports_autosuspend = 1,
1735 #endif
1736         .disable_hub_initiated_lpm = 1,
1737 };
1738
1739 /*
1740  * TTY driver structures.
1741  */
1742
1743 static const struct tty_operations acm_ops = {
1744         .install =              acm_tty_install,
1745         .open =                 acm_tty_open,
1746         .close =                acm_tty_close,
1747         .cleanup =              acm_tty_cleanup,
1748         .hangup =               acm_tty_hangup,
1749         .write =                acm_tty_write,
1750         .write_room =           acm_tty_write_room,
1751         .ioctl =                acm_tty_ioctl,
1752         .throttle =             acm_tty_throttle,
1753         .unthrottle =           acm_tty_unthrottle,
1754         .chars_in_buffer =      acm_tty_chars_in_buffer,
1755         .break_ctl =            acm_tty_break_ctl,
1756         .set_termios =          acm_tty_set_termios,
1757         .tiocmget =             acm_tty_tiocmget,
1758         .tiocmset =             acm_tty_tiocmset,
1759 };
1760
1761 /*
1762  * Init / exit.
1763  */
1764
1765 static int __init acm_init(void)
1766 {
1767         int retval;
1768         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1769         if (!acm_tty_driver)
1770                 return -ENOMEM;
1771         acm_tty_driver->driver_name = "acm",
1772         acm_tty_driver->name = "ttyACM",
1773         acm_tty_driver->major = ACM_TTY_MAJOR,
1774         acm_tty_driver->minor_start = 0,
1775         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1776         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1777         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1778         acm_tty_driver->init_termios = tty_std_termios;
1779         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1780                                                                 HUPCL | CLOCAL;
1781         tty_set_operations(acm_tty_driver, &acm_ops);
1782
1783         retval = tty_register_driver(acm_tty_driver);
1784         if (retval) {
1785                 put_tty_driver(acm_tty_driver);
1786                 return retval;
1787         }
1788
1789         retval = usb_register(&acm_driver);
1790         if (retval) {
1791                 tty_unregister_driver(acm_tty_driver);
1792                 put_tty_driver(acm_tty_driver);
1793                 return retval;
1794         }
1795
1796         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1797
1798         return 0;
1799 }
1800
1801 static void __exit acm_exit(void)
1802 {
1803         usb_deregister(&acm_driver);
1804         tty_unregister_driver(acm_tty_driver);
1805         put_tty_driver(acm_tty_driver);
1806 }
1807
1808 module_init(acm_init);
1809 module_exit(acm_exit);
1810
1811 MODULE_AUTHOR(DRIVER_AUTHOR);
1812 MODULE_DESCRIPTION(DRIVER_DESC);
1813 MODULE_LICENSE("GPL");
1814 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);