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

/*
 * USB Serial Converter Generic functions
 *
 * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com)
 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/sysrq.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/uaccess.h>
#include <linux/kfifo.h>
#include <linux/serial.h>

static int debug;

#ifdef CONFIG_USB_SERIAL_GENERIC

static int generic_probe(struct usb_interface *interface,
			 const struct usb_device_id *id);

static __u16 vendor  = 0x05f9;
static __u16 product = 0xffff;

module_param(vendor, ushort, 0);
MODULE_PARM_DESC(vendor, "User specified USB idVendor");

module_param(product, ushort, 0);
MODULE_PARM_DESC(product, "User specified USB idProduct");

static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */

/* we want to look at all devices, as the vendor/product id can change
 * depending on the command line argument */
static const struct usb_device_id generic_serial_ids[] = {
	{.driver_info = 42},
	{}
};

static struct usb_driver generic_driver = {
	.name =		"usbserial_generic",
	.probe =	generic_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	generic_serial_ids,
	.no_dynamic_id =	1,
};

/* All of the device info needed for the Generic Serial Converter */
struct usb_serial_driver usb_serial_generic_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"generic",
	},
	.id_table =		generic_device_ids,
	.usb_driver = 		&generic_driver,
	.num_ports =		1,
	.disconnect =		usb_serial_generic_disconnect,
	.release =		usb_serial_generic_release,
	.throttle =		usb_serial_generic_throttle,
	.unthrottle =		usb_serial_generic_unthrottle,
	.resume =		usb_serial_generic_resume,
};

static int generic_probe(struct usb_interface *interface,
			       const struct usb_device_id *id)
{
	const struct usb_device_id *id_pattern;

	id_pattern = usb_match_id(interface, generic_device_ids);
	if (id_pattern != NULL)
		return usb_serial_probe(interface, id);
	return -ENODEV;
}
#endif

int usb_serial_generic_register(int _debug)
{
	int retval = 0;

	debug = _debug;
#ifdef CONFIG_USB_SERIAL_GENERIC
	generic_device_ids[0].idVendor = vendor;
	generic_device_ids[0].idProduct = product;
	generic_device_ids[0].match_flags =
		USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;

	/* register our generic driver with ourselves */
	retval = usb_serial_register(&usb_serial_generic_device);
	if (retval)
		goto exit;
	retval = usb_register(&generic_driver);
	if (retval)
		usb_serial_deregister(&usb_serial_generic_device);
exit:
#endif
	return retval;
}

void usb_serial_generic_deregister(void)
{
#ifdef CONFIG_USB_SERIAL_GENERIC
	/* remove our generic driver */
	usb_deregister(&generic_driver);
	usb_serial_deregister(&usb_serial_generic_device);
#endif
}

int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	int result = 0;
	unsigned long flags;

	dbg("%s - port %d", __func__, port->number);

	/* clear the throttle flags */
	spin_lock_irqsave(&port->lock, flags);
	port->throttled = 0;
	port->throttle_req = 0;
	spin_unlock_irqrestore(&port->lock, flags);

	/* if we have a bulk endpoint, start reading from it */
	if (port->bulk_in_size)
		result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);

	return result;
}
EXPORT_SYMBOL_GPL(usb_serial_generic_open);

static void generic_cleanup(struct usb_serial_port *port)
{
	struct usb_serial *serial = port->serial;
	unsigned long flags;
	int i;

	dbg("%s - port %d", __func__, port->number);

	if (serial->dev) {
		/* shutdown any bulk transfers that might be going on */
		if (port->bulk_out_size) {
			usb_kill_urb(port->write_urb);
			for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
				usb_kill_urb(port->write_urbs[i]);

			spin_lock_irqsave(&port->lock, flags);
			kfifo_reset_out(&port->write_fifo);
			spin_unlock_irqrestore(&port->lock, flags);
		}
		if (port->bulk_in_size)
			usb_kill_urb(port->read_urb);
	}
}

void usb_serial_generic_close(struct usb_serial_port *port)
{
	dbg("%s - port %d", __func__, port->number);
	generic_cleanup(port);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_close);

int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
						void *dest, size_t size)
{
	return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock);
}

/**
 * usb_serial_generic_write_start - kick off an URB write
 * @port:	Pointer to the &struct usb_serial_port data
 *
 * Returns zero on success, or a negative errno value
 */
static int usb_serial_generic_write_start(struct usb_serial_port *port)
{
	struct urb *urb;
	int count, result;
	unsigned long flags;
	int i;

	if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags))
		return 0;
