[deliverable/linux.git] / drivers / usb / serial / usb_wwan.c

/*
  USB Driver layer for GSM modems

  Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>

  This driver is free software; you can redistribute it and/or modify
  it under the terms of Version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>

  History: see the git log.

  Work sponsored by: Sigos GmbH, Germany <info@sigos.de>

  This driver exists because the "normal" serial driver doesn't work too well
  with GSM modems. Issues:
  - data loss -- one single Receive URB is not nearly enough
  - controlling the baud rate doesn't make sense
*/

#define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
#define DRIVER_DESC "USB Driver for GSM modems"

#include <linux/kernel.h>
#include <linux/jiffies.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/bitops.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/serial.h>
#include "usb-wwan.h"

void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
{
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata;

	intfdata = port->serial->private;

	if (!intfdata->send_setup)
		return;

	portdata = usb_get_serial_port_data(port);
	/* FIXME: locking */
	portdata->rts_state = on;
	portdata->dtr_state = on;

	intfdata->send_setup(port);
}
EXPORT_SYMBOL(usb_wwan_dtr_rts);

void usb_wwan_set_termios(struct tty_struct *tty,
			  struct usb_serial_port *port,
			  struct ktermios *old_termios)
{
	struct usb_wwan_intf_private *intfdata = port->serial->private;

	/* Doesn't support option setting */
	tty_termios_copy_hw(&tty->termios, old_termios);

	if (intfdata->send_setup)
		intfdata->send_setup(port);
}
EXPORT_SYMBOL(usb_wwan_set_termios);

int usb_wwan_tiocmget(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	unsigned int value;
	struct usb_wwan_port_private *portdata;

	portdata = usb_get_serial_port_data(port);

	value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
	    ((portdata->dtr_state) ? TIOCM_DTR : 0) |
	    ((portdata->cts_state) ? TIOCM_CTS : 0) |
	    ((portdata->dsr_state) ? TIOCM_DSR : 0) |
	    ((portdata->dcd_state) ? TIOCM_CAR : 0) |
	    ((portdata->ri_state) ? TIOCM_RNG : 0);

	return value;
}
EXPORT_SYMBOL(usb_wwan_tiocmget);

int usb_wwan_tiocmset(struct tty_struct *tty,
		      unsigned int set, unsigned int clear)
{
	struct usb_serial_port *port = tty->driver_data;
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata;

	portdata = usb_get_serial_port_data(port);
	intfdata = port->serial->private;

	if (!intfdata->send_setup)
		return -EINVAL;

	/* FIXME: what locks portdata fields ? */
	if (set & TIOCM_RTS)
		portdata->rts_state = 1;
	if (set & TIOCM_DTR)
		portdata->dtr_state = 1;

	if (clear & TIOCM_RTS)
		portdata->rts_state = 0;
	if (clear & TIOCM_DTR)
		portdata->dtr_state = 0;
	return intfdata->send_setup(port);
}
EXPORT_SYMBOL(usb_wwan_tiocmset);

static int get_serial_info(struct usb_serial_port *port,
			   struct serial_struct __user *retinfo)
{
	struct serial_struct tmp;

	if (!retinfo)
		return -EFAULT;

	memset(&tmp, 0, sizeof(tmp));
	tmp.line            = port->minor;
	tmp.port            = port->port_number;
	tmp.baud_base       = tty_get_baud_rate(port->port.tty);
	tmp.close_delay	    = port->port.close_delay / 10;
	tmp.closing_wait    = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
				 ASYNC_CLOSING_WAIT_NONE :
				 port->port.closing_wait / 10;

	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
		return -EFAULT;
	return 0;
}

static int set_serial_info(struct usb_serial_port *port,
			   struct serial_struct __user *newinfo)
{
	struct serial_struct new_serial;
	unsigned int closing_wait, close_delay;
	int retval = 0;

	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
		return -EFAULT;

	close_delay = new_serial.close_delay * 10;
	closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
			ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;

	mutex_lock(&port->port.mutex);

	if (!capable(CAP_SYS_ADMIN)) {
		if ((close_delay != port->port.close_delay) ||
		    (closing_wait != port->port.closing_wait))
			retval = -EPERM;
		else
			retval = -EOPNOTSUPP;
	} else {
		port->port.close_delay  = close_delay;
		port->port.closing_wait = closing_wait;
	}

	mutex_unlock(&port->port.mutex);
	return retval;
}

int usb_wwan_ioctl(struct tty_struct *tty,
		   unsigned int cmd, unsigned long arg)
{
	struct usb_serial_port *port = tty->driver_data;

	dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);

	switch (cmd) {
	case TIOCGSERIAL:
		return get_serial_info(port,
				       (struct serial_struct __user *) arg);
	case TIOCSSERIAL:
		return set_serial_info(port,
				       (struct serial_struct __user *) arg);
	default:
		break;
	}

	dev_dbg(&port->dev, "%s arg not supported\n", __func__);

	return -ENOIOCTLCMD;
}
EXPORT_SYMBOL(usb_wwan_ioctl);

