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 * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) 7 * 8 * This program is largely derived from work by the linux-usb group 9 * and associated source files. Please see the usb/serial files for 10 * individual credits and copyrights. 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * See Documentation/usb/usb-serial.txt for more information on using this 18 * driver 19 * 20 * TODO: 21 * -- Add true modem contol line query capability. Currently we track the 22 * states reported by the interrupt and the states we request. 23 * -- Add error reporting back to application for UART error conditions. 24 * Just point me at how to implement this and I'll do it. I've put the 25 * framework in, but haven't analyzed the "tty_flip" interface yet. 26 * -- Add support for flush commands 27 * -- Add everything that is missing :) 28 * 29 * 27-Nov-2001 gkh 30 * compressed all the differnent device entries into 1. 31 * 32 * 30-May-2001 gkh 33 * switched from using spinlock to a semaphore, which fixes lots of 34 * problems. 35 * 36 * 08-Apr-2001 gb 37 * - Identify version on module load. 38 * 39 * 12-Mar-2001 gkh 40 * - Added support for the GoHubs GO-COM232 device which is the same as the 41 * Peracom device. 42 * 43 * 06-Nov-2000 gkh 44 * - Added support for the old Belkin and Peracom devices. 45 * - Made the port able to be opened multiple times. 46 * - Added some defaults incase the line settings are things these devices 47 * can't support. 48 * 49 * 18-Oct-2000 William Greathouse 50 * Released into the wild (linux-usb-devel) 51 * 52 * 17-Oct-2000 William Greathouse 53 * Add code to recognize firmware version and set hardware flow control 54 * appropriately. Belkin states that firmware prior to 3.05 does not 55 * operate correctly in hardware handshake mode. I have verified this 56 * on firmware 2.05 -- for both RTS and DTR input flow control, the control 57 * line is not reset. The test performed by the Belkin Win* driver is 58 * to enable hardware flow control for firmware 2.06 or greater and 59 * for 1.00 or prior. I am only enabling for 2.06 or greater. 60 * 61 * 12-Oct-2000 William Greathouse 62 * First cut at supporting Belkin USB Serial Adapter F5U103 63 * I did not have a copy of the original work to support this 64 * adapter, so pardon any stupid mistakes. All of the information 65 * I am using to write this driver was acquired by using a modified 66 * UsbSnoop on Windows2000 and from examining the other USB drivers. 67 */ 68 69 #include <linux/kernel.h> 70 #include <linux/errno.h> 71 #include <linux/init.h> 72 #include <linux/slab.h> 73 #include <linux/tty.h> 74 #include <linux/tty_driver.h> 75 #include <linux/tty_flip.h> 76 #include <linux/module.h> 77 #include <linux/spinlock.h> 78 #include <linux/uaccess.h> 79 #include <linux/usb.h> 80 #include <linux/usb/serial.h> 81 #include "belkin_sa.h" 82 83 static int debug; 84 85 /* 86 * Version Information 87 */ 88 #define DRIVER_VERSION "v1.3" 89 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" 90 #define DRIVER_DESC "USB Belkin Serial converter driver" 91 92 /* function prototypes for a Belkin USB Serial Adapter F5U103 */ 93 static int belkin_sa_startup(struct usb_serial *serial); 94 static void belkin_sa_release(struct usb_serial *serial); 95 static int belkin_sa_open(struct tty_struct *tty, 96 struct usb_serial_port *port); 97 static void belkin_sa_close(struct usb_serial_port *port); 98 static void belkin_sa_read_int_callback(struct urb *urb); 99 static void belkin_sa_process_read_urb(struct urb *urb); 100 static void belkin_sa_set_termios(struct tty_struct *tty, 101 struct usb_serial_port *port, struct ktermios * old); 102 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state); 103 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file); 104 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file, 105 unsigned int set, unsigned int clear); 106 107 108 static const struct usb_device_id id_table_combined[] = { 109 { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) }, 110 { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) }, 111 { USB_DEVICE(PERACOM_VID, PERACOM_PID) }, 112 { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) }, 113 { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) }, 114 { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) }, 115 { } /* Terminating entry */ 116 }; 117 MODULE_DEVICE_TABLE(usb, id_table_combined); 118 119 static struct usb_driver belkin_driver = { 120 .name = "belkin", 121 .probe = usb_serial_probe, 122 .disconnect = usb_serial_disconnect, 123 .id_table = id_table_combined, 124 .no_dynamic_id = 1, 125 }; 126 127 /* All of the device info needed for the serial converters */ 128 static struct usb_serial_driver belkin_device = { 129 .driver = { 130 .owner = THIS_MODULE, 131 .name = "belkin", 132 }, 133 .description = "Belkin / Peracom / GoHubs USB Serial Adapter", 134 .usb_driver = &belkin_driver, 135 .id_table = id_table_combined, 136 .num_ports = 1, 137 .open = belkin_sa_open, 138 .close = belkin_sa_close, 139 .read_int_callback = belkin_sa_read_int_callback, 140 .process_read_urb = belkin_sa_process_read_urb, 141 .set_termios = belkin_sa_set_termios, 142 .break_ctl = belkin_sa_break_ctl, 143 .tiocmget = belkin_sa_tiocmget, 144 .tiocmset = belkin_sa_tiocmset, 145 .attach = belkin_sa_startup, 146 .release = belkin_sa_release, 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 static void belkin_sa_release(struct usb_serial *serial) 200 { 201 int i; 202 203 dbg("%s", __func__); 204 205 for (i = 0; i < serial->num_ports; ++i) 206 kfree(usb_get_serial_port_data(serial->port[i])); 207 } 208 209 static int belkin_sa_open(struct tty_struct *tty, 210 struct usb_serial_port *port) 211 { 212 int retval; 213 214 dbg("%s port %d", __func__, port->number); 215 216 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 217 if (retval) { 218 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 219 return retval; 220 } 221 222 retval = usb_serial_generic_open(tty, port); 223 if (retval) 224 usb_kill_urb(port->interrupt_in_urb); 225 226 return retval; 227 } 228 229 static void belkin_sa_close(struct usb_serial_port *port) 230 { 231 dbg("%s port %d", __func__, port->number); 232 233 usb_serial_generic_close(port); 234 usb_kill_urb(port->interrupt_in_urb); 235 } 236 237 static void belkin_sa_read_int_callback(struct urb *urb) 238 { 239 struct usb_serial_port *port = urb->context; 240 struct belkin_sa_private *priv; 241 unsigned char *data = urb->transfer_buffer; 242 int retval; 243 int status = urb->status; 244 unsigned long flags; 245 246 switch (status) { 247 case 0: 248 /* success */ 249 break; 250 case -ECONNRESET: 251 case -ENOENT: 252 case -ESHUTDOWN: 253 /* this urb is terminated, clean up */ 254 dbg("%s - urb shutting down with status: %d", 255 __func__, status); 256 return; 257 default: 258 dbg("%s - nonzero urb status received: %d", 259 __func__, status); 260 goto exit; 261 } 262 263 usb_serial_debug_data(debug, &port->dev, __func__, 264 urb->actual_length, data); 265 266 /* Handle known interrupt data */ 267 /* ignore data[0] and data[1] */ 268 269 priv = usb_get_serial_port_data(port); 270 spin_lock_irqsave(&priv->lock, flags); 271 priv->last_msr = data[BELKIN_SA_MSR_INDEX]; 272 273 /* Record Control Line states */ 274 if (priv->last_msr & BELKIN_SA_MSR_DSR) 275 priv->control_state |= TIOCM_DSR; 276 else 277 priv->control_state &= ~TIOCM_DSR; 278 279 if (priv->last_msr & BELKIN_SA_MSR_CTS) 280 priv->control_state |= TIOCM_CTS; 281 else 282 priv->control_state &= ~TIOCM_CTS; 283 284 if (priv->last_msr & BELKIN_SA_MSR_RI) 285 priv->control_state |= TIOCM_RI; 286 else 287 priv->control_state &= ~TIOCM_RI; 288 289 if (priv->last_msr & BELKIN_SA_MSR_CD) 290 priv->control_state |= TIOCM_CD; 291 else 292 priv->control_state &= ~TIOCM_CD; 293 294 priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; 295 spin_unlock_irqrestore(&priv->lock, flags); 296 exit: 297 retval = usb_submit_urb(urb, GFP_ATOMIC); 298 if (retval) 299 dev_err(&port->dev, "%s - usb_submit_urb failed with " 300 "result %d\n", __func__, retval); 301 } 302 303 static void belkin_sa_process_read_urb(struct urb *urb) 304 { 305 struct usb_serial_port *port = urb->context; 306 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 307 struct tty_struct *tty; 308 unsigned char *data = urb->transfer_buffer; 309 unsigned long flags; 310 unsigned char status; 311 char tty_flag; 312 313 /* Update line status */ 314 tty_flag = TTY_NORMAL; 315 316 spin_lock_irqsave(&priv->lock, flags); 317 status = priv->last_lsr; 318 priv->last_lsr &= ~BELKIN_SA_LSR_ERR; 319 spin_unlock_irqrestore(&priv->lock, flags); 320 321 if (!urb->actual_length) 322 return; 323 324 tty = tty_port_tty_get(&port->port); 325 if (!tty) 326 return; 327 328 if (status & BELKIN_SA_LSR_ERR) { 329 /* Break takes precedence over parity, which takes precedence 330 * over framing errors. */ 331 if (status & BELKIN_SA_LSR_BI) 332 tty_flag = TTY_BREAK; 333 else if (status & BELKIN_SA_LSR_PE) 334 tty_flag = TTY_PARITY; 335 else if (status & BELKIN_SA_LSR_FE) 336 tty_flag = TTY_FRAME; 337 dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); 338 339 /* Overrun is special, not associated with a char. */ 340 if (status & BELKIN_SA_LSR_OE) 341 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 342 } 343 344 tty_insert_flip_string_fixed_flag(tty, data, tty_flag, 345 urb->actual_length); 346 tty_flip_buffer_push(tty); 347 tty_kref_put(tty); 348 } 349 350 static void belkin_sa_set_termios(struct tty_struct *tty, 351 struct usb_serial_port *port, struct ktermios *old_termios) 352 { 353 struct usb_serial *serial = port->serial; 354 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 355 unsigned int iflag; 356 unsigned int cflag; 357 unsigned int old_iflag = 0; 358 unsigned int old_cflag = 0; 359 __u16 urb_value = 0; /* Will hold the new flags */ 360 unsigned long flags; 361 unsigned long control_state; 362 int bad_flow_control; 363 speed_t baud; 364 struct ktermios *termios = tty->termios; 365 366 iflag = termios->c_iflag; 367 cflag = termios->c_cflag; 368 369 termios->c_cflag &= ~CMSPAR; 370 371 /* get a local copy of the current port settings */ 372 spin_lock_irqsave(&priv->lock, flags); 373 control_state = priv->control_state; 374 bad_flow_control = priv->bad_flow_control; 375 spin_unlock_irqrestore(&priv->lock, flags); 376 377 old_iflag = old_termios->c_iflag; 378 old_cflag = old_termios->c_cflag; 379 380 /* Set the baud rate */ 381 if ((cflag & CBAUD) != (old_cflag & CBAUD)) { 382 /* reassert DTR and (maybe) RTS on transition from B0 */ 383 if ((old_cflag & CBAUD) == B0) { 384 control_state |= (TIOCM_DTR|TIOCM_RTS); 385 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) 386 dev_err(&port->dev, "Set DTR error\n"); 387 /* don't set RTS if using hardware flow control */ 388 if (!(old_cflag & CRTSCTS)) 389 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST 390 , 1) < 0) 391 dev_err(&port->dev, "Set RTS error\n"); 392 } 393 } 394 395 baud = tty_get_baud_rate(tty); 396 if (baud) { 397 urb_value = BELKIN_SA_BAUD(baud); 398 /* Clip to maximum speed */ 399 if (urb_value == 0) 400 urb_value = 1; 401 /* Turn it back into a resulting real baud rate */ 402 baud = BELKIN_SA_BAUD(urb_value); 403 404 /* Report the actual baud rate back to the caller */ 405 tty_encode_baud_rate(tty, baud, baud); 406 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) 407 dev_err(&port->dev, "Set baudrate error\n"); 408 } else { 409 /* Disable flow control */ 410 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, 411 BELKIN_SA_FLOW_NONE) < 0) 412 dev_err(&port->dev, "Disable flowcontrol error\n"); 413 /* Drop RTS and DTR */ 414 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 415 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) 416 dev_err(&port->dev, "DTR LOW error\n"); 417 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) 418 dev_err(&port->dev, "RTS LOW error\n"); 419 } 420 421 /* set the parity */ 422 if ((cflag ^ old_cflag) & (PARENB | PARODD)) { 423 if (cflag & PARENB) 424 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD 425 : BELKIN_SA_PARITY_EVEN; 426 else 427 urb_value = BELKIN_SA_PARITY_NONE; 428 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) 429 dev_err(&port->dev, "Set parity error\n"); 430 } 431 432 /* set the number of data bits */ 433 if ((cflag & CSIZE) != (old_cflag & CSIZE)) { 434 switch (cflag & CSIZE) { 435 case CS5: 436 urb_value = BELKIN_SA_DATA_BITS(5); 437 break; 438 case CS6: 439 urb_value = BELKIN_SA_DATA_BITS(6); 440 break; 441 case CS7: 442 urb_value = BELKIN_SA_DATA_BITS(7); 443 break; 444 case CS8: 445 urb_value = BELKIN_SA_DATA_BITS(8); 446 break; 447 default: dbg("CSIZE was not CS5-CS8, using default of 8"); 448 urb_value = BELKIN_SA_DATA_BITS(8); 449 break; 450 } 451 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) 452 dev_err(&port->dev, "Set data bits error\n"); 453 } 454 455 /* set the number of stop bits */ 456 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { 457 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) 458 : BELKIN_SA_STOP_BITS(1); 459 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, 460 urb_value) < 0) 461 dev_err(&port->dev, "Set stop bits error\n"); 462 } 463 464 /* Set flow control */ 465 if (((iflag ^ old_iflag) & (IXOFF | IXON)) || 466 ((cflag ^ old_cflag) & CRTSCTS)) { 467 urb_value = 0; 468 if ((iflag & IXOFF) || (iflag & IXON)) 469 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 470 else 471 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 472 473 if (cflag & CRTSCTS) 474 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 475 else 476 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 477 478 if (bad_flow_control) 479 urb_value &= ~(BELKIN_SA_FLOW_IRTS); 480 481 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) 482 dev_err(&port->dev, "Set flow control error\n"); 483 } 484 485 /* save off the modified port settings */ 486 spin_lock_irqsave(&priv->lock, flags); 487 priv->control_state = control_state; 488 spin_unlock_irqrestore(&priv->lock, flags); 489 } 490 491 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) 492 { 493 struct usb_serial_port *port = tty->driver_data; 494 struct usb_serial *serial = port->serial; 495 496 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) 497 dev_err(&port->dev, "Set break_ctl %d\n", break_state); 498 } 499 500 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file) 501 { 502 struct usb_serial_port *port = tty->driver_data; 503 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 504 unsigned long control_state; 505 unsigned long flags; 506 507 dbg("%s", __func__); 508 509 spin_lock_irqsave(&priv->lock, flags); 510 control_state = priv->control_state; 511 spin_unlock_irqrestore(&priv->lock, flags); 512 513 return control_state; 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 static void __exit belkin_sa_exit (void) 588 { 589 usb_deregister(&belkin_driver); 590 usb_serial_deregister(&belkin_device); 591 } 592 593 594 module_init(belkin_sa_init); 595 module_exit(belkin_sa_exit); 596 597 MODULE_AUTHOR(DRIVER_AUTHOR); 598 MODULE_DESCRIPTION(DRIVER_DESC); 599 MODULE_VERSION(DRIVER_VERSION); 600 MODULE_LICENSE("GPL"); 601 602 module_param(debug, bool, S_IRUGO | S_IWUSR); 603 MODULE_PARM_DESC(debug, "Debug enabled or not"); 604