drivers/usb/serial/symbolserial.c

   1 /*
   2  * Symbol USB barcode to serial driver
   3  *
   4  * Copyright (C) 2013 Johan Hovold <jhovold@gmail.com>
   5  * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de>
   6  * Copyright (C) 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/slab.h>
  17 #include <linux/tty_driver.h>
  18 #include <linux/tty_flip.h>
  19 #include <linux/module.h>
  20 #include <linux/usb.h>
  21 #include <linux/usb/serial.h>
  22 #include <linux/uaccess.h>
  23
  24 static const struct usb_device_id id_table[] = {
  25         { USB_DEVICE(0x05e0, 0x0600) },
  26         { },
  27 };
  28 MODULE_DEVICE_TABLE(usb, id_table);
  29
  30 struct symbol_private {
  31         spinlock_t lock;        /* protects the following flags */
  32         bool throttled;
  33         bool actually_throttled;
  34 };
  35
  36 static void symbol_int_callback(struct urb *urb)
  37 {
  38         struct usb_serial_port *port = urb->context;
  39         struct symbol_private *priv = usb_get_serial_port_data(port);
  40         unsigned char *data = urb->transfer_buffer;
  41         int status = urb->status;
  42         int result;
  43         int data_length;
  44
  45         switch (status) {
  46         case 0:
  47                 /* success */
  48                 break;
  49         case -ECONNRESET:
  50         case -ENOENT:
  51         case -ESHUTDOWN:
  52                 /* this urb is terminated, clean up */
  53                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
  54                         __func__, status);
  55                 return;
  56         default:
  57                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
  58                         __func__, status);
  59                 goto exit;
  60         }
  61
  62         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
  63
  64         if (urb->actual_length > 1) {
  65                 data_length = urb->actual_length - 1;
  66
  67                 /*
  68                  * Data from the device comes with a 1 byte header:
  69                  *
  70                  * <size of data>data...
  71                  *      This is real data to be sent to the tty layer
  72                  * we pretty much just ignore the size and send everything
  73                  * else to the tty layer.
  74                  */
  75                 tty_insert_flip_string(&port->port, &data[1], data_length);
  76                 tty_flip_buffer_push(&port->port);
  77         } else {
  78                 dev_dbg(&port->dev,
  79                         "Improper amount of data received from the device, "
  80                         "%d bytes", urb->actual_length);
  81         }
  82
  83 exit:
  84         spin_lock(&priv->lock);
  85
  86         /* Continue trying to always read if we should */
  87         if (!priv->throttled) {
  88                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
  89                 if (result)
  90                         dev_err(&port->dev,
  91                             "%s - failed resubmitting read urb, error %d\n",
  92                                                         __func__, result);
  93         } else
  94                 priv->actually_throttled = true;
  95         spin_unlock(&priv->lock);
  96 }
  97
  98 static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
  99 {
 100         struct symbol_private *priv = usb_get_serial_data(port->serial);
 101         unsigned long flags;
 102         int result = 0;
 103
 104         spin_lock_irqsave(&priv->lock, flags);
 105         priv->throttled = false;
 106         priv->actually_throttled = false;
 107         spin_unlock_irqrestore(&priv->lock, flags);
 108
 109         /* Start reading from the device */
 110         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 111         if (result)
 112                 dev_err(&port->dev,
 113                         "%s - failed resubmitting read urb, error %d\n",
 114                         __func__, result);
 115         return result;
 116 }
 117
 118 static void symbol_close(struct usb_serial_port *port)
 119 {
 120         usb_kill_urb(port->interrupt_in_urb);
 121 }
 122
 123 static void symbol_throttle(struct tty_struct *tty)
 124 {
 125         struct usb_serial_port *port = tty->driver_data;
 126         struct symbol_private *priv = usb_get_serial_data(port->serial);
 127
 128         spin_lock_irq(&priv->lock);
 129         priv->throttled = true;
 130         spin_unlock_irq(&priv->lock);
 131 }
 132
 133 static void symbol_unthrottle(struct tty_struct *tty)
 134 {
 135         struct usb_serial_port *port = tty->driver_data;
 136         struct symbol_private *priv = usb_get_serial_data(port->serial);
 137         int result;
 138         bool was_throttled;
 139
 140         spin_lock_irq(&priv->lock);
 141         priv->throttled = false;
 142         was_throttled = priv->actually_throttled;
 143         priv->actually_throttled = false;
 144         spin_unlock_irq(&priv->lock);
 145
 146         if (was_throttled) {
 147                 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 148                 if (result)
 149                         dev_err(&port->dev,
 150                                 "%s - failed submitting read urb, error %d\n",
 151                                                         __func__, result);
 152         }
 153 }
 154
 155 static int symbol_startup(struct usb_serial *serial)
 156 {
 157         if (!serial->num_interrupt_in) {
 158                 dev_err(&serial->dev->dev, "no interrupt-in endpoint\n");
 159                 return -ENODEV;
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int symbol_port_probe(struct usb_serial_port *port)
 166 {
 167         struct symbol_private *priv;
 168
 169         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 170         if (!priv)
 171                 return -ENOMEM;
 172
 173         spin_lock_init(&priv->lock);
 174
 175         usb_set_serial_port_data(port, priv);
 176
 177         return 0;
 178 }
 179
 180 static int symbol_port_remove(struct usb_serial_port *port)
 181 {
 182         struct symbol_private *priv = usb_get_serial_port_data(port);
 183
 184         kfree(priv);
 185
 186         return 0;
 187 }
 188
 189 static struct usb_serial_driver symbol_device = {
 190         .driver = {
 191                 .owner =        THIS_MODULE,
 192                 .name =         "symbol",
 193         },
 194         .id_table =             id_table,
 195         .num_ports =            1,
 196         .attach =               symbol_startup,
 197         .port_probe =           symbol_port_probe,
 198         .port_remove =          symbol_port_remove,
 199         .open =                 symbol_open,
 200         .close =                symbol_close,
 201         .throttle =             symbol_throttle,
 202         .unthrottle =           symbol_unthrottle,
 203         .read_int_callback =    symbol_int_callback,
 204 };
 205
 206 static struct usb_serial_driver * const serial_drivers[] = {
 207         &symbol_device, NULL
 208 };
 209
 210 module_usb_serial_driver(serial_drivers, id_table);
 211
 212 MODULE_LICENSE("GPL");