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 */
usb_wwan_send_setup(struct usb_serial_port * port)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
usb_wwan_dtr_rts(struct usb_serial_port * port,int on)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
usb_wwan_tiocmget(struct tty_struct * tty)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
usb_wwan_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)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
get_serial_info(struct usb_serial_port * port,struct serial_struct __user * retinfo)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
set_serial_info(struct usb_serial_port * port,struct serial_struct __user * newinfo)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
usb_wwan_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)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
usb_wwan_write(struct tty_struct * tty,struct usb_serial_port * port,const unsigned char * buf,int count)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
usb_wwan_indat_callback(struct urb * urb)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
usb_wwan_outdat_callback(struct urb * urb)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
usb_wwan_write_room(struct tty_struct * tty)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
usb_wwan_chars_in_buffer(struct tty_struct * tty)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
usb_wwan_open(struct tty_struct * tty,struct usb_serial_port * port)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
unbusy_queued_urb(struct urb * urb,struct usb_wwan_port_private * portdata)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
usb_wwan_close(struct usb_serial_port * port)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
usb_wwan_setup_urb(struct usb_serial_port * port,int endpoint,int dir,void * ctx,char * buf,int len,void (* callback)(struct urb *))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
usb_wwan_port_probe(struct usb_serial_port * port)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
usb_wwan_port_remove(struct usb_serial_port * port)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
stop_urbs(struct usb_serial * serial)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
usb_wwan_suspend(struct usb_serial * serial,pm_message_t message)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. */
usb_wwan_submit_delayed_urbs(struct usb_serial_port * port)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
usb_wwan_resume(struct usb_serial * serial)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");
738