2 * Belkin USB Serial Adapter Driver
4 * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com)
5 * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com)
8 * This program is largely derived from work by the linux-usb group
9 * and associated source files. Please see the usb/serial files for
10 * individual credits and copyrights.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * See Documentation/usb/usb-serial.txt for more information on using this
21 * -- Add true modem contol line query capability. Currently we track the
22 * states reported by the interrupt and the states we request.
23 * -- Add support for flush commands
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/tty.h>
31 #include <linux/tty_driver.h>
32 #include <linux/tty_flip.h>
33 #include <linux/module.h>
34 #include <linux/spinlock.h>
35 #include <linux/uaccess.h>
36 #include <linux/usb.h>
37 #include <linux/usb/serial.h>
38 #include "belkin_sa.h"
45 #define DRIVER_VERSION "v1.3"
46 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
47 #define DRIVER_DESC "USB Belkin Serial converter driver"
49 /* function prototypes for a Belkin USB Serial Adapter F5U103 */
50 static int belkin_sa_startup(struct usb_serial
*serial
);
51 static void belkin_sa_release(struct usb_serial
*serial
);
52 static int belkin_sa_open(struct tty_struct
*tty
,
53 struct usb_serial_port
*port
);
54 static void belkin_sa_close(struct usb_serial_port
*port
);
55 static void belkin_sa_read_int_callback(struct urb
*urb
);
56 static void belkin_sa_process_read_urb(struct urb
*urb
);
57 static void belkin_sa_set_termios(struct tty_struct
*tty
,
58 struct usb_serial_port
*port
, struct ktermios
* old
);
59 static void belkin_sa_break_ctl(struct tty_struct
*tty
, int break_state
);
60 static int belkin_sa_tiocmget(struct tty_struct
*tty
);
61 static int belkin_sa_tiocmset(struct tty_struct
*tty
,
62 unsigned int set
, unsigned int clear
);
65 static const struct usb_device_id id_table
[] = {
66 { USB_DEVICE(BELKIN_SA_VID
, BELKIN_SA_PID
) },
67 { USB_DEVICE(BELKIN_OLD_VID
, BELKIN_OLD_PID
) },
68 { USB_DEVICE(PERACOM_VID
, PERACOM_PID
) },
69 { USB_DEVICE(GOHUBS_VID
, GOHUBS_PID
) },
70 { USB_DEVICE(GOHUBS_VID
, HANDYLINK_PID
) },
71 { USB_DEVICE(BELKIN_DOCKSTATION_VID
, BELKIN_DOCKSTATION_PID
) },
72 { } /* Terminating entry */
74 MODULE_DEVICE_TABLE(usb
, id_table
);
76 /* All of the device info needed for the serial converters */
77 static struct usb_serial_driver belkin_device
= {
82 .description
= "Belkin / Peracom / GoHubs USB Serial Adapter",
85 .open
= belkin_sa_open
,
86 .close
= belkin_sa_close
,
87 .read_int_callback
= belkin_sa_read_int_callback
,
88 .process_read_urb
= belkin_sa_process_read_urb
,
89 .set_termios
= belkin_sa_set_termios
,
90 .break_ctl
= belkin_sa_break_ctl
,
91 .tiocmget
= belkin_sa_tiocmget
,
92 .tiocmset
= belkin_sa_tiocmset
,
93 .attach
= belkin_sa_startup
,
94 .release
= belkin_sa_release
,
97 static struct usb_serial_driver
* const serial_drivers
[] = {
101 struct belkin_sa_private
{
103 unsigned long control_state
;
104 unsigned char last_lsr
;
105 unsigned char last_msr
;
106 int bad_flow_control
;
111 * ***************************************************************************
112 * Belkin USB Serial Adapter F5U103 specific driver functions
113 * ***************************************************************************
116 #define WDR_TIMEOUT 5000 /* default urb timeout */
118 /* assumes that struct usb_serial *serial is available */
119 #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
120 (c), BELKIN_SA_SET_REQUEST_TYPE, \
121 (v), 0, NULL, 0, WDR_TIMEOUT)
123 /* do some startup allocations not currently performed by usb_serial_probe() */
124 static int belkin_sa_startup(struct usb_serial
*serial
)
126 struct usb_device
*dev
= serial
->dev
;
127 struct belkin_sa_private
*priv
;
129 /* allocate the private data structure */
130 priv
= kmalloc(sizeof(struct belkin_sa_private
), GFP_KERNEL
);
132 return -1; /* error */
133 /* set initial values for control structures */
134 spin_lock_init(&priv
->lock
);
135 priv
->control_state
= 0;
138 /* see comments at top of file */
139 priv
->bad_flow_control
=
140 (le16_to_cpu(dev
->descriptor
.bcdDevice
) <= 0x0206) ? 1 : 0;
141 dev_info(&dev
->dev
, "bcdDevice: %04x, bfc: %d\n",
142 le16_to_cpu(dev
->descriptor
.bcdDevice
),
143 priv
->bad_flow_control
);
145 init_waitqueue_head(&serial
->port
[0]->write_wait
);
146 usb_set_serial_port_data(serial
->port
[0], priv
);
151 static void belkin_sa_release(struct usb_serial
*serial
)
155 for (i
= 0; i
< serial
->num_ports
; ++i
)
156 kfree(usb_get_serial_port_data(serial
->port
[i
]));
159 static int belkin_sa_open(struct tty_struct
*tty
,
160 struct usb_serial_port
*port
)
164 retval
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
166 dev_err(&port
->dev
, "usb_submit_urb(read int) failed\n");
170 retval
= usb_serial_generic_open(tty
, port
);
172 usb_kill_urb(port
->interrupt_in_urb
);
177 static void belkin_sa_close(struct usb_serial_port
*port
)
179 usb_serial_generic_close(port
);
180 usb_kill_urb(port
->interrupt_in_urb
);
183 static void belkin_sa_read_int_callback(struct urb
*urb
)
185 struct usb_serial_port
*port
= urb
->context
;
186 struct belkin_sa_private
*priv
;
187 unsigned char *data
= urb
->transfer_buffer
;
189 int status
= urb
->status
;
199 /* this urb is terminated, clean up */
200 dbg("%s - urb shutting down with status: %d",
204 dbg("%s - nonzero urb status received: %d",
209 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
210 urb
->actual_length
, data
);
212 /* Handle known interrupt data */
213 /* ignore data[0] and data[1] */
215 priv
= usb_get_serial_port_data(port
);
216 spin_lock_irqsave(&priv
->lock
, flags
);
217 priv
->last_msr
= data
[BELKIN_SA_MSR_INDEX
];
219 /* Record Control Line states */
220 if (priv
->last_msr
& BELKIN_SA_MSR_DSR
)
221 priv
->control_state
|= TIOCM_DSR
;
223 priv
->control_state
&= ~TIOCM_DSR
;
225 if (priv
->last_msr
& BELKIN_SA_MSR_CTS
)
226 priv
->control_state
|= TIOCM_CTS
;
228 priv
->control_state
&= ~TIOCM_CTS
;
230 if (priv
->last_msr
& BELKIN_SA_MSR_RI
)
231 priv
->control_state
|= TIOCM_RI
;
233 priv
->control_state
&= ~TIOCM_RI
;
235 if (priv
->last_msr
& BELKIN_SA_MSR_CD
)
236 priv
->control_state
|= TIOCM_CD
;
238 priv
->control_state
&= ~TIOCM_CD
;
240 priv
->last_lsr
= data
[BELKIN_SA_LSR_INDEX
];
241 spin_unlock_irqrestore(&priv
->lock
, flags
);
243 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
245 dev_err(&port
->dev
, "%s - usb_submit_urb failed with "
246 "result %d\n", __func__
, retval
);
249 static void belkin_sa_process_read_urb(struct urb
*urb
)
251 struct usb_serial_port
*port
= urb
->context
;
252 struct belkin_sa_private
*priv
= usb_get_serial_port_data(port
);
253 struct tty_struct
*tty
;
254 unsigned char *data
= urb
->transfer_buffer
;
256 unsigned char status
;
259 /* Update line status */
260 tty_flag
= TTY_NORMAL
;
262 spin_lock_irqsave(&priv
->lock
, flags
);
263 status
= priv
->last_lsr
;
264 priv
->last_lsr
&= ~BELKIN_SA_LSR_ERR
;
265 spin_unlock_irqrestore(&priv
->lock
, flags
);
267 if (!urb
->actual_length
)
270 tty
= tty_port_tty_get(&port
->port
);
274 if (status
& BELKIN_SA_LSR_ERR
) {
275 /* Break takes precedence over parity, which takes precedence
276 * over framing errors. */
277 if (status
& BELKIN_SA_LSR_BI
)
278 tty_flag
= TTY_BREAK
;
279 else if (status
& BELKIN_SA_LSR_PE
)
280 tty_flag
= TTY_PARITY
;
281 else if (status
& BELKIN_SA_LSR_FE
)
282 tty_flag
= TTY_FRAME
;
283 dev_dbg(&port
->dev
, "tty_flag = %d\n", tty_flag
);
285 /* Overrun is special, not associated with a char. */
286 if (status
& BELKIN_SA_LSR_OE
)
287 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
290 tty_insert_flip_string_fixed_flag(tty
, data
, tty_flag
,
292 tty_flip_buffer_push(tty
);
296 static void belkin_sa_set_termios(struct tty_struct
*tty
,
297 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
299 struct usb_serial
*serial
= port
->serial
;
300 struct belkin_sa_private
*priv
= usb_get_serial_port_data(port
);
303 unsigned int old_iflag
= 0;
304 unsigned int old_cflag
= 0;
305 __u16 urb_value
= 0; /* Will hold the new flags */
307 unsigned long control_state
;
308 int bad_flow_control
;
310 struct ktermios
*termios
= tty
->termios
;
312 iflag
= termios
->c_iflag
;
313 cflag
= termios
->c_cflag
;
315 termios
->c_cflag
&= ~CMSPAR
;
317 /* get a local copy of the current port settings */
318 spin_lock_irqsave(&priv
->lock
, flags
);
319 control_state
= priv
->control_state
;
320 bad_flow_control
= priv
->bad_flow_control
;
321 spin_unlock_irqrestore(&priv
->lock
, flags
);
323 old_iflag
= old_termios
->c_iflag
;
324 old_cflag
= old_termios
->c_cflag
;
326 /* Set the baud rate */
327 if ((cflag
& CBAUD
) != (old_cflag
& CBAUD
)) {
328 /* reassert DTR and (maybe) RTS on transition from B0 */
329 if ((old_cflag
& CBAUD
) == B0
) {
330 control_state
|= (TIOCM_DTR
|TIOCM_RTS
);
331 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST
, 1) < 0)
332 dev_err(&port
->dev
, "Set DTR error\n");
333 /* don't set RTS if using hardware flow control */
334 if (!(old_cflag
& CRTSCTS
))
335 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
337 dev_err(&port
->dev
, "Set RTS error\n");
341 baud
= tty_get_baud_rate(tty
);
343 urb_value
= BELKIN_SA_BAUD(baud
);
344 /* Clip to maximum speed */
347 /* Turn it back into a resulting real baud rate */
348 baud
= BELKIN_SA_BAUD(urb_value
);
350 /* Report the actual baud rate back to the caller */
351 tty_encode_baud_rate(tty
, baud
, baud
);
352 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST
, urb_value
) < 0)
353 dev_err(&port
->dev
, "Set baudrate error\n");
355 /* Disable flow control */
356 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST
,
357 BELKIN_SA_FLOW_NONE
) < 0)
358 dev_err(&port
->dev
, "Disable flowcontrol error\n");
359 /* Drop RTS and DTR */
360 control_state
&= ~(TIOCM_DTR
| TIOCM_RTS
);
361 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST
, 0) < 0)
362 dev_err(&port
->dev
, "DTR LOW error\n");
363 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
, 0) < 0)
364 dev_err(&port
->dev
, "RTS LOW error\n");
368 if ((cflag
^ old_cflag
) & (PARENB
| PARODD
)) {
370 urb_value
= (cflag
& PARODD
) ? BELKIN_SA_PARITY_ODD
371 : BELKIN_SA_PARITY_EVEN
;
373 urb_value
= BELKIN_SA_PARITY_NONE
;
374 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST
, urb_value
) < 0)
375 dev_err(&port
->dev
, "Set parity error\n");
378 /* set the number of data bits */
379 if ((cflag
& CSIZE
) != (old_cflag
& CSIZE
)) {
380 switch (cflag
& CSIZE
) {
382 urb_value
= BELKIN_SA_DATA_BITS(5);
385 urb_value
= BELKIN_SA_DATA_BITS(6);
388 urb_value
= BELKIN_SA_DATA_BITS(7);
391 urb_value
= BELKIN_SA_DATA_BITS(8);
394 dbg("CSIZE was not CS5-CS8, using default of 8");
395 urb_value
= BELKIN_SA_DATA_BITS(8);
398 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST
, urb_value
) < 0)
399 dev_err(&port
->dev
, "Set data bits error\n");
402 /* set the number of stop bits */
403 if ((cflag
& CSTOPB
) != (old_cflag
& CSTOPB
)) {
404 urb_value
= (cflag
& CSTOPB
) ? BELKIN_SA_STOP_BITS(2)
405 : BELKIN_SA_STOP_BITS(1);
406 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST
,
408 dev_err(&port
->dev
, "Set stop bits error\n");
411 /* Set flow control */
412 if (((iflag
^ old_iflag
) & (IXOFF
| IXON
)) ||
413 ((cflag
^ old_cflag
) & CRTSCTS
)) {
415 if ((iflag
& IXOFF
) || (iflag
& IXON
))
416 urb_value
|= (BELKIN_SA_FLOW_OXON
| BELKIN_SA_FLOW_IXON
);
418 urb_value
&= ~(BELKIN_SA_FLOW_OXON
| BELKIN_SA_FLOW_IXON
);
421 urb_value
|= (BELKIN_SA_FLOW_OCTS
| BELKIN_SA_FLOW_IRTS
);
423 urb_value
&= ~(BELKIN_SA_FLOW_OCTS
| BELKIN_SA_FLOW_IRTS
);
425 if (bad_flow_control
)
426 urb_value
&= ~(BELKIN_SA_FLOW_IRTS
);
428 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST
, urb_value
) < 0)
429 dev_err(&port
->dev
, "Set flow control error\n");
432 /* save off the modified port settings */
433 spin_lock_irqsave(&priv
->lock
, flags
);
434 priv
->control_state
= control_state
;
435 spin_unlock_irqrestore(&priv
->lock
, flags
);
438 static void belkin_sa_break_ctl(struct tty_struct
*tty
, int break_state
)
440 struct usb_serial_port
*port
= tty
->driver_data
;
441 struct usb_serial
*serial
= port
->serial
;
443 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST
, break_state
? 1 : 0) < 0)
444 dev_err(&port
->dev
, "Set break_ctl %d\n", break_state
);
447 static int belkin_sa_tiocmget(struct tty_struct
*tty
)
449 struct usb_serial_port
*port
= tty
->driver_data
;
450 struct belkin_sa_private
*priv
= usb_get_serial_port_data(port
);
451 unsigned long control_state
;
454 spin_lock_irqsave(&priv
->lock
, flags
);
455 control_state
= priv
->control_state
;
456 spin_unlock_irqrestore(&priv
->lock
, flags
);
458 return control_state
;
461 static int belkin_sa_tiocmset(struct tty_struct
*tty
,
462 unsigned int set
, unsigned int clear
)
464 struct usb_serial_port
*port
= tty
->driver_data
;
465 struct usb_serial
*serial
= port
->serial
;
466 struct belkin_sa_private
*priv
= usb_get_serial_port_data(port
);
467 unsigned long control_state
;
473 spin_lock_irqsave(&priv
->lock
, flags
);
474 control_state
= priv
->control_state
;
476 if (set
& TIOCM_RTS
) {
477 control_state
|= TIOCM_RTS
;
480 if (set
& TIOCM_DTR
) {
481 control_state
|= TIOCM_DTR
;
484 if (clear
& TIOCM_RTS
) {
485 control_state
&= ~TIOCM_RTS
;
488 if (clear
& TIOCM_DTR
) {
489 control_state
&= ~TIOCM_DTR
;
493 priv
->control_state
= control_state
;
494 spin_unlock_irqrestore(&priv
->lock
, flags
);
496 retval
= BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
, rts
);
498 dev_err(&port
->dev
, "Set RTS error %d\n", retval
);
502 retval
= BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST
, dtr
);
504 dev_err(&port
->dev
, "Set DTR error %d\n", retval
);
511 module_usb_serial_driver(serial_drivers
, id_table
);
513 MODULE_AUTHOR(DRIVER_AUTHOR
);
514 MODULE_DESCRIPTION(DRIVER_DESC
);
515 MODULE_VERSION(DRIVER_VERSION
);
516 MODULE_LICENSE("GPL");
518 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
519 MODULE_PARM_DESC(debug
, "Debug enabled or not");