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@suse.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  * ChangeLog:
  16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  17  *      v0.10 - some more cleanups
  18  *      v0.11 - fixed flow control, read error doesn't stop reads
  19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  20  *      v0.13 - added termios, added hangup
  21  *      v0.14 - sized down struct acm
  22  *      v0.15 - fixed flow control again - characters could be lost
  23  *      v0.16 - added code for modems with swapped data and control interfaces
  24  *      v0.17 - added new style probing
  25  *      v0.18 - fixed new style probing for devices with more configurations
  26  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  27  *      v0.20 - switched to probing on interface (rather than device) class
  28  *      v0.21 - revert to probing on device for devices with multiple configs
  29  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  30  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  31  *      v0.23 - use softirq for rx processing, as needed by tty layer
  32  *      v0.24 - change probe method to evaluate CDC union descriptor
  33  *      v0.25 - downstream tasks paralelized to maximize throughput
  34  */
  35
  36 /*
  37  * This program is free software; you can redistribute it and/or modify
  38  * it under the terms of the GNU General Public License as published by
  39  * the Free Software Foundation; either version 2 of the License, or
  40  * (at your option) any later version.
  41  *
  42  * This program is distributed in the hope that it will be useful,
  43  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  44  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  45  * GNU General Public License for more details.
  46  *
  47  * You should have received a copy of the GNU General Public License
  48  * along with this program; if not, write to the Free Software
  49  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  50  */
  51
  52 #undef DEBUG
  53
  54 #include <linux/kernel.h>
  55 #include <linux/errno.h>
  56 #include <linux/init.h>
  57 #include <linux/slab.h>
  58 #include <linux/tty.h>
  59 #include <linux/tty_driver.h>
  60 #include <linux/tty_flip.h>
  61 #include <linux/module.h>
  62 #include <linux/smp_lock.h>
  63 #include <linux/mutex.h>
  64 #include <asm/uaccess.h>
  65 #include <linux/usb.h>
  66 #include <linux/usb/cdc.h>
  67 #include <asm/byteorder.h>
  68 #include <asm/unaligned.h>
  69 #include <linux/list.h>
  70
  71 #include "cdc-acm.h"
  72
  73 /*
  74  * Version Information
  75  */
  76 #define DRIVER_VERSION "v0.25"
  77 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  78 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  79
  80 static struct usb_driver acm_driver;
  81 static struct tty_driver *acm_tty_driver;
  82 static struct acm *acm_table[ACM_TTY_MINORS];
  83
  84 static DEFINE_MUTEX(open_mutex);
  85
  86 #define ACM_READY(acm)  (acm && acm->dev && acm->used)
  87
  88 /*
  89  * Functions for ACM control messages.
  90  */
  91
  92 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  93 {
  94         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  95                 request, USB_RT_ACM, value,
  96                 acm->control->altsetting[0].desc.bInterfaceNumber,
  97                 buf, len, 5000);
  98         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  99         return retval < 0 ? retval : 0;
 100 }
 101
 102 /* devices aren't required to support these requests.
 103  * the cdc acm descriptor tells whether they do...
 104  */
 105 #define acm_set_control(acm, control) \
 106         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 107 #define acm_set_line(acm, line) \
 108         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 109 #define acm_send_break(acm, ms) \
 110         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 111
 112 /*
 113  * Write buffer management.
 114  * All of these assume proper locks taken by the caller.
 115  */
 116
 117 static int acm_wb_alloc(struct acm *acm)
 118 {
 119         int i, wbn;
 120         struct acm_wb *wb;
 121
 122         wbn = acm->write_current;
 123         i = 0;
 124         for (;;) {
 125                 wb = &acm->wb[wbn];
 126                 if (!wb->use) {
 127                         wb->use = 1;
 128                         return wbn;
 129                 }
 130                 wbn = (wbn + 1) % ACM_NW;
 131                 if (++i >= ACM_NW)
 132                         return -1;
 133         }
 134 }
 135
 136 static void acm_wb_free(struct acm *acm, int wbn)
 137 {
 138         acm->wb[wbn].use = 0;
 139 }
 140
 141 static int acm_wb_is_avail(struct acm *acm)
 142 {
 143         int i, n;
 144
 145         n = ACM_NW;
 146         for (i = 0; i < ACM_NW; i++) {
 147                 n -= acm->wb[i].use;
 148         }
 149         return n;
 150 }
 151
 152 static inline int acm_wb_is_used(struct acm *acm, int wbn)
 153 {
 154         return acm->wb[wbn].use;
 155 }
 156
 157 /*
 158  * Finish write.
 159  */
 160 static void acm_write_done(struct acm *acm)
 161 {
 162         unsigned long flags;
 163         int wbn;
 164
 165         spin_lock_irqsave(&acm->write_lock, flags);
 166         acm->write_ready = 1;
 167         wbn = acm->write_current;
 168         acm_wb_free(acm, wbn);
 169         acm->write_current = (wbn + 1) % ACM_NW;
 170         spin_unlock_irqrestore(&acm->write_lock, flags);
 171 }
 172
 173 /*
 174  * Poke write.
 175  */
 176 static int acm_write_start(struct acm *acm)
 177 {
 178         unsigned long flags;
 179         int wbn;
 180         struct acm_wb *wb;
 181         int rc;
 182
 183         spin_lock_irqsave(&acm->write_lock, flags);
 184         if (!acm->dev) {
 185                 spin_unlock_irqrestore(&acm->write_lock, flags);
 186                 return -ENODEV;
 187         }
 188
 189         if (!acm->write_ready) {
 190                 spin_unlock_irqrestore(&acm->write_lock, flags);
 191                 return 0;       /* A white lie */
 192         }
 193
 194         wbn = acm->write_current;
 195         if (!acm_wb_is_used(acm, wbn)) {
 196                 spin_unlock_irqrestore(&acm->write_lock, flags);
 197                 return 0;
 198         }
 199         wb = &acm->wb[wbn];
 200
 201         acm->write_ready = 0;
 202         spin_unlock_irqrestore(&acm->write_lock, flags);
 203
 204         acm->writeurb->transfer_buffer = wb->buf;
 205         acm->writeurb->transfer_dma = wb->dmah;
 206         acm->writeurb->transfer_buffer_length = wb->len;
 207         acm->writeurb->dev = acm->dev;
 208
 209         if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
 210                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
 211                 acm_write_done(acm);
 212         }
 213         return rc;
 214 }
 215
 216 /*
 217  * Interrupt handlers for various ACM device responses
 218  */
 219
 220 /* control interface reports status changes with "interrupt" transfers */
 221 static void acm_ctrl_irq(struct urb *urb)
 222 {
 223         struct acm *acm = urb->context;
 224         struct usb_cdc_notification *dr = urb->transfer_buffer;
 225         unsigned char *data;
 226         int newctrl;
 227         int status;
 228
 229         switch (urb->status) {
 230         case 0:
 231                 /* success */
 232                 break;
 233         case -ECONNRESET:
 234         case -ENOENT:
 235         case -ESHUTDOWN:
 236                 /* this urb is terminated, clean up */
 237                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
 238                 return;
 239         default:
 240                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
 241                 goto exit;
 242         }
 243
 244         if (!ACM_READY(acm))
 245                 goto exit;
 246
 247         data = (unsigned char *)(dr + 1);
 248         switch (dr->bNotificationType) {
 249
 250                 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 251
 252                         dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 253                         break;
 254
 255                 case USB_CDC_NOTIFY_SERIAL_STATE:
 256
 257                         newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
 258
 259                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 260                                 dbg("calling hangup");
 261                                 tty_hangup(acm->tty);
 262                         }
 263
 264                         acm->ctrlin = newctrl;
 265
 266                         dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 267                                 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 268                                 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 269                                 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 270                                 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 271
 272                         break;
 273
 274                 default:
 275                         dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 276                                 dr->bNotificationType, dr->wIndex,
 277                                 dr->wLength, data[0], data[1]);
 278                         break;
 279         }
 280 exit:
 281         status = usb_submit_urb (urb, GFP_ATOMIC);
 282         if (status)
 283                 err ("%s - usb_submit_urb failed with result %d",
 284                      __FUNCTION__, status);
 285 }
 286
 287 /* data interface returns incoming bytes, or we got unthrottled */
 288 static void acm_read_bulk(struct urb *urb)
 289 {
 290         struct acm_rb *buf;
 291         struct acm_ru *rcv = urb->context;
 292         struct acm *acm = rcv->instance;
 293         int status = urb->status;
 294         dbg("Entering acm_read_bulk with status %d", urb->status);
 295
 296         if (!ACM_READY(acm))
 297                 return;
 298
 299         if (status)
 300                 dev_dbg(&acm->data->dev, "bulk rx status %d", status);
 301
 302         buf = rcv->buffer;
 303         buf->size = urb->actual_length;
 304
 305         if (likely(status == 0)) {
 306                 spin_lock(&acm->read_lock);
 307                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 308                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 309                 spin_unlock(&acm->read_lock);
 310         } else {
 311                 /* we drop the buffer due to an error */
 312                 spin_lock(&acm->read_lock);
 313                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 314                 list_add(&buf->list, &acm->spare_read_bufs);
 315                 spin_unlock(&acm->read_lock);
 316                 /* nevertheless the tasklet must be kicked unconditionally
 317                 so the queue cannot dry up */
 318         }
 319         tasklet_schedule(&acm->urb_task);
 320 }
 321
 322 static void acm_rx_tasklet(unsigned long _acm)
 323 {
 324         struct acm *acm = (void *)_acm;
 325         struct acm_rb *buf;
 326         struct tty_struct *tty = acm->tty;
 327         struct acm_ru *rcv;
 328         unsigned long flags;
 329         unsigned char throttled;
 330         dbg("Entering acm_rx_tasklet");
 331
 332         if (!ACM_READY(acm))
 333                 return;
 334
 335         spin_lock(&acm->throttle_lock);
 336         throttled = acm->throttle;
 337         spin_unlock(&acm->throttle_lock);
 338         if (throttled)
 339                 return;
 340
 341 next_buffer:
 342         spin_lock_irqsave(&acm->read_lock, flags);
 343         if (list_empty(&acm->filled_read_bufs)) {
 344                 spin_unlock_irqrestore(&acm->read_lock, flags);
 345                 goto urbs;
 346         }
 347         buf = list_entry(acm->filled_read_bufs.next,
 348                          struct acm_rb, list);
 349         list_del(&buf->list);
 350         spin_unlock_irqrestore(&acm->read_lock, flags);
 351
 352         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 353
 354         tty_buffer_request_room(tty, buf->size);
 355         spin_lock(&acm->throttle_lock);
 356         throttled = acm->throttle;
 357         spin_unlock(&acm->throttle_lock);
 358         if (!throttled)
 359                 tty_insert_flip_string(tty, buf->base, buf->size);
 360         tty_flip_buffer_push(tty);
 361
 362         if (throttled) {
 363                 dbg("Throttling noticed");
 364                 spin_lock_irqsave(&acm->read_lock, flags);
 365                 list_add(&buf->list, &acm->filled_read_bufs);
 366                 spin_unlock_irqrestore(&acm->read_lock, flags);
 367                 return;
 368         }
 369
 370         spin_lock_irqsave(&acm->read_lock, flags);
 371         list_add(&buf->list, &acm->spare_read_bufs);
 372         spin_unlock_irqrestore(&acm->read_lock, flags);
 373         goto next_buffer;
 374
 375 urbs:
 376         while (!list_empty(&acm->spare_read_bufs)) {
 377                 spin_lock_irqsave(&acm->read_lock, flags);
 378                 if (list_empty(&acm->spare_read_urbs)) {
 379                         spin_unlock_irqrestore(&acm->read_lock, flags);
 380                         return;
 381                 }
 382                 rcv = list_entry(acm->spare_read_urbs.next,
 383                                  struct acm_ru, list);
 384                 list_del(&rcv->list);
 385                 spin_unlock_irqrestore(&acm->read_lock, flags);
 386
 387                 buf = list_entry(acm->spare_read_bufs.next,
 388                                  struct acm_rb, list);
 389                 list_del(&buf->list);
 390
 391                 rcv->buffer = buf;
 392
 393                 usb_fill_bulk_urb(rcv->urb, acm->dev,
 394                                   acm->rx_endpoint,
 395                                   buf->base,
 396                                   acm->readsize,
 397                                   acm_read_bulk, rcv);
 398                 rcv->urb->transfer_dma = buf->dma;
 399                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 400
 401                 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 402
 403                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
 404                    free-urbs-pool and resubmited ASAP */
 405                 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 406                         list_add(&buf->list, &acm->spare_read_bufs);
 407                         spin_lock_irqsave(&acm->read_lock, flags);
 408                         list_add(&rcv->list, &acm->spare_read_urbs);
 409                         spin_unlock_irqrestore(&acm->read_lock, flags);
 410                         return;
 411                 }
 412         }
 413 }
 414
 415 /* data interface wrote those outgoing bytes */
 416 static void acm_write_bulk(struct urb *urb)
 417 {
 418         struct acm *acm = (struct acm *)urb->context;
 419
 420         dbg("Entering acm_write_bulk with status %d", urb->status);
 421
 422         acm_write_done(acm);
 423         acm_write_start(acm);
 424         if (ACM_READY(acm))
 425                 schedule_work(&acm->work);
 426 }
 427
 428 static void acm_softint(struct work_struct *work)
 429 {
 430         struct acm *acm = container_of(work, struct acm, work);
 431         dbg("Entering acm_softint.");
 432
 433         if (!ACM_READY(acm))
 434                 return;
 435         tty_wakeup(acm->tty);
 436 }
 437
 438 /*
 439  * TTY handlers
 440  */
 441
 442 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 443 {
 444         struct acm *acm;
 445         int rv = -EINVAL;
 446         int i;
 447         dbg("Entering acm_tty_open.");
 448
 449         mutex_lock(&open_mutex);
 450
 451         acm = acm_table[tty->index];
 452         if (!acm || !acm->dev)
 453                 goto err_out;
 454         else
 455                 rv = 0;
 456
 457         tty->driver_data = acm;
 458         acm->tty = tty;
 459
 460         /* force low_latency on so that our tty_push actually forces the data through,
 461            otherwise it is scheduled, and with high data rates data can get lost. */
 462         tty->low_latency = 1;
 463
 464         if (acm->used++) {
 465                 goto done;
 466         }
 467
 468         acm->ctrlurb->dev = acm->dev;
 469         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 470                 dbg("usb_submit_urb(ctrl irq) failed");
 471                 goto bail_out;
 472         }
 473
 474         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 475             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 476                 goto full_bailout;
 477
 478         INIT_LIST_HEAD(&acm->spare_read_urbs);
 479         INIT_LIST_HEAD(&acm->spare_read_bufs);
 480         INIT_LIST_HEAD(&acm->filled_read_bufs);
 481         for (i = 0; i < acm->rx_buflimit; i++) {
 482                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 483         }
 484         for (i = 0; i < acm->rx_buflimit; i++) {
 485                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 486         }
 487
 488         acm->throttle = 0;
 489
 490         tasklet_schedule(&acm->urb_task);
 491
 492 done:
 493 err_out:
 494         mutex_unlock(&open_mutex);
 495         return rv;
 496
 497 full_bailout:
 498         usb_kill_urb(acm->ctrlurb);
 499 bail_out:
 500         acm->used--;
 501         mutex_unlock(&open_mutex);
 502         return -EIO;
 503 }
 504
 505 static void acm_tty_unregister(struct acm *acm)
 506 {
 507         int i,nr;
 508
 509         nr = acm->rx_buflimit;
 510         tty_unregister_device(acm_tty_driver, acm->minor);
 511         usb_put_intf(acm->control);
 512         acm_table[acm->minor] = NULL;
 513         usb_free_urb(acm->ctrlurb);
 514         usb_free_urb(acm->writeurb);
 515         for (i = 0; i < nr; i++)
 516                 usb_free_urb(acm->ru[i].urb);
 517         kfree(acm);
 518 }
 519
 520 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 521 {
 522         struct acm *acm = tty->driver_data;
 523         int i,nr;
 524
 525         if (!acm || !acm->used)
 526                 return;
 527
 528         nr = acm->rx_buflimit;
 529         mutex_lock(&open_mutex);
 530         if (!--acm->used) {
 531                 if (acm->dev) {
 532                         acm_set_control(acm, acm->ctrlout = 0);
 533                         usb_kill_urb(acm->ctrlurb);
 534                         usb_kill_urb(acm->writeurb);
 535                         for (i = 0; i < nr; i++)
 536                                 usb_kill_urb(acm->ru[i].urb);
 537                 } else
 538                         acm_tty_unregister(acm);
 539         }
 540         mutex_unlock(&open_mutex);
 541 }
 542
 543 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 544 {
 545         struct acm *acm = tty->driver_data;
 546         int stat;
 547         unsigned long flags;
 548         int wbn;
 549         struct acm_wb *wb;
 550
 551         dbg("Entering acm_tty_write to write %d bytes,", count);
 552
 553         if (!ACM_READY(acm))
 554                 return -EINVAL;
 555         if (!count)
 556                 return 0;
 557
 558         spin_lock_irqsave(&acm->write_lock, flags);
 559         if ((wbn = acm_wb_alloc(acm)) < 0) {
 560                 spin_unlock_irqrestore(&acm->write_lock, flags);
 561                 acm_write_start(acm);
 562                 return 0;
 563         }
 564         wb = &acm->wb[wbn];
 565
 566         count = (count > acm->writesize) ? acm->writesize : count;
 567         dbg("Get %d bytes...", count);
 568         memcpy(wb->buf, buf, count);
 569         wb->len = count;
 570         spin_unlock_irqrestore(&acm->write_lock, flags);
 571
 572         if ((stat = acm_write_start(acm)) < 0)
 573                 return stat;
 574         return count;
 575 }
 576
 577 static int acm_tty_write_room(struct tty_struct *tty)
 578 {
 579         struct acm *acm = tty->driver_data;
 580         if (!ACM_READY(acm))
 581                 return -EINVAL;
 582         /*
 583          * Do not let the line discipline to know that we have a reserve,
 584          * or it might get too enthusiastic.
 585          */
 586         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 587 }
 588
 589 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 590 {
 591         struct acm *acm = tty->driver_data;
 592         if (!ACM_READY(acm))
 593                 return -EINVAL;
 594         /*
 595          * This is inaccurate (overcounts), but it works.
 596          */
 597         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 598 }
 599
 600 static void acm_tty_throttle(struct tty_struct *tty)
 601 {
 602         struct acm *acm = tty->driver_data;
 603         if (!ACM_READY(acm))
 604                 return;
 605         spin_lock_bh(&acm->throttle_lock);
 606         acm->throttle = 1;
 607         spin_unlock_bh(&acm->throttle_lock);
 608 }
 609
 610 static void acm_tty_unthrottle(struct tty_struct *tty)
 611 {
 612         struct acm *acm = tty->driver_data;
 613         if (!ACM_READY(acm))
 614                 return;
 615         spin_lock_bh(&acm->throttle_lock);
 616         acm->throttle = 0;
 617         spin_unlock_bh(&acm->throttle_lock);
 618         tasklet_schedule(&acm->urb_task);
 619 }
 620
 621 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 622 {
 623         struct acm *acm = tty->driver_data;
 624         if (!ACM_READY(acm))
 625                 return;
 626         if (acm_send_break(acm, state ? 0xffff : 0))
 627                 dbg("send break failed");
 628 }
 629
 630 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 631 {
 632         struct acm *acm = tty->driver_data;
 633
 634         if (!ACM_READY(acm))
 635                 return -EINVAL;
 636
 637         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 638                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 639                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 640                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 641                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 642                TIOCM_CTS;
 643 }
 644
 645 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 646                             unsigned int set, unsigned int clear)
 647 {
 648         struct acm *acm = tty->driver_data;
 649         unsigned int newctrl;
 650
 651         if (!ACM_READY(acm))
 652                 return -EINVAL;
 653
 654         newctrl = acm->ctrlout;
 655         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 656         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 657
 658         newctrl = (newctrl & ~clear) | set;
 659
 660         if (acm->ctrlout == newctrl)
 661                 return 0;
 662         return acm_set_control(acm, acm->ctrlout = newctrl);
 663 }
 664
 665 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 666 {
 667         struct acm *acm = tty->driver_data;
 668
 669         if (!ACM_READY(acm))
 670                 return -EINVAL;
 671
 672         return -ENOIOCTLCMD;
 673 }
 674
 675 static const __u32 acm_tty_speed[] = {
 676         0, 50, 75, 110, 134, 150, 200, 300, 600,
 677         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 678         57600, 115200, 230400, 460800, 500000, 576000,
 679         921600, 1000000, 1152000, 1500000, 2000000,
 680         2500000, 3000000, 3500000, 4000000
 681 };
 682
 683 static const __u8 acm_tty_size[] = {
 684         5, 6, 7, 8
 685 };
 686
 687 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 688 {
 689         struct acm *acm = tty->driver_data;
 690         struct ktermios *termios = tty->termios;
 691         struct usb_cdc_line_coding newline;
 692         int newctrl = acm->ctrlout;
 693
 694         if (!ACM_READY(acm))
 695                 return;
 696
 697         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 698                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 699         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 700         newline.bParityType = termios->c_cflag & PARENB ?
 701                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 702         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 703
 704         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 705
 706         if (!newline.dwDTERate) {
 707                 newline.dwDTERate = acm->line.dwDTERate;
 708                 newctrl &= ~ACM_CTRL_DTR;
 709         } else  newctrl |=  ACM_CTRL_DTR;
 710
 711         if (newctrl != acm->ctrlout)
 712                 acm_set_control(acm, acm->ctrlout = newctrl);
 713
 714         if (memcmp(&acm->line, &newline, sizeof newline)) {
 715                 memcpy(&acm->line, &newline, sizeof newline);
 716                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 717                         newline.bCharFormat, newline.bParityType,
 718                         newline.bDataBits);
 719                 acm_set_line(acm, &acm->line);
 720         }
 721 }
 722
 723 /*
 724  * USB probe and disconnect routines.
 725  */
 726
 727 /* Little helper: write buffers free */
 728 static void acm_write_buffers_free(struct acm *acm)
 729 {
 730         int i;
 731         struct acm_wb *wb;
 732
 733         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 734                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 735         }
 736 }
 737
 738 /* Little helper: write buffers allocate */
 739 static int acm_write_buffers_alloc(struct acm *acm)
 740 {
 741         int i;
 742         struct acm_wb *wb;
 743
 744         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 745                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 746                     &wb->dmah);
 747                 if (!wb->buf) {
 748                         while (i != 0) {
 749                                 --i;
 750                                 --wb;
 751                                 usb_buffer_free(acm->dev, acm->writesize,
 752                                     wb->buf, wb->dmah);
 753                         }
 754                         return -ENOMEM;
 755                 }
 756         }
 757         return 0;
 758 }
 759
 760 static int acm_probe (struct usb_interface *intf,
 761                       const struct usb_device_id *id)
 762 {
 763         struct usb_cdc_union_desc *union_header = NULL;
 764         char *buffer = intf->altsetting->extra;
 765         int buflen = intf->altsetting->extralen;
 766         struct usb_interface *control_interface;
 767         struct usb_interface *data_interface;
 768         struct usb_endpoint_descriptor *epctrl;
 769         struct usb_endpoint_descriptor *epread;
 770         struct usb_endpoint_descriptor *epwrite;
 771         struct usb_device *usb_dev = interface_to_usbdev(intf);
 772         struct acm *acm;
 773         int minor;
 774         int ctrlsize,readsize;
 775         u8 *buf;
 776         u8 ac_management_function = 0;
 777         u8 call_management_function = 0;
 778         int call_interface_num = -1;
 779         int data_interface_num;
 780         unsigned long quirks;
 781         int num_rx_buf;
 782         int i;
 783
 784         /* normal quirks */
 785         quirks = (unsigned long)id->driver_info;
 786         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 787
 788         /* handle quirks deadly to normal probing*/
 789         if (quirks == NO_UNION_NORMAL) {
 790                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 791                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 792                 goto skip_normal_probe;
 793         }
 794
 795         /* normal probing*/
 796         if (!buffer) {
 797                 err("Wierd descriptor references\n");
 798                 return -EINVAL;
 799         }
 800
 801         if (!buflen) {
 802                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 803                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
 804                         buflen = intf->cur_altsetting->endpoint->extralen;
 805                         buffer = intf->cur_altsetting->endpoint->extra;
 806                 } else {
 807                         err("Zero length descriptor references\n");
 808                         return -EINVAL;
 809                 }
 810         }
 811
 812         while (buflen > 0) {
 813                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 814                         err("skipping garbage\n");
 815                         goto next_desc;
 816                 }
 817
 818                 switch (buffer [2]) {
 819                         case USB_CDC_UNION_TYPE: /* we've found it */
 820                                 if (union_header) {
 821                                         err("More than one union descriptor, skipping ...");
 822                                         goto next_desc;
 823                                 }
 824                                 union_header = (struct usb_cdc_union_desc *)
 825                                                         buffer;
 826                                 break;
 827                         case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */
 828                                 break; /* for now we ignore it */
 829                         case USB_CDC_HEADER_TYPE: /* maybe check version */
 830                                 break; /* for now we ignore it */
 831                         case USB_CDC_ACM_TYPE:
 832                                 ac_management_function = buffer[3];
 833                                 break;
 834                         case USB_CDC_CALL_MANAGEMENT_TYPE:
 835                                 call_management_function = buffer[3];
 836                                 call_interface_num = buffer[4];
 837                                 if ((call_management_function & 3) != 3)
 838                                         err("This device cannot do calls on its own. It is no modem.");
 839                                 break;
 840
 841                         default:
 842                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 843                                 break;
 844                         }
 845 next_desc:
 846                 buflen -= buffer[0];
 847                 buffer += buffer[0];
 848         }
 849
 850         if (!union_header) {
 851                 if (call_interface_num > 0) {
 852                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
 853                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 854                         control_interface = intf;
 855                 } else {
 856                         dev_dbg(&intf->dev,"No union descriptor, giving up");
 857                         return -ENODEV;
 858                 }
 859         } else {
 860                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 861                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 862                 if (!control_interface || !data_interface) {
 863                         dev_dbg(&intf->dev,"no interfaces");
 864                         return -ENODEV;
 865                 }
 866         }
 867
 868         if (data_interface_num != call_interface_num)
 869                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
 870
 871 skip_normal_probe:
 872
 873         /*workaround for switched interfaces */
 874         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 875                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 876                         struct usb_interface *t;
 877                         dev_dbg(&intf->dev,"Your device has switched interfaces.");
 878
 879                         t = control_interface;
 880                         control_interface = data_interface;
 881                         data_interface = t;
 882                 } else {
 883                         return -EINVAL;
 884                 }
 885         }
 886
 887         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 888                 dev_dbg(&intf->dev,"The data interface isn't available");
 889                 return -EBUSY;
 890         }
 891
 892
 893         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 894                 return -EINVAL;
 895
 896         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 897         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 898         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 899
 900
 901         /* workaround for switched endpoints */
 902         if (!usb_endpoint_dir_in(epread)) {
 903                 /* descriptors are swapped */
 904                 struct usb_endpoint_descriptor *t;
 905                 dev_dbg(&intf->dev,"The data interface has switched endpoints");
 906
 907                 t = epread;
 908                 epread = epwrite;
 909                 epwrite = t;
 910         }
 911         dbg("interfaces are valid");
 912         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 913
 914         if (minor == ACM_TTY_MINORS) {
 915                 err("no more free acm devices");
 916                 return -ENODEV;
 917         }
 918
 919         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 920                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
 921                 goto alloc_fail;
 922         }
 923
 924         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 925         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 926         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 927         acm->control = control_interface;
 928         acm->data = data_interface;
 929         acm->minor = minor;
 930         acm->dev = usb_dev;
 931         acm->ctrl_caps = ac_management_function;
 932         acm->ctrlsize = ctrlsize;
 933         acm->readsize = readsize;
 934         acm->rx_buflimit = num_rx_buf;
 935         acm->urb_task.func = acm_rx_tasklet;
 936         acm->urb_task.data = (unsigned long) acm;
 937         INIT_WORK(&acm->work, acm_softint);
 938         spin_lock_init(&acm->throttle_lock);
 939         spin_lock_init(&acm->write_lock);
 940         spin_lock_init(&acm->read_lock);
 941         acm->write_ready = 1;
 942         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 943
 944         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 945         if (!buf) {
 946                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
 947                 goto alloc_fail2;
 948         }
 949         acm->ctrl_buffer = buf;
 950
 951         if (acm_write_buffers_alloc(acm) < 0) {
 952                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
 953                 goto alloc_fail4;
 954         }
 955
 956         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 957         if (!acm->ctrlurb) {
 958                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
 959                 goto alloc_fail5;
 960         }
 961         for (i = 0; i < num_rx_buf; i++) {
 962                 struct acm_ru *rcv = &(acm->ru[i]);
 963
 964                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 965                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
 966                         goto alloc_fail7;
 967                 }
 968
 969                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 970                 rcv->instance = acm;
 971         }
 972         for (i = 0; i < num_rx_buf; i++) {
 973                 struct acm_rb *buf = &(acm->rb[i]);
 974
 975                 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
 976                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
 977                         goto alloc_fail7;
 978                 }
 979         }
 980         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
 981         if (!acm->writeurb) {
 982                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
 983                 goto alloc_fail7;
 984         }
 985
 986         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 987                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 988         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 989         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 990
 991         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 992                           NULL, acm->writesize, acm_write_bulk, acm);
 993         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 994
 995         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 996
 997         acm_set_control(acm, acm->ctrlout);
 998
 999         acm->line.dwDTERate = cpu_to_le32(9600);
