b282c0f2d8e565101bd17a7f0f37e220b9b17e6d
[linux-2.6.git] / drivers / usb / serial / symbolserial.c
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 {
129         struct symbol_private *priv = usb_get_serial_data(port->serial);
130         unsigned long flags;
131         int result = 0;
132
133         dbg("%s - port %d", __func__, port->number);
134
135         spin_lock_irqsave(&priv->lock, flags);
136         priv->throttled = false;
137         priv->actually_throttled = false;
138         priv->port = port;
139         spin_unlock_irqrestore(&priv->lock, flags);
140
141         /* Start reading from the device */
142         usb_fill_int_urb(priv->int_urb, priv->udev,
143                          usb_rcvintpipe(priv->udev, priv->int_address),
144                          priv->int_buffer, priv->buffer_size,
145                          symbol_int_callback, priv, priv->bInterval);
146         result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
147         if (result)
148                 dev_err(&port->dev,
149                         "%s - failed resubmitting read urb, error %d\n",
150                         __func__, result);
151         return result;
152 }
153
154 static void symbol_close(struct usb_serial_port *port)
155 {
156         struct symbol_private *priv = usb_get_serial_data(port->serial);
157
158         dbg("%s - port %d", __func__, port->number);
159
160         /* shutdown our urbs */
161         usb_kill_urb(priv->int_urb);
162 }
163
164 static void symbol_throttle(struct tty_struct *tty)
165 {
166         struct usb_serial_port *port = tty->driver_data;
167         struct symbol_private *priv = usb_get_serial_data(port->serial);
168
169         dbg("%s - port %d", __func__, port->number);
170         spin_lock_irq(&priv->lock);
171         priv->throttled = true;
172         spin_unlock_irq(&priv->lock);
173 }
174
175 static void symbol_unthrottle(struct tty_struct *tty)
176 {
177         struct usb_serial_port *port = tty->driver_data;
178         struct symbol_private *priv = usb_get_serial_data(port->serial);
179         int result;
180         bool was_throttled;
181
182         dbg("%s - port %d", __func__, port->number);
183
184         spin_lock_irq(&priv->lock);
185         priv->throttled = false;
186         was_throttled = priv->actually_throttled;
187         priv->actually_throttled = false;
188         spin_unlock_irq(&priv->lock);
189
190         priv->int_urb->dev = port->serial->dev;
191         if (was_throttled) {
192                 result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
193                 if (result)
194                         dev_err(&port->dev,
195                                 "%s - failed submitting read urb, error %d\n",
196                                                         __func__, result);
197         }
198 }
199
200 static int symbol_startup(struct usb_serial *serial)
201 {
202         struct symbol_private *priv;
203         struct usb_host_interface *intf;
204         int i;
205         int retval = -ENOMEM;
206         bool int_in_found = false;
207
208         /* create our private serial structure */
209         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
210         if (priv == NULL) {
211                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
212                 return -ENOMEM;
213         }
214         spin_lock_init(&priv->lock);
215         priv->serial = serial;
216         priv->port = serial->port[0];
217         priv->udev = serial->dev;
218
219         /* find our interrupt endpoint */
220         intf = serial->interface->altsetting;
221         for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
222                 struct usb_endpoint_descriptor *endpoint;
223
224                 endpoint = &intf->endpoint[i].desc;
225                 if (!usb_endpoint_is_int_in(endpoint))
226                         continue;
227
228                 priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
229                 if (!priv->int_urb) {
230                         dev_err(&priv->udev->dev, "out of memory\n");
231                         goto error;
232                 }
233
234                 priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
235                 priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
236                 if (!priv->int_buffer) {
237                         dev_err(&priv->udev->dev, "out of memory\n");
238                         goto error;
239                 }
240
241                 priv->int_address = endpoint->bEndpointAddress;
242                 priv->bInterval = endpoint->bInterval;
243
244                 /* set up our int urb */
245                 usb_fill_int_urb(priv->int_urb, priv->udev,
246                                  usb_rcvintpipe(priv->udev,
247                                                 endpoint->bEndpointAddress),
248                                  priv->int_buffer, priv->buffer_size,
249                                  symbol_int_callback, priv, priv->bInterval);
250
251                 int_in_found = true;
252                 break;
253                 }
254
255         if (!int_in_found) {
256                 dev_err(&priv->udev->dev,
257                         "Error - the proper endpoints were not found!\n");
258                 goto error;
259         }
260
261         usb_set_serial_data(serial, priv);
262         return 0;
263
264 error:
265         usb_free_urb(priv->int_urb);
266         kfree(priv->int_buffer);
267         kfree(priv);
268         return retval;
269 }
270
271 static void symbol_disconnect(struct usb_serial *serial)
272 {
273         struct symbol_private *priv = usb_get_serial_data(serial);
274
275         dbg("%s", __func__);
276
277         usb_kill_urb(priv->int_urb);
278         usb_free_urb(priv->int_urb);
279 }
280
281 static void symbol_release(struct usb_serial *serial)
282 {
283         struct symbol_private *priv = usb_get_serial_data(serial);
284
285         dbg("%s", __func__);
286
287         kfree(priv->int_buffer);
288         kfree(priv);
289 }
290
291 static struct usb_driver symbol_driver = {
292         .name =                 "symbol",
293         .probe =                usb_serial_probe,
294         .disconnect =           usb_serial_disconnect,
295         .id_table =             id_table,
296         .no_dynamic_id =        1,
297 };
298
299 static struct usb_serial_driver symbol_device = {
300         .driver = {
301                 .owner =        THIS_MODULE,
302                 .name =         "symbol",
303         },
304         .id_table =             id_table,
305         .usb_driver =           &symbol_driver,
306         .num_ports =            1,
307         .attach =               symbol_startup,
308         .open =                 symbol_open,
309         .close =                symbol_close,
310         .disconnect =           symbol_disconnect,
311         .release =              symbol_release,
312         .throttle =             symbol_throttle,
313         .unthrottle =           symbol_unthrottle,
314 };
315
316 static int __init symbol_init(void)
317 {
318         int retval;
319
320         retval = usb_serial_register(&symbol_device);
321         if (retval)
322                 return retval;
323         retval = usb_register(&symbol_driver);
324         if (retval)
325                 usb_serial_deregister(&symbol_device);
326         return retval;
327 }
328
329 static void __exit symbol_exit(void)
330 {
331         usb_deregister(&symbol_driver);
332         usb_serial_deregister(&symbol_device);
333 }
334
335 module_init(symbol_init);
336 module_exit(symbol_exit);
337 MODULE_LICENSE("GPL");
338
339 module_param(debug, bool, S_IRUGO | S_IWUSR);
340 MODULE_PARM_DESC(debug, "Debug enabled or not");