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