/* Write */
int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
		   const unsigned char *buf, int count)
{
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata;
	int i;
	int left, todo;
	struct urb *this_urb = NULL;	/* spurious */
	int err;
	unsigned long flags;

	portdata = usb_get_serial_port_data(port);
	intfdata = port->serial->private;

	dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);

	i = 0;
	left = count;
	for (i = 0; left > 0 && i < N_OUT_URB; i++) {
		todo = left;
		if (todo > OUT_BUFLEN)
			todo = OUT_BUFLEN;

		this_urb = portdata->out_urbs[i];
		if (test_and_set_bit(i, &portdata->out_busy)) {
			if (time_before(jiffies,
					portdata->tx_start_time[i] + 10 * HZ))
				continue;
			usb_unlink_urb(this_urb);
			continue;
		}
		dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
			usb_pipeendpoint(this_urb->pipe), i);

		err = usb_autopm_get_interface_async(port->serial->interface);
		if (err < 0) {
			clear_bit(i, &portdata->out_busy);
			break;
		}

		/* send the data */
		memcpy(this_urb->transfer_buffer, buf, todo);
		this_urb->transfer_buffer_length = todo;

		spin_lock_irqsave(&intfdata->susp_lock, flags);
		if (intfdata->suspended) {
			usb_anchor_urb(this_urb, &portdata->delayed);
			spin_unlock_irqrestore(&intfdata->susp_lock, flags);
		} else {
			intfdata->in_flight++;
			spin_unlock_irqrestore(&intfdata->susp_lock, flags);
			err = usb_submit_urb(this_urb, GFP_ATOMIC);
			if (err) {
				dev_dbg(&port->dev,
					"usb_submit_urb %p (write bulk) failed (%d)\n",
					this_urb, err);
				clear_bit(i, &portdata->out_busy);
				spin_lock_irqsave(&intfdata->susp_lock, flags);
				intfdata->in_flight--;
				spin_unlock_irqrestore(&intfdata->susp_lock,
						       flags);
				usb_autopm_put_interface_async(port->serial->interface);
				break;
			}
		}

		portdata->tx_start_time[i] = jiffies;
		buf += todo;
		left -= todo;
	}

	count -= left;
	dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
	return count;
}
EXPORT_SYMBOL(usb_wwan_write);

static void usb_wwan_indat_callback(struct urb *urb)
{
	int err;
	int endpoint;
	struct usb_serial_port *port;
	struct device *dev;
	unsigned char *data = urb->transfer_buffer;
	int status = urb->status;

	endpoint = usb_pipeendpoint(urb->pipe);
	port = urb->context;
	dev = &port->dev;

	if (status) {
		dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
			__func__, status, endpoint);
	} else {
		if (urb->actual_length) {
			tty_insert_flip_string(&port->port, data,
					urb->actual_length);
			tty_flip_buffer_push(&port->port);
		} else
			dev_dbg(dev, "%s: empty read urb received\n", __func__);
	}
	/* Resubmit urb so we continue receiving */
	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err) {
		if (err != -EPERM) {
			dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
				__func__, err);
			/* busy also in error unless we are killed */
			usb_mark_last_busy(port->serial->dev);
		}
	} else {
		usb_mark_last_busy(port->serial->dev);
	}
}

static void usb_wwan_outdat_callback(struct urb *urb)
{
	struct usb_serial_port *port;
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata;
	int i;

	port = urb->context;
	intfdata = port->serial->private;

	usb_serial_port_softint(port);
	usb_autopm_put_interface_async(port->serial->interface);
	portdata = usb_get_serial_port_data(port);
	spin_lock(&intfdata->susp_lock);
	intfdata->in_flight--;
	spin_unlock(&intfdata->susp_lock);

	for (i = 0; i < N_OUT_URB; ++i) {
		if (portdata->out_urbs[i] == urb) {
			smp_mb__before_clear_bit();
			clear_bit(i, &portdata->out_busy);
			break;
		}
	}
}

int usb_wwan_write_room(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct usb_wwan_port_private *portdata;
	int i;
	int data_len = 0;
	struct urb *this_urb;

	portdata = usb_get_serial_port_data(port);

	for (i = 0; i < N_OUT_URB; i++) {
		this_urb = portdata->out_urbs[i];
		if (this_urb && !test_bit(i, &portdata->out_busy))
			data_len += OUT_BUFLEN;
	}

	dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
	return data_len;
}
EXPORT_SYMBOL(usb_wwan_write_room);

int usb_wwan_chars_in_buffer(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct usb_wwan_port_private *portdata;
	int i;
	int data_len = 0;
	struct urb *this_urb;

	portdata = usb_get_serial_port_data(port);

	for (i = 0; i < N_OUT_URB; i++) {
		this_urb = portdata->out_urbs[i];
		/* FIXME: This locking is insufficient as this_urb may
		   go unused during the test */
		if (this_urb && test_bit(i, &portdata->out_busy))
			data_len += this_urb->transfer_buffer_length;
	}
	dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
	return data_len;
}
EXPORT_SYMBOL(usb_wwan_chars_in_buffer);

