Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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         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");
210 

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