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