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