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