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