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)
7 * This program is largely derived from work by the linux-usb group
8 * and associated source files. Please see the usb/serial files for
9 * individual credits and copyrights.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * See Documentation/usb/usb-serial.txt for more information on using this
20 * -- Add true modem contol line query capability. Currently we track the
21 * states reported by the interrupt and the states we request.
22 * -- Add error reporting back to application for UART error conditions.
23 * Just point me at how to implement this and I'll do it. I've put the
24 * framework in, but haven't analyzed the "tty_flip" interface yet.
25 * -- Add support for flush commands
26 * -- Add everything that is missing :)
29 * compressed all the differnent device entries into 1.
32 * switched from using spinlock to a semaphore, which fixes lots of
36 * - Identify version on module load.
39 * - Added support for the GoHubs GO-COM232 device which is the same as the
43 * - Added support for the old Belkin and Peracom devices.
44 * - Made the port able to be opened multiple times.
45 * - Added some defaults incase the line settings are things these devices
48 * 18-Oct-2000 William Greathouse
49 * Released into the wild (linux-usb-devel)
51 * 17-Oct-2000 William Greathouse
52 * Add code to recognize firmware version and set hardware flow control
53 * appropriately. Belkin states that firmware prior to 3.05 does not
54 * operate correctly in hardware handshake mode. I have verified this
55 * on firmware 2.05 -- for both RTS and DTR input flow control, the control
56 * line is not reset. The test performed by the Belkin Win* driver is
57 * to enable hardware flow control for firmware 2.06 or greater and
58 * for 1.00 or prior. I am only enabling for 2.06 or greater.
60 * 12-Oct-2000 William Greathouse
61 * First cut at supporting Belkin USB Serial Adapter F5U103
62 * I did not have a copy of the original work to support this
63 * adapter, so pardon any stupid mistakes. All of the information
64 * I am using to write this driver was acquired by using a modified
65 * UsbSnoop on Windows2000 and from examining the other USB drivers.
68 #include <linux/kernel.h>
69 #include <linux/errno.h>
70 #include <linux/init.h>
71 #include <linux/slab.h>
72 #include <linux/tty.h>
73 #include <linux/tty_driver.h>
74 #include <linux/tty_flip.h>
75 #include <linux/module.h>
76 #include <linux/spinlock.h>
77 #include <linux/uaccess.h>
78 #include <linux/usb.h>
79 #include <linux/usb/serial.h>
80 #include "belkin_sa.h"
87 #define DRIVER_VERSION "v1.2"
88 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
89 #define DRIVER_DESC "USB Belkin Serial converter driver"
91 /* function prototypes for a Belkin USB Serial Adapter F5U103 */
92 static int belkin_sa_startup(struct usb_serial *serial);
93 static void belkin_sa_release(struct usb_serial *serial);
94 static int belkin_sa_open(struct tty_struct *tty,
95 struct usb_serial_port *port);
96 static void belkin_sa_close(struct usb_serial_port *port);
97 static void belkin_sa_read_int_callback(struct urb *urb);
98 static void belkin_sa_set_termios(struct tty_struct *tty,
99 struct usb_serial_port *port, struct ktermios * old);
100 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
101 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file);
102 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
103 unsigned int set, unsigned int clear);
106 static const struct usb_device_id id_table_combined[] = {
107 { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
108 { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
109 { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
110 { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
111 { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
112 { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
113 { } /* Terminating entry */
115 MODULE_DEVICE_TABLE(usb, id_table_combined);
117 static struct usb_driver belkin_driver = {
119 .probe = usb_serial_probe,
120 .disconnect = usb_serial_disconnect,
121 .id_table = id_table_combined,
125 /* All of the device info needed for the serial converters */
126 static struct usb_serial_driver belkin_device = {
128 .owner = THIS_MODULE,
131 .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
132 .usb_driver = &belkin_driver,
133 .id_table = id_table_combined,
135 .open = belkin_sa_open,
136 .close = belkin_sa_close,
137 .read_int_callback = belkin_sa_read_int_callback,
138 /* How we get the status info */
139 .set_termios = belkin_sa_set_termios,
140 .break_ctl = belkin_sa_break_ctl,
141 .tiocmget = belkin_sa_tiocmget,
142 .tiocmset = belkin_sa_tiocmset,
143 .attach = belkin_sa_startup,
144 .release = belkin_sa_release,
147 struct belkin_sa_private {
149 unsigned long control_state;
150 unsigned char last_lsr;
151 unsigned char last_msr;
152 int bad_flow_control;
157 * ***************************************************************************
158 * Belkin USB Serial Adapter F5U103 specific driver functions
159 * ***************************************************************************
162 #define WDR_TIMEOUT 5000 /* default urb timeout */
164 /* assumes that struct usb_serial *serial is available */
165 #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
166 (c), BELKIN_SA_SET_REQUEST_TYPE, \
167 (v), 0, NULL, 0, WDR_TIMEOUT)
169 /* do some startup allocations not currently performed by usb_serial_probe() */
170 static int belkin_sa_startup(struct usb_serial *serial)
172 struct usb_device *dev = serial->dev;
173 struct belkin_sa_private *priv;
175 /* allocate the private data structure */
176 priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
178 return -1; /* error */
179 /* set initial values for control structures */
180 spin_lock_init(&priv->lock);
181 priv->control_state = 0;
184 /* see comments at top of file */
185 priv->bad_flow_control =
186 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
187 dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
188 le16_to_cpu(dev->descriptor.bcdDevice),
189 priv->bad_flow_control);
191 init_waitqueue_head(&serial->port[0]->write_wait);
192 usb_set_serial_port_data(serial->port[0], priv);
197 static void belkin_sa_release(struct usb_serial *serial)
203 for (i = 0; i < serial->num_ports; ++i)
204 kfree(usb_get_serial_port_data(serial->port[i]));
207 static int belkin_sa_open(struct tty_struct *tty,
208 struct usb_serial_port *port)
212 dbg("%s port %d", __func__, port->number);
214 /*Start reading from the device*/
215 /* TODO: Look at possibility of submitting multiple URBs to device to
216 * enhance buffering. Win trace shows 16 initial read URBs.
218 port->read_urb->dev = port->serial->dev;
219 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
221 dev_err(&port->dev, "usb_submit_urb(read bulk) failed\n");
225 port->interrupt_in_urb->dev = port->serial->dev;
226 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
228 usb_kill_urb(port->read_urb);
229 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
236 static void belkin_sa_close(struct usb_serial_port *port)
238 dbg("%s port %d", __func__, port->number);
240 usb_serial_generic_close(port);
241 usb_kill_urb(port->interrupt_in_urb);
244 static void belkin_sa_read_int_callback(struct urb *urb)
246 struct usb_serial_port *port = urb->context;
247 struct belkin_sa_private *priv;
248 unsigned char *data = urb->transfer_buffer;
250 int status = urb->status;
260 /* this urb is terminated, clean up */
261 dbg("%s - urb shutting down with status: %d",
265 dbg("%s - nonzero urb status received: %d",
270 usb_serial_debug_data(debug, &port->dev, __func__,
271 urb->actual_length, data);
273 /* Handle known interrupt data */
274 /* ignore data[0] and data[1] */
276 priv = usb_get_serial_port_data(port);
277 spin_lock_irqsave(&priv->lock, flags);
278 priv->last_msr = data[BELKIN_SA_MSR_INDEX];
280 /* Record Control Line states */
281 if (priv->last_msr & BELKIN_SA_MSR_DSR)
282 priv->control_state |= TIOCM_DSR;
284 priv->control_state &= ~TIOCM_DSR;
286 if (priv->last_msr & BELKIN_SA_MSR_CTS)
287 priv->control_state |= TIOCM_CTS;
289 priv->control_state &= ~TIOCM_CTS;
291 if (priv->last_msr & BELKIN_SA_MSR_RI)
292 priv->control_state |= TIOCM_RI;
294 priv->control_state &= ~TIOCM_RI;
296 if (priv->last_msr & BELKIN_SA_MSR_CD)
297 priv->control_state |= TIOCM_CD;
299 priv->control_state &= ~TIOCM_CD;
301 /* Now to report any errors */
302 priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
305 * fill in the flip buffer here, but I do not know the relation
306 * to the current/next receive buffer or characters. I need
307 * to look in to this before committing any code.
309 if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
310 tty = tty_port_tty_get(&port->port);
312 if (priv->last_lsr & BELKIN_SA_LSR_OE) {
315 if (priv->last_lsr & BELKIN_SA_LSR_PE) {
318 if (priv->last_lsr & BELKIN_SA_LSR_FE) {
320 /* Break Indicator */
321 if (priv->last_lsr & BELKIN_SA_LSR_BI) {
326 spin_unlock_irqrestore(&priv->lock, flags);
328 retval = usb_submit_urb(urb, GFP_ATOMIC);
330 dev_err(&port->dev, "%s - usb_submit_urb failed with "
331 "result %d\n", __func__, retval);
334 static void belkin_sa_set_termios(struct tty_struct *tty,
335 struct usb_serial_port *port, struct ktermios *old_termios)
337 struct usb_serial *serial = port->serial;
338 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
341 unsigned int old_iflag = 0;
342 unsigned int old_cflag = 0;
343 __u16 urb_value = 0; /* Will hold the new flags */
345 unsigned long control_state;
346 int bad_flow_control;
348 struct ktermios *termios = tty->termios;
350 iflag = termios->c_iflag;
351 cflag = termios->c_cflag;
353 termios->c_cflag &= ~CMSPAR;
355 /* get a local copy of the current port settings */
356 spin_lock_irqsave(&priv->lock, flags);
357 control_state = priv->control_state;
358 bad_flow_control = priv->bad_flow_control;
359 spin_unlock_irqrestore(&priv->lock, flags);
361 old_iflag = old_termios->c_iflag;
362 old_cflag = old_termios->c_cflag;
364 /* Set the baud rate */
365 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
366 /* reassert DTR and (maybe) RTS on transition from B0 */
367 if ((old_cflag & CBAUD) == B0) {
368 control_state |= (TIOCM_DTR|TIOCM_RTS);
369 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
370 dev_err(&port->dev, "Set DTR error\n");
371 /* don't set RTS if using hardware flow control */
372 if (!(old_cflag & CRTSCTS))
373 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
375 dev_err(&port->dev, "Set RTS error\n");
379 baud = tty_get_baud_rate(tty);
381 urb_value = BELKIN_SA_BAUD(baud);
382 /* Clip to maximum speed */
385 /* Turn it back into a resulting real baud rate */
386 baud = BELKIN_SA_BAUD(urb_value);
388 /* Report the actual baud rate back to the caller */
389 tty_encode_baud_rate(tty, baud, baud);
390 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
391 dev_err(&port->dev, "Set baudrate error\n");
393 /* Disable flow control */
394 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
395 BELKIN_SA_FLOW_NONE) < 0)
396 dev_err(&port->dev, "Disable flowcontrol error\n");
397 /* Drop RTS and DTR */
398 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
399 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
400 dev_err(&port->dev, "DTR LOW error\n");
401 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
402 dev_err(&port->dev, "RTS LOW error\n");
406 if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
408 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD
409 : BELKIN_SA_PARITY_EVEN;
411 urb_value = BELKIN_SA_PARITY_NONE;
412 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
413 dev_err(&port->dev, "Set parity error\n");
416 /* set the number of data bits */
417 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
418 switch (cflag & CSIZE) {
420 urb_value = BELKIN_SA_DATA_BITS(5);
423 urb_value = BELKIN_SA_DATA_BITS(6);
426 urb_value = BELKIN_SA_DATA_BITS(7);
429 urb_value = BELKIN_SA_DATA_BITS(8);
431 default: dbg("CSIZE was not CS5-CS8, using default of 8");
432 urb_value = BELKIN_SA_DATA_BITS(8);
435 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
436 dev_err(&port->dev, "Set data bits error\n");
439 /* set the number of stop bits */
440 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
441 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
442 : BELKIN_SA_STOP_BITS(1);
443 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
445 dev_err(&port->dev, "Set stop bits error\n");
448 /* Set flow control */
449 if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
450 ((cflag ^ old_cflag) & CRTSCTS)) {
452 if ((iflag & IXOFF) || (iflag & IXON))
453 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
455 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
458 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
460 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
462 if (bad_flow_control)
463 urb_value &= ~(BELKIN_SA_FLOW_IRTS);
465 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
466 dev_err(&port->dev, "Set flow control error\n");
469 /* save off the modified port settings */
470 spin_lock_irqsave(&priv->lock, flags);
471 priv->control_state = control_state;
472 spin_unlock_irqrestore(&priv->lock, flags);
475 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
477 struct usb_serial_port *port = tty->driver_data;
478 struct usb_serial *serial = port->serial;
480 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
481 dev_err(&port->dev, "Set break_ctl %d\n", break_state);
484 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
486 struct usb_serial_port *port = tty->driver_data;
487 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
488 unsigned long control_state;
493 spin_lock_irqsave(&priv->lock, flags);
494 control_state = priv->control_state;
495 spin_unlock_irqrestore(&priv->lock, flags);
497 return control_state;
500 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
501 unsigned int set, unsigned int clear)
503 struct usb_serial_port *port = tty->driver_data;
504 struct usb_serial *serial = port->serial;
505 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
506 unsigned long control_state;
514 spin_lock_irqsave(&priv->lock, flags);
515 control_state = priv->control_state;
517 if (set & TIOCM_RTS) {
518 control_state |= TIOCM_RTS;
521 if (set & TIOCM_DTR) {
522 control_state |= TIOCM_DTR;
525 if (clear & TIOCM_RTS) {
526 control_state &= ~TIOCM_RTS;
529 if (clear & TIOCM_DTR) {
530 control_state &= ~TIOCM_DTR;
534 priv->control_state = control_state;
535 spin_unlock_irqrestore(&priv->lock, flags);
537 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
539 dev_err(&port->dev, "Set RTS error %d\n", retval);
543 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
545 dev_err(&port->dev, "Set DTR error %d\n", retval);
553 static int __init belkin_sa_init(void)
556 retval = usb_serial_register(&belkin_device);
558 goto failed_usb_serial_register;
559 retval = usb_register(&belkin_driver);
561 goto failed_usb_register;
562 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
566 usb_serial_deregister(&belkin_device);
567 failed_usb_serial_register:
571 static void __exit belkin_sa_exit (void)
573 usb_deregister(&belkin_driver);
574 usb_serial_deregister(&belkin_device);
578 module_init(belkin_sa_init);
579 module_exit(belkin_sa_exit);
581 MODULE_AUTHOR(DRIVER_AUTHOR);
582 MODULE_DESCRIPTION(DRIVER_DESC);
583 MODULE_VERSION(DRIVER_VERSION);
584 MODULE_LICENSE("GPL");
586 module_param(debug, bool, S_IRUGO | S_IWUSR);
587 MODULE_PARM_DESC(debug, "Debug enabled or not");