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