1
2
3
4
5
6
7
8
9#include <linux/kernel.h>
10#include <linux/init.h>
11#include <linux/tty.h>
12#include <linux/module.h>
13#include <linux/usb.h>
14#include <linux/errno.h>
15#include <linux/slab.h>
16#include <linux/tty_driver.h>
17#include <linux/tty_flip.h>
18#include <linux/moduleparam.h>
19#include <linux/spinlock.h>
20#include <linux/uaccess.h>
21#include <linux/usb/serial.h>
22
23#define DRIVER_DESC "Metrologic Instruments Inc. - USB-POS driver"
24
25
26#define FOCUS_VENDOR_ID 0x0C2E
27#define FOCUS_PRODUCT_ID_BI 0x0720
28#define FOCUS_PRODUCT_ID_UNI 0x0700
29
30#define METROUSB_SET_REQUEST_TYPE 0x40
31#define METROUSB_SET_MODEM_CTRL_REQUEST 10
32#define METROUSB_SET_BREAK_REQUEST 0x40
33#define METROUSB_MCR_NONE 0x08
34#define METROUSB_MCR_RTS 0x0a
35#define METROUSB_MCR_DTR 0x09
36#define WDR_TIMEOUT 5000
37
38
39struct metrousb_private {
40 spinlock_t lock;
41 int throttled;
42 unsigned long control_state;
43};
44
45
46static struct usb_device_id id_table[] = {
47 { USB_DEVICE(FOCUS_VENDOR_ID, FOCUS_PRODUCT_ID_BI) },
48 { USB_DEVICE(FOCUS_VENDOR_ID, FOCUS_PRODUCT_ID_UNI) },
49 { },
50};
51MODULE_DEVICE_TABLE(usb, id_table);
52
53
54#define UNI_CMD_OPEN 0x80
55#define UNI_CMD_CLOSE 0xFF
56
57inline int metrousb_is_unidirectional_mode(struct usb_serial_port *port)
58{
59 __u16 product_id = le16_to_cpu(
60 port->serial->dev->descriptor.idProduct);
61
62 return product_id == FOCUS_PRODUCT_ID_UNI;
63}
64
65static int metrousb_send_unidirectional_cmd(u8 cmd, struct usb_serial_port *port)
66{
67 int ret;
68 int actual_len;
69 u8 *buffer_cmd = NULL;
70
71 if (!metrousb_is_unidirectional_mode(port))
72 return 0;
73
74 buffer_cmd = kzalloc(sizeof(cmd), GFP_KERNEL);
75 if (!buffer_cmd)
76 return -ENOMEM;
77
78 *buffer_cmd = cmd;
79
80 ret = usb_interrupt_msg(port->serial->dev,
81 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),
82 buffer_cmd, sizeof(cmd),
83 &actual_len, USB_CTRL_SET_TIMEOUT);
84
85 kfree(buffer_cmd);
86
87 if (ret < 0)
88 return ret;
89 else if (actual_len != sizeof(cmd))
90 return -EIO;
91 return 0;
92}
93
94static void metrousb_read_int_callback(struct urb *urb)
95{
96 struct usb_serial_port *port = urb->context;
97 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
98 unsigned char *data = urb->transfer_buffer;
99 int throttled = 0;
100 int result = 0;
101 unsigned long flags = 0;
102
103 dev_dbg(&port->dev, "%s\n", __func__);
104
105 switch (urb->status) {
106 case 0:
107
108 break;
109 case -ECONNRESET:
110 case -ENOENT:
111 case -ESHUTDOWN:
112
113 dev_dbg(&port->dev,
114 "%s - urb shutting down, error code=%d\n",
115 __func__, urb->status);
116 return;
117 default:
118 dev_dbg(&port->dev,
119 "%s - non-zero urb received, error code=%d\n",
120 __func__, urb->status);
121 goto exit;
122 }
123
124
125
126 if (urb->actual_length) {
127
128 tty_insert_flip_string(&port->port, data, urb->actual_length);
129
130
131 tty_flip_buffer_push(&port->port);
132 }
133
134
135 spin_lock_irqsave(&metro_priv->lock, flags);
136 throttled = metro_priv->throttled;
137 spin_unlock_irqrestore(&metro_priv->lock, flags);
138
139
140 if (!throttled) {
141 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
142 usb_rcvintpipe(port->serial->dev, port->interrupt_in_endpointAddress),
143 port->interrupt_in_urb->transfer_buffer,
144 port->interrupt_in_urb->transfer_buffer_length,
145 metrousb_read_int_callback, port, 1);
146
147 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
148
149 if (result)
150 dev_err(&port->dev,
151 "%s - failed submitting interrupt in urb, error code=%d\n",
152 __func__, result);
153 }
154 return;
155
156exit:
157
158 result = usb_submit_urb(urb, GFP_ATOMIC);
159 if (result)
160 dev_err(&port->dev,
161 "%s - failed submitting interrupt in urb, error code=%d\n",
162 __func__, result);
163}
164
165static void metrousb_write_int_callback(struct urb *urb)
166{
167 struct usb_serial_port *port = urb->context;
168
169 dev_warn(&port->dev, "%s not implemented yet.\n",
170 __func__);
171}
172
173static void metrousb_cleanup(struct usb_serial_port *port)
174{
175 dev_dbg(&port->dev, "%s\n", __func__);
176
177 usb_unlink_urb(port->interrupt_in_urb);
178 usb_kill_urb(port->interrupt_in_urb);
179
180 metrousb_send_unidirectional_cmd(UNI_CMD_CLOSE, port);
181}
182
183static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port)
184{
185 struct usb_serial *serial = port->serial;
186 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
187 unsigned long flags = 0;
188 int result = 0;
189
190 dev_dbg(&port->dev, "%s\n", __func__);
191
192
193 if (!port->interrupt_in_urb) {
194 dev_err(&port->dev, "%s - interrupt urb not initialized\n",
195 __func__);
196 return -ENODEV;
197 }
198
199
200 spin_lock_irqsave(&metro_priv->lock, flags);
201 metro_priv->control_state = 0;
202 metro_priv->throttled = 0;
203 spin_unlock_irqrestore(&metro_priv->lock, flags);
204
205
206 usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
207
208
209 usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
210 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
211 port->interrupt_in_urb->transfer_buffer,
212 port->interrupt_in_urb->transfer_buffer_length,
213 metrousb_read_int_callback, port, 1);
214 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
215
216 if (result) {
217 dev_err(&port->dev,
218 "%s - failed submitting interrupt in urb, error code=%d\n",
219 __func__, result);
220 goto exit;
221 }
222
223
224 result = metrousb_send_unidirectional_cmd(UNI_CMD_OPEN, port);
225 if (result) {
226 dev_err(&port->dev,
227 "%s - failed to configure device for port number=%d, error code=%d\n",
228 __func__, port->number, result);
229 goto exit;
230 }
231
232 dev_dbg(&port->dev, "%s - port open\n", __func__);
233exit:
234 return result;
235}
236
237static int metrousb_set_modem_ctrl(struct usb_serial *serial, unsigned int control_state)
238{
239 int retval = 0;
240 unsigned char mcr = METROUSB_MCR_NONE;
241
242 dev_dbg(&serial->dev->dev, "%s - control state = %d\n",
243 __func__, control_state);
244
245
246 if (control_state & TIOCM_DTR)
247 mcr |= METROUSB_MCR_DTR;
248 if (control_state & TIOCM_RTS)
249 mcr |= METROUSB_MCR_RTS;
250
251
252 retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
253 METROUSB_SET_REQUEST_TYPE, METROUSB_SET_MODEM_CTRL_REQUEST,
254 control_state, 0, NULL, 0, WDR_TIMEOUT);
255 if (retval < 0)
256 dev_err(&serial->dev->dev,
257 "%s - set modem ctrl=0x%x failed, error code=%d\n",
258 __func__, mcr, retval);
259
260 return retval;
261}
262
263static int metrousb_port_probe(struct usb_serial_port *port)
264{
265 struct metrousb_private *metro_priv;
266
267 metro_priv = kzalloc(sizeof(*metro_priv), GFP_KERNEL);
268 if (!metro_priv)
269 return -ENOMEM;
270
271 spin_lock_init(&metro_priv->lock);
272
273 usb_set_serial_port_data(port, metro_priv);
274
275 return 0;
276}
277
278static int metrousb_port_remove(struct usb_serial_port *port)
279{
280 struct metrousb_private *metro_priv;
281
282 metro_priv = usb_get_serial_port_data(port);
283 kfree(metro_priv);
284
285 return 0;
286}
287
288static void metrousb_throttle(struct tty_struct *tty)
289{
290 struct usb_serial_port *port = tty->driver_data;
291 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
292 unsigned long flags = 0;
293
294 dev_dbg(tty->dev, "%s\n", __func__);
295
296
297 spin_lock_irqsave(&metro_priv->lock, flags);
298 metro_priv->throttled = 1;
299 spin_unlock_irqrestore(&metro_priv->lock, flags);
300}
301
302static int metrousb_tiocmget(struct tty_struct *tty)
303{
304 unsigned long control_state = 0;
305 struct usb_serial_port *port = tty->driver_data;
306 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
307 unsigned long flags = 0;
308
309 dev_dbg(tty->dev, "%s\n", __func__);
310
311 spin_lock_irqsave(&metro_priv->lock, flags);
312 control_state = metro_priv->control_state;
313 spin_unlock_irqrestore(&metro_priv->lock, flags);
314
315 return control_state;
316}
317
318static int metrousb_tiocmset(struct tty_struct *tty,
319 unsigned int set, unsigned int clear)
320{
321 struct usb_serial_port *port = tty->driver_data;
322 struct usb_serial *serial = port->serial;
323 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
324 unsigned long flags = 0;
325 unsigned long control_state = 0;
326
327 dev_dbg(tty->dev, "%s - set=%d, clear=%d\n", __func__, set, clear);
328
329 spin_lock_irqsave(&metro_priv->lock, flags);
330 control_state = metro_priv->control_state;
331
332
333 if (set & TIOCM_RTS)
334 control_state |= TIOCM_RTS;
335 if (set & TIOCM_DTR)
336 control_state |= TIOCM_DTR;
337 if (clear & TIOCM_RTS)
338 control_state &= ~TIOCM_RTS;
339 if (clear & TIOCM_DTR)
340 control_state &= ~TIOCM_DTR;
341
342 metro_priv->control_state = control_state;
343 spin_unlock_irqrestore(&metro_priv->lock, flags);
344 return metrousb_set_modem_ctrl(serial, control_state);
345}
346
347static void metrousb_unthrottle(struct tty_struct *tty)
348{
349 struct usb_serial_port *port = tty->driver_data;
350 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
351 unsigned long flags = 0;
352 int result = 0;
353
354 dev_dbg(tty->dev, "%s\n", __func__);
355
356
357 spin_lock_irqsave(&metro_priv->lock, flags);
358 metro_priv->throttled = 0;
359 spin_unlock_irqrestore(&metro_priv->lock, flags);
360
361
362 port->interrupt_in_urb->dev = port->serial->dev;
363 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
364 if (result)
365 dev_err(tty->dev,
366 "failed submitting interrupt in urb error code=%d\n",
367 result);
368}
369
370static struct usb_serial_driver metrousb_device = {
371 .driver = {
372 .owner = THIS_MODULE,
373 .name = "metro-usb",
374 },
375 .description = "Metrologic USB to Serial",
376 .id_table = id_table,
377 .num_ports = 1,
378 .open = metrousb_open,
379 .close = metrousb_cleanup,
380 .read_int_callback = metrousb_read_int_callback,
381 .write_int_callback = metrousb_write_int_callback,
382 .port_probe = metrousb_port_probe,
383 .port_remove = metrousb_port_remove,
384 .throttle = metrousb_throttle,
385 .unthrottle = metrousb_unthrottle,
386 .tiocmget = metrousb_tiocmget,
387 .tiocmset = metrousb_tiocmset,
388};
389
390static struct usb_serial_driver * const serial_drivers[] = {
391 &metrousb_device,
392 NULL,
393};
394
395module_usb_serial_driver(serial_drivers, id_table);
396
397MODULE_LICENSE("GPL");
398MODULE_AUTHOR("Philip Nicastro");
399MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
400MODULE_DESCRIPTION(DRIVER_DESC);
401