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