[mirror_ubuntu-bionic-kernel.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;

	/* 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);

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;

	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 (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]);

	/* 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 err;
	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);

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

	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 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;
		}
	}
}

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;

	/* get the interrupt URBs resubmitted unconditionally */
	for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		if (!port->interrupt_in_urb) {
			dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
			continue;
		}
		err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
		dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
		if (err < 0) {
			dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
				__func__, err);
			goto err_out;
		}
	}

	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;

		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
0d456194 MG	391	/* Start reading from the IN endpoint */
	392	for (i = 0; i < N_IN_URB; i++) {
	393	urb = portdata->in_urbs[i];
	394	if (!urb)
	395	continue;
	396	err = usb_submit_urb(urb, GFP_KERNEL);
	397	if (err) {
a80be97d GKH	398	dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
a80be97d GKH	399	__func__, i, err, urb->transfer_buffer_length);
0d456194 MG	400	}
	401	}
	402
	403	if (intfdata->send_setup)
	404	intfdata->send_setup(port);
	405
	406	serial->interface->needs_remote_wakeup = 1;
	407	spin_lock_irq(&intfdata->susp_lock);
	408	portdata->opened = 1;
	409	spin_unlock_irq(&intfdata->susp_lock);
9a91aedc	410	/* this balances a get in the generic USB serial code */
0d456194 MG	411	usb_autopm_put_interface(serial->interface);
	412
	413	return 0;
	414	}
	415	EXPORT_SYMBOL(usb_wwan_open);
	416
	417	void usb_wwan_close(struct usb_serial_port *port)
	418	{
	419	int i;
	420	struct usb_serial *serial = port->serial;
	421	struct usb_wwan_port_private *portdata;
	422	struct usb_wwan_intf_private *intfdata = port->serial->private;
	423
0d456194 MG	424	portdata = usb_get_serial_port_data(port);
0d456194 MG	425
e6d144bc JH	426	/* Stop reading/writing urbs */
	427	spin_lock_irq(&intfdata->susp_lock);
	428	portdata->opened = 0;
	429	spin_unlock_irq(&intfdata->susp_lock);
	430
	431	for (i = 0; i < N_IN_URB; i++)
	432	usb_kill_urb(portdata->in_urbs[i]);
	433	for (i = 0; i < N_OUT_URB; i++)
	434	usb_kill_urb(portdata->out_urbs[i]);
	435
	436	/* balancing - important as an error cannot be handled*/
	437	usb_autopm_get_interface_no_resume(serial->interface);
	438	serial->interface->needs_remote_wakeup = 0;
0d456194 MG	439	}
	440	EXPORT_SYMBOL(usb_wwan_close);
	441
	442	/* Helper functions used by usb_wwan_setup_urbs */
b8f0e820 JH	443	static struct urb usb_wwan_setup_urb(struct usb_serial_port port,
b8f0e820 JH	444	int endpoint,
0d456194 MG	445	int dir, void ctx, char buf, int len,
	446	void (callback) (struct urb ))
	447	{
b8f0e820	448	struct usb_serial *serial = port->serial;
0d456194 MG	449	struct urb *urb;
0d456194 MG	450
0d456194	451	urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
10c642d0	452	if (!urb)
0d456194	453	return NULL;
0d456194 MG	454
	455	/* Fill URB using supplied data. */
	456	usb_fill_bulk_urb(urb, serial->dev,
	457	usb_sndbulkpipe(serial->dev, endpoint) \| dir,
	458	buf, len, callback, ctx);
	459
	460	return urb;
	461	}
	462
b8f0e820	463	int usb_wwan_port_probe(struct usb_serial_port *port)
0d456194	464	{
0d456194	465	struct usb_wwan_port_private *portdata;
b8f0e820 JH	466	struct urb *urb;
	467	u8 *buffer;
	468	int err;
	469	int i;
0d456194	470
bd73bd88 JH	471	if (!port->bulk_in_size \|\| !port->bulk_out_size)
	472	return -ENODEV;
	473
b8f0e820 JH	474	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
	475	if (!portdata)
	476	return -ENOMEM;
0d456194	477
b8f0e820	478	init_usb_anchor(&portdata->delayed);
0d456194	479
b8f0e820 JH	480	for (i = 0; i < N_IN_URB; i++) {
	481	buffer = (u8 *)__get_free_page(GFP_KERNEL);
	482	if (!buffer)
	483	goto bail_out_error;
	484	portdata->in_buffer[i] = buffer;
	485
	486	urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
	487	USB_DIR_IN, port,
	488	buffer, IN_BUFLEN,
	489	usb_wwan_indat_callback);
	490	portdata->in_urbs[i] = urb;
	491	}