retry:
	spin_lock_irqsave(&port->lock, flags);
	if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) {
		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
		spin_unlock_irqrestore(&port->lock, flags);
		return 0;
	}
	i = (int)find_first_bit(&port->write_urbs_free,
						ARRAY_SIZE(port->write_urbs));
	spin_unlock_irqrestore(&port->lock, flags);

	urb = port->write_urbs[i];
	count = port->serial->type->prepare_write_buffer(port,
						urb->transfer_buffer,
						port->bulk_out_size);
	urb->transfer_buffer_length = count;
	usb_serial_debug_data(debug, &port->dev, __func__, count,
						urb->transfer_buffer);
	result = usb_submit_urb(urb, GFP_ATOMIC);
	if (result) {
		dev_err(&port->dev, "%s - error submitting urb: %d\n",
						__func__, result);
		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
		return result;
	}
	clear_bit(i, &port->write_urbs_free);

	spin_lock_irqsave(&port->lock, flags);
	port->tx_bytes += count;
	spin_unlock_irqrestore(&port->lock, flags);

	/* Try sending off another urb, unless in irq context (in which case
	 * there will be no free urb). */
	if (!in_irq())
		goto retry;

	clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);

	return 0;
}

/**
 * usb_serial_generic_write - generic write function for serial USB devices
 * @tty:	Pointer to &struct tty_struct for the device
 * @port:	Pointer to the &usb_serial_port structure for the device
 * @buf:	Pointer to the data to write
 * @count:	Number of bytes to write
 *
 * Returns the number of characters actually written, which may be anything
 * from zero to @count. If an error occurs, it returns the negative errno
 * value.
 */
int usb_serial_generic_write(struct tty_struct *tty,
	struct usb_serial_port *port, const unsigned char *buf, int count)
{
	int result;

	dbg("%s - port %d", __func__, port->number);

	/* only do something if we have a bulk out endpoint */
	if (!port->bulk_out_size)
		return -ENODEV;

	if (!count)
		return 0;

	count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
	result = usb_serial_generic_write_start(port);
	if (result)
		return result;

	return count;
}
EXPORT_SYMBOL_GPL(usb_serial_generic_write);

int usb_serial_generic_write_room(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	unsigned long flags;
	int room;

	dbg("%s - port %d", __func__, port->number);

	if (!port->bulk_out_size)
		return 0;

	spin_lock_irqsave(&port->lock, flags);
	room = kfifo_avail(&port->write_fifo);
	spin_unlock_irqrestore(&port->lock, flags);

	dbg("%s - returns %d", __func__, room);
	return room;
}

int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	unsigned long flags;
	int chars;

	dbg("%s - port %d", __func__, port->number);

	if (!port->bulk_out_size)
		return 0;

	spin_lock_irqsave(&port->lock, flags);
	chars = kfifo_len(&port->write_fifo) + port->tx_bytes;
	spin_unlock_irqrestore(&port->lock, flags);

	dbg("%s - returns %d", __func__, chars);
	return chars;
}

int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
					gfp_t mem_flags)
{
	int result;

	result = usb_submit_urb(port->read_urb, mem_flags);
	if (result && result != -EPERM) {
		dev_err(&port->dev, "%s - error submitting urb: %d\n",
							__func__, result);
	}
	return result;
}
EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urb);

void usb_serial_generic_process_read_urb(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct tty_struct *tty;
	char *ch = (char *)urb->transfer_buffer;
	int i;

	if (!urb->actual_length)
		return;

	tty = tty_port_tty_get(&port->port);
	if (!tty)
		return;

	/* The per character mucking around with sysrq path it too slow for
	   stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
	   where the USB serial is not a console anyway */
	if (!port->port.console || !port->sysrq)
		tty_insert_flip_string(tty, ch, urb->actual_length);
	else {
		for (i = 0; i < urb->actual_length; i++, ch++) {
			if (!usb_serial_handle_sysrq_char(tty, port, *ch))
				tty_insert_flip_char(tty, *ch, TTY_NORMAL);
		}
	}
	tty_flip_buffer_push(tty);
	tty_kref_put(tty);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);