1000         acm->line.bDataBits = 8;
1001         acm_set_line(acm, &acm->line);
1002
1003         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1004
1005         usb_get_intf(control_interface);
1006         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1007
1008         acm_table[minor] = acm;
1009         usb_set_intfdata (intf, acm);
1010         return 0;
1011
1012 alloc_fail7:
1013         for (i = 0; i < num_rx_buf; i++)
1014                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1015         for (i = 0; i < num_rx_buf; i++)
1016                 usb_free_urb(acm->ru[i].urb);
1017         usb_free_urb(acm->ctrlurb);
1018 alloc_fail5:
1019         acm_write_buffers_free(acm);
1020 alloc_fail4:
1021         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1022 alloc_fail2:
1023         kfree(acm);
1024 alloc_fail:
1025         return -ENOMEM;
1026 }
1027
1028 static void acm_disconnect(struct usb_interface *intf)
1029 {
1030         struct acm *acm = usb_get_intfdata (intf);
1031         struct usb_device *usb_dev = interface_to_usbdev(intf);
1032         int i;
1033
1034         if (!acm || !acm->dev) {
1035                 dbg("disconnect on nonexisting interface");
1036                 return;
1037         }
1038
1039         mutex_lock(&open_mutex);
1040         if (!usb_get_intfdata(intf)) {
1041                 mutex_unlock(&open_mutex);
1042                 return;
1043         }
1044         acm->dev = NULL;
1045         usb_set_intfdata(acm->control, NULL);
1046         usb_set_intfdata(acm->data, NULL);
1047
1048         tasklet_disable(&acm->urb_task);
1049
1050         usb_kill_urb(acm->ctrlurb);
1051         usb_kill_urb(acm->writeurb);
1052         for (i = 0; i < acm->rx_buflimit; i++)
1053                 usb_kill_urb(acm->ru[i].urb);
1054
1055         INIT_LIST_HEAD(&acm->filled_read_bufs);
1056         INIT_LIST_HEAD(&acm->spare_read_bufs);
1057
1058         tasklet_enable(&acm->urb_task);
1059
1060         flush_scheduled_work(); /* wait for acm_softint */
1061
1062         acm_write_buffers_free(acm);
1063         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1064         for (i = 0; i < acm->rx_buflimit; i++)
1065                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1066
1067         usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1068
1069         if (!acm->used) {
1070                 acm_tty_unregister(acm);
1071                 mutex_unlock(&open_mutex);
1072                 return;
1073         }
1074
1075         mutex_unlock(&open_mutex);
1076
1077         if (acm->tty)
1078                 tty_hangup(acm->tty);
1079 }
1080
1081 /*
1082  * USB driver structure.
1083  */
1084
1085 static struct usb_device_id acm_ids[] = {
1086         /* quirky and broken devices */
1087         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1088         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1089         },
1090         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1091         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1092         },
1093         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1094         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1095         },
1096         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1097         .driver_info = SINGLE_RX_URB, /* firmware bug */
1098         },
1099         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1100         .driver_info = SINGLE_RX_URB, /* firmware bug */
1101         },
1102         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1103         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1104         },
1105
1106         /* control interfaces with various AT-command sets */
1107         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1108                 USB_CDC_ACM_PROTO_AT_V25TER) },
1109         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1110                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1111         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1112                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1113         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1114                 USB_CDC_ACM_PROTO_AT_GSM) },
1115         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1116                 USB_CDC_ACM_PROTO_AT_3G ) },
1117         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1118                 USB_CDC_ACM_PROTO_AT_CDMA) },
1119
1120         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1121         { }
1122 };
1123
1124 MODULE_DEVICE_TABLE (usb, acm_ids);
1125
1126 static struct usb_driver acm_driver = {
1127         .name =         "cdc_acm",
1128         .probe =        acm_probe,
1129         .disconnect =   acm_disconnect,
1130         .id_table =     acm_ids,
1131 };
1132
1133 /*
1134  * TTY driver structures.
1135  */
1136
1137 static const struct tty_operations acm_ops = {
1138         .open =                 acm_tty_open,
1139         .close =                acm_tty_close,
1140         .write =                acm_tty_write,
1141         .write_room =           acm_tty_write_room,
1142         .ioctl =                acm_tty_ioctl,
1143         .throttle =             acm_tty_throttle,
1144         .unthrottle =           acm_tty_unthrottle,
1145         .chars_in_buffer =      acm_tty_chars_in_buffer,
1146         .break_ctl =            acm_tty_break_ctl,
1147         .set_termios =          acm_tty_set_termios,
1148         .tiocmget =             acm_tty_tiocmget,
1149         .tiocmset =             acm_tty_tiocmset,
1150 };
1151
1152 /*
1153  * Init / exit.
1154  */
1155
1156 static int __init acm_init(void)
1157 {
1158         int retval;
1159         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1160         if (!acm_tty_driver)
1161                 return -ENOMEM;
1162         acm_tty_driver->owner = THIS_MODULE,
1163         acm_tty_driver->driver_name = "acm",
1164         acm_tty_driver->name = "ttyACM",
1165         acm_tty_driver->major = ACM_TTY_MAJOR,
1166         acm_tty_driver->minor_start = 0,
1167         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1168         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1169         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1170         acm_tty_driver->init_termios = tty_std_termios;
1171         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1172         tty_set_operations(acm_tty_driver, &acm_ops);
1173
1174         retval = tty_register_driver(acm_tty_driver);
1175         if (retval) {
1176                 put_tty_driver(acm_tty_driver);
1177                 return retval;
1178         }
1179
1180         retval = usb_register(&acm_driver);
1181         if (retval) {
1182                 tty_unregister_driver(acm_tty_driver);
1183                 put_tty_driver(acm_tty_driver);
1184                 return retval;
1185         }
1186
1187         info(DRIVER_VERSION ":" DRIVER_DESC);
1188
1189         return 0;
1190 }
1191
1192 static void __exit acm_exit(void)
1193 {
1194         usb_deregister(&acm_driver);
1195         tty_unregister_driver(acm_tty_driver);
1196         put_tty_driver(acm_tty_driver);
1197 }
1198
1199 module_init(acm_init);
1200 module_exit(acm_exit);
1201
1202 MODULE_AUTHOR( DRIVER_AUTHOR );
1203 MODULE_DESCRIPTION( DRIVER_DESC );
1204 MODULE_LICENSE("GPL");
1205