1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Belkin USB Serial Adapter Driver |
4 | * |
5 | * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com) |
6 | * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com) |
7 | * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) |
8 | * |
9 | * This program is largely derived from work by the linux-usb group |
10 | * and associated source files. Please see the usb/serial files for |
11 | * individual credits and copyrights. |
12 | * |
13 | * See Documentation/usb/usb-serial.rst for more information on using this |
14 | * driver |
15 | * |
16 | * TODO: |
17 | * -- Add true modem control line query capability. Currently we track the |
18 | * states reported by the interrupt and the states we request. |
19 | * -- Add support for flush commands |
20 | */ |
21 | |
22 | #include <linux/kernel.h> |
23 | #include <linux/errno.h> |
24 | #include <linux/slab.h> |
25 | #include <linux/tty.h> |
26 | #include <linux/tty_driver.h> |
27 | #include <linux/tty_flip.h> |
28 | #include <linux/module.h> |
29 | #include <linux/spinlock.h> |
30 | #include <linux/uaccess.h> |
31 | #include <linux/usb.h> |
32 | #include <linux/usb/serial.h> |
33 | #include "belkin_sa.h" |
34 | |
35 | #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" |
36 | #define DRIVER_DESC "USB Belkin Serial converter driver" |
37 | |
38 | /* function prototypes for a Belkin USB Serial Adapter F5U103 */ |
39 | static int belkin_sa_port_probe(struct usb_serial_port *port); |
40 | static void belkin_sa_port_remove(struct usb_serial_port *port); |
41 | static int belkin_sa_open(struct tty_struct *tty, |
42 | struct usb_serial_port *port); |
43 | static void belkin_sa_close(struct usb_serial_port *port); |
44 | static void belkin_sa_read_int_callback(struct urb *urb); |
45 | static void belkin_sa_process_read_urb(struct urb *urb); |
46 | static void belkin_sa_set_termios(struct tty_struct *tty, |
47 | struct usb_serial_port *port, |
48 | const struct ktermios *old_termios); |
49 | static int belkin_sa_break_ctl(struct tty_struct *tty, int break_state); |
50 | static int belkin_sa_tiocmget(struct tty_struct *tty); |
51 | static int belkin_sa_tiocmset(struct tty_struct *tty, |
52 | unsigned int set, unsigned int clear); |
53 | |
54 | |
55 | static const struct usb_device_id id_table[] = { |
56 | { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) }, |
57 | { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) }, |
58 | { USB_DEVICE(PERACOM_VID, PERACOM_PID) }, |
59 | { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) }, |
60 | { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) }, |
61 | { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) }, |
62 | { } /* Terminating entry */ |
63 | }; |
64 | MODULE_DEVICE_TABLE(usb, id_table); |
65 | |
66 | /* All of the device info needed for the serial converters */ |
67 | static struct usb_serial_driver belkin_device = { |
68 | .driver = { |
69 | .owner = THIS_MODULE, |
70 | .name = "belkin" , |
71 | }, |
72 | .description = "Belkin / Peracom / GoHubs USB Serial Adapter" , |
73 | .id_table = id_table, |
74 | .num_ports = 1, |
75 | .open = belkin_sa_open, |
76 | .close = belkin_sa_close, |
77 | .read_int_callback = belkin_sa_read_int_callback, |
78 | .process_read_urb = belkin_sa_process_read_urb, |
79 | .set_termios = belkin_sa_set_termios, |
80 | .break_ctl = belkin_sa_break_ctl, |
81 | .tiocmget = belkin_sa_tiocmget, |
82 | .tiocmset = belkin_sa_tiocmset, |
83 | .port_probe = belkin_sa_port_probe, |
84 | .port_remove = belkin_sa_port_remove, |
85 | }; |
86 | |
87 | static struct usb_serial_driver * const serial_drivers[] = { |
88 | &belkin_device, NULL |
89 | }; |
90 | |
91 | struct belkin_sa_private { |
92 | spinlock_t lock; |
93 | unsigned long control_state; |
94 | unsigned char last_lsr; |
95 | unsigned char last_msr; |
96 | int bad_flow_control; |
97 | }; |
98 | |
99 | |
100 | /* |
101 | * *************************************************************************** |
102 | * Belkin USB Serial Adapter F5U103 specific driver functions |
103 | * *************************************************************************** |
104 | */ |
105 | |
106 | #define WDR_TIMEOUT 5000 /* default urb timeout */ |
107 | |
108 | /* assumes that struct usb_serial *serial is available */ |
109 | #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \ |
110 | (c), BELKIN_SA_SET_REQUEST_TYPE, \ |
111 | (v), 0, NULL, 0, WDR_TIMEOUT) |
112 | |
113 | static int belkin_sa_port_probe(struct usb_serial_port *port) |
114 | { |
115 | struct usb_device *dev = port->serial->dev; |
116 | struct belkin_sa_private *priv; |
117 | |
118 | priv = kmalloc(size: sizeof(struct belkin_sa_private), GFP_KERNEL); |
119 | if (!priv) |
120 | return -ENOMEM; |
121 | |
122 | spin_lock_init(&priv->lock); |
123 | priv->control_state = 0; |
124 | priv->last_lsr = 0; |
125 | priv->last_msr = 0; |
126 | /* see comments at top of file */ |
127 | priv->bad_flow_control = |
128 | (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0; |
129 | dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n" , |
130 | le16_to_cpu(dev->descriptor.bcdDevice), |
131 | priv->bad_flow_control); |
132 | |
133 | usb_set_serial_port_data(port, data: priv); |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static void belkin_sa_port_remove(struct usb_serial_port *port) |
139 | { |
140 | struct belkin_sa_private *priv; |
141 | |
142 | priv = usb_get_serial_port_data(port); |
143 | kfree(objp: priv); |
144 | } |
145 | |
146 | static int belkin_sa_open(struct tty_struct *tty, |
147 | struct usb_serial_port *port) |
148 | { |
149 | int retval; |
150 | |
151 | retval = usb_submit_urb(urb: port->interrupt_in_urb, GFP_KERNEL); |
152 | if (retval) { |
153 | dev_err(&port->dev, "usb_submit_urb(read int) failed\n" ); |
154 | return retval; |
155 | } |
156 | |
157 | retval = usb_serial_generic_open(tty, port); |
158 | if (retval) |
159 | usb_kill_urb(urb: port->interrupt_in_urb); |
160 | |
161 | return retval; |
162 | } |
163 | |
164 | static void belkin_sa_close(struct usb_serial_port *port) |
165 | { |
166 | usb_serial_generic_close(port); |
167 | usb_kill_urb(urb: port->interrupt_in_urb); |
168 | } |
169 | |
170 | static void belkin_sa_read_int_callback(struct urb *urb) |
171 | { |
172 | struct usb_serial_port *port = urb->context; |
173 | struct belkin_sa_private *priv; |
174 | unsigned char *data = urb->transfer_buffer; |
175 | int retval; |
176 | int status = urb->status; |
177 | unsigned long flags; |
178 | |
179 | switch (status) { |
180 | case 0: |
181 | /* success */ |
182 | break; |
183 | case -ECONNRESET: |
184 | case -ENOENT: |
185 | case -ESHUTDOWN: |
186 | /* this urb is terminated, clean up */ |
187 | dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n" , |
188 | __func__, status); |
189 | return; |
190 | default: |
191 | dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n" , |
192 | __func__, status); |
193 | goto exit; |
194 | } |
195 | |
196 | usb_serial_debug_data(dev: &port->dev, function: __func__, size: urb->actual_length, data); |
197 | |
198 | /* Handle known interrupt data */ |
199 | /* ignore data[0] and data[1] */ |
200 | |
201 | priv = usb_get_serial_port_data(port); |
202 | spin_lock_irqsave(&priv->lock, flags); |
203 | priv->last_msr = data[BELKIN_SA_MSR_INDEX]; |
204 | |
205 | /* Record Control Line states */ |
206 | if (priv->last_msr & BELKIN_SA_MSR_DSR) |
207 | priv->control_state |= TIOCM_DSR; |
208 | else |
209 | priv->control_state &= ~TIOCM_DSR; |
210 | |
211 | if (priv->last_msr & BELKIN_SA_MSR_CTS) |
212 | priv->control_state |= TIOCM_CTS; |
213 | else |
214 | priv->control_state &= ~TIOCM_CTS; |
215 | |
216 | if (priv->last_msr & BELKIN_SA_MSR_RI) |
217 | priv->control_state |= TIOCM_RI; |
218 | else |
219 | priv->control_state &= ~TIOCM_RI; |
220 | |
221 | if (priv->last_msr & BELKIN_SA_MSR_CD) |
222 | priv->control_state |= TIOCM_CD; |
223 | else |
224 | priv->control_state &= ~TIOCM_CD; |
225 | |
226 | priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; |
227 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
228 | exit: |
229 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
230 | if (retval) |
231 | dev_err(&port->dev, "%s - usb_submit_urb failed with " |
232 | "result %d\n" , __func__, retval); |
233 | } |
234 | |
235 | static void belkin_sa_process_read_urb(struct urb *urb) |
236 | { |
237 | struct usb_serial_port *port = urb->context; |
238 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
239 | unsigned char *data = urb->transfer_buffer; |
240 | unsigned long flags; |
241 | unsigned char status; |
242 | char tty_flag; |
243 | |
244 | /* Update line status */ |
245 | tty_flag = TTY_NORMAL; |
246 | |
247 | spin_lock_irqsave(&priv->lock, flags); |
248 | status = priv->last_lsr; |
249 | priv->last_lsr &= ~BELKIN_SA_LSR_ERR; |
250 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
251 | |
252 | if (!urb->actual_length) |
253 | return; |
254 | |
255 | if (status & BELKIN_SA_LSR_ERR) { |
256 | /* Break takes precedence over parity, which takes precedence |
257 | * over framing errors. */ |
258 | if (status & BELKIN_SA_LSR_BI) |
259 | tty_flag = TTY_BREAK; |
260 | else if (status & BELKIN_SA_LSR_PE) |
261 | tty_flag = TTY_PARITY; |
262 | else if (status & BELKIN_SA_LSR_FE) |
263 | tty_flag = TTY_FRAME; |
264 | dev_dbg(&port->dev, "tty_flag = %d\n" , tty_flag); |
265 | |
266 | /* Overrun is special, not associated with a char. */ |
267 | if (status & BELKIN_SA_LSR_OE) |
268 | tty_insert_flip_char(port: &port->port, ch: 0, TTY_OVERRUN); |
269 | } |
270 | |
271 | tty_insert_flip_string_fixed_flag(port: &port->port, chars: data, flag: tty_flag, |
272 | size: urb->actual_length); |
273 | tty_flip_buffer_push(port: &port->port); |
274 | } |
275 | |
276 | static void belkin_sa_set_termios(struct tty_struct *tty, |
277 | struct usb_serial_port *port, |
278 | const struct ktermios *old_termios) |
279 | { |
280 | struct usb_serial *serial = port->serial; |
281 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
282 | unsigned int iflag; |
283 | unsigned int cflag; |
284 | unsigned int old_iflag = 0; |
285 | unsigned int old_cflag = 0; |
286 | __u16 urb_value = 0; /* Will hold the new flags */ |
287 | unsigned long flags; |
288 | unsigned long control_state; |
289 | int bad_flow_control; |
290 | speed_t baud; |
291 | struct ktermios *termios = &tty->termios; |
292 | |
293 | iflag = termios->c_iflag; |
294 | cflag = termios->c_cflag; |
295 | |
296 | termios->c_cflag &= ~CMSPAR; |
297 | |
298 | /* get a local copy of the current port settings */ |
299 | spin_lock_irqsave(&priv->lock, flags); |
300 | control_state = priv->control_state; |
301 | bad_flow_control = priv->bad_flow_control; |
302 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
303 | |
304 | old_iflag = old_termios->c_iflag; |
305 | old_cflag = old_termios->c_cflag; |
306 | |
307 | /* Set the baud rate */ |
308 | if ((cflag & CBAUD) != (old_cflag & CBAUD)) { |
309 | /* reassert DTR and (maybe) RTS on transition from B0 */ |
310 | if ((old_cflag & CBAUD) == B0) { |
311 | control_state |= (TIOCM_DTR|TIOCM_RTS); |
312 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) |
313 | dev_err(&port->dev, "Set DTR error\n" ); |
314 | /* don't set RTS if using hardware flow control */ |
315 | if (!(old_cflag & CRTSCTS)) |
316 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST |
317 | , 1) < 0) |
318 | dev_err(&port->dev, "Set RTS error\n" ); |
319 | } |
320 | } |
321 | |
322 | baud = tty_get_baud_rate(tty); |
323 | if (baud) { |
324 | urb_value = BELKIN_SA_BAUD(baud); |
325 | /* Clip to maximum speed */ |
326 | if (urb_value == 0) |
327 | urb_value = 1; |
328 | /* Turn it back into a resulting real baud rate */ |
329 | baud = BELKIN_SA_BAUD(urb_value); |
330 | |
331 | /* Report the actual baud rate back to the caller */ |
332 | tty_encode_baud_rate(tty, ibaud: baud, obaud: baud); |
333 | if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) |
334 | dev_err(&port->dev, "Set baudrate error\n" ); |
335 | } else { |
336 | /* Disable flow control */ |
337 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, |
338 | BELKIN_SA_FLOW_NONE) < 0) |
339 | dev_err(&port->dev, "Disable flowcontrol error\n" ); |
340 | /* Drop RTS and DTR */ |
341 | control_state &= ~(TIOCM_DTR | TIOCM_RTS); |
342 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) |
343 | dev_err(&port->dev, "DTR LOW error\n" ); |
344 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) |
345 | dev_err(&port->dev, "RTS LOW error\n" ); |
346 | } |
347 | |
348 | /* set the parity */ |
349 | if ((cflag ^ old_cflag) & (PARENB | PARODD)) { |
350 | if (cflag & PARENB) |
351 | urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD |
352 | : BELKIN_SA_PARITY_EVEN; |
353 | else |
354 | urb_value = BELKIN_SA_PARITY_NONE; |
355 | if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) |
356 | dev_err(&port->dev, "Set parity error\n" ); |
357 | } |
358 | |
359 | /* set the number of data bits */ |
360 | if ((cflag & CSIZE) != (old_cflag & CSIZE)) { |
361 | urb_value = BELKIN_SA_DATA_BITS(tty_get_char_size(cflag)); |
362 | if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) |
363 | dev_err(&port->dev, "Set data bits error\n" ); |
364 | } |
365 | |
366 | /* set the number of stop bits */ |
367 | if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { |
368 | urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) |
369 | : BELKIN_SA_STOP_BITS(1); |
370 | if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, |
371 | urb_value) < 0) |
372 | dev_err(&port->dev, "Set stop bits error\n" ); |
373 | } |
374 | |
375 | /* Set flow control */ |
376 | if (((iflag ^ old_iflag) & (IXOFF | IXON)) || |
377 | ((cflag ^ old_cflag) & CRTSCTS)) { |
378 | urb_value = 0; |
379 | if ((iflag & IXOFF) || (iflag & IXON)) |
380 | urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); |
381 | else |
382 | urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); |
383 | |
384 | if (cflag & CRTSCTS) |
385 | urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); |
386 | else |
387 | urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); |
388 | |
389 | if (bad_flow_control) |
390 | urb_value &= ~(BELKIN_SA_FLOW_IRTS); |
391 | |
392 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) |
393 | dev_err(&port->dev, "Set flow control error\n" ); |
394 | } |
395 | |
396 | /* save off the modified port settings */ |
397 | spin_lock_irqsave(&priv->lock, flags); |
398 | priv->control_state = control_state; |
399 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
400 | } |
401 | |
402 | static int belkin_sa_break_ctl(struct tty_struct *tty, int break_state) |
403 | { |
404 | struct usb_serial_port *port = tty->driver_data; |
405 | struct usb_serial *serial = port->serial; |
406 | int ret; |
407 | |
408 | ret = BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0); |
409 | if (ret < 0) { |
410 | dev_err(&port->dev, "Set break_ctl %d\n" , break_state); |
411 | return ret; |
412 | } |
413 | |
414 | return 0; |
415 | } |
416 | |
417 | static int belkin_sa_tiocmget(struct tty_struct *tty) |
418 | { |
419 | struct usb_serial_port *port = tty->driver_data; |
420 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
421 | unsigned long control_state; |
422 | unsigned long flags; |
423 | |
424 | spin_lock_irqsave(&priv->lock, flags); |
425 | control_state = priv->control_state; |
426 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
427 | |
428 | return control_state; |
429 | } |
430 | |
431 | static int belkin_sa_tiocmset(struct tty_struct *tty, |
432 | unsigned int set, unsigned int clear) |
433 | { |
434 | struct usb_serial_port *port = tty->driver_data; |
435 | struct usb_serial *serial = port->serial; |
436 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
437 | unsigned long control_state; |
438 | unsigned long flags; |
439 | int retval; |
440 | int rts = 0; |
441 | int dtr = 0; |
442 | |
443 | spin_lock_irqsave(&priv->lock, flags); |
444 | control_state = priv->control_state; |
445 | |
446 | if (set & TIOCM_RTS) { |
447 | control_state |= TIOCM_RTS; |
448 | rts = 1; |
449 | } |
450 | if (set & TIOCM_DTR) { |
451 | control_state |= TIOCM_DTR; |
452 | dtr = 1; |
453 | } |
454 | if (clear & TIOCM_RTS) { |
455 | control_state &= ~TIOCM_RTS; |
456 | rts = 0; |
457 | } |
458 | if (clear & TIOCM_DTR) { |
459 | control_state &= ~TIOCM_DTR; |
460 | dtr = 0; |
461 | } |
462 | |
463 | priv->control_state = control_state; |
464 | spin_unlock_irqrestore(lock: &priv->lock, flags); |
465 | |
466 | retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); |
467 | if (retval < 0) { |
468 | dev_err(&port->dev, "Set RTS error %d\n" , retval); |
469 | goto exit; |
470 | } |
471 | |
472 | retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); |
473 | if (retval < 0) { |
474 | dev_err(&port->dev, "Set DTR error %d\n" , retval); |
475 | goto exit; |
476 | } |
477 | exit: |
478 | return retval; |
479 | } |
480 | |
481 | module_usb_serial_driver(serial_drivers, id_table); |
482 | |
483 | MODULE_AUTHOR(DRIVER_AUTHOR); |
484 | MODULE_DESCRIPTION(DRIVER_DESC); |
485 | MODULE_LICENSE("GPL" ); |
486 | |