drivers/usb/serial/usb_wwan.c

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