void usb_serial_generic_read_bulk_callback(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	unsigned char *data = urb->transfer_buffer;
	int status = urb->status;
	unsigned long flags;

	dbg("%s - port %d", __func__, port->number);

	if (unlikely(status != 0)) {
		dbg("%s - nonzero read bulk status received: %d",
		    __func__, status);
		return;
	}

	usb_serial_debug_data(debug, &port->dev, __func__,
						urb->actual_length, data);
	port->serial->type->process_read_urb(urb);

	/* Throttle the device if requested by tty */
	spin_lock_irqsave(&port->lock, flags);
	port->throttled = port->throttle_req;
	if (!port->throttled) {
		spin_unlock_irqrestore(&port->lock, flags);
		usb_serial_generic_submit_read_urb(port, GFP_ATOMIC);
	} else
		spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);

void usb_serial_generic_write_bulk_callback(struct urb *urb)
{
	unsigned long flags;
	struct usb_serial_port *port = urb->context;
	int status = urb->status;
	int i;

	dbg("%s - port %d", __func__, port->number);

	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
		if (port->write_urbs[i] == urb)
			break;

	spin_lock_irqsave(&port->lock, flags);
	port->tx_bytes -= urb->transfer_buffer_length;
	set_bit(i, &port->write_urbs_free);
	spin_unlock_irqrestore(&port->lock, flags);

	if (status) {
		dbg("%s - non-zero urb status: %d", __func__, status);

		spin_lock_irqsave(&port->lock, flags);
		kfifo_reset_out(&port->write_fifo);
		spin_unlock_irqrestore(&port->lock, flags);
	} else {
		usb_serial_generic_write_start(port);
	}

	usb_serial_port_softint(port);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);

void usb_serial_generic_throttle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	unsigned long flags;

	dbg("%s - port %d", __func__, port->number);

	/* Set the throttle request flag. It will be picked up
	 * by usb_serial_generic_read_bulk_callback(). */
	spin_lock_irqsave(&port->lock, flags);
	port->throttle_req = 1;
	spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_throttle);

void usb_serial_generic_unthrottle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	int was_throttled;

	dbg("%s - port %d", __func__, port->number);

	/* Clear the throttle flags */
	spin_lock_irq(&port->lock);
	was_throttled = port->throttled;
	port->throttled = port->throttle_req = 0;
	spin_unlock_irq(&port->lock);

	if (was_throttled)
		usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle);

#ifdef CONFIG_MAGIC_SYSRQ
int usb_serial_handle_sysrq_char(struct tty_struct *tty,
			struct usb_serial_port *port, unsigned int ch)
{
	if (port->sysrq && port->port.console) {
		if (ch && time_before(jiffies, port->sysrq)) {
			handle_sysrq(ch, tty);
			port->sysrq = 0;
			return 1;
		}
		port->sysrq = 0;
	}
	return 0;
}
#else
int usb_serial_handle_sysrq_char(struct tty_struct *tty,
			struct usb_serial_port *port, unsigned int ch)
{
	return 0;
}
#endif
EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char);

int usb_serial_handle_break(struct usb_serial_port *port)
{
	if (!port->sysrq) {
		port->sysrq = jiffies + HZ*5;
		return 1;
	}
	port->sysrq = 0;
	return 0;
}
EXPORT_SYMBOL_GPL(usb_serial_handle_break);

int usb_serial_generic_resume(struct usb_serial *serial)
{
	struct usb_serial_port *port;
	int i, c = 0, r;

	for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
			continue;

		if (port->read_urb) {
			r = usb_submit_urb(port->read_urb, GFP_NOIO);
			if (r < 0)
				c++;
		}

		if (port->bulk_out_size) {
			r = usb_serial_generic_write_start(port);
			if (r < 0)
				c++;
		}
	}

	return c ? -EIO : 0;
}
EXPORT_SYMBOL_GPL(usb_serial_generic_resume);

void usb_serial_generic_disconnect(struct usb_serial *serial)
{
	int i;

	dbg("%s", __func__);

	/* stop reads and writes on all ports */
	for (i = 0; i < serial->num_ports; ++i)
		generic_cleanup(serial->port[i]);
}

