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