git.oblomov.eu Git - linux-2.6/blob - drivers/usb/class/cdc-acm.c

   1 /*
   2  * cdc-acm.c
   3  *
   4  * Copyright (c) 1999 Armin Fuerst      <fuerst@in.tum.de>
   5  * Copyright (c) 1999 Pavel Machek      <pavel@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         int i = 0;
 330         dbg("Entering acm_rx_tasklet");
 331
 332         if (!ACM_READY(acm) || acm->throttle)
 333                 return;
 334
 335 next_buffer:
 336         spin_lock_irqsave(&acm->read_lock, flags);
 337         if (list_empty(&acm->filled_read_bufs)) {
 338                 spin_unlock_irqrestore(&acm->read_lock, flags);
 339                 goto urbs;
 340         }
 341         buf = list_entry(acm->filled_read_bufs.next,
 342                          struct acm_rb, list);
 343         list_del(&buf->list);
 344         spin_unlock_irqrestore(&acm->read_lock, flags);
 345
 346         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 347
 348         tty_buffer_request_room(tty, buf->size);
 349         if (!acm->throttle)
 350                 tty_insert_flip_string(tty, buf->base, buf->size);
 351         tty_flip_buffer_push(tty);
 352
 353         spin_lock(&acm->throttle_lock);
 354         if (acm->throttle) {
 355                 dbg("Throtteling noticed");
 356                 memmove(buf->base, buf->base + i, buf->size - i);
 357                 buf->size -= i;
 358                 spin_unlock(&acm->throttle_lock);
 359                 spin_lock_irqsave(&acm->read_lock, flags);
 360                 list_add(&buf->list, &acm->filled_read_bufs);
 361                 spin_unlock_irqrestore(&acm->read_lock, flags);
 362                 return;
 363         }
 364         spin_unlock(&acm->throttle_lock);
 365
 366         spin_lock_irqsave(&acm->read_lock, flags);
 367         list_add(&buf->list, &acm->spare_read_bufs);
 368         spin_unlock_irqrestore(&acm->read_lock, flags);
 369         goto next_buffer;
 370
 371 urbs:
 372         while (!list_empty(&acm->spare_read_bufs)) {
 373                 spin_lock_irqsave(&acm->read_lock, flags);
 374                 if (list_empty(&acm->spare_read_urbs)) {
 375                         spin_unlock_irqrestore(&acm->read_lock, flags);
 376                         return;
 377                 }
 378                 rcv = list_entry(acm->spare_read_urbs.next,
 379                                  struct acm_ru, list);
 380                 list_del(&rcv->list);
 381                 spin_unlock_irqrestore(&acm->read_lock, flags);
 382
 383                 buf = list_entry(acm->spare_read_bufs.next,
 384                                  struct acm_rb, list);
 385                 list_del(&buf->list);
 386
 387                 rcv->buffer = buf;
 388
 389                 usb_fill_bulk_urb(rcv->urb, acm->dev,
 390                                   acm->rx_endpoint,
 391                                   buf->base,
 392                                   acm->readsize,
 393                                   acm_read_bulk, rcv);
 394                 rcv->urb->transfer_dma = buf->dma;
 395                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 396
 397                 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 398
 399                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
 400                    free-urbs-pool and resubmited ASAP */
 401                 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 402                         list_add(&buf->list, &acm->spare_read_bufs);
 403                         spin_lock_irqsave(&acm->read_lock, flags);
 404                         list_add(&rcv->list, &acm->spare_read_urbs);
 405                         spin_unlock_irqrestore(&acm->read_lock, flags);
 406                         return;
 407                 }
 408         }
 409 }
 410
 411 /* data interface wrote those outgoing bytes */
 412 static void acm_write_bulk(struct urb *urb)
 413 {
 414         struct acm *acm = (struct acm *)urb->context;
 415
 416         dbg("Entering acm_write_bulk with status %d", urb->status);
 417
 418         acm_write_done(acm);
 419         acm_write_start(acm);
 420         if (ACM_READY(acm))
 421                 schedule_work(&acm->work);
 422 }
 423
 424 static void acm_softint(struct work_struct *work)
 425 {
 426         struct acm *acm = container_of(work, struct acm, work);
 427         dbg("Entering acm_softint.");
 428
 429         if (!ACM_READY(acm))
 430                 return;
 431         tty_wakeup(acm->tty);
 432 }
 433
 434 /*
 435  * TTY handlers
 436  */
 437
 438 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 439 {
 440         struct acm *acm;
 441         int rv = -EINVAL;
 442         int i;
 443         dbg("Entering acm_tty_open.");
 444
 445         mutex_lock(&open_mutex);
 446
 447         acm = acm_table[tty->index];
 448         if (!acm || !acm->dev)
 449                 goto err_out;
 450         else
 451                 rv = 0;
 452
 453         tty->driver_data = acm;
 454         acm->tty = tty;
 455
 456         /* force low_latency on so that our tty_push actually forces the data through,
 457            otherwise it is scheduled, and with high data rates data can get lost. */
 458         tty->low_latency = 1;
 459
 460         if (acm->used++) {
 461                 goto done;
 462         }
 463
 464         acm->ctrlurb->dev = acm->dev;
 465         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 466                 dbg("usb_submit_urb(ctrl irq) failed");
 467                 goto bail_out;
 468         }
 469
 470         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
 471                 goto full_bailout;
 472
 473         INIT_LIST_HEAD(&acm->spare_read_urbs);
 474         INIT_LIST_HEAD(&acm->spare_read_bufs);
 475         INIT_LIST_HEAD(&acm->filled_read_bufs);
 476         for (i = 0; i < acm->rx_buflimit; i++) {
 477                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 478         }
 479         for (i = 0; i < acm->rx_buflimit; i++) {
 480                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 481         }
 482
 483         tasklet_schedule(&acm->urb_task);
 484
 485 done:
 486 err_out:
 487         mutex_unlock(&open_mutex);
 488         return rv;
 489
 490 full_bailout:
 491         usb_kill_urb(acm->ctrlurb);
 492 bail_out:
 493         acm->used--;
 494         mutex_unlock(&open_mutex);
 495         return -EIO;
 496 }
 497
 498 static void acm_tty_unregister(struct acm *acm)
 499 {
 500         int i,nr;
 501
 502         nr = acm->rx_buflimit;
 503         tty_unregister_device(acm_tty_driver, acm->minor);
 504         usb_put_intf(acm->control);
 505         acm_table[acm->minor] = NULL;
 506         usb_free_urb(acm->ctrlurb);
 507         usb_free_urb(acm->writeurb);
 508         for (i = 0; i < nr; i++)
 509                 usb_free_urb(acm->ru[i].urb);
 510         kfree(acm);
 511 }
 512
 513 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 514 {
 515         struct acm *acm = tty->driver_data;
 516         int i,nr;
 517
 518         if (!acm || !acm->used)
 519                 return;
 520
 521         nr = acm->rx_buflimit;
 522         mutex_lock(&open_mutex);
 523         if (!--acm->used) {
 524                 if (acm->dev) {
 525                         acm_set_control(acm, acm->ctrlout = 0);
 526                         usb_kill_urb(acm->ctrlurb);
 527                         usb_kill_urb(acm->writeurb);
 528                         for (i = 0; i < nr; i++)
 529                                 usb_kill_urb(acm->ru[i].urb);
 530                 } else
 531                         acm_tty_unregister(acm);
 532         }
 533         mutex_unlock(&open_mutex);
 534 }
 535
 536 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 537 {
 538         struct acm *acm = tty->driver_data;
 539         int stat;
 540         unsigned long flags;
 541         int wbn;
 542         struct acm_wb *wb;
 543
 544         dbg("Entering acm_tty_write to write %d bytes,", count);
 545
 546         if (!ACM_READY(acm))
 547                 return -EINVAL;
 548         if (!count)
 549                 return 0;
 550
 551         spin_lock_irqsave(&acm->write_lock, flags);
 552         if ((wbn = acm_wb_alloc(acm)) < 0) {
 553                 spin_unlock_irqrestore(&acm->write_lock, flags);
 554                 acm_write_start(acm);
 555                 return 0;
 556         }
 557         wb = &acm->wb[wbn];
 558
 559         count = (count > acm->writesize) ? acm->writesize : count;
 560         dbg("Get %d bytes...", count);
 561         memcpy(wb->buf, buf, count);
 562         wb->len = count;
 563         spin_unlock_irqrestore(&acm->write_lock, flags);
 564
 565         if ((stat = acm_write_start(acm)) < 0)
 566                 return stat;
 567         return count;
 568 }
 569
 570 static int acm_tty_write_room(struct tty_struct *tty)
 571 {
 572         struct acm *acm = tty->driver_data;
 573         if (!ACM_READY(acm))
 574                 return -EINVAL;
 575         /*
 576          * Do not let the line discipline to know that we have a reserve,
 577          * or it might get too enthusiastic.
 578          */
 579         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 580 }
 581
 582 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 583 {
 584         struct acm *acm = tty->driver_data;
 585         if (!ACM_READY(acm))
 586                 return -EINVAL;
 587         /*
 588          * This is inaccurate (overcounts), but it works.
 589          */
 590         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 591 }
 592
 593 static void acm_tty_throttle(struct tty_struct *tty)
 594 {
 595         struct acm *acm = tty->driver_data;
 596         if (!ACM_READY(acm))
 597                 return;
 598         spin_lock_bh(&acm->throttle_lock);
 599         acm->throttle = 1;
 600         spin_unlock_bh(&acm->throttle_lock);
 601 }
 602
 603 static void acm_tty_unthrottle(struct tty_struct *tty)
 604 {
 605         struct acm *acm = tty->driver_data;
 606         if (!ACM_READY(acm))
 607                 return;
 608         spin_lock_bh(&acm->throttle_lock);
 609         acm->throttle = 0;
 610         spin_unlock_bh(&acm->throttle_lock);
 611         tasklet_schedule(&acm->urb_task);
 612 }
 613
 614 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 615 {
 616         struct acm *acm = tty->driver_data;
 617         if (!ACM_READY(acm))
 618                 return;
 619         if (acm_send_break(acm, state ? 0xffff : 0))
 620                 dbg("send break failed");
 621 }
 622
 623 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 624 {
 625         struct acm *acm = tty->driver_data;
 626
 627         if (!ACM_READY(acm))
 628                 return -EINVAL;
 629
 630         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 631                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 632                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 633                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 634                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 635                TIOCM_CTS;
 636 }
 637
 638 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 639                             unsigned int set, unsigned int clear)
 640 {
 641         struct acm *acm = tty->driver_data;
 642         unsigned int newctrl;
 643
 644         if (!ACM_READY(acm))
 645                 return -EINVAL;
 646
 647         newctrl = acm->ctrlout;
 648         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 649         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 650
 651         newctrl = (newctrl & ~clear) | set;
 652
 653         if (acm->ctrlout == newctrl)
 654                 return 0;
 655         return acm_set_control(acm, acm->ctrlout = newctrl);
 656 }
 657
 658 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 659 {
 660         struct acm *acm = tty->driver_data;
 661
 662         if (!ACM_READY(acm))
 663                 return -EINVAL;
 664
 665         return -ENOIOCTLCMD;
 666 }
 667
 668 static const __u32 acm_tty_speed[] = {
 669         0, 50, 75, 110, 134, 150, 200, 300, 600,
 670         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 671         57600, 115200, 230400, 460800, 500000, 576000,
 672         921600, 1000000, 1152000, 1500000, 2000000,
 673         2500000, 3000000, 3500000, 4000000
 674 };
 675
 676 static const __u8 acm_tty_size[] = {
 677         5, 6, 7, 8
 678 };
 679
 680 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 681 {
 682         struct acm *acm = tty->driver_data;
 683         struct ktermios *termios = tty->termios;
 684         struct usb_cdc_line_coding newline;
 685         int newctrl = acm->ctrlout;
 686
 687         if (!ACM_READY(acm))
 688                 return;
 689
 690         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 691                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 692         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 693         newline.bParityType = termios->c_cflag & PARENB ?
 694                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 695         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 696
 697         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 698
 699         if (!newline.dwDTERate) {
 700                 newline.dwDTERate = acm->line.dwDTERate;
 701                 newctrl &= ~ACM_CTRL_DTR;
 702         } else  newctrl |=  ACM_CTRL_DTR;
 703
 704         if (newctrl != acm->ctrlout)
 705                 acm_set_control(acm, acm->ctrlout = newctrl);
 706
 707         if (memcmp(&acm->line, &newline, sizeof newline)) {
 708                 memcpy(&acm->line, &newline, sizeof newline);
 709                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 710                         newline.bCharFormat, newline.bParityType,
 711                         newline.bDataBits);
 712                 acm_set_line(acm, &acm->line);
 713         }
 714 }
 715
 716 /*
 717  * USB probe and disconnect routines.
 718  */
 719
 720 /* Little helper: write buffers free */
 721 static void acm_write_buffers_free(struct acm *acm)
 722 {
 723         int i;
 724         struct acm_wb *wb;
 725
 726         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 727                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 728         }
 729 }
 730
 731 /* Little helper: write buffers allocate */
 732 static int acm_write_buffers_alloc(struct acm *acm)
 733 {
 734         int i;
 735         struct acm_wb *wb;
 736
 737         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 738                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 739                     &wb->dmah);
 740                 if (!wb->buf) {
 741                         while (i != 0) {
 742                                 --i;
 743                                 --wb;
 744                                 usb_buffer_free(acm->dev, acm->writesize,
 745                                     wb->buf, wb->dmah);
 746                         }
 747                         return -ENOMEM;
 748                 }
 749         }
 750         return 0;
 751 }
 752
 753 static int acm_probe (struct usb_interface *intf,
 754                       const struct usb_device_id *id)
 755 {
 756         struct usb_cdc_union_desc *union_header = NULL;
 757         char *buffer = intf->altsetting->extra;
 758         int buflen = intf->altsetting->extralen;
 759         struct usb_interface *control_interface;
 760         struct usb_interface *data_interface;
 761         struct usb_endpoint_descriptor *epctrl;
 762         struct usb_endpoint_descriptor *epread;
 763         struct usb_endpoint_descriptor *epwrite;
 764         struct usb_device *usb_dev = interface_to_usbdev(intf);
 765         struct acm *acm;
 766         int minor;
 767         int ctrlsize,readsize;
 768         u8 *buf;
 769         u8 ac_management_function = 0;
 770         u8 call_management_function = 0;
 771         int call_interface_num = -1;
 772         int data_interface_num;
 773         unsigned long quirks;
 774         int num_rx_buf;
 775         int i;
 776
 777         /* normal quirks */
 778         quirks = (unsigned long)id->driver_info;
 779         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 780
 781         /* handle quirks deadly to normal probing*/
 782         if (quirks == NO_UNION_NORMAL) {
 783                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 784                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 785                 goto skip_normal_probe;
 786         }
 787
 788         /* normal probing*/
 789         if (!buffer) {
 790                 err("Wierd descriptor references\n");
 791                 return -EINVAL;
 792         }
 793
 794         if (!buflen) {
 795                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 796                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
 797                         buflen = intf->cur_altsetting->endpoint->extralen;
 798                         buffer = intf->cur_altsetting->endpoint->extra;
 799                 } else {
 800                         err("Zero length descriptor references\n");
 801                         return -EINVAL;
 802                 }
 803         }
 804
 805         while (buflen > 0) {
 806                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 807                         err("skipping garbage\n");
 808                         goto next_desc;
 809                 }
 810
 811                 switch (buffer [2]) {
 812                         case USB_CDC_UNION_TYPE: /* we've found it */
 813                                 if (union_header) {
 814                                         err("More than one union descriptor, skipping ...");
 815                                         goto next_desc;
 816                                 }
 817                                 union_header = (struct usb_cdc_union_desc *)
 818                                                         buffer;
 819                                 break;
 820                         case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */
 821                                 break; /* for now we ignore it */
 822                         case USB_CDC_HEADER_TYPE: /* maybe check version */
 823                                 break; /* for now we ignore it */
 824                         case USB_CDC_ACM_TYPE:
 825                                 ac_management_function = buffer[3];
 826                                 break;
 827                         case USB_CDC_CALL_MANAGEMENT_TYPE:
 828                                 call_management_function = buffer[3];
 829                                 call_interface_num = buffer[4];
 830                                 if ((call_management_function & 3) != 3)
 831                                         err("This device cannot do calls on its own. It is no modem.");
 832                                 break;
 833
 834                         default:
 835                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 836                                 break;
 837                         }
 838 next_desc:
 839                 buflen -= buffer[0];
 840                 buffer += buffer[0];
 841         }
 842
 843         if (!union_header) {
 844                 if (call_interface_num > 0) {
 845                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
 846                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 847                         control_interface = intf;
 848                 } else {
 849                         dev_dbg(&intf->dev,"No union descriptor, giving up");
 850                         return -ENODEV;
 851                 }
 852         } else {
 853                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 854                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 855                 if (!control_interface || !data_interface) {
 856                         dev_dbg(&intf->dev,"no interfaces");
 857                         return -ENODEV;
 858                 }
 859         }
 860
 861         if (data_interface_num != call_interface_num)
 862                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
 863
 864 skip_normal_probe:
 865
 866         /*workaround for switched interfaces */
 867         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 868                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 869                         struct usb_interface *t;
 870                         dev_dbg(&intf->dev,"Your device has switched interfaces.");
 871
 872                         t = control_interface;
 873                         control_interface = data_interface;
 874                         data_interface = t;
 875                 } else {
 876                         return -EINVAL;
 877                 }
 878         }
 879
 880         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 881                 dev_dbg(&intf->dev,"The data interface isn't available");
 882                 return -EBUSY;
 883         }
 884
 885
 886         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 887                 return -EINVAL;
 888
 889         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 890         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 891         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 892
 893
 894         /* workaround for switched endpoints */
 895         if (!usb_endpoint_dir_in(epread)) {
 896                 /* descriptors are swapped */
 897                 struct usb_endpoint_descriptor *t;
 898                 dev_dbg(&intf->dev,"The data interface has switched endpoints");
 899
 900                 t = epread;
 901                 epread = epwrite;
 902                 epwrite = t;
 903         }
 904         dbg("interfaces are valid");
 905         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 906
 907         if (minor == ACM_TTY_MINORS) {
 908                 err("no more free acm devices");
 909                 return -ENODEV;
 910         }
 911
 912         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 913                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
 914                 goto alloc_fail;
 915         }
 916
 917         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 918         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 919         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 920         acm->control = control_interface;
 921         acm->data = data_interface;
 922         acm->minor = minor;
 923         acm->dev = usb_dev;
 924         acm->ctrl_caps = ac_management_function;
 925         acm->ctrlsize = ctrlsize;
 926         acm->readsize = readsize;
 927         acm->rx_buflimit = num_rx_buf;
 928         acm->urb_task.func = acm_rx_tasklet;
 929         acm->urb_task.data = (unsigned long) acm;
 930         INIT_WORK(&acm->work, acm_softint);
 931         spin_lock_init(&acm->throttle_lock);
 932         spin_lock_init(&acm->write_lock);
 933         spin_lock_init(&acm->read_lock);
 934         acm->write_ready = 1;
 935         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 936
 937         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 938         if (!buf) {
 939                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
 940                 goto alloc_fail2;
 941         }
 942         acm->ctrl_buffer = buf;
 943
 944         if (acm_write_buffers_alloc(acm) < 0) {
 945                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
 946                 goto alloc_fail4;
 947         }
 948
 949         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 950         if (!acm->ctrlurb) {
 951                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
 952                 goto alloc_fail5;
 953         }
 954         for (i = 0; i < num_rx_buf; i++) {
 955                 struct acm_ru *rcv = &(acm->ru[i]);
 956
 957                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 958                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
 959                         goto alloc_fail7;
 960                 }
 961
 962                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 963                 rcv->instance = acm;
 964         }
 965         for (i = 0; i < num_rx_buf; i++) {
 966                 struct acm_rb *buf = &(acm->rb[i]);
 967
 968                 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
 969                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
 970                         goto alloc_fail7;
 971                 }
 972         }
 973         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
 974         if (!acm->writeurb) {
 975                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
 976                 goto alloc_fail7;
 977         }
 978
 979         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 980                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 981         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 982         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 983
 984         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 985                           NULL, acm->writesize, acm_write_bulk, acm);
 986         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 987
 988         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 989
 990         acm_set_control(acm, acm->ctrlout);
 991
 992         acm->line.dwDTERate = cpu_to_le32(9600);
 993         acm->line.bDataBits = 8;
 994         acm_set_line(acm, &acm->line);
 995
 996         usb_driver_claim_interface(&acm_driver, data_interface, acm);
 997
 998         usb_get_intf(control_interface);
 999         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1000
