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