void usb_serial_generic_release(struct usb_serial *serial)
{
	dbg("%s", __func__);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* USB Serial Converter Generic functions
	3	*
27c7acf2	4	* Copyright (C) 2010 Johan Hovold (jhovold@gmail.com)
1da177e4 LT	5	* Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License version
	9	* 2 as published by the Free Software Foundation.
	10	*
	11	*/
	12
1da177e4 LT	13	#include <linux/kernel.h>
	14	#include <linux/errno.h>
	15	#include <linux/slab.h>
7f0ae3a8	16	#include <linux/sysrq.h>
1da177e4 LT	17	#include <linux/tty.h>
	18	#include <linux/tty_flip.h>
	19	#include <linux/module.h>
	20	#include <linux/moduleparam.h>
	21	#include <linux/usb.h>
a969888c	22	#include <linux/usb/serial.h>
ae64387a	23	#include <linux/uaccess.h>
8e8dce06	24	#include <linux/kfifo.h>
1f87158e	25	#include <linux/serial.h>
d9b1b787	26
1da177e4 LT	27	static int debug;
	28
	29	#ifdef CONFIG_USB_SERIAL_GENERIC
b46d60fc DB	30
	31	static int generic_probe(struct usb_interface *interface,
	32	const struct usb_device_id *id);
	33
1da177e4 LT	34	static __u16 vendor = 0x05f9;
	35	static __u16 product = 0xffff;
	36
	37	module_param(vendor, ushort, 0);
	38	MODULE_PARM_DESC(vendor, "User specified USB idVendor");
	39
	40	module_param(product, ushort, 0);
	41	MODULE_PARM_DESC(product, "User specified USB idProduct");
	42
	43	static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
	44
d9b1b787 JH	45	/* we want to look at all devices, as the vendor/product id can change
d9b1b787 JH	46	* depending on the command line argument */
7d40d7e8	47	static const struct usb_device_id generic_serial_ids[] = {
d9b1b787 JH	48	{.driver_info = 42},
	49	{}
	50	};
	51
	52	static struct usb_driver generic_driver = {
	53	.name = "usbserial_generic",
	54	.probe = generic_probe,
	55	.disconnect = usb_serial_disconnect,
	56	.id_table = generic_serial_ids,
	57	.no_dynamic_id = 1,
	58	};
	59
1da177e4	60	/* All of the device info needed for the Generic Serial Converter */
ea65370d	61	struct usb_serial_driver usb_serial_generic_device = {
18fcac35 GKH	62	.driver = {
18fcac35 GKH	63	.owner = THIS_MODULE,
269bda1c	64	.name = "generic",
18fcac35	65	},
1da177e4	66	.id_table = generic_device_ids,
d9b1b787	67	.usb_driver = &generic_driver,
1da177e4	68	.num_ports = 1,
f9c99bb8 AS	69	.disconnect = usb_serial_generic_disconnect,
f9c99bb8 AS	70	.release = usb_serial_generic_release,
253ca923 JR	71	.throttle = usb_serial_generic_throttle,
253ca923 JR	72	.unthrottle = usb_serial_generic_unthrottle,
ec22559e	73	.resume = usb_serial_generic_resume,
1da177e4 LT	74	};
1da177e4 LT	75
1da177e4 LT	76	static int generic_probe(struct usb_interface *interface,
	77	const struct usb_device_id *id)
	78	{
	79	const struct usb_device_id *id_pattern;
	80
	81	id_pattern = usb_match_id(interface, generic_device_ids);
	82	if (id_pattern != NULL)
	83	return usb_serial_probe(interface, id);
	84	return -ENODEV;
	85	}
1da177e4 LT	86	#endif
1da177e4 LT	87
ae64387a	88	int usb_serial_generic_register(int _debug)
1da177e4 LT	89	{
	90	int retval = 0;
	91
	92	debug = _debug;
	93	#ifdef CONFIG_USB_SERIAL_GENERIC
	94	generic_device_ids[0].idVendor = vendor;
	95	generic_device_ids[0].idProduct = product;
ae64387a AC	96	generic_device_ids[0].match_flags =
ae64387a AC	97	USB_DEVICE_ID_MATCH_VENDOR \| USB_DEVICE_ID_MATCH_PRODUCT;
1da177e4 LT	98
1da177e4 LT	99	/* register our generic driver with ourselves */
ae64387a	100	retval = usb_serial_register(&usb_serial_generic_device);
1da177e4 LT	101	if (retval)
	102	goto exit;
	103	retval = usb_register(&generic_driver);
	104	if (retval)
	105	usb_serial_deregister(&usb_serial_generic_device);
	106	exit:
	107	#endif
	108	return retval;
	109	}
	110
ae64387a	111	void usb_serial_generic_deregister(void)
1da177e4 LT	112	{
	113	#ifdef CONFIG_USB_SERIAL_GENERIC
	114	/* remove our generic driver */
	115	usb_deregister(&generic_driver);
ae64387a	116	usb_serial_deregister(&usb_serial_generic_device);
1da177e4 LT	117	#endif
	118	}
	119
a509a7e4	120	int usb_serial_generic_open(struct tty_struct tty, struct usb_serial_port port)
1da177e4	121	{
1da177e4	122	int result = 0;
253ca923	123	unsigned long flags;
1da177e4	124
441b62c1	125	dbg("%s - port %d", __func__, port->number);
1da177e4	126
253ca923 JR	127	/* clear the throttle flags */
	128	spin_lock_irqsave(&port->lock, flags);
	129	port->throttled = 0;
	130	port->throttle_req = 0;
	131	spin_unlock_irqrestore(&port->lock, flags);
	132
	133	/* if we have a bulk endpoint, start reading from it */
41bd72f9 JH	134	if (port->bulk_in_size)
41bd72f9 JH	135	result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
1da177e4 LT	136
	137	return result;
	138	}
815ddc99	139	EXPORT_SYMBOL_GPL(usb_serial_generic_open);
1da177e4	140
95da310e	141	static void generic_cleanup(struct usb_serial_port *port)
1da177e4 LT	142	{
1da177e4 LT	143	struct usb_serial *serial = port->serial;
ec3ee508	144	unsigned long flags;
27c7acf2	145	int i;
1da177e4	146
441b62c1	147	dbg("%s - port %d", __func__, port->number);
1da177e4 LT	148
1da177e4 LT	149	if (serial->dev) {
eb8878a8	150	/* shutdown any bulk transfers that might be going on */
ec3ee508	151	if (port->bulk_out_size) {
1da177e4	152	usb_kill_urb(port->write_urb);
27c7acf2 JH	153	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
27c7acf2 JH	154	usb_kill_urb(port->write_urbs[i]);
ec3ee508 JH	155
	156	spin_lock_irqsave(&port->lock, flags);
	157	kfifo_reset_out(&port->write_fifo);
	158	spin_unlock_irqrestore(&port->lock, flags);
	159	}
eb8878a8	160	if (port->bulk_in_size)
1da177e4 LT	161	usb_kill_urb(port->read_urb);
	162	}
	163	}
	164
335f8514	165	void usb_serial_generic_close(struct usb_serial_port *port)
1da177e4	166	{
441b62c1	167	dbg("%s - port %d", __func__, port->number);
ae64387a	168	generic_cleanup(port);
1da177e4	169	}
f26788da	170	EXPORT_SYMBOL_GPL(usb_serial_generic_close);
1da177e4	171
eaa3bcb0	172	int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
c23e5fc1	173	void *dest, size_t size)
eaa3bcb0	174	{
c23e5fc1	175	return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock);
715b1dc0 JW	176	}
715b1dc0 JW	177
8e8dce06 DV	178	/**
	179	* usb_serial_generic_write_start - kick off an URB write
	180	* @port: Pointer to the &struct usb_serial_port data
	181	*
27c7acf2	182	* Returns zero on success, or a negative errno value
8e8dce06 DV	183	*/
	184	static int usb_serial_generic_write_start(struct usb_serial_port *port)
	185	{
27c7acf2 JH	186	struct urb *urb;
27c7acf2 JH	187	int count, result;
8e8dce06	188	unsigned long flags;
27c7acf2	189	int i;
8e8dce06	190
27c7acf2 JH	191	if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags))
	192	return 0;
	193	retry:
