Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / usb / serial / belkin_sa.c
blob1295e44e3f1ce9382c5c2dc138b230ccca2d9ddd
1 /*
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
17 * driver
19 * TODO:
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 :)
28 * 27-Nov-2001 gkh
29 * compressed all the differnent device entries into 1.
31 * 30-May-2001 gkh
32 * switched from using spinlock to a semaphore, which fixes lots of
33 * problems.
35 * 08-Apr-2001 gb
36 * - Identify version on module load.
38 * 12-Mar-2001 gkh
39 * - Added support for the GoHubs GO-COM232 device which is the same as the
40 * Peracom device.
42 * 06-Nov-2000 gkh
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
46 * can't support.
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"
82 static int debug;
85 * Version Information
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 */
116 MODULE_DEVICE_TABLE(usb, id_table_combined);
118 static struct usb_driver belkin_driver = {
119 .name = "belkin",
120 .probe = usb_serial_probe,
121 .disconnect = usb_serial_disconnect,
122 .id_table = id_table_combined,
123 .no_dynamic_id = 1,
126 /* All of the device info needed for the serial converters */
127 static struct usb_serial_driver belkin_device = {
128 .driver = {
129 .owner = THIS_MODULE,
130 .name = "belkin",
132 .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
133 .usb_driver = &belkin_driver,
134 .id_table = id_table_combined,
135 .num_ports = 1,
136 .open = belkin_sa_open,
137 .close = belkin_sa_close,
138 .read_int_callback = belkin_sa_read_int_callback,
139 /* How we get the status info */
140 .set_termios = belkin_sa_set_termios,
141 .break_ctl = belkin_sa_break_ctl,
142 .tiocmget = belkin_sa_tiocmget,
143 .tiocmset = belkin_sa_tiocmset,
144 .attach = belkin_sa_startup,
145 .release = belkin_sa_release,
149 struct belkin_sa_private {
150 spinlock_t lock;
151 unsigned long control_state;
152 unsigned char last_lsr;
153 unsigned char last_msr;
154 int bad_flow_control;
159 * ***************************************************************************
160 * Belkin USB Serial Adapter F5U103 specific driver functions
161 * ***************************************************************************
164 #define WDR_TIMEOUT 5000 /* default urb timeout */
166 /* assumes that struct usb_serial *serial is available */
167 #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
168 (c), BELKIN_SA_SET_REQUEST_TYPE, \
169 (v), 0, NULL, 0, WDR_TIMEOUT)
171 /* do some startup allocations not currently performed by usb_serial_probe() */
172 static int belkin_sa_startup(struct usb_serial *serial)
174 struct usb_device *dev = serial->dev;
175 struct belkin_sa_private *priv;
177 /* allocate the private data structure */
178 priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
179 if (!priv)
180 return -1; /* error */
181 /* set initial values for control structures */
182 spin_lock_init(&priv->lock);
183 priv->control_state = 0;
184 priv->last_lsr = 0;
185 priv->last_msr = 0;
186 /* see comments at top of file */
187 priv->bad_flow_control =
188 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
189 dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
190 le16_to_cpu(dev->descriptor.bcdDevice),
191 priv->bad_flow_control);
193 init_waitqueue_head(&serial->port[0]->write_wait);
194 usb_set_serial_port_data(serial->port[0], priv);
196 return 0;
200 static void belkin_sa_release(struct usb_serial *serial)
202 struct belkin_sa_private *priv;
203 int i;
205 dbg("%s", __func__);
207 for (i = 0; i < serial->num_ports; ++i) {
208 /* My special items, the standard routines free my urbs */
209 priv = usb_get_serial_port_data(serial->port[i]);
210 kfree(priv);
215 static int belkin_sa_open(struct tty_struct *tty,
216 struct usb_serial_port *port)
218 int retval = 0;
220 dbg("%s port %d", __func__, port->number);
222 /*Start reading from the device*/
223 /* TODO: Look at possibility of submitting multiple URBs to device to
224 * enhance buffering. Win trace shows 16 initial read URBs.
226 port->read_urb->dev = port->serial->dev;
227 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
228 if (retval) {
229 dev_err(&port->dev, "usb_submit_urb(read bulk) failed\n");
230 goto exit;
233 port->interrupt_in_urb->dev = port->serial->dev;
234 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
235 if (retval) {
236 usb_kill_urb(port->read_urb);
237 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
240 exit:
241 return retval;
242 } /* belkin_sa_open */
245 static void belkin_sa_close(struct usb_serial_port *port)
247 dbg("%s port %d", __func__, port->number);
249 /* shutdown our bulk reads and writes */
250 usb_kill_urb(port->write_urb);
251 usb_kill_urb(port->read_urb);
252 usb_kill_urb(port->interrupt_in_urb);
253 } /* belkin_sa_close */
256 static void belkin_sa_read_int_callback(struct urb *urb)
258 struct usb_serial_port *port = urb->context;
259 struct belkin_sa_private *priv;
260 unsigned char *data = urb->transfer_buffer;
261 int retval;
262 int status = urb->status;
263 unsigned long flags;
265 switch (status) {
266 case 0:
267 /* success */
268 break;
269 case -ECONNRESET:
270 case -ENOENT:
271 case -ESHUTDOWN:
272 /* this urb is terminated, clean up */
273 dbg("%s - urb shutting down with status: %d",
274 __func__, status);
275 return;
276 default:
277 dbg("%s - nonzero urb status received: %d",
278 __func__, status);
279 goto exit;
282 usb_serial_debug_data(debug, &port->dev, __func__,
283 urb->actual_length, data);
285 /* Handle known interrupt data */
286 /* ignore data[0] and data[1] */
288 priv = usb_get_serial_port_data(port);
289 spin_lock_irqsave(&priv->lock, flags);
290 priv->last_msr = data[BELKIN_SA_MSR_INDEX];
292 /* Record Control Line states */
293 if (priv->last_msr & BELKIN_SA_MSR_DSR)
294 priv->control_state |= TIOCM_DSR;
295 else
296 priv->control_state &= ~TIOCM_DSR;
298 if (priv->last_msr & BELKIN_SA_MSR_CTS)
299 priv->control_state |= TIOCM_CTS;
300 else
301 priv->control_state &= ~TIOCM_CTS;
303 if (priv->last_msr & BELKIN_SA_MSR_RI)
304 priv->control_state |= TIOCM_RI;
305 else
306 priv->control_state &= ~TIOCM_RI;
308 if (priv->last_msr & BELKIN_SA_MSR_CD)
309 priv->control_state |= TIOCM_CD;
310 else
311 priv->control_state &= ~TIOCM_CD;
313 /* Now to report any errors */
314 priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
315 #if 0
317 * fill in the flip buffer here, but I do not know the relation
318 * to the current/next receive buffer or characters. I need
319 * to look in to this before committing any code.
321 if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
322 tty = tty_port_tty_get(&port->port);
323 /* Overrun Error */
324 if (priv->last_lsr & BELKIN_SA_LSR_OE) {
326 /* Parity Error */
327 if (priv->last_lsr & BELKIN_SA_LSR_PE) {
329 /* Framing Error */
330 if (priv->last_lsr & BELKIN_SA_LSR_FE) {
332 /* Break Indicator */
333 if (priv->last_lsr & BELKIN_SA_LSR_BI) {
335 tty_kref_put(tty);
337 #endif
338 spin_unlock_irqrestore(&priv->lock, flags);
339 exit:
340 retval = usb_submit_urb(urb, GFP_ATOMIC);
341 if (retval)
342 dev_err(&port->dev, "%s - usb_submit_urb failed with "
343 "result %d\n", __func__, retval);
346 static void belkin_sa_set_termios(struct tty_struct *tty,
347 struct usb_serial_port *port, struct ktermios *old_termios)
349 struct usb_serial *serial = port->serial;
350 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
351 unsigned int iflag;
352 unsigned int cflag;
353 unsigned int old_iflag = 0;
354 unsigned int old_cflag = 0;
355 __u16 urb_value = 0; /* Will hold the new flags */
356 unsigned long flags;
357 unsigned long control_state;
358 int bad_flow_control;
359 speed_t baud;
360 struct ktermios *termios = tty->termios;
362 iflag = termios->c_iflag;
363 cflag = termios->c_cflag;
365 termios->c_cflag &= ~CMSPAR;
367 /* get a local copy of the current port settings */
368 spin_lock_irqsave(&priv->lock, flags);
369 control_state = priv->control_state;
370 bad_flow_control = priv->bad_flow_control;
371 spin_unlock_irqrestore(&priv->lock, flags);
373 old_iflag = old_termios->c_iflag;
374 old_cflag = old_termios->c_cflag;
376 /* Set the baud rate */
377 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
378 /* reassert DTR and (maybe) RTS on transition from B0 */
379 if ((old_cflag & CBAUD) == B0) {
380 control_state |= (TIOCM_DTR|TIOCM_RTS);
381 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
382 dev_err(&port->dev, "Set DTR error\n");
383 /* don't set RTS if using hardware flow control */
384 if (!(old_cflag & CRTSCTS))
385 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
386 , 1) < 0)
387 dev_err(&port->dev, "Set RTS error\n");
391 baud = tty_get_baud_rate(tty);
392 if (baud) {
393 urb_value = BELKIN_SA_BAUD(baud);
394 /* Clip to maximum speed */
395 if (urb_value == 0)
396 urb_value = 1;
397 /* Turn it back into a resulting real baud rate */
398 baud = BELKIN_SA_BAUD(urb_value);
400 /* Report the actual baud rate back to the caller */
401 tty_encode_baud_rate(tty, baud, baud);
402 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
403 dev_err(&port->dev, "Set baudrate error\n");
404 } else {
405 /* Disable flow control */
406 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
407 BELKIN_SA_FLOW_NONE) < 0)
408 dev_err(&port->dev, "Disable flowcontrol error\n");
409 /* Drop RTS and DTR */
410 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
411 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
412 dev_err(&port->dev, "DTR LOW error\n");
413 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
414 dev_err(&port->dev, "RTS LOW error\n");
417 /* set the parity */
418 if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
419 if (cflag & PARENB)
420 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD
421 : BELKIN_SA_PARITY_EVEN;
422 else
423 urb_value = BELKIN_SA_PARITY_NONE;
424 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
425 dev_err(&port->dev, "Set parity error\n");
428 /* set the number of data bits */
429 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
430 switch (cflag & CSIZE) {
431 case CS5:
432 urb_value = BELKIN_SA_DATA_BITS(5);
433 break;
434 case CS6:
435 urb_value = BELKIN_SA_DATA_BITS(6);
436 break;
437 case CS7:
438 urb_value = BELKIN_SA_DATA_BITS(7);
439 break;
440 case CS8:
441 urb_value = BELKIN_SA_DATA_BITS(8);
442 break;
443 default: dbg("CSIZE was not CS5-CS8, using default of 8");
444 urb_value = BELKIN_SA_DATA_BITS(8);
445 break;
447 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
448 dev_err(&port->dev, "Set data bits error\n");
451 /* set the number of stop bits */
452 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
453 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
454 : BELKIN_SA_STOP_BITS(1);
455 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
456 urb_value) < 0)
457 dev_err(&port->dev, "Set stop bits error\n");
460 /* Set flow control */
461 if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
462 ((cflag ^ old_cflag) & CRTSCTS)) {
463 urb_value = 0;
464 if ((iflag & IXOFF) || (iflag & IXON))
465 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
466 else
467 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
469 if (cflag & CRTSCTS)
470 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
471 else
472 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
474 if (bad_flow_control)
475 urb_value &= ~(BELKIN_SA_FLOW_IRTS);
477 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
478 dev_err(&port->dev, "Set flow control error\n");
481 /* save off the modified port settings */
482 spin_lock_irqsave(&priv->lock, flags);
483 priv->control_state = control_state;
484 spin_unlock_irqrestore(&priv->lock, flags);
485 } /* belkin_sa_set_termios */
488 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
490 struct usb_serial_port *port = tty->driver_data;
491 struct usb_serial *serial = port->serial;
493 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
494 dev_err(&port->dev, "Set break_ctl %d\n", break_state);
498 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
500 struct usb_serial_port *port = tty->driver_data;
501 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
502 unsigned long control_state;
503 unsigned long flags;
505 dbg("%s", __func__);
507 spin_lock_irqsave(&priv->lock, flags);
508 control_state = priv->control_state;
509 spin_unlock_irqrestore(&priv->lock, flags);
511 return control_state;
515 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
516 unsigned int set, unsigned int clear)
518 struct usb_serial_port *port = tty->driver_data;
519 struct usb_serial *serial = port->serial;
520 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
521 unsigned long control_state;
522 unsigned long flags;
523 int retval;
524 int rts = 0;
525 int dtr = 0;
527 dbg("%s", __func__);
529 spin_lock_irqsave(&priv->lock, flags);
530 control_state = priv->control_state;
532 if (set & TIOCM_RTS) {
533 control_state |= TIOCM_RTS;
534 rts = 1;
536 if (set & TIOCM_DTR) {
537 control_state |= TIOCM_DTR;
538 dtr = 1;
540 if (clear & TIOCM_RTS) {
541 control_state &= ~TIOCM_RTS;
542 rts = 0;
544 if (clear & TIOCM_DTR) {
545 control_state &= ~TIOCM_DTR;
546 dtr = 0;
549 priv->control_state = control_state;
550 spin_unlock_irqrestore(&priv->lock, flags);
552 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
553 if (retval < 0) {
554 dev_err(&port->dev, "Set RTS error %d\n", retval);
555 goto exit;
558 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
559 if (retval < 0) {
560 dev_err(&port->dev, "Set DTR error %d\n", retval);
561 goto exit;
563 exit:
564 return retval;
568 static int __init belkin_sa_init(void)
570 int retval;
571 retval = usb_serial_register(&belkin_device);
572 if (retval)
573 goto failed_usb_serial_register;
574 retval = usb_register(&belkin_driver);
575 if (retval)
576 goto failed_usb_register;
577 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
578 DRIVER_DESC "\n");
579 return 0;
580 failed_usb_register:
581 usb_serial_deregister(&belkin_device);
582 failed_usb_serial_register:
583 return retval;
587 static void __exit belkin_sa_exit (void)
589 usb_deregister(&belkin_driver);
590 usb_serial_deregister(&belkin_device);
594 module_init(belkin_sa_init);
595 module_exit(belkin_sa_exit);
597 MODULE_AUTHOR(DRIVER_AUTHOR);
598 MODULE_DESCRIPTION(DRIVER_DESC);
599 MODULE_VERSION(DRIVER_VERSION);
600 MODULE_LICENSE("GPL");
602 module_param(debug, bool, S_IRUGO | S_IWUSR);
603 MODULE_PARM_DESC(debug, "Debug enabled or not");