int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata;
	struct usb_serial *serial = port->serial;
	int i, err;
	struct urb *urb;

	portdata = usb_get_serial_port_data(port);
	intfdata = serial->private;

	if (port->interrupt_in_urb) {
		err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
		if (err) {
			dev_dbg(&port->dev, "%s: submit int urb failed: %d\n",
				__func__, err);
		}
	}

	/* Start reading from the IN endpoint */
	for (i = 0; i < N_IN_URB; i++) {
		urb = portdata->in_urbs[i];
		if (!urb)
			continue;
		err = usb_submit_urb(urb, GFP_KERNEL);
		if (err) {
			dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
				__func__, i, err, urb->transfer_buffer_length);
		}
	}

	if (intfdata->send_setup)
		intfdata->send_setup(port);

	serial->interface->needs_remote_wakeup = 1;
	spin_lock_irq(&intfdata->susp_lock);
	portdata->opened = 1;
	spin_unlock_irq(&intfdata->susp_lock);
	/* this balances a get in the generic USB serial code */
	usb_autopm_put_interface(serial->interface);

	return 0;
}
EXPORT_SYMBOL(usb_wwan_open);

static void unbusy_queued_urb(struct urb *urb,
					struct usb_wwan_port_private *portdata)
{
	int i;

	for (i = 0; i < N_OUT_URB; i++) {
		if (urb == portdata->out_urbs[i]) {
			clear_bit(i, &portdata->out_busy);
			break;
		}
	}
}

void usb_wwan_close(struct usb_serial_port *port)
{
	int i;
	struct usb_serial *serial = port->serial;
	struct usb_wwan_port_private *portdata;
	struct usb_wwan_intf_private *intfdata = port->serial->private;
	struct urb *urb;

	portdata = usb_get_serial_port_data(port);

	/* Stop reading/writing urbs */
	spin_lock_irq(&intfdata->susp_lock);
	portdata->opened = 0;
	spin_unlock_irq(&intfdata->susp_lock);

	for (;;) {
		urb = usb_get_from_anchor(&portdata->delayed);
		if (!urb)
			break;
		unbusy_queued_urb(urb, portdata);
		usb_autopm_put_interface_async(serial->interface);
	}

	for (i = 0; i < N_IN_URB; i++)
		usb_kill_urb(portdata->in_urbs[i]);
	for (i = 0; i < N_OUT_URB; i++)
		usb_kill_urb(portdata->out_urbs[i]);
	usb_kill_urb(port->interrupt_in_urb);

	/* balancing - important as an error cannot be handled*/
	usb_autopm_get_interface_no_resume(serial->interface);
	serial->interface->needs_remote_wakeup = 0;
}
EXPORT_SYMBOL(usb_wwan_close);

/* Helper functions used by usb_wwan_setup_urbs */
static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
				      int endpoint,
				      int dir, void *ctx, char *buf, int len,
				      void (*callback) (struct urb *))
{
	struct usb_serial *serial = port->serial;
	struct urb *urb;

	urb = usb_alloc_urb(0, GFP_KERNEL);	/* No ISO */
	if (!urb)
		return NULL;

	/* Fill URB using supplied data. */
	usb_fill_bulk_urb(urb, serial->dev,
			  usb_sndbulkpipe(serial->dev, endpoint) | dir,
			  buf, len, callback, ctx);

	return urb;
}

int usb_wwan_port_probe(struct usb_serial_port *port)
{
	struct usb_wwan_port_private *portdata;
	struct urb *urb;
	u8 *buffer;
	int i;

	if (!port->bulk_in_size || !port->bulk_out_size)
		return -ENODEV;

	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
	if (!portdata)
		return -ENOMEM;

	init_usb_anchor(&portdata->delayed);

	for (i = 0; i < N_IN_URB; i++) {
		buffer = (u8 *)__get_free_page(GFP_KERNEL);
		if (!buffer)
			goto bail_out_error;
		portdata->in_buffer[i] = buffer;

		urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
						USB_DIR_IN, port,
						buffer, IN_BUFLEN,
						usb_wwan_indat_callback);
		portdata->in_urbs[i] = urb;
	}

	for (i = 0; i < N_OUT_URB; i++) {
		buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
		if (!buffer)
			goto bail_out_error2;
		portdata->out_buffer[i] = buffer;

		urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
						USB_DIR_OUT, port,
						buffer, OUT_BUFLEN,
						usb_wwan_outdat_callback);
		portdata->out_urbs[i] = urb;
	}

	usb_set_serial_port_data(port, portdata);

	return 0;

bail_out_error2:
	for (i = 0; i < N_OUT_URB; i++) {
		usb_free_urb(portdata->out_urbs[i]);
		kfree(portdata->out_buffer[i]);
	}
bail_out_error:
	for (i = 0; i < N_IN_URB; i++) {
		usb_free_urb(portdata->in_urbs[i]);
		free_page((unsigned long)portdata->in_buffer[i]);
	}
	kfree(portdata);

	return -ENOMEM;
}
EXPORT_SYMBOL_GPL(usb_wwan_port_probe);

