1 /* 2 USB Driver layer for GSM modems 3 4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de> 5 6 This driver is free software; you can redistribute it and/or modify 7 it under the terms of Version 2 of the GNU General Public License as 8 published by the Free Software Foundation. 9 10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org> 11 12 History: see the git log. 13 14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de> 15 16 This driver exists because the "normal" serial driver doesn't work too well 17 with GSM modems. Issues: 18 - data loss -- one single Receive URB is not nearly enough 19 - controlling the baud rate doesn't make sense 20 */ 21 22 #define DRIVER_VERSION "v0.7.2" 23 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 24 #define DRIVER_DESC "USB Driver for GSM modems" 25 26 #include <linux/kernel.h> 27 #include <linux/jiffies.h> 28 #include <linux/errno.h> 29 #include <linux/slab.h> 30 #include <linux/tty.h> 31 #include <linux/tty_flip.h> 32 #include <linux/module.h> 33 #include <linux/bitops.h> 34 #include <linux/uaccess.h> 35 #include <linux/usb.h> 36 #include <linux/usb/serial.h> 37 #include <linux/serial.h> 38 #include "usb-wwan.h" 39 40 static bool debug; 41 42 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on) 43 { 44 struct usb_serial *serial = port->serial; 45 struct usb_wwan_port_private *portdata; 46 47 struct usb_wwan_intf_private *intfdata; 48 49 dbg("%s", __func__); 50 51 intfdata = port->serial->private; 52 53 if (!intfdata->send_setup) 54 return; 55 56 portdata = usb_get_serial_port_data(port); 57 mutex_lock(&serial->disc_mutex); 58 portdata->rts_state = on; 59 portdata->dtr_state = on; 60 if (serial->dev) 61 intfdata->send_setup(port); 62 mutex_unlock(&serial->disc_mutex); 63 } 64 EXPORT_SYMBOL(usb_wwan_dtr_rts); 65 66 void usb_wwan_set_termios(struct tty_struct *tty, 67 struct usb_serial_port *port, 68 struct ktermios *old_termios) 69 { 70 struct usb_wwan_intf_private *intfdata = port->serial->private; 71 72 dbg("%s", __func__); 73 74 /* Doesn't support option setting */ 75 tty_termios_copy_hw(tty->termios, old_termios); 76 77 if (intfdata->send_setup) 78 intfdata->send_setup(port); 79 } 80 EXPORT_SYMBOL(usb_wwan_set_termios); 81 82 int usb_wwan_tiocmget(struct tty_struct *tty) 83 { 84 struct usb_serial_port *port = tty->driver_data; 85 unsigned int value; 86 struct usb_wwan_port_private *portdata; 87 88 portdata = usb_get_serial_port_data(port); 89 90 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 91 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 92 ((portdata->cts_state) ? TIOCM_CTS : 0) | 93 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 94 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 95 ((portdata->ri_state) ? TIOCM_RNG : 0); 96 97 return value; 98 } 99 EXPORT_SYMBOL(usb_wwan_tiocmget); 100 101 int usb_wwan_tiocmset(struct tty_struct *tty, 102 unsigned int set, unsigned int clear) 103 { 104 struct usb_serial_port *port = tty->driver_data; 105 struct usb_wwan_port_private *portdata; 106 struct usb_wwan_intf_private *intfdata; 107 108 portdata = usb_get_serial_port_data(port); 109 intfdata = port->serial->private; 110 111 if (!intfdata->send_setup) 112 return -EINVAL; 113 114 /* FIXME: what locks portdata fields ? */ 115 if (set & TIOCM_RTS) 116 portdata->rts_state = 1; 117 if (set & TIOCM_DTR) 118 portdata->dtr_state = 1; 119 120 if (clear & TIOCM_RTS) 121 portdata->rts_state = 0; 122 if (clear & TIOCM_DTR) 123 portdata->dtr_state = 0; 124 return intfdata->send_setup(port); 125 } 126 EXPORT_SYMBOL(usb_wwan_tiocmset); 127 128 static int get_serial_info(struct usb_serial_port *port, 129 struct serial_struct __user *retinfo) 130 { 131 struct serial_struct tmp; 132 133 if (!retinfo) 134 return -EFAULT; 135 136 memset(&tmp, 0, sizeof(tmp)); 137 tmp.line = port->serial->minor; 138 tmp.port = port->number; 139 tmp.baud_base = tty_get_baud_rate(port->port.tty); 140 tmp.close_delay = port->port.close_delay / 10; 141 tmp.closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 142 ASYNC_CLOSING_WAIT_NONE : 143 port->port.closing_wait / 10; 144 145 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 146 return -EFAULT; 147 return 0; 148 } 149 150 static int set_serial_info(struct usb_serial_port *port, 151 struct serial_struct __user *newinfo) 152 { 153 struct serial_struct new_serial; 154 unsigned int closing_wait, close_delay; 155 int retval = 0; 156 157 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial))) 158 return -EFAULT; 159 160 close_delay = new_serial.close_delay * 10; 161 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 162 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10; 163 164 mutex_lock(&port->port.mutex); 165 166 if (!capable(CAP_SYS_ADMIN)) { 167 if ((close_delay != port->port.close_delay) || 168 (closing_wait != port->port.closing_wait)) 169 retval = -EPERM; 170 else 171 retval = -EOPNOTSUPP; 172 } else { 173 port->port.close_delay = close_delay; 174 port->port.closing_wait = closing_wait; 175 } 176 177 mutex_unlock(&port->port.mutex); 178 return retval; 179 } 180 181 int usb_wwan_ioctl(struct tty_struct *tty, 182 unsigned int cmd, unsigned long arg) 183 { 184 struct usb_serial_port *port = tty->driver_data; 185 186 dbg("%s cmd 0x%04x", __func__, cmd); 187 188 switch (cmd) { 189 case TIOCGSERIAL: 190 return get_serial_info(port, 191 (struct serial_struct __user *) arg); 192 case TIOCSSERIAL: 193 return set_serial_info(port, 194 (struct serial_struct __user *) arg); 195 default: 196 break; 197 } 198 199 dbg("%s arg not supported", __func__); 200 201 return -ENOIOCTLCMD; 202 } 203 EXPORT_SYMBOL(usb_wwan_ioctl); 204 205 /* Write */ 206 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 207 const unsigned char *buf, int count) 208 { 209 struct usb_wwan_port_private *portdata; 210 struct usb_wwan_intf_private *intfdata; 211 int i; 212 int left, todo; 213 struct urb *this_urb = NULL; /* spurious */ 214 int err; 215 unsigned long flags; 216 217 portdata = usb_get_serial_port_data(port); 218 intfdata = port->serial->private; 219 220 dbg("%s: write (%d chars)", __func__, count); 221 222 i = 0; 223 left = count; 224 for (i = 0; left > 0 && i < N_OUT_URB; i++) { 225 todo = left; 226 if (todo > OUT_BUFLEN) 227 todo = OUT_BUFLEN; 228 229 this_urb = portdata->out_urbs[i]; 230 if (test_and_set_bit(i, &portdata->out_busy)) { 231 if (time_before(jiffies, 232 portdata->tx_start_time[i] + 10 * HZ)) 233 continue; 234 usb_unlink_urb(this_urb); 235 continue; 236 } 237 dbg("%s: endpoint %d buf %d", __func__, 238 usb_pipeendpoint(this_urb->pipe), i); 239 240 err = usb_autopm_get_interface_async(port->serial->interface); 241 if (err < 0) 242 break; 243 244 /* send the data */ 245 memcpy(this_urb->transfer_buffer, buf, todo); 246 this_urb->transfer_buffer_length = todo; 247 248 spin_lock_irqsave(&intfdata->susp_lock, flags); 249 if (intfdata->suspended) { 250 usb_anchor_urb(this_urb, &portdata->delayed); 251 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 252 } else { 253 intfdata->in_flight++; 254 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 255 err = usb_submit_urb(this_urb, GFP_ATOMIC); 256 if (err) { 257 dbg("usb_submit_urb %p (write bulk) failed " 258 "(%d)", this_urb, err); 259 clear_bit(i, &portdata->out_busy); 260 spin_lock_irqsave(&intfdata->susp_lock, flags); 261 intfdata->in_flight--; 262 spin_unlock_irqrestore(&intfdata->susp_lock, 263 flags); 264 usb_autopm_put_interface_async(port->serial->interface); 265 break; 266 } 267 } 268 269 portdata->tx_start_time[i] = jiffies; 270 buf += todo; 271 left -= todo; 272 } 273 274 count -= left; 275 dbg("%s: wrote (did %d)", __func__, count); 276 return count; 277 } 278 EXPORT_SYMBOL(usb_wwan_write); 279 280 static void usb_wwan_indat_callback(struct urb *urb) 281 { 282 int err; 283 int endpoint; 284 struct usb_serial_port *port; 285 struct tty_struct *tty; 286 unsigned char *data = urb->transfer_buffer; 287 int status = urb->status; 288 289 dbg("%s: %p", __func__, urb); 290 291 endpoint = usb_pipeendpoint(urb->pipe); 292 port = urb->context; 293 294 if (status) { 295 dbg("%s: nonzero status: %d on endpoint %02x.", 296 __func__, status, endpoint); 297 } else { 298 tty = tty_port_tty_get(&port->port); 299 if (tty) { 300 if (urb->actual_length) { 301 tty_insert_flip_string(tty, data, 302 urb->actual_length); 303 tty_flip_buffer_push(tty); 304 } else 305 dbg("%s: empty read urb received", __func__); 306 tty_kref_put(tty); 307 } 308 309 /* Resubmit urb so we continue receiving */ 310 if (status != -ESHUTDOWN) { 311 err = usb_submit_urb(urb, GFP_ATOMIC); 312 if (err) { 313 if (err != -EPERM) { 314 printk(KERN_ERR "%s: resubmit read urb failed. " 315 "(%d)", __func__, err); 316 /* busy also in error unless we are killed */ 317 usb_mark_last_busy(port->serial->dev); 318 } 319 } else { 320 usb_mark_last_busy(port->serial->dev); 321 } 322 } 323 324 } 325 } 326 327 static void usb_wwan_outdat_callback(struct urb *urb) 328 { 329 struct usb_serial_port *port; 330 struct usb_wwan_port_private *portdata; 331 struct usb_wwan_intf_private *intfdata; 332 int i; 333 334 dbg("%s", __func__); 335 336 port = urb->context; 337 intfdata = port->serial->private; 338 339 usb_serial_port_softint(port); 340 usb_autopm_put_interface_async(port->serial->interface); 341 portdata = usb_get_serial_port_data(port); 342 spin_lock(&intfdata->susp_lock); 343 intfdata->in_flight--; 344 spin_unlock(&intfdata->susp_lock); 345 346 for (i = 0; i < N_OUT_URB; ++i) { 347 if (portdata->out_urbs[i] == urb) { 348 smp_mb__before_clear_bit(); 349 clear_bit(i, &portdata->out_busy); 350 break; 351 } 352 } 353 } 354 355 int usb_wwan_write_room(struct tty_struct *tty) 356 { 357 struct usb_serial_port *port = tty->driver_data; 358 struct usb_wwan_port_private *portdata; 359 int i; 360 int data_len = 0; 361 struct urb *this_urb; 362 363 portdata = usb_get_serial_port_data(port); 364 365 for (i = 0; i < N_OUT_URB; i++) { 366 this_urb = portdata->out_urbs[i]; 367 if (this_urb && !test_bit(i, &portdata->out_busy)) 368 data_len += OUT_BUFLEN; 369 } 370 371 dbg("%s: %d", __func__, data_len); 372 return data_len; 373 } 374 EXPORT_SYMBOL(usb_wwan_write_room); 375 376 int usb_wwan_chars_in_buffer(struct tty_struct *tty) 377 { 378 struct usb_serial_port *port = tty->driver_data; 379 struct usb_wwan_port_private *portdata; 380 int i; 381 int data_len = 0; 382 struct urb *this_urb; 383 384 portdata = usb_get_serial_port_data(port); 385 386 for (i = 0; i < N_OUT_URB; i++) { 387 this_urb = portdata->out_urbs[i]; 388 /* FIXME: This locking is insufficient as this_urb may 389 go unused during the test */ 390 if (this_urb && test_bit(i, &portdata->out_busy)) 391 data_len += this_urb->transfer_buffer_length; 392 } 393 dbg("%s: %d", __func__, data_len); 394 return data_len; 395 } 396 EXPORT_SYMBOL(usb_wwan_chars_in_buffer); 397 398 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port) 399 { 400 struct usb_wwan_port_private *portdata; 401 struct usb_wwan_intf_private *intfdata; 402 struct usb_serial *serial = port->serial; 403 int i, err; 404 struct urb *urb; 405 406 portdata = usb_get_serial_port_data(port); 407 intfdata = serial->private; 408 409 dbg("%s", __func__); 410 411 /* Start reading from the IN endpoint */ 412 for (i = 0; i < N_IN_URB; i++) { 413 urb = portdata->in_urbs[i]; 414 if (!urb) 415 continue; 416 err = usb_submit_urb(urb, GFP_KERNEL); 417 if (err) { 418 dbg("%s: submit urb %d failed (%d) %d", 419 __func__, i, err, urb->transfer_buffer_length); 420 } 421 } 422 423 if (intfdata->send_setup) 424 intfdata->send_setup(port); 425 426 serial->interface->needs_remote_wakeup = 1; 427 spin_lock_irq(&intfdata->susp_lock); 428 portdata->opened = 1; 429 spin_unlock_irq(&intfdata->susp_lock); 430 /* this balances a get in the generic USB serial code */ 431 usb_autopm_put_interface(serial->interface); 432 433 return 0; 434 } 435 EXPORT_SYMBOL(usb_wwan_open); 436 437 void usb_wwan_close(struct usb_serial_port *port) 438 { 439 int i; 440 struct usb_serial *serial = port->serial; 441 struct usb_wwan_port_private *portdata; 442 struct usb_wwan_intf_private *intfdata = port->serial->private; 443 444 dbg("%s", __func__); 445 portdata = usb_get_serial_port_data(port); 446 447 if (serial->dev) { 448 /* Stop reading/writing urbs */ 449 spin_lock_irq(&intfdata->susp_lock); 450 portdata->opened = 0; 451 spin_unlock_irq(&intfdata->susp_lock); 452 453 for (i = 0; i < N_IN_URB; i++) 454 usb_kill_urb(portdata->in_urbs[i]); 455 for (i = 0; i < N_OUT_URB; i++) 456 usb_kill_urb(portdata->out_urbs[i]); 457 /* balancing - important as an error cannot be handled*/ 458 usb_autopm_get_interface_no_resume(serial->interface); 459 serial->interface->needs_remote_wakeup = 0; 460 } 461 } 462 EXPORT_SYMBOL(usb_wwan_close); 463 464 /* Helper functions used by usb_wwan_setup_urbs */ 465 static struct urb *usb_wwan_setup_urb(struct usb_serial *serial, int endpoint, 466 int dir, void *ctx, char *buf, int len, 467 void (*callback) (struct urb *)) 468 { 469 struct urb *urb; 470 471 if (endpoint == -1) 472 return NULL; /* endpoint not needed */ 473 474 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 475 if (urb == NULL) { 476 dbg("%s: alloc for endpoint %d failed.", __func__, endpoint); 477 return NULL; 478 } 479 480 /* Fill URB using supplied data. */ 481 usb_fill_bulk_urb(urb, serial->dev, 482 usb_sndbulkpipe(serial->dev, endpoint) | dir, 483 buf, len, callback, ctx); 484 485 return urb; 486 } 487 488 /* Setup urbs */ 489 static void usb_wwan_setup_urbs(struct usb_serial *serial) 490 { 491 int i, j; 492 struct usb_serial_port *port; 493 struct usb_wwan_port_private *portdata; 494 495 dbg("%s", __func__); 496 497 for (i = 0; i < serial->num_ports; i++) { 498 port = serial->port[i]; 499 portdata = usb_get_serial_port_data(port); 500 501 /* Do indat endpoints first */ 502 for (j = 0; j < N_IN_URB; ++j) { 503 portdata->in_urbs[j] = usb_wwan_setup_urb(serial, 504 port-> 505 bulk_in_endpointAddress, 506 USB_DIR_IN, 507 port, 508 portdata-> 509 in_buffer[j], 510 IN_BUFLEN, 511 usb_wwan_indat_callback); 512 } 513 514 /* outdat endpoints */ 515 for (j = 0; j < N_OUT_URB; ++j) { 516 portdata->out_urbs[j] = usb_wwan_setup_urb(serial, 517 port-> 518 bulk_out_endpointAddress, 519 USB_DIR_OUT, 520 port, 521 portdata-> 522 out_buffer 523 [j], 524 OUT_BUFLEN, 525 usb_wwan_outdat_callback); 526 } 527 } 528 } 529 530 int usb_wwan_startup(struct usb_serial *serial) 531 { 532 int i, j, err; 533 struct usb_serial_port *port; 534 struct usb_wwan_port_private *portdata; 535 u8 *buffer; 536 537 dbg("%s", __func__); 538 539 /* Now setup per port private data */ 540 for (i = 0; i < serial->num_ports; i++) { 541 port = serial->port[i]; 542 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 543 if (!portdata) { 544 dbg("%s: kmalloc for usb_wwan_port_private (%d) failed!.", 545 __func__, i); 546 return 1; 547 } 548 init_usb_anchor(&portdata->delayed); 549 550 for (j = 0; j < N_IN_URB; j++) { 551 buffer = (u8 *) __get_free_page(GFP_KERNEL); 552 if (!buffer) 553 goto bail_out_error; 554 portdata->in_buffer[j] = buffer; 555 } 556 557 for (j = 0; j < N_OUT_URB; j++) { 558 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL); 559 if (!buffer) 560 goto bail_out_error2; 561 portdata->out_buffer[j] = buffer; 562 } 563 564 usb_set_serial_port_data(port, portdata); 565 566 if (!port->interrupt_in_urb) 567 continue; 568 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 569 if (err) 570 dbg("%s: submit irq_in urb failed %d", __func__, err); 571 } 572 usb_wwan_setup_urbs(serial); 573 return 0; 574 575 bail_out_error2: 576 for (j = 0; j < N_OUT_URB; j++) 577 kfree(portdata->out_buffer[j]); 578 bail_out_error: 579 for (j = 0; j < N_IN_URB; j++) 580 if (portdata->in_buffer[j]) 581 free_page((unsigned long)portdata->in_buffer[j]); 582 kfree(portdata); 583 return 1; 584 } 585 EXPORT_SYMBOL(usb_wwan_startup); 586 587 static void stop_read_write_urbs(struct usb_serial *serial) 588 { 589 int i, j; 590 struct usb_serial_port *port; 591 struct usb_wwan_port_private *portdata; 592 593 /* Stop reading/writing urbs */ 594 for (i = 0; i < serial->num_ports; ++i) { 595 port = serial->port[i]; 596 portdata = usb_get_serial_port_data(port); 597 for (j = 0; j < N_IN_URB; j++) 598 usb_kill_urb(portdata->in_urbs[j]); 599 for (j = 0; j < N_OUT_URB; j++) 600 usb_kill_urb(portdata->out_urbs[j]); 601 } 602 } 603 604 void usb_wwan_disconnect(struct usb_serial *serial) 605 { 606 dbg("%s", __func__); 607 608 stop_read_write_urbs(serial); 609 } 610 EXPORT_SYMBOL(usb_wwan_disconnect); 611 612 void usb_wwan_release(struct usb_serial *serial) 613 { 614 int i, j; 615 struct usb_serial_port *port; 616 struct usb_wwan_port_private *portdata; 617 618 dbg("%s", __func__); 619 620 /* Now free them */ 621 for (i = 0; i < serial->num_ports; ++i) { 622 port = serial->port[i]; 623 portdata = usb_get_serial_port_data(port); 624 625 for (j = 0; j < N_IN_URB; j++) { 626 usb_free_urb(portdata->in_urbs[j]); 627 free_page((unsigned long) 628 portdata->in_buffer[j]); 629 portdata->in_urbs[j] = NULL; 630 } 631 for (j = 0; j < N_OUT_URB; j++) { 632 usb_free_urb(portdata->out_urbs[j]); 633 kfree(portdata->out_buffer[j]); 634 portdata->out_urbs[j] = NULL; 635 } 636 } 637 638 /* Now free per port private data */ 639 for (i = 0; i < serial->num_ports; i++) { 640 port = serial->port[i]; 641 kfree(usb_get_serial_port_data(port)); 642 } 643 } 644 EXPORT_SYMBOL(usb_wwan_release); 645 646 #ifdef CONFIG_PM 647 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message) 648 { 649 struct usb_wwan_intf_private *intfdata = serial->private; 650 int b; 651 652 dbg("%s entered", __func__); 653 654 if (PMSG_IS_AUTO(message)) { 655 spin_lock_irq(&intfdata->susp_lock); 656 b = intfdata->in_flight; 657 spin_unlock_irq(&intfdata->susp_lock); 658 659 if (b) 660 return -EBUSY; 661 } 662 663 spin_lock_irq(&intfdata->susp_lock); 664 intfdata->suspended = 1; 665 spin_unlock_irq(&intfdata->susp_lock); 666 stop_read_write_urbs(serial); 667 668 return 0; 669 } 670 EXPORT_SYMBOL(usb_wwan_suspend); 671 672 static void unbusy_queued_urb(struct urb *urb, struct usb_wwan_port_private *portdata) 673 { 674 int i; 675 676 for (i = 0; i < N_OUT_URB; i++) { 677 if (urb == portdata->out_urbs[i]) { 678 clear_bit(i, &portdata->out_busy); 679 break; 680 } 681 } 682 } 683 684 static void play_delayed(struct usb_serial_port *port) 685 { 686 struct usb_wwan_intf_private *data; 687 struct usb_wwan_port_private *portdata; 688 struct urb *urb; 689 int err; 690 691 portdata = usb_get_serial_port_data(port); 692 data = port->serial->private; 693 while ((urb = usb_get_from_anchor(&portdata->delayed))) { 694 err = usb_submit_urb(urb, GFP_ATOMIC); 695 if (!err) { 696 data->in_flight++; 697 } else { 698 /* we have to throw away the rest */ 699 do { 700 unbusy_queued_urb(urb, portdata); 701 usb_autopm_put_interface_no_suspend(port->serial->interface); 702 } while ((urb = usb_get_from_anchor(&portdata->delayed))); 703 break; 704 } 705 } 706 } 707 708 int usb_wwan_resume(struct usb_serial *serial) 709 { 710 int i, j; 711 struct usb_serial_port *port; 712 struct usb_wwan_intf_private *intfdata = serial->private; 713 struct usb_wwan_port_private *portdata; 714 struct urb *urb; 715 int err = 0; 716 717 dbg("%s entered", __func__); 718 /* get the interrupt URBs resubmitted unconditionally */ 719 for (i = 0; i < serial->num_ports; i++) { 720 port = serial->port[i]; 721 if (!port->interrupt_in_urb) { 722 dbg("%s: No interrupt URB for port %d", __func__, i); 723 continue; 724 } 725 err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 726 dbg("Submitted interrupt URB for port %d (result %d)", i, err); 727 if (err < 0) { 728 err("%s: Error %d for interrupt URB of port%d", 729 __func__, err, i); 730 goto err_out; 731 } 732 } 733 734 for (i = 0; i < serial->num_ports; i++) { 735 /* walk all ports */ 736 port = serial->port[i]; 737 portdata = usb_get_serial_port_data(port); 738 739 /* skip closed ports */ 740 spin_lock_irq(&intfdata->susp_lock); 741 if (!portdata->opened) { 742 spin_unlock_irq(&intfdata->susp_lock); 743 continue; 744 } 745 746 for (j = 0; j < N_IN_URB; j++) { 747 urb = portdata->in_urbs[j]; 748 err = usb_submit_urb(urb, GFP_ATOMIC); 749 if (err < 0) { 750 err("%s: Error %d for bulk URB %d", 751 __func__, err, i); 752 spin_unlock_irq(&intfdata->susp_lock); 753 goto err_out; 754 } 755 } 756 play_delayed(port); 757 spin_unlock_irq(&intfdata->susp_lock); 758 } 759 spin_lock_irq(&intfdata->susp_lock); 760 intfdata->suspended = 0; 761 spin_unlock_irq(&intfdata->susp_lock); 762 err_out: 763 return err; 764 } 765 EXPORT_SYMBOL(usb_wwan_resume); 766 #endif 767 768 MODULE_AUTHOR(DRIVER_AUTHOR); 769 MODULE_DESCRIPTION(DRIVER_DESC); 770 MODULE_VERSION(DRIVER_VERSION); 771 MODULE_LICENSE("GPL"); 772 773 module_param(debug, bool, S_IRUGO | S_IWUSR); 774 MODULE_PARM_DESC(debug, "Debug messages"); 775