xref: /openbmc/linux/drivers/usb/serial/metro-usb.c (revision 6aa7de05)
1 /*
2   Some of this code is credited to Linux USB open source files that are
3   distributed with Linux.
4 
5   Copyright:	2007 Metrologic Instruments. All rights reserved.
6   Copyright:	2011 Azimut Ltd. <http://azimutrzn.ru/>
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 /* Product information. */
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	/* 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. */
36 
37 /* Private data structure. */
38 struct metrousb_private {
39 	spinlock_t lock;
40 	int throttled;
41 	unsigned long control_state;
42 };
43 
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. */
50 };
51 MODULE_DEVICE_TABLE(usb, id_table);
52 
53 /* UNI-Directional mode commands for device configure */
54 #define UNI_CMD_OPEN	0x80
55 #define UNI_CMD_CLOSE	0xFF
56 
57 static 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 
65 static 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 
94 static 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 		/* Success status, read from the port. */
108 		break;
109 	case -ECONNRESET:
110 	case -ENOENT:
111 	case -ESHUTDOWN:
112 		/* urb has been terminated. */
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 	/* 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);
129 
130 		/* Force the data to the tty layer. */
131 		tty_flip_buffer_push(&port->port);
132 	}
133 
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);
138 
139 	if (throttled)
140 		return;
141 exit:
142 	/* Try to resubmit the urb. */
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 
150 static 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 
157 static 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 	/* Make sure the urb is initialized. */
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 	/* 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);
176 
177 	/* Clear the urb pipe. */
178 	usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
179 
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);
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 	/* Send activate cmd to device */
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 	}
203 exit:
204 	return result;
205 }
206 
207 static 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 	/* Set the modem control value. */
216 	if (control_state & TIOCM_DTR)
217 		mcr |= METROUSB_MCR_DTR;
218 	if (control_state & TIOCM_RTS)
219 		mcr |= METROUSB_MCR_RTS;
220 
221 	/* Send the command to the usb port. */
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 
233 static 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 
248 static 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 
258 static 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 	/* Set the private information for the port to stop reading data. */
265 	spin_lock_irqsave(&metro_priv->lock, flags);
266 	metro_priv->throttled = 1;
267 	spin_unlock_irqrestore(&metro_priv->lock, flags);
268 }
269 
270 static 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 
284 static 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 	/* Set the RTS and DTR values. */
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 
313 static 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 	/* Set the private information for the port to resume reading data. */
321 	spin_lock_irqsave(&metro_priv->lock, flags);
322 	metro_priv->throttled = 0;
323 	spin_unlock_irqrestore(&metro_priv->lock, flags);
324 
325 	/* Submit the urb to read from the port. */
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 
333 static 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 
352 static struct usb_serial_driver * const serial_drivers[] = {
353 	&metrousb_device,
354 	NULL,
355 };
356 
357 module_usb_serial_driver(serial_drivers, id_table);
358 
359 MODULE_LICENSE("GPL");
360 MODULE_AUTHOR("Philip Nicastro");
361 MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
362 MODULE_DESCRIPTION(DRIVER_DESC);
363