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