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