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