]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/usb/serial/symbolserial.c
Merge branch 'x86/setup' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux...
[linux-2.6-omap-h63xx.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                         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
142         /*
143          * Force low_latency on so that our tty_push actually forces the data
144          * through, otherwise it is scheduled, and with high data rates (like
145          * with OHCI) data can get lost.
146          */
147         if (tty)
148                 tty->low_latency = 1;
149
150         /* Start reading from the device */
151         usb_fill_int_urb(priv->int_urb, priv->udev,
152                          usb_rcvintpipe(priv->udev, priv->int_address),
153                          priv->int_buffer, priv->buffer_size,
154                          symbol_int_callback, priv, priv->bInterval);
155         result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
156         if (result)
157                 dev_err(&port->dev,
158                         "%s - failed resubmitting read urb, error %d\n",
159                         __func__, result);
160         return result;
161 }
162
163 static void symbol_close(struct tty_struct *tty, struct usb_serial_port *port,
164                           struct file *filp)
165 {
166         struct symbol_private *priv = usb_get_serial_data(port->serial);
167
168         dbg("%s - port %d", __func__, port->number);
169
170         /* shutdown our urbs */
171         usb_kill_urb(priv->int_urb);
172 }
173
174 static void symbol_throttle(struct tty_struct *tty)
175 {
176         struct usb_serial_port *port = tty->driver_data;
177         struct symbol_private *priv = usb_get_serial_data(port->serial);
178         unsigned long flags;
179
180         dbg("%s - port %d", __func__, port->number);
181         spin_lock_irqsave(&priv->lock, flags);
182         priv->throttled = true;
183         spin_unlock_irqrestore(&priv->lock, flags);
184 }
185
186 static void symbol_unthrottle(struct tty_struct *tty)
187 {
188         struct usb_serial_port *port = tty->driver_data;
189         struct symbol_private *priv = usb_get_serial_data(port->serial);
190         unsigned long flags;
191         int result;
192
193         dbg("%s - port %d", __func__, port->number);
194
195         spin_lock_irqsave(&priv->lock, flags);
196         priv->throttled = false;
197         priv->actually_throttled = false;
198         spin_unlock_irqrestore(&priv->lock, flags);
199
200         priv->int_urb->dev = port->serial->dev;
201         result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
202         if (result)
203                 dev_err(&port->dev,
204                         "%s - failed submitting read urb, error %d\n",
205                                                         __func__, result);
206 }
207
208 static int symbol_ioctl(struct tty_struct *tty, struct file *file,
209                         unsigned int cmd, unsigned long arg)
210 {
211         struct usb_serial_port *port = tty->driver_data;
212         struct device *dev = &port->dev;
213
214         /*
215          * Right now we need to figure out what commands
216          * most userspace tools want to see for this driver,
217          * so just log the things.
218          */
219         switch (cmd) {
220         case TIOCSERGETLSR:
221                 dev_info(dev, "%s: TIOCSERGETLSR\n", __func__);
222                 break;
223
224         case TIOCGSERIAL:
225                 dev_info(dev, "%s: TIOCGSERIAL\n", __func__);
226                 break;
227
228         case TIOCMIWAIT:
229                 dev_info(dev, "%s: TIOCMIWAIT\n", __func__);
230                 break;
231
232         case TIOCGICOUNT:
233                 dev_info(dev, "%s: TIOCGICOUNT\n", __func__);
234                 break;
235         default:
236                 dev_info(dev, "%s: unknown (%d)\n", __func__, cmd);
237         }
238         return -ENOIOCTLCMD;
239 }
240
241 static int symbol_tiocmget(struct tty_struct *tty, struct file *file)
242 {
243         struct usb_serial_port *port = tty->driver_data;
244         struct device *dev = &port->dev;
245
246         /* TODO */
247         /* probably just need to shadow whatever was sent to us here */
248         dev_info(dev, "%s\n", __func__);
249         return 0;
250 }
251
252 static int symbol_tiocmset(struct tty_struct *tty, struct file *file,
253                            unsigned int set, unsigned int clear)
254 {
255         struct usb_serial_port *port = tty->driver_data;
256         struct device *dev = &port->dev;
257
258         /* TODO */
259         /* probably just need to shadow whatever was sent to us here */
260         dev_info(dev, "%s\n", __func__);
261         return 0;
262 }
263
264 static int symbol_startup(struct usb_serial *serial)
265 {
266         struct symbol_private *priv;
267         struct usb_host_interface *intf;
268         int i;
269         int retval = -ENOMEM;
270         bool int_in_found = false;
271
272         /* create our private serial structure */
273         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
274         if (priv == NULL) {
275                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
276                 return -ENOMEM;
277         }
278         spin_lock_init(&priv->lock);
279         priv->serial = serial;
280         priv->port = serial->port[0];
281         priv->udev = serial->dev;
282
283         /* find our interrupt endpoint */
284         intf = serial->interface->altsetting;
285         for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
286                 struct usb_endpoint_descriptor *endpoint;
287
288                 endpoint = &intf->endpoint[i].desc;
289                 if (!usb_endpoint_is_int_in(endpoint))
290                         continue;
291
292                 priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
293                 if (!priv->int_urb) {
294                         dev_err(&priv->udev->dev, "out of memory\n");
295                         goto error;
296                 }
297
298                 priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
299                 priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
300                 if (!priv->int_buffer) {
301                         dev_err(&priv->udev->dev, "out of memory\n");
302                         goto error;
303                 }
304
305                 priv->int_address = endpoint->bEndpointAddress;
306                 priv->bInterval = endpoint->bInterval;
307
308                 /* set up our int urb */
309                 usb_fill_int_urb(priv->int_urb, priv->udev,
310                                  usb_rcvintpipe(priv->udev,
311                                                 endpoint->bEndpointAddress),
312                                  priv->int_buffer, priv->buffer_size,
313                                  symbol_int_callback, priv, priv->bInterval);
314
315                 int_in_found = true;
316                 break;
317                 }
318
319         if (!int_in_found) {
320                 dev_err(&priv->udev->dev,
321                         "Error - the proper endpoints were not found!\n");
322                 goto error;
323         }
324
325         usb_set_serial_data(serial, priv);
326         return 0;
327
328 error:
329         usb_free_urb(priv->int_urb);
330         kfree(priv->int_buffer);
331         kfree(priv);
332         return retval;
333 }
334
335 static void symbol_shutdown(struct usb_serial *serial)
336 {
337         struct symbol_private *priv = usb_get_serial_data(serial);
338
339         dbg("%s", __func__);
340
341         usb_kill_urb(priv->int_urb);
342         usb_free_urb(priv->int_urb);
343         kfree(priv->int_buffer);
344         kfree(priv);
345         usb_set_serial_data(serial, NULL);
346 }
347
348 static struct usb_driver symbol_driver = {
349         .name =                 "symbol",
350         .probe =                usb_serial_probe,
351         .disconnect =           usb_serial_disconnect,
352         .id_table =             id_table,
353         .no_dynamic_id =        1,
354 };
355
356 static struct usb_serial_driver symbol_device = {
357         .driver = {
358                 .owner =        THIS_MODULE,
359                 .name =         "symbol",
360         },
361         .id_table =             id_table,
362         .usb_driver =           &symbol_driver,
363         .num_ports =            1,
364         .attach =               symbol_startup,
365         .open =                 symbol_open,
366         .close =                symbol_close,
367         .shutdown =             symbol_shutdown,
368         .throttle =             symbol_throttle,
369         .unthrottle =           symbol_unthrottle,
370         .ioctl =                symbol_ioctl,
371         .tiocmget =             symbol_tiocmget,
372         .tiocmset =             symbol_tiocmset,
373 };
374
375 static int __init symbol_init(void)
376 {
377         int retval;
378
379         retval = usb_serial_register(&symbol_device);
380         if (retval)
381                 return retval;
382         retval = usb_register(&symbol_driver);
383         if (retval)
384                 usb_serial_deregister(&symbol_device);
385         return retval;
386 }
387
388 static void __exit symbol_exit(void)
389 {
390         usb_deregister(&symbol_driver);
391         usb_serial_deregister(&symbol_device);
392 }
393
394 module_init(symbol_init);
395 module_exit(symbol_exit);
396 MODULE_LICENSE("GPL");
397
398 module_param(debug, bool, S_IRUGO | S_IWUSR);
399 MODULE_PARM_DESC(debug, "Debug enabled or not");