8e8dce06	194	spin_lock_irqsave(&port->lock, flags);
27c7acf2 JH	195	if (!port->write_urbs_free \|\| !kfifo_len(&port->write_fifo)) {
27c7acf2 JH	196	clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
50a5f70c JH	197	spin_unlock_irqrestore(&port->lock, flags);
50a5f70c JH	198	return 0;
8e8dce06	199	}
27c7acf2 JH	200	i = (int)find_first_bit(&port->write_urbs_free,
27c7acf2 JH	201	ARRAY_SIZE(port->write_urbs));
8e8dce06 DV	202	spin_unlock_irqrestore(&port->lock, flags);
8e8dce06 DV	203
27c7acf2	204	urb = port->write_urbs[i];
eaa3bcb0	205	count = port->serial->type->prepare_write_buffer(port,
c23e5fc1 JH	206	urb->transfer_buffer,
c23e5fc1 JH	207	port->bulk_out_size);
27c7acf2 JH	208	urb->transfer_buffer_length = count;
	209	usb_serial_debug_data(debug, &port->dev, __func__, count,
	210	urb->transfer_buffer);
	211	result = usb_submit_urb(urb, GFP_ATOMIC);
8e8dce06	212	if (result) {
1a1405e2	213	dev_err(&port->dev, "%s - error submitting urb: %d\n",
8e8dce06	214	__func__, result);
27c7acf2	215	clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
30af7fb5 JH	216	return result;
30af7fb5 JH	217	}
27c7acf2	218	clear_bit(i, &port->write_urbs_free);
8e8dce06	219
30af7fb5	220	spin_lock_irqsave(&port->lock, flags);
25d514ca	221	port->tx_bytes += count;
30af7fb5 JH	222	spin_unlock_irqrestore(&port->lock, flags);
30af7fb5 JH	223
27c7acf2 JH	224	/* Try sending off another urb, unless in irq context (in which case
	225	* there will be no free urb). */
	226	if (!in_irq())
	227	goto retry;
	228
	229	clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
	230
	231	return 0;
