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 const __u8 acm_tty_size[] = { 821 5, 6, 7, 8 822 }; 823 824 static void acm_tty_set_termios(struct tty_struct *tty, 825 struct ktermios *termios_old) 826 { 827 struct acm *acm = tty->driver_data; 828 struct ktermios *termios = &tty->termios; 829 struct usb_cdc_line_coding newline; 830 int newctrl = acm->ctrlout; 831 832 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty)); 833 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0; 834 newline.bParityType = termios->c_cflag & PARENB ? 835 (termios->c_cflag & PARODD ? 1 : 2) + 836 (termios->c_cflag & CMSPAR ? 2 : 0) : 0; 837 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4]; 838 /* FIXME: Needs to clear unsupported bits in the termios */ 839 acm->clocal = ((termios->c_cflag & CLOCAL) != 0); 840 841 if (!newline.dwDTERate) { 842 newline.dwDTERate = acm->line.dwDTERate; 843 newctrl &= ~ACM_CTRL_DTR; 844 } else 845 newctrl |= ACM_CTRL_DTR; 846 847 if (newctrl != acm->ctrlout) 848 acm_set_control(acm, acm->ctrlout = newctrl); 849 850 if (memcmp(&acm->line, &newline, sizeof newline)) { 851 memcpy(&acm->line, &newline, sizeof newline); 852 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n", 853 __func__, 854 le32_to_cpu(newline.dwDTERate), 855 newline.bCharFormat, newline.bParityType, 856 newline.bDataBits); 857 acm_set_line(acm, &acm->line); 858 } 859 } 860 861 static const struct tty_port_operations acm_port_ops = { 862 .shutdown = acm_port_shutdown, 863 .activate = acm_port_activate, 864 .destruct = acm_port_destruct, 865 }; 866 867 /* 868 * USB probe and disconnect routines. 869 */ 870 871 /* Little helpers: write/read buffers free */ 872 static void acm_write_buffers_free(struct acm *acm) 873 { 874 int i; 875 struct acm_wb *wb; 876 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 877 878 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) 879 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah); 880 } 881 882 static void acm_read_buffers_free(struct acm *acm) 883 { 884 struct usb_device *usb_dev = interface_to_usbdev(acm->control); 885 int i; 886 887 for (i = 0; i < acm->rx_buflimit; i++) 888 usb_free_coherent(usb_dev, acm->readsize, 889 acm->read_buffers[i].base, acm->read_buffers[i].dma); 890 } 891 892 /* Little helper: write buffers allocate */ 893 static int acm_write_buffers_alloc(struct acm *acm) 894 { 895 int i; 896 struct acm_wb *wb; 897 898 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { 899 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL, 900 &wb->dmah); 901 if (!wb->buf) { 902 while (i != 0) { 903 --i; 904 --wb; 905 usb_free_coherent(acm->dev, acm->writesize, 906 wb->buf, wb->dmah); 907 } 908 return -ENOMEM; 909 } 910 } 911 return 0; 912 } 913 914 static int acm_probe(struct usb_interface *intf, 915 const struct usb_device_id *id) 916 { 917 struct usb_cdc_union_desc *union_header = NULL; 918 struct usb_cdc_country_functional_desc *cfd = NULL; 919 unsigned char *buffer = intf->altsetting->extra; 920 int buflen = intf->altsetting->extralen; 921 struct usb_interface *control_interface; 922 struct usb_interface *data_interface; 923 struct usb_endpoint_descriptor *epctrl = NULL; 924 struct usb_endpoint_descriptor *epread = NULL; 925 struct usb_endpoint_descriptor *epwrite = NULL; 926 struct usb_device *usb_dev = interface_to_usbdev(intf); 927 struct acm *acm; 928 int minor; 929 int ctrlsize, readsize; 930 u8 *buf; 931 u8 ac_management_function = 0; 932 u8 call_management_function = 0; 933 int call_interface_num = -1; 934 int data_interface_num = -1; 935 unsigned long quirks; 936 int num_rx_buf; 937 int i; 938 int combined_interfaces = 0; 939 940 /* normal quirks */ 941 quirks = (unsigned long)id->driver_info; 942 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR; 943 944 /* handle quirks deadly to normal probing*/ 945 if (quirks == NO_UNION_NORMAL) { 946 data_interface = usb_ifnum_to_if(usb_dev, 1); 947 control_interface = usb_ifnum_to_if(usb_dev, 0); 948 goto skip_normal_probe; 949 } 950 951 /* normal probing*/ 952 if (!buffer) { 953 dev_err(&intf->dev, "Weird descriptor references\n"); 954 return -EINVAL; 955 } 956 957 if (!buflen) { 958 if (intf->cur_altsetting->endpoint && 959 intf->cur_altsetting->endpoint->extralen && 960 intf->cur_altsetting->endpoint->extra) { 961 dev_dbg(&intf->dev, 962 "Seeking extra descriptors on endpoint\n"); 963 buflen = intf->cur_altsetting->endpoint->extralen; 964 buffer = intf->cur_altsetting->endpoint->extra; 965 } else { 966 dev_err(&intf->dev, 967 "Zero length descriptor references\n"); 968 return -EINVAL; 969 } 970 } 971 972 while (buflen > 0) { 973 if (buffer[1] != USB_DT_CS_INTERFACE) { 974 dev_err(&intf->dev, "skipping garbage\n"); 975 goto next_desc; 976 } 977 978 switch (buffer[2]) { 979 case USB_CDC_UNION_TYPE: /* we've found it */ 980 if (union_header) { 981 dev_err(&intf->dev, "More than one " 982 "union descriptor, skipping ...\n"); 983 goto next_desc; 984 } 985 union_header = (struct usb_cdc_union_desc *)buffer; 986 break; 987 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/ 988 cfd = (struct usb_cdc_country_functional_desc *)buffer; 989 break; 990 case USB_CDC_HEADER_TYPE: /* maybe check version */ 991 break; /* for now we ignore it */ 992 case USB_CDC_ACM_TYPE: 993 ac_management_function = buffer[3]; 994 break; 995 case USB_CDC_CALL_MANAGEMENT_TYPE: 996 call_management_function = buffer[3]; 997 call_interface_num = buffer[4]; 998 if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3) 999 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n"); 1000 break; 1001 default: 1002 /* there are LOTS more CDC descriptors that 1003 * could legitimately be found here. 1004 */ 1005 dev_dbg(&intf->dev, "Ignoring descriptor: " 1006 "type %02x, length %d\n", 1007 buffer[2], buffer[0]); 1008 break; 1009 } 1010 next_desc: 1011 buflen -= buffer[0]; 1012 buffer += buffer[0]; 1013 } 1014 1015 if (!union_header) { 1016 if (call_interface_num > 0) { 1017 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n"); 1018 /* quirks for Droids MuIn LCD */ 1019 if (quirks & NO_DATA_INTERFACE) 1020 data_interface = usb_ifnum_to_if(usb_dev, 0); 1021 else 1022 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); 1023 control_interface = intf; 1024 } else { 1025 if (intf->cur_altsetting->desc.bNumEndpoints != 3) { 1026 dev_dbg(&intf->dev,"No union descriptor, giving up\n"); 1027 return -ENODEV; 1028 } else { 1029 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n"); 1030 combined_interfaces = 1; 1031 control_interface = data_interface = intf; 1032 goto look_for_collapsed_interface; 1033 } 1034 } 1035 } else { 1036 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); 1037 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0)); 1038 if (!control_interface || !data_interface) { 1039 dev_dbg(&intf->dev, "no interfaces\n"); 1040 return -ENODEV; 1041 } 1042 } 1043 1044 if (data_interface_num != call_interface_num) 1045 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); 1046 1047 if (control_interface == data_interface) { 1048 /* some broken devices designed for windows work this way */ 1049 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n"); 1050 combined_interfaces = 1; 1051 /* a popular other OS doesn't use it */ 1052 quirks |= NO_CAP_LINE; 1053 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) { 1054 dev_err(&intf->dev, "This needs exactly 3 endpoints\n"); 1055 return -EINVAL; 1056 } 1057 look_for_collapsed_interface: 1058 for (i = 0; i < 3; i++) { 1059 struct usb_endpoint_descriptor *ep; 1060 ep = &data_interface->cur_altsetting->endpoint[i].desc; 1061 1062 if (usb_endpoint_is_int_in(ep)) 1063 epctrl = ep; 1064 else if (usb_endpoint_is_bulk_out(ep)) 1065 epwrite = ep; 1066 else if (usb_endpoint_is_bulk_in(ep)) 1067 epread = ep; 1068 else 1069 return -EINVAL; 1070 } 1071 if (!epctrl || !epread || !epwrite) 1072 return -ENODEV; 1073 else 1074 goto made_compressed_probe; 1075 } 1076 1077 skip_normal_probe: 1078 1079 /*workaround for switched interfaces */ 1080 if (data_interface->cur_altsetting->desc.bInterfaceClass 1081 != CDC_DATA_INTERFACE_TYPE) { 1082 if (control_interface->cur_altsetting->desc.bInterfaceClass 1083 == CDC_DATA_INTERFACE_TYPE) { 1084 struct usb_interface *t; 1085 dev_dbg(&intf->dev, 1086 "Your device has switched interfaces.\n"); 1087 t = control_interface; 1088 control_interface = data_interface; 1089 data_interface = t; 1090 } else { 1091 return -EINVAL; 1092 } 1093 } 1094 1095 /* Accept probe requests only for the control interface */ 1096 if (!combined_interfaces && intf != control_interface) 1097 return -ENODEV; 1098 1099 if (!combined_interfaces && usb_interface_claimed(data_interface)) { 1100 /* valid in this context */ 1101 dev_dbg(&intf->dev, "The data interface isn't available\n"); 1102 return -EBUSY; 1103 } 1104 1105 1106 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 || 1107 control_interface->cur_altsetting->desc.bNumEndpoints == 0) 1108 return -EINVAL; 1109 1110 epctrl = &control_interface->cur_altsetting->endpoint[0].desc; 1111 epread = &data_interface->cur_altsetting->endpoint[0].desc; 1112 epwrite = &data_interface->cur_altsetting->endpoint[1].desc; 1113 1114 1115 /* workaround for switched endpoints */ 1116 if (!usb_endpoint_dir_in(epread)) { 1117 /* descriptors are swapped */ 1118 struct usb_endpoint_descriptor *t; 1119 dev_dbg(&intf->dev, 1120 "The data interface has switched endpoints\n"); 1121 t = epread; 1122 epread = epwrite; 1123 epwrite = t; 1124 } 1125 made_compressed_probe: 1126 dev_dbg(&intf->dev, "interfaces are valid\n"); 1127 1128 acm = kzalloc(sizeof(struct acm), GFP_KERNEL); 1129 if (acm == NULL) { 1130 dev_err(&intf->dev, "out of memory (acm kzalloc)\n"); 1131 goto alloc_fail; 1132 } 1133 1134 minor = acm_alloc_minor(acm); 1135 if (minor == ACM_TTY_MINORS) { 1136 dev_err(&intf->dev, "no more free acm devices\n"); 1137 kfree(acm); 1138 return -ENODEV; 1139 } 1140 1141 ctrlsize = usb_endpoint_maxp(epctrl); 1142 readsize = usb_endpoint_maxp(epread) * 1143 (quirks == SINGLE_RX_URB ? 1 : 2); 1144 acm->combined_interfaces = combined_interfaces; 1145 acm->writesize = usb_endpoint_maxp(epwrite) * 20; 1146 acm->control = control_interface; 1147 acm->data = data_interface; 1148 acm->minor = minor; 1149 acm->dev = usb_dev; 1150 acm->ctrl_caps = ac_management_function; 1151 if (quirks & NO_CAP_LINE) 1152 acm->ctrl_caps &= ~USB_CDC_CAP_LINE; 1153 acm->ctrlsize = ctrlsize; 1154 acm->readsize = readsize; 1155 acm->rx_buflimit = num_rx_buf; 1156 INIT_WORK(&acm->work, acm_softint); 1157 spin_lock_init(&acm->write_lock); 1158 spin_lock_init(&acm->read_lock); 1159 mutex_init(&acm->mutex); 1160 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); 1161 acm->is_int_ep = usb_endpoint_xfer_int(epread); 1162 if (acm->is_int_ep) 1163 acm->bInterval = epread->bInterval; 1164 tty_port_init(&acm->port); 1165 acm->port.ops = &acm_port_ops; 1166 1167 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); 1168 if (!buf) { 1169 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n"); 1170 goto alloc_fail2; 1171 } 1172 acm->ctrl_buffer = buf; 1173 1174 if (acm_write_buffers_alloc(acm) < 0) { 1175 dev_err(&intf->dev, "out of memory (write buffer alloc)\n"); 1176 goto alloc_fail4; 1177 } 1178 1179 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL); 1180 if (!acm->ctrlurb) { 1181 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); 1182 goto alloc_fail5; 1183 } 1184 for (i = 0; i < num_rx_buf; i++) { 1185 struct acm_rb *rb = &(acm->read_buffers[i]); 1186 struct urb *urb; 1187 1188 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL, 1189 &rb->dma); 1190 if (!rb->base) { 1191 dev_err(&intf->dev, "out of memory " 1192 "(read bufs usb_alloc_coherent)\n"); 1193 goto alloc_fail6; 1194 } 1195 rb->index = i; 1196 rb->instance = acm; 1197 1198 urb = usb_alloc_urb(0, GFP_KERNEL); 1199 if (!urb) { 1200 dev_err(&intf->dev, 1201 "out of memory (read urbs usb_alloc_urb)\n"); 1202 goto alloc_fail6; 1203 } 1204 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1205 urb->transfer_dma = rb->dma; 1206 if (acm->is_int_ep) { 1207 usb_fill_int_urb(urb, acm->dev, 1208 acm->rx_endpoint, 1209 rb->base, 1210 acm->readsize, 1211 acm_read_bulk_callback, rb, 1212 acm->bInterval); 1213 } else { 1214 usb_fill_bulk_urb(urb, acm->dev, 1215 acm->rx_endpoint, 1216 rb->base, 1217 acm->readsize, 1218 acm_read_bulk_callback, rb); 1219 } 1220 1221 acm->read_urbs[i] = urb; 1222 __set_bit(i, &acm->read_urbs_free); 1223 } 1224 for (i = 0; i < ACM_NW; i++) { 1225 struct acm_wb *snd = &(acm->wb[i]); 1226 1227 snd->urb = usb_alloc_urb(0, GFP_KERNEL); 1228 if (snd->urb == NULL) { 1229 dev_err(&intf->dev, 1230 "out of memory (write urbs usb_alloc_urb)\n"); 1231 goto alloc_fail7; 1232 } 1233 1234 if (usb_endpoint_xfer_int(epwrite)) 1235 usb_fill_int_urb(snd->urb, usb_dev, 1236 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 1237 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval); 1238 else 1239 usb_fill_bulk_urb(snd->urb, usb_dev, 1240 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 1241 NULL, acm->writesize, acm_write_bulk, snd); 1242 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1243 snd->instance = acm; 1244 } 1245 1246 usb_set_intfdata(intf, acm); 1247 1248 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities); 1249 if (i < 0) 1250 goto alloc_fail7; 1251 1252 if (cfd) { /* export the country data */ 1253 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL); 1254 if (!acm->country_codes) 1255 goto skip_countries; 1256 acm->country_code_size = cfd->bLength - 4; 1257 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, 1258 cfd->bLength - 4); 1259 acm->country_rel_date = cfd->iCountryCodeRelDate; 1260 1261 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes); 1262 if (i < 0) { 1263 kfree(acm->country_codes); 1264 acm->country_codes = NULL; 1265 acm->country_code_size = 0; 1266 goto skip_countries; 1267 } 1268 1269 i = device_create_file(&intf->dev, 1270 &dev_attr_iCountryCodeRelDate); 1271 if (i < 0) { 1272 device_remove_file(&intf->dev, &dev_attr_wCountryCodes); 1273 kfree(acm->country_codes); 1274 acm->country_codes = NULL; 1275 acm->country_code_size = 0; 1276 goto skip_countries; 1277 } 1278 } 1279 1280 skip_countries: 1281 usb_fill_int_urb(acm->ctrlurb, usb_dev, 1282 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), 1283 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, 1284 /* works around buggy devices */ 1285 epctrl->bInterval ? epctrl->bInterval : 0xff); 1286 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1287 acm->ctrlurb->transfer_dma = acm->ctrl_dma; 1288 1289 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); 1290 1291 acm_set_control(acm, acm->ctrlout); 1292 1293 acm->line.dwDTERate = cpu_to_le32(9600); 1294 acm->line.bDataBits = 8; 1295 acm_set_line(acm, &acm->line); 1296 1297 usb_driver_claim_interface(&acm_driver, data_interface, acm); 1298 usb_set_intfdata(data_interface, acm); 1299 1300 usb_get_intf(control_interface); 1301 tty_port_register_device(&acm->port, acm_tty_driver, minor, 1302 &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