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