8e8dce06 DV	232	}
	233
	234	/**
	235	* usb_serial_generic_write - generic write function for serial USB devices
	236	* @tty: Pointer to &struct tty_struct for the device
	237	* @port: Pointer to the &usb_serial_port structure for the device
	238	* @buf: Pointer to the data to write
	239	* @count: Number of bytes to write
	240	*
	241	* Returns the number of characters actually written, which may be anything
	242	* from zero to @count. If an error occurs, it returns the negative errno
	243	* value.
	244	*/
95da310e AC	245	int usb_serial_generic_write(struct tty_struct *tty,
95da310e AC	246	struct usb_serial_port port, const unsigned char buf, int count)
1da177e4	247	{
1da177e4	248	int result;
1da177e4	249
441b62c1	250	dbg("%s - port %d", __func__, port->number);
1da177e4	251
eb8878a8 JH	252	/* only do something if we have a bulk out endpoint */
	253	if (!port->bulk_out_size)
	254	return -ENODEV;
	255
1a1405e2	256	if (!count)
ae64387a	257	return 0;
1da177e4	258
119eecc8	259	count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
8e8dce06	260	result = usb_serial_generic_write_start(port);
c23e5fc1 JH	261	if (result)
c23e5fc1 JH	262	return result;
1da177e4	263
c23e5fc1	264	return count;
1da177e4	265	}
98fcb5f7	266	EXPORT_SYMBOL_GPL(usb_serial_generic_write);
1da177e4	267
ae64387a	268	int usb_serial_generic_write_room(struct tty_struct *tty)
1da177e4	269	{
95da310e	270	struct usb_serial_port *port = tty->driver_data;
715b1dc0	271	unsigned long flags;
25d514ca	272	int room;
1da177e4	273
441b62c1	274	dbg("%s - port %d", __func__, port->number);
eb8878a8 JH	275
	276	if (!port->bulk_out_size)
	277	return 0;
	278
715b1dc0	279	spin_lock_irqsave(&port->lock, flags);
c23e5fc1	280	room = kfifo_avail(&port->write_fifo);
715b1dc0	281	spin_unlock_irqrestore(&port->lock, flags);
1da177e4	282
441b62c1	283	dbg("%s - returns %d", __func__, room);
a5b6f60c	284	return room;
1da177e4 LT	285	}
1da177e4 LT	286
95da310e	287	int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
1da177e4	288	{
95da310e	289	struct usb_serial_port *port = tty->driver_data;
715b1dc0	290	unsigned long flags;
eb8878a8	291	int chars;
1da177e4	292
441b62c1	293	dbg("%s - port %d", __func__, port->number);
1da177e4	294
eb8878a8 JH	295	if (!port->bulk_out_size)
	296	return 0;
	297
25719e6b	298	spin_lock_irqsave(&port->lock, flags);
c23e5fc1	299	chars = kfifo_len(&port->write_fifo) + port->tx_bytes;
25719e6b	300	spin_unlock_irqrestore(&port->lock, flags);
1da177e4	301
441b62c1	302	dbg("%s - returns %d", __func__, chars);
95da310e	303	return chars;
1da177e4 LT	304	}
1da177e4 LT	305
41bd72f9 JH	306	int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
41bd72f9 JH	307	gfp_t mem_flags)
1da177e4	308	{
1da177e4 LT	309	int result;
1da177e4 LT	310
056afc0f	311	result = usb_submit_urb(port->read_urb, mem_flags);
0ae14743	312	if (result && result != -EPERM) {
1a1405e2	313	dev_err(&port->dev, "%s - error submitting urb: %d\n",
ae64387a	314	__func__, result);
0ae14743	315	}
41bd72f9	316	return result;
1da177e4	317	}
41bd72f9	318	EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urb);
253ca923	319
23154320	320	void usb_serial_generic_process_read_urb(struct urb *urb)
1abdeeb1	321	{
0f3d5bae JH	322	struct usb_serial_port *port = urb->context;
0f3d5bae JH	323	struct tty_struct *tty;
98fcb5f7 JW	324	char ch = (char )urb->transfer_buffer;
	325	int i;
	326
56a1df46 JH	327	if (!urb->actual_length)
	328	return;
	329
0f3d5bae	330	tty = tty_port_tty_get(&port->port);
98fcb5f7	331	if (!tty)
0f3d5bae	332	return;
1abdeeb1	333
4cd1de0a AC	334	/* The per character mucking around with sysrq path it too slow for
	335	stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
	336	where the USB serial is not a console anyway */
bd5afa9e	337	if (!port->port.console \|\| !port->sysrq)
4cd1de0a AC	338	tty_insert_flip_string(tty, ch, urb->actual_length);
4cd1de0a AC	339	else {
4cd1de0a	340	for (i = 0; i < urb->actual_length; i++, ch++) {
24a15a62	341	if (!usb_serial_handle_sysrq_char(tty, port, *ch))
4cd1de0a AC	342	tty_insert_flip_char(tty, *ch, TTY_NORMAL);
4cd1de0a AC	343	}
1abdeeb1	344	}
98fcb5f7	345	tty_flip_buffer_push(tty);
4a90f09b	346	tty_kref_put(tty);
1abdeeb1	347	}
23154320	348	EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);
1abdeeb1	349
95da310e	350	void usb_serial_generic_read_bulk_callback(struct urb *urb)
253ca923	351	{
cdc97792	352	struct usb_serial_port *port = urb->context;
253ca923	353	unsigned char *data = urb->transfer_buffer;
fbd27225	354	int status = urb->status;
bfaeafcf	355	unsigned long flags;
253ca923	356
441b62c1	357	dbg("%s - port %d", __func__, port->number);
253ca923	358
fbd27225 GKH	359	if (unlikely(status != 0)) {
fbd27225 GKH	360	dbg("%s - nonzero read bulk status received: %d",
441b62c1	361	__func__, status);
253ca923 JR	362	return;
	363	}
	364
ae64387a AC	365	usb_serial_debug_data(debug, &port->dev, __func__,
ae64387a AC	366	urb->actual_length, data);
23154320	367	port->serial->type->process_read_urb(urb);
253ca923 JR	368
253ca923 JR	369	/* Throttle the device if requested by tty */
bfaeafcf	370	spin_lock_irqsave(&port->lock, flags);
ae64387a AC	371	port->throttled = port->throttle_req;
ae64387a AC	372	if (!port->throttled) {
b507cc97	373	spin_unlock_irqrestore(&port->lock, flags);
0f3d5bae	374	usb_serial_generic_submit_read_urb(port, GFP_ATOMIC);
ae64387a	375	} else
b507cc97	376	spin_unlock_irqrestore(&port->lock, flags);
253ca923	377	}
166ffccf	378	EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
1da177e4	379
95da310e	380	void usb_serial_generic_write_bulk_callback(struct urb *urb)
1da177e4	381	{
715b1dc0	382	unsigned long flags;
cdc97792	383	struct usb_serial_port *port = urb->context;
fbd27225	384	int status = urb->status;
27c7acf2	385	int i;
1da177e4	386
441b62c1	387	dbg("%s - port %d", __func__, port->number);
1da177e4	388
c23e5fc1 JH	389	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
	390	if (port->write_urbs[i] == urb)
	391	break;
25915302	392
c23e5fc1 JH	393	spin_lock_irqsave(&port->lock, flags);
	394	port->tx_bytes -= urb->transfer_buffer_length;
	395	set_bit(i, &port->write_urbs_free);
	396	spin_unlock_irqrestore(&port->lock, flags);
	397
	398	if (status) {
	399	dbg("%s - non-zero urb status: %d", __func__, status);
27c7acf2	400
30af7fb5	401	spin_lock_irqsave(&port->lock, flags);
c23e5fc1	402	kfifo_reset_out(&port->write_fifo);
30af7fb5	403	spin_unlock_irqrestore(&port->lock, flags);
c23e5fc1 JH	404	} else {
c23e5fc1 JH	405	usb_serial_generic_write_start(port);
1da177e4	406	}
8e8dce06	407
cf2c7481	408	usb_serial_port_softint(port);
1da177e4	409	}
bb833986	410	EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
1da177e4	411
95da310e	412	void usb_serial_generic_throttle(struct tty_struct *tty)
253ca923	413	{
95da310e	414	struct usb_serial_port *port = tty->driver_data;
253ca923 JR	415	unsigned long flags;
253ca923 JR	416
441b62c1	417	dbg("%s - port %d", __func__, port->number);
253ca923 JR	418
	419	/* Set the throttle request flag. It will be picked up
	420	* by usb_serial_generic_read_bulk_callback(). */
	421	spin_lock_irqsave(&port->lock, flags);
	422	port->throttle_req = 1;
	423	spin_unlock_irqrestore(&port->lock, flags);
	424	}
