2 Some of this code is credited to Linux USB open source files that are
3 distributed with Linux.
5 Copyright: 2007 Metrologic Instruments. All rights reserved.
6 Copyright: 2011 Azimut Ltd. <http://azimutrzn.ru/>
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>
22 #define DRIVER_DESC "Metrologic Instruments Inc. - USB-POS driver"
24 /* Product information. */
25 #define FOCUS_VENDOR_ID 0x0C2E
26 #define FOCUS_PRODUCT_ID_BI 0x0720
27 #define FOCUS_PRODUCT_ID_UNI 0x0700
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 /* Deactivate DTR and RTS. */
33 #define METROUSB_MCR_RTS 0x0a /* Activate RTS. */
34 #define METROUSB_MCR_DTR 0x09 /* Activate DTR. */
35 #define WDR_TIMEOUT 5000 /* default urb timeout. */
37 /* Private data structure. */
38 struct metrousb_private
{
41 unsigned long control_state
;
44 /* Device table list. */
45 static 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) }, /* MS7820 */
49 { }, /* Terminating entry. */
51 MODULE_DEVICE_TABLE(usb
, id_table
);
53 /* UNI-Directional mode commands for device configure */
54 #define UNI_CMD_OPEN 0x80
55 #define UNI_CMD_CLOSE 0xFF
57 static inline int metrousb_is_unidirectional_mode(struct usb_serial_port
*port
)
59 __u16 product_id
= le16_to_cpu(
60 port
->serial
->dev
->descriptor
.idProduct
);
62 return product_id
== FOCUS_PRODUCT_ID_UNI
;
65 static int metrousb_send_unidirectional_cmd(u8 cmd
, struct usb_serial_port
*port
)
69 u8
*buffer_cmd
= NULL
;
71 if (!metrousb_is_unidirectional_mode(port
))
74 buffer_cmd
= kzalloc(sizeof(cmd
), GFP_KERNEL
);
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
);
89 else if (actual_len
!= sizeof(cmd
))
94 static void metrousb_read_int_callback(struct urb
*urb
)
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
;
101 unsigned long flags
= 0;
103 dev_dbg(&port
->dev
, "%s\n", __func__
);
105 switch (urb
->status
) {
107 /* Success status, read from the port. */
112 /* urb has been terminated. */
114 "%s - urb shutting down, error code=%d\n",
115 __func__
, urb
->status
);
119 "%s - non-zero urb received, error code=%d\n",
120 __func__
, urb
->status
);
125 /* Set the data read from the usb port into the serial port buffer. */
126 if (urb
->actual_length
) {
127 /* Loop through the data copying each byte to the tty layer. */
128 tty_insert_flip_string(&port
->port
, data
, urb
->actual_length
);
130 /* Force the data to the tty layer. */
131 tty_flip_buffer_push(&port
->port
);
134 /* Set any port variables. */
135 spin_lock_irqsave(&metro_priv
->lock
, flags
);
136 throttled
= metro_priv
->throttled
;
137 spin_unlock_irqrestore(&metro_priv
->lock
, flags
);
142 /* Try to resubmit the urb. */
143 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
146 "%s - failed submitting interrupt in urb, error code=%d\n",
150 static void metrousb_cleanup(struct usb_serial_port
*port
)
152 usb_kill_urb(port
->interrupt_in_urb
);
154 metrousb_send_unidirectional_cmd(UNI_CMD_CLOSE
, port
);
157 static int metrousb_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
159 struct usb_serial
*serial
= port
->serial
;
160 struct metrousb_private
*metro_priv
= usb_get_serial_port_data(port
);
161 unsigned long flags
= 0;
164 /* Make sure the urb is initialized. */
165 if (!port
->interrupt_in_urb
) {
166 dev_err(&port
->dev
, "%s - interrupt urb not initialized\n",
171 /* Set the private data information for the port. */
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
);
177 /* Clear the urb pipe. */
178 usb_clear_halt(serial
->dev
, port
->interrupt_in_urb
->pipe
);
180 /* Start reading from the device */
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
);
190 "%s - failed submitting interrupt in urb, error code=%d\n",
195 /* Send activate cmd to device */
196 result
= metrousb_send_unidirectional_cmd(UNI_CMD_OPEN
, port
);
199 "%s - failed to configure device, error code=%d\n",
207 usb_kill_urb(port
->interrupt_in_urb
);
212 static int metrousb_set_modem_ctrl(struct usb_serial
*serial
, unsigned int control_state
)
215 unsigned char mcr
= METROUSB_MCR_NONE
;
217 dev_dbg(&serial
->dev
->dev
, "%s - control state = %d\n",
218 __func__
, control_state
);
220 /* Set the modem control value. */
221 if (control_state
& TIOCM_DTR
)
222 mcr
|= METROUSB_MCR_DTR
;
223 if (control_state
& TIOCM_RTS
)
224 mcr
|= METROUSB_MCR_RTS
;
226 /* Send the command to the usb port. */
227 retval
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
228 METROUSB_SET_REQUEST_TYPE
, METROUSB_SET_MODEM_CTRL_REQUEST
,
229 control_state
, 0, NULL
, 0, WDR_TIMEOUT
);
231 dev_err(&serial
->dev
->dev
,
232 "%s - set modem ctrl=0x%x failed, error code=%d\n",
233 __func__
, mcr
, retval
);
238 static int metrousb_port_probe(struct usb_serial_port
*port
)
240 struct metrousb_private
*metro_priv
;
242 metro_priv
= kzalloc(sizeof(*metro_priv
), GFP_KERNEL
);
246 spin_lock_init(&metro_priv
->lock
);
248 usb_set_serial_port_data(port
, metro_priv
);
253 static int metrousb_port_remove(struct usb_serial_port
*port
)
255 struct metrousb_private
*metro_priv
;
257 metro_priv
= usb_get_serial_port_data(port
);
263 static void metrousb_throttle(struct tty_struct
*tty
)
265 struct usb_serial_port
*port
= tty
->driver_data
;
266 struct metrousb_private
*metro_priv
= usb_get_serial_port_data(port
);
267 unsigned long flags
= 0;
269 /* Set the private information for the port to stop reading data. */
270 spin_lock_irqsave(&metro_priv
->lock
, flags
);
271 metro_priv
->throttled
= 1;
272 spin_unlock_irqrestore(&metro_priv
->lock
, flags
);
275 static int metrousb_tiocmget(struct tty_struct
*tty
)
277 unsigned long control_state
= 0;
278 struct usb_serial_port
*port
= tty
->driver_data
;
279 struct metrousb_private
*metro_priv
= usb_get_serial_port_data(port
);
280 unsigned long flags
= 0;
282 spin_lock_irqsave(&metro_priv
->lock
, flags
);
283 control_state
= metro_priv
->control_state
;
284 spin_unlock_irqrestore(&metro_priv
->lock
, flags
);
286 return control_state
;
289 static int metrousb_tiocmset(struct tty_struct
*tty
,
290 unsigned int set
, unsigned int clear
)
292 struct usb_serial_port
*port
= tty
->driver_data
;
293 struct usb_serial
*serial
= port
->serial
;
294 struct metrousb_private
*metro_priv
= usb_get_serial_port_data(port
);
295 unsigned long flags
= 0;
296 unsigned long control_state
= 0;
298 dev_dbg(tty
->dev
, "%s - set=%d, clear=%d\n", __func__
, set
, clear
);
300 spin_lock_irqsave(&metro_priv
->lock
, flags
);
301 control_state
= metro_priv
->control_state
;
303 /* Set the RTS and DTR values. */
305 control_state
|= TIOCM_RTS
;
307 control_state
|= TIOCM_DTR
;
308 if (clear
& TIOCM_RTS
)
309 control_state
&= ~TIOCM_RTS
;
310 if (clear
& TIOCM_DTR
)
311 control_state
&= ~TIOCM_DTR
;
313 metro_priv
->control_state
= control_state
;
314 spin_unlock_irqrestore(&metro_priv
->lock
, flags
);
315 return metrousb_set_modem_ctrl(serial
, control_state
);
318 static void metrousb_unthrottle(struct tty_struct
*tty
)
320 struct usb_serial_port
*port
= tty
->driver_data
;
321 struct metrousb_private
*metro_priv
= usb_get_serial_port_data(port
);
322 unsigned long flags
= 0;
325 /* Set the private information for the port to resume reading data. */
326 spin_lock_irqsave(&metro_priv
->lock
, flags
);
327 metro_priv
->throttled
= 0;
328 spin_unlock_irqrestore(&metro_priv
->lock
, flags
);
330 /* Submit the urb to read from the port. */
331 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
334 "failed submitting interrupt in urb error code=%d\n",
338 static struct usb_serial_driver metrousb_device
= {
340 .owner
= THIS_MODULE
,
343 .description
= "Metrologic USB to Serial",
344 .id_table
= id_table
,
346 .open
= metrousb_open
,
347 .close
= metrousb_cleanup
,
348 .read_int_callback
= metrousb_read_int_callback
,
349 .port_probe
= metrousb_port_probe
,
350 .port_remove
= metrousb_port_remove
,
351 .throttle
= metrousb_throttle
,
352 .unthrottle
= metrousb_unthrottle
,
353 .tiocmget
= metrousb_tiocmget
,
354 .tiocmset
= metrousb_tiocmset
,
357 static struct usb_serial_driver
* const serial_drivers
[] = {
362 module_usb_serial_driver(serial_drivers
, id_table
);
364 MODULE_LICENSE("GPL");
365 MODULE_AUTHOR("Philip Nicastro");
366 MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
367 MODULE_DESCRIPTION(DRIVER_DESC
);