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