f1e949ac	425	EXPORT_SYMBOL_GPL(usb_serial_generic_throttle);
253ca923	426
95da310e	427	void usb_serial_generic_unthrottle(struct tty_struct *tty)
253ca923	428	{
95da310e	429	struct usb_serial_port *port = tty->driver_data;
253ca923	430	int was_throttled;
253ca923	431
441b62c1	432	dbg("%s - port %d", __func__, port->number);
253ca923 JR	433
253ca923 JR	434	/* Clear the throttle flags */
0f3d5bae	435	spin_lock_irq(&port->lock);
253ca923 JR	436	was_throttled = port->throttled;
253ca923 JR	437	port->throttled = port->throttle_req = 0;
0f3d5bae	438	spin_unlock_irq(&port->lock);
253ca923	439
0f3d5bae JH	440	if (was_throttled)
0f3d5bae JH	441	usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
253ca923	442	}
f1e949ac	443	EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle);
253ca923	444
7f0ae3a8	445	#ifdef CONFIG_MAGIC_SYSRQ
24a15a62 AC	446	int usb_serial_handle_sysrq_char(struct tty_struct *tty,
24a15a62 AC	447	struct usb_serial_port *port, unsigned int ch)
98fcb5f7	448	{
bd5afa9e	449	if (port->sysrq && port->port.console) {
98fcb5f7	450	if (ch && time_before(jiffies, port->sysrq)) {
24a15a62	451	handle_sysrq(ch, tty);
98fcb5f7 JW	452	port->sysrq = 0;
	453	return 1;
	454	}
	455	port->sysrq = 0;
	456	}
	457	return 0;
	458	}
