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