int usb_wwan_port_remove(struct usb_serial_port *port)
{
	int i;
	struct usb_wwan_port_private *portdata;

	portdata = usb_get_serial_port_data(port);
	usb_set_serial_port_data(port, NULL);

	/* Stop reading/writing urbs and free them */
	for (i = 0; i < N_IN_URB; i++) {
		usb_kill_urb(portdata->in_urbs[i]);
		usb_free_urb(portdata->in_urbs[i]);
		free_page((unsigned long)portdata->in_buffer[i]);
	}
	for (i = 0; i < N_OUT_URB; i++) {
		usb_kill_urb(portdata->out_urbs[i]);
		usb_free_urb(portdata->out_urbs[i]);
		kfree(portdata->out_buffer[i]);
	}

	/* Now free port private data */
	kfree(portdata);
	return 0;
}
EXPORT_SYMBOL(usb_wwan_port_remove);

#ifdef CONFIG_PM
static void stop_read_write_urbs(struct usb_serial *serial)
{
	int i, j;
	struct usb_serial_port *port;
	struct usb_wwan_port_private *portdata;

	/* Stop reading/writing urbs */
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		portdata = usb_get_serial_port_data(port);
		if (!portdata)
			continue;
		for (j = 0; j < N_IN_URB; j++)
			usb_kill_urb(portdata->in_urbs[j]);
		for (j = 0; j < N_OUT_URB; j++)
			usb_kill_urb(portdata->out_urbs[j]);
	}
}

int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
{
	struct usb_wwan_intf_private *intfdata = serial->private;

	spin_lock_irq(&intfdata->susp_lock);
	if (PMSG_IS_AUTO(message)) {
		if (intfdata->in_flight) {
			spin_unlock_irq(&intfdata->susp_lock);
			return -EBUSY;
		}
	}
	intfdata->suspended = 1;
	spin_unlock_irq(&intfdata->susp_lock);

	stop_read_write_urbs(serial);

	return 0;
}
EXPORT_SYMBOL(usb_wwan_suspend);

static void play_delayed(struct usb_serial_port *port)
{
	struct usb_wwan_intf_private *data;
	struct usb_wwan_port_private *portdata;
	struct urb *urb;
	int err;

	portdata = usb_get_serial_port_data(port);
	data = port->serial->private;
	while ((urb = usb_get_from_anchor(&portdata->delayed))) {
		err = usb_submit_urb(urb, GFP_ATOMIC);
		if (!err) {
			data->in_flight++;
		} else {
			/* we have to throw away the rest */
			do {
				unbusy_queued_urb(urb, portdata);
				usb_autopm_put_interface_no_suspend(port->serial->interface);
			} while ((urb = usb_get_from_anchor(&portdata->delayed)));
			break;
		}
	}
}

int usb_wwan_resume(struct usb_serial *serial)
{
	int i, j;
	struct usb_serial_port *port;
	struct usb_wwan_intf_private *intfdata = serial->private;
	struct usb_wwan_port_private *portdata;
	struct urb *urb;
	int err = 0;

	spin_lock_irq(&intfdata->susp_lock);
	for (i = 0; i < serial->num_ports; i++) {
		/* walk all ports */
		port = serial->port[i];
		portdata = usb_get_serial_port_data(port);

		/* skip closed ports */
		if (!portdata || !portdata->opened)
			continue;

		if (port->interrupt_in_urb) {
			err = usb_submit_urb(port->interrupt_in_urb,
					GFP_ATOMIC);
			if (err) {
				dev_err(&port->dev,
					"%s: submit int urb failed: %d\n",
					__func__, err);
			}
		}

		for (j = 0; j < N_IN_URB; j++) {
			urb = portdata->in_urbs[j];
			err = usb_submit_urb(urb, GFP_ATOMIC);
			if (err < 0) {
				dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
					__func__, err, i);
				spin_unlock_irq(&intfdata->susp_lock);
				goto err_out;
			}
		}
		play_delayed(port);
	}
	intfdata->suspended = 0;
	spin_unlock_irq(&intfdata->susp_lock);
err_out:
	return err;
}
EXPORT_SYMBOL(usb_wwan_resume);
#endif

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
Commit	Line	Data
0d456194 MG	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
0d456194 MG	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>
66921edd	33	#include <linux/uaccess.h>
0d456194 MG	34	#include <linux/usb.h>
0d456194 MG	35	#include <linux/usb/serial.h>
02303f73	36	#include <linux/serial.h>
0d456194 MG	37	#include "usb-wwan.h"
0d456194 MG	38
0d456194 MG	39	void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
0d456194 MG	40	{
0d456194	41	struct usb_wwan_port_private *portdata;
0d456194 MG	42	struct usb_wwan_intf_private *intfdata;
0d456194 MG	43
0d456194 MG	44	intfdata = port->serial->private;
	45
	46	if (!intfdata->send_setup)
	47	return;
	48
	49	portdata = usb_get_serial_port_data(port);
b2ca6990	50	/* FIXME: locking */
0d456194 MG	51	portdata->rts_state = on;
0d456194 MG	52	portdata->dtr_state = on;
b2ca6990 JH	53
b2ca6990 JH	54	intfdata->send_setup(port);
0d456194 MG	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
0d456194	64	/* Doesn't support option setting */
adc8d746	65	tty_termios_copy_hw(&tty->termios, old_termios);
0d456194 MG	66
	67	if (intfdata->send_setup)
	68	intfdata->send_setup(port);
	69	}
	70	EXPORT_SYMBOL(usb_wwan_set_termios);
	71
