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