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