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

/*
 * Symbol USB barcode to serial driver
 *
 * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de>
 * Copyright (C) 2009 Novell Inc.
 *
 *	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/init.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/uaccess.h>

static int debug;

static struct usb_device_id id_table[] = {
	{ USB_DEVICE(0x05e0, 0x0600) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

/* This structure holds all of the individual device information */
struct symbol_private {
	struct usb_device *udev;
	struct usb_serial *serial;
	struct usb_serial_port *port;
	unsigned char *int_buffer;
	struct urb *int_urb;
	int buffer_size;
	u8 bInterval;
	u8 int_address;
	spinlock_t lock;	/* protects the following flags */
	bool throttled;
	bool actually_throttled;
	bool rts;
};

static void symbol_int_callback(struct urb *urb)
{
	struct symbol_private *priv = urb->context;
	unsigned char *data = urb->transfer_buffer;
	struct usb_serial_port *port = priv->port;
	int status = urb->status;
	struct tty_struct *tty;
	int result;
	int available_room = 0;
	int data_length;

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

	switch (status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dbg("%s - urb shutting down with status: %d",
		    __func__, status);
		return;
	default:
		dbg("%s - nonzero urb status received: %d",
		    __func__, status);
		goto exit;
	}

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

	if (urb->actual_length > 1) {
		data_length = urb->actual_length - 1;

		/*
		 * Data from the device comes with a 1 byte header:
		 *
		 * <size of data>data...
		 * 	This is real data to be sent to the tty layer
		 * we pretty much just ignore the size and send everything
		 * else to the tty layer.
		 */
		tty = tty_port_tty_get(&port->port);
		if (tty) {
			available_room = tty_buffer_request_room(tty,
							data_length);
			if (available_room) {
				tty_insert_flip_string(tty, &data[1],
						       available_room);
				tty_flip_buffer_push(tty);
			}
			tty_kref_put(tty);
		}
	} else {
		dev_dbg(&priv->udev->dev,
			"Improper ammount of data received from the device, "
			"%d bytes", urb->actual_length);
	}

exit:
	spin_lock(&priv->lock);

	/* Continue trying to always read if we should */
	if (!priv->throttled) {
		usb_fill_int_urb(priv->int_urb, priv->udev,
				 usb_rcvintpipe(priv->udev,
				 		priv->int_address),
				 priv->int_buffer, priv->buffer_size,
				 symbol_int_callback, priv, priv->bInterval);
		result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
		if (result)
			dev_err(&port->dev,
			    "%s - failed resubmitting read urb, error %d\n",
							__func__, result);
	} else
		priv->actually_throttled = true;
	spin_unlock(&priv->lock);
}

static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port,
			struct file *filp)
{
	struct symbol_private *priv = usb_get_serial_data(port->serial);
	unsigned long flags;
	int result = 0;

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

	spin_lock_irqsave(&priv->lock, flags);
	priv->throttled = false;
	priv->actually_throttled = false;
	priv->port = port;
	spin_unlock_irqrestore(&priv->lock, flags);

	/* Start reading from the device */
	usb_fill_int_urb(priv->int_urb, priv->udev,
			 usb_rcvintpipe(priv->udev, priv->int_address),
			 priv->int_buffer, priv->buffer_size,
			 symbol_int_callback, priv, priv->bInterval);
	result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
	if (result)
		dev_err(&port->dev,
			"%s - failed resubmitting read urb, error %d\n",
			__func__, result);
	return result;
}

static void symbol_close(struct usb_serial_port *port)
{
	struct symbol_private *priv = usb_get_serial_data(port->serial);

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

	/* shutdown our urbs */
	usb_kill_urb(priv->int_urb);
}

static void symbol_throttle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct symbol_private *priv = usb_get_serial_data(port->serial);
	unsigned long flags;

	dbg("%s - port %d", __func__, port->number);
	spin_lock_irqsave(&priv->lock, flags);
	priv->throttled = true;
	spin_unlock_irqrestore(&priv->lock, flags);
}

static void symbol_unthrottle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct symbol_private *priv = usb_get_serial_data(port->serial);
	unsigned long flags;
	int result;

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

	spin_lock_irqsave(&priv->lock, flags);
	priv->throttled = false;
	priv->actually_throttled = false;
	spin_unlock_irqrestore(&priv->lock, flags);

	priv->int_urb->dev = port->serial->dev;
	result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
	if (result)
		dev_err(&port->dev,
			"%s - failed submitting read urb, error %d\n",
							__func__, result);
}

