Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/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_startup(struct usb_serial *serial)
151 {
152         if (!serial->num_interrupt_in) {
153                 dev_err(&serial->dev->dev, "no interrupt-in endpoint\n");
154                 return -ENODEV;
155         }
156 
157         return 0;
158 }
159 
160 static int symbol_port_probe(struct usb_serial_port *port)
161 {
162         struct symbol_private *priv;
163 
164         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
165         if (!priv)
166                 return -ENOMEM;
167 
168         spin_lock_init(&priv->lock);
169 
170         usb_set_serial_port_data(port, priv);
171 
172         return 0;
173 }
174 
175 static int symbol_port_remove(struct usb_serial_port *port)
176 {
177         struct symbol_private *priv = usb_get_serial_port_data(port);
178 
179         kfree(priv);
180 
181         return 0;
182 }
183 
184 static struct usb_serial_driver symbol_device = {
185         .driver = {
186                 .owner =        THIS_MODULE,
187                 .name =         "symbol",
188         },
189         .id_table =             id_table,
190         .num_ports =            1,
191         .attach =               symbol_startup,
192         .port_probe =           symbol_port_probe,
193         .port_remove =          symbol_port_remove,
194         .open =                 symbol_open,
195         .close =                symbol_close,
196         .throttle =             symbol_throttle,
197         .unthrottle =           symbol_unthrottle,
198         .read_int_callback =    symbol_int_callback,
199 };
200 
201 static struct usb_serial_driver * const serial_drivers[] = {
202         &symbol_device, NULL
203 };
204 
205 module_usb_serial_driver(serial_drivers, id_table);
206 
207 MODULE_LICENSE("GPL");
208 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us