xref: /openbmc/linux/drivers/usb/serial/metro-usb.c (revision 17cd3a10)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3   Some of this code is credited to Linux USB open source files that are
4   distributed with Linux.
5 
6   Copyright:	2007 Metrologic Instruments. All rights reserved.
7   Copyright:	2011 Azimut Ltd. <http://azimutrzn.ru/>
8 */
9 
10 #include <linux/kernel.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 /* Product information. */
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	/* Deactivate DTR and RTS. */
34 #define METROUSB_MCR_RTS		0x0a	/* Activate RTS. */
35 #define METROUSB_MCR_DTR		0x09	/* Activate DTR. */
36 #define WDR_TIMEOUT			5000	/* default urb timeout. */
37 
38 /* Private data structure. */
39 struct metrousb_private {
40 	spinlock_t lock;
41 	int throttled;
42 	unsigned long control_state;
43 };
44 
45 /* Device table list. */
46 static const 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 	{ USB_DEVICE_INTERFACE_CLASS(0x0c2e, 0x0730, 0xff) },	/* MS7820 */
50 	{ }, /* Terminating entry. */
51 };
52 MODULE_DEVICE_TABLE(usb, id_table);
53 
54 /* UNI-Directional mode commands for device configure */
55 #define UNI_CMD_OPEN	0x80
56 #define UNI_CMD_CLOSE	0xFF
57 
metrousb_is_unidirectional_mode(struct usb_serial * serial)58 static int metrousb_is_unidirectional_mode(struct usb_serial *serial)
59 {
60 	u16 product_id = le16_to_cpu(serial->dev->descriptor.idProduct);
61 
62 	return product_id == FOCUS_PRODUCT_ID_UNI;
63 }
64 
metrousb_calc_num_ports(struct usb_serial * serial,struct usb_serial_endpoints * epds)65 static int metrousb_calc_num_ports(struct usb_serial *serial,
66 				   struct usb_serial_endpoints *epds)
67 {
68 	if (metrousb_is_unidirectional_mode(serial)) {
69 		if (epds->num_interrupt_out == 0) {
70 			dev_err(&serial->interface->dev, "interrupt-out endpoint missing\n");
71 			return -ENODEV;
72 		}
73 	}
74 
75 	return 1;
76 }
77 
metrousb_send_unidirectional_cmd(u8 cmd,struct usb_serial_port * port)78 static int metrousb_send_unidirectional_cmd(u8 cmd, struct usb_serial_port *port)
79 {
80 	int ret;
81 	int actual_len;
82 	u8 *buffer_cmd = NULL;
83 
84 	if (!metrousb_is_unidirectional_mode(port->serial))
85 		return 0;
86 
87 	buffer_cmd = kzalloc(sizeof(cmd), GFP_KERNEL);
88 	if (!buffer_cmd)
89 		return -ENOMEM;
90 
91 	*buffer_cmd = cmd;
92 
93 	ret = usb_interrupt_msg(port->serial->dev,
94 		usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),
95 		buffer_cmd, sizeof(cmd),
96 		&actual_len, USB_CTRL_SET_TIMEOUT);
97 
98 	kfree(buffer_cmd);
99 
100 	if (ret < 0)
101 		return ret;
102 	else if (actual_len != sizeof(cmd))
103 		return -EIO;
104 	return 0;
105 }
106 
metrousb_read_int_callback(struct urb * urb)107 static void metrousb_read_int_callback(struct urb *urb)
108 {
109 	struct usb_serial_port *port = urb->context;
110 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
111 	unsigned char *data = urb->transfer_buffer;
112 	unsigned long flags;
113 	int throttled = 0;
114 	int result = 0;
115 
116 	dev_dbg(&port->dev, "%s\n", __func__);
117 
118 	switch (urb->status) {
119 	case 0:
120 		/* Success status, read from the port. */
121 		break;
122 	case -ECONNRESET:
123 	case -ENOENT:
124 	case -ESHUTDOWN:
125 		/* urb has been terminated. */
126 		dev_dbg(&port->dev,
127 			"%s - urb shutting down, error code=%d\n",
128 			__func__, urb->status);
129 		return;
130 	default:
131 		dev_dbg(&port->dev,
132 			"%s - non-zero urb received, error code=%d\n",
133 			__func__, urb->status);
134 		goto exit;
135 	}
136 
137 
138 	/* Set the data read from the usb port into the serial port buffer. */
139 	if (urb->actual_length) {
140 		/* Loop through the data copying each byte to the tty layer. */
141 		tty_insert_flip_string(&port->port, data, urb->actual_length);
142 
143 		/* Force the data to the tty layer. */
144 		tty_flip_buffer_push(&port->port);
145 	}
146 
147 	/* Set any port variables. */
148 	spin_lock_irqsave(&metro_priv->lock, flags);
149 	throttled = metro_priv->throttled;
150 	spin_unlock_irqrestore(&metro_priv->lock, flags);
151 
152 	if (throttled)
153 		return;
154 exit:
155 	/* Try to resubmit the urb. */
156 	result = usb_submit_urb(urb, GFP_ATOMIC);
157 	if (result)
158 		dev_err(&port->dev,
159 			"%s - failed submitting interrupt in urb, error code=%d\n",
160 			__func__, result);
161 }
162 
metrousb_cleanup(struct usb_serial_port * port)163 static void metrousb_cleanup(struct usb_serial_port *port)
164 {
165 	usb_kill_urb(port->interrupt_in_urb);
166 
167 	metrousb_send_unidirectional_cmd(UNI_CMD_CLOSE, port);
168 }
169 
metrousb_open(struct tty_struct * tty,struct usb_serial_port * port)170 static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port)
171 {
172 	struct usb_serial *serial = port->serial;
173 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
174 	unsigned long flags;
175 	int result = 0;
176 
177 	/* Set the private data information for the port. */
178 	spin_lock_irqsave(&metro_priv->lock, flags);
179 	metro_priv->control_state = 0;
180 	metro_priv->throttled = 0;
181 	spin_unlock_irqrestore(&metro_priv->lock, flags);
182 
183 	/* Clear the urb pipe. */
184 	usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
185 
186 	/* Start reading from the device */
187 	usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
188 			  usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
189 			   port->interrupt_in_urb->transfer_buffer,
190 			   port->interrupt_in_urb->transfer_buffer_length,
191 			   metrousb_read_int_callback, port, 1);
192 	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
193 
194 	if (result) {
195 		dev_err(&port->dev,
196 			"%s - failed submitting interrupt in urb, error code=%d\n",
197 			__func__, result);
198 		return result;
199 	}
200 
201 	/* Send activate cmd to device */
202 	result = metrousb_send_unidirectional_cmd(UNI_CMD_OPEN, port);
203 	if (result) {
204 		dev_err(&port->dev,
205 			"%s - failed to configure device, error code=%d\n",
206 			__func__, result);
207 		goto err_kill_urb;
208 	}
209 
210 	return 0;
211 
212 err_kill_urb:
213 	usb_kill_urb(port->interrupt_in_urb);
214 
215 	return result;
216 }
217 
metrousb_set_modem_ctrl(struct usb_serial * serial,unsigned int control_state)218 static int metrousb_set_modem_ctrl(struct usb_serial *serial, unsigned int control_state)
219 {
220 	int retval = 0;
221 	unsigned char mcr = METROUSB_MCR_NONE;
222 
223 	dev_dbg(&serial->dev->dev, "%s - control state = %d\n",
224 		__func__, control_state);
225 
226 	/* Set the modem control value. */
227 	if (control_state & TIOCM_DTR)
228 		mcr |= METROUSB_MCR_DTR;
229 	if (control_state & TIOCM_RTS)
230 		mcr |= METROUSB_MCR_RTS;
231 
232 	/* Send the command to the usb port. */
233 	retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
234 				METROUSB_SET_REQUEST_TYPE, METROUSB_SET_MODEM_CTRL_REQUEST,
235 				control_state, 0, NULL, 0, WDR_TIMEOUT);
236 	if (retval < 0)
237 		dev_err(&serial->dev->dev,
238 			"%s - set modem ctrl=0x%x failed, error code=%d\n",
239 			__func__, mcr, retval);
240 
241 	return retval;
242 }
243 
metrousb_port_probe(struct usb_serial_port * port)244 static int metrousb_port_probe(struct usb_serial_port *port)
245 {
246 	struct metrousb_private *metro_priv;
247 
248 	metro_priv = kzalloc(sizeof(*metro_priv), GFP_KERNEL);
249 	if (!metro_priv)
250 		return -ENOMEM;
251 
252 	spin_lock_init(&metro_priv->lock);
253 
254 	usb_set_serial_port_data(port, metro_priv);
255 
256 	return 0;
257 }
258 
metrousb_port_remove(struct usb_serial_port * port)259 static void metrousb_port_remove(struct usb_serial_port *port)
260 {
261 	struct metrousb_private *metro_priv;
262 
263 	metro_priv = usb_get_serial_port_data(port);
264 	kfree(metro_priv);
265 }
266 
metrousb_throttle(struct tty_struct * tty)267 static void metrousb_throttle(struct tty_struct *tty)
268 {
269 	struct usb_serial_port *port = tty->driver_data;
270 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
271 	unsigned long flags;
272 
273 	/* Set the private information for the port to stop reading data. */
274 	spin_lock_irqsave(&metro_priv->lock, flags);
275 	metro_priv->throttled = 1;
276 	spin_unlock_irqrestore(&metro_priv->lock, flags);
277 }
278 
metrousb_tiocmget(struct tty_struct * tty)279 static int metrousb_tiocmget(struct tty_struct *tty)
280 {
281 	unsigned long control_state = 0;
282 	struct usb_serial_port *port = tty->driver_data;
283 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
284 	unsigned long flags;
285 
286 	spin_lock_irqsave(&metro_priv->lock, flags);
287 	control_state = metro_priv->control_state;
288 	spin_unlock_irqrestore(&metro_priv->lock, flags);
289 
290 	return control_state;
291 }
292 
metrousb_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)293 static int metrousb_tiocmset(struct tty_struct *tty,
294 			     unsigned int set, unsigned int clear)
295 {
296 	struct usb_serial_port *port = tty->driver_data;
297 	struct usb_serial *serial = port->serial;
298 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
299 	unsigned long flags;
300 	unsigned long control_state = 0;
301 
302 	dev_dbg(&port->dev, "%s - set=%d, clear=%d\n", __func__, set, clear);
303 
304 	spin_lock_irqsave(&metro_priv->lock, flags);
305 	control_state = metro_priv->control_state;
306 
307 	/* Set the RTS and DTR values. */
308 	if (set & TIOCM_RTS)
309 		control_state |= TIOCM_RTS;
310 	if (set & TIOCM_DTR)
311 		control_state |= TIOCM_DTR;
312 	if (clear & TIOCM_RTS)
313 		control_state &= ~TIOCM_RTS;
314 	if (clear & TIOCM_DTR)
315 		control_state &= ~TIOCM_DTR;
316 
317 	metro_priv->control_state = control_state;
318 	spin_unlock_irqrestore(&metro_priv->lock, flags);
319 	return metrousb_set_modem_ctrl(serial, control_state);
320 }
321 
metrousb_unthrottle(struct tty_struct * tty)322 static void metrousb_unthrottle(struct tty_struct *tty)
323 {
324 	struct usb_serial_port *port = tty->driver_data;
325 	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
326 	unsigned long flags;
327 	int result = 0;
328 
329 	/* Set the private information for the port to resume reading data. */
330 	spin_lock_irqsave(&metro_priv->lock, flags);
331 	metro_priv->throttled = 0;
332 	spin_unlock_irqrestore(&metro_priv->lock, flags);
333 
334 	/* Submit the urb to read from the port. */
335 	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
336 	if (result)
337 		dev_err(&port->dev,
338 			"failed submitting interrupt in urb error code=%d\n",
339 			result);
340 }
341 
342 static struct usb_serial_driver metrousb_device = {
343 	.driver = {
344 		.owner =	THIS_MODULE,
345 		.name =		"metro-usb",
346 	},
347 	.description		= "Metrologic USB to Serial",
348 	.id_table		= id_table,
349 	.num_interrupt_in	= 1,
350 	.calc_num_ports		= metrousb_calc_num_ports,
351 	.open			= metrousb_open,
352 	.close			= metrousb_cleanup,
353 	.read_int_callback	= metrousb_read_int_callback,
354 	.port_probe		= metrousb_port_probe,
355 	.port_remove		= metrousb_port_remove,
356 	.throttle		= metrousb_throttle,
357 	.unthrottle		= metrousb_unthrottle,
358 	.tiocmget		= metrousb_tiocmget,
359 	.tiocmset		= metrousb_tiocmset,
360 };
361 
362 static struct usb_serial_driver * const serial_drivers[] = {
363 	&metrousb_device,
364 	NULL,
365 };
366 
367 module_usb_serial_driver(serial_drivers, id_table);
368 
369 MODULE_LICENSE("GPL v2");
370 MODULE_AUTHOR("Philip Nicastro");
371 MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
372 MODULE_DESCRIPTION(DRIVER_DESC);
373