static int symbol_startup(struct usb_serial *serial)
{
	struct symbol_private *priv;
	struct usb_host_interface *intf;
	int i;
	int retval = -ENOMEM;
	bool int_in_found = false;

	/* create our private serial structure */
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (priv == NULL) {
		dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
		return -ENOMEM;
	}
	spin_lock_init(&priv->lock);
	priv->serial = serial;
	priv->port = serial->port[0];
	priv->udev = serial->dev;

	/* find our interrupt endpoint */
	intf = serial->interface->altsetting;
	for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
		struct usb_endpoint_descriptor *endpoint;

		endpoint = &intf->endpoint[i].desc;
		if (!usb_endpoint_is_int_in(endpoint))
			continue;

		priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
		if (!priv->int_urb) {
			dev_err(&priv->udev->dev, "out of memory\n");
			goto error;
		}

		priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
		priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
		if (!priv->int_buffer) {
			dev_err(&priv->udev->dev, "out of memory\n");
			goto error;
		}

		priv->int_address = endpoint->bEndpointAddress;
		priv->bInterval = endpoint->bInterval;

		/* set up our int urb */
		usb_fill_int_urb(priv->int_urb, priv->udev,
				 usb_rcvintpipe(priv->udev,
				 		endpoint->bEndpointAddress),
				 priv->int_buffer, priv->buffer_size,
				 symbol_int_callback, priv, priv->bInterval);

		int_in_found = true;
		break;
		}

	if (!int_in_found) {
		dev_err(&priv->udev->dev,
			"Error - the proper endpoints were not found!\n");
		goto error;
	}

	usb_set_serial_data(serial, priv);
	return 0;

error:
	usb_free_urb(priv->int_urb);
	kfree(priv->int_buffer);
	kfree(priv);
	return retval;
}

static void symbol_disconnect(struct usb_serial *serial)
{
	struct symbol_private *priv = usb_get_serial_data(serial);

	dbg("%s", __func__);

	usb_kill_urb(priv->int_urb);
	usb_free_urb(priv->int_urb);
}

static void symbol_release(struct usb_serial *serial)
{
	struct symbol_private *priv = usb_get_serial_data(serial);

	dbg("%s", __func__);

	kfree(priv->int_buffer);
	kfree(priv);
}

static struct usb_driver symbol_driver = {
	.name =			"symbol",
	.probe =		usb_serial_probe,
	.disconnect =		usb_serial_disconnect,
	.id_table =		id_table,
	.no_dynamic_id = 	1,
};

static struct usb_serial_driver symbol_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"symbol",
	},
	.id_table =		id_table,
	.usb_driver = 		&symbol_driver,
	.num_ports =		1,
	.attach =		symbol_startup,
	.open =			symbol_open,
	.close =		symbol_close,
	.disconnect =		symbol_disconnect,
	.release =		symbol_release,
	.throttle = 		symbol_throttle,
	.unthrottle =		symbol_unthrottle,
};

static int __init symbol_init(void)
{
	int retval;

	retval = usb_serial_register(&symbol_device);
	if (retval)
		return retval;
	retval = usb_register(&symbol_driver);
	if (retval)
		usb_serial_deregister(&symbol_device);
	return retval;
}

static void __exit symbol_exit(void)
{
	usb_deregister(&symbol_driver);
	usb_serial_deregister(&symbol_device);
}

