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 usb_fill_bulk_urb(rcv->urb, acm->dev, 466 acm->rx_endpoint, 467 buf->base, 468 acm->readsize, 469 acm_read_bulk, rcv); 470 rcv->urb->transfer_dma = buf->dma; 471 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 472 473 /* This shouldn't kill the driver as unsuccessful URBs are 474 returned to the free-urbs-pool and resubmited ASAP */ 475 spin_lock_irqsave(&acm->read_lock, flags); 476 if (acm->susp_count || 477 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) { 478 list_add(&buf->list, &acm->spare_read_bufs); 479 list_add(&rcv->list, &acm->spare_read_urbs); 480 acm->processing = 0; 481 spin_unlock_irqrestore(&acm->read_lock, flags); 482 return; 483 } else { 484 spin_unlock_irqrestore(&acm->read_lock, flags); 485 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf); 486 } 487 } 488 spin_lock_irqsave(&acm->read_lock, flags); 489 acm->processing = 0; 490 spin_unlock_irqrestore(&acm->read_lock, flags); 491 } 492 493 /* data interface wrote those outgoing bytes */ 494 static void acm_write_bulk(struct urb *urb) 495 { 496 struct acm_wb *wb = urb->context; 497 struct acm *acm = wb->instance; 498 unsigned long flags; 499 500 if (verbose || urb->status 501 || (urb->actual_length != urb->transfer_buffer_length)) 502 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n", 503 urb->actual_length, 504 urb->transfer_buffer_length, 505 urb->status); 506 507 spin_lock_irqsave(&acm->write_lock, flags); 508 acm_write_done(acm, wb); 509 spin_unlock_irqrestore(&acm->write_lock, flags); 510 if (ACM_READY(acm)) 511 schedule_work(&acm->work); 512 else 513 wake_up_interruptible(&acm->drain_wait); 514 } 515 516 static void acm_softint(struct work_struct *work) 517 { 518 struct acm *acm = container_of(work, struct acm, work); 519 struct tty_struct *tty; 520 521 dev_vdbg(&acm->data->dev, "tx work\n"); 522 if (!ACM_READY(acm)) 523 return; 524 tty = tty_port_tty_get(&acm->port); 525 tty_wakeup(tty); 526 tty_kref_put(tty); 527 } 528 529 static void acm_waker(struct work_struct *waker) 530 { 531 struct acm *acm = container_of(waker, struct acm, waker); 532 int rv; 533 534 rv = usb_autopm_get_interface(acm->control); 535 if (rv < 0) { 536 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__); 537 return; 538 } 539 if (acm->delayed_wb) { 540 acm_start_wb(acm, acm->delayed_wb); 541 acm->delayed_wb = NULL; 542 } 543 usb_autopm_put_interface(acm->control); 544 } 545 546 /* 547 * TTY handlers 548 */ 549 550 static int acm_tty_open(struct tty_struct *tty, struct file *filp) 551 { 552 struct acm *acm; 553 int rv = -EINVAL; 554 int i; 555 dbg("Entering acm_tty_open."); 556 557 mutex_lock(&open_mutex); 558 559 acm = acm_table[tty->index]; 560 if (!acm || !acm->dev) 561 goto err_out; 562 else 563 rv = 0; 564 565 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags); 566 567 tty->driver_data = acm; 568 tty_port_tty_set(&acm->port, tty); 569 570 if (usb_autopm_get_interface(acm->control) < 0) 571 goto early_bail; 572 else 573 acm->control->needs_remote_wakeup = 1; 574 575 mutex_lock(&acm->mutex); 576 if (acm->port.count++) { 577 usb_autopm_put_interface(acm->control); 578 goto done; 579 } 580 581 acm->ctrlurb->dev = acm->dev; 582 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) { 583 dbg("usb_submit_urb(ctrl irq) failed"); 584 goto bail_out; 585 } 586 587 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) && 588 (acm->ctrl_caps & USB_CDC_CAP_LINE)) 589 goto full_bailout; 590 591 usb_autopm_put_interface(acm->control); 592 593 INIT_LIST_HEAD(&acm->spare_read_urbs); 594 INIT_LIST_HEAD(&acm->spare_read_bufs); 595 INIT_LIST_HEAD(&acm->filled_read_bufs); 596 597 for (i = 0; i < acm->rx_buflimit; i++) 598 list_add(&(acm->ru[i].list), &acm->spare_read_urbs); 599 for (i = 0; i < acm->rx_buflimit; i++) 600 list_add(&(acm->rb[i].list), &acm->spare_read_bufs); 601 602 acm->throttle = 0; 603 604 tasklet_schedule(&acm->urb_task); 605 rv = tty_port_block_til_ready(&acm->port, tty, filp); 606 done: 607 mutex_unlock(&acm->mutex); 608 err_out: 609 mutex_unlock(&open_mutex); 610 return rv; 611 612 full_bailout: 613 usb_kill_urb(acm->ctrlurb); 614 bail_out: 615 usb_autopm_put_interface(acm->control); 616 acm->port.count--; 617 mutex_unlock(&acm->mutex); 618 early_bail: 619 mutex_unlock(&open_mutex); 620 tty_port_tty_set(&acm->port, NULL); 621 return -EIO; 622 } 623 624 static void acm_tty_unregister(struct acm *acm) 625 { 626 int i, nr; 627 628 nr = acm->rx_buflimit; 629 tty_unregister_device(acm_tty_driver, acm->minor); 630 usb_put_intf(acm->control); 631 acm_table[acm->minor] = NULL; 632 usb_free_urb(acm->ctrlurb); 633 for (i = 0; i < ACM_NW; i++) 634 usb_free_urb(acm->wb[i].urb); 635 for (i = 0; i < nr; i++) 636 usb_free_urb(acm->ru[i].urb); 637 kfree(acm->country_codes); 638 kfree(acm); 639 } 640 641 static int acm_tty_chars_in_buffer(struct tty_struct *tty); 642 643 static void acm_port_down(struct acm *acm, int drain) 644 { 645 int i, nr = acm->rx_buflimit; 646 mutex_lock(&open_mutex); 647 if (acm->dev) { 648 usb_autopm_get_interface(acm->control); 649 acm_set_control(acm, acm->ctrlout = 0); 650 /* try letting the last writes drain naturally */ 651 if (drain) { 652 wait_event_interruptible_timeout(acm->drain_wait, 653 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev, 654 ACM_CLOSE_TIMEOUT * HZ); 655 } 656 usb_kill_urb(acm->ctrlurb); 657 for (i = 0; i < ACM_NW; i++) 658 usb_kill_urb(acm->wb[i].urb); 659 for (i = 0; i < nr; i++) 660 usb_kill_urb(acm->ru[i].urb); 661 acm->control->needs_remote_wakeup = 0; 662 usb_autopm_put_interface(acm->control); 663 } 664 mutex_unlock(&open_mutex); 665 } 666 667 static void acm_tty_hangup(struct tty_struct *tty) 668 { 669 struct acm *acm = tty->driver_data; 670 tty_port_hangup(&acm->port); 671 acm_port_down(acm, 0); 672 } 673 674 static void acm_tty_close(struct tty_struct *tty, struct file *filp) 675 { 676 struct acm *acm = tty->driver_data; 677 678 /* Perform the closing process and see if we need to do the hardware 679 shutdown */ 680 if (tty_port_close_start(&acm->port, tty, filp) == 0) 681 return; 682 acm_port_down(acm, 0); 683 tty_port_close_end(&acm->port, tty); 684 mutex_lock(&open_mutex); 685 tty_port_tty_set(&acm->port, NULL); 686 if (!acm->dev) 687 acm_tty_unregister(acm); 688 mutex_unlock(&open_mutex); 689 } 690 691 static int acm_tty_write(struct tty_struct *tty, 692 const unsigned char *buf, int count) 693 { 694 struct acm *acm = tty->driver_data; 695 int stat; 696 unsigned long flags; 697 int wbn; 698 struct acm_wb *wb; 699 700 dbg("Entering acm_tty_write to write %d bytes,", count); 701 702 if (!ACM_READY(acm)) 703 return -EINVAL; 704 if (!count) 705 return 0; 706 707 spin_lock_irqsave(&acm->write_lock, flags); 708 wbn = acm_wb_alloc(acm); 709 if (wbn < 0) { 710 spin_unlock_irqrestore(&acm->write_lock, flags); 711 return 0; 712 } 713 wb = &acm->wb[wbn]; 714 715 count = (count > acm->writesize) ? acm->writesize : count; 716 dbg("Get %d bytes...", count); 717 memcpy(wb->buf, buf, count); 718 wb->len = count; 719 spin_unlock_irqrestore(&acm->write_lock, flags); 720 721 stat = acm_write_start(acm, wbn); 722 if (stat < 0) 723 return stat; 724 return count; 725 } 726 727 static int acm_tty_write_room(struct tty_struct *tty) 728 { 729 struct acm *acm = tty->driver_data; 730 if (!ACM_READY(acm)) 731 return -EINVAL; 732 /* 733 * Do not let the line discipline to know that we have a reserve, 734 * or it might get too enthusiastic. 735 */ 736 return acm_wb_is_avail(acm) ? acm->writesize : 0; 737 } 738 739 static int acm_tty_chars_in_buffer(struct tty_struct *tty) 740 { 741 struct acm *acm = tty->driver_data; 742 if (!ACM_READY(acm)) 743 return -EINVAL; 744 /* 745 * This is inaccurate (overcounts), but it works. 746 */ 747 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize; 748 } 749 750 static void acm_tty_throttle(struct tty_struct *tty) 751 { 752 struct acm *acm = tty->driver_data; 753 if (!ACM_READY(acm)) 754 return; 755 spin_lock_bh(&acm->throttle_lock); 756 acm->throttle = 1; 757 spin_unlock_bh(&acm->throttle_lock); 758 } 759 760 static void acm_tty_unthrottle(struct tty_struct *tty) 761 { 762 struct acm *acm = tty->driver_data; 763 if (!ACM_READY(acm)) 764 return; 765 spin_lock_bh(&acm->throttle_lock); 766 acm->throttle = 0; 767 spin_unlock_bh(&acm->throttle_lock); 768 tasklet_schedule(&acm->urb_task); 769 } 770 771 static int acm_tty_break_ctl(struct tty_struct *tty, int state) 772 { 773 struct acm *acm = tty->driver_data; 774 int retval; 775 if (!ACM_READY(acm)) 776 return -EINVAL; 777 retval = acm_send_break(acm, state ? 0xffff : 0); 778 if (retval < 0) 779 dbg("send break failed"); 780 return retval; 781 } 782 783 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file) 784 { 785 struct acm *acm = tty->driver_data; 786 787 if (!ACM_READY(acm)) 788 return -EINVAL; 789 790 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) | 791 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) | 792 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) | 793 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) | 794 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) | 795 TIOCM_CTS; 796 } 797 798 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file, 799 unsigned int set, unsigned int clear) 800 { 801 struct acm *acm = tty->driver_data; 802 unsigned int newctrl; 803 804 if (!ACM_READY(acm)) 805 return -EINVAL; 806 807 newctrl = acm->ctrlout; 808 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | 809 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0); 810 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | 811 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0); 812 813 newctrl = (newctrl & ~clear) | set; 814 815 if (acm->ctrlout == newctrl) 816 return 0; 817 return acm_set_control(acm, acm->ctrlout = newctrl); 818 } 819 820 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, 821 unsigned int cmd, unsigned long arg) 822 { 823 struct acm *acm = tty->driver_data; 824 825 if (!ACM_READY(acm)) 826 return -EINVAL; 827 828 return -ENOIOCTLCMD; 829 } 830 831 static const __u32 acm_tty_speed[] = { 832 0, 50, 75, 110, 134, 150, 200, 300, 600, 833 1200, 1800, 2400, 4800, 9600, 19200, 38400, 834 57600, 115200, 230400, 460800, 500000, 576000, 835 921600, 1000000, 1152000, 1500000, 2000000, 836 2500000, 3000000, 3500000, 4000000 837 }; 838 839 static const __u8 acm_tty_size[] = { 840 5, 6, 7, 8 841 }; 842 843 static void acm_tty_set_termios(struct tty_struct *tty, 844 struct ktermios *termios_old) 845 { 846 struct acm *acm = tty->driver_data; 847 struct ktermios *termios = tty->termios; 848 struct usb_cdc_line_coding newline; 849 int newctrl = acm->ctrlout; 850 851 if (!ACM_READY(acm)) 852 return; 853 854 /* FIXME: Needs to support the tty_baud interface */ 855 /* FIXME: Broken on sparc */ 856 newline.dwDTERate = cpu_to_le32p(acm_tty_speed + 857 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0)); 858 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0; 859 newline.bParityType = termios->c_cflag & PARENB ? 860 (termios->c_cflag & PARODD ? 1 : 2) + 861 (termios->c_cflag & CMSPAR ? 2 : 0) : 0; 862 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4]; 863 /* FIXME: Needs to clear unsupported bits in the termios */ 864 acm->clocal = ((termios->c_cflag & CLOCAL) != 0); 865 866 if (!newline.dwDTERate) { 867 newline.dwDTERate = acm->line.dwDTERate; 868 newctrl &= ~ACM_CTRL_DTR; 869 } else 870 newctrl |= ACM_CTRL_DTR; 871 872 if (newctrl != acm->ctrlout) 873 acm_set_control(acm, acm->ctrlout = newctrl); 874 875 if (memcmp(&acm->line, &newline, sizeof newline)) { 876 memcpy(&acm->line, &newline, sizeof newline); 877 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate), 878 newline.bCharFormat, newline.bParityType, 879 newline.bDataBits); 880 acm_set_line(acm, &acm->line); 881 } 882 } 883 884 /* 885 * USB probe and disconnect routines. 886 */ 887 888 /* Little helpers: write/read buffers free */ 889 static void acm_write_buffers_free(struct acm *acm) 890 { 891 int i; 892 struct acm_wb *wb; 893 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 894 895 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) 896 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah); 897 } 898 899 static void acm_read_buffers_free(struct acm *acm) 900 { 901 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 902 int i, n = acm->rx_buflimit; 903 904 for (i = 0; i < n; i++) 905 usb_buffer_free(usb_dev, acm->readsize, 906 acm->rb[i].base, acm->rb[i].dma); 907 } 908 909 /* Little helper: write buffers allocate */ 910 static int acm_write_buffers_alloc(struct acm *acm) 911 { 912 int i; 913 struct acm_wb *wb; 914 915 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { 916 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL, 917 &wb->dmah); 918 if (!wb->buf) { 919 while (i != 0) { 920 --i; 921 --wb; 922 usb_buffer_free(acm->dev, acm->writesize, 923 wb->buf, wb->dmah); 924 } 925 return -ENOMEM; 926 } 927 } 928 return 0; 929 } 930 931 static int acm_probe(struct usb_interface *intf, 932 const struct usb_device_id *id) 933 { 934 struct usb_cdc_union_desc *union_header = NULL; 935 struct usb_cdc_country_functional_desc *cfd = NULL; 936 unsigned char *buffer = intf->altsetting->extra; 937 int buflen = intf->altsetting->extralen; 938 struct usb_interface *control_interface; 939 struct usb_interface *data_interface; 940 struct usb_endpoint_descriptor *epctrl; 941 struct usb_endpoint_descriptor *epread; 942 struct usb_endpoint_descriptor *epwrite; 943 struct usb_device *usb_dev = interface_to_usbdev(intf); 944 struct acm *acm; 945 int minor; 946 int ctrlsize, readsize; 947 u8 *buf; 948 u8 ac_management_function = 0; 949 u8 call_management_function = 0; 950 int call_interface_num = -1; 951 int data_interface_num; 952 unsigned long quirks; 953 int num_rx_buf; 954 int i; 955 956 /* normal quirks */ 957 quirks = (unsigned long)id->driver_info; 958 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR; 959 960 /* handle quirks deadly to normal probing*/ 961 if (quirks == NO_UNION_NORMAL) { 962 data_interface = usb_ifnum_to_if(usb_dev, 1); 963 control_interface = usb_ifnum_to_if(usb_dev, 0); 964 goto skip_normal_probe; 965 } 966 967 /* normal probing*/ 968 if (!buffer) { 969 dev_err(&intf->dev, "Weird descriptor references\n"); 970 return -EINVAL; 971 } 972 973 if (!buflen) { 974 if (intf->cur_altsetting->endpoint->extralen && 975 intf->cur_altsetting->endpoint->extra) { 976 dev_dbg(&intf->dev, 977 "Seeking extra descriptors on endpoint\n"); 978 buflen = intf->cur_altsetting->endpoint->extralen; 979 buffer = intf->cur_altsetting->endpoint->extra; 980 } else { 981 dev_err(&intf->dev, 982 "Zero length descriptor references\n"); 983 return -EINVAL; 984 } 985 } 986 987 while (buflen > 0) { 988 if (buffer[1] != USB_DT_CS_INTERFACE) { 989 dev_err(&intf->dev, "skipping garbage\n"); 990 goto next_desc; 991 } 992 993 switch (buffer[2]) { 994 case USB_CDC_UNION_TYPE: /* we've found it */ 995 if (union_header) { 996 dev_err(&intf->dev, "More than one " 997 "union descriptor, skipping ...\n"); 998 goto next_desc; 999 } 1000 union_header = (struct usb_cdc_union_desc *)buffer; 1001 break; 1002 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/ 1003 cfd = (struct usb_cdc_country_functional_desc *)buffer; 1004 break; 1005 case USB_CDC_HEADER_TYPE: /* maybe check version */ 1006 break; /* for now we ignore it */ 1007 case USB_CDC_ACM_TYPE: 1008 ac_management_function = buffer[3]; 1009 break; 1010 case USB_CDC_CALL_MANAGEMENT_TYPE: 1011 call_management_function = buffer[3]; 1012 call_interface_num = buffer[4]; 1013 if ((call_management_function & 3) != 3) 1014 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n"); 1015 break; 1016 default: 1017 /* there are LOTS more CDC descriptors that 1018 * could legitimately be found here. 1019 */ 1020 dev_dbg(&intf->dev, "Ignoring descriptor: " 1021 "type %02x, length %d\n", 1022 buffer[2], buffer[0]); 1023 break; 1024 } 1025 next_desc: 1026 buflen -= buffer[0]; 1027 buffer += buffer[0]; 1028 } 1029 1030 if (!union_header) { 1031 if (call_interface_num > 0) { 1032 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n"); 1033 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); 1034 control_interface = intf; 1035 } else { 1036 dev_dbg(&intf->dev, 1037 "No union descriptor, giving up\n"); 1038 return -ENODEV; 1039 } 1040 } else { 1041 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); 1042 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0)); 1043 if (!control_interface || !data_interface) { 1044 dev_dbg(&intf->dev, "no interfaces\n"); 1045 return -ENODEV; 1046 } 1047 } 1048 1049 if (data_interface_num != call_interface_num) 1050 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); 1051 1052 skip_normal_probe: 1053 1054 /*workaround for switched interfaces */ 1055 if (data_interface->cur_altsetting->desc.bInterfaceClass 1056 != CDC_DATA_INTERFACE_TYPE) { 1057 if (control_interface->cur_altsetting->desc.bInterfaceClass 1058 == CDC_DATA_INTERFACE_TYPE) { 1059 struct usb_interface *t; 1060 dev_dbg(&intf->dev, 1061 "Your device has switched interfaces.\n"); 1062 t = control_interface; 1063 control_interface = data_interface; 1064 data_interface = t; 1065 } else { 1066 return -EINVAL; 1067 } 1068 } 1069 1070 /* Accept probe requests only for the control interface */ 1071 if (intf != control_interface) 1072 return -ENODEV; 1073 1074 if (usb_interface_claimed(data_interface)) { /* valid in this context */ 1075 dev_dbg(&intf->dev, "The data interface isn't available\n"); 1076 return -EBUSY; 1077 } 1078 1079 1080 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2) 1081 return -EINVAL; 1082 1083 epctrl = &control_interface->cur_altsetting->endpoint[0].desc; 1084 epread = &data_interface->cur_altsetting->endpoint[0].desc; 1085 epwrite = &data_interface->cur_altsetting->endpoint[1].desc; 1086 1087 1088 /* workaround for switched endpoints */ 1089 if (!usb_endpoint_dir_in(epread)) { 1090 /* descriptors are swapped */ 1091 struct usb_endpoint_descriptor *t; 1092 dev_dbg(&intf->dev, 1093 "The data interface has switched endpoints\n"); 1094 t = epread; 1095 epread = epwrite; 1096 epwrite = t; 1097 } 1098 dbg("interfaces are valid"); 1099 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++); 1100 1101 if (minor == ACM_TTY_MINORS) { 1102 dev_err(&intf->dev, "no more free acm devices\n"); 1103 return -ENODEV; 1104 } 1105 1106 acm = kzalloc(sizeof(struct acm), GFP_KERNEL); 1107 if (acm == NULL) { 1108 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n"); 1109 goto alloc_fail; 1110 } 1111 1112 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); 1113 readsize = le16_to_cpu(epread->wMaxPacketSize) * 1114 (quirks == SINGLE_RX_URB ? 1 : 2); 1115 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20; 1116 acm->control = control_interface; 1117 acm->data = data_interface; 1118 acm->minor = minor; 1119 acm->dev = usb_dev; 1120 acm->ctrl_caps = ac_management_function; 1121 acm->ctrlsize = ctrlsize; 1122 acm->readsize = readsize; 1123 acm->rx_buflimit = num_rx_buf; 1124 acm->urb_task.func = acm_rx_tasklet; 1125 acm->urb_task.data = (unsigned long) acm; 1126 INIT_WORK(&acm->work, acm_softint); 1127 INIT_WORK(&acm->waker, acm_waker); 1128 init_waitqueue_head(&acm->drain_wait); 1129 spin_lock_init(&acm->throttle_lock); 1130 spin_lock_init(&acm->write_lock); 1131 spin_lock_init(&acm->read_lock); 1132 mutex_init(&acm->mutex); 1133 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); 1134 tty_port_init(&acm->port); 1135 acm->port.ops = &acm_port_ops; 1136 1137 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); 1138 if (!buf) { 1139 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n"); 1140 goto alloc_fail2; 1141 } 1142 acm->ctrl_buffer = buf; 1143 1144 if (acm_write_buffers_alloc(acm) < 0) { 1145 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n"); 1146 goto alloc_fail4; 1147 } 1148 1149 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL); 1150 if (!acm->ctrlurb) { 1151 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); 1152 goto alloc_fail5; 1153 } 1154 for (i = 0; i < num_rx_buf; i++) { 1155 struct acm_ru *rcv = &(acm->ru[i]); 1156 1157 rcv->urb = usb_alloc_urb(0, GFP_KERNEL); 1158 if (rcv->urb == NULL) { 1159 dev_dbg(&intf->dev, 1160 "out of memory (read urbs usb_alloc_urb)\n"); 1161 goto alloc_fail7; 1162 } 1163 1164 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1165 rcv->instance = acm; 1166 } 1167 for (i = 0; i < num_rx_buf; i++) { 1168 struct acm_rb *rb = &(acm->rb[i]); 1169 1170 rb->base = usb_buffer_alloc(acm->dev, readsize, 1171 GFP_KERNEL, &rb->dma); 1172 if (!rb->base) { 1173 dev_dbg(&intf->dev, 1174 "out of memory (read bufs usb_buffer_alloc)\n"); 1175 goto alloc_fail7; 1176 } 1177 } 1178 for (i = 0; i < ACM_NW; i++) { 1179 struct acm_wb *snd = &(acm->wb[i]); 1180 1181 snd->urb = usb_alloc_urb(0, GFP_KERNEL); 1182 if (snd->urb == NULL) { 1183 dev_dbg(&intf->dev, 1184 "out of memory (write urbs usb_alloc_urb)"); 1185 goto alloc_fail7; 1186 } 1187 1188 usb_fill_bulk_urb(snd->urb, usb_dev, 1189 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 1190 NULL, acm->writesize, acm_write_bulk, snd); 1191 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1192 snd->instance = acm; 1193 } 1194 1195 usb_set_intfdata(intf, acm); 1196 1197 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities); 1198 if (i < 0) 1199 goto alloc_fail8; 1200 1201 if (cfd) { /* export the country data */ 1202 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL); 1203 if (!acm->country_codes) 1204 goto skip_countries; 1205 acm->country_code_size = cfd->bLength - 4; 1206 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, 1207 cfd->bLength - 4); 1208 acm->country_rel_date = cfd->iCountryCodeRelDate; 1209 1210 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes); 1211 if (i < 0) { 1212 kfree(acm->country_codes); 1213 goto skip_countries; 1214 } 1215 1216 i = device_create_file(&intf->dev, 1217 &dev_attr_iCountryCodeRelDate); 1218 if (i < 0) { 1219 kfree(acm->country_codes); 1220 goto skip_countries; 1221 } 1222 } 1223 1224 skip_countries: 1225 usb_fill_int_urb(acm->ctrlurb, usb_dev, 1226 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), 1227 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, 1228 epctrl->bInterval); 1229 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1230 acm->ctrlurb->transfer_dma = acm->ctrl_dma; 1231 1232 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); 1233 1234 acm_set_control(acm, acm->ctrlout); 1235 1236 acm->line.dwDTERate = cpu_to_le32(9600); 1237 acm->line.bDataBits = 8; 1238 acm_set_line(acm, &acm->line); 1239 1240 usb_driver_claim_interface(&acm_driver, data_interface, acm); 1241 usb_set_intfdata(data_interface, acm); 1242 1243 usb_get_intf(control_interface); 1244 tty_register_device(acm_tty_driver, minor, &control_interface->dev); 1245 1246 acm_table[minor] = acm; 1247 1248 return 0; 1249 alloc_fail8: 1250 for (i = 0; i < ACM_NW; i++) 1251 usb_free_urb(acm->wb[i].urb); 1252 alloc_fail7: 1253 acm_read_buffers_free(acm); 1254 for (i = 0; i < num_rx_buf; i++) 1255 usb_free_urb(acm->ru[i].urb); 1256 usb_free_urb(acm->ctrlurb); 1257 alloc_fail5: 1258 acm_write_buffers_free(acm); 1259 alloc_fail4: 1260 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); 1261 alloc_fail2: 1262 kfree(acm); 1263 alloc_fail: 1264 return -ENOMEM; 1265 } 1266 1267 static void stop_data_traffic(struct acm *acm) 1268 { 1269 int i; 1270 dbg("Entering stop_data_traffic"); 1271 1272 tasklet_disable(&acm->urb_task); 1273 1274 usb_kill_urb(acm->ctrlurb); 1275 for (i = 0; i < ACM_NW; i++) 1276 usb_kill_urb(acm->wb[i].urb); 1277 for (i = 0; i < acm->rx_buflimit; i++) 1278 usb_kill_urb(acm->ru[i].urb); 1279 1280 tasklet_enable(&acm->urb_task); 1281 1282 cancel_work_sync(&acm->work); 1283 cancel_work_sync(&acm->waker); 1284 } 1285 1286 static void acm_disconnect(struct usb_interface *intf) 1287 { 1288 struct acm *acm = usb_get_intfdata(intf); 1289 struct usb_device *usb_dev = interface_to_usbdev(intf); 1290 struct tty_struct *tty; 1291 1292 /* sibling interface is already cleaning up */ 1293 if (!acm) 1294 return; 1295 1296 mutex_lock(&open_mutex); 1297 if (acm->country_codes) { 1298 device_remove_file(&acm->control->dev, 1299 &dev_attr_wCountryCodes); 1300 device_remove_file(&acm->control->dev, 1301 &dev_attr_iCountryCodeRelDate); 1302 } 1303 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities); 1304 acm->dev = NULL; 1305 usb_set_intfdata(acm->control, NULL); 1306 usb_set_intfdata(acm->data, NULL); 1307 1308 stop_data_traffic(acm); 1309 1310 acm_write_buffers_free(acm); 1311 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, 1312 acm->ctrl_dma); 1313 acm_read_buffers_free(acm); 1314 1315 usb_driver_release_interface(&acm_driver, intf == acm->control ? 1316 acm->data : acm->control); 1317 1318 if (acm->port.count == 0) { 1319 acm_tty_unregister(acm); 1320 mutex_unlock(&open_mutex); 1321 return; 1322 } 1323 1324 mutex_unlock(&open_mutex); 1325 tty = tty_port_tty_get(&acm->port); 1326 if (tty) { 1327 tty_hangup(tty); 1328 tty_kref_put(tty); 1329 } 1330 } 1331 1332 #ifdef CONFIG_PM 1333 static int acm_suspend(struct usb_interface *intf, pm_message_t message) 1334 { 1335 struct acm *acm = usb_get_intfdata(intf); 1336 int cnt; 1337 1338 if (message.event & PM_EVENT_AUTO) { 1339 int b; 1340 1341 spin_lock_irq(&acm->read_lock); 1342 spin_lock(&acm->write_lock); 1343 b = acm->processing + acm->transmitting; 1344 spin_unlock(&acm->write_lock); 1345 spin_unlock_irq(&acm->read_lock); 1346 if (b) 1347 return -EBUSY; 1348 } 1349 1350 spin_lock_irq(&acm->read_lock); 1351 spin_lock(&acm->write_lock); 1352 cnt = acm->susp_count++; 1353 spin_unlock(&acm->write_lock); 1354 spin_unlock_irq(&acm->read_lock); 1355 1356 if (cnt) 1357 return 0; 1358 /* 1359 we treat opened interfaces differently, 1360 we must guard against open 1361 */ 1362 mutex_lock(&acm->mutex); 1363 1364 if (acm->port.count) 1365 stop_data_traffic(acm); 1366 1367 mutex_unlock(&acm->mutex); 1368 return 0; 1369 } 1370 1371 static int acm_resume(struct usb_interface *intf) 1372 { 1373 struct acm *acm = usb_get_intfdata(intf); 1374 int rv = 0; 1375 int cnt; 1376 1377 spin_lock_irq(&acm->read_lock); 1378 acm->susp_count -= 1; 1379 cnt = acm->susp_count; 1380 spin_unlock_irq(&acm->read_lock); 1381 1382 if (cnt) 1383 return 0; 1384 1385 mutex_lock(&acm->mutex); 1386 if (acm->port.count) { 1387 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO); 1388 if (rv < 0) 1389 goto err_out; 1390 1391 tasklet_schedule(&acm->urb_task); 1392 } 1393 1394 err_out: 1395 mutex_unlock(&acm->mutex); 1396 return rv; 1397 } 1398 1399 #endif /* CONFIG_PM */ 1400 /* 1401 * USB driver structure. 1402 */ 1403 1404 static struct usb_device_id acm_ids[] = { 1405 /* quirky and broken devices */ 1406 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */ 1407 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1408 }, 1409 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */ 1410 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1411 }, 1412 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */ 1413 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1414 }, 1415 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */ 1416 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1417 }, 1418 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */ 1419 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1420 }, 1421 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */ 1422 .driver_info = SINGLE_RX_URB, 1423 }, 1424 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */ 1425 .driver_info = SINGLE_RX_URB, /* firmware bug */ 1426 }, 1427 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */ 1428 .driver_info = SINGLE_RX_URB, /* firmware bug */ 1429 }, 1430 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */ 1431 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1432 }, 1433 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */ 1434 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1435 }, 1436 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */ 1437 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1438 }, 1439 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */ 1440 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1441 }, 1442 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */ 1443 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1444 }, 1445 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */ 1446 }, 1447 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */ 1448 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on 1449 data interface instead of 1450 communications interface. 1451 Maybe we should define a new 1452 quirk for this. */ 1453 }, 1454 1455 /* control interfaces with various AT-command sets */ 1456 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1457 USB_CDC_ACM_PROTO_AT_V25TER) }, 1458 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1459 USB_CDC_ACM_PROTO_AT_PCCA101) }, 1460 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1461 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) }, 1462 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1463 USB_CDC_ACM_PROTO_AT_GSM) }, 1464 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1465 USB_CDC_ACM_PROTO_AT_3G) }, 1466 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1467 USB_CDC_ACM_PROTO_AT_CDMA) }, 1468 1469 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */ 1470 { } 1471 }; 1472 1473 MODULE_DEVICE_TABLE(usb, acm_ids); 1474 1475 static struct usb_driver acm_driver = { 1476 .name = "cdc_acm", 1477 .probe = acm_probe, 1478 .disconnect = acm_disconnect, 1479 #ifdef CONFIG_PM 1480 .suspend = acm_suspend, 1481 .resume = acm_resume, 1482 #endif 1483 .id_table = acm_ids, 1484 #ifdef CONFIG_PM 1485 .supports_autosuspend = 1, 1486 #endif 1487 }; 1488 1489 /* 1490 * TTY driver structures. 1491 */ 1492 1493 static const struct tty_operations acm_ops = { 1494 .open = acm_tty_open, 1495 .close = acm_tty_close, 1496 .hangup = acm_tty_hangup, 1497 .write = acm_tty_write, 1498 .write_room = acm_tty_write_room, 1499 .ioctl = acm_tty_ioctl, 1500 .throttle = acm_tty_throttle, 1501 .unthrottle = acm_tty_unthrottle, 1502 .chars_in_buffer = acm_tty_chars_in_buffer, 1503 .break_ctl = acm_tty_break_ctl, 1504 .set_termios = acm_tty_set_termios, 1505 .tiocmget = acm_tty_tiocmget, 1506 .tiocmset = acm_tty_tiocmset, 1507 }; 1508 1509 /* 1510 * Init / exit. 1511 */ 1512 1513 static int __init acm_init(void) 1514 { 1515 int retval; 1516 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS); 1517 if (!acm_tty_driver) 1518 return -ENOMEM; 1519 acm_tty_driver->owner = THIS_MODULE, 1520 acm_tty_driver->driver_name = "acm", 1521 acm_tty_driver->name = "ttyACM", 1522 acm_tty_driver->major = ACM_TTY_MAJOR, 1523 acm_tty_driver->minor_start = 0, 1524 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL, 1525 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL, 1526 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1527 acm_tty_driver->init_termios = tty_std_termios; 1528 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | 1529 HUPCL | CLOCAL; 1530 tty_set_operations(acm_tty_driver, &acm_ops); 1531 1532 retval = tty_register_driver(acm_tty_driver); 1533 if (retval) { 1534 put_tty_driver(acm_tty_driver); 1535 return retval; 1536 } 1537 1538 retval = usb_register(&acm_driver); 1539 if (retval) { 1540 tty_unregister_driver(acm_tty_driver); 1541 put_tty_driver(acm_tty_driver); 1542 return retval; 1543 } 1544 1545 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1546 DRIVER_DESC "\n"); 1547 1548 return 0; 1549 } 1550 1551 static void __exit acm_exit(void) 1552 { 1553 usb_deregister(&acm_driver); 1554 tty_unregister_driver(acm_tty_driver); 1555 put_tty_driver(acm_tty_driver); 1556 } 1557 1558 module_init(acm_init); 1559 module_exit(acm_exit); 1560 1561 MODULE_AUTHOR(DRIVER_AUTHOR); 1562 MODULE_DESCRIPTION(DRIVER_DESC); 1563 MODULE_LICENSE("GPL"); 1564 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR); 1565