blob: eacc27dc465788eb456cc7496207d58efe730cc2 [file] [log] [blame]
Matthew Garrett0d456192010-04-01 12:31:07 -04001/*
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
Matthew Garrett0d456192010-04-01 12:31:07 -040022#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>
Peter Huewe66921ed2010-12-09 23:27:35 +010033#include <linux/uaccess.h>
Matthew Garrett0d456192010-04-01 12:31:07 -040034#include <linux/usb.h>
35#include <linux/usb/serial.h>
Dan Williams02303f72010-11-19 16:04:00 -060036#include <linux/serial.h>
Matthew Garrett0d456192010-04-01 12:31:07 -040037#include "usb-wwan.h"
38
Matthew Garrett0d456192010-04-01 12:31:07 -040039void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
40{
Matthew Garrett0d456192010-04-01 12:31:07 -040041 struct usb_wwan_port_private *portdata;
Matthew Garrett0d456192010-04-01 12:31:07 -040042 struct usb_wwan_intf_private *intfdata;
43
Matthew Garrett0d456192010-04-01 12:31:07 -040044 intfdata = port->serial->private;
45
46 if (!intfdata->send_setup)
47 return;
48
49 portdata = usb_get_serial_port_data(port);
Johan Hovoldb2ca6992013-02-13 17:53:28 +010050 /* FIXME: locking */
Matthew Garrett0d456192010-04-01 12:31:07 -040051 portdata->rts_state = on;
52 portdata->dtr_state = on;
Johan Hovoldb2ca6992013-02-13 17:53:28 +010053
54 intfdata->send_setup(port);
Matthew Garrett0d456192010-04-01 12:31:07 -040055}
56EXPORT_SYMBOL(usb_wwan_dtr_rts);
57
58void 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
Matthew Garrett0d456192010-04-01 12:31:07 -040064 /* Doesn't support option setting */
Alan Coxadc8d742012-07-14 15:31:47 +010065 tty_termios_copy_hw(&tty->termios, old_termios);
Matthew Garrett0d456192010-04-01 12:31:07 -040066
67 if (intfdata->send_setup)
68 intfdata->send_setup(port);
69}
70EXPORT_SYMBOL(usb_wwan_set_termios);
71
Alan Cox60b33c12011-02-14 16:26:14 +000072int usb_wwan_tiocmget(struct tty_struct *tty)
Matthew Garrett0d456192010-04-01 12:31:07 -040073{
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}
89EXPORT_SYMBOL(usb_wwan_tiocmget);
90
Alan Cox20b9d172011-02-14 16:26:50 +000091int usb_wwan_tiocmset(struct tty_struct *tty,
Matthew Garrett0d456192010-04-01 12:31:07 -040092 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}
116EXPORT_SYMBOL(usb_wwan_tiocmset);
117
Dan Williams02303f72010-11-19 16:04:00 -0600118static 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;
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700128 tmp.port = port->port_number;
Dan Williams02303f72010-11-19 16:04:00 -0600129 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
140static 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
Alan Cox00a0d0d2011-02-14 16:27:06 +0000171int usb_wwan_ioctl(struct tty_struct *tty,
Dan Williams02303f72010-11-19 16:04:00 -0600172 unsigned int cmd, unsigned long arg)
173{
174 struct usb_serial_port *port = tty->driver_data;
175
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700176 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
Dan Williams02303f72010-11-19 16:04:00 -0600177
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
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700189 dev_dbg(&port->dev, "%s arg not supported\n", __func__);
Dan Williams02303f72010-11-19 16:04:00 -0600190
191 return -ENOIOCTLCMD;
192}
193EXPORT_SYMBOL(usb_wwan_ioctl);
194
Matthew Garrett0d456192010-04-01 12:31:07 -0400195/* Write */
196int 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
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700210 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
Matthew Garrett0d456192010-04-01 12:31:07 -0400211
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 }
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700227 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
228 usb_pipeendpoint(this_urb->pipe), i);
Matthew Garrett0d456192010-04-01 12:31:07 -0400229
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) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700247 dev_dbg(&port->dev,
248 "usb_submit_urb %p (write bulk) failed (%d)\n",
249 this_urb, err);
Matthew Garrett0d456192010-04-01 12:31:07 -0400250 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);
Oliver Neukum3d06bf12011-02-10 15:33:17 +0100255 usb_autopm_put_interface_async(port->serial->interface);
Oliver Neukum433508a2011-02-10 15:33:23 +0100256 break;
Matthew Garrett0d456192010-04-01 12:31:07 -0400257 }
258 }
259
260 portdata->tx_start_time[i] = jiffies;
261 buf += todo;
262 left -= todo;
263 }
264
265 count -= left;
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700266 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
Matthew Garrett0d456192010-04-01 12:31:07 -0400267 return count;
268}
269EXPORT_SYMBOL(usb_wwan_write);
270
271static void usb_wwan_indat_callback(struct urb *urb)
272{
273 int err;
274 int endpoint;
275 struct usb_serial_port *port;
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700276 struct device *dev;
Matthew Garrett0d456192010-04-01 12:31:07 -0400277 unsigned char *data = urb->transfer_buffer;
278 int status = urb->status;
279
Matthew Garrett0d456192010-04-01 12:31:07 -0400280 endpoint = usb_pipeendpoint(urb->pipe);
281 port = urb->context;
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700282 dev = &port->dev;
Matthew Garrett0d456192010-04-01 12:31:07 -0400283
284 if (status) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700285 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
286 __func__, status, endpoint);
Matthew Garrett0d456192010-04-01 12:31:07 -0400287 } else {
Jiri Slaby2e124b42013-01-03 15:53:06 +0100288 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__);
Matthew Garrett0d456192010-04-01 12:31:07 -0400294
295 /* Resubmit urb so we continue receiving */
Dan Carpenterec428992012-04-20 09:33:31 +0300296 err = usb_submit_urb(urb, GFP_ATOMIC);
297 if (err) {
298 if (err != -EPERM) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700299 dev_err(dev, "%s: resubmit read urb failed. (%d)\n", __func__, err);
Dan Carpenterec428992012-04-20 09:33:31 +0300300 /* busy also in error unless we are killed */
Matthew Garrett0d456192010-04-01 12:31:07 -0400301 usb_mark_last_busy(port->serial->dev);
Oliver Neukumc9c45582011-02-10 15:33:10 +0100302 }
Dan Carpenterec428992012-04-20 09:33:31 +0300303 } else {
304 usb_mark_last_busy(port->serial->dev);
Matthew Garrett0d456192010-04-01 12:31:07 -0400305 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400306 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400307}
308
309static 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400316 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
335int 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
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700351 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
Matthew Garrett0d456192010-04-01 12:31:07 -0400352 return data_len;
353}
354EXPORT_SYMBOL(usb_wwan_write_room);
355
356int 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 }
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700373 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
Matthew Garrett0d456192010-04-01 12:31:07 -0400374 return data_len;
375}
376EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
377
378int 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400389 /* 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) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700396 dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
397 __func__, i, err, urb->transfer_buffer_length);
Matthew Garrett0d456192010-04-01 12:31:07 -0400398 }
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);
Oliver Neukum9a91aed2011-02-10 15:33:37 +0100408 /* this balances a get in the generic USB serial code */
Matthew Garrett0d456192010-04-01 12:31:07 -0400409 usb_autopm_put_interface(serial->interface);
410
411 return 0;
412}
413EXPORT_SYMBOL(usb_wwan_open);
414
415void 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400422 portdata = usb_get_serial_port_data(port);
423
Johan Hovolde6d144b2013-03-21 12:36:37 +0100424 /* Stop reading/writing urbs */
425 spin_lock_irq(&intfdata->susp_lock);
426 portdata->opened = 0;
427 spin_unlock_irq(&intfdata->susp_lock);
Matthew Garrett0d456192010-04-01 12:31:07 -0400428
Johan Hovolde6d144b2013-03-21 12:36:37 +0100429 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;
Matthew Garrett0d456192010-04-01 12:31:07 -0400437}
438EXPORT_SYMBOL(usb_wwan_close);
439
440/* Helper functions used by usb_wwan_setup_urbs */
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200441static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
442 int endpoint,
Matthew Garrett0d456192010-04-01 12:31:07 -0400443 int dir, void *ctx, char *buf, int len,
444 void (*callback) (struct urb *))
445{
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200446 struct usb_serial *serial = port->serial;
Matthew Garrett0d456192010-04-01 12:31:07 -0400447 struct urb *urb;
448
Matthew Garrett0d456192010-04-01 12:31:07 -0400449 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
450 if (urb == NULL) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700451 dev_dbg(&serial->interface->dev,
452 "%s: alloc for endpoint %d failed.\n", __func__,
453 endpoint);
Matthew Garrett0d456192010-04-01 12:31:07 -0400454 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
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200465int usb_wwan_port_probe(struct usb_serial_port *port)
Matthew Garrett0d456192010-04-01 12:31:07 -0400466{
Matthew Garrett0d456192010-04-01 12:31:07 -0400467 struct usb_wwan_port_private *portdata;
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200468 struct urb *urb;
Matthew Garrett0d456192010-04-01 12:31:07 -0400469 u8 *buffer;
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200470 int err;
471 int i;
Matthew Garrett0d456192010-04-01 12:31:07 -0400472
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200473 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
474 if (!portdata)
475 return -ENOMEM;
Matthew Garrett0d456192010-04-01 12:31:07 -0400476
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200477 init_usb_anchor(&portdata->delayed);
Matthew Garrett0d456192010-04-01 12:31:07 -0400478
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200479 for (i = 0; i < N_IN_URB; i++) {
Johan Hovold8e493ca12012-10-26 18:44:20 +0200480 if (!port->bulk_in_size)
481 break;
482
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200483 buffer = (u8 *)__get_free_page(GFP_KERNEL);
484 if (!buffer)
485 goto bail_out_error;
486 portdata->in_buffer[i] = buffer;
Matthew Garrett0d456192010-04-01 12:31:07 -0400487
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200488 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 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400494
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200495 for (i = 0; i < N_OUT_URB; i++) {
Johan Hovold8e493ca12012-10-26 18:44:20 +0200496 if (!port->bulk_out_size)
497 break;
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200498
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) {
Matthew Garrett0d456192010-04-01 12:31:07 -0400514 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
515 if (err)
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700516 dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
517 __func__, err);
Matthew Garrett0d456192010-04-01 12:31:07 -0400518 }
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200519
Matthew Garrett0d456192010-04-01 12:31:07 -0400520 return 0;
521
522bail_out_error2:
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200523 for (i = 0; i < N_OUT_URB; i++) {
524 usb_free_urb(portdata->out_urbs[i]);
525 kfree(portdata->out_buffer[i]);
526 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400527bail_out_error:
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200528 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 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400532 kfree(portdata);
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200533
534 return -ENOMEM;
Matthew Garrett0d456192010-04-01 12:31:07 -0400535}
Johan Hovoldb8f0e822012-10-25 10:29:16 +0200536EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
Matthew Garrett0d456192010-04-01 12:31:07 -0400537
Bjørn Morka1028f02012-07-27 01:11:41 +0200538int 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}
562EXPORT_SYMBOL(usb_wwan_port_remove);
563
564#ifdef CONFIG_PM
Matthew Garrett0d456192010-04-01 12:31:07 -0400565static 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);
Bjørn Mork032129c2012-07-27 01:11:43 +0200575 if (!portdata)
576 continue;
Matthew Garrett0d456192010-04-01 12:31:07 -0400577 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400584int 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
Alan Stern5b1b0b82011-08-19 23:49:48 +0200589 if (PMSG_IS_AUTO(message)) {
Matthew Garrett0d456192010-04-01 12:31:07 -0400590 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}
605EXPORT_SYMBOL(usb_wwan_suspend);
606
Oliver Neukum16871dc2011-02-10 15:33:29 +0100607static 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400619static 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);
Oliver Neukum16871dc2011-02-10 15:33:29 +0100630 if (!err) {
Matthew Garrett0d456192010-04-01 12:31:07 -0400631 data->in_flight++;
Oliver Neukum16871dc2011-02-10 15:33:29 +0100632 } else {
633 /* we have to throw away the rest */
634 do {
635 unbusy_queued_urb(urb, portdata);
Oliver Neukum97ac01d2011-03-18 12:44:17 +0100636 usb_autopm_put_interface_no_suspend(port->serial->interface);
Oliver Neukum16871dc2011-02-10 15:33:29 +0100637 } while ((urb = usb_get_from_anchor(&portdata->delayed)));
638 break;
639 }
Matthew Garrett0d456192010-04-01 12:31:07 -0400640 }
641}
642
643int 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
Matthew Garrett0d456192010-04-01 12:31:07 -0400652 /* 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) {
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700656 dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
Matthew Garrett0d456192010-04-01 12:31:07 -0400657 continue;
658 }
659 err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
Greg Kroah-Hartmana80be972012-09-13 17:41:50 -0700660 dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
Matthew Garrett0d456192010-04-01 12:31:07 -0400661 if (err < 0) {
Greg Kroah-Hartman3a1c2a82012-04-20 16:54:01 -0700662 dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
663 __func__, err);
Matthew Garrett0d456192010-04-01 12:31:07 -0400664 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);
Bjørn Mork032129c2012-07-27 01:11:43 +0200675 if (!portdata || !portdata->opened) {
Matthew Garrett0d456192010-04-01 12:31:07 -0400676 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) {
Greg Kroah-Hartman3a1c2a82012-04-20 16:54:01 -0700684 dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
685 __func__, err, i);
Matthew Garrett0d456192010-04-01 12:31:07 -0400686 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);
696err_out:
697 return err;
698}
699EXPORT_SYMBOL(usb_wwan_resume);
700#endif
701
702MODULE_AUTHOR(DRIVER_AUTHOR);
703MODULE_DESCRIPTION(DRIVER_DESC);
Matthew Garrett0d456192010-04-01 12:31:07 -0400704MODULE_LICENSE("GPL");