60b33c13	72	int usb_wwan_tiocmget(struct tty_struct *tty)
0d456194 MG	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
20b9d177	91	int usb_wwan_tiocmset(struct tty_struct *tty,
0d456194 MG	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
02303f73 DW	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));
e5b1e206	127	tmp.line = port->minor;
1143832e	128	tmp.port = port->port_number;
02303f73 DW	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
00a0d0d6	171	int usb_wwan_ioctl(struct tty_struct *tty,
02303f73 DW	172	unsigned int cmd, unsigned long arg)
	173	{
	174	struct usb_serial_port *port = tty->driver_data;
	175
a80be97d	176	dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
02303f73 DW	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
a80be97d	189	dev_dbg(&port->dev, "%s arg not supported\n", __func__);
02303f73 DW	190
	191	return -ENOIOCTLCMD;
	192	}
	193	EXPORT_SYMBOL(usb_wwan_ioctl);
	194
0d456194 MG	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
a80be97d	210	dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
0d456194 MG	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	}
a80be97d GKH	227	dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
a80be97d GKH	228	usb_pipeendpoint(this_urb->pipe), i);
0d456194 MG	229
0d456194 MG	230	err = usb_autopm_get_interface_async(port->serial->interface);
db090473	231	if (err < 0) {
db090473	232	clear_bit(i, &portdata->out_busy);
0d456194	233	break;
db090473	234	}
0d456194 MG	235
	236	/* send the data */
	237	memcpy(this_urb->transfer_buffer, buf, todo);
	238	this_urb->transfer_buffer_length = todo;
	239
	240	spin_lock_irqsave(&intfdata->susp_lock, flags);
	241	if (intfdata->suspended) {
	242	usb_anchor_urb(this_urb, &portdata->delayed);
	243	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
	244	} else {
	245	intfdata->in_flight++;
	246	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
	247	err = usb_submit_urb(this_urb, GFP_ATOMIC);
	248	if (err) {
a80be97d GKH	249	dev_dbg(&port->dev,
	250	"usb_submit_urb %p (write bulk) failed (%d)\n",
	251	this_urb, err);
0d456194 MG	252	clear_bit(i, &portdata->out_busy);
	253	spin_lock_irqsave(&intfdata->susp_lock, flags);
	254	intfdata->in_flight--;
	255	spin_unlock_irqrestore(&intfdata->susp_lock,
	256	flags);
3d06bf15	257	usb_autopm_put_interface_async(port->serial->interface);
433508ae	258	break;
0d456194 MG	259	}
	260	}
	261
	262	portdata->tx_start_time[i] = jiffies;
	263	buf += todo;
	264	left -= todo;
	265	}
	266
	267	count -= left;