module_init(symbol_init);
module_exit(symbol_exit);
MODULE_LICENSE("GPL");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
Commit	Line	Data
68b44eae GKH	1	/*
	2	* Symbol USB barcode to serial driver
	3	*
	4	* Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de>
	5	* Copyright (C) 2009 Novell Inc.
	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	#include <linux/kernel.h>
	13	#include <linux/init.h>
	14	#include <linux/tty.h>
	15	#include <linux/tty_driver.h>
	16	#include <linux/tty_flip.h>
	17	#include <linux/module.h>
	18	#include <linux/usb.h>
	19	#include <linux/usb/serial.h>
	20	#include <linux/uaccess.h>
	21
	22	static int debug;
	23
	24	static struct usb_device_id id_table[] = {
	25	{ USB_DEVICE(0x05e0, 0x0600) },
	26	{ },
	27	};
	28	MODULE_DEVICE_TABLE(usb, id_table);
	29
	30	/* This structure holds all of the individual device information */
	31	struct symbol_private {
	32	struct usb_device *udev;
	33	struct usb_serial *serial;
	34	struct usb_serial_port *port;
	35	unsigned char *int_buffer;
	36	struct urb *int_urb;
	37	int buffer_size;
	38	u8 bInterval;
	39	u8 int_address;
	40	spinlock_t lock; /* protects the following flags */
	41	bool throttled;
	42	bool actually_throttled;
	43	bool rts;
	44	};
	45
	46	static void symbol_int_callback(struct urb *urb)
	47	{
	48	struct symbol_private *priv = urb->context;
	49	unsigned char *data = urb->transfer_buffer;
	50	struct usb_serial_port *port = priv->port;
	51	int status = urb->status;
	52	struct tty_struct *tty;
	53	int result;
	54	int available_room = 0;
	55	int data_length;
	56
	57	dbg("%s - port %d", __func__, port->number);
	58
	59	switch (status) {
	60	case 0:
	61	/* success */
	62	break;
	63	case -ECONNRESET:
	64	case -ENOENT:
65	case -ESHUTDOWN:
66	/* this urb is terminated, clean up */
67	dbg("%s - urb shutting down with status: %d",
68	__func__, status);
69	return;
70	default:
71	dbg("%s - nonzero urb status received: %d",
72	__func__, status);
73	goto exit;
74	}
75
76	usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
77	data);
78
79	if (urb->actual_length > 1) {
80	data_length = urb->actual_length - 1;
81
82	/*
83	* Data from the device comes with a 1 byte header:
84	*
85	* <size of data>data...
86	* This is real data to be sent to the tty layer
87	* we pretty much just ignore the size and send everything
88	* else to the tty layer.
89	*/
90	tty = tty_port_tty_get(&port->port);
91	if (tty) {
92	available_room = tty_buffer_request_room(tty,
93	data_length);
94	if (available_room) {
95	tty_insert_flip_string(tty, &data[1],
96	available_room);
97	tty_flip_buffer_push(tty);
98	}
99	tty_kref_put(tty);
100	}
101	} else {
102	dev_dbg(&priv->udev->dev,
103	"Improper ammount of data received from the device, "
104	"%d bytes", urb->actual_length);
105	}
106
107	exit:
108	spin_lock(&priv->lock);
109
110	/* Continue trying to always read if we should */
111	if (!priv->throttled) {
112	usb_fill_int_urb(priv->int_urb, priv->udev,
113	usb_rcvintpipe(priv->udev,
114	priv->int_address),
115	priv->int_buffer, priv->buffer_size,
116	symbol_int_callback, priv, priv->bInterval);
117	result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
118	if (result)
119	dev_err(&port->dev,
120	"%s - failed resubmitting read urb, error %d\n",
121	__func__, result);
122	} else
123	priv->actually_throttled = true;
124	spin_unlock(&priv->lock);
125	}
126
127	static int symbol_open(struct tty_struct tty, struct usb_serial_port port,
128	struct file *filp)
129	{
130	struct symbol_private *priv = usb_get_serial_data(port->serial);
131	unsigned long flags;
132	int result = 0;
133
134	dbg("%s - port %d", __func__, port->number);
135
136	spin_lock_irqsave(&priv->lock, flags);
137	priv->throttled = false;
138	priv->actually_throttled = false;
139	priv->port = port;
140	spin_unlock_irqrestore(&priv->lock, flags);
141
68b44eae GKH	142	/* Start reading from the device */
	143	usb_fill_int_urb(priv->int_urb, priv->udev,
	144	usb_rcvintpipe(priv->udev, priv->int_address),
	145	priv->int_buffer, priv->buffer_size,
	146	symbol_int_callback, priv, priv->bInterval);
	147	result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
	148	if (result)
	149	dev_err(&port->dev,
	150	"%s - failed resubmitting read urb, error %d\n",
	151	__func__, result);
	152	return result;
	153	}
	154
