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