7f0ae3a8 RD	459	#else
	460	int usb_serial_handle_sysrq_char(struct tty_struct *tty,
	461	struct usb_serial_port *port, unsigned int ch)
	462	{
	463	return 0;
	464	}
	465	#endif
98fcb5f7 JW	466	EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char);
	467
	468	int usb_serial_handle_break(struct usb_serial_port *port)
	469	{
	470	if (!port->sysrq) {
	471	port->sysrq = jiffies + HZ*5;
	472	return 1;
	473	}
	474	port->sysrq = 0;
	475	return 0;
	476	}
	477	EXPORT_SYMBOL_GPL(usb_serial_handle_break);
	478
8e8dce06 DV	479	int usb_serial_generic_resume(struct usb_serial *serial)
	480	{
	481	struct usb_serial_port *port;
	482	int i, c = 0, r;
	483
	484	for (i = 0; i < serial->num_ports; i++) {
	485	port = serial->port[i];
1f87158e	486	if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
8e8dce06 DV	487	continue;
	488
	489	if (port->read_urb) {
	490	r = usb_submit_urb(port->read_urb, GFP_NOIO);
	491	if (r < 0)
	492	c++;
	493	}
	494
27c7acf2	495	if (port->bulk_out_size) {
8e8dce06 DV	496	r = usb_serial_generic_write_start(port);
	497	if (r < 0)
	498	c++;
	499	}
	500	}
	501
	502	return c ? -EIO : 0;
	503	}
	504	EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
	505
f9c99bb8	506	void usb_serial_generic_disconnect(struct usb_serial *serial)
1da177e4 LT	507	{
	508	int i;
	509
441b62c1	510	dbg("%s", __func__);
1da177e4 LT	511
1da177e4 LT	512	/* stop reads and writes on all ports */
ae64387a	513	for (i = 0; i < serial->num_ports; ++i)
1da177e4	514	generic_cleanup(serial->port[i]);
1da177e4 LT	515	}
1da177e4 LT	516
f9c99bb8 AS	517	void usb_serial_generic_release(struct usb_serial *serial)
	518	{
	519	dbg("%s", __func__);
	520	}