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