a80be97d	268	dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
0d456194 MG	269	return count;
	270	}
	271	EXPORT_SYMBOL(usb_wwan_write);
	272
	273	static void usb_wwan_indat_callback(struct urb *urb)
	274	{
	275	int err;
	276	int endpoint;
	277	struct usb_serial_port *port;
a80be97d	278	struct device *dev;
0d456194 MG	279	unsigned char *data = urb->transfer_buffer;
	280	int status = urb->status;
	281
0d456194 MG	282	endpoint = usb_pipeendpoint(urb->pipe);
0d456194 MG	283	port = urb->context;
a80be97d	284	dev = &port->dev;
0d456194 MG	285
0d456194 MG	286	if (status) {
a80be97d GKH	287	dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
a80be97d GKH	288	__func__, status, endpoint);
0d456194	289	} else {
2e124b4a JS	290	if (urb->actual_length) {
	291	tty_insert_flip_string(&port->port, data,
	292	urb->actual_length);
	293	tty_flip_buffer_push(&port->port);
	294	} else
	295	dev_dbg(dev, "%s: empty read urb received\n", __func__);
6c1ee66a MB	296	}
	297	/* Resubmit urb so we continue receiving */
	298	err = usb_submit_urb(urb, GFP_ATOMIC);
	299	if (err) {
	300	if (err != -EPERM) {
	301	dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
	302	__func__, err);
	303	/* busy also in error unless we are killed */
ec42899c	304	usb_mark_last_busy(port->serial->dev);
0d456194	305	}
6c1ee66a MB	306	} else {
6c1ee66a MB	307	usb_mark_last_busy(port->serial->dev);
0d456194	308	}
0d456194 MG	309	}
	310
	311	static void usb_wwan_outdat_callback(struct urb *urb)
	312	{
	313	struct usb_serial_port *port;
	314	struct usb_wwan_port_private *portdata;
	315	struct usb_wwan_intf_private *intfdata;
	316	int i;
	317
0d456194 MG	318	port = urb->context;
	319	intfdata = port->serial->private;
	320
	321	usb_serial_port_softint(port);
	322	usb_autopm_put_interface_async(port->serial->interface);
	323	portdata = usb_get_serial_port_data(port);
	324	spin_lock(&intfdata->susp_lock);
	325	intfdata->in_flight--;
	326	spin_unlock(&intfdata->susp_lock);
	327
	328	for (i = 0; i < N_OUT_URB; ++i) {
	329	if (portdata->out_urbs[i] == urb) {
	330	smp_mb__before_clear_bit();
	331	clear_bit(i, &portdata->out_busy);
	332	break;
	333	}
	334	}
	335	}
	336
	337	int usb_wwan_write_room(struct tty_struct *tty)
	338	{
	339	struct usb_serial_port *port = tty->driver_data;
	340	struct usb_wwan_port_private *portdata;
	341	int i;
	342	int data_len = 0;
	343	struct urb *this_urb;
	344
	345	portdata = usb_get_serial_port_data(port);
	346
	347	for (i = 0; i < N_OUT_URB; i++) {
	348	this_urb = portdata->out_urbs[i];
	349	if (this_urb && !test_bit(i, &portdata->out_busy))
	350	data_len += OUT_BUFLEN;
	351	}
	352
a80be97d	353	dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
0d456194 MG	354	return data_len;
	355	}
	356	EXPORT_SYMBOL(usb_wwan_write_room);
	357
	358	int usb_wwan_chars_in_buffer(struct tty_struct *tty)
	359	{
	360	struct usb_serial_port *port = tty->driver_data;
	361	struct usb_wwan_port_private *portdata;
	362	int i;
	363	int data_len = 0;
	364	struct urb *this_urb;
	365
	366	portdata = usb_get_serial_port_data(port);
	367
	368	for (i = 0; i < N_OUT_URB; i++) {
	369	this_urb = portdata->out_urbs[i];
	370	/* FIXME: This locking is insufficient as this_urb may
	371	go unused during the test */
	372	if (this_urb && test_bit(i, &portdata->out_busy))
	373	data_len += this_urb->transfer_buffer_length;
	374	}
a80be97d	375	dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
0d456194 MG	376	return data_len;
	377	}
	378	EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
	379
	380	int usb_wwan_open(struct tty_struct tty, struct usb_serial_port port)
	381	{
	382	struct usb_wwan_port_private *portdata;
	383	struct usb_wwan_intf_private *intfdata;
	384	struct usb_serial *serial = port->serial;
	385	int i, err;
	386	struct urb *urb;
	387
	388	portdata = usb_get_serial_port_data(port);
	389	intfdata = serial->private;
	390
9096f1fb JH	391	if (port->interrupt_in_urb) {
	392	err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
	393	if (err) {
	394	dev_dbg(&port->dev, "%s: submit int urb failed: %d\n",
	395	__func__, err);
	396	}
	397	}
	398
0d456194 MG	399	/* Start reading from the IN endpoint */
	400	for (i = 0; i < N_IN_URB; i++) {
	401	urb = portdata->in_urbs[i];
	402	if (!urb)
	403	continue;
	404	err = usb_submit_urb(urb, GFP_KERNEL);
	405	if (err) {
a80be97d GKH	406	dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
a80be97d GKH	407	__func__, i, err, urb->transfer_buffer_length);
0d456194 MG	408	}
	409	}
	410
	411	if (intfdata->send_setup)
	412	intfdata->send_setup(port);
	413
	414	serial->interface->needs_remote_wakeup = 1;
	415	spin_lock_irq(&intfdata->susp_lock);
	416	portdata->opened = 1;
	417	spin_unlock_irq(&intfdata->susp_lock);
9a91aedc	418	/* this balances a get in the generic USB serial code */
0d456194 MG	419	usb_autopm_put_interface(serial->interface);
	420
	421	return 0;
	422	}
	423	EXPORT_SYMBOL(usb_wwan_open);
	424
79eed03e JH	425	static void unbusy_queued_urb(struct urb *urb,
	426	struct usb_wwan_port_private *portdata)
	427	{
	428	int i;
	429
	430	for (i = 0; i < N_OUT_URB; i++) {
	431	if (urb == portdata->out_urbs[i]) {
	432	clear_bit(i, &portdata->out_busy);
	433	break;
	434	}
	435	}
	436	}
	437
0d456194 MG	438	void usb_wwan_close(struct usb_serial_port *port)
	439	{
	440	int i;
	441	struct usb_serial *serial = port->serial;
	442	struct usb_wwan_port_private *portdata;
	443	struct usb_wwan_intf_private *intfdata = port->serial->private;
79eed03e	444	struct urb *urb;
0d456194	445
0d456194 MG	446	portdata = usb_get_serial_port_data(port);
0d456194 MG	447
e6d144bc JH	448	/* Stop reading/writing urbs */
	449	spin_lock_irq(&intfdata->susp_lock);
	450	portdata->opened = 0;
	451	spin_unlock_irq(&intfdata->susp_lock);
	452
79eed03e JH	453	for (;;) {
	454	urb = usb_get_from_anchor(&portdata->delayed);
	455	if (!urb)
	456	break;
	457	unbusy_queued_urb(urb, portdata);
	458	usb_autopm_put_interface_async(serial->interface);
	459	}
	460
e6d144bc JH	461	for (i = 0; i < N_IN_URB; i++)
	462	usb_kill_urb(portdata->in_urbs[i]);
	463	for (i = 0; i < N_OUT_URB; i++)
	464	usb_kill_urb(portdata->out_urbs[i]);
9096f1fb	465	usb_kill_urb(port->interrupt_in_urb);
e6d144bc JH	466
	467	/* balancing - important as an error cannot be handled*/
	468	usb_autopm_get_interface_no_resume(serial->interface);
	469	serial->interface->needs_remote_wakeup = 0;
0d456194 MG	470	}
	471	EXPORT_SYMBOL(usb_wwan_close);
	472
	473	/* Helper functions used by usb_wwan_setup_urbs */
