[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_VERSION "v0.7.2"
#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"

static bool debug;

void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
{
	struct usb_serial *serial = port->serial;
	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);
	mutex_lock(&serial->disc_mutex);
	portdata->rts_state = on;
	portdata->dtr_state = on;
	if (serial->dev)
		intfdata->send_setup(port);
	mutex_unlock(&serial->disc_mutex);
}
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->serial->minor;
	tmp.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;

	dbg("%s cmd 0x%04x", __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;
	}

	dbg("%s arg not supported", __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;

	dbg("%s: write (%d chars)", __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;
		}
		dbg("%s: endpoint %d buf %d", __func__,
		    usb_pipeendpoint(this_urb->pipe), i);

		err = usb_autopm_get_interface_async(port->serial->interface);
		if (err < 0)
			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) {
				dbg("usb_submit_urb %p (write bulk) failed "
				    "(%d)", 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;
	dbg("%s: wrote (did %d)", __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 tty_struct *tty;
	unsigned char *data = urb->transfer_buffer;
	int status = urb->status;

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

	if (status) {
		dbg("%s: nonzero status: %d on endpoint %02x.",
		    __func__, status, endpoint);
	} else {
		tty = tty_port_tty_get(&port->port);
		if (tty) {
			if (urb->actual_length) {
				tty_insert_flip_string(tty, data,
						urb->actual_length);
				tty_flip_buffer_push(tty);
			} else
				dbg("%s: empty read urb received", __func__);
			tty_kref_put(tty);
		}

		/* Resubmit urb so we continue receiving */
		err = usb_submit_urb(urb, GFP_ATOMIC);
		if (err) {
			if (err != -EPERM) {
				printk(KERN_ERR "%s: resubmit read urb failed. "
					"(%d)", __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;
	}

	dbg("%s: %d", __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;
	}
	dbg("%s: %d", __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) {
			dbg("%s: submit urb %d failed (%d) %d",
			    __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);

	if (serial->dev) {
		/* 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 *serial, int endpoint,
				      int dir, void *ctx, char *buf, int len,
				      void (*callback) (struct urb *))
{
	struct urb *urb;

	if (endpoint == -1)
		return NULL;	/* endpoint not needed */

	urb = usb_alloc_urb(0, GFP_KERNEL);	/* No ISO */
	if (urb == NULL) {
		dbg("%s: alloc for endpoint %d failed.", __func__, endpoint);
		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;
}

/* Setup urbs */
static void usb_wwan_setup_urbs(struct usb_serial *serial)
{
	int i, j;
	struct usb_serial_port *port;
	struct usb_wwan_port_private *portdata;

	for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		portdata = usb_get_serial_port_data(port);

		/* Do indat endpoints first */
		for (j = 0; j < N_IN_URB; ++j) {
			portdata->in_urbs[j] = usb_wwan_setup_urb(serial,
								  port->
								  bulk_in_endpointAddress,
								  USB_DIR_IN,
								  port,
								  portdata->
								  in_buffer[j],
								  IN_BUFLEN,
								  usb_wwan_indat_callback);
		}

		/* outdat endpoints */
		for (j = 0; j < N_OUT_URB; ++j) {
			portdata->out_urbs[j] = usb_wwan_setup_urb(serial,
								   port->
								   bulk_out_endpointAddress,
								   USB_DIR_OUT,
								   port,
								   portdata->
								   out_buffer
								   [j],
								   OUT_BUFLEN,
								   usb_wwan_outdat_callback);
		}
	}
}

int usb_wwan_startup(struct usb_serial *serial)
{
	int i, j, err;
	struct usb_serial_port *port;
	struct usb_wwan_port_private *portdata;
	u8 *buffer;

	/* Now setup per port private data */
	for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
		if (!portdata) {
			dbg("%s: kmalloc for usb_wwan_port_private (%d) failed!.",
			    __func__, i);
			return 1;
		}
		init_usb_anchor(&portdata->delayed);

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

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

		usb_set_serial_port_data(port, portdata);

		if (!port->interrupt_in_urb)
			continue;
		err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
		if (err)
			dbg("%s: submit irq_in urb failed %d", __func__, err);
	}
	usb_wwan_setup_urbs(serial);
	return 0;

bail_out_error2:
	for (j = 0; j < N_OUT_URB; j++)
		kfree(portdata->out_buffer[j]);
bail_out_error:
	for (j = 0; j < N_IN_URB; j++)
		if (portdata->in_buffer[j])
			free_page((unsigned long)portdata->in_buffer[j]);
	kfree(portdata);
	return 1;
}
EXPORT_SYMBOL(usb_wwan_startup);

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

void usb_wwan_disconnect(struct usb_serial *serial)
{
	stop_read_write_urbs(serial);
}
EXPORT_SYMBOL(usb_wwan_disconnect);

void usb_wwan_release(struct usb_serial *serial)
{
	int i, j;
	struct usb_serial_port *port;
	struct usb_wwan_port_private *portdata;

	/* Now free them */
	for (i = 0; i < serial->num_ports; ++i) {
		port = serial->port[i];
		portdata = usb_get_serial_port_data(port);

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

	/* Now free per port private data */
	for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		kfree(usb_get_serial_port_data(port));
	}
}
EXPORT_SYMBOL(usb_wwan_release);

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

	if (PMSG_IS_AUTO(message)) {
		spin_lock_irq(&intfdata->susp_lock);
		b = intfdata->in_flight;
		spin_unlock_irq(&intfdata->susp_lock);

		if (b)
			return -EBUSY;
	}

	spin_lock_irq(&intfdata->susp_lock);
	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) {
			dbg("%s: No interrupt URB for port %d", __func__, i);
			continue;
		}
		err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
		dbg("Submitted interrupt URB for port %d (result %d)", i, err);
		if (err < 0) {
			dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
				__func__, err);
			goto err_out;
		}
	}

	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 */
		spin_lock_irq(&intfdata->susp_lock);
		if (!portdata->opened) {
			spin_unlock_irq(&intfdata->susp_lock);
			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);
		spin_unlock_irq(&intfdata->susp_lock);
	}
	spin_lock_irq(&intfdata->susp_lock);
	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_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");

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