0d456194	492
b8f0e820	493	for (i = 0; i < N_OUT_URB; i++) {
b8f0e820 JH	494	buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
	495	if (!buffer)
	496	goto bail_out_error2;
	497	portdata->out_buffer[i] = buffer;
0d456194	498
b8f0e820 JH	499	urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
	500	USB_DIR_OUT, port,
	501	buffer, OUT_BUFLEN,
	502	usb_wwan_outdat_callback);
	503	portdata->out_urbs[i] = urb;
	504	}
0d456194	505
b8f0e820	506	usb_set_serial_port_data(port, portdata);
0d456194	507
b8f0e820	508	if (port->interrupt_in_urb) {
0d456194 MG	509	err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
0d456194 MG	510	if (err)
a80be97d GKH	511	dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
a80be97d GKH	512	__func__, err);
0d456194	513	}
b8f0e820	514
0d456194 MG	515	return 0;
	516
	517	bail_out_error2:
b8f0e820 JH	518	for (i = 0; i < N_OUT_URB; i++) {
	519	usb_free_urb(portdata->out_urbs[i]);
	520	kfree(portdata->out_buffer[i]);
	521	}
0d456194	522	bail_out_error:
b8f0e820 JH	523	for (i = 0; i < N_IN_URB; i++) {
	524	usb_free_urb(portdata->in_urbs[i]);
	525	free_page((unsigned long)portdata->in_buffer[i]);
	526	}
0d456194	527	kfree(portdata);
b8f0e820 JH	528
b8f0e820 JH	529	return -ENOMEM;
0d456194	530	}
b8f0e820	531	EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
0d456194	532
a1028f0a	533	int usb_wwan_port_remove(struct usb_serial_port *port)
0d456194	534	{
a1028f0a	535	int i;
0d456194 MG	536	struct usb_wwan_port_private *portdata;
0d456194 MG	537
a1028f0a BM	538	portdata = usb_get_serial_port_data(port);
	539	usb_set_serial_port_data(port, NULL);
	540
	541	/* Stop reading/writing urbs and free them */
	542	for (i = 0; i < N_IN_URB; i++) {
	543	usb_kill_urb(portdata->in_urbs[i]);
	544	usb_free_urb(portdata->in_urbs[i]);
	545	free_page((unsigned long)portdata->in_buffer[i]);
	546	}
	547	for (i = 0; i < N_OUT_URB; i++) {
	548	usb_kill_urb(portdata->out_urbs[i]);
	549	usb_free_urb(portdata->out_urbs[i]);
	550	kfree(portdata->out_buffer[i]);
0d456194	551	}
0d456194	552
a1028f0a BM	553	/* Now free port private data */
	554	kfree(portdata);
	555	return 0;
0d456194	556	}
a1028f0a	557	EXPORT_SYMBOL(usb_wwan_port_remove);
0d456194	558
a1028f0a BM	559	#ifdef CONFIG_PM
a1028f0a BM	560	static void stop_read_write_urbs(struct usb_serial *serial)
0d456194 MG	561	{
	562	int i, j;
	563	struct usb_serial_port *port;
	564	struct usb_wwan_port_private *portdata;
	565
a1028f0a	566	/* Stop reading/writing urbs */
0d456194 MG	567	for (i = 0; i < serial->num_ports; ++i) {
	568	port = serial->port[i];
	569	portdata = usb_get_serial_port_data(port);
032129cb BM	570	if (!portdata)
032129cb BM	571	continue;
a1028f0a BM	572	for (j = 0; j < N_IN_URB; j++)
	573	usb_kill_urb(portdata->in_urbs[j]);
	574	for (j = 0; j < N_OUT_URB; j++)
	575	usb_kill_urb(portdata->out_urbs[j]);
0d456194 MG	576	}
0d456194 MG	577	}
0d456194	578
0d456194 MG	579	int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
	580	{
	581	struct usb_wwan_intf_private *intfdata = serial->private;
0d456194	582
170fad9e	583	spin_lock_irq(&intfdata->susp_lock);
5b1b0b81	584	if (PMSG_IS_AUTO(message)) {
170fad9e JH	585	if (intfdata->in_flight) {
170fad9e JH	586	spin_unlock_irq(&intfdata->susp_lock);
0d456194	587	return -EBUSY;
170fad9e	588	}
0d456194	589	}
0d456194 MG	590	intfdata->suspended = 1;
0d456194 MG	591	spin_unlock_irq(&intfdata->susp_lock);
170fad9e	592
0d456194 MG	593	stop_read_write_urbs(serial);
	594
	595	return 0;
	596	}
	597	EXPORT_SYMBOL(usb_wwan_suspend);
	598