b8f0e820 JH	474	static struct urb usb_wwan_setup_urb(struct usb_serial_port port,
b8f0e820 JH	475	int endpoint,
0d456194 MG	476	int dir, void ctx, char buf, int len,
	477	void (callback) (struct urb ))
	478	{
b8f0e820	479	struct usb_serial *serial = port->serial;
0d456194 MG	480	struct urb *urb;
0d456194 MG	481
0d456194	482	urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
10c642d0	483	if (!urb)
0d456194	484	return NULL;
0d456194 MG	485
	486	/* Fill URB using supplied data. */
	487	usb_fill_bulk_urb(urb, serial->dev,
	488	usb_sndbulkpipe(serial->dev, endpoint) \| dir,
	489	buf, len, callback, ctx);
	490
	491	return urb;
	492	}
	493
b8f0e820	494	int usb_wwan_port_probe(struct usb_serial_port *port)
0d456194	495	{
0d456194	496	struct usb_wwan_port_private *portdata;
b8f0e820 JH	497	struct urb *urb;
b8f0e820 JH	498	u8 *buffer;
b8f0e820	499	int i;
0d456194	500
bd73bd88 JH	501	if (!port->bulk_in_size \|\| !port->bulk_out_size)
	502	return -ENODEV;
	503
b8f0e820 JH	504	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
	505	if (!portdata)
	506	return -ENOMEM;
0d456194	507
b8f0e820	508	init_usb_anchor(&portdata->delayed);
0d456194	509
b8f0e820 JH	510	for (i = 0; i < N_IN_URB; i++) {
	511	buffer = (u8 *)__get_free_page(GFP_KERNEL);
	512	if (!buffer)
	513	goto bail_out_error;
	514	portdata->in_buffer[i] = buffer;
	515
	516	urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
	517	USB_DIR_IN, port,
	518	buffer, IN_BUFLEN,
	519	usb_wwan_indat_callback);
	520	portdata->in_urbs[i] = urb;
	521	}
0d456194	522
b8f0e820	523	for (i = 0; i < N_OUT_URB; i++) {
b8f0e820 JH	524	buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
	525	if (!buffer)
	526	goto bail_out_error2;
	527	portdata->out_buffer[i] = buffer;
0d456194	528
b8f0e820 JH	529	urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
	530	USB_DIR_OUT, port,
	531	buffer, OUT_BUFLEN,
	532	usb_wwan_outdat_callback);
	533	portdata->out_urbs[i] = urb;
	534	}
0d456194	535
b8f0e820	536	usb_set_serial_port_data(port, portdata);
0d456194	537
0d456194 MG	538	return 0;
	539
	540	bail_out_error2:
b8f0e820 JH	541	for (i = 0; i < N_OUT_URB; i++) {
	542	usb_free_urb(portdata->out_urbs[i]);
	543	kfree(portdata->out_buffer[i]);
	544	}
0d456194	545	bail_out_error:
b8f0e820 JH	546	for (i = 0; i < N_IN_URB; i++) {
	547	usb_free_urb(portdata->in_urbs[i]);
	548	free_page((unsigned long)portdata->in_buffer[i]);
	549	}
