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
 309                 /* don't resubmit on fatal errors */
 310                 if (status == -ESHUTDOWN || status == -ENOENT)
 311                         return;
 312         } else {
 313                 if (urb->actual_length) {
 314                         tty_insert_flip_string(&port->port, data,
 315                                         urb->actual_length);
 316                         tty_flip_buffer_push(&port->port);
 317                 } else
 318                         dev_dbg(dev, "%s: empty read urb received\n", __func__);
 319         }
 320         /* Resubmit urb so we continue receiving */
 321         err = usb_submit_urb(urb, GFP_ATOMIC);
 322         if (err) {
 323                 if (err != -EPERM && err != -ENODEV) {
 324                         dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
 325                                 __func__, err);
 326                         /* busy also in error unless we are killed */
 327                         usb_mark_last_busy(port->serial->dev);
 328                 }
 329         } else {
 330                 usb_mark_last_busy(port->serial->dev);
 331         }
 332 }
 333
 334 static void usb_wwan_outdat_callback(struct urb *urb)
 335 {
 336         struct usb_serial_port *port;
 337         struct usb_wwan_port_private *portdata;
 338         struct usb_wwan_intf_private *intfdata;
 339         int i;
 340
 341         port = urb->context;
 342         intfdata = usb_get_serial_data(port->serial);
 343
 344         usb_serial_port_softint(port);
 345         usb_autopm_put_interface_async(port->serial->interface);
 346         portdata = usb_get_serial_port_data(port);
 347         spin_lock(&intfdata->susp_lock);
 348         intfdata->in_flight--;
 349         spin_unlock(&intfdata->susp_lock);
 350
 351         for (i = 0; i < N_OUT_URB; ++i) {
 352                 if (portdata->out_urbs[i] == urb) {
 353                         smp_mb__before_atomic();
 354                         clear_bit(i, &portdata->out_busy);
 355                         break;
 356                 }
 357         }
 358 }
 359
 360 int usb_wwan_write_room(struct tty_struct *tty)
 361 {
 362         struct usb_serial_port *port = tty->driver_data;
 363         struct usb_wwan_port_private *portdata;
 364         int i;
 365         int data_len = 0;
 366         struct urb *this_urb;
 367
 368         portdata = usb_get_serial_port_data(port);
 369
 370         for (i = 0; i < N_OUT_URB; i++) {
 371                 this_urb = portdata->out_urbs[i];
 372                 if (this_urb && !test_bit(i, &portdata->out_busy))
 373                         data_len += OUT_BUFLEN;
 374         }
 375
 376         dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
 377         return data_len;
 378 }
 379 EXPORT_SYMBOL(usb_wwan_write_room);
 380
 381 int usb_wwan_chars_in_buffer(struct tty_struct *tty)
 382 {
 383         struct usb_serial_port *port = tty->driver_data;
 384         struct usb_wwan_port_private *portdata;
 385         int i;
 386         int data_len = 0;
 387         struct urb *this_urb;
 388
 389         portdata = usb_get_serial_port_data(port);
 390
 391         for (i = 0; i < N_OUT_URB; i++) {
 392                 this_urb = portdata->out_urbs[i];
 393                 /* FIXME: This locking is insufficient as this_urb may
 394                    go unused during the test */
 395                 if (this_urb && test_bit(i, &portdata->out_busy))
 396                         data_len += this_urb->transfer_buffer_length;
 397         }
 398         dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
 399         return data_len;
 400 }
 401 EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
 402
 403 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
 404 {
 405         struct usb_wwan_port_private *portdata;
 406         struct usb_wwan_intf_private *intfdata;
 407         struct usb_serial *serial = port->serial;
 408         int i, err;
 409         struct urb *urb;
 410
 411         portdata = usb_get_serial_port_data(port);
 412         intfdata = usb_get_serial_data(serial);
 413
 414         if (port->interrupt_in_urb) {
 415                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 416                 if (err) {
 417                         dev_err(&port->dev, "%s: submit int urb failed: %d\n",
 418                                 __func__, err);
 419                 }
 420         }
 421
 422         /* Start reading from the IN endpoint */
 423         for (i = 0; i < N_IN_URB; i++) {
 424                 urb = portdata->in_urbs[i];
 425                 if (!urb)
 426                         continue;
 427                 err = usb_submit_urb(urb, GFP_KERNEL);
 428                 if (err) {
 429                         dev_err(&port->dev,
 430                                 "%s: submit read urb %d failed: %d\n",
 431                                 __func__, i, err);
 432                 }
 433         }
 434
 435         spin_lock_irq(&intfdata->susp_lock);
 436         if (++intfdata->open_ports == 1)
 437                 serial->interface->needs_remote_wakeup = 1;
 438         spin_unlock_irq(&intfdata->susp_lock);
 439         /* this balances a get in the generic USB serial code */
 440         usb_autopm_put_interface(serial->interface);
 441
 442         return 0;
 443 }
 444 EXPORT_SYMBOL(usb_wwan_open);
 445
 446 static void unbusy_queued_urb(struct urb *urb,
 447                                         struct usb_wwan_port_private *portdata)
 448 {
 449         int i;
 450
 451         for (i = 0; i < N_OUT_URB; i++) {
 452                 if (urb == portdata->out_urbs[i]) {
 453                         clear_bit(i, &portdata->out_busy);
 454                         break;
 455                 }
 456         }
 457 }
 458
 459 void usb_wwan_close(struct usb_serial_port *port)
 460 {
 461         int i;
 462         struct usb_serial *serial = port->serial;
 463         struct usb_wwan_port_private *portdata;
 464         struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 465         struct urb *urb;
 466
 467         portdata = usb_get_serial_port_data(port);
 468
 469         /*
 470          * Need to take susp_lock to make sure port is not already being
 471          * resumed, but no need to hold it due to ASYNC_INITIALIZED.
 472          */
 473         spin_lock_irq(&intfdata->susp_lock);
 474         if (--intfdata->open_ports == 0)
 475                 serial->interface->needs_remote_wakeup = 0;
 476         spin_unlock_irq(&intfdata->susp_lock);
 477
 478         for (;;) {
 479                 urb = usb_get_from_anchor(&portdata->delayed);
 480                 if (!urb)
 481                         break;
 482                 unbusy_queued_urb(urb, portdata);
 483                 usb_autopm_put_interface_async(serial->interface);
 484         }
 485
 486         for (i = 0; i < N_IN_URB; i++)
 487                 usb_kill_urb(portdata->in_urbs[i]);
 488         for (i = 0; i < N_OUT_URB; i++)
 489                 usb_kill_urb(portdata->out_urbs[i]);
 490         usb_kill_urb(port->interrupt_in_urb);
 491
 492         usb_autopm_get_interface_no_resume(serial->interface);
 493 }
 494 EXPORT_SYMBOL(usb_wwan_close);
 495
 496 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
 497                                       int endpoint,
 498                                       int dir, void *ctx, char *buf, int len,
 499                                       void (*callback) (struct urb *))
 500 {
 501         struct usb_serial *serial = port->serial;
 502         struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 503         struct urb *urb;
 504
 505         urb = usb_alloc_urb(0, GFP_KERNEL);     /* No ISO */
 506         if (!urb)
 507                 return NULL;
 508
 509         usb_fill_bulk_urb(urb, serial->dev,
 510                           usb_sndbulkpipe(serial->dev, endpoint) | dir,
 511                           buf, len, callback, ctx);
 512
 513         if (intfdata->use_zlp && dir == USB_DIR_OUT)
 514                 urb->transfer_flags |= URB_ZERO_PACKET;
 515
 516         return urb;
 517 }
 518
 519 int usb_wwan_port_probe(struct usb_serial_port *port)
 520 {
 521         struct usb_wwan_port_private *portdata;
 522         struct urb *urb;
 523         u8 *buffer;
 524         int i;
 525
 526         if (!port->bulk_in_size || !port->bulk_out_size)
 527                 return -ENODEV;
 528
 529         portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
 530         if (!portdata)
 531                 return -ENOMEM;
 532
 533         init_usb_anchor(&portdata->delayed);
 534
 535         for (i = 0; i < N_IN_URB; i++) {
 536                 buffer = (u8 *)__get_free_page(GFP_KERNEL);
 537                 if (!buffer)
 538                         goto bail_out_error;
 539                 portdata->in_buffer[i] = buffer;
 540
 541                 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
 542                                                 USB_DIR_IN, port,
 543                                                 buffer, IN_BUFLEN,
 544                                                 usb_wwan_indat_callback);
 545                 portdata->in_urbs[i] = urb;
 546         }
 547
 548         for (i = 0; i < N_OUT_URB; i++) {
 549                 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
 550                 if (!buffer)
 551                         goto bail_out_error2;
 552                 portdata->out_buffer[i] = buffer;
 553
 554                 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
 555                                                 USB_DIR_OUT, port,
 556                                                 buffer, OUT_BUFLEN,
 557                                                 usb_wwan_outdat_callback);
 558                 portdata->out_urbs[i] = urb;
 559         }
 560
 561         usb_set_serial_port_data(port, portdata);
 562
 563         return 0;
 564
 565 bail_out_error2:
 566         for (i = 0; i < N_OUT_URB; i++) {
 567                 usb_free_urb(portdata->out_urbs[i]);
 568                 kfree(portdata->out_buffer[i]);
 569         }
 570 bail_out_error:
 571         for (i = 0; i < N_IN_URB; i++) {
 572                 usb_free_urb(portdata->in_urbs[i]);
 573                 free_page((unsigned long)portdata->in_buffer[i]);
 574         }
 575         kfree(portdata);
 576
 577         return -ENOMEM;
 578 }
 579 EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
 580
 581 int usb_wwan_port_remove(struct usb_serial_port *port)
 582 {
 583         int i;
 584         struct usb_wwan_port_private *portdata;
 585
 586         portdata = usb_get_serial_port_data(port);
 587         usb_set_serial_port_data(port, NULL);
 588
 589         for (i = 0; i < N_IN_URB; i++) {
 590                 usb_free_urb(portdata->in_urbs[i]);
 591                 free_page((unsigned long)portdata->in_buffer[i]);
 592         }
 593         for (i = 0; i < N_OUT_URB; i++) {
 594                 usb_free_urb(portdata->out_urbs[i]);
 595                 kfree(portdata->out_buffer[i]);
 596         }
 597
 598         kfree(portdata);
 599
 600         return 0;
 601 }
 602 EXPORT_SYMBOL(usb_wwan_port_remove);
 603
 604 #ifdef CONFIG_PM
 605 static void stop_urbs(struct usb_serial *serial)
 606 {
 607         int i, j;
 608         struct usb_serial_port *port;
 609         struct usb_wwan_port_private *portdata;
 610
 611         for (i = 0; i < serial->num_ports; ++i) {
 612                 port = serial->port[i];
 613                 portdata = usb_get_serial_port_data(port);
 614                 if (!portdata)
 615                         continue;
 616                 for (j = 0; j < N_IN_URB; j++)
 617                         usb_kill_urb(portdata->in_urbs[j]);
 618                 for (j = 0; j < N_OUT_URB; j++)
 619                         usb_kill_urb(portdata->out_urbs[j]);
 620                 usb_kill_urb(port->interrupt_in_urb);
 621         }
 622 }
 623
 624 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
 625 {
 626         struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 627
 628         spin_lock_irq(&intfdata->susp_lock);
 629         if (PMSG_IS_AUTO(message)) {
 630                 if (intfdata->in_flight) {
 631                         spin_unlock_irq(&intfdata->susp_lock);
 632                         return -EBUSY;
 633                 }
 634         }
 635         intfdata->suspended = 1;
 636         spin_unlock_irq(&intfdata->susp_lock);
 637
 638         stop_urbs(serial);
 639
 640         return 0;
 641 }
 642 EXPORT_SYMBOL(usb_wwan_suspend);
 643
 644 /* Caller must hold susp_lock. */
 645 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
 646 {
 647         struct usb_serial *serial = port->serial;
 648         struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
 649         struct usb_wwan_port_private *portdata;
 650         struct urb *urb;
 651         int err_count = 0;
 652         int err;
 653
 654         portdata = usb_get_serial_port_data(port);
 655
 656         for (;;) {
 657                 urb = usb_get_from_anchor(&portdata->delayed);
 658                 if (!urb)
 659                         break;
 660
 661                 err = usb_submit_urb(urb, GFP_ATOMIC);
 662                 if (err) {
 663                         dev_err(&port->dev, "%s: submit urb failed: %d\n",
 664                                         __func__, err);
 665                         err_count++;
 666                         unbusy_queued_urb(urb, portdata);
 667                         usb_autopm_put_interface_async(serial->interface);
 668                         continue;
 669                 }
 670                 data->in_flight++;
 671         }
 672
 673         if (err_count)
 674                 return -EIO;
 675
 676         return 0;
 677 }
 678
 679 int usb_wwan_resume(struct usb_serial *serial)
 680 {
 681         int i, j;
 682         struct usb_serial_port *port;
 683         struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 684         struct usb_wwan_port_private *portdata;
 685         struct urb *urb;
 686         int err;
 687         int err_count = 0;
 688
 689         spin_lock_irq(&intfdata->susp_lock);
 690         for (i = 0; i < serial->num_ports; i++) {
 691                 port = serial->port[i];
 692
 693                 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
 694                         continue;
 695
 696                 portdata = usb_get_serial_port_data(port);
 697
 698                 if (port->interrupt_in_urb) {
 699                         err = usb_submit_urb(port->interrupt_in_urb,
 700                                         GFP_ATOMIC);
 701                         if (err) {
 702                                 dev_err(&port->dev,
 703                                         "%s: submit int urb failed: %d\n",
 704                                         __func__, err);
 705                                 err_count++;
 706                         }
 707                 }
 708
 709                 err = usb_wwan_submit_delayed_urbs(port);
 710                 if (err)
 711                         err_count++;
 712
 713                 for (j = 0; j < N_IN_URB; j++) {
 714                         urb = portdata->in_urbs[j];
 715                         err = usb_submit_urb(urb, GFP_ATOMIC);
 716                         if (err < 0) {
 717                                 dev_err(&port->dev,
 718                                         "%s: submit read urb %d failed: %d\n",
 719                                         __func__, i, err);
 720                                 err_count++;
 721                         }
 722                 }
 723         }
 724         intfdata->suspended = 0;
 725         spin_unlock_irq(&intfdata->susp_lock);
 726
 727         if (err_count)
 728                 return -EIO;
 729
 730         return 0;
 731 }
 732 EXPORT_SYMBOL(usb_wwan_resume);
 733 #endif
 734
 735 MODULE_AUTHOR(DRIVER_AUTHOR);
 736 MODULE_DESCRIPTION(DRIVER_DESC);
 737 MODULE_LICENSE("GPL");