drivers/usb/class/cdc-acm.c

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