xref: /openbmc/linux/drivers/usb/serial/usb_wwan.c (revision b34e08d5)
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 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 
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 
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 
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 
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->minor;
128 	tmp.port            = 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 
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 
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 */
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 
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",
300 				__func__, err);
301 			/* busy also in error unless we are killed */
302 			usb_mark_last_busy(port->serial->dev);
303 		}
304 	} else {
305 		usb_mark_last_busy(port->serial->dev);
306 	}
307 }
308 
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 
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 
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 
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 
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 */
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)
451 		return NULL;
452 
453 	/* Fill URB using supplied data. */
454 	usb_fill_bulk_urb(urb, serial->dev,
455 			  usb_sndbulkpipe(serial->dev, endpoint) | dir,
456 			  buf, len, callback, ctx);
457 
458 	return urb;
459 }
460 
461 int usb_wwan_port_probe(struct usb_serial_port *port)
462 {
463 	struct usb_wwan_port_private *portdata;
464 	struct urb *urb;
465 	u8 *buffer;
466 	int err;
467 	int i;
468 
469 	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
470 	if (!portdata)
471 		return -ENOMEM;
472 
473 	init_usb_anchor(&portdata->delayed);
474 
475 	for (i = 0; i < N_IN_URB; i++) {
476 		if (!port->bulk_in_size)
477 			break;
478 
479 		buffer = (u8 *)__get_free_page(GFP_KERNEL);
480 		if (!buffer)
481 			goto bail_out_error;
482 		portdata->in_buffer[i] = buffer;
483 
484 		urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
485 						USB_DIR_IN, port,
486 						buffer, IN_BUFLEN,
487 						usb_wwan_indat_callback);
488 		portdata->in_urbs[i] = urb;
489 	}
490 
491 	for (i = 0; i < N_OUT_URB; i++) {
492 		if (!port->bulk_out_size)
493 			break;
494 
495 		buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
496 		if (!buffer)
497 			goto bail_out_error2;
498 		portdata->out_buffer[i] = buffer;
499 
500 		urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
501 						USB_DIR_OUT, port,
502 						buffer, OUT_BUFLEN,
503 						usb_wwan_outdat_callback);
504 		portdata->out_urbs[i] = urb;
505 	}
506 
507 	usb_set_serial_port_data(port, portdata);
508 
509 	if (port->interrupt_in_urb) {
510 		err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
511 		if (err)
512 			dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
513 				__func__, err);
514 	}
515 
516 	return 0;
517 
518 bail_out_error2:
519 	for (i = 0; i < N_OUT_URB; i++) {
520 		usb_free_urb(portdata->out_urbs[i]);
521 		kfree(portdata->out_buffer[i]);
522 	}
523 bail_out_error:
524 	for (i = 0; i < N_IN_URB; i++) {
525 		usb_free_urb(portdata->in_urbs[i]);
526 		free_page((unsigned long)portdata->in_buffer[i]);
527 	}
528 	kfree(portdata);
529 
530 	return -ENOMEM;
531 }
532 EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
533 
534 int usb_wwan_port_remove(struct usb_serial_port *port)
535 {
536 	int i;
537 	struct usb_wwan_port_private *portdata;
538 
539 	portdata = usb_get_serial_port_data(port);
540 	usb_set_serial_port_data(port, NULL);
541 
542 	/* Stop reading/writing urbs and free them */
543 	for (i = 0; i < N_IN_URB; i++) {
544 		usb_kill_urb(portdata->in_urbs[i]);
545 		usb_free_urb(portdata->in_urbs[i]);
546 		free_page((unsigned long)portdata->in_buffer[i]);
547 	}
548 	for (i = 0; i < N_OUT_URB; i++) {
549 		usb_kill_urb(portdata->out_urbs[i]);
550 		usb_free_urb(portdata->out_urbs[i]);
551 		kfree(portdata->out_buffer[i]);
552 	}
553 
554 	/* Now free port private data */
555 	kfree(portdata);
556 	return 0;
557 }
558 EXPORT_SYMBOL(usb_wwan_port_remove);
559 
560 #ifdef CONFIG_PM
561 static void stop_read_write_urbs(struct usb_serial *serial)
562 {
563 	int i, j;
564 	struct usb_serial_port *port;
565 	struct usb_wwan_port_private *portdata;
566 
567 	/* Stop reading/writing urbs */
568 	for (i = 0; i < serial->num_ports; ++i) {
569 		port = serial->port[i];
570 		portdata = usb_get_serial_port_data(port);
571 		if (!portdata)
572 			continue;
573 		for (j = 0; j < N_IN_URB; j++)
574 			usb_kill_urb(portdata->in_urbs[j]);
575 		for (j = 0; j < N_OUT_URB; j++)
576 			usb_kill_urb(portdata->out_urbs[j]);
577 	}
578 }
579 
580 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
581 {
582 	struct usb_wwan_intf_private *intfdata = serial->private;
583 	int b;
584 
585 	if (PMSG_IS_AUTO(message)) {
586 		spin_lock_irq(&intfdata->susp_lock);
587 		b = intfdata->in_flight;
588 		spin_unlock_irq(&intfdata->susp_lock);
589 
590 		if (b)
591 			return -EBUSY;
592 	}
593 
594 	spin_lock_irq(&intfdata->susp_lock);
595 	intfdata->suspended = 1;
596 	spin_unlock_irq(&intfdata->susp_lock);
597 	stop_read_write_urbs(serial);
598 
599 	return 0;
600 }
601 EXPORT_SYMBOL(usb_wwan_suspend);
602 
603 static void unbusy_queued_urb(struct urb *urb, struct usb_wwan_port_private *portdata)
604 {
605 	int i;
606 
607 	for (i = 0; i < N_OUT_URB; i++) {
608 		if (urb == portdata->out_urbs[i]) {
609 			clear_bit(i, &portdata->out_busy);
610 			break;
611 		}
612 	}
613 }
614 
615 static void play_delayed(struct usb_serial_port *port)
616 {
617 	struct usb_wwan_intf_private *data;
618 	struct usb_wwan_port_private *portdata;
619 	struct urb *urb;
620 	int err;
621 
622 	portdata = usb_get_serial_port_data(port);
623 	data = port->serial->private;
624 	while ((urb = usb_get_from_anchor(&portdata->delayed))) {
625 		err = usb_submit_urb(urb, GFP_ATOMIC);
626 		if (!err) {
627 			data->in_flight++;
628 		} else {
629 			/* we have to throw away the rest */
630 			do {
631 				unbusy_queued_urb(urb, portdata);
632 				usb_autopm_put_interface_no_suspend(port->serial->interface);
633 			} while ((urb = usb_get_from_anchor(&portdata->delayed)));
634 			break;
635 		}
636 	}
637 }
638 
639 int usb_wwan_resume(struct usb_serial *serial)
640 {
641 	int i, j;
642 	struct usb_serial_port *port;
643 	struct usb_wwan_intf_private *intfdata = serial->private;
644 	struct usb_wwan_port_private *portdata;
645 	struct urb *urb;
646 	int err = 0;
647 
648 	/* get the interrupt URBs resubmitted unconditionally */
649 	for (i = 0; i < serial->num_ports; i++) {
650 		port = serial->port[i];
651 		if (!port->interrupt_in_urb) {
652 			dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
653 			continue;
654 		}
655 		err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
656 		dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
657 		if (err < 0) {
658 			dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
659 				__func__, err);
660 			goto err_out;
661 		}
662 	}
663 
664 	for (i = 0; i < serial->num_ports; i++) {
665 		/* walk all ports */
666 		port = serial->port[i];
667 		portdata = usb_get_serial_port_data(port);
668 
669 		/* skip closed ports */
670 		spin_lock_irq(&intfdata->susp_lock);
671 		if (!portdata || !portdata->opened) {
672 			spin_unlock_irq(&intfdata->susp_lock);
673 			continue;
674 		}
675 
676 		for (j = 0; j < N_IN_URB; j++) {
677 			urb = portdata->in_urbs[j];
678 			err = usb_submit_urb(urb, GFP_ATOMIC);
679 			if (err < 0) {
680 				dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
681 					__func__, err, i);
682 				spin_unlock_irq(&intfdata->susp_lock);
683 				goto err_out;
684 			}
685 		}
686 		play_delayed(port);
687 		spin_unlock_irq(&intfdata->susp_lock);
688 	}
689 	spin_lock_irq(&intfdata->susp_lock);
690 	intfdata->suspended = 0;
691 	spin_unlock_irq(&intfdata->susp_lock);
692 err_out:
693 	return err;
694 }
695 EXPORT_SYMBOL(usb_wwan_resume);
696 #endif
697 
698 MODULE_AUTHOR(DRIVER_AUTHOR);
699 MODULE_DESCRIPTION(DRIVER_DESC);
700 MODULE_LICENSE("GPL");
701