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