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 80static 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 */ 90static int belkin_sa_startup (struct usb_serial *serial); 91static void belkin_sa_shutdown (struct usb_serial *serial); 92static int belkin_sa_open (struct usb_serial_port *port, struct file *filp); 93static void belkin_sa_close (struct usb_serial_port *port, struct file *filp); 94static void belkin_sa_read_int_callback (struct urb *urb); 95static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios * old); 96static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg); 97static void belkin_sa_break_ctl (struct usb_serial_port *port, int break_state ); 98static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file); 99static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear); 100 101 102static 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 112MODULE_DEVICE_TABLE (usb, id_table_combined); 113 114static 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 */ 123static 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 148struct 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() */ 171static 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 196static 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 212static 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 236exit: 237 return retval; 238} /* belkin_sa_open */ 239 240 241static 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 252static 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 unsigned long flags; 259 260 switch (urb->status) { 261 case 0: 262 /* success */ 263 break; 264 case -ECONNRESET: 265 case -ENOENT: 266 case -ESHUTDOWN: 267 /* this urb is terminated, clean up */ 268 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status); 269 return; 270 default: 271 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status); 272 goto exit; 273 } 274 275 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); 276 277 /* Handle known interrupt data */ 278 /* ignore data[0] and data[1] */ 279 280 priv = usb_get_serial_port_data(port); 281 spin_lock_irqsave(&priv->lock, flags); 282 priv->last_msr = data[BELKIN_SA_MSR_INDEX]; 283 284 /* Record Control Line states */ 285 if (priv->last_msr & BELKIN_SA_MSR_DSR) 286 priv->control_state |= TIOCM_DSR; 287 else 288 priv->control_state &= ~TIOCM_DSR; 289 290 if (priv->last_msr & BELKIN_SA_MSR_CTS) 291 priv->control_state |= TIOCM_CTS; 292 else 293 priv->control_state &= ~TIOCM_CTS; 294 295 if (priv->last_msr & BELKIN_SA_MSR_RI) 296 priv->control_state |= TIOCM_RI; 297 else 298 priv->control_state &= ~TIOCM_RI; 299 300 if (priv->last_msr & BELKIN_SA_MSR_CD) 301 priv->control_state |= TIOCM_CD; 302 else 303 priv->control_state &= ~TIOCM_CD; 304 305 /* Now to report any errors */ 306 priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; 307 spin_unlock_irqrestore(&priv->lock, flags); 308exit: 309 retval = usb_submit_urb (urb, GFP_ATOMIC); 310 if (retval) 311 err ("%s - usb_submit_urb failed with result %d", 312 __FUNCTION__, retval); 313} 314 315static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios *old_termios) 316{ 317 struct usb_serial *serial = port->serial; 318 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 319 unsigned int iflag; 320 unsigned int cflag; 321 unsigned int old_iflag = 0; 322 unsigned int old_cflag = 0; 323 __u16 urb_value = 0; /* Will hold the new flags */ 324 unsigned long flags; 325 unsigned long control_state; 326 int bad_flow_control; 327 328 if ((!port->tty) || (!port->tty->termios)) { 329 dbg ("%s - no tty or termios structure", __FUNCTION__); 330 return; 331 } 332 333 iflag = port->tty->termios->c_iflag; 334 cflag = port->tty->termios->c_cflag; 335 336 /* get a local copy of the current port settings */ 337 spin_lock_irqsave(&priv->lock, flags); 338 control_state = priv->control_state; 339 bad_flow_control = priv->bad_flow_control; 340 spin_unlock_irqrestore(&priv->lock, flags); 341 342 /* check that they really want us to change something */ 343 if (old_termios) { 344 if ((cflag == old_termios->c_cflag) && 345 (RELEVANT_IFLAG(port->tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) { 346 dbg("%s - nothing to change...", __FUNCTION__); 347 return; 348 } 349 old_iflag = old_termios->c_iflag; 350 old_cflag = old_termios->c_cflag; 351 } 352 353 /* Set the baud rate */ 354 if( (cflag&CBAUD) != (old_cflag&CBAUD) ) { 355 /* reassert DTR and (maybe) RTS on transition from B0 */ 356 if( (old_cflag&CBAUD) == B0 ) { 357 control_state |= (TIOCM_DTR|TIOCM_RTS); 358 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) 359 err("Set DTR error"); 360 /* don't set RTS if using hardware flow control */ 361 if (!(old_cflag&CRTSCTS) ) 362 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 1) < 0) 363 err("Set RTS error"); 364 } 365 366 switch(cflag & CBAUD) { 367 case B0: /* handled below */ break; 368 case B300: urb_value = BELKIN_SA_BAUD(300); break; 369 case B600: urb_value = BELKIN_SA_BAUD(600); break; 370 case B1200: urb_value = BELKIN_SA_BAUD(1200); break; 371 case B2400: urb_value = BELKIN_SA_BAUD(2400); break; 372 case B4800: urb_value = BELKIN_SA_BAUD(4800); break; 373 case B9600: urb_value = BELKIN_SA_BAUD(9600); break; 374 case B19200: urb_value = BELKIN_SA_BAUD(19200); break; 375 case B38400: urb_value = BELKIN_SA_BAUD(38400); break; 376 case B57600: urb_value = BELKIN_SA_BAUD(57600); break; 377 case B115200: urb_value = BELKIN_SA_BAUD(115200); break; 378 case B230400: urb_value = BELKIN_SA_BAUD(230400); break; 379 default: err("BELKIN USB Serial Adapter: unsupported baudrate request, using default of 9600"); 380 urb_value = BELKIN_SA_BAUD(9600); break; 381 } 382 if ((cflag & CBAUD) != B0 ) { 383 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) 384 err("Set baudrate error"); 385 } else { 386 /* Disable flow control */ 387 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, BELKIN_SA_FLOW_NONE) < 0) 388 err("Disable flowcontrol error"); 389 390 /* Drop RTS and DTR */ 391 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 392 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) 393 err("DTR LOW error"); 394 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) 395 err("RTS LOW error"); 396 } 397 } 398 399 /* set the parity */ 400 if( (cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD)) ) { 401 if (cflag & PARENB) 402 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD : BELKIN_SA_PARITY_EVEN; 403 else 404 urb_value = BELKIN_SA_PARITY_NONE; 405 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) 406 err("Set parity error"); 407 } 408 409 /* set the number of data bits */ 410 if( (cflag&CSIZE) != (old_cflag&CSIZE) ) { 411 switch (cflag & CSIZE) { 412 case CS5: urb_value = BELKIN_SA_DATA_BITS(5); break; 413 case CS6: urb_value = BELKIN_SA_DATA_BITS(6); break; 414 case CS7: urb_value = BELKIN_SA_DATA_BITS(7); break; 415 case CS8: urb_value = BELKIN_SA_DATA_BITS(8); break; 416 default: err("CSIZE was not CS5-CS8, using default of 8"); 417 urb_value = BELKIN_SA_DATA_BITS(8); 418 break; 419 } 420 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) 421 err("Set data bits error"); 422 } 423 424 /* set the number of stop bits */ 425 if( (cflag&CSTOPB) != (old_cflag&CSTOPB) ) { 426 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) : BELKIN_SA_STOP_BITS(1); 427 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, urb_value) < 0) 428 err("Set stop bits error"); 429 } 430 431 /* Set flow control */ 432 if( (iflag&IXOFF) != (old_iflag&IXOFF) 433 || (iflag&IXON) != (old_iflag&IXON) 434 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS) ) { 435 urb_value = 0; 436 if ((iflag & IXOFF) || (iflag & IXON)) 437 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 438 else 439 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 440 441 if (cflag & CRTSCTS) 442 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 443 else 444 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 445 446 if (bad_flow_control) 447 urb_value &= ~(BELKIN_SA_FLOW_IRTS); 448 449 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) 450 err("Set flow control error"); 451 } 452 453 /* save off the modified port settings */ 454 spin_lock_irqsave(&priv->lock, flags); 455 priv->control_state = control_state; 456 spin_unlock_irqrestore(&priv->lock, flags); 457} /* belkin_sa_set_termios */ 458 459 460static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state ) 461{ 462 struct usb_serial *serial = port->serial; 463 464 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) 465 err("Set break_ctl %d", break_state); 466} 467 468 469static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file) 470{ 471 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 472 unsigned long control_state; 473 unsigned long flags; 474 475 dbg("%s", __FUNCTION__); 476 477 spin_lock_irqsave(&priv->lock, flags); 478 control_state = priv->control_state; 479 spin_unlock_irqrestore(&priv->lock, flags); 480 481 return control_state; 482} 483 484 485static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file, 486 unsigned int set, unsigned int clear) 487{ 488 struct usb_serial *serial = port->serial; 489 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 490 unsigned long control_state; 491 unsigned long flags; 492 int retval; 493 int rts = 0; 494 int dtr = 0; 495 496 dbg("%s", __FUNCTION__); 497 498 spin_lock_irqsave(&priv->lock, flags); 499 control_state = priv->control_state; 500 501 if (set & TIOCM_RTS) { 502 control_state |= TIOCM_RTS; 503 rts = 1; 504 } 505 if (set & TIOCM_DTR) { 506 control_state |= TIOCM_DTR; 507 dtr = 1; 508 } 509 if (clear & TIOCM_RTS) { 510 control_state &= ~TIOCM_RTS; 511 rts = 0; 512 } 513 if (clear & TIOCM_DTR) { 514 control_state &= ~TIOCM_DTR; 515 dtr = 0; 516 } 517 518 priv->control_state = control_state; 519 spin_unlock_irqrestore(&priv->lock, flags); 520 521 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); 522 if (retval < 0) { 523 err("Set RTS error %d", retval); 524 goto exit; 525 } 526 527 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); 528 if (retval < 0) { 529 err("Set DTR error %d", retval); 530 goto exit; 531 } 532exit: 533 return retval; 534} 535 536 537static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg) 538{ 539 switch (cmd) { 540 case TIOCMIWAIT: 541 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/ 542 /* TODO */ 543 return( 0 ); 544 545 case TIOCGICOUNT: 546 /* return count of modemline transitions */ 547 /* TODO */ 548 return 0; 549 550 default: 551 dbg("belkin_sa_ioctl arg not supported - 0x%04x",cmd); 552 return(-ENOIOCTLCMD); 553 break; 554 } 555 return 0; 556} /* belkin_sa_ioctl */ 557 558 559static int __init belkin_sa_init (void) 560{ 561 int retval; 562 retval = usb_serial_register(&belkin_device); 563 if (retval) 564 goto failed_usb_serial_register; 565 retval = usb_register(&belkin_driver); 566 if (retval) 567 goto failed_usb_register; 568 info(DRIVER_DESC " " DRIVER_VERSION); 569 return 0; 570failed_usb_register: 571 usb_serial_deregister(&belkin_device); 572failed_usb_serial_register: 573 return retval; 574} 575 576 577static void __exit belkin_sa_exit (void) 578{ 579 usb_deregister (&belkin_driver); 580 usb_serial_deregister (&belkin_device); 581} 582 583 584module_init (belkin_sa_init); 585module_exit (belkin_sa_exit); 586 587MODULE_AUTHOR( DRIVER_AUTHOR ); 588MODULE_DESCRIPTION( DRIVER_DESC ); 589MODULE_VERSION( DRIVER_VERSION ); 590MODULE_LICENSE("GPL"); 591 592module_param(debug, bool, S_IRUGO | S_IWUSR); 593MODULE_PARM_DESC(debug, "Debug enabled or not"); 594