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 support for flush commands 24 */ 25 26 #include <linux/kernel.h> 27 #include <linux/errno.h> 28 #include <linux/init.h> 29 #include <linux/slab.h> 30 #include <linux/tty.h> 31 #include <linux/tty_driver.h> 32 #include <linux/tty_flip.h> 33 #include <linux/module.h> 34 #include <linux/spinlock.h> 35 #include <linux/uaccess.h> 36 #include <linux/usb.h> 37 #include <linux/usb/serial.h> 38 #include "belkin_sa.h" 39 40 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" 41 #define DRIVER_DESC "USB Belkin Serial converter driver" 42 43 /* function prototypes for a Belkin USB Serial Adapter F5U103 */ 44 static int belkin_sa_port_probe(struct usb_serial_port *port); 45 static int belkin_sa_port_remove(struct usb_serial_port *port); 46 static int belkin_sa_open(struct tty_struct *tty, 47 struct usb_serial_port *port); 48 static void belkin_sa_close(struct usb_serial_port *port); 49 static void belkin_sa_read_int_callback(struct urb *urb); 50 static void belkin_sa_process_read_urb(struct urb *urb); 51 static void belkin_sa_set_termios(struct tty_struct *tty, 52 struct usb_serial_port *port, struct ktermios * old); 53 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state); 54 static int belkin_sa_tiocmget(struct tty_struct *tty); 55 static int belkin_sa_tiocmset(struct tty_struct *tty, 56 unsigned int set, unsigned int clear); 57 58 59 static const struct usb_device_id id_table[] = { 60 { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) }, 61 { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) }, 62 { USB_DEVICE(PERACOM_VID, PERACOM_PID) }, 63 { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) }, 64 { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) }, 65 { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) }, 66 { } /* Terminating entry */ 67 }; 68 MODULE_DEVICE_TABLE(usb, id_table); 69 70 /* All of the device info needed for the serial converters */ 71 static struct usb_serial_driver belkin_device = { 72 .driver = { 73 .owner = THIS_MODULE, 74 .name = "belkin", 75 }, 76 .description = "Belkin / Peracom / GoHubs USB Serial Adapter", 77 .id_table = id_table, 78 .num_ports = 1, 79 .open = belkin_sa_open, 80 .close = belkin_sa_close, 81 .read_int_callback = belkin_sa_read_int_callback, 82 .process_read_urb = belkin_sa_process_read_urb, 83 .set_termios = belkin_sa_set_termios, 84 .break_ctl = belkin_sa_break_ctl, 85 .tiocmget = belkin_sa_tiocmget, 86 .tiocmset = belkin_sa_tiocmset, 87 .port_probe = belkin_sa_port_probe, 88 .port_remove = belkin_sa_port_remove, 89 }; 90 91 static struct usb_serial_driver * const serial_drivers[] = { 92 &belkin_device, NULL 93 }; 94 95 struct belkin_sa_private { 96 spinlock_t lock; 97 unsigned long control_state; 98 unsigned char last_lsr; 99 unsigned char last_msr; 100 int bad_flow_control; 101 }; 102 103 104 /* 105 * *************************************************************************** 106 * Belkin USB Serial Adapter F5U103 specific driver functions 107 * *************************************************************************** 108 */ 109 110 #define WDR_TIMEOUT 5000 /* default urb timeout */ 111 112 /* assumes that struct usb_serial *serial is available */ 113 #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \ 114 (c), BELKIN_SA_SET_REQUEST_TYPE, \ 115 (v), 0, NULL, 0, WDR_TIMEOUT) 116 117 static int belkin_sa_port_probe(struct usb_serial_port *port) 118 { 119 struct usb_device *dev = port->serial->dev; 120 struct belkin_sa_private *priv; 121 122 priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL); 123 if (!priv) 124 return -ENOMEM; 125 126 spin_lock_init(&priv->lock); 127 priv->control_state = 0; 128 priv->last_lsr = 0; 129 priv->last_msr = 0; 130 /* see comments at top of file */ 131 priv->bad_flow_control = 132 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0; 133 dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n", 134 le16_to_cpu(dev->descriptor.bcdDevice), 135 priv->bad_flow_control); 136 137 usb_set_serial_port_data(port, priv); 138 139 return 0; 140 } 141 142 static int belkin_sa_port_remove(struct usb_serial_port *port) 143 { 144 struct belkin_sa_private *priv; 145 146 priv = usb_get_serial_port_data(port); 147 kfree(priv); 148 149 return 0; 150 } 151 152 static int belkin_sa_open(struct tty_struct *tty, 153 struct usb_serial_port *port) 154 { 155 int retval; 156 157 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 158 if (retval) { 159 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 160 return retval; 161 } 162 163 retval = usb_serial_generic_open(tty, port); 164 if (retval) 165 usb_kill_urb(port->interrupt_in_urb); 166 167 return retval; 168 } 169 170 static void belkin_sa_close(struct usb_serial_port *port) 171 { 172 usb_serial_generic_close(port); 173 usb_kill_urb(port->interrupt_in_urb); 174 } 175 176 static void belkin_sa_read_int_callback(struct urb *urb) 177 { 178 struct usb_serial_port *port = urb->context; 179 struct belkin_sa_private *priv; 180 unsigned char *data = urb->transfer_buffer; 181 int retval; 182 int status = urb->status; 183 unsigned long flags; 184 185 switch (status) { 186 case 0: 187 /* success */ 188 break; 189 case -ECONNRESET: 190 case -ENOENT: 191 case -ESHUTDOWN: 192 /* this urb is terminated, clean up */ 193 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", 194 __func__, status); 195 return; 196 default: 197 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", 198 __func__, status); 199 goto exit; 200 } 201 202 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); 203 204 /* Handle known interrupt data */ 205 /* ignore data[0] and data[1] */ 206 207 priv = usb_get_serial_port_data(port); 208 spin_lock_irqsave(&priv->lock, flags); 209 priv->last_msr = data[BELKIN_SA_MSR_INDEX]; 210 211 /* Record Control Line states */ 212 if (priv->last_msr & BELKIN_SA_MSR_DSR) 213 priv->control_state |= TIOCM_DSR; 214 else 215 priv->control_state &= ~TIOCM_DSR; 216 217 if (priv->last_msr & BELKIN_SA_MSR_CTS) 218 priv->control_state |= TIOCM_CTS; 219 else 220 priv->control_state &= ~TIOCM_CTS; 221 222 if (priv->last_msr & BELKIN_SA_MSR_RI) 223 priv->control_state |= TIOCM_RI; 224 else 225 priv->control_state &= ~TIOCM_RI; 226 227 if (priv->last_msr & BELKIN_SA_MSR_CD) 228 priv->control_state |= TIOCM_CD; 229 else 230 priv->control_state &= ~TIOCM_CD; 231 232 priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; 233 spin_unlock_irqrestore(&priv->lock, flags); 234 exit: 235 retval = usb_submit_urb(urb, GFP_ATOMIC); 236 if (retval) 237 dev_err(&port->dev, "%s - usb_submit_urb failed with " 238 "result %d\n", __func__, retval); 239 } 240 241 static void belkin_sa_process_read_urb(struct urb *urb) 242 { 243 struct usb_serial_port *port = urb->context; 244 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 245 unsigned char *data = urb->transfer_buffer; 246 unsigned long flags; 247 unsigned char status; 248 char tty_flag; 249 250 /* Update line status */ 251 tty_flag = TTY_NORMAL; 252 253 spin_lock_irqsave(&priv->lock, flags); 254 status = priv->last_lsr; 255 priv->last_lsr &= ~BELKIN_SA_LSR_ERR; 256 spin_unlock_irqrestore(&priv->lock, flags); 257 258 if (!urb->actual_length) 259 return; 260 261 if (status & BELKIN_SA_LSR_ERR) { 262 /* Break takes precedence over parity, which takes precedence 263 * over framing errors. */ 264 if (status & BELKIN_SA_LSR_BI) 265 tty_flag = TTY_BREAK; 266 else if (status & BELKIN_SA_LSR_PE) 267 tty_flag = TTY_PARITY; 268 else if (status & BELKIN_SA_LSR_FE) 269 tty_flag = TTY_FRAME; 270 dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); 271 272 /* Overrun is special, not associated with a char. */ 273 if (status & BELKIN_SA_LSR_OE) 274 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN); 275 } 276 277 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag, 278 urb->actual_length); 279 tty_flip_buffer_push(&port->port); 280 } 281 282 static void belkin_sa_set_termios(struct tty_struct *tty, 283 struct usb_serial_port *port, struct ktermios *old_termios) 284 { 285 struct usb_serial *serial = port->serial; 286 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 287 unsigned int iflag; 288 unsigned int cflag; 289 unsigned int old_iflag = 0; 290 unsigned int old_cflag = 0; 291 __u16 urb_value = 0; /* Will hold the new flags */ 292 unsigned long flags; 293 unsigned long control_state; 294 int bad_flow_control; 295 speed_t baud; 296 struct ktermios *termios = &tty->termios; 297 298 iflag = termios->c_iflag; 299 cflag = termios->c_cflag; 300 301 termios->c_cflag &= ~CMSPAR; 302 303 /* get a local copy of the current port settings */ 304 spin_lock_irqsave(&priv->lock, flags); 305 control_state = priv->control_state; 306 bad_flow_control = priv->bad_flow_control; 307 spin_unlock_irqrestore(&priv->lock, flags); 308 309 old_iflag = old_termios->c_iflag; 310 old_cflag = old_termios->c_cflag; 311 312 /* Set the baud rate */ 313 if ((cflag & CBAUD) != (old_cflag & CBAUD)) { 314 /* reassert DTR and (maybe) RTS on transition from B0 */ 315 if ((old_cflag & CBAUD) == B0) { 316 control_state |= (TIOCM_DTR|TIOCM_RTS); 317 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) 318 dev_err(&port->dev, "Set DTR error\n"); 319 /* don't set RTS if using hardware flow control */ 320 if (!(old_cflag & CRTSCTS)) 321 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST 322 , 1) < 0) 323 dev_err(&port->dev, "Set RTS error\n"); 324 } 325 } 326 327 baud = tty_get_baud_rate(tty); 328 if (baud) { 329 urb_value = BELKIN_SA_BAUD(baud); 330 /* Clip to maximum speed */ 331 if (urb_value == 0) 332 urb_value = 1; 333 /* Turn it back into a resulting real baud rate */ 334 baud = BELKIN_SA_BAUD(urb_value); 335 336 /* Report the actual baud rate back to the caller */ 337 tty_encode_baud_rate(tty, baud, baud); 338 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) 339 dev_err(&port->dev, "Set baudrate error\n"); 340 } else { 341 /* Disable flow control */ 342 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, 343 BELKIN_SA_FLOW_NONE) < 0) 344 dev_err(&port->dev, "Disable flowcontrol error\n"); 345 /* Drop RTS and DTR */ 346 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 347 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) 348 dev_err(&port->dev, "DTR LOW error\n"); 349 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) 350 dev_err(&port->dev, "RTS LOW error\n"); 351 } 352 353 /* set the parity */ 354 if ((cflag ^ old_cflag) & (PARENB | PARODD)) { 355 if (cflag & PARENB) 356 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD 357 : BELKIN_SA_PARITY_EVEN; 358 else 359 urb_value = BELKIN_SA_PARITY_NONE; 360 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) 361 dev_err(&port->dev, "Set parity error\n"); 362 } 363 364 /* set the number of data bits */ 365 if ((cflag & CSIZE) != (old_cflag & CSIZE)) { 366 switch (cflag & CSIZE) { 367 case CS5: 368 urb_value = BELKIN_SA_DATA_BITS(5); 369 break; 370 case CS6: 371 urb_value = BELKIN_SA_DATA_BITS(6); 372 break; 373 case CS7: 374 urb_value = BELKIN_SA_DATA_BITS(7); 375 break; 376 case CS8: 377 urb_value = BELKIN_SA_DATA_BITS(8); 378 break; 379 default: 380 dev_dbg(&port->dev, 381 "CSIZE was not CS5-CS8, using default of 8\n"); 382 urb_value = BELKIN_SA_DATA_BITS(8); 383 break; 384 } 385 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) 386 dev_err(&port->dev, "Set data bits error\n"); 387 } 388 389 /* set the number of stop bits */ 390 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { 391 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) 392 : BELKIN_SA_STOP_BITS(1); 393 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, 394 urb_value) < 0) 395 dev_err(&port->dev, "Set stop bits error\n"); 396 } 397 398 /* Set flow control */ 399 if (((iflag ^ old_iflag) & (IXOFF | IXON)) || 400 ((cflag ^ old_cflag) & CRTSCTS)) { 401 urb_value = 0; 402 if ((iflag & IXOFF) || (iflag & IXON)) 403 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 404 else 405 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 406 407 if (cflag & CRTSCTS) 408 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 409 else 410 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 411 412 if (bad_flow_control) 413 urb_value &= ~(BELKIN_SA_FLOW_IRTS); 414 415 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) 416 dev_err(&port->dev, "Set flow control error\n"); 417 } 418 419 /* save off the modified port settings */ 420 spin_lock_irqsave(&priv->lock, flags); 421 priv->control_state = control_state; 422 spin_unlock_irqrestore(&priv->lock, flags); 423 } 424 425 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) 426 { 427 struct usb_serial_port *port = tty->driver_data; 428 struct usb_serial *serial = port->serial; 429 430 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) 431 dev_err(&port->dev, "Set break_ctl %d\n", break_state); 432 } 433 434 static int belkin_sa_tiocmget(struct tty_struct *tty) 435 { 436 struct usb_serial_port *port = tty->driver_data; 437 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 438 unsigned long control_state; 439 unsigned long flags; 440 441 spin_lock_irqsave(&priv->lock, flags); 442 control_state = priv->control_state; 443 spin_unlock_irqrestore(&priv->lock, flags); 444 445 return control_state; 446 } 447 448 static int belkin_sa_tiocmset(struct tty_struct *tty, 449 unsigned int set, unsigned int clear) 450 { 451 struct usb_serial_port *port = tty->driver_data; 452 struct usb_serial *serial = port->serial; 453 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 454 unsigned long control_state; 455 unsigned long flags; 456 int retval; 457 int rts = 0; 458 int dtr = 0; 459 460 spin_lock_irqsave(&priv->lock, flags); 461 control_state = priv->control_state; 462 463 if (set & TIOCM_RTS) { 464 control_state |= TIOCM_RTS; 465 rts = 1; 466 } 467 if (set & TIOCM_DTR) { 468 control_state |= TIOCM_DTR; 469 dtr = 1; 470 } 471 if (clear & TIOCM_RTS) { 472 control_state &= ~TIOCM_RTS; 473 rts = 0; 474 } 475 if (clear & TIOCM_DTR) { 476 control_state &= ~TIOCM_DTR; 477 dtr = 0; 478 } 479 480 priv->control_state = control_state; 481 spin_unlock_irqrestore(&priv->lock, flags); 482 483 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); 484 if (retval < 0) { 485 dev_err(&port->dev, "Set RTS error %d\n", retval); 486 goto exit; 487 } 488 489 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); 490 if (retval < 0) { 491 dev_err(&port->dev, "Set DTR error %d\n", retval); 492 goto exit; 493 } 494 exit: 495 return retval; 496 } 497 498 module_usb_serial_driver(serial_drivers, id_table); 499 500 MODULE_AUTHOR(DRIVER_AUTHOR); 501 MODULE_DESCRIPTION(DRIVER_DESC); 502 MODULE_LICENSE("GPL"); 503