drivers/usb/serial/belkin_sa.c

   1 /*
   2  * Belkin USB Serial Adapter Driver
   3  *
   4  *  Copyright (C) 2000          William Greathouse ([email protected])
   5  *  Copyright (C) 2000-2001     Greg Kroah-Hartman ([email protected])
   6  *  Copyright (C) 2010          Johan Hovold ([email protected])
   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 <[email protected]>"
  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");