drivers/usb/class/cdc-acm.c

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