1
2
3
4
5
6
7
8
9
10
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/tty.h>
15#include <linux/tty_driver.h>
16#include <linux/tty_flip.h>
17#include <linux/module.h>
18#include <linux/usb.h>
19#include <linux/usb/serial.h>
20#include <linux/uaccess.h>
21
22static int debug;
23
24static struct usb_device_id id_table[] = {
25 { USB_DEVICE(0x05e0, 0x0600) },
26 { },
27};
28MODULE_DEVICE_TABLE(usb, id_table);
29
30
31struct symbol_private {
32 struct usb_device *udev;
33 struct usb_serial *serial;
34 struct usb_serial_port *port;
35 unsigned char *int_buffer;
36 struct urb *int_urb;
37 int buffer_size;
38 u8 bInterval;
39 u8 int_address;
40 spinlock_t lock;
41 bool throttled;
42 bool actually_throttled;
43 bool rts;
44};
45
46static void symbol_int_callback(struct urb *urb)
47{
48 struct symbol_private *priv = urb->context;
49 unsigned char *data = urb->transfer_buffer;
50 struct usb_serial_port *port = priv->port;
51 int status = urb->status;
52 struct tty_struct *tty;
53 int result;
54 int available_room = 0;
55 int data_length;
56
57 dbg("%s - port %d", __func__, port->number);
58
59 switch (status) {
60 case 0:
61
62 break;
63 case -ECONNRESET:
64 case -ENOENT:
65 case -ESHUTDOWN:
66
67 dbg("%s - urb shutting down with status: %d",
68 __func__, status);
69 return;
70 default:
71 dbg("%s - nonzero urb status received: %d",
72 __func__, status);
73 goto exit;
74 }
75
76 usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
77 data);
78
79 if (urb->actual_length > 1) {
80 data_length = urb->actual_length - 1;
81
82
83
84
85
86
87
88
89
90 tty = tty_port_tty_get(&port->port);
91 if (tty) {
92 available_room = tty_buffer_request_room(tty,
93 data_length);
94 if (available_room) {
95 tty_insert_flip_string(tty, &data[1],
96 available_room);
97 tty_flip_buffer_push(tty);
98 }
99 tty_kref_put(tty);
100 }
101 } else {
102 dev_dbg(&priv->udev->dev,
103 "Improper ammount of data received from the device, "
104 "%d bytes", urb->actual_length);
105 }
106
107exit:
108 spin_lock(&priv->lock);
109
110
111 if (!priv->throttled) {
112 usb_fill_int_urb(priv->int_urb, priv->udev,
113 usb_rcvintpipe(priv->udev,
114 priv->int_address),
115 priv->int_buffer, priv->buffer_size,
116 symbol_int_callback, priv, priv->bInterval);
117 result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
118 if (result)
119 dev_err(&port->dev,
120 "%s - failed resubmitting read urb, error %d\n",
121 __func__, result);
122 } else
123 priv->actually_throttled = true;
124 spin_unlock(&priv->lock);
125}
126
127static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
128{
129 struct symbol_private *priv = usb_get_serial_data(port->serial);
130 unsigned long flags;
131 int result = 0;
132
133 dbg("%s - port %d", __func__, port->number);
134
135 spin_lock_irqsave(&priv->lock, flags);
136 priv->throttled = false;
137 priv->actually_throttled = false;
138 priv->port = port;
139 spin_unlock_irqrestore(&priv->lock, flags);
140
141
142 usb_fill_int_urb(priv->int_urb, priv->udev,
143 usb_rcvintpipe(priv->udev, priv->int_address),
144 priv->int_buffer, priv->buffer_size,
145 symbol_int_callback, priv, priv->bInterval);
146 result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
147 if (result)
148 dev_err(&port->dev,
149 "%s - failed resubmitting read urb, error %d\n",
150 __func__, result);
151 return result;
152}
153
154static void symbol_close(struct usb_serial_port *port)
155{
156 struct symbol_private *priv = usb_get_serial_data(port->serial);
157
158 dbg("%s - port %d", __func__, port->number);
159
160
161 usb_kill_urb(priv->int_urb);
162}
163
164static void symbol_throttle(struct tty_struct *tty)
165{
166 struct usb_serial_port *port = tty->driver_data;
167 struct symbol_private *priv = usb_get_serial_data(port->serial);
168
169 dbg("%s - port %d", __func__, port->number);
170 spin_lock_irq(&priv->lock);
171 priv->throttled = true;
172 spin_unlock_irq(&priv->lock);
173}
174
175static void symbol_unthrottle(struct tty_struct *tty)
176{
177 struct usb_serial_port *port = tty->driver_data;
178 struct symbol_private *priv = usb_get_serial_data(port->serial);
179 int result;
180 bool was_throttled;
181
182 dbg("%s - port %d", __func__, port->number);
183
184 spin_lock_irq(&priv->lock);
185 priv->throttled = false;
186 was_throttled = priv->actually_throttled;
187 priv->actually_throttled = false;
188 spin_unlock_irq(&priv->lock);
189
190 priv->int_urb->dev = port->serial->dev;
191 if (was_throttled) {
192 result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
193 if (result)
194 dev_err(&port->dev,
195 "%s - failed submitting read urb, error %d\n",
196 __func__, result);
197 }
198}
199
200static int symbol_startup(struct usb_serial *serial)
201{
202 struct symbol_private *priv;
203 struct usb_host_interface *intf;
204 int i;
205 int retval = -ENOMEM;
206 bool int_in_found = false;
207
208
209 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
210 if (priv == NULL) {
211 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
212 return -ENOMEM;
213 }
214 spin_lock_init(&priv->lock);
215 priv->serial = serial;
216 priv->port = serial->port[0];
217 priv->udev = serial->dev;
218
219
220 intf = serial->interface->altsetting;
221 for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
222 struct usb_endpoint_descriptor *endpoint;
223
224 endpoint = &intf->endpoint[i].desc;
225 if (!usb_endpoint_is_int_in(endpoint))
226 continue;
227
228 priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
229 if (!priv->int_urb) {
230 dev_err(&priv->udev->dev, "out of memory\n");
231 goto error;
232 }
233
234 priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
235 priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
236 if (!priv->int_buffer) {
237 dev_err(&priv->udev->dev, "out of memory\n");
238 goto error;
239 }
240
241 priv->int_address = endpoint->bEndpointAddress;
242 priv->bInterval = endpoint->bInterval;
243
244
245 usb_fill_int_urb(priv->int_urb, priv->udev,
246 usb_rcvintpipe(priv->udev,
247 endpoint->bEndpointAddress),
248 priv->int_buffer, priv->buffer_size,
249 symbol_int_callback, priv, priv->bInterval);
250
251 int_in_found = true;
252 break;
253 }
254
255 if (!int_in_found) {
256 dev_err(&priv->udev->dev,
257 "Error - the proper endpoints were not found!\n");
258 goto error;
259 }
260
261 usb_set_serial_data(serial, priv);
262 return 0;
263
264error:
265 usb_free_urb(priv->int_urb);
266 kfree(priv->int_buffer);
267 kfree(priv);
268 return retval;
269}
270
271static void symbol_disconnect(struct usb_serial *serial)
272{
273 struct symbol_private *priv = usb_get_serial_data(serial);
274
275 dbg("%s", __func__);
276
277 usb_kill_urb(priv->int_urb);
278 usb_free_urb(priv->int_urb);
279}
280
281static void symbol_release(struct usb_serial *serial)
282{
283 struct symbol_private *priv = usb_get_serial_data(serial);
284
285 dbg("%s", __func__);
286
287 kfree(priv->int_buffer);
288 kfree(priv);
289}
290
291static struct usb_driver symbol_driver = {
292 .name = "symbol",
293 .probe = usb_serial_probe,
294 .disconnect = usb_serial_disconnect,
295 .id_table = id_table,
296 .no_dynamic_id = 1,
297};
298
299static struct usb_serial_driver symbol_device = {
300 .driver = {
301 .owner = THIS_MODULE,
302 .name = "symbol",
303 },
304 .id_table = id_table,
305 .usb_driver = &symbol_driver,
306 .num_ports = 1,
307 .attach = symbol_startup,
308 .open = symbol_open,
309 .close = symbol_close,
310 .disconnect = symbol_disconnect,
311 .release = symbol_release,
312 .throttle = symbol_throttle,
313 .unthrottle = symbol_unthrottle,
314};
315
316static int __init symbol_init(void)
317{
318 int retval;
319
320 retval = usb_serial_register(&symbol_device);
321 if (retval)
322 return retval;
323 retval = usb_register(&symbol_driver);
324 if (retval)
325 usb_serial_deregister(&symbol_device);
326 return retval;
327}
328
329static void __exit symbol_exit(void)
330{
331 usb_deregister(&symbol_driver);
332 usb_serial_deregister(&symbol_device);
333}
334
335module_init(symbol_init);
336module_exit(symbol_exit);
337MODULE_LICENSE("GPL");
338
339module_param(debug, bool, S_IRUGO | S_IWUSR);
340MODULE_PARM_DESC(debug, "Debug enabled or not");
341