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