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