1
2
3
4
5
6
7
8
9#include <linux/kernel.h>
10#include <linux/tty.h>
11#include <linux/module.h>
12#include <linux/usb.h>
13#include <linux/errno.h>
14#include <linux/slab.h>
15#include <linux/tty_driver.h>
16#include <linux/tty_flip.h>
17#include <linux/moduleparam.h>
18#include <linux/spinlock.h>
19#include <linux/uaccess.h>
20#include <linux/usb/serial.h>
21
22#define DRIVER_DESC "Metrologic Instruments Inc. - USB-POS driver"
23
24
25#define FOCUS_VENDOR_ID 0x0C2E
26#define FOCUS_PRODUCT_ID_BI 0x0720
27#define FOCUS_PRODUCT_ID_UNI 0x0700
28
29#define METROUSB_SET_REQUEST_TYPE 0x40
30#define METROUSB_SET_MODEM_CTRL_REQUEST 10
31#define METROUSB_SET_BREAK_REQUEST 0x40
32#define METROUSB_MCR_NONE 0x08
33#define METROUSB_MCR_RTS 0x0a
34#define METROUSB_MCR_DTR 0x09
35#define WDR_TIMEOUT 5000
36
37
38struct metrousb_private {
39 spinlock_t lock;
40 int throttled;
41 unsigned long control_state;
42};
43
44
45static const struct usb_device_id id_table[] = {
46 { USB_DEVICE(FOCUS_VENDOR_ID, FOCUS_PRODUCT_ID_BI) },
47 { USB_DEVICE(FOCUS_VENDOR_ID, FOCUS_PRODUCT_ID_UNI) },
48 { USB_DEVICE_INTERFACE_CLASS(0x0c2e, 0x0730, 0xff) },
49 { },
50};
51MODULE_DEVICE_TABLE(usb, id_table);
52
53
54#define UNI_CMD_OPEN 0x80
55#define UNI_CMD_CLOSE 0xFF
56
57static inline 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 if (throttled)
140 return;
141exit:
142
143 result = usb_submit_urb(urb, GFP_ATOMIC);
144 if (result)
145 dev_err(&port->dev,
146 "%s - failed submitting interrupt in urb, error code=%d\n",
147 __func__, result);
148}
149
150static void metrousb_cleanup(struct usb_serial_port *port)
151{
152 usb_kill_urb(port->interrupt_in_urb);
153
154 metrousb_send_unidirectional_cmd(UNI_CMD_CLOSE, port);
155}
156
157static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port)
158{
159 struct usb_serial *serial = port->serial;
160 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
161 unsigned long flags = 0;
162 int result = 0;
163
164
165 if (!port->interrupt_in_urb) {
166 dev_err(&port->dev, "%s - interrupt urb not initialized\n",
167 __func__);
168 return -ENODEV;
169 }
170
171
172 spin_lock_irqsave(&metro_priv->lock, flags);
173 metro_priv->control_state = 0;
174 metro_priv->throttled = 0;
175 spin_unlock_irqrestore(&metro_priv->lock, flags);
176
177
178 usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
179
180
181 usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
182 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
183 port->interrupt_in_urb->transfer_buffer,
184 port->interrupt_in_urb->transfer_buffer_length,
185 metrousb_read_int_callback, port, 1);
186 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
187
188 if (result) {
189 dev_err(&port->dev,
190 "%s - failed submitting interrupt in urb, error code=%d\n",
191 __func__, result);
192 goto exit;
193 }
194
195
196 result = metrousb_send_unidirectional_cmd(UNI_CMD_OPEN, port);
197 if (result) {
198 dev_err(&port->dev,
199 "%s - failed to configure device, error code=%d\n",
200 __func__, result);
201 goto exit;
202 }
203exit:
204 return result;
205}
206
207static int metrousb_set_modem_ctrl(struct usb_serial *serial, unsigned int control_state)
208{
209 int retval = 0;
210 unsigned char mcr = METROUSB_MCR_NONE;
211
212 dev_dbg(&serial->dev->dev, "%s - control state = %d\n",
213 __func__, control_state);
214
215
216 if (control_state & TIOCM_DTR)
217 mcr |= METROUSB_MCR_DTR;
218 if (control_state & TIOCM_RTS)
219 mcr |= METROUSB_MCR_RTS;
220
221
222 retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
223 METROUSB_SET_REQUEST_TYPE, METROUSB_SET_MODEM_CTRL_REQUEST,
224 control_state, 0, NULL, 0, WDR_TIMEOUT);
225 if (retval < 0)
226 dev_err(&serial->dev->dev,
227 "%s - set modem ctrl=0x%x failed, error code=%d\n",
228 __func__, mcr, retval);
229
230 return retval;
231}
232
233static int metrousb_port_probe(struct usb_serial_port *port)
234{
235 struct metrousb_private *metro_priv;
236
237 metro_priv = kzalloc(sizeof(*metro_priv), GFP_KERNEL);
238 if (!metro_priv)
239 return -ENOMEM;
240
241 spin_lock_init(&metro_priv->lock);
242
243 usb_set_serial_port_data(port, metro_priv);
244
245 return 0;
246}
247
248static int metrousb_port_remove(struct usb_serial_port *port)
249{
250 struct metrousb_private *metro_priv;
251
252 metro_priv = usb_get_serial_port_data(port);
253 kfree(metro_priv);
254
255 return 0;
256}
257
258static void metrousb_throttle(struct tty_struct *tty)
259{
260 struct usb_serial_port *port = tty->driver_data;
261 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
262 unsigned long flags = 0;
263
264
265 spin_lock_irqsave(&metro_priv->lock, flags);
266 metro_priv->throttled = 1;
267 spin_unlock_irqrestore(&metro_priv->lock, flags);
268}
269
270static int metrousb_tiocmget(struct tty_struct *tty)
271{
272 unsigned long control_state = 0;
273 struct usb_serial_port *port = tty->driver_data;
274 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
275 unsigned long flags = 0;
276
277 spin_lock_irqsave(&metro_priv->lock, flags);
278 control_state = metro_priv->control_state;
279 spin_unlock_irqrestore(&metro_priv->lock, flags);
280
281 return control_state;
282}
283
284static int metrousb_tiocmset(struct tty_struct *tty,
285 unsigned int set, unsigned int clear)
286{
287 struct usb_serial_port *port = tty->driver_data;
288 struct usb_serial *serial = port->serial;
289 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
290 unsigned long flags = 0;
291 unsigned long control_state = 0;
292
293 dev_dbg(tty->dev, "%s - set=%d, clear=%d\n", __func__, set, clear);
294
295 spin_lock_irqsave(&metro_priv->lock, flags);
296 control_state = metro_priv->control_state;
297
298
299 if (set & TIOCM_RTS)
300 control_state |= TIOCM_RTS;
301 if (set & TIOCM_DTR)
302 control_state |= TIOCM_DTR;
303 if (clear & TIOCM_RTS)
304 control_state &= ~TIOCM_RTS;
305 if (clear & TIOCM_DTR)
306 control_state &= ~TIOCM_DTR;
307
308 metro_priv->control_state = control_state;
309 spin_unlock_irqrestore(&metro_priv->lock, flags);
310 return metrousb_set_modem_ctrl(serial, control_state);
311}
312
313static void metrousb_unthrottle(struct tty_struct *tty)
314{
315 struct usb_serial_port *port = tty->driver_data;
316 struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
317 unsigned long flags = 0;
318 int result = 0;
319
320
321 spin_lock_irqsave(&metro_priv->lock, flags);
322 metro_priv->throttled = 0;
323 spin_unlock_irqrestore(&metro_priv->lock, flags);
324
325
326 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
327 if (result)
328 dev_err(tty->dev,
329 "failed submitting interrupt in urb error code=%d\n",
330 result);
331}
332
333static struct usb_serial_driver metrousb_device = {
334 .driver = {
335 .owner = THIS_MODULE,
336 .name = "metro-usb",
337 },
338 .description = "Metrologic USB to Serial",
339 .id_table = id_table,
340 .num_ports = 1,
341 .open = metrousb_open,
342 .close = metrousb_cleanup,
343 .read_int_callback = metrousb_read_int_callback,
344 .port_probe = metrousb_port_probe,
345 .port_remove = metrousb_port_remove,
346 .throttle = metrousb_throttle,
347 .unthrottle = metrousb_unthrottle,
348 .tiocmget = metrousb_tiocmget,
349 .tiocmset = metrousb_tiocmset,
350};
351
352static struct usb_serial_driver * const serial_drivers[] = {
353 &metrousb_device,
354 NULL,
355};
356
357module_usb_serial_driver(serial_drivers, id_table);
358
359MODULE_LICENSE("GPL");
360MODULE_AUTHOR("Philip Nicastro");
361MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
362MODULE_DESCRIPTION(DRIVER_DESC);
363
