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