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