drivers/usb/class/cdc-acm.c

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