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