- Linux 3.0.50.
[opensuse:kernel.git] / drivers / usb / serial / opticon.c
1 /*
2  * Opticon USB barcode to serial driver
3  *
4  * Copyright (C) 2011 Martin Jansen <martin.jansen@opticon.com>
5  * Copyright (C) 2008 - 2009 Greg Kroah-Hartman <gregkh@suse.de>
6  * Copyright (C) 2008 - 2009 Novell Inc.
7  *
8  *      This program is free software; you can redistribute it and/or
9  *      modify it under the terms of the GNU General Public License version
10  *      2 as published by the Free Software Foundation.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/tty.h>
16 #include <linux/tty_driver.h>
17 #include <linux/slab.h>
18 #include <linux/tty_flip.h>
19 #include <linux/serial.h>
20 #include <linux/module.h>
21 #include <linux/usb.h>
22 #include <linux/usb/serial.h>
23 #include <linux/uaccess.h>
24
25 #define CONTROL_RTS                     0x02
26 #define RESEND_CTS_STATE        0x03
27
28 /* max number of write urbs in flight */
29 #define URB_UPPER_LIMIT 8
30
31 /* This driver works for the Opticon 1D barcode reader
32  * an examples of 1D barcode types are EAN, UPC, Code39, IATA etc.. */
33 #define DRIVER_DESC     "Opticon USB barcode to serial driver (1D)"
34
35 static int debug;
36
37 static const struct usb_device_id id_table[] = {
38         { USB_DEVICE(0x065a, 0x0009) },
39         { },
40 };
41 MODULE_DEVICE_TABLE(usb, id_table);
42
43 /* This structure holds all of the individual device information */
44 struct opticon_private {
45         struct usb_device *udev;
46         struct usb_serial *serial;
47         struct usb_serial_port *port;
48         unsigned char *bulk_in_buffer;
49         struct urb *bulk_read_urb;
50         int buffer_size;
51         u8 bulk_address;
52         spinlock_t lock;        /* protects the following flags */
53         bool throttled;
54         bool actually_throttled;
55         bool rts;
56         bool cts;
57         int outstanding_urbs;
58 };
59
60
61
62 static void opticon_read_bulk_callback(struct urb *urb)
63 {
64         struct opticon_private *priv = urb->context;
65         unsigned char *data = urb->transfer_buffer;
66         struct usb_serial_port *port = priv->port;
67         int status = urb->status;
68         struct tty_struct *tty;
69         int result;
70         int data_length;
71         unsigned long flags;
72
73         dbg("%s - port %d", __func__, port->number);
74
75         switch (status) {
76         case 0:
77                 /* success */
78                 break;
79         case -ECONNRESET:
80         case -ENOENT:
81         case -ESHUTDOWN:
82                 /* this urb is terminated, clean up */
83                 dbg("%s - urb shutting down with status: %d",
84                     __func__, status);
85                 return;
86         default:
87                 dbg("%s - nonzero urb status received: %d",
88                     __func__, status);
89                 goto exit;
90         }
91
92         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
93                               data);
94
95         if (urb->actual_length > 2) {
96                 data_length = urb->actual_length - 2;
97
98                 /*
99                  * Data from the device comes with a 2 byte header:
100                  *
101                  * <0x00><0x00>data...
102                  *      This is real data to be sent to the tty layer
103                  * <0x00><0x01)level
104                  *      This is a CTS level change, the third byte is the CTS
105                  *      value (0 for low, 1 for high).
106                  */
107                 if ((data[0] == 0x00) && (data[1] == 0x00)) {
108                         /* real data, send it to the tty layer */
109                         tty = tty_port_tty_get(&port->port);
110                         if (tty) {
111                                 tty_insert_flip_string(tty, data + 2,
112                                                        data_length);
113                                 tty_flip_buffer_push(tty);
114                                 tty_kref_put(tty);
115                         }
116                 } else {
117                         if ((data[0] == 0x00) && (data[1] == 0x01)) {
118                                 spin_lock_irqsave(&priv->lock, flags);
119                                 /* CTS status information package */
120                                 if (data[2] == 0x00)
121                                         priv->cts = false;
122                                 else
123                                         priv->cts = true;
124                                 spin_unlock_irqrestore(&priv->lock, flags);
125                         } else {
126                                 dev_dbg(&priv->udev->dev,
127                                         "Unknown data packet received from the device:"
128                                         " %2x %2x\n",
129                                         data[0], data[1]);
130                         }
131                 }
132         } else {
133                 dev_dbg(&priv->udev->dev,
134                         "Improper amount of data received from the device, "
135                         "%d bytes", urb->actual_length);
136         }
137
138 exit:
139         spin_lock(&priv->lock);
140
141         /* Continue trying to always read if we should */
142         if (!priv->throttled) {
143                 usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
144                                   usb_rcvbulkpipe(priv->udev,
145                                                   priv->bulk_address),
146                                   priv->bulk_in_buffer, priv->buffer_size,
147                                   opticon_read_bulk_callback, priv);
148                 result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
149                 if (result)
150                         dev_err(&port->dev,
151                             "%s - failed resubmitting read urb, error %d\n",
152                                                         __func__, result);
153         } else
154                 priv->actually_throttled = true;
155         spin_unlock(&priv->lock);
156 }
157
158 static int send_control_msg(struct usb_serial_port *port, u8 requesttype,
159                                 u8 val)
160 {
161         struct usb_serial *serial = port->serial;
162         int retval;
163         u8 *buffer;
164
165         buffer = kzalloc(1, GFP_KERNEL);
166         if (!buffer)
167                 return -ENOMEM;
168
169         buffer[0] = val;
170         /* Send the message to the vendor control endpoint
171          * of the connected device */
172         retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
173                                 requesttype,
174                                 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
175                                 0, 0, buffer, 1, 0);
176         kfree(buffer);
177
178         return retval;
179 }
180
181 static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
182 {
183         struct opticon_private *priv = usb_get_serial_data(port->serial);
184         unsigned long flags;
185         int result = 0;
186
187         dbg("%s - port %d", __func__, port->number);
188
189         spin_lock_irqsave(&priv->lock, flags);
190         priv->throttled = false;
191         priv->actually_throttled = false;
192         priv->port = port;
193         priv->rts = false;
194         spin_unlock_irqrestore(&priv->lock, flags);
195
196         /* Clear RTS line */
197         send_control_msg(port, CONTROL_RTS, 0);
198
199         /* Setup the read URB and start reading from the device */
200         usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
201                           usb_rcvbulkpipe(priv->udev,
202                                           priv->bulk_address),
203                           priv->bulk_in_buffer, priv->buffer_size,
204                           opticon_read_bulk_callback, priv);
205
206         /* clear the halt status of the enpoint */
207         usb_clear_halt(priv->udev, priv->bulk_read_urb->pipe);
208
209         result = usb_submit_urb(priv->bulk_read_urb, GFP_KERNEL);
210         if (result)
211                 dev_err(&port->dev,
212                         "%s - failed resubmitting read urb, error %d\n",
213                         __func__, result);
214         /* Request CTS line state, sometimes during opening the current
215          * CTS state can be missed. */
216         send_control_msg(port, RESEND_CTS_STATE, 1);
217         return result;
218 }
219
220 static void opticon_close(struct usb_serial_port *port)
221 {
222         struct opticon_private *priv = usb_get_serial_data(port->serial);
223
224         dbg("%s - port %d", __func__, port->number);
225
226         /* shutdown our urbs */
227         usb_kill_urb(priv->bulk_read_urb);
228 }
229
230 static void opticon_write_control_callback(struct urb *urb)
231 {
232         struct opticon_private *priv = urb->context;
233         int status = urb->status;
234         unsigned long flags;
235
236         /* free up the transfer buffer, as usb_free_urb() does not do this */
237         kfree(urb->transfer_buffer);
238
239         /* setup packet may be set if we're using it for writing */
240         kfree(urb->setup_packet);
241
242         if (status)
243                 dbg("%s - nonzero write bulk status received: %d",
244                     __func__, status);
245
246         spin_lock_irqsave(&priv->lock, flags);
247         --priv->outstanding_urbs;
248         spin_unlock_irqrestore(&priv->lock, flags);
249
250         usb_serial_port_softint(priv->port);
251 }
252
253 static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
254                          const unsigned char *buf, int count)
255 {
256         struct opticon_private *priv = usb_get_serial_data(port->serial);
257         struct usb_serial *serial = port->serial;
258         struct urb *urb;
259         unsigned char *buffer;
260         unsigned long flags;
261         int status;
262         struct usb_ctrlrequest *dr;
263
264         dbg("%s - port %d", __func__, port->number);
265
266         spin_lock_irqsave(&priv->lock, flags);
267         if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
268                 spin_unlock_irqrestore(&priv->lock, flags);
269                 dbg("%s - write limit hit", __func__);
270                 return 0;
271         }
272         priv->outstanding_urbs++;
273         spin_unlock_irqrestore(&priv->lock, flags);
274
275         buffer = kmalloc(count, GFP_ATOMIC);
276         if (!buffer) {
277                 dev_err(&port->dev, "out of memory\n");
278                 count = -ENOMEM;
279
280                 goto error_no_buffer;
281         }
282
283         urb = usb_alloc_urb(0, GFP_ATOMIC);
284         if (!urb) {
285                 dev_err(&port->dev, "no more free urbs\n");
286                 count = -ENOMEM;
287                 goto error_no_urb;
288         }
289
290         memcpy(buffer, buf, count);
291
292         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
293
294         /* The conncected devices do not have a bulk write endpoint,
295          * to transmit data to de barcode device the control endpoint is used */
296         dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
297         if (!dr) {
298                 dev_err(&port->dev, "out of memory\n");
299                 count = -ENOMEM;
300                 goto error_no_dr;
301         }
302
303         dr->bRequestType = USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT;
304         dr->bRequest = 0x01;
305         dr->wValue = 0;
306         dr->wIndex = 0;
307         dr->wLength = cpu_to_le16(count);
308
309         usb_fill_control_urb(urb, serial->dev,
310                 usb_sndctrlpipe(serial->dev, 0),
311                 (unsigned char *)dr, buffer, count,
312                 opticon_write_control_callback, priv);
313
314         /* send it down the pipe */
315         status = usb_submit_urb(urb, GFP_ATOMIC);
316         if (status) {
317                 dev_err(&port->dev,
318                 "%s - usb_submit_urb(write endpoint) failed status = %d\n",
319                                                         __func__, status);
320                 count = status;
321                 goto error;
322         }
323
324         /* we are done with this urb, so let the host driver
325          * really free it when it is finished with it */
326         usb_free_urb(urb);
327
328         return count;
329 error:
330         kfree(dr);
331 error_no_dr:
332         usb_free_urb(urb);
333 error_no_urb:
334         kfree(buffer);
335 error_no_buffer:
336         spin_lock_irqsave(&priv->lock, flags);
337         --priv->outstanding_urbs;
338         spin_unlock_irqrestore(&priv->lock, flags);
339         return count;
340 }
341
342 static int opticon_write_room(struct tty_struct *tty)
343 {
344         struct usb_serial_port *port = tty->driver_data;
345         struct opticon_private *priv = usb_get_serial_data(port->serial);
346         unsigned long flags;
347
348         dbg("%s - port %d", __func__, port->number);
349
350         /*
351          * We really can take almost anything the user throws at us
352          * but let's pick a nice big number to tell the tty
353          * layer that we have lots of free space, unless we don't.
354          */
355         spin_lock_irqsave(&priv->lock, flags);
356         if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
357                 spin_unlock_irqrestore(&priv->lock, flags);
358                 dbg("%s - write limit hit", __func__);
359                 return 0;
360         }
361         spin_unlock_irqrestore(&priv->lock, flags);
362
363         return 2048;
364 }
365
366 static void opticon_throttle(struct tty_struct *tty)
367 {
368         struct usb_serial_port *port = tty->driver_data;
369         struct opticon_private *priv = usb_get_serial_data(port->serial);
370         unsigned long flags;
371
372         dbg("%s - port %d", __func__, port->number);
373         spin_lock_irqsave(&priv->lock, flags);
374         priv->throttled = true;
375         spin_unlock_irqrestore(&priv->lock, flags);
376 }
377
378
379 static void opticon_unthrottle(struct tty_struct *tty)
380 {
381         struct usb_serial_port *port = tty->driver_data;
382         struct opticon_private *priv = usb_get_serial_data(port->serial);
383         unsigned long flags;
384         int result, was_throttled;
385
386         dbg("%s - port %d", __func__, port->number);
387
388         spin_lock_irqsave(&priv->lock, flags);
389         priv->throttled = false;
390         was_throttled = priv->actually_throttled;
391         priv->actually_throttled = false;
392         spin_unlock_irqrestore(&priv->lock, flags);
393
394         priv->bulk_read_urb->dev = port->serial->dev;
395         if (was_throttled) {
396                 result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
397                 if (result)
398                         dev_err(&port->dev,
399                                 "%s - failed submitting read urb, error %d\n",
400                                                         __func__, result);
401         }
402 }
403
404 static int opticon_tiocmget(struct tty_struct *tty)
405 {
406         struct usb_serial_port *port = tty->driver_data;
407         struct opticon_private *priv = usb_get_serial_data(port->serial);
408         unsigned long flags;
409         int result = 0;
410
411         dbg("%s - port %d", __func__, port->number);
412         if (!usb_get_intfdata(port->serial->interface))
413                 return -ENODEV;
414
415         spin_lock_irqsave(&priv->lock, flags);
416         if (priv->rts)
417                 result |= TIOCM_RTS;
418         if (priv->cts)
419                 result |= TIOCM_CTS;
420         spin_unlock_irqrestore(&priv->lock, flags);
421
422         dbg("%s - %x", __func__, result);
423         return result;
424 }
425
426 static int opticon_tiocmset(struct tty_struct *tty,
427                            unsigned int set, unsigned int clear)
428 {
429         struct usb_serial_port *port = tty->driver_data;
430         struct opticon_private *priv = usb_get_serial_data(port->serial);
431         unsigned long flags;
432         bool rts;
433         bool changed = false;
434
435         if (!usb_get_intfdata(port->serial->interface))
436                 return -ENODEV;
437         /* We only support RTS so we only handle that */
438         spin_lock_irqsave(&priv->lock, flags);
439
440         rts = priv->rts;
441         if (set & TIOCM_RTS)
442                 priv->rts = true;
443         if (clear & TIOCM_RTS)
444                 priv->rts = false;
445         changed = rts ^ priv->rts;
446         spin_unlock_irqrestore(&priv->lock, flags);
447
448         if (!changed)
449                 return 0;
450
451         /* Send the new RTS state to the connected device */
452         return send_control_msg(port, CONTROL_RTS, !rts);
453 }
454
455 static int get_serial_info(struct opticon_private *priv,
456                            struct serial_struct __user *serial)
457 {
458         struct serial_struct tmp;
459
460         if (!serial)
461                 return -EFAULT;
462
463         memset(&tmp, 0x00, sizeof(tmp));
464
465         /* fake emulate a 16550 uart to make userspace code happy */
466         tmp.type                = PORT_16550A;
467         tmp.line                = priv->serial->minor;
468         tmp.port                = 0;
469         tmp.irq                 = 0;
470         tmp.flags               = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
471         tmp.xmit_fifo_size      = 1024;
472         tmp.baud_base           = 9600;
473         tmp.close_delay         = 5*HZ;
474         tmp.closing_wait        = 30*HZ;
475
476         if (copy_to_user(serial, &tmp, sizeof(*serial)))
477                 return -EFAULT;
478         return 0;
479 }
480
481 static int opticon_ioctl(struct tty_struct *tty,
482                          unsigned int cmd, unsigned long arg)
483 {
484         struct usb_serial_port *port = tty->driver_data;
485         struct opticon_private *priv = usb_get_serial_data(port->serial);
486
487         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
488
489         switch (cmd) {
490         case TIOCGSERIAL:
491                 return get_serial_info(priv,
492                                        (struct serial_struct __user *)arg);
493         }
494
495         return -ENOIOCTLCMD;
496 }
497
498 static int opticon_startup(struct usb_serial *serial)
499 {
500         struct opticon_private *priv;
501         struct usb_host_interface *intf;
502         int i;
503         int retval = -ENOMEM;
504         bool bulk_in_found = false;
505
506         /* create our private serial structure */
507         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
508         if (priv == NULL) {
509                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
510                 return -ENOMEM;
511         }
512         spin_lock_init(&priv->lock);
513         priv->serial = serial;
514         priv->port = serial->port[0];
515         priv->udev = serial->dev;
516         priv->outstanding_urbs = 0;     /* Init the outstanding urbs */
517
518         /* find our bulk endpoint */
519         intf = serial->interface->altsetting;
520         for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
521                 struct usb_endpoint_descriptor *endpoint;
522
523                 endpoint = &intf->endpoint[i].desc;
524                 if (!usb_endpoint_is_bulk_in(endpoint))
525                         continue;
526
527                 priv->bulk_read_urb = usb_alloc_urb(0, GFP_KERNEL);
528                 if (!priv->bulk_read_urb) {
529                         dev_err(&priv->udev->dev, "out of memory\n");
530                         goto error;
531                 }
532
533                 priv->buffer_size = usb_endpoint_maxp(endpoint) * 2;
534                 priv->bulk_in_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
535                 if (!priv->bulk_in_buffer) {
536                         dev_err(&priv->udev->dev, "out of memory\n");
537                         goto error;
538                 }
539
540                 priv->bulk_address = endpoint->bEndpointAddress;
541
542                 bulk_in_found = true;
543                 break;
544                 }
545
546         if (!bulk_in_found) {
547                 dev_err(&priv->udev->dev,
548                         "Error - the proper endpoints were not found!\n");
549                 goto error;
550         }
551
552         usb_set_serial_data(serial, priv);
553         return 0;
554
555 error:
556         usb_free_urb(priv->bulk_read_urb);
557         kfree(priv->bulk_in_buffer);
558         kfree(priv);
559         return retval;
560 }
561
562 static void opticon_disconnect(struct usb_serial *serial)
563 {
564         struct opticon_private *priv = usb_get_serial_data(serial);
565
566         dbg("%s", __func__);
567
568         usb_kill_urb(priv->bulk_read_urb);
569         usb_free_urb(priv->bulk_read_urb);
570 }
571
572 static void opticon_release(struct usb_serial *serial)
573 {
574         struct opticon_private *priv = usb_get_serial_data(serial);
575
576         dbg("%s", __func__);
577
578         kfree(priv->bulk_in_buffer);
579         kfree(priv);
580 }
581
582 static int opticon_suspend(struct usb_interface *intf, pm_message_t message)
583 {
584         struct usb_serial *serial = usb_get_intfdata(intf);
585         struct opticon_private *priv = usb_get_serial_data(serial);
586
587         usb_kill_urb(priv->bulk_read_urb);
588         return 0;
589 }
590
591 static int opticon_resume(struct usb_interface *intf)
592 {
593         struct usb_serial *serial = usb_get_intfdata(intf);
594         struct opticon_private *priv = usb_get_serial_data(serial);
595         struct usb_serial_port *port = serial->port[0];
596         int result;
597
598         mutex_lock(&port->port.mutex);
599         /* This is protected by the port mutex against close/open */
600         if (test_bit(ASYNCB_INITIALIZED, &port->port.flags))
601                 result = usb_submit_urb(priv->bulk_read_urb, GFP_NOIO);
602         else
603                 result = 0;
604         mutex_unlock(&port->port.mutex);
605         return result;
606 }
607
608 static struct usb_driver opticon_driver = {
609         .name =         "opticon",
610         .probe =        usb_serial_probe,
611         .disconnect =   usb_serial_disconnect,
612         .suspend =      opticon_suspend,
613         .resume =       opticon_resume,
614         .id_table =     id_table,
615         .no_dynamic_id =        1,
616 };
617
618 static struct usb_serial_driver opticon_device = {
619         .driver = {
620                 .owner =        THIS_MODULE,
621                 .name =         "opticon",
622         },
623         .id_table =             id_table,
624         .usb_driver =           &opticon_driver,
625         .num_ports =            1,
626         .attach =               opticon_startup,
627         .open =                 opticon_open,
628         .close =                opticon_close,
629         .write =                opticon_write,
630         .write_room =           opticon_write_room,
631         .disconnect =           opticon_disconnect,
632         .release =              opticon_release,
633         .throttle =             opticon_throttle,
634         .unthrottle =           opticon_unthrottle,
635         .ioctl =                opticon_ioctl,
636         .tiocmget =             opticon_tiocmget,
637         .tiocmset =             opticon_tiocmset,
638 };
639
640 static int __init opticon_init(void)
641 {
642         int retval;
643
644         retval = usb_serial_register(&opticon_device);
645         if (retval)
646                 return retval;
647         retval = usb_register(&opticon_driver);
648         if (retval)
649                 usb_serial_deregister(&opticon_device);
650         return retval;
651 }
652
653 static void __exit opticon_exit(void)
654 {
655         usb_deregister(&opticon_driver);
656         usb_serial_deregister(&opticon_device);
657 }
658
659 module_init(opticon_init);
660 module_exit(opticon_exit);
661 MODULE_DESCRIPTION(DRIVER_DESC);
662 MODULE_LICENSE("GPL");
663
664 module_param(debug, bool, S_IRUGO | S_IWUSR);
665 MODULE_PARM_DESC(debug, "Debug enabled or not");