1001         acm_table[minor] = acm;
1002         usb_set_intfdata (intf, acm);
1003         return 0;
1004
1005 alloc_fail7:
1006         for (i = 0; i < num_rx_buf; i++)
1007                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1008         for (i = 0; i < num_rx_buf; i++)
1009                 usb_free_urb(acm->ru[i].urb);
1010         usb_free_urb(acm->ctrlurb);
1011 alloc_fail5:
1012         acm_write_buffers_free(acm);
1013 alloc_fail4:
1014         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1015 alloc_fail2:
1016         kfree(acm);
1017 alloc_fail:
1018         return -ENOMEM;
1019 }
1020
1021 static void acm_disconnect(struct usb_interface *intf)
1022 {
1023         struct acm *acm = usb_get_intfdata (intf);
1024         struct usb_device *usb_dev = interface_to_usbdev(intf);
1025         int i;
1026
1027         if (!acm || !acm->dev) {
1028                 dbg("disconnect on nonexisting interface");
1029                 return;
1030         }
1031
1032         mutex_lock(&open_mutex);
1033         if (!usb_get_intfdata(intf)) {
1034                 mutex_unlock(&open_mutex);
1035                 return;
1036         }
1037         acm->dev = NULL;
1038         usb_set_intfdata(acm->control, NULL);
1039         usb_set_intfdata(acm->data, NULL);
1040
1041         tasklet_disable(&acm->urb_task);
1042
1043         usb_kill_urb(acm->ctrlurb);
1044         usb_kill_urb(acm->writeurb);
1045         for (i = 0; i < acm->rx_buflimit; i++)
1046                 usb_kill_urb(acm->ru[i].urb);
1047
1048         INIT_LIST_HEAD(&acm->filled_read_bufs);
1049         INIT_LIST_HEAD(&acm->spare_read_bufs);
1050
1051         tasklet_enable(&acm->urb_task);
1052
1053         flush_scheduled_work(); /* wait for acm_softint */
1054
1055         acm_write_buffers_free(acm);
1056         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1057         for (i = 0; i < acm->rx_buflimit; i++)
1058                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1059
1060         usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1061
1062         if (!acm->used) {
1063                 acm_tty_unregister(acm);
1064                 mutex_unlock(&open_mutex);
1065                 return;
1066         }
1067
1068         mutex_unlock(&open_mutex);
1069
1070         if (acm->tty)
1071                 tty_hangup(acm->tty);
1072 }
1073
1074 /*
1075  * USB driver structure.
1076  */
1077
1078 static struct usb_device_id acm_ids[] = {
1079         /* quirky and broken devices */
1080         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1081         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1082         },
1083         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1084         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1085         },
1086         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1087         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1088         },
1089         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1090         .driver_info = SINGLE_RX_URB, /* firmware bug */
1091         },
1092         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1093         .driver_info = SINGLE_RX_URB, /* firmware bug */
1094         },
1095         /* control interfaces with various AT-command sets */
1096         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1097                 USB_CDC_ACM_PROTO_AT_V25TER) },
1098         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1099                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1100         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1101                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1102         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1103                 USB_CDC_ACM_PROTO_AT_GSM) },
1104         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1105                 USB_CDC_ACM_PROTO_AT_3G ) },
1106         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1107                 USB_CDC_ACM_PROTO_AT_CDMA) },
1108
1109         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1110         { }
1111 };
1112
1113 MODULE_DEVICE_TABLE (usb, acm_ids);
1114
1115 static struct usb_driver acm_driver = {
1116         .name =         "cdc_acm",
1117         .probe =        acm_probe,
1118         .disconnect =   acm_disconnect,
1119         .id_table =     acm_ids,
1120 };
1121
1122 /*
1123  * TTY driver structures.
1124  */
1125
1126 static const struct tty_operations acm_ops = {
1127         .open =                 acm_tty_open,
1128         .close =                acm_tty_close,
1129         .write =                acm_tty_write,
1130         .write_room =           acm_tty_write_room,
1131         .ioctl =                acm_tty_ioctl,
1132         .throttle =             acm_tty_throttle,
1133         .unthrottle =           acm_tty_unthrottle,
1134         .chars_in_buffer =      acm_tty_chars_in_buffer,
1135         .break_ctl =            acm_tty_break_ctl,
1136         .set_termios =          acm_tty_set_termios,
1137         .tiocmget =             acm_tty_tiocmget,
1138         .tiocmset =             acm_tty_tiocmset,
1139 };
1140
1141 /*
1142  * Init / exit.
1143  */
1144
1145 static int __init acm_init(void)
1146 {
1147         int retval;
1148         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1149         if (!acm_tty_driver)
1150                 return -ENOMEM;
1151         acm_tty_driver->owner = THIS_MODULE,
1152         acm_tty_driver->driver_name = "acm",
1153         acm_tty_driver->name = "ttyACM",
1154         acm_tty_driver->major = ACM_TTY_MAJOR,
1155         acm_tty_driver->minor_start = 0,
1156         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1157         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1158         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1159         acm_tty_driver->init_termios = tty_std_termios;
1160         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1161         tty_set_operations(acm_tty_driver, &acm_ops);
1162
1163         retval = tty_register_driver(acm_tty_driver);
1164         if (retval) {
1165                 put_tty_driver(acm_tty_driver);
1166                 return retval;
1167         }
1168
1169         retval = usb_register(&acm_driver);
1170         if (retval) {
1171                 tty_unregister_driver(acm_tty_driver);
1172                 put_tty_driver(acm_tty_driver);
1173                 return retval;
1174         }
1175
1176         info(DRIVER_VERSION ":" DRIVER_DESC);
1177
1178         return 0;
1179 }
1180
1181 static void __exit acm_exit(void)
1182 {
1183         usb_deregister(&acm_driver);
1184         tty_unregister_driver(acm_tty_driver);
1185         put_tty_driver(acm_tty_driver);
1186 }
1187
1188 module_init(acm_init);
1189 module_exit(acm_exit);
1190
1191 MODULE_AUTHOR( DRIVER_AUTHOR );
1192 MODULE_DESCRIPTION( DRIVER_DESC );
1193 MODULE_LICENSE("GPL");
1194