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 mutex_lock(&open_mutex); 543 if (acm->dev) { 544 usb_autopm_get_interface(acm->control); 545 acm_set_control(acm, acm->ctrlout = 0); 546 usb_kill_urb(acm->ctrlurb); 547 for (i = 0; i < ACM_NW; i++) 548 usb_kill_urb(acm->wb[i].urb); 549 for (i = 0; i < acm->rx_buflimit; i++) 550 usb_kill_urb(acm->read_urbs[i]); 551 acm->control->needs_remote_wakeup = 0; 552 usb_autopm_put_interface(acm->control); 553 } 554 mutex_unlock(&open_mutex); 555 } 556 557 static void acm_tty_hangup(struct tty_struct *tty) 558 { 559 struct acm *acm = tty->driver_data; 560 tty_port_hangup(&acm->port); 561 acm_port_down(acm); 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 if (tty_port_close_start(&acm->port, tty, filp) == 0) { 573 mutex_lock(&open_mutex); 574 if (!acm->dev) { 575 tty_port_tty_set(&acm->port, NULL); 576 acm_tty_unregister(acm); 577 tty->driver_data = NULL; 578 } 579 mutex_unlock(&open_mutex); 580 return; 581 } 582 acm_port_down(acm); 583 tty_port_close_end(&acm->port, tty); 584 tty_port_tty_set(&acm->port, NULL); 585 } 586 587 static int acm_tty_write(struct tty_struct *tty, 588 const unsigned char *buf, int count) 589 { 590 struct acm *acm = tty->driver_data; 591 int stat; 592 unsigned long flags; 593 int wbn; 594 struct acm_wb *wb; 595 596 if (!ACM_READY(acm)) 597 return -EINVAL; 598 if (!count) 599 return 0; 600 601 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count); 602 603 spin_lock_irqsave(&acm->write_lock, flags); 604 wbn = acm_wb_alloc(acm); 605 if (wbn < 0) { 606 spin_unlock_irqrestore(&acm->write_lock, flags); 607 return 0; 608 } 609 wb = &acm->wb[wbn]; 610 611 count = (count > acm->writesize) ? acm->writesize : count; 612 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count); 613 memcpy(wb->buf, buf, count); 614 wb->len = count; 615 spin_unlock_irqrestore(&acm->write_lock, flags); 616 617 stat = acm_write_start(acm, wbn); 618 if (stat < 0) 619 return stat; 620 return count; 621 } 622 623 static int acm_tty_write_room(struct tty_struct *tty) 624 { 625 struct acm *acm = tty->driver_data; 626 if (!ACM_READY(acm)) 627 return -EINVAL; 628 /* 629 * Do not let the line discipline to know that we have a reserve, 630 * or it might get too enthusiastic. 631 */ 632 return acm_wb_is_avail(acm) ? acm->writesize : 0; 633 } 634 635 static int acm_tty_chars_in_buffer(struct tty_struct *tty) 636 { 637 struct acm *acm = tty->driver_data; 638 if (!ACM_READY(acm)) 639 return 0; 640 /* 641 * This is inaccurate (overcounts), but it works. 642 */ 643 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize; 644 } 645 646 static void acm_tty_throttle(struct tty_struct *tty) 647 { 648 struct acm *acm = tty->driver_data; 649 650 if (!ACM_READY(acm)) 651 return; 652 653 spin_lock_irq(&acm->read_lock); 654 acm->throttle_req = 1; 655 spin_unlock_irq(&acm->read_lock); 656 } 657 658 static void acm_tty_unthrottle(struct tty_struct *tty) 659 { 660 struct acm *acm = tty->driver_data; 661 unsigned int was_throttled; 662 663 if (!ACM_READY(acm)) 664 return; 665 666 spin_lock_irq(&acm->read_lock); 667 was_throttled = acm->throttled; 668 acm->throttled = 0; 669 acm->throttle_req = 0; 670 spin_unlock_irq(&acm->read_lock); 671 672 if (was_throttled) 673 acm_submit_read_urbs(acm, GFP_KERNEL); 674 } 675 676 static int acm_tty_break_ctl(struct tty_struct *tty, int state) 677 { 678 struct acm *acm = tty->driver_data; 679 int retval; 680 if (!ACM_READY(acm)) 681 return -EINVAL; 682 retval = acm_send_break(acm, state ? 0xffff : 0); 683 if (retval < 0) 684 dev_dbg(&acm->control->dev, "%s - send break failed\n", 685 __func__); 686 return retval; 687 } 688 689 static int acm_tty_tiocmget(struct tty_struct *tty) 690 { 691 struct acm *acm = tty->driver_data; 692 693 if (!ACM_READY(acm)) 694 return -EINVAL; 695 696 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) | 697 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) | 698 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) | 699 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) | 700 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) | 701 TIOCM_CTS; 702 } 703 704 static int acm_tty_tiocmset(struct tty_struct *tty, 705 unsigned int set, unsigned int clear) 706 { 707 struct acm *acm = tty->driver_data; 708 unsigned int newctrl; 709 710 if (!ACM_READY(acm)) 711 return -EINVAL; 712 713 newctrl = acm->ctrlout; 714 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | 715 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0); 716 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | 717 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0); 718 719 newctrl = (newctrl & ~clear) | set; 720 721 if (acm->ctrlout == newctrl) 722 return 0; 723 return acm_set_control(acm, acm->ctrlout = newctrl); 724 } 725 726 static int acm_tty_ioctl(struct tty_struct *tty, 727 unsigned int cmd, unsigned long arg) 728 { 729 struct acm *acm = tty->driver_data; 730 731 if (!ACM_READY(acm)) 732 return -EINVAL; 733 734 return -ENOIOCTLCMD; 735 } 736 737 static const __u32 acm_tty_speed[] = { 738 0, 50, 75, 110, 134, 150, 200, 300, 600, 739 1200, 1800, 2400, 4800, 9600, 19200, 38400, 740 57600, 115200, 230400, 460800, 500000, 576000, 741 921600, 1000000, 1152000, 1500000, 2000000, 742 2500000, 3000000, 3500000, 4000000 743 }; 744 745 static const __u8 acm_tty_size[] = { 746 5, 6, 7, 8 747 }; 748 749 static void acm_tty_set_termios(struct tty_struct *tty, 750 struct ktermios *termios_old) 751 { 752 struct acm *acm = tty->driver_data; 753 struct ktermios *termios = tty->termios; 754 struct usb_cdc_line_coding newline; 755 int newctrl = acm->ctrlout; 756 757 if (!ACM_READY(acm)) 758 return; 759 760 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty)); 761 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0; 762 newline.bParityType = termios->c_cflag & PARENB ? 763 (termios->c_cflag & PARODD ? 1 : 2) + 764 (termios->c_cflag & CMSPAR ? 2 : 0) : 0; 765 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4]; 766 /* FIXME: Needs to clear unsupported bits in the termios */ 767 acm->clocal = ((termios->c_cflag & CLOCAL) != 0); 768 769 if (!newline.dwDTERate) { 770 newline.dwDTERate = acm->line.dwDTERate; 771 newctrl &= ~ACM_CTRL_DTR; 772 } else 773 newctrl |= ACM_CTRL_DTR; 774 775 if (newctrl != acm->ctrlout) 776 acm_set_control(acm, acm->ctrlout = newctrl); 777 778 if (memcmp(&acm->line, &newline, sizeof newline)) { 779 memcpy(&acm->line, &newline, sizeof newline); 780 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n", 781 __func__, 782 le32_to_cpu(newline.dwDTERate), 783 newline.bCharFormat, newline.bParityType, 784 newline.bDataBits); 785 acm_set_line(acm, &acm->line); 786 } 787 } 788 789 /* 790 * USB probe and disconnect routines. 791 */ 792 793 /* Little helpers: write/read buffers free */ 794 static void acm_write_buffers_free(struct acm *acm) 795 { 796 int i; 797 struct acm_wb *wb; 798 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 799 800 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) 801 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah); 802 } 803 804 static void acm_read_buffers_free(struct acm *acm) 805 { 806 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 807 int i; 808 809 for (i = 0; i < acm->rx_buflimit; i++) 810 usb_free_coherent(usb_dev, acm->readsize, 811 acm->read_buffers[i].base, acm->read_buffers[i].dma); 812 } 813 814 /* Little helper: write buffers allocate */ 815 static int acm_write_buffers_alloc(struct acm *acm) 816 { 817 int i; 818 struct acm_wb *wb; 819 820 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { 821 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL, 822 &wb->dmah); 823 if (!wb->buf) { 824 while (i != 0) { 825 --i; 826 --wb; 827 usb_free_coherent(acm->dev, acm->writesize, 828 wb->buf, wb->dmah); 829 } 830 return -ENOMEM; 831 } 832 } 833 return 0; 834 } 835 836 static int acm_probe(struct usb_interface *intf, 837 const struct usb_device_id *id) 838 { 839 struct usb_cdc_union_desc *union_header = NULL; 840 struct usb_cdc_country_functional_desc *cfd = NULL; 841 unsigned char *buffer = intf->altsetting->extra; 842 int buflen = intf->altsetting->extralen; 843 struct usb_interface *control_interface; 844 struct usb_interface *data_interface; 845 struct usb_endpoint_descriptor *epctrl = NULL; 846 struct usb_endpoint_descriptor *epread = NULL; 847 struct usb_endpoint_descriptor *epwrite = NULL; 848 struct usb_device *usb_dev = interface_to_usbdev(intf); 849 struct acm *acm; 850 int minor; 851 int ctrlsize, readsize; 852 u8 *buf; 853 u8 ac_management_function = 0; 854 u8 call_management_function = 0; 855 int call_interface_num = -1; 856 int data_interface_num = -1; 857 unsigned long quirks; 858 int num_rx_buf; 859 int i; 860 int combined_interfaces = 0; 861 862 /* normal quirks */ 863 quirks = (unsigned long)id->driver_info; 864 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR; 865 866 /* handle quirks deadly to normal probing*/ 867 if (quirks == NO_UNION_NORMAL) { 868 data_interface = usb_ifnum_to_if(usb_dev, 1); 869 control_interface = usb_ifnum_to_if(usb_dev, 0); 870 goto skip_normal_probe; 871 } 872 873 /* normal probing*/ 874 if (!buffer) { 875 dev_err(&intf->dev, "Weird descriptor references\n"); 876 return -EINVAL; 877 } 878 879 if (!buflen) { 880 if (intf->cur_altsetting->endpoint && 881 intf->cur_altsetting->endpoint->extralen && 882 intf->cur_altsetting->endpoint->extra) { 883 dev_dbg(&intf->dev, 884 "Seeking extra descriptors on endpoint\n"); 885 buflen = intf->cur_altsetting->endpoint->extralen; 886 buffer = intf->cur_altsetting->endpoint->extra; 887 } else { 888 dev_err(&intf->dev, 889 "Zero length descriptor references\n"); 890 return -EINVAL; 891 } 892 } 893 894 while (buflen > 0) { 895 if (buffer[1] != USB_DT_CS_INTERFACE) { 896 dev_err(&intf->dev, "skipping garbage\n"); 897 goto next_desc; 898 } 899 900 switch (buffer[2]) { 901 case USB_CDC_UNION_TYPE: /* we've found it */ 902 if (union_header) { 903 dev_err(&intf->dev, "More than one " 904 "union descriptor, skipping ...\n"); 905 goto next_desc; 906 } 907 union_header = (struct usb_cdc_union_desc *)buffer; 908 break; 909 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/ 910 cfd = (struct usb_cdc_country_functional_desc *)buffer; 911 break; 912 case USB_CDC_HEADER_TYPE: /* maybe check version */ 913 break; /* for now we ignore it */ 914 case USB_CDC_ACM_TYPE: 915 ac_management_function = buffer[3]; 916 break; 917 case USB_CDC_CALL_MANAGEMENT_TYPE: 918 call_management_function = buffer[3]; 919 call_interface_num = buffer[4]; 920 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3) 921 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n"); 922 break; 923 default: 924 /* there are LOTS more CDC descriptors that 925 * could legitimately be found here. 926 */ 927 dev_dbg(&intf->dev, "Ignoring descriptor: " 928 "type %02x, length %d\n", 929 buffer[2], buffer[0]); 930 break; 931 } 932 next_desc: 933 buflen -= buffer[0]; 934 buffer += buffer[0]; 935 } 936 937 if (!union_header) { 938 if (call_interface_num > 0) { 939 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n"); 940 /* quirks for Droids MuIn LCD */ 941 if (quirks & NO_DATA_INTERFACE) 942 data_interface = usb_ifnum_to_if(usb_dev, 0); 943 else 944 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); 945 control_interface = intf; 946 } else { 947 if (intf->cur_altsetting->desc.bNumEndpoints != 3) { 948 dev_dbg(&intf->dev,"No union descriptor, giving up\n"); 949 return -ENODEV; 950 } else { 951 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n"); 952 combined_interfaces = 1; 953 control_interface = data_interface = intf; 954 goto look_for_collapsed_interface; 955 } 956 } 957 } else { 958 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); 959 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0)); 960 if (!control_interface || !data_interface) { 961 dev_dbg(&intf->dev, "no interfaces\n"); 962 return -ENODEV; 963 } 964 } 965 966 if (data_interface_num != call_interface_num) 967 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); 968 969 if (control_interface == data_interface) { 970 /* some broken devices designed for windows work this way */ 971 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n"); 972 combined_interfaces = 1; 973 /* a popular other OS doesn't use it */ 974 quirks |= NO_CAP_LINE; 975 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) { 976 dev_err(&intf->dev, "This needs exactly 3 endpoints\n"); 977 return -EINVAL; 978 } 979 look_for_collapsed_interface: 980 for (i = 0; i < 3; i++) { 981 struct usb_endpoint_descriptor *ep; 982 ep = &data_interface->cur_altsetting->endpoint[i].desc; 983 984 if (usb_endpoint_is_int_in(ep)) 985 epctrl = ep; 986 else if (usb_endpoint_is_bulk_out(ep)) 987 epwrite = ep; 988 else if (usb_endpoint_is_bulk_in(ep)) 989 epread = ep; 990 else 991 return -EINVAL; 992 } 993 if (!epctrl || !epread || !epwrite) 994 return -ENODEV; 995 else 996 goto made_compressed_probe; 997 } 998 999 skip_normal_probe: 1000 1001 /*workaround for switched interfaces */ 1002 if (data_interface->cur_altsetting->desc.bInterfaceClass 1003 != CDC_DATA_INTERFACE_TYPE) { 1004 if (control_interface->cur_altsetting->desc.bInterfaceClass 1005 == CDC_DATA_INTERFACE_TYPE) { 1006 struct usb_interface *t; 1007 dev_dbg(&intf->dev, 1008 "Your device has switched interfaces.\n"); 1009 t = control_interface; 1010 control_interface = data_interface; 1011 data_interface = t; 1012 } else { 1013 return -EINVAL; 1014 } 1015 } 1016 1017 /* Accept probe requests only for the control interface */ 1018 if (!combined_interfaces && intf != control_interface) 1019 return -ENODEV; 1020 1021 if (!combined_interfaces && usb_interface_claimed(data_interface)) { 1022 /* valid in this context */ 1023 dev_dbg(&intf->dev, "The data interface isn't available\n"); 1024 return -EBUSY; 1025 } 1026 1027 1028 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2) 1029 return -EINVAL; 1030 1031 epctrl = &control_interface->cur_altsetting->endpoint[0].desc; 1032 epread = &data_interface->cur_altsetting->endpoint[0].desc; 1033 epwrite = &data_interface->cur_altsetting->endpoint[1].desc; 1034 1035 1036 /* workaround for switched endpoints */ 1037 if (!usb_endpoint_dir_in(epread)) { 1038 /* descriptors are swapped */ 1039 struct usb_endpoint_descriptor *t; 1040 dev_dbg(&intf->dev, 1041 "The data interface has switched endpoints\n"); 1042 t = epread; 1043 epread = epwrite; 1044 epwrite = t; 1045 } 1046 made_compressed_probe: 1047 dev_dbg(&intf->dev, "interfaces are valid\n"); 1048 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++); 1049 1050 if (minor == ACM_TTY_MINORS) { 1051 dev_err(&intf->dev, "no more free acm devices\n"); 1052 return -ENODEV; 1053 } 1054 1055 acm = kzalloc(sizeof(struct acm), GFP_KERNEL); 1056 if (acm == NULL) { 1057 dev_err(&intf->dev, "out of memory (acm kzalloc)\n"); 1058 goto alloc_fail; 1059 } 1060 1061 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); 1062 readsize = le16_to_cpu(epread->wMaxPacketSize) * 1063 (quirks == SINGLE_RX_URB ? 1 : 2); 1064 acm->combined_interfaces = combined_interfaces; 1065 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20; 1066 acm->control = control_interface; 1067 acm->data = data_interface; 1068 acm->minor = minor; 1069 acm->dev = usb_dev; 1070 acm->ctrl_caps = ac_management_function; 1071 if (quirks & NO_CAP_LINE) 1072 acm->ctrl_caps &= ~USB_CDC_CAP_LINE; 1073 acm->ctrlsize = ctrlsize; 1074 acm->readsize = readsize; 1075 acm->rx_buflimit = num_rx_buf; 1076 INIT_WORK(&acm->work, acm_softint); 1077 spin_lock_init(&acm->write_lock); 1078 spin_lock_init(&acm->read_lock); 1079 mutex_init(&acm->mutex); 1080 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); 1081 acm->is_int_ep = usb_endpoint_xfer_int(epread); 1082 if (acm->is_int_ep) 1083 acm->bInterval = epread->bInterval; 1084 tty_port_init(&acm->port); 1085 acm->port.ops = &acm_port_ops; 1086 1087 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); 1088 if (!buf) { 1089 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n"); 1090 goto alloc_fail2; 1091 } 1092 acm->ctrl_buffer = buf; 1093 1094 if (acm_write_buffers_alloc(acm) < 0) { 1095 dev_err(&intf->dev, "out of memory (write buffer alloc)\n"); 1096 goto alloc_fail4; 1097 } 1098 1099 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL); 1100 if (!acm->ctrlurb) { 1101 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); 1102 goto alloc_fail5; 1103 } 1104 for (i = 0; i < num_rx_buf; i++) { 1105 struct acm_rb *rb = &(acm->read_buffers[i]); 1106 struct urb *urb; 1107 1108 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL, 1109 &rb->dma); 1110 if (!rb->base) { 1111 dev_err(&intf->dev, "out of memory " 1112 "(read bufs usb_alloc_coherent)\n"); 1113 goto alloc_fail6; 1114 } 1115 rb->index = i; 1116 rb->instance = acm; 1117 1118 urb = usb_alloc_urb(0, GFP_KERNEL); 1119 if (!urb) { 1120 dev_err(&intf->dev, 1121 "out of memory (read urbs usb_alloc_urb)\n"); 1122 goto alloc_fail6; 1123 } 1124 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1125 urb->transfer_dma = rb->dma; 1126 if (acm->is_int_ep) { 1127 usb_fill_int_urb(urb, acm->dev, 1128 acm->rx_endpoint, 1129 rb->base, 1130 acm->readsize, 1131 acm_read_bulk_callback, rb, 1132 acm->bInterval); 1133 } else { 1134 usb_fill_bulk_urb(urb, acm->dev, 1135 acm->rx_endpoint, 1136 rb->base, 1137 acm->readsize, 1138 acm_read_bulk_callback, rb); 1139 } 1140 1141 acm->read_urbs[i] = urb; 1142 __set_bit(i, &acm->read_urbs_free); 1143 } 1144 for (i = 0; i < ACM_NW; i++) { 1145 struct acm_wb *snd = &(acm->wb[i]); 1146 1147 snd->urb = usb_alloc_urb(0, GFP_KERNEL); 1148 if (snd->urb == NULL) { 1149 dev_err(&intf->dev, 1150 "out of memory (write urbs usb_alloc_urb)\n"); 1151 goto alloc_fail7; 1152 } 1153 1154 if (usb_endpoint_xfer_int(epwrite)) 1155 usb_fill_int_urb(snd->urb, usb_dev, 1156 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 1157 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval); 1158 else 1159 usb_fill_bulk_urb(snd->urb, usb_dev, 1160 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 1161 NULL, acm->writesize, acm_write_bulk, snd); 1162 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1163 snd->instance = acm; 1164 } 1165 1166 usb_set_intfdata(intf, acm); 1167 1168 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities); 1169 if (i < 0) 1170 goto alloc_fail7; 1171 1172 if (cfd) { /* export the country data */ 1173 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL); 1174 if (!acm->country_codes) 1175 goto skip_countries; 1176 acm->country_code_size = cfd->bLength - 4; 1177 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, 1178 cfd->bLength - 4); 1179 acm->country_rel_date = cfd->iCountryCodeRelDate; 1180 1181 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes); 1182 if (i < 0) { 1183 kfree(acm->country_codes); 1184 goto skip_countries; 1185 } 1186 1187 i = device_create_file(&intf->dev, 1188 &dev_attr_iCountryCodeRelDate); 1189 if (i < 0) { 1190 device_remove_file(&intf->dev, &dev_attr_wCountryCodes); 1191 kfree(acm->country_codes); 1192 goto skip_countries; 1193 } 1194 } 1195 1196 skip_countries: 1197 usb_fill_int_urb(acm->ctrlurb, usb_dev, 1198 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), 1199 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, 1200 /* works around buggy devices */ 1201 epctrl->bInterval ? epctrl->bInterval : 0xff); 1202 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1203 acm->ctrlurb->transfer_dma = acm->ctrl_dma; 1204 1205 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); 1206 1207 acm_set_control(acm, acm->ctrlout); 1208 1209 acm->line.dwDTERate = cpu_to_le32(9600); 1210 acm->line.bDataBits = 8; 1211 acm_set_line(acm, &acm->line); 1212 1213 usb_driver_claim_interface(&acm_driver, data_interface, acm); 1214 usb_set_intfdata(data_interface, acm); 1215 1216 usb_get_intf(control_interface); 1217 tty_register_device(acm_tty_driver, minor, &control_interface->dev); 1218 1219 acm_table[minor] = acm; 1220 1221 return 0; 1222 alloc_fail7: 1223 for (i = 0; i < ACM_NW; i++) 1224 usb_free_urb(acm->wb[i].urb); 1225 alloc_fail6: 1226 for (i = 0; i < num_rx_buf; i++) 1227 usb_free_urb(acm->read_urbs[i]); 1228 acm_read_buffers_free(acm); 1229 usb_free_urb(acm->ctrlurb); 1230 alloc_fail5: 1231 acm_write_buffers_free(acm); 1232 alloc_fail4: 1233 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); 1234 alloc_fail2: 1235 kfree(acm); 1236 alloc_fail: 1237 return -ENOMEM; 1238 } 1239 1240 static void stop_data_traffic(struct acm *acm) 1241 { 1242 int i; 1243 1244 dev_dbg(&acm->control->dev, "%s\n", __func__); 1245 1246 usb_kill_urb(acm->ctrlurb); 1247 for (i = 0; i < ACM_NW; i++) 1248 usb_kill_urb(acm->wb[i].urb); 1249 for (i = 0; i < acm->rx_buflimit; i++) 1250 usb_kill_urb(acm->read_urbs[i]); 1251 1252 cancel_work_sync(&acm->work); 1253 } 1254 1255 static void acm_disconnect(struct usb_interface *intf) 1256 { 1257 struct acm *acm = usb_get_intfdata(intf); 1258 struct usb_device *usb_dev = interface_to_usbdev(intf); 1259 struct tty_struct *tty; 1260 1261 /* sibling interface is already cleaning up */ 1262 if (!acm) 1263 return; 1264 1265 mutex_lock(&open_mutex); 1266 if (acm->country_codes) { 1267 device_remove_file(&acm->control->dev, 1268 &dev_attr_wCountryCodes); 1269 device_remove_file(&acm->control->dev, 1270 &dev_attr_iCountryCodeRelDate); 1271 } 1272 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities); 1273 acm->dev = NULL; 1274 usb_set_intfdata(acm->control, NULL); 1275 usb_set_intfdata(acm->data, NULL); 1276 1277 stop_data_traffic(acm); 1278 1279 acm_write_buffers_free(acm); 1280 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, 1281 acm->ctrl_dma); 1282 acm_read_buffers_free(acm); 1283 1284 if (!acm->combined_interfaces) 1285 usb_driver_release_interface(&acm_driver, intf == acm->control ? 1286 acm->data : acm->control); 1287 1288 if (acm->port.count == 0) { 1289 acm_tty_unregister(acm); 1290 mutex_unlock(&open_mutex); 1291 return; 1292 } 1293 1294 mutex_unlock(&open_mutex); 1295 tty = tty_port_tty_get(&acm->port); 1296 if (tty) { 1297 tty_hangup(tty); 1298 tty_kref_put(tty); 1299 } 1300 } 1301 1302 #ifdef CONFIG_PM 1303 static int acm_suspend(struct usb_interface *intf, pm_message_t message) 1304 { 1305 struct acm *acm = usb_get_intfdata(intf); 1306 int cnt; 1307 1308 if (message.event & PM_EVENT_AUTO) { 1309 int b; 1310 1311 spin_lock_irq(&acm->write_lock); 1312 b = acm->transmitting; 1313 spin_unlock_irq(&acm->write_lock); 1314 if (b) 1315 return -EBUSY; 1316 } 1317 1318 spin_lock_irq(&acm->read_lock); 1319 spin_lock(&acm->write_lock); 1320 cnt = acm->susp_count++; 1321 spin_unlock(&acm->write_lock); 1322 spin_unlock_irq(&acm->read_lock); 1323 1324 if (cnt) 1325 return 0; 1326 /* 1327 we treat opened interfaces differently, 1328 we must guard against open 1329 */ 1330 mutex_lock(&acm->mutex); 1331 1332 if (acm->port.count) 1333 stop_data_traffic(acm); 1334 1335 mutex_unlock(&acm->mutex); 1336 return 0; 1337 } 1338 1339 static int acm_resume(struct usb_interface *intf) 1340 { 1341 struct acm *acm = usb_get_intfdata(intf); 1342 struct acm_wb *wb; 1343 int rv = 0; 1344 int cnt; 1345 1346 spin_lock_irq(&acm->read_lock); 1347 acm->susp_count -= 1; 1348 cnt = acm->susp_count; 1349 spin_unlock_irq(&acm->read_lock); 1350 1351 if (cnt) 1352 return 0; 1353 1354 mutex_lock(&acm->mutex); 1355 if (acm->port.count) { 1356 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO); 1357 1358 spin_lock_irq(&acm->write_lock); 1359 if (acm->delayed_wb) { 1360 wb = acm->delayed_wb; 1361 acm->delayed_wb = NULL; 1362 spin_unlock_irq(&acm->write_lock); 1363 acm_start_wb(acm, wb); 1364 } else { 1365 spin_unlock_irq(&acm->write_lock); 1366 } 1367 1368 /* 1369 * delayed error checking because we must 1370 * do the write path at all cost 1371 */ 1372 if (rv < 0) 1373 goto err_out; 1374 1375 rv = acm_submit_read_urbs(acm, GFP_NOIO); 1376 } 1377 1378 err_out: 1379 mutex_unlock(&acm->mutex); 1380 return rv; 1381 } 1382 1383 static int acm_reset_resume(struct usb_interface *intf) 1384 { 1385 struct acm *acm = usb_get_intfdata(intf); 1386 struct tty_struct *tty; 1387 1388 mutex_lock(&acm->mutex); 1389 if (acm->port.count) { 1390 tty = tty_port_tty_get(&acm->port); 1391 if (tty) { 1392 tty_hangup(tty); 1393 tty_kref_put(tty); 1394 } 1395 } 1396 mutex_unlock(&acm->mutex); 1397 return acm_resume(intf); 1398 } 1399 1400 #endif /* CONFIG_PM */ 1401 1402 #define NOKIA_PCSUITE_ACM_INFO(x) \ 1403 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \ 1404 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \ 1405 USB_CDC_ACM_PROTO_VENDOR) 1406 1407 #define SAMSUNG_PCSUITE_ACM_INFO(x) \ 1408 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \ 1409 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \ 1410 USB_CDC_ACM_PROTO_VENDOR) 1411 1412 /* 1413 * USB driver structure. 1414 */ 1415 1416 static const struct usb_device_id acm_ids[] = { 1417 /* quirky and broken devices */ 1418 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */ 1419 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1420 }, 1421 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */ 1422 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1423 }, 1424 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */ 1425 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1426 }, 1427 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */ 1428 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1429 }, 1430 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */ 1431 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1432 }, 1433 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */ 1434 .driver_info = SINGLE_RX_URB, 1435 }, 1436 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */ 1437 .driver_info = SINGLE_RX_URB, /* firmware bug */ 1438 }, 1439 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */ 1440 .driver_info = SINGLE_RX_URB, /* firmware bug */ 1441 }, 1442 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */ 1443 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1444 }, 1445 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */ 1446 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1447 }, 1448 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */ 1449 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1450 }, 1451 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */ 1452 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1453 }, 1454 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */ 1455 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1456 }, 1457 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */ 1458 }, 1459 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */ 1460 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on 1461 data interface instead of 1462 communications interface. 1463 Maybe we should define a new 1464 quirk for this. */ 1465 }, 1466 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */ 1467 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */ 1468 }, 1469 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */ 1470 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */ 1471 }, 1472 1473 /* Nokia S60 phones expose two ACM channels. The first is 1474 * a modem and is picked up by the standard AT-command 1475 * information below. The second is 'vendor-specific' but 1476 * is treated as a serial device at the S60 end, so we want 1477 * to expose it on Linux too. */ 1478 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */ 1479 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */ 1480 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */ 1481 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */ 1482 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */ 1483 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */ 1484 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */ 1485 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */ 1486 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */ 1487 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */ 1488 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */ 1489 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */ 1490 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */ 1491 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */ 1492 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */ 1493 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */ 1494 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */ 1495 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */ 1496 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */ 1497 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */ 1498 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */ 1499 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */ 1500 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */ 1501 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */ 1502 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */ 1503 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */ 1504 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */ 1505 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */ 1506 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */ 1507 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */ 1508 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */ 1509 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */ 1510 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */ 1511 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */ 1512 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */ 1513 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */ 1514 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */ 1515 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */ 1516 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */ 1517 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */ 1518 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */ 1519 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */ 1520 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */ 1521 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */ 1522 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */ 1523 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */ 1524 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */ 1525 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */ 1526 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */ 1527 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */ 1528 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */ 1529 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */ 1530 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */ 1531 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */ 1532 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */ 1533 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */ 1534 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */ 1535 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */ 1536 1537 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */ 1538 1539 /* Support Lego NXT using pbLua firmware */ 1540 { USB_DEVICE(0x0694, 0xff00), 1541 .driver_info = NOT_A_MODEM, 1542 }, 1543 1544 /* Support for Droids MuIn LCD */ 1545 { USB_DEVICE(0x04d8, 0x000b), 1546 .driver_info = NO_DATA_INTERFACE, 1547 }, 1548 1549 /* control interfaces without any protocol set */ 1550 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1551 USB_CDC_PROTO_NONE) }, 1552 1553 /* control interfaces with various AT-command sets */ 1554 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1555 USB_CDC_ACM_PROTO_AT_V25TER) }, 1556 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1557 USB_CDC_ACM_PROTO_AT_PCCA101) }, 1558 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1559 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) }, 1560 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1561 USB_CDC_ACM_PROTO_AT_GSM) }, 1562 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1563 USB_CDC_ACM_PROTO_AT_3G) }, 1564 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1565 USB_CDC_ACM_PROTO_AT_CDMA) }, 1566 1567 { } 1568 }; 1569 1570 MODULE_DEVICE_TABLE(usb, acm_ids); 1571 1572 static struct usb_driver acm_driver = { 1573 .name = "cdc_acm", 1574 .probe = acm_probe, 1575 .disconnect = acm_disconnect, 1576 #ifdef CONFIG_PM 1577 .suspend = acm_suspend, 1578 .resume = acm_resume, 1579 .reset_resume = acm_reset_resume, 1580 #endif 1581 .id_table = acm_ids, 1582 #ifdef CONFIG_PM 1583 .supports_autosuspend = 1, 1584 #endif 1585 }; 1586 1587 /* 1588 * TTY driver structures. 1589 */ 1590 1591 static const struct tty_operations acm_ops = { 1592 .open = acm_tty_open, 1593 .close = acm_tty_close, 1594 .hangup = acm_tty_hangup, 1595 .write = acm_tty_write, 1596 .write_room = acm_tty_write_room, 1597 .ioctl = acm_tty_ioctl, 1598 .throttle = acm_tty_throttle, 1599 .unthrottle = acm_tty_unthrottle, 1600 .chars_in_buffer = acm_tty_chars_in_buffer, 1601 .break_ctl = acm_tty_break_ctl, 1602 .set_termios = acm_tty_set_termios, 1603 .tiocmget = acm_tty_tiocmget, 1604 .tiocmset = acm_tty_tiocmset, 1605 }; 1606 1607 /* 1608 * Init / exit. 1609 */ 1610 1611 static int __init acm_init(void) 1612 { 1613 int retval; 1614 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS); 1615 if (!acm_tty_driver) 1616 return -ENOMEM; 1617 acm_tty_driver->owner = THIS_MODULE, 1618 acm_tty_driver->driver_name = "acm", 1619 acm_tty_driver->name = "ttyACM", 1620 acm_tty_driver->major = ACM_TTY_MAJOR, 1621 acm_tty_driver->minor_start = 0, 1622 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL, 1623 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL, 1624 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1625 acm_tty_driver->init_termios = tty_std_termios; 1626 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | 1627 HUPCL | CLOCAL; 1628 tty_set_operations(acm_tty_driver, &acm_ops); 1629 1630 retval = tty_register_driver(acm_tty_driver); 1631 if (retval) { 1632 put_tty_driver(acm_tty_driver); 1633 return retval; 1634 } 1635 1636 retval = usb_register(&acm_driver); 1637 if (retval) { 1638 tty_unregister_driver(acm_tty_driver); 1639 put_tty_driver(acm_tty_driver); 1640 return retval; 1641 } 1642 1643 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1644 1645 return 0; 1646 } 1647 1648 static void __exit acm_exit(void) 1649 { 1650 usb_deregister(&acm_driver); 1651 tty_unregister_driver(acm_tty_driver); 1652 put_tty_driver(acm_tty_driver); 1653 } 1654 1655 module_init(acm_init); 1656 module_exit(acm_exit); 1657 1658 MODULE_AUTHOR(DRIVER_AUTHOR); 1659 MODULE_DESCRIPTION(DRIVER_DESC); 1660 MODULE_LICENSE("GPL"); 1661 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR); 1662