1 /*
2 * Belkin USB Serial Adapter Driver
3 *
4 * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com)
5 * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com)
6 *
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.
10 *
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.
15 *
16 * See Documentation/usb/usb-serial.txt for more information on using this driver
17 *
18 * TODO:
19 * -- Add true modem contol line query capability. Currently we track the
20 * states reported by the interrupt and the states we request.
21 * -- Add error reporting back to application for UART error conditions.
22 * Just point me at how to implement this and I'll do it. I've put the
23 * framework in, but haven't analyzed the "tty_flip" interface yet.
24 * -- Add support for flush commands
25 * -- Add everything that is missing :)
26 *
27 * 27-Nov-2001 gkh
28 * compressed all the differnent device entries into 1.
29 *
30 * 30-May-2001 gkh
31 * switched from using spinlock to a semaphore, which fixes lots of problems.
32 *
33 * 08-Apr-2001 gb
34 * - Identify version on module load.
35 *
36 * 12-Mar-2001 gkh
37 * - Added support for the GoHubs GO-COM232 device which is the same as the
38 * Peracom device.
39 *
40 * 06-Nov-2000 gkh
41 * - Added support for the old Belkin and Peracom devices.
42 * - Made the port able to be opened multiple times.
43 * - Added some defaults incase the line settings are things these devices
44 * can't support.
45 *
46 * 18-Oct-2000 William Greathouse
47 * Released into the wild (linux-usb-devel)
48 *
49 * 17-Oct-2000 William Greathouse
50 * Add code to recognize firmware version and set hardware flow control
51 * appropriately. Belkin states that firmware prior to 3.05 does not
52 * operate correctly in hardware handshake mode. I have verified this
53 * on firmware 2.05 -- for both RTS and DTR input flow control, the control
54 * line is not reset. The test performed by the Belkin Win* driver is
55 * to enable hardware flow control for firmware 2.06 or greater and
56 * for 1.00 or prior. I am only enabling for 2.06 or greater.
57 *
58 * 12-Oct-2000 William Greathouse
59 * First cut at supporting Belkin USB Serial Adapter F5U103
60 * I did not have a copy of the original work to support this
61 * adapter, so pardon any stupid mistakes. All of the information
62 * I am using to write this driver was acquired by using a modified
63 * UsbSnoop on Windows2000 and from examining the other USB drivers.
64 */
65
66 #include <linux/kernel.h>
67 #include <linux/errno.h>
68 #include <linux/init.h>
69 #include <linux/slab.h>
70 #include <linux/tty.h>
71 #include <linux/tty_driver.h>
72 #include <linux/tty_flip.h>
73 #include <linux/module.h>
74 #include <linux/spinlock.h>
75 #include <asm/uaccess.h>
76 #include <linux/usb.h>
77 #include <linux/usb/serial.h>
78 #include "belkin_sa.h"
79
80 static int debug;
81
82 /*
83 * Version Information
84 */
85 #define DRIVER_VERSION "v1.2"
86 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
87 #define DRIVER_DESC "USB Belkin Serial converter driver"
88
89 /* function prototypes for a Belkin USB Serial Adapter F5U103 */
90 static int belkin_sa_startup (struct usb_serial *serial);
91 static void belkin_sa_shutdown (struct usb_serial *serial);
92 static int belkin_sa_open (struct usb_serial_port *port, struct file *filp);
93 static void belkin_sa_close (struct usb_serial_port *port, struct file *filp);
94 static void belkin_sa_read_int_callback (struct urb *urb);
95 static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios * old);
96 static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
97 static void belkin_sa_break_ctl (struct usb_serial_port *port, int break_state );
98 static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file);
99 static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
100
101
102 static struct usb_device_id id_table_combined [] = {
103 { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
104 { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
105 { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
106 { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
107 { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
108 { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
109 { } /* Terminating entry */
110 };
111
112 MODULE_DEVICE_TABLE (usb, id_table_combined);
113
114 static struct usb_driver belkin_driver = {
115 .name = "belkin",
116 .probe = usb_serial_probe,
117 .disconnect = usb_serial_disconnect,
118 .id_table = id_table_combined,
119 .no_dynamic_id = 1,
120 };
121
122 /* All of the device info needed for the serial converters */
123 static struct usb_serial_driver belkin_device = {
124 .driver = {
125 .owner = THIS_MODULE,
126 .name = "belkin",
127 },
128 .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
129 .usb_driver = &belkin_driver,
130 .id_table = id_table_combined,
131 .num_interrupt_in = 1,
132 .num_bulk_in = 1,
133 .num_bulk_out = 1,
134 .num_ports = 1,
135 .open = belkin_sa_open,
136 .close = belkin_sa_close,
137 .read_int_callback = belkin_sa_read_int_callback, /* How we get the status info */
138 .ioctl = belkin_sa_ioctl,
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 .shutdown = belkin_sa_shutdown,
145 };
146
147
148 struct belkin_sa_private {
149 spinlock_t lock;
150 unsigned long control_state;
151 unsigned char last_lsr;
152 unsigned char last_msr;
153 int bad_flow_control;
154 };
155
156
157 /*
158 * ***************************************************************************
159 * Belkin USB Serial Adapter F5U103 specific driver functions
160 * ***************************************************************************
161 */
162
163 #define WDR_TIMEOUT 5000 /* default urb timeout */
164
165 /* assumes that struct usb_serial *serial is available */
166 #define BSA_USB_CMD(c,v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
167 (c), BELKIN_SA_SET_REQUEST_TYPE, \
168 (v), 0, NULL, 0, WDR_TIMEOUT)
169
170 /* do some startup allocations not currently performed by usb_serial_probe() */
171 static int belkin_sa_startup (struct usb_serial *serial)
172 {
173 struct usb_device *dev = serial->dev;
174 struct belkin_sa_private *priv;
175
176 /* allocate the private data structure */
177 priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
178 if (!priv)
179 return (-1); /* error */
180 /* set initial values for control structures */
181 spin_lock_init(&priv->lock);
182 priv->control_state = 0;
183 priv->last_lsr = 0;
184 priv->last_msr = 0;
185 /* see comments at top of file */
186 priv->bad_flow_control = (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
187 info("bcdDevice: %04x, bfc: %d", le16_to_cpu(dev->descriptor.bcdDevice), priv->bad_flow_control);
188
189 init_waitqueue_head(&serial->port[0]->write_wait);
190 usb_set_serial_port_data(serial->port[0], priv);
191
192 return (0);
193 }
194
195
196 static void belkin_sa_shutdown (struct usb_serial *serial)
197 {
198 struct belkin_sa_private *priv;
199 int i;
200
201 dbg ("%s", __FUNCTION__);
202
203 /* stop reads and writes on all ports */
204 for (i=0; i < serial->num_ports; ++i) {
205 /* My special items, the standard routines free my urbs */
206 priv = usb_get_serial_port_data(serial->port[i]);
207 kfree(priv);
208 }
209 }
210
211
212 static int belkin_sa_open (struct usb_serial_port *port, struct file *filp)
213 {
214 int retval = 0;
215
216 dbg("%s port %d", __FUNCTION__, port->number);
217
218 /*Start reading from the device*/
219 /* TODO: Look at possibility of submitting multiple URBs to device to
220 * enhance buffering. Win trace shows 16 initial read URBs.
221 */
222 port->read_urb->dev = port->serial->dev;
223 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
224 if (retval) {
225 err("usb_submit_urb(read bulk) failed");
226 goto exit;
227 }
228
229 port->interrupt_in_urb->dev = port->serial->dev;
230 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
231 if (retval) {
232 usb_kill_urb(port->read_urb);
233 err(" usb_submit_urb(read int) failed");
234 }
235
236 exit:
237 return retval;
238 } /* belkin_sa_open */
239
240
241 static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
242 {
243 dbg("%s port %d", __FUNCTION__, port->number);
244
245 /* shutdown our bulk reads and writes */
246 usb_kill_urb(port->write_urb);
247 usb_kill_urb(port->read_urb);
248 usb_kill_urb(port->interrupt_in_urb);
249 } /* belkin_sa_close */
250
251
252 static void belkin_sa_read_int_callback (struct urb *urb)
253 {
254 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
255 struct belkin_sa_private *priv;
256 unsigned char *data = urb->transfer_buffer;
257 int retval;
258 int status = urb->status;
259 unsigned long flags;
260
261 switch (status) {
262 case 0:
263 /* success */
264 break;
265 case -ECONNRESET:
266 case -ENOENT:
267 case -ESHUTDOWN:
268 /* this urb is terminated, clean up */
269 dbg("%s - urb shutting down with status: %d",
270 __FUNCTION__, status);
271 return;
272 default:
273 dbg("%s - nonzero urb status received: %d",
274 __FUNCTION__, status);
275 goto exit;
276 }
277
278 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
279
280 /* Handle known interrupt data */
281 /* ignore data[0] and data[1] */
282
283 priv = usb_get_serial_port_data(port);
284 spin_lock_irqsave(&priv->lock, flags);
285 priv->last_msr = data[BELKIN_SA_MSR_INDEX];
286
287 /* Record Control Line states */
288 if (priv->last_msr & BELKIN_SA_MSR_DSR)
289 priv->control_state |= TIOCM_DSR;
290 else
291 priv->control_state &= ~TIOCM_DSR;
292
293 if (priv->last_msr & BELKIN_SA_MSR_CTS)
294 priv->control_state |= TIOCM_CTS;
295 else
296 priv->control_state &= ~TIOCM_CTS;
297
298 if (priv->last_msr & BELKIN_SA_MSR_RI)
299 priv->control_state |= TIOCM_RI;
300 else
301 priv->control_state &= ~TIOCM_RI;
302
303 if (priv->last_msr & BELKIN_SA_MSR_CD)
304 priv->control_state |= TIOCM_CD;
305 else
306 priv->control_state &= ~TIOCM_CD;
307
308 /* Now to report any errors */
309 priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
310 #if 0
311 /*
312 * fill in the flip buffer here, but I do not know the relation
313 * to the current/next receive buffer or characters. I need
314 * to look in to this before committing any code.
315 */
316 if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
317 tty = port->tty;
318 /* Overrun Error */
319 if (priv->last_lsr & BELKIN_SA_LSR_OE) {
320 }
321 /* Parity Error */
322 if (priv->last_lsr & BELKIN_SA_LSR_PE) {
323 }
324 /* Framing Error */
325 if (priv->last_lsr & BELKIN_SA_LSR_FE) {
326 }
327 /* Break Indicator */
328 if (priv->last_lsr & BELKIN_SA_LSR_BI) {
329 }
330 }
331 #endif
332 spin_unlock_irqrestore(&priv->lock, flags);
333 exit:
334 retval = usb_submit_urb (urb, GFP_ATOMIC);
335 if (retval)
336 err ("%s - usb_submit_urb failed with result %d",
337 __FUNCTION__, retval);
338 }
339
340 static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
341 {
342 struct usb_serial *serial = port->serial;
343 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
344 unsigned int iflag;
345 unsigned int cflag;
346 unsigned int old_iflag = 0;
347 unsigned int old_cflag = 0;
348 __u16 urb_value = 0; /* Will hold the new flags */
349 unsigned long flags;
350 unsigned long control_state;
351 int bad_flow_control;
352 speed_t baud;
353 struct ktermios *termios = port->tty->termios;
354
355 iflag = termios->c_iflag;
356 cflag = termios->c_cflag;
357
358 termios->c_cflag &= ~CMSPAR;
359
360 /* get a local copy of the current port settings */
361 spin_lock_irqsave(&priv->lock, flags);
362 control_state = priv->control_state;
363 bad_flow_control = priv->bad_flow_control;
364 spin_unlock_irqrestore(&priv->lock, flags);
365
366 old_iflag = old_termios->c_iflag;
367 old_cflag = old_termios->c_cflag;
368
369 /* Set the baud rate */
370 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
371 /* reassert DTR and (maybe) RTS on transition from B0 */
372 if( (old_cflag&CBAUD) == B0 ) {
373 control_state |= (TIOCM_DTR|TIOCM_RTS);
374 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
375 err("Set DTR error");
376 /* don't set RTS if using hardware flow control */
377 if (!(old_cflag & CRTSCTS))
378 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 1) < 0)
379 err("Set RTS error");
380 }
381 }
382
383 baud = tty_get_baud_rate(port->tty);
384 if (baud) {
385 urb_value = BELKIN_SA_BAUD(baud);
386 /* Clip to maximum speed */
387 if (urb_value == 0)
388 urb_value = 1;
389 /* Turn it back into a resulting real baud rate */
390 baud = BELKIN_SA_BAUD(urb_value);
391
392 /* Report the actual baud rate back to the caller */
393 tty_encode_baud_rate(port->tty, baud, baud);
394 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
395 err("Set baudrate error");
396 } else {
397 /* Disable flow control */
398 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, BELKIN_SA_FLOW_NONE) < 0)
399 err("Disable flowcontrol error");
400 /* Drop RTS and DTR */
401 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
402 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
403 err("DTR LOW error");
404 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
405 err("RTS LOW error");
406 }
407
408 /* set the parity */
409 if( (cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD)) ) {
410 if (cflag & PARENB)
411 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD : BELKIN_SA_PARITY_EVEN;
412 else
413 urb_value = BELKIN_SA_PARITY_NONE;
414 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
415 err("Set parity error");
416 }
417
418 /* set the number of data bits */
419 if( (cflag&CSIZE) != (old_cflag&CSIZE) ) {
420 switch (cflag & CSIZE) {
421 case CS5: urb_value = BELKIN_SA_DATA_BITS(5); break;
422 case CS6: urb_value = BELKIN_SA_DATA_BITS(6); break;
423 case CS7: urb_value = BELKIN_SA_DATA_BITS(7); break;
424 case CS8: urb_value = BELKIN_SA_DATA_BITS(8); break;
425 default: dbg("CSIZE was not CS5-CS8, using default of 8");
426 urb_value = BELKIN_SA_DATA_BITS(8);
427 break;
428 }
429 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
430 err("Set data bits error");
431 }
432
433 /* set the number of stop bits */
434 if( (cflag&CSTOPB) != (old_cflag&CSTOPB) ) {
435 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) : BELKIN_SA_STOP_BITS(1);
436 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, urb_value) < 0)
437 err("Set stop bits error");
438 }
439
440 /* Set flow control */
441 if( (iflag&IXOFF) != (old_iflag&IXOFF)
442 || (iflag&IXON) != (old_iflag&IXON)
443 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS) ) {
444 urb_value = 0;
445 if ((iflag & IXOFF) || (iflag & IXON))
446 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
447 else
448 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
449
450 if (cflag & CRTSCTS)
451 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
452 else
453 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
454
455 if (bad_flow_control)
456 urb_value &= ~(BELKIN_SA_FLOW_IRTS);
457
458 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
459 err("Set flow control error");
460 }
461
462 /* save off the modified port settings */
463 spin_lock_irqsave(&priv->lock, flags);
464 priv->control_state = control_state;
465 spin_unlock_irqrestore(&priv->lock, flags);
466 } /* belkin_sa_set_termios */
467
468
469 static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
470 {
471 struct usb_serial *serial = port->serial;
472
473 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
474 err("Set break_ctl %d", break_state);
475 }
476
477
478 static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
479 {
480 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
481 unsigned long control_state;
482 unsigned long flags;
483
484 dbg("%s", __FUNCTION__);
485
486 spin_lock_irqsave(&priv->lock, flags);
487 control_state = priv->control_state;
488 spin_unlock_irqrestore(&priv->lock, flags);
489
490 return control_state;
491 }
492
493
494 static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file,
495 unsigned int set, unsigned int clear)
496 {
497 struct usb_serial *serial = port->serial;
498 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
499 unsigned long control_state;
500 unsigned long flags;
501 int retval;
502 int rts = 0;
503 int dtr = 0;
504
505 dbg("%s", __FUNCTION__);
506
507 spin_lock_irqsave(&priv->lock, flags);
508 control_state = priv->control_state;
509
510 if (set & TIOCM_RTS) {
511 control_state |= TIOCM_RTS;
512 rts = 1;
513 }
514 if (set & TIOCM_DTR) {
515 control_state |= TIOCM_DTR;
516 dtr = 1;
517 }
518 if (clear & TIOCM_RTS) {
519 control_state &= ~TIOCM_RTS;
520 rts = 0;
521 }
522 if (clear & TIOCM_DTR) {
523 control_state &= ~TIOCM_DTR;
524 dtr = 0;
525 }
526
527 priv->control_state = control_state;
528 spin_unlock_irqrestore(&priv->lock, flags);
529
530 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
531 if (retval < 0) {
532 err("Set RTS error %d", retval);
533 goto exit;
534 }
535
536 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
537 if (retval < 0) {
538 err("Set DTR error %d", retval);
539 goto exit;
540 }
541 exit:
542 return retval;
543 }
544
545
546 static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
547 {
548 switch (cmd) {
549 case TIOCMIWAIT:
550 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
551 /* TODO */
552 return( 0 );
553
554 case TIOCGICOUNT:
555 /* return count of modemline transitions */
556 /* TODO */
557 return 0;
558
559 default:
560 dbg("belkin_sa_ioctl arg not supported - 0x%04x",cmd);
561 return(-ENOIOCTLCMD);
562 break;
563 }
564 return 0;
565 } /* belkin_sa_ioctl */
566
567
568 static int __init belkin_sa_init (void)
569 {
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 info(DRIVER_DESC " " DRIVER_VERSION);
578 return 0;
579 failed_usb_register:
580 usb_serial_deregister(&belkin_device);
581 failed_usb_serial_register:
582 return retval;
583 }
584
585
586 static void __exit belkin_sa_exit (void)
587 {
588 usb_deregister (&belkin_driver);
589 usb_serial_deregister (&belkin_device);
590 }
591
592
593 module_init (belkin_sa_init);
594 module_exit (belkin_sa_exit);
595
596 MODULE_AUTHOR( DRIVER_AUTHOR );
597 MODULE_DESCRIPTION( DRIVER_DESC );
598 MODULE_VERSION( DRIVER_VERSION );
599 MODULE_LICENSE("GPL");
600
601 module_param(debug, bool, S_IRUGO | S_IWUSR);
602 MODULE_PARM_DESC(debug, "Debug enabled or not");
603
|
This page was automatically generated by the
LXR engine.
|