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