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 struct tty_struct *tty; 246 unsigned char *data = urb->transfer_buffer; 247 unsigned long flags; 248 unsigned char status; 249 char tty_flag; 250 251 /* Update line status */ 252 tty_flag = TTY_NORMAL; 253 254 spin_lock_irqsave(&priv->lock, flags); 255 status = priv->last_lsr; 256 priv->last_lsr &= ~BELKIN_SA_LSR_ERR; 257 spin_unlock_irqrestore(&priv->lock, flags); 258 259 if (!urb->actual_length) 260 return; 261 262 tty = tty_port_tty_get(&port->port); 263 if (!tty) 264 return; 265 266 if (status & BELKIN_SA_LSR_ERR) { 267 /* Break takes precedence over parity, which takes precedence 268 * over framing errors. */ 269 if (status & BELKIN_SA_LSR_BI) 270 tty_flag = TTY_BREAK; 271 else if (status & BELKIN_SA_LSR_PE) 272 tty_flag = TTY_PARITY; 273 else if (status & BELKIN_SA_LSR_FE) 274 tty_flag = TTY_FRAME; 275 dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); 276 277 /* Overrun is special, not associated with a char. */ 278 if (status & BELKIN_SA_LSR_OE) 279 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 280 } 281 282 tty_insert_flip_string_fixed_flag(tty, data, tty_flag, 283 urb->actual_length); 284 tty_flip_buffer_push(tty); 285 tty_kref_put(tty); 286 } 287 288 static void belkin_sa_set_termios(struct tty_struct *tty, 289 struct usb_serial_port *port, struct ktermios *old_termios) 290 { 291 struct usb_serial *serial = port->serial; 292 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 293 unsigned int iflag; 294 unsigned int cflag; 295 unsigned int old_iflag = 0; 296 unsigned int old_cflag = 0; 297 __u16 urb_value = 0; /* Will hold the new flags */ 298 unsigned long flags; 299 unsigned long control_state; 300 int bad_flow_control; 301 speed_t baud; 302 struct ktermios *termios = &tty->termios; 303 304 iflag = termios->c_iflag; 305 cflag = termios->c_cflag; 306 307 termios->c_cflag &= ~CMSPAR; 308 309 /* get a local copy of the current port settings */ 310 spin_lock_irqsave(&priv->lock, flags); 311 control_state = priv->control_state; 312 bad_flow_control = priv->bad_flow_control; 313 spin_unlock_irqrestore(&priv->lock, flags); 314 315 old_iflag = old_termios->c_iflag; 316 old_cflag = old_termios->c_cflag; 317 318 /* Set the baud rate */ 319 if ((cflag & CBAUD) != (old_cflag & CBAUD)) { 320 /* reassert DTR and (maybe) RTS on transition from B0 */ 321 if ((old_cflag & CBAUD) == B0) { 322 control_state |= (TIOCM_DTR|TIOCM_RTS); 323 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) 324 dev_err(&port->dev, "Set DTR error\n"); 325 /* don't set RTS if using hardware flow control */ 326 if (!(old_cflag & CRTSCTS)) 327 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST 328 , 1) < 0) 329 dev_err(&port->dev, "Set RTS error\n"); 330 } 331 } 332 333 baud = tty_get_baud_rate(tty); 334 if (baud) { 335 urb_value = BELKIN_SA_BAUD(baud); 336 /* Clip to maximum speed */ 337 if (urb_value == 0) 338 urb_value = 1; 339 /* Turn it back into a resulting real baud rate */ 340 baud = BELKIN_SA_BAUD(urb_value); 341 342 /* Report the actual baud rate back to the caller */ 343 tty_encode_baud_rate(tty, baud, baud); 344 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) 345 dev_err(&port->dev, "Set baudrate error\n"); 346 } else { 347 /* Disable flow control */ 348 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, 349 BELKIN_SA_FLOW_NONE) < 0) 350 dev_err(&port->dev, "Disable flowcontrol error\n"); 351 /* Drop RTS and DTR */ 352 control_state &= ~(TIOCM_DTR | TIOCM_RTS); 353 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) 354 dev_err(&port->dev, "DTR LOW error\n"); 355 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) 356 dev_err(&port->dev, "RTS LOW error\n"); 357 } 358 359 /* set the parity */ 360 if ((cflag ^ old_cflag) & (PARENB | PARODD)) { 361 if (cflag & PARENB) 362 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD 363 : BELKIN_SA_PARITY_EVEN; 364 else 365 urb_value = BELKIN_SA_PARITY_NONE; 366 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) 367 dev_err(&port->dev, "Set parity error\n"); 368 } 369 370 /* set the number of data bits */ 371 if ((cflag & CSIZE) != (old_cflag & CSIZE)) { 372 switch (cflag & CSIZE) { 373 case CS5: 374 urb_value = BELKIN_SA_DATA_BITS(5); 375 break; 376 case CS6: 377 urb_value = BELKIN_SA_DATA_BITS(6); 378 break; 379 case CS7: 380 urb_value = BELKIN_SA_DATA_BITS(7); 381 break; 382 case CS8: 383 urb_value = BELKIN_SA_DATA_BITS(8); 384 break; 385 default: 386 dev_dbg(&port->dev, 387 "CSIZE was not CS5-CS8, using default of 8\n"); 388 urb_value = BELKIN_SA_DATA_BITS(8); 389 break; 390 } 391 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) 392 dev_err(&port->dev, "Set data bits error\n"); 393 } 394 395 /* set the number of stop bits */ 396 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { 397 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) 398 : BELKIN_SA_STOP_BITS(1); 399 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, 400 urb_value) < 0) 401 dev_err(&port->dev, "Set stop bits error\n"); 402 } 403 404 /* Set flow control */ 405 if (((iflag ^ old_iflag) & (IXOFF | IXON)) || 406 ((cflag ^ old_cflag) & CRTSCTS)) { 407 urb_value = 0; 408 if ((iflag & IXOFF) || (iflag & IXON)) 409 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 410 else 411 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); 412 413 if (cflag & CRTSCTS) 414 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 415 else 416 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); 417 418 if (bad_flow_control) 419 urb_value &= ~(BELKIN_SA_FLOW_IRTS); 420 421 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) 422 dev_err(&port->dev, "Set flow control error\n"); 423 } 424 425 /* save off the modified port settings */ 426 spin_lock_irqsave(&priv->lock, flags); 427 priv->control_state = control_state; 428 spin_unlock_irqrestore(&priv->lock, flags); 429 } 430 431 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) 432 { 433 struct usb_serial_port *port = tty->driver_data; 434 struct usb_serial *serial = port->serial; 435 436 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) 437 dev_err(&port->dev, "Set break_ctl %d\n", break_state); 438 } 439 440 static int belkin_sa_tiocmget(struct tty_struct *tty) 441 { 442 struct usb_serial_port *port = tty->driver_data; 443 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 444 unsigned long control_state; 445 unsigned long flags; 446 447 spin_lock_irqsave(&priv->lock, flags); 448 control_state = priv->control_state; 449 spin_unlock_irqrestore(&priv->lock, flags); 450 451 return control_state; 452 } 453 454 static int belkin_sa_tiocmset(struct tty_struct *tty, 455 unsigned int set, unsigned int clear) 456 { 457 struct usb_serial_port *port = tty->driver_data; 458 struct usb_serial *serial = port->serial; 459 struct belkin_sa_private *priv = usb_get_serial_port_data(port); 460 unsigned long control_state; 461 unsigned long flags; 462 int retval; 463 int rts = 0; 464 int dtr = 0; 465 466 spin_lock_irqsave(&priv->lock, flags); 467 control_state = priv->control_state; 468 469 if (set & TIOCM_RTS) { 470 control_state |= TIOCM_RTS; 471 rts = 1; 472 } 473 if (set & TIOCM_DTR) { 474 control_state |= TIOCM_DTR; 475 dtr = 1; 476 } 477 if (clear & TIOCM_RTS) { 478 control_state &= ~TIOCM_RTS; 479 rts = 0; 480 } 481 if (clear & TIOCM_DTR) { 482 control_state &= ~TIOCM_DTR; 483 dtr = 0; 484 } 485 486 priv->control_state = control_state; 487 spin_unlock_irqrestore(&priv->lock, flags); 488 489 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); 490 if (retval < 0) { 491 dev_err(&port->dev, "Set RTS error %d\n", retval); 492 goto exit; 493 } 494 495 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); 496 if (retval < 0) { 497 dev_err(&port->dev, "Set DTR error %d\n", retval); 498 goto exit; 499 } 500 exit: 501 return retval; 502 } 503 504 module_usb_serial_driver(serial_drivers, id_table); 505 506 MODULE_AUTHOR(DRIVER_AUTHOR); 507 MODULE_DESCRIPTION(DRIVER_DESC); 508 MODULE_LICENSE("GPL"); 509