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 17 * driver 18 * 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 :) 27 * 28 * 27-Nov-2001 gkh 29 * compressed all the differnent device entries into 1. 30 * 31 * 30-May-2001 gkh 32 * switched from using spinlock to a semaphore, which fixes lots of 33 * problems. 34 * 35 * 08-Apr-2001 gb 36 * - Identify version on module load. 37 * 38 * 12-Mar-2001 gkh 39 * - Added support for the GoHubs GO-COM232 device which is the same as the 40 * Peracom device. 41 * 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. 47 * 48 * 18-Oct-2000 William Greathouse 49 * Released into the wild (linux-usb-devel) 50 * 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. 59 * 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. 66 */ 67 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" 81 82 static int debug; 83 84 /* 85 * Version Information 86 */ 87 #define DRIVER_VERSION "v1.2" 88 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" 89 #define DRIVER_DESC "USB Belkin Serial converter driver" 90 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_shutdown(struct usb_serial *serial); 94 static int belkin_sa_open(struct tty_struct *tty, 95 struct usb_serial_port *port, struct file *filp); 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); 104 105 106 static 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 */ 114 }; 115 116 MODULE_DEVICE_TABLE(usb, id_table_combined); 117 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, 124 }; 125 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", 131 }, 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 .shutdown = belkin_sa_shutdown, 146 }; 147 148 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; 155 }; 156 157 158 /* 159 * *************************************************************************** 160 * Belkin USB Serial Adapter F5U103 specific driver functions 161 * *************************************************************************** 162 */ 163 164 #define WDR_TIMEOUT 5000 /* default urb timeout */ 165 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) 170 171 /* do some startup allocations not currently performed by usb_serial_probe() */ 172 static int belkin_sa_startup(struct usb_serial *serial) 173 { 174 struct usb_device *dev = serial->dev; 175 struct belkin_sa_private *priv; 176 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); 192 193 init_waitqueue_head(&serial->port[0]->write_wait); 194 usb_set_serial_port_data(serial->port[0], priv); 195 196 return 0; 197 } 198 199 200 static void belkin_sa_shutdown(struct usb_serial *serial) 201 { 202 struct belkin_sa_private *priv; 203 int i; 204 205 dbg("%s", __func__); 206 207 /* stop reads and writes on all ports */ 208 for (i = 0; i < serial->num_ports; ++i) { 209 /* My special items, the standard routines free my urbs */ 210 priv = usb_get_serial_port_data(serial->port[i]); 211 kfree(priv); 212 } 213 } 214 215 216 static int belkin_sa_open(struct tty_struct *tty, 217 struct usb_serial_port *port, struct file *filp) 218 { 219 int retval = 0; 220 221 dbg("%s port %d", __func__, port->number); 222 223 /*Start reading from the device*/ 224 /* TODO: Look at possibility of submitting multiple URBs to device to 225 * enhance buffering. Win trace shows 16 initial read URBs. 226 */ 227 port->read_urb->dev = port->serial->dev; 228 retval = usb_submit_urb(port->read_urb, GFP_KERNEL); 229 if (retval) { 230 dev_err(&port->dev, "usb_submit_urb(read bulk) failed\n"); 231 goto exit; 232 } 233 234 port->interrupt_in_urb->dev = port->serial->dev; 235 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 236 if (retval) { 237 usb_kill_urb(port->read_urb); 238 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 239 } 240 241 exit: 242 return retval; 243 } /* belkin_sa_open */ 244 245 246 static void belkin_sa_close(struct usb_serial_port *port) 247 { 248 dbg("%s port %d", __func__, port->number); 249 250 /* shutdown our bulk reads and writes */ 251 usb_kill_urb(port->write_urb); 252 usb_kill_urb(port->read_urb); 253 usb_kill_urb(port->interrupt_in_urb); 254 } /* belkin_sa_close */ 255 256 257 static void belkin_sa_read_int_callback(struct urb *urb) 258 { 259 struct usb_serial_port *port = urb->context; 260 struct belkin_sa_private *priv; 261 unsigned char *data = urb->transfer_buffer; 262 int retval; 263 int status = urb->status; 264 unsigned long flags; 265 266 switch (status) { 267 case 0: 268 /* success */ 269 break; 270 case -ECONNRESET: 271 case -ENOENT: 272 case -ESHUTDOWN: 273 /* this urb is terminated, clean up */ 274 dbg("%s - urb shutting down with status: %d", 275 __func__, status); 276 return; 277 default: 278 dbg("%s - nonzero urb status received: %d", 279 __func__, status); 280 goto exit; 281 } 282 283 usb_serial_debug_data(debug, &port->dev, __func__, 284 urb->actual_length, data); 285 286 /* Handle known interrupt data */ 287 /* ignore data[0] and data[1] */ 288 289 priv = usb_get_serial_port_data(port); 290 spin_lock_irqsave(&priv->lock, flags); 291 priv->last_msr = data[BELKIN_SA_MSR_INDEX]; 292 293 /* Record Control Line states */ 294 if (priv->last_msr & BELKIN_SA_MSR_DSR) 295 priv->control_state |= TIOCM_DSR; 296 else 297 priv->control_state &= ~TIOCM_DSR; 298 299 if (priv->last_msr & BELKIN_SA_MSR_CTS) 300 priv->control_state |= TIOCM_CTS; 301 else 302 priv->control_state &= ~TIOCM_CTS; 303 304 if (priv->last_msr & BELKIN_SA_MSR_RI) 305 priv->control_state |= TIOCM_RI; 306 else 307 priv->control_state &= ~TIOCM_RI; 308 309 if (priv->last_msr & BELKIN_SA_MSR_CD) 310 priv->control_state |= TIOCM_CD; 311 else 312 priv->control_state &= ~TIOCM_CD; 313 314 /* Now to report any errors */ 315 priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; 316 #if 0 317 /* 318 * fill in the flip buffer here, but I do not know the relation 319 * to the current/next receive buffer or characters. I need 320 * to look in to this before committing any code. 321 */ 322 if (priv->last_lsr & BELKIN_SA_LSR_ERR) { 323 tty = tty_port_tty_get(&port->port); 324 /* Overrun Error */ 325 if (priv->last_lsr & BELKIN_SA_LSR_OE) { 326 } 327 /* Parity Error */ 328 if (priv->last_lsr & BELKIN_SA_LSR_PE) { 329 } 330 /* Framing Error */ 331 if (priv->last_lsr & BELKIN_SA_LSR_FE) { 332 } 333 /* Break Indicator */ 334 if (priv->last_lsr & BELKIN_SA_LSR_BI) { 335 } 336 tty_kref_put(tty); 337 } 338 #endif 339 spin_unlock_irqrestore(&priv->lock, flags); 340 exit: 341 retval = usb_submit_urb(urb, GFP_ATOMIC); 342 if (retval) 343 dev_err(&port->dev, "%s - usb_submit_urb failed with " 344 "result %d\n", __func__, retval); 345 } 346 347 static void belkin_sa_set_termios(struct tty_struct *tty, 348 struct usb_serial_port *port, struct ktermios *old_termios) 349 { 350 struct usb_serial *serial = port->serial; 351 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 352 unsigned int iflag; 353 unsigned int cflag; 354 unsigned int old_iflag = 0; 355 unsigned int old_cflag = 0; 356 __u16 urb_value = 0; /* Will hold the new flags */ 357 unsigned long flags; 358 unsigned long control_state; 359 int bad_flow_control; 360 speed_t baud; 361 struct ktermios *termios = tty->termios; 362 363 iflag = termios->c_iflag; 364 cflag = termios->c_cflag; 365 366 termios->c_cflag &= ~CMSPAR; 367 368 /* get a local copy of the current port settings */ 369 spin_lock_irqsave(&priv->lock, flags); 370 control_state = priv->control_state; 371 bad_flow_control = priv->bad_flow_control; 372 spin_unlock_irqrestore(&priv->lock, flags); 373 374 old_iflag = old_termios->c_iflag; 375 old_cflag = old_termios->c_cflag; 376 377 /* Set the baud rate */ 378 if ((cflag & CBAUD) != (old_cflag & CBAUD)) { 379 /* reassert DTR and (maybe) RTS on transition from B0 */ 380 if ((old_cflag & CBAUD) == B0) { 381 control_state |= (TIOCM_DTR|TIOCM_RTS); 382 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) 383 dev_err(&port->dev, "Set DTR error\n"); 384 /* don't set RTS if using hardware flow control */ 385 if (!(old_cflag & CRTSCTS)) 386 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST 387 , 1) < 0) 388 dev_err(&port->dev, "Set RTS error\n"); 389 } 390 } 391 392 baud = tty_get_baud_rate(tty); 393 if (baud) { 394 urb_value = BELKIN_SA_BAUD(baud); 395 /* Clip to maximum speed */ 396 if (urb_value == 0) 397 urb_value = 1; 398 /* Turn it back into a resulting real baud rate */ 399 baud = BELKIN_SA_BAUD(urb_value); 400 401 /* Report the actual baud rate back to the caller */ 402 tty_encode_baud_rate(tty, baud, baud); 403 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) 404 dev_err(&port->dev, "Set baudrate error\n"); 405 } else { 406 /* Disable flow control */ 407 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, 408 BELKIN_SA_FLOW_NONE) < 0) 409 dev_err(&port->dev, "Disable flowcontrol error\n"); 410 /* Drop RTS and DTR */ 411 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 412 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) 413 dev_err(&port->dev, "DTR LOW error\n"); 414 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) 415 dev_err(&port->dev, "RTS LOW error\n"); 416 } 417 418 /* set the parity */ 419 if ((cflag ^ old_cflag) & (PARENB | PARODD)) { 420 if (cflag & PARENB) 421 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD 422 : BELKIN_SA_PARITY_EVEN; 423 else 424 urb_value = BELKIN_SA_PARITY_NONE; 425 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) 426 dev_err(&port->dev, "Set parity error\n"); 427 } 428 429 /* set the number of data bits */ 430 if ((cflag & CSIZE) != (old_cflag & CSIZE)) { 431 switch (cflag & CSIZE) { 432 case CS5: 433 urb_value = BELKIN_SA_DATA_BITS(5); 434 break; 435 case CS6: 436 urb_value = BELKIN_SA_DATA_BITS(6); 437 break; 438 case CS7: 439 urb_value = BELKIN_SA_DATA_BITS(7); 440 break; 441 case CS8: 442 urb_value = BELKIN_SA_DATA_BITS(8); 443 break; 444 default: dbg("CSIZE was not CS5-CS8, using default of 8"); 445 urb_value = BELKIN_SA_DATA_BITS(8); 446 break; 447 } 448 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) 449 dev_err(&port->dev, "Set data bits error\n"); 450 } 451 452 /* set the number of stop bits */ 453 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { 454 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) 455 : BELKIN_SA_STOP_BITS(1); 456 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, 457 urb_value) < 0) 458 dev_err(&port->dev, "Set stop bits error\n"); 459 } 460 461 /* Set flow control */ 462 if (((iflag ^ old_iflag) & (IXOFF | IXON)) || 463 ((cflag ^ old_cflag) & CRTSCTS)) { 464 urb_value = 0; 465 if ((iflag & IXOFF) || (iflag & IXON)) 466 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 467 else 468 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 469 470 if (cflag & CRTSCTS) 471 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 472 else 473 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 474 475 if (bad_flow_control) 476 urb_value &= ~(BELKIN_SA_FLOW_IRTS); 477 478 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) 479 dev_err(&port->dev, "Set flow control error\n"); 480 } 481 482 /* save off the modified port settings */ 483 spin_lock_irqsave(&priv->lock, flags); 484 priv->control_state = control_state; 485 spin_unlock_irqrestore(&priv->lock, flags); 486 } /* belkin_sa_set_termios */ 487 488 489 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) 490 { 491 struct usb_serial_port *port = tty->driver_data; 492 struct usb_serial *serial = port->serial; 493 494 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) 495 dev_err(&port->dev, "Set break_ctl %d\n", break_state); 496 } 497 498 499 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file) 500 { 501 struct usb_serial_port *port = tty->driver_data; 502 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 503 unsigned long control_state; 504 unsigned long flags; 505 506 dbg("%s", __func__); 507 508 spin_lock_irqsave(&priv->lock, flags); 509 control_state = priv->control_state; 510 spin_unlock_irqrestore(&priv->lock, flags); 511 512 return control_state; 513 } 514 515 516 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file, 517 unsigned int set, unsigned int clear) 518 { 519 struct usb_serial_port *port = tty->driver_data; 520 struct usb_serial *serial = port->serial; 521 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 522 unsigned long control_state; 523 unsigned long flags; 524 int retval; 525 int rts = 0; 526 int dtr = 0; 527 528 dbg("%s", __func__); 529 530 spin_lock_irqsave(&priv->lock, flags); 531 control_state = priv->control_state; 532 533 if (set & TIOCM_RTS) { 534 control_state |= TIOCM_RTS; 535 rts = 1; 536 } 537 if (set & TIOCM_DTR) { 538 control_state |= TIOCM_DTR; 539 dtr = 1; 540 } 541 if (clear & TIOCM_RTS) { 542 control_state &= ~TIOCM_RTS; 543 rts = 0; 544 } 545 if (clear & TIOCM_DTR) { 546 control_state &= ~TIOCM_DTR; 547 dtr = 0; 548 } 549 550 priv->control_state = control_state; 551 spin_unlock_irqrestore(&priv->lock, flags); 552 553 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); 554 if (retval < 0) { 555 dev_err(&port->dev, "Set RTS error %d\n", retval); 556 goto exit; 557 } 558 559 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); 560 if (retval < 0) { 561 dev_err(&port->dev, "Set DTR error %d\n", retval); 562 goto exit; 563 } 564 exit: 565 return retval; 566 } 567 568 569 static int __init belkin_sa_init(void) 570 { 571 int retval; 572 retval = usb_serial_register(&belkin_device); 573 if (retval) 574 goto failed_usb_serial_register; 575 retval = usb_register(&belkin_driver); 576 if (retval) 577 goto failed_usb_register; 578 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 579 DRIVER_DESC "\n"); 580 return 0; 581 failed_usb_register: 582 usb_serial_deregister(&belkin_device); 583 failed_usb_serial_register: 584 return retval; 585 } 586 587 588 static void __exit belkin_sa_exit (void) 589 { 590 usb_deregister(&belkin_driver); 591 usb_serial_deregister(&belkin_device); 592 } 593 594 595 module_init(belkin_sa_init); 596 module_exit(belkin_sa_exit); 597 598 MODULE_AUTHOR(DRIVER_AUTHOR); 599 MODULE_DESCRIPTION(DRIVER_DESC); 600 MODULE_VERSION(DRIVER_VERSION); 601 MODULE_LICENSE("GPL"); 602 603 module_param(debug, bool, S_IRUGO | S_IWUSR); 604 MODULE_PARM_DESC(debug, "Debug enabled or not"); 605