16871dca ON	599	static void unbusy_queued_urb(struct urb urb, struct usb_wwan_port_private portdata)
	600	{
	601	int i;
	602
	603	for (i = 0; i < N_OUT_URB; i++) {
	604	if (urb == portdata->out_urbs[i]) {
	605	clear_bit(i, &portdata->out_busy);
	606	break;
	607	}
	608	}
	609	}
	610
0d456194 MG	611	static void play_delayed(struct usb_serial_port *port)
	612	{
	613	struct usb_wwan_intf_private *data;
	614	struct usb_wwan_port_private *portdata;
	615	struct urb *urb;
	616	int err;
	617
	618	portdata = usb_get_serial_port_data(port);
	619	data = port->serial->private;
	620	while ((urb = usb_get_from_anchor(&portdata->delayed))) {
	621	err = usb_submit_urb(urb, GFP_ATOMIC);
16871dca	622	if (!err) {
0d456194	623	data->in_flight++;
16871dca ON	624	} else {
	625	/* we have to throw away the rest */
	626	do {
	627	unbusy_queued_urb(urb, portdata);
97ac01d8	628	usb_autopm_put_interface_no_suspend(port->serial->interface);
16871dca ON	629	} while ((urb = usb_get_from_anchor(&portdata->delayed)));
	630	break;
	631	}
0d456194 MG	632	}
	633	}
	634
	635	int usb_wwan_resume(struct usb_serial *serial)
	636	{
	637	int i, j;
	638	struct usb_serial_port *port;
	639	struct usb_wwan_intf_private *intfdata = serial->private;
	640	struct usb_wwan_port_private *portdata;
	641	struct urb *urb;
	642	int err = 0;
	643
0d456194 MG	644	/* get the interrupt URBs resubmitted unconditionally */
	645	for (i = 0; i < serial->num_ports; i++) {
	646	port = serial->port[i];
	647	if (!port->interrupt_in_urb) {
a80be97d	648	dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
0d456194 MG	649	continue;
	650	}
	651	err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
a80be97d	652	dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
0d456194	653	if (err < 0) {
3a1c2a82 GKH	654	dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
3a1c2a82 GKH	655	__func__, err);
0d456194 MG	656	goto err_out;
	657	}
	658	}
	659
d9e93c08	660	spin_lock_irq(&intfdata->susp_lock);
0d456194 MG	661	for (i = 0; i < serial->num_ports; i++) {
	662	/* walk all ports */
	663	port = serial->port[i];
	664	portdata = usb_get_serial_port_data(port);
	665
	666	/* skip closed ports */
d9e93c08	667	if (!portdata \|\| !portdata->opened)
0d456194	668	continue;
0d456194 MG	669
	670	for (j = 0; j < N_IN_URB; j++) {
	671	urb = portdata->in_urbs[j];
	672	err = usb_submit_urb(urb, GFP_ATOMIC);
	673	if (err < 0) {
3a1c2a82 GKH	674	dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
3a1c2a82 GKH	675	__func__, err, i);
0d456194 MG	676	spin_unlock_irq(&intfdata->susp_lock);
	677	goto err_out;
	678	}
	679	}
	680	play_delayed(port);
0d456194	681	}
0d456194 MG	682	intfdata->suspended = 0;
	683	spin_unlock_irq(&intfdata->susp_lock);
	684	err_out:
	685	return err;
	686	}
	687	EXPORT_SYMBOL(usb_wwan_resume);
	688	#endif
	689
	690	MODULE_AUTHOR(DRIVER_AUTHOR);
	691	MODULE_DESCRIPTION(DRIVER_DESC);
0d456194	692	MODULE_LICENSE("GPL");