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