Pileus Git - ~andy/linux/blob - 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
 791         if (copy_to_user(info, &tmp, sizeof(tmp)))
 792                 return -EFAULT;
 793         else
 794                 return 0;
 795 }
 796
 797 static int acm_tty_ioctl(struct tty_struct *tty,
 798                                         unsigned int cmd, unsigned long arg)
 799 {
 800         struct acm *acm = tty->driver_data;
 801         int rv = -ENOIOCTLCMD;
 802
 803         switch (cmd) {
 804         case TIOCGSERIAL: /* gets serial port data */
 805                 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
 806                 break;
 807         }
 808
 809         return rv;
 810 }
 811
 812 static const __u32 acm_tty_speed[] = {
 813         0, 50, 75, 110, 134, 150, 200, 300, 600,
 814         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 815         57600, 115200, 230400, 460800, 500000, 576000,
 816         921600, 1000000, 1152000, 1500000, 2000000,
 817         2500000, 3000000, 3500000, 4000000
 818 };
 819
 820 static void acm_tty_set_termios(struct tty_struct *tty,
 821                                                 struct ktermios *termios_old)
 822 {
 823         struct acm *acm = tty->driver_data;
 824         struct ktermios *termios = &tty->termios;
 825         struct usb_cdc_line_coding newline;
 826         int newctrl = acm->ctrlout;
 827
 828         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 829         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 830         newline.bParityType = termios->c_cflag & PARENB ?
 831                                 (termios->c_cflag & PARODD ? 1 : 2) +
 832                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 833         switch (termios->c_cflag & CSIZE) {
 834         case CS5:
 835                 newline.bDataBits = 5;
 836                 break;
 837         case CS6:
 838                 newline.bDataBits = 6;
 839                 break;
 840         case CS7:
 841                 newline.bDataBits = 7;
 842                 break;
 843         case CS8:
 844         default:
 845                 newline.bDataBits = 8;
 846                 break;
 847         }
 848         /* FIXME: Needs to clear unsupported bits in the termios */
 849         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 850
 851         if (!newline.dwDTERate) {
 852                 newline.dwDTERate = acm->line.dwDTERate;
 853                 newctrl &= ~ACM_CTRL_DTR;
 854         } else
 855                 newctrl |=  ACM_CTRL_DTR;
 856
 857         if (newctrl != acm->ctrlout)
 858                 acm_set_control(acm, acm->ctrlout = newctrl);
 859
 860         if (memcmp(&acm->line, &newline, sizeof newline)) {
 861                 memcpy(&acm->line, &newline, sizeof newline);
 862                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 863                         __func__,
 864                         le32_to_cpu(newline.dwDTERate),
 865                         newline.bCharFormat, newline.bParityType,
 866                         newline.bDataBits);
 867                 acm_set_line(acm, &acm->line);
 868         }
 869 }
 870
 871 static const struct tty_port_operations acm_port_ops = {
 872         .shutdown = acm_port_shutdown,
 873         .activate = acm_port_activate,
 874         .destruct = acm_port_destruct,
 875 };
 876
 877 /*
 878  * USB probe and disconnect routines.
 879  */
 880
 881 /* Little helpers: write/read buffers free */
 882 static void acm_write_buffers_free(struct acm *acm)
 883 {
 884         int i;
 885         struct acm_wb *wb;
 886         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 887
 888         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 889                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 890 }
 891
 892 static void acm_read_buffers_free(struct acm *acm)
 893 {
 894         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 895         int i;
 896
 897         for (i = 0; i < acm->rx_buflimit; i++)
 898                 usb_free_coherent(usb_dev, acm->readsize,
 899                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
 900 }
 901
 902 /* Little helper: write buffers allocate */
 903 static int acm_write_buffers_alloc(struct acm *acm)
 904 {
 905         int i;
 906         struct acm_wb *wb;
 907
 908         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 909                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 910                     &wb->dmah);
 911                 if (!wb->buf) {
 912                         while (i != 0) {
 913                                 --i;
 914                                 --wb;
 915                                 usb_free_coherent(acm->dev, acm->writesize,
 916                                     wb->buf, wb->dmah);
 917                         }
 918                         return -ENOMEM;
 919                 }
 920         }
 921         return 0;
 922 }
 923
 924 static int acm_probe(struct usb_interface *intf,
 925                      const struct usb_device_id *id)
 926 {
 927         struct usb_cdc_union_desc *union_header = NULL;
 928         struct usb_cdc_country_functional_desc *cfd = NULL;
 929         unsigned char *buffer = intf->altsetting->extra;
 930         int buflen = intf->altsetting->extralen;
 931         struct usb_interface *control_interface;
 932         struct usb_interface *data_interface;
 933         struct usb_endpoint_descriptor *epctrl = NULL;
 934         struct usb_endpoint_descriptor *epread = NULL;
 935         struct usb_endpoint_descriptor *epwrite = NULL;
 936         struct usb_device *usb_dev = interface_to_usbdev(intf);
 937         struct acm *acm;
 938         int minor;
 939         int ctrlsize, readsize;
 940         u8 *buf;
 941         u8 ac_management_function = 0;
 942         u8 call_management_function = 0;
 943         int call_interface_num = -1;
 944         int data_interface_num = -1;
 945         unsigned long quirks;
 946         int num_rx_buf;
 947         int i;
 948         int combined_interfaces = 0;
 949
 950         /* normal quirks */
 951         quirks = (unsigned long)id->driver_info;
 952
 953         if (quirks == IGNORE_DEVICE)
 954                 return -ENODEV;
 955
 956         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 957
 958         /* handle quirks deadly to normal probing*/
 959         if (quirks == NO_UNION_NORMAL) {
 960                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 961                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 962                 goto skip_normal_probe;
 963         }
 964
 965         /* normal probing*/
 966         if (!buffer) {
 967                 dev_err(&intf->dev, "Weird descriptor references\n");
 968                 return -EINVAL;
 969         }
 970
 971         if (!buflen) {
 972                 if (intf->cur_altsetting->endpoint &&
 973                                 intf->cur_altsetting->endpoint->extralen &&
 974                                 intf->cur_altsetting->endpoint->extra) {
 975                         dev_dbg(&intf->dev,
 976                                 "Seeking extra descriptors on endpoint\n");
 977                         buflen = intf->cur_altsetting->endpoint->extralen;
 978                         buffer = intf->cur_altsetting->endpoint->extra;
 979                 } else {
 980                         dev_err(&intf->dev,
 981                                 "Zero length descriptor references\n");
 982                         return -EINVAL;
 983                 }
 984         }
 985
 986         while (buflen > 0) {
 987                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 988                         dev_err(&intf->dev, "skipping garbage\n");
 989                         goto next_desc;
 990                 }
 991
 992                 switch (buffer[2]) {
 993                 case USB_CDC_UNION_TYPE: /* we've found it */
 994                         if (union_header) {
 995                                 dev_err(&intf->dev, "More than one "
 996                                         "union descriptor, skipping ...\n");
 997                                 goto next_desc;
 998                         }
 999                         union_header = (struct usb_cdc_union_desc *)buffer;
1000                         break;
1001                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1002                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1003                         break;
1004                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1005                         break; /* for now we ignore it */
1006                 case USB_CDC_ACM_TYPE:
1007                         ac_management_function = buffer[3];
1008                         break;
1009                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1010                         call_management_function = buffer[3];
1011                         call_interface_num = buffer[4];
1012                         if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1013                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1014                         break;
1015                 default:
1016                         /* there are LOTS more CDC descriptors that
1017                          * could legitimately be found here.
1018                          */
1019                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1020                                         "type %02x, length %d\n",
1021                                         buffer[2], buffer[0]);
1022                         break;
1023                 }
1024 next_desc:
1025                 buflen -= buffer[0];
1026                 buffer += buffer[0];
1027         }
1028
1029         if (!union_header) {
1030                 if (call_interface_num > 0) {
1031                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1032                         /* quirks for Droids MuIn LCD */
1033                         if (quirks & NO_DATA_INTERFACE)
1034                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
1035                         else
1036                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1037                         control_interface = intf;
1038                 } else {
1039                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1040                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1041                                 return -ENODEV;
1042                         } else {
1043                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1044                                 combined_interfaces = 1;
1045                                 control_interface = data_interface = intf;
1046                                 goto look_for_collapsed_interface;
1047                         }
1048                 }
1049         } else {
1050                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1051                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1052                 if (!control_interface || !data_interface) {
1053                         dev_dbg(&intf->dev, "no interfaces\n");
1054                         return -ENODEV;
1055                 }
1056         }
1057
1058         if (data_interface_num != call_interface_num)
1059                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1060
1061         if (control_interface == data_interface) {
1062                 /* some broken devices designed for windows work this way */
1063                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1064                 combined_interfaces = 1;
1065                 /* a popular other OS doesn't use it */
1066                 quirks |= NO_CAP_LINE;
1067                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1068                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1069                         return -EINVAL;
1070                 }
1071 look_for_collapsed_interface:
1072                 for (i = 0; i < 3; i++) {
1073                         struct usb_endpoint_descriptor *ep;
1074                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1075
1076                         if (usb_endpoint_is_int_in(ep))
1077                                 epctrl = ep;
1078                         else if (usb_endpoint_is_bulk_out(ep))
1079                                 epwrite = ep;
1080                         else if (usb_endpoint_is_bulk_in(ep))
1081                                 epread = ep;
1082                         else
1083                                 return -EINVAL;
1084                 }
1085                 if (!epctrl || !epread || !epwrite)
1086                         return -ENODEV;
1087                 else
1088                         goto made_compressed_probe;
1089         }
1090
1091 skip_normal_probe:
1092
1093         /*workaround for switched interfaces */
1094         if (data_interface->cur_altsetting->desc.bInterfaceClass
1095                                                 != CDC_DATA_INTERFACE_TYPE) {
1096                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1097                                                 == CDC_DATA_INTERFACE_TYPE) {
1098                         struct usb_interface *t;
1099                         dev_dbg(&intf->dev,
1100                                 "Your device has switched interfaces.\n");
1101                         t = control_interface;
1102                         control_interface = data_interface;
1103                         data_interface = t;
1104                 } else {
1105                         return -EINVAL;
1106                 }
1107         }
1108
1109         /* Accept probe requests only for the control interface */
1110         if (!combined_interfaces && intf != control_interface)
1111                 return -ENODEV;
1112
1113         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1114                 /* valid in this context */
1115                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1116                 return -EBUSY;
1117         }
1118
1119
1120         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1121             control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1122                 return -EINVAL;
1123
1124         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1125         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1126         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1127
1128
1129         /* workaround for switched endpoints */
1130         if (!usb_endpoint_dir_in(epread)) {
1131                 /* descriptors are swapped */
1132                 struct usb_endpoint_descriptor *t;
1133                 dev_dbg(&intf->dev,
1134                         "The data interface has switched endpoints\n");
1135                 t = epread;
1136                 epread = epwrite;
1137                 epwrite = t;
1138         }
1139 made_compressed_probe:
1140         dev_dbg(&intf->dev, "interfaces are valid\n");
1141
1142         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1143         if (acm == NULL) {
1144                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1145                 goto alloc_fail;
1146         }
1147
1148         minor = acm_alloc_minor(acm);
1149         if (minor == ACM_TTY_MINORS) {
1150                 dev_err(&intf->dev, "no more free acm devices\n");
1151                 kfree(acm);
1152                 return -ENODEV;
1153         }
1154
1155         ctrlsize = usb_endpoint_maxp(epctrl);
1156         readsize = usb_endpoint_maxp(epread) *
1157                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1158         acm->combined_interfaces = combined_interfaces;
1159         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1160         acm->control = control_interface;
1161         acm->data = data_interface;
1162         acm->minor = minor;
1163         acm->dev = usb_dev;
1164         acm->ctrl_caps = ac_management_function;
1165         if (quirks & NO_CAP_LINE)
1166                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1167         acm->ctrlsize = ctrlsize;
1168         acm->readsize = readsize;
1169         acm->rx_buflimit = num_rx_buf;
1170         INIT_WORK(&acm->work, acm_softint);
1171         spin_lock_init(&acm->write_lock);
1172         spin_lock_init(&acm->read_lock);
1173         mutex_init(&acm->mutex);
1174         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1175         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1176         if (acm->is_int_ep)
1177                 acm->bInterval = epread->bInterval;
1178         tty_port_init(&acm->port);
1179         acm->port.ops = &acm_port_ops;
1180
1181         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1182         if (!buf) {
1183                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1184                 goto alloc_fail2;
1185         }
1186         acm->ctrl_buffer = buf;
1187
1188         if (acm_write_buffers_alloc(acm) < 0) {
1189                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1190                 goto alloc_fail4;
1191         }
1192
1193         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1194         if (!acm->ctrlurb) {
1195                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1196                 goto alloc_fail5;
1197         }
1198         for (i = 0; i < num_rx_buf; i++) {
1199                 struct acm_rb *rb = &(acm->read_buffers[i]);
1200                 struct urb *urb;
1201
1202                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1203                                                                 &rb->dma);
1204                 if (!rb->base) {
1205                         dev_err(&intf->dev, "out of memory "
1206                                         "(read bufs usb_alloc_coherent)\n");
1207                         goto alloc_fail6;
1208                 }
1209                 rb->index = i;
1210                 rb->instance = acm;
1211
1212                 urb = usb_alloc_urb(0, GFP_KERNEL);
1213                 if (!urb) {
1214                         dev_err(&intf->dev,
1215                                 "out of memory (read urbs usb_alloc_urb)\n");
1216                         goto alloc_fail6;
1217                 }
1218                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1219                 urb->transfer_dma = rb->dma;
1220                 if (acm->is_int_ep) {
1221                         usb_fill_int_urb(urb, acm->dev,
1222                                          acm->rx_endpoint,
1223                                          rb->base,
1224                                          acm->readsize,
1225                                          acm_read_bulk_callback, rb,
1226                                          acm->bInterval);
1227                 } else {
1228                         usb_fill_bulk_urb(urb, acm->dev,
1229                                           acm->rx_endpoint,
1230                                           rb->base,
1231                                           acm->readsize,
1232                                           acm_read_bulk_callback, rb);
1233                 }
1234
1235                 acm->read_urbs[i] = urb;
1236                 __set_bit(i, &acm->read_urbs_free);
1237         }
1238         for (i = 0; i < ACM_NW; i++) {
1239                 struct acm_wb *snd = &(acm->wb[i]);
1240
1241                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1242                 if (snd->urb == NULL) {
1243                         dev_err(&intf->dev,
1244                                 "out of memory (write urbs usb_alloc_urb)\n");
1245                         goto alloc_fail7;
1246                 }
1247
1248                 if (usb_endpoint_xfer_int(epwrite))
1249                         usb_fill_int_urb(snd->urb, usb_dev,
1250                                 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1251                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1252                 else
1253                         usb_fill_bulk_urb(snd->urb, usb_dev,
1254                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1255                                 NULL, acm->writesize, acm_write_bulk, snd);
1256                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1257                 snd->instance = acm;
1258         }
1259
1260         usb_set_intfdata(intf, acm);
1261
1262         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1263         if (i < 0)
1264                 goto alloc_fail7;
1265
1266         if (cfd) { /* export the country data */
1267                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1268                 if (!acm->country_codes)
1269                         goto skip_countries;
1270                 acm->country_code_size = cfd->bLength - 4;
1271                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1272                                                         cfd->bLength - 4);
1273                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1274
1275                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1276                 if (i < 0) {
1277                         kfree(acm->country_codes);
1278                         acm->country_codes = NULL;
1279                         acm->country_code_size = 0;
1280                         goto skip_countries;
1281                 }
1282
1283                 i = device_create_file(&intf->dev,
1284                                                 &dev_attr_iCountryCodeRelDate);
1285                 if (i < 0) {
1286                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1287                         kfree(acm->country_codes);
1288                         acm->country_codes = NULL;
1289                         acm->country_code_size = 0;
1290                         goto skip_countries;
1291                 }
1292         }
1293
1294 skip_countries:
1295         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1296                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1297                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1298                          /* works around buggy devices */
1299                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1300         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1301         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1302
1303         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1304
1305         acm_set_control(acm, acm->ctrlout);
1306
1307         acm->line.dwDTERate = cpu_to_le32(9600);
1308         acm->line.bDataBits = 8;
1309         acm_set_line(acm, &acm->line);
1310
1311         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1312         usb_set_intfdata(data_interface, acm);
1313
1314         usb_get_intf(control_interface);
1315         tty_port_register_device(&acm->port, acm_tty_driver, minor,
1316                         &control_interface->dev);
1317
1318         return 0;
1319 alloc_fail7:
1320         for (i = 0; i < ACM_NW; i++)
1321                 usb_free_urb(acm->wb[i].urb);
1322 alloc_fail6:
1323         for (i = 0; i < num_rx_buf; i++)
1324                 usb_free_urb(acm->read_urbs[i]);
1325         acm_read_buffers_free(acm);
1326         usb_free_urb(acm->ctrlurb);
1327 alloc_fail5:
1328         acm_write_buffers_free(acm);
1329 alloc_fail4:
1330         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1331 alloc_fail2:
1332         acm_release_minor(acm);
1333         kfree(acm);
1334 alloc_fail:
1335         return -ENOMEM;
1336 }
1337
1338 static void stop_data_traffic(struct acm *acm)
1339 {
1340         int i;
1341
1342         dev_dbg(&acm->control->dev, "%s\n", __func__);
1343
1344         usb_kill_urb(acm->ctrlurb);
1345         for (i = 0; i < ACM_NW; i++)
1346                 usb_kill_urb(acm->wb[i].urb);
1347         for (i = 0; i < acm->rx_buflimit; i++)
1348                 usb_kill_urb(acm->read_urbs[i]);
1349
1350         cancel_work_sync(&acm->work);
1351 }
1352
1353 static void acm_disconnect(struct usb_interface *intf)
1354 {
1355         struct acm *acm = usb_get_intfdata(intf);
1356         struct usb_device *usb_dev = interface_to_usbdev(intf);
1357         struct tty_struct *tty;
1358         int i;
1359
1360         dev_dbg(&intf->dev, "%s\n", __func__);
1361
1362         /* sibling interface is already cleaning up */
1363         if (!acm)
1364                 return;
1365
1366         mutex_lock(&acm->mutex);
1367         acm->disconnected = true;
1368         if (acm->country_codes) {
1369                 device_remove_file(&acm->control->dev,
1370                                 &dev_attr_wCountryCodes);
1371                 device_remove_file(&acm->control->dev,
1372                                 &dev_attr_iCountryCodeRelDate);
1373         }
1374         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1375         usb_set_intfdata(acm->control, NULL);
1376         usb_set_intfdata(acm->data, NULL);
1377         mutex_unlock(&acm->mutex);
1378
1379         tty = tty_port_tty_get(&acm->port);
1380         if (tty) {
1381                 tty_vhangup(tty);
1382                 tty_kref_put(tty);
1383         }
1384
1385         stop_data_traffic(acm);
1386
1387         usb_free_urb(acm->ctrlurb);
1388         for (i = 0; i < ACM_NW; i++)
1389                 usb_free_urb(acm->wb[i].urb);
1390         for (i = 0; i < acm->rx_buflimit; i++)
1391                 usb_free_urb(acm->read_urbs[i]);
1392         acm_write_buffers_free(acm);
1393         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1394         acm_read_buffers_free(acm);
1395
1396         if (!acm->combined_interfaces)
1397                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1398                                         acm->data : acm->control);
1399
1400         tty_port_put(&acm->port);
1401 }
1402
1403 #ifdef CONFIG_PM
1404 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1405 {
1406         struct acm *acm = usb_get_intfdata(intf);
1407         int cnt;
1408
1409         if (PMSG_IS_AUTO(message)) {
1410                 int b;
1411
1412                 spin_lock_irq(&acm->write_lock);
1413                 b = acm->transmitting;
1414                 spin_unlock_irq(&acm->write_lock);
1415                 if (b)
1416                         return -EBUSY;
1417         }
1418
1419         spin_lock_irq(&acm->read_lock);
1420         spin_lock(&acm->write_lock);
1421         cnt = acm->susp_count++;
1422         spin_unlock(&acm->write_lock);
1423         spin_unlock_irq(&acm->read_lock);
1424
1425         if (cnt)
1426                 return 0;
1427
1428         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1429                 stop_data_traffic(acm);
1430
1431         return 0;
1432 }
1433
1434 static int acm_resume(struct usb_interface *intf)
1435 {
1436         struct acm *acm = usb_get_intfdata(intf);
1437         struct acm_wb *wb;
1438         int rv = 0;
1439         int cnt;
1440
1441         spin_lock_irq(&acm->read_lock);
1442         acm->susp_count -= 1;
1443         cnt = acm->susp_count;
1444         spin_unlock_irq(&acm->read_lock);
1445
1446         if (cnt)
1447                 return 0;
1448
1449         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1450                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1451
1452                 spin_lock_irq(&acm->write_lock);
1453                 if (acm->delayed_wb) {
1454                         wb = acm->delayed_wb;
1455                         acm->delayed_wb = NULL;
1456                         spin_unlock_irq(&acm->write_lock);
1457                         acm_start_wb(acm, wb);
1458                 } else {
1459                         spin_unlock_irq(&acm->write_lock);
1460                 }
1461
1462                 /*
1463                  * delayed error checking because we must
1464                  * do the write path at all cost
1465                  */
1466                 if (rv < 0)
1467                         goto err_out;
1468
1469                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1470         }
1471
1472 err_out:
1473         return rv;
1474 }
1475
1476 static int acm_reset_resume(struct usb_interface *intf)
1477 {
1478         struct acm *acm = usb_get_intfdata(intf);
1479         struct tty_struct *tty;
1480
1481         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1482                 tty = tty_port_tty_get(&acm->port);
1483                 if (tty) {
1484                         tty_hangup(tty);
1485                         tty_kref_put(tty);
1486                 }
1487         }
1488
1489         return acm_resume(intf);
1490 }
1491
1492 #endif /* CONFIG_PM */
1493
1494 #define NOKIA_PCSUITE_ACM_INFO(x) \
1495                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1496                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1497                 USB_CDC_ACM_PROTO_VENDOR)
1498
1499 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1500                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1501                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1502                 USB_CDC_ACM_PROTO_VENDOR)
1503
1504 /*
1505  * USB driver structure.
1506  */
1507
1508 static const struct usb_device_id acm_ids[] = {
1509         /* quirky and broken devices */
1510         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1511         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1512         },
1513         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1514         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1515         },
1516         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1517         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1518         },
1519         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1520         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1521         },
1522         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1523         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1524         },
1525         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1526         .driver_info = SINGLE_RX_URB,
1527         },
1528         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1529         .driver_info = SINGLE_RX_URB, /* firmware bug */
1530         },
1531         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1532         .driver_info = SINGLE_RX_URB, /* firmware bug */
1533         },
1534         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1535         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1536         },
1537         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1538         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1539         },
1540         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1541         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1542         },
1543         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1544         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1545         },
1546         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1547         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1548         },
1549         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1550         },
1551         /* Motorola H24 HSPA module: */
1552         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1553         { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1554         { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1555         { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1556         { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1557         { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1558         { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1559         { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1560
1561         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1562         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1563                                            data interface instead of
1564                                            communications interface.
1565                                            Maybe we should define a new
1566                                            quirk for this. */
1567         },
1568         { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1569         .driver_info = NO_UNION_NORMAL,
1570         },
1571         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1572         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1573         },
1574         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1575         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1576         },
1577
1578         /* Nokia S60 phones expose two ACM channels. The first is
1579          * a modem and is picked up by the standard AT-command
1580          * information below. The second is 'vendor-specific' but
1581          * is treated as a serial device at the S60 end, so we want
1582          * to expose it on Linux too. */
1583         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1584         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1585         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1586         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1588         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1589         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1592         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1594         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1595         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1596         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1597         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1598         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1599         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1600         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1601         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1602         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1603         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1604         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1605         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1606         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1607         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1608         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1609         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1610         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1611         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1612         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1613         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1614         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1615         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1616         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1617         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1618         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1619         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1620         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1621         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1622         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1623         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1624         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1625         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1626         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1627         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1628         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1629         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1630         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1631         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1632         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1633         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1634         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1635         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1636         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1637         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1638         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1639         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1640         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1641
1642         /* Support for Owen devices */
1643         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1644
1645         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1646
1647         /* Support Lego NXT using pbLua firmware */
1648         { USB_DEVICE(0x0694, 0xff00),
1649         .driver_info = NOT_A_MODEM,
1650         },
1651
1652         /* Support for Droids MuIn LCD */
1653         { USB_DEVICE(0x04d8, 0x000b),
1654         .driver_info = NO_DATA_INTERFACE,
1655         },
1656
1657 #if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1658         { USB_DEVICE(0x04d8, 0x0082),   /* Application mode */
1659         .driver_info = IGNORE_DEVICE,
1660         },
1661         { USB_DEVICE(0x04d8, 0x0083),   /* Bootloader mode */
1662         .driver_info = IGNORE_DEVICE,
1663         },
1664 #endif
1665
1666         /* control interfaces without any protocol set */
1667         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1668                 USB_CDC_PROTO_NONE) },
1669
1670         /* control interfaces with various AT-command sets */
1671         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1672                 USB_CDC_ACM_PROTO_AT_V25TER) },
1673         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1674                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1675         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1676                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1677         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1678                 USB_CDC_ACM_PROTO_AT_GSM) },
1679         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1680                 USB_CDC_ACM_PROTO_AT_3G) },
1681         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1682                 USB_CDC_ACM_PROTO_AT_CDMA) },
1683
1684         { }
1685 };
1686
1687 MODULE_DEVICE_TABLE(usb, acm_ids);
1688
1689 static struct usb_driver acm_driver = {
1690         .name =         "cdc_acm",
1691         .probe =        acm_probe,
1692         .disconnect =   acm_disconnect,
1693 #ifdef CONFIG_PM
1694         .suspend =      acm_suspend,
1695         .resume =       acm_resume,
1696         .reset_resume = acm_reset_resume,
1697 #endif
1698         .id_table =     acm_ids,
1699 #ifdef CONFIG_PM
1700         .supports_autosuspend = 1,
1701 #endif
1702         .disable_hub_initiated_lpm = 1,
1703 };
1704
1705 /*
1706  * TTY driver structures.
1707  */
1708
1709 static const struct tty_operations acm_ops = {
1710         .install =              acm_tty_install,
1711         .open =                 acm_tty_open,
1712         .close =                acm_tty_close,
1713         .cleanup =              acm_tty_cleanup,
1714         .hangup =               acm_tty_hangup,
1715         .write =                acm_tty_write,
1716         .write_room =           acm_tty_write_room,
1717         .ioctl =                acm_tty_ioctl,
1718         .throttle =             acm_tty_throttle,
1719         .unthrottle =           acm_tty_unthrottle,
1720         .chars_in_buffer =      acm_tty_chars_in_buffer,
1721         .break_ctl =            acm_tty_break_ctl,
1722         .set_termios =          acm_tty_set_termios,
1723         .tiocmget =             acm_tty_tiocmget,
1724         .tiocmset =             acm_tty_tiocmset,
1725 };
1726
1727 /*
1728  * Init / exit.
1729  */
1730
1731 static int __init acm_init(void)
1732 {
1733         int retval;
1734         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1735         if (!acm_tty_driver)
1736                 return -ENOMEM;
1737         acm_tty_driver->driver_name = "acm",
1738         acm_tty_driver->name = "ttyACM",
1739         acm_tty_driver->major = ACM_TTY_MAJOR,
1740         acm_tty_driver->minor_start = 0,
1741         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1742         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1743         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1744         acm_tty_driver->init_termios = tty_std_termios;
1745         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1746                                                                 HUPCL | CLOCAL;
1747         tty_set_operations(acm_tty_driver, &acm_ops);
1748
1749         retval = tty_register_driver(acm_tty_driver);
1750         if (retval) {
1751                 put_tty_driver(acm_tty_driver);
1752                 return retval;
1753         }
1754
1755         retval = usb_register(&acm_driver);
1756         if (retval) {
1757                 tty_unregister_driver(acm_tty_driver);
1758                 put_tty_driver(acm_tty_driver);
1759                 return retval;
1760         }
1761
1762         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1763
1764         return 0;
1765 }
1766
1767 static void __exit acm_exit(void)
1768 {
1769         usb_deregister(&acm_driver);
1770         tty_unregister_driver(acm_tty_driver);
1771         put_tty_driver(acm_tty_driver);
1772 }
1773
1774 module_init(acm_init);
1775 module_exit(acm_exit);
1776
1777 MODULE_AUTHOR(DRIVER_AUTHOR);
1778 MODULE_DESCRIPTION(DRIVER_DESC);
1779 MODULE_LICENSE("GPL");
1780 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);