335f8514	155	static void symbol_close(struct usb_serial_port *port)
68b44eae GKH	156	{
	157	struct symbol_private *priv = usb_get_serial_data(port->serial);
	158
	159	dbg("%s - port %d", __func__, port->number);
	160
	161	/* shutdown our urbs */
	162	usb_kill_urb(priv->int_urb);
	163	}
	164
	165	static void symbol_throttle(struct tty_struct *tty)
	166	{
	167	struct usb_serial_port *port = tty->driver_data;
	168	struct symbol_private *priv = usb_get_serial_data(port->serial);
	169	unsigned long flags;
	170
	171	dbg("%s - port %d", __func__, port->number);
	172	spin_lock_irqsave(&priv->lock, flags);
	173	priv->throttled = true;
	174	spin_unlock_irqrestore(&priv->lock, flags);
	175	}
	176
	177	static void symbol_unthrottle(struct tty_struct *tty)
	178	{
	179	struct usb_serial_port *port = tty->driver_data;
	180	struct symbol_private *priv = usb_get_serial_data(port->serial);
	181	unsigned long flags;
	182	int result;
	183
	184	dbg("%s - port %d", __func__, port->number);
	185
	186	spin_lock_irqsave(&priv->lock, flags);
	187	priv->throttled = false;
	188	priv->actually_throttled = false;
	189	spin_unlock_irqrestore(&priv->lock, flags);
	190
	191	priv->int_urb->dev = port->serial->dev;
	192	result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
	193	if (result)
	194	dev_err(&port->dev,
	195	"%s - failed submitting read urb, error %d\n",
	196	__func__, result);
	197	}
	198
	199	static int symbol_startup(struct usb_serial *serial)
	200	{
	201	struct symbol_private *priv;
	202	struct usb_host_interface *intf;
	203	int i;
	204	int retval = -ENOMEM;
	205	bool int_in_found = false;
	206
	207	/* create our private serial structure */
	208	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	209	if (priv == NULL) {
	210	dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
	211	return -ENOMEM;
	212	}
	213	spin_lock_init(&priv->lock);
	214	priv->serial = serial;
	215	priv->port = serial->port[0];
	216	priv->udev = serial->dev;
	217
	218	/* find our interrupt endpoint */
	219	intf = serial->interface->altsetting;
220	for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
221	struct usb_endpoint_descriptor *endpoint;
222
223	endpoint = &intf->endpoint[i].desc;
224	if (!usb_endpoint_is_int_in(endpoint))
225	continue;
226
227	priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
228	if (!priv->int_urb) {
229	dev_err(&priv->udev->dev, "out of memory\n");
230	goto error;
231	}
232
233	priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
234	priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
235	if (!priv->int_buffer) {
236	dev_err(&priv->udev->dev, "out of memory\n");
237	goto error;
238	}
239
240	priv->int_address = endpoint->bEndpointAddress;
241	priv->bInterval = endpoint->bInterval;
242
243	/* set up our int urb */
244	usb_fill_int_urb(priv->int_urb, priv->udev,
245	usb_rcvintpipe(priv->udev,
246	endpoint->bEndpointAddress),
247	priv->int_buffer, priv->buffer_size,
248	symbol_int_callback, priv, priv->bInterval);
249
250	int_in_found = true;
251	break;
252	}
253
254	if (!int_in_found) {
255	dev_err(&priv->udev->dev,
256	"Error - the proper endpoints were not found!\n");
257	goto error;
258	}
259
260	usb_set_serial_data(serial, priv);
261	return 0;
262
263	error:
264	usb_free_urb(priv->int_urb);
265	kfree(priv->int_buffer);
266	kfree(priv);
267	return retval;
268	}
269
f9c99bb8	270	static void symbol_disconnect(struct usb_serial *serial)
68b44eae GKH	271	{
	272	struct symbol_private *priv = usb_get_serial_data(serial);
	273
	274	dbg("%s", __func__);
	275
	276	usb_kill_urb(priv->int_urb);
	277	usb_free_urb(priv->int_urb);
f9c99bb8 AS	278	}
	279
	280	static void symbol_release(struct usb_serial *serial)
	281	{
	282	struct symbol_private *priv = usb_get_serial_data(serial);
	283
	284	dbg("%s", __func__);
	285
68b44eae GKH	286	kfree(priv->int_buffer);
68b44eae GKH	287	kfree(priv);
68b44eae GKH	288	}
	289
	290	static struct usb_driver symbol_driver = {
	291	.name = "symbol",
	292	.probe = usb_serial_probe,
	293	.disconnect = usb_serial_disconnect,
	294	.id_table = id_table,
	295	.no_dynamic_id = 1,
	296	};
	297
	298	static struct usb_serial_driver symbol_device = {
	299	.driver = {
	300	.owner = THIS_MODULE,
	301	.name = "symbol",
	302	},
	303	.id_table = id_table,
	304	.usb_driver = &symbol_driver,
	305	.num_ports = 1,
	306	.attach = symbol_startup,
	307	.open = symbol_open,
	308	.close = symbol_close,
f9c99bb8 AS	309	.disconnect = symbol_disconnect,
f9c99bb8 AS	310	.release = symbol_release,
68b44eae GKH	311	.throttle = symbol_throttle,
	312	.unthrottle = symbol_unthrottle,
	313	};
	314
	315	static int __init symbol_init(void)
	316	{
	317	int retval;
	318
	319	retval = usb_serial_register(&symbol_device);
	320	if (retval)
	321	return retval;
	322	retval = usb_register(&symbol_driver);
	323	if (retval)
	324	usb_serial_deregister(&symbol_device);
	325	return retval;
	326	}
	327
	328	static void __exit symbol_exit(void)
	329	{
	330	usb_deregister(&symbol_driver);
	331	usb_serial_deregister(&symbol_device);
	332	}
	333
	334	module_init(symbol_init);
	335	module_exit(symbol_exit);
	336	MODULE_LICENSE("GPL");
	337
	338	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	339	MODULE_PARM_DESC(debug, "Debug enabled or not");