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