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         /*
  65          * Data from the device comes with a 1 byte header:
  66          *
  67          * <size of data> <data>...
  68          */
  69         if (urb->actual_length > 1) {
  70                 data_length = data[0];
  71                 if (data_length > (urb->actual_length - 1))
  72                         data_length = urb->actual_length - 1;
  73                 tty_insert_flip_string(&port->port, &data[1], data_length);
  74                 tty_flip_buffer_push(&port->port);
  75         } else {
  76                 dev_dbg(&port->dev,
  77                         "Improper amount of data received from the device, "
  78                         "%d bytes", urb->actual_length);
  79         }
  80
  81 exit:
  82         spin_lock(&priv->lock);
  83
  84         /* Continue trying to always read if we should */
  85         if (!priv->throttled) {
  86                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
  87                 if (result)
  88                         dev_err(&port->dev,
  89                             "%s - failed resubmitting read urb, error %d\n",
  90                                                         __func__, result);
  91         } else
  92                 priv->actually_throttled = true;
  93         spin_unlock(&priv->lock);
  94 }
  95
  96 static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
  97 {
  98         struct symbol_private *priv = usb_get_serial_port_data(port);
  99         unsigned long flags;
 100         int result = 0;
 101
 102         spin_lock_irqsave(&priv->lock, flags);
 103         priv->throttled = false;
 104         priv->actually_throttled = false;
 105         spin_unlock_irqrestore(&priv->lock, flags);
 106
 107         /* Start reading from the device */
 108         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 109         if (result)
 110                 dev_err(&port->dev,
 111                         "%s - failed resubmitting read urb, error %d\n",
 112                         __func__, result);
 113         return result;
 114 }
 115
 116 static void symbol_close(struct usb_serial_port *port)
 117 {
 118         usb_kill_urb(port->interrupt_in_urb);
 119 }
 120
 121 static void symbol_throttle(struct tty_struct *tty)
 122 {
 123         struct usb_serial_port *port = tty->driver_data;
 124         struct symbol_private *priv = usb_get_serial_port_data(port);
 125
 126         spin_lock_irq(&priv->lock);
 127         priv->throttled = true;
 128         spin_unlock_irq(&priv->lock);
 129 }
 130
 131 static void symbol_unthrottle(struct tty_struct *tty)
 132 {
 133         struct usb_serial_port *port = tty->driver_data;
 134         struct symbol_private *priv = usb_get_serial_port_data(port);
 135         int result;
 136         bool was_throttled;
 137
 138         spin_lock_irq(&priv->lock);
 139         priv->throttled = false;
 140         was_throttled = priv->actually_throttled;
 141         priv->actually_throttled = false;
 142         spin_unlock_irq(&priv->lock);
 143
 144         if (was_throttled) {
 145                 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 146                 if (result)
 147                         dev_err(&port->dev,
 148                                 "%s - failed submitting read urb, error %d\n",
 149                                                         __func__, result);
 150         }
 151 }
 152
 153 static int symbol_startup(struct usb_serial *serial)
 154 {
 155         if (!serial->num_interrupt_in) {
 156                 dev_err(&serial->dev->dev, "no interrupt-in endpoint\n");
 157                 return -ENODEV;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static int symbol_port_probe(struct usb_serial_port *port)
 164 {
 165         struct symbol_private *priv;
 166
 167         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 168         if (!priv)
 169                 return -ENOMEM;
 170
 171         spin_lock_init(&priv->lock);
 172
 173         usb_set_serial_port_data(port, priv);
 174
 175         return 0;
 176 }
 177
 178 static int symbol_port_remove(struct usb_serial_port *port)
 179 {
 180         struct symbol_private *priv = usb_get_serial_port_data(port);
 181
 182         kfree(priv);
 183
 184         return 0;
 185 }
 186
 187 static struct usb_serial_driver symbol_device = {
 188         .driver = {
 189                 .owner =        THIS_MODULE,
 190                 .name =         "symbol",
 191         },
 192         .id_table =             id_table,
 193         .num_ports =            1,
 194         .attach =               symbol_startup,
 195         .port_probe =           symbol_port_probe,
 196         .port_remove =          symbol_port_remove,
 197         .open =                 symbol_open,
 198         .close =                symbol_close,
 199         .throttle =             symbol_throttle,
 200         .unthrottle =           symbol_unthrottle,
 201         .read_int_callback =    symbol_int_callback,
 202 };
 203
 204 static struct usb_serial_driver * const serial_drivers[] = {
 205         &symbol_device, NULL
 206 };
 207
 208 module_usb_serial_driver(serial_drivers, id_table);
 209
 210 MODULE_LICENSE("GPL");