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