0d456194	550	kfree(portdata);
b8f0e820 JH	551
b8f0e820 JH	552	return -ENOMEM;
0d456194	553	}
b8f0e820	554	EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
0d456194	555
a1028f0a	556	int usb_wwan_port_remove(struct usb_serial_port *port)
0d456194	557	{
a1028f0a	558	int i;
0d456194 MG	559	struct usb_wwan_port_private *portdata;
0d456194 MG	560
a1028f0a BM	561	portdata = usb_get_serial_port_data(port);
	562	usb_set_serial_port_data(port, NULL);
	563
	564	/* Stop reading/writing urbs and free them */
	565	for (i = 0; i < N_IN_URB; i++) {
	566	usb_kill_urb(portdata->in_urbs[i]);
	567	usb_free_urb(portdata->in_urbs[i]);
	568	free_page((unsigned long)portdata->in_buffer[i]);
	569	}
	570	for (i = 0; i < N_OUT_URB; i++) {
	571	usb_kill_urb(portdata->out_urbs[i]);
	572	usb_free_urb(portdata->out_urbs[i]);
	573	kfree(portdata->out_buffer[i]);
0d456194	574	}
0d456194	575
a1028f0a BM	576	/* Now free port private data */
	577	kfree(portdata);
	578	return 0;
0d456194	579	}
a1028f0a	580	EXPORT_SYMBOL(usb_wwan_port_remove);
0d456194	581
a1028f0a BM	582	#ifdef CONFIG_PM
a1028f0a BM	583	static void stop_read_write_urbs(struct usb_serial *serial)
0d456194 MG	584	{
	585	int i, j;
	586	struct usb_serial_port *port;
	587	struct usb_wwan_port_private *portdata;
	588
a1028f0a	589	/* Stop reading/writing urbs */
0d456194 MG	590	for (i = 0; i < serial->num_ports; ++i) {
	591	port = serial->port[i];
	592	portdata = usb_get_serial_port_data(port);
032129cb BM	593	if (!portdata)
032129cb BM	594	continue;
a1028f0a BM	595	for (j = 0; j < N_IN_URB; j++)
	596	usb_kill_urb(portdata->in_urbs[j]);
	597	for (j = 0; j < N_OUT_URB; j++)
	598	usb_kill_urb(portdata->out_urbs[j]);
0d456194 MG	599	}
0d456194 MG	600	}
0d456194	601
0d456194 MG	602	int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
	603	{
	604	struct usb_wwan_intf_private *intfdata = serial->private;
0d456194	605
170fad9e	606	spin_lock_irq(&intfdata->susp_lock);
5b1b0b81	607	if (PMSG_IS_AUTO(message)) {
170fad9e JH	608	if (intfdata->in_flight) {
170fad9e JH	609	spin_unlock_irq(&intfdata->susp_lock);
0d456194	610	return -EBUSY;
170fad9e	611	}
0d456194	612	}
0d456194 MG	613	intfdata->suspended = 1;
0d456194 MG	614	spin_unlock_irq(&intfdata->susp_lock);
170fad9e	615
0d456194 MG	616	stop_read_write_urbs(serial);
	617
	618	return 0;
	619	}
	620	EXPORT_SYMBOL(usb_wwan_suspend);
	621
	622	static void play_delayed(struct usb_serial_port *port)
	623	{
	624	struct usb_wwan_intf_private *data;
	625	struct usb_wwan_port_private *portdata;
	626	struct urb *urb;
	627	int err;
	628
	629	portdata = usb_get_serial_port_data(port);
	630	data = port->serial->private;
	631	while ((urb = usb_get_from_anchor(&portdata->delayed))) {
	632	err = usb_submit_urb(urb, GFP_ATOMIC);
16871dca	633	if (!err) {
0d456194	634	data->in_flight++;
16871dca ON	635	} else {
	636	/* we have to throw away the rest */
	637	do {
	638	unbusy_queued_urb(urb, portdata);
97ac01d8	639	usb_autopm_put_interface_no_suspend(port->serial->interface);
16871dca ON	640	} while ((urb = usb_get_from_anchor(&portdata->delayed)));
	641	break;
	642	}
0d456194 MG	643	}
	644	}
	645
	646	int usb_wwan_resume(struct usb_serial *serial)
	647	{
	648	int i, j;
	649	struct usb_serial_port *port;
	650	struct usb_wwan_intf_private *intfdata = serial->private;
	651	struct usb_wwan_port_private *portdata;
	652	struct urb *urb;
	653	int err = 0;
	654
d9e93c08	655	spin_lock_irq(&intfdata->susp_lock);
0d456194 MG	656	for (i = 0; i < serial->num_ports; i++) {
	657	/* walk all ports */
	658	port = serial->port[i];
	659	portdata = usb_get_serial_port_data(port);
	660
	661	/* skip closed ports */
d9e93c08	662	if (!portdata \|\| !portdata->opened)
0d456194	663	continue;
0d456194	664
9096f1fb JH	665	if (port->interrupt_in_urb) {
	666	err = usb_submit_urb(port->interrupt_in_urb,
	667	GFP_ATOMIC);
	668	if (err) {
	669	dev_err(&port->dev,
	670	"%s: submit int urb failed: %d\n",
	671	__func__, err);
	672	}
	673	}
	674
0d456194 MG	675	for (j = 0; j < N_IN_URB; j++) {
	676	urb = portdata->in_urbs[j];
	677	err = usb_submit_urb(urb, GFP_ATOMIC);
	678	if (err < 0) {
3a1c2a82 GKH	679	dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
3a1c2a82 GKH	680	__func__, err, i);
0d456194 MG	681	spin_unlock_irq(&intfdata->susp_lock);
	682	goto err_out;
	683	}
	684	}
	685	play_delayed(port);
0d456194	686	}
0d456194 MG	687	intfdata->suspended = 0;
	688	spin_unlock_irq(&intfdata->susp_lock);
	689	err_out:
	690	return err;
	691	}
	692	EXPORT_SYMBOL(usb_wwan_resume);
	693	#endif
	694
	695	MODULE_AUTHOR(DRIVER_AUTHOR);
	696	MODULE_DESCRIPTION(DRIVER_DESC);
0d456194	697	MODULE_LICENSE("GPL");