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