drivers/usb/serial/mct_u232.c

   1 /*
   2  * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
   3  *
   4  *   Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  * This program is largely derived from the Belkin USB Serial Adapter Driver
  12  * (see belkin_sa.[ch]). All of the information about the device was acquired
  13  * by using SniffUSB on Windows98. For technical details see mct_u232.h.
  14  *
  15  * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
  16  * do the reverse engineering and how to write a USB serial device driver.
  17  *
  18  * TO BE DONE, TO BE CHECKED:
  19  *   DTR/RTS signal handling may be incomplete or incorrect. I have mainly
  20  *   implemented what I have seen with SniffUSB or found in belkin_sa.c.
  21  *   For further TODOs check also belkin_sa.c.
  22  *
  23  * TEST STATUS:
  24  *   Basic tests have been performed with minicom/zmodem transfers and
  25  *   modem dialing under Linux 2.4.0-test10 (for me it works fine).
  26  *
  27  * 04-Nov-2003 Bill Marr <marr at flex dot com>
  28  *   - Mimic Windows driver by sending 2 USB 'device request' messages
  29  *     following normal 'baud rate change' message.  This allows data to be
  30  *     transmitted to RS-232 devices which don't assert the 'CTS' signal.
  31  *
  32  * 10-Nov-2001 Wolfgang Grandegger
  33  *   - Fixed an endianess problem with the baudrate selection for PowerPC.
  34  *
  35  * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
  36  *   - Added support for the Belkin F5U109 DB9 adaptor
  37  *
  38  * 30-May-2001 Greg Kroah-Hartman
  39  *   - switched from using spinlock to a semaphore, which fixes lots of
  40  *     problems.
  41  *
  42  * 04-May-2001 Stelian Pop
  43  *   - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
  44  *     instead of the device reported 32 (using 32 bytes causes many data
  45  *     loss, Windows driver uses 16 too).
  46  *
  47  * 02-May-2001 Stelian Pop
  48  *   - Fixed the baud calculation for Sitecom U232-P25 model
  49  *
  50  * 08-Apr-2001 gb
  51  *   - Identify version on module load.
  52  *
  53  * 06-Jan-2001 Cornel Ciocirlan
  54  *   - Added support for Sitecom U232-P25 model (Product Id 0x0230)
  55  *   - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
  56  *
  57  * 29-Nov-2000 Greg Kroah-Hartman
  58  *   - Added device id table to fit with 2.4.0-test11 structure.
  59  *   - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
  60  *     (lots of things will change if/when the usb-serial core changes to
  61  *     handle these issues.
  62  *
  63  * 27-Nov-2000 Wolfgang Grandegge
  64  *   A version for kernel 2.4.0-test10 released to the Linux community
  65  *   (via linux-usb-devel).
  66  */
  67
  68 #include <linux/kernel.h>
  69 #include <linux/errno.h>
  70 #include <linux/init.h>
  71 #include <linux/slab.h>
  72 #include <linux/tty.h>
  73 #include <linux/tty_driver.h>
  74 #include <linux/tty_flip.h>
  75 #include <linux/module.h>
  76 #include <linux/spinlock.h>
  77 #include <linux/uaccess.h>
  78 #include <linux/usb.h>
  79 #include <linux/usb/serial.h>
  80 #include "mct_u232.h"
  81
  82 /*
  83  * Version Information
  84  */
  85 #define DRIVER_VERSION "z2.1"           /* Linux in-kernel version */
  86 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
  87 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
  88
  89 static int debug;
  90
  91 /*
  92  * Function prototypes
  93  */
  94 static int  mct_u232_startup(struct usb_serial *serial);
  95 static void mct_u232_shutdown(struct usb_serial *serial);
  96 static int  mct_u232_open(struct tty_struct *tty,
  97                         struct usb_serial_port *port, struct file *filp);
  98 static void mct_u232_close(struct usb_serial_port *port);
  99 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
 100 static void mct_u232_read_int_callback(struct urb *urb);
 101 static void mct_u232_set_termios(struct tty_struct *tty,
 102                         struct usb_serial_port *port, struct ktermios *old);
 103 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
 104 static int  mct_u232_tiocmget(struct tty_struct *tty, struct file *file);
 105 static int  mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
 106                         unsigned int set, unsigned int clear);
 107 static void mct_u232_throttle(struct tty_struct *tty);
 108 static void mct_u232_unthrottle(struct tty_struct *tty);
 109
 110
 111 /*
 112  * All of the device info needed for the MCT USB-RS232 converter.
 113  */
 114 static struct usb_device_id id_table_combined [] = {
 115         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
 116         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
 117         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
 118         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
 119         { }             /* Terminating entry */
 120 };
 121
 122 MODULE_DEVICE_TABLE(usb, id_table_combined);
 123
 124 static struct usb_driver mct_u232_driver = {
 125         .name =         "mct_u232",
 126         .probe =        usb_serial_probe,
 127         .disconnect =   usb_serial_disconnect,
 128         .id_table =     id_table_combined,
 129         .no_dynamic_id =        1,
 130 };
 131
 132 static struct usb_serial_driver mct_u232_device = {
 133         .driver = {
 134                 .owner =        THIS_MODULE,
 135                 .name =         "mct_u232",
 136         },
 137         .description =       "MCT U232",
 138         .usb_driver =        &mct_u232_driver,
 139         .id_table =          id_table_combined,
 140         .num_ports =         1,
 141         .open =              mct_u232_open,
 142         .close =             mct_u232_close,
 143         .dtr_rts =           mct_u232_dtr_rts,
 144         .throttle =          mct_u232_throttle,
 145         .unthrottle =        mct_u232_unthrottle,
 146         .read_int_callback = mct_u232_read_int_callback,
 147         .set_termios =       mct_u232_set_termios,
 148         .break_ctl =         mct_u232_break_ctl,
 149         .tiocmget =          mct_u232_tiocmget,
 150         .tiocmset =          mct_u232_tiocmset,
 151         .attach =            mct_u232_startup,
 152         .shutdown =          mct_u232_shutdown,
 153 };
 154
 155
 156 struct mct_u232_private {
 157         spinlock_t lock;
 158         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
 159         unsigned char        last_lcr;      /* Line Control Register */
 160         unsigned char        last_lsr;      /* Line Status Register */
 161         unsigned char        last_msr;      /* Modem Status Register */
 162         unsigned int         rx_flags;      /* Throttling flags */
 163 };
 164
 165 #define THROTTLED               0x01
 166
 167 /*
 168  * Handle vendor specific USB requests
 169  */
 170
 171 #define WDR_TIMEOUT 5000 /* default urb timeout */
 172
 173 /*
 174  * Later day 2.6.0-test kernels have new baud rates like B230400 which
 175  * we do not know how to support. We ignore them for the moment.
 176  */
 177 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
 178                                         speed_t value, speed_t *result)
 179 {
 180         *result = value;
 181
 182         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
 183                 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
 184                 switch (value) {
 185                 case 300:
 186                         return 0x01;
 187                 case 600:
 188                         return 0x02; /* this one not tested */
 189                 case 1200:
 190                         return 0x03;
 191                 case 2400:
 192                         return 0x04;
 193                 case 4800:
 194                         return 0x06;
 195                 case 9600:
 196                         return 0x08;
 197                 case 19200:
 198                         return 0x09;
 199                 case 38400:
 200                         return 0x0a;
 201                 case 57600:
 202                         return 0x0b;
 203                 case 115200:
 204                         return 0x0c;
 205                 default:
 206                         *result = 9600;
 207                         return 0x08;
 208                 }
 209         } else {
 210                 /* FIXME: Can we use any divider - should we do
 211                    divider = 115200/value;
 212                    real baud = 115200/divider */
 213                 switch (value) {
 214                 case 300: break;
 215                 case 600: break;
 216                 case 1200: break;
 217                 case 2400: break;
 218                 case 4800: break;
 219                 case 9600: break;
 220                 case 19200: break;
 221                 case 38400: break;
 222                 case 57600: break;
 223                 case 115200: break;
 224                 default:
 225                         value = 9600;
 226                         *result = 9600;
 227                 }
 228                 return 115200/value;
 229         }
 230 }
 231
 232 static int mct_u232_set_baud_rate(struct tty_struct *tty,
 233         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 234 {
 235         __le32 divisor;
 236         int rc;
 237         unsigned char zero_byte = 0;
 238         unsigned char cts_enable_byte = 0;
 239         speed_t speed;
 240
 241         divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value,
 242                                                                 &speed));
 243
 244         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 245                                 MCT_U232_SET_BAUD_RATE_REQUEST,
 246                                 MCT_U232_SET_REQUEST_TYPE,
 247                                 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
 248                                 WDR_TIMEOUT);
 249         if (rc < 0)     /*FIXME: What value speed results */
 250                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
 251                         value, rc);
 252         else
 253                 tty_encode_baud_rate(tty, speed, speed);
 254         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
 255
 256         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
 257            always sends two extra USB 'device request' messages after the
 258            'baud rate change' message.  The actual functionality of the
 259            request codes in these messages is not fully understood but these
 260            particular codes are never seen in any operation besides a baud
 261            rate change.  Both of these messages send a single byte of data.
 262            In the first message, the value of this byte is always zero.
 263
 264            The second message has been determined experimentally to control
 265            whether data will be transmitted to a device which is not asserting
 266            the 'CTS' signal.  If the second message's data byte is zero, data
 267            will be transmitted even if 'CTS' is not asserted (i.e. no hardware
 268            flow control).  if the second message's data byte is nonzero (a
 269            value of 1 is used by this driver), data will not be transmitted to
 270            a device which is not asserting 'CTS'.
 271         */
 272
 273         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 274                                 MCT_U232_SET_UNKNOWN1_REQUEST,
 275                                 MCT_U232_SET_REQUEST_TYPE,
 276                                 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
 277                                 WDR_TIMEOUT);
 278         if (rc < 0)
 279                 dev_err(&port->dev, "Sending USB device request code %d "
 280                         "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
 281                         rc);
 282
 283         if (port && C_CRTSCTS(tty))
 284            cts_enable_byte = 1;
 285
 286         dbg("set_baud_rate: send second control message, data = %02X",
 287                                                         cts_enable_byte);
 288         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 289                         MCT_U232_SET_CTS_REQUEST,
 290                         MCT_U232_SET_REQUEST_TYPE,
 291                         0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
 292                         WDR_TIMEOUT);
 293         if (rc < 0)
 294                 dev_err(&port->dev, "Sending USB device request code %d "
 295                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
 296
 297         return rc;
 298 } /* mct_u232_set_baud_rate */
 299
 300 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
 301 {
 302         int rc;
 303         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 304                         MCT_U232_SET_LINE_CTRL_REQUEST,
 305                         MCT_U232_SET_REQUEST_TYPE,
 306                         0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
 307                         WDR_TIMEOUT);
 308         if (rc < 0)
 309                 dev_err(&serial->dev->dev,
 310                         "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
 311         dbg("set_line_ctrl: 0x%x", lcr);
 312         return rc;
 313 } /* mct_u232_set_line_ctrl */
 314
 315 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
 316                                    unsigned int control_state)
 317 {
 318         int rc;
 319         unsigned char mcr = MCT_U232_MCR_NONE;
 320
 321         if (control_state & TIOCM_DTR)
 322                 mcr |= MCT_U232_MCR_DTR;
 323         if (control_state & TIOCM_RTS)
 324                 mcr |= MCT_U232_MCR_RTS;
 325
 326         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 327                         MCT_U232_SET_MODEM_CTRL_REQUEST,
 328                         MCT_U232_SET_REQUEST_TYPE,
 329                         0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
 330                         WDR_TIMEOUT);
 331         if (rc < 0)
 332                 dev_err(&serial->dev->dev,
 333                         "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
 334         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
 335
 336         return rc;
 337 } /* mct_u232_set_modem_ctrl */
 338
 339 static int mct_u232_get_modem_stat(struct usb_serial *serial,
 340                                                 unsigned char *msr)
 341 {
 342         int rc;
 343         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 344                         MCT_U232_GET_MODEM_STAT_REQUEST,
 345                         MCT_U232_GET_REQUEST_TYPE,
 346                         0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
 347                         WDR_TIMEOUT);
 348         if (rc < 0) {
 349                 dev_err(&serial->dev->dev,
 350                         "Get MODEM STATus failed (error = %d)\n", rc);
 351                 *msr = 0;
 352         }
 353         dbg("get_modem_stat: 0x%x", *msr);
 354         return rc;
 355 } /* mct_u232_get_modem_stat */
 356
 357 static void mct_u232_msr_to_state(unsigned int *control_state,
 358                                                 unsigned char msr)
 359 {
 360         /* Translate Control Line states */
 361         if (msr & MCT_U232_MSR_DSR)
 362                 *control_state |=  TIOCM_DSR;
 363         else
 364                 *control_state &= ~TIOCM_DSR;
 365         if (msr & MCT_U232_MSR_CTS)
 366                 *control_state |=  TIOCM_CTS;
 367         else
 368                 *control_state &= ~TIOCM_CTS;
 369         if (msr & MCT_U232_MSR_RI)
 370                 *control_state |=  TIOCM_RI;
 371         else
 372                 *control_state &= ~TIOCM_RI;
 373         if (msr & MCT_U232_MSR_CD)
 374                 *control_state |=  TIOCM_CD;
 375         else
 376                 *control_state &= ~TIOCM_CD;
 377         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
 378 } /* mct_u232_msr_to_state */
 379
 380 /*
 381  * Driver's tty interface functions
 382  */
 383
 384 static int mct_u232_startup(struct usb_serial *serial)
 385 {
 386         struct mct_u232_private *priv;
 387         struct usb_serial_port *port, *rport;
 388
 389         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 390         if (!priv)
 391                 return -ENOMEM;
 392         spin_lock_init(&priv->lock);
 393         usb_set_serial_port_data(serial->port[0], priv);
 394
 395         init_waitqueue_head(&serial->port[0]->write_wait);
 396
 397         /* Puh, that's dirty */
 398         port = serial->port[0];
 399         rport = serial->port[1];
 400         /* No unlinking, it wasn't submitted yet. */
 401         usb_free_urb(port->read_urb);
 402         port->read_urb = rport->interrupt_in_urb;
 403         rport->interrupt_in_urb = NULL;
 404         port->read_urb->context = port;
 405
 406         return 0;
 407 } /* mct_u232_startup */
 408
 409
 410 static void mct_u232_shutdown(struct usb_serial *serial)
 411 {
 412         struct mct_u232_private *priv;
 413         int i;
 414
 415         dbg("%s", __func__);
 416
 417         for (i = 0; i < serial->num_ports; ++i) {
 418                 /* My special items, the standard routines free my urbs */
 419                 priv = usb_get_serial_port_data(serial->port[i]);
 420                 if (priv) {
 421                         usb_set_serial_port_data(serial->port[i], NULL);
 422                         kfree(priv);
 423                 }
 424         }
 425 } /* mct_u232_shutdown */
 426
 427 static int  mct_u232_open(struct tty_struct *tty,
 428                         struct usb_serial_port *port, struct file *filp)
 429 {
 430         struct usb_serial *serial = port->serial;
 431         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 432         int retval = 0;
 433         unsigned int control_state;
 434         unsigned long flags;
 435         unsigned char last_lcr;
 436         unsigned char last_msr;
 437
 438         dbg("%s port %d", __func__, port->number);
 439
 440         /* Compensate for a hardware bug: although the Sitecom U232-P25
 441          * device reports a maximum output packet size of 32 bytes,
 442          * it seems to be able to accept only 16 bytes (and that's what
 443          * SniffUSB says too...)
 444          */
 445         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 446                                                 == MCT_U232_SITECOM_PID)
 447                 port->bulk_out_size = 16;
 448
 449         /* Do a defined restart: the normal serial device seems to
 450          * always turn on DTR and RTS here, so do the same. I'm not
 451          * sure if this is really necessary. But it should not harm
 452          * either.
 453          */
 454         spin_lock_irqsave(&priv->lock, flags);
 455         if (tty && (tty->termios->c_cflag & CBAUD))
 456                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 457         else
 458                 priv->control_state = 0;
 459
 460         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 461                           MCT_U232_PARITY_NONE |
 462                           MCT_U232_STOP_BITS_1);
 463         control_state = priv->control_state;
 464         last_lcr = priv->last_lcr;
 465         spin_unlock_irqrestore(&priv->lock, flags);
 466         mct_u232_set_modem_ctrl(serial, control_state);
 467         mct_u232_set_line_ctrl(serial, last_lcr);
 468
 469         /* Read modem status and update control state */
 470         mct_u232_get_modem_stat(serial, &last_msr);
 471         spin_lock_irqsave(&priv->lock, flags);
 472         priv->last_msr = last_msr;
 473         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 474         spin_unlock_irqrestore(&priv->lock, flags);
 475
 476         port->read_urb->dev = port->serial->dev;
 477         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 478         if (retval) {
 479                 dev_err(&port->dev,
 480                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 481                         port->read_urb->pipe, retval);
 482                 goto error;
 483         }
 484
 485         port->interrupt_in_urb->dev = port->serial->dev;
 486         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 487         if (retval) {
 488                 usb_kill_urb(port->read_urb);
 489                 dev_err(&port->dev,
 490                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 491                         port->interrupt_in_urb->pipe, retval);
 492                 goto error;
 493         }
 494         return 0;
 495
 496 error:
 497         return retval;
 498 } /* mct_u232_open */
 499
 500 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 501 {
 502         unsigned int control_state;
 503         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 504
 505         mutex_lock(&port->serial->disc_mutex);
 506         if (!port->serial->disconnected) {
 507                 /* drop DTR and RTS */
 508                 spin_lock_irq(&priv->lock);
 509                 if (on)
 510                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 511                 else
 512                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 513                 control_state = priv->control_state;
 514                 spin_unlock_irq(&priv->lock);
 515                 mct_u232_set_modem_ctrl(port->serial, control_state);
 516         }
 517         mutex_unlock(&port->serial->disc_mutex);
 518 }
 519
 520 static void mct_u232_close(struct usb_serial_port *port)
 521 {
 522         dbg("%s port %d", __func__, port->number);
 523
 524         if (port->serial->dev) {
 525                 /* shutdown our urbs */
 526                 usb_kill_urb(port->write_urb);
 527                 usb_kill_urb(port->read_urb);
 528                 usb_kill_urb(port->interrupt_in_urb);
 529         }
 530 } /* mct_u232_close */
 531
 532
 533 static void mct_u232_read_int_callback(struct urb *urb)
 534 {
 535         struct usb_serial_port *port = urb->context;
 536         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 537         struct usb_serial *serial = port->serial;
 538         struct tty_struct *tty;
 539         unsigned char *data = urb->transfer_buffer;
 540         int retval;
 541         int status = urb->status;
 542         unsigned long flags;
 543
 544         switch (status) {
 545         case 0:
 546                 /* success */
 547                 break;
 548         case -ECONNRESET:
 549         case -ENOENT:
 550         case -ESHUTDOWN:
 551                 /* this urb is terminated, clean up */
 552                 dbg("%s - urb shutting down with status: %d",
 553                     __func__, status);
 554                 return;
 555         default:
 556                 dbg("%s - nonzero urb status received: %d",
 557                     __func__, status);
 558                 goto exit;
 559         }
 560
 561         if (!serial) {
 562                 dbg("%s - bad serial pointer, exiting", __func__);
 563                 return;
 564         }
 565
 566         dbg("%s - port %d", __func__, port->number);
 567         usb_serial_debug_data(debug, &port->dev, __func__,
 568                                         urb->actual_length, data);
 569
 570         /*
 571          * Work-a-round: handle the 'usual' bulk-in pipe here
 572          */
 573         if (urb->transfer_buffer_length > 2) {
 574                 tty = tty_port_tty_get(&port->port);
 575                 if (urb->actual_length) {
 576                         tty_insert_flip_string(tty, data, urb->actual_length);
 577                         tty_flip_buffer_push(tty);
 578                         tty_kref_put(tty);
 579                 }
 580                 goto exit;
 581         }
 582
 583         /*
 584          * The interrupt-in pipe signals exceptional conditions (modem line
 585          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 586          */
 587         spin_lock_irqsave(&priv->lock, flags);
 588         priv->last_msr = data[MCT_U232_MSR_INDEX];
 589
 590         /* Record Control Line states */
 591         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 592
 593 #if 0
 594         /* Not yet handled. See belkin_sa.c for further information */
 595         /* Now to report any errors */
 596         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 597         /*
 598          * fill in the flip buffer here, but I do not know the relation
 599          * to the current/next receive buffer or characters.  I need
 600          * to look in to this before committing any code.
 601          */
 602         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 603                 tty = tty_port_tty_get(&port->port);
 604                 /* Overrun Error */
 605                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 606                 }
 607                 /* Parity Error */
 608                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 609                 }
 610                 /* Framing Error */
 611                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 612                 }
 613                 /* Break Indicator */
 614                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 615                 }
 616                 tty_kref_put(tty);
 617         }
 618 #endif
 619         spin_unlock_irqrestore(&priv->lock, flags);
 620 exit:
 621         retval = usb_submit_urb(urb, GFP_ATOMIC);
 622         if (retval)
 623                 dev_err(&port->dev,
 624                         "%s - usb_submit_urb failed with result %d\n",
 625                         __func__, retval);
 626 } /* mct_u232_read_int_callback */
 627
 628 static void mct_u232_set_termios(struct tty_struct *tty,
 629                                  struct usb_serial_port *port,
 630                                  struct ktermios *old_termios)
 631 {
 632         struct usb_serial *serial = port->serial;
 633         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 634         struct ktermios *termios = tty->termios;
 635         unsigned int cflag = termios->c_cflag;
 636         unsigned int old_cflag = old_termios->c_cflag;
 637         unsigned long flags;
 638         unsigned int control_state;
 639         unsigned char last_lcr;
 640
 641         /* get a local copy of the current port settings */
 642         spin_lock_irqsave(&priv->lock, flags);
 643         control_state = priv->control_state;
 644         spin_unlock_irqrestore(&priv->lock, flags);
 645         last_lcr = 0;
 646
 647         /*
 648          * Update baud rate.
 649          * Do not attempt to cache old rates and skip settings,
 650          * disconnects screw such tricks up completely.
 651          * Premature optimization is the root of all evil.
 652          */
 653
 654         /* reassert DTR and RTS on transition from B0 */
 655         if ((old_cflag & CBAUD) == B0) {
 656                 dbg("%s: baud was B0", __func__);
 657                 control_state |= TIOCM_DTR | TIOCM_RTS;
 658                 mct_u232_set_modem_ctrl(serial, control_state);
 659         }
 660
 661         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 662
 663         if ((cflag & CBAUD) == B0) {
 664                 dbg("%s: baud is B0", __func__);
 665                 /* Drop RTS and DTR */
 666                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 667                 mct_u232_set_modem_ctrl(serial, control_state);
 668         }
 669
 670         /*
 671          * Update line control register (LCR)
 672          */
 673
 674         /* set the parity */
 675         if (cflag & PARENB)
 676                 last_lcr |= (cflag & PARODD) ?
 677                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 678         else
 679                 last_lcr |= MCT_U232_PARITY_NONE;
 680
 681         /* set the number of data bits */
 682         switch (cflag & CSIZE) {
 683         case CS5:
 684                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 685         case CS6:
 686                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 687         case CS7:
 688                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 689         case CS8:
 690                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 691         default:
 692                 dev_err(&port->dev,
 693                         "CSIZE was not CS5-CS8, using default of 8\n");
 694                 last_lcr |= MCT_U232_DATA_BITS_8;
 695                 break;
 696         }
 697
 698         termios->c_cflag &= ~CMSPAR;
 699
 700         /* set the number of stop bits */
 701         last_lcr |= (cflag & CSTOPB) ?
 702                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 703
 704         mct_u232_set_line_ctrl(serial, last_lcr);
 705
 706         /* save off the modified port settings */
 707         spin_lock_irqsave(&priv->lock, flags);
 708         priv->control_state = control_state;
 709         priv->last_lcr = last_lcr;
 710         spin_unlock_irqrestore(&priv->lock, flags);
 711 } /* mct_u232_set_termios */
 712
 713 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 714 {
 715         struct usb_serial_port *port = tty->driver_data;
 716         struct usb_serial *serial = port->serial;
 717         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 718         unsigned char lcr;
 719         unsigned long flags;
 720
 721         dbg("%sstate=%d", __func__, break_state);
 722
 723         spin_lock_irqsave(&priv->lock, flags);
 724         lcr = priv->last_lcr;
 725
 726         if (break_state)
 727                 lcr |= MCT_U232_SET_BREAK;
 728         spin_unlock_irqrestore(&priv->lock, flags);
 729
 730         mct_u232_set_line_ctrl(serial, lcr);
 731 } /* mct_u232_break_ctl */
 732
 733
 734 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
 735 {
 736         struct usb_serial_port *port = tty->driver_data;
 737         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 738         unsigned int control_state;
 739         unsigned long flags;
 740
 741         dbg("%s", __func__);
 742
 743         spin_lock_irqsave(&priv->lock, flags);
 744         control_state = priv->control_state;
 745         spin_unlock_irqrestore(&priv->lock, flags);
 746
 747         return control_state;
 748 }
 749
 750 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
 751                               unsigned int set, unsigned int clear)
 752 {
 753         struct usb_serial_port *port = tty->driver_data;
 754         struct usb_serial *serial = port->serial;
 755         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 756         unsigned int control_state;
 757         unsigned long flags;
 758
 759         dbg("%s", __func__);
 760
 761         spin_lock_irqsave(&priv->lock, flags);
 762         control_state = priv->control_state;
 763
 764         if (set & TIOCM_RTS)
 765                 control_state |= TIOCM_RTS;
 766         if (set & TIOCM_DTR)
 767                 control_state |= TIOCM_DTR;
 768         if (clear & TIOCM_RTS)
 769                 control_state &= ~TIOCM_RTS;
 770         if (clear & TIOCM_DTR)
 771                 control_state &= ~TIOCM_DTR;
 772
 773         priv->control_state = control_state;
 774         spin_unlock_irqrestore(&priv->lock, flags);
 775         return mct_u232_set_modem_ctrl(serial, control_state);
 776 }
 777
 778 static void mct_u232_throttle(struct tty_struct *tty)
 779 {
 780         struct usb_serial_port *port = tty->driver_data;
 781         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 782         unsigned long flags;
 783         unsigned int control_state;
 784
 785         dbg("%s - port %d", __func__, port->number);
 786
 787         spin_lock_irqsave(&priv->lock, flags);
 788         priv->rx_flags |= THROTTLED;
 789         if (C_CRTSCTS(tty)) {
 790                 priv->control_state &= ~TIOCM_RTS;
 791                 control_state = priv->control_state;
 792                 spin_unlock_irqrestore(&priv->lock, flags);
 793                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 794         } else {
 795                 spin_unlock_irqrestore(&priv->lock, flags);
 796         }
 797 }
 798
 799
 800 static void mct_u232_unthrottle(struct tty_struct *tty)
 801 {
 802         struct usb_serial_port *port = tty->driver_data;
 803         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 804         unsigned long flags;
 805         unsigned int control_state;
 806
 807         dbg("%s - port %d", __func__, port->number);
 808
 809         spin_lock_irqsave(&priv->lock, flags);
 810         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 811                 priv->rx_flags &= ~THROTTLED;
 812                 priv->control_state |= TIOCM_RTS;
 813                 control_state = priv->control_state;
 814                 spin_unlock_irqrestore(&priv->lock, flags);
 815                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 816         } else {
 817                 spin_unlock_irqrestore(&priv->lock, flags);
 818         }
 819 }
 820
 821 static int __init mct_u232_init(void)
 822 {
 823         int retval;
 824         retval = usb_serial_register(&mct_u232_device);
 825         if (retval)
 826                 goto failed_usb_serial_register;
 827         retval = usb_register(&mct_u232_driver);
 828         if (retval)
 829                 goto failed_usb_register;
 830         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 831                DRIVER_DESC "\n");
 832         return 0;
 833 failed_usb_register:
 834         usb_serial_deregister(&mct_u232_device);
 835 failed_usb_serial_register:
 836         return retval;
 837 }
 838
 839
 840 static void __exit mct_u232_exit(void)
 841 {
 842         usb_deregister(&mct_u232_driver);
 843         usb_serial_deregister(&mct_u232_device);
 844 }
 845
 846 module_init(mct_u232_init);
 847 module_exit(mct_u232_exit);
 848
 849 MODULE_AUTHOR(DRIVER_AUTHOR);
 850 MODULE_DESCRIPTION(DRIVER_DESC);
 851 MODULE_LICENSE("GPL");
 852
 853 module_param(debug, bool, S_IRUGO | S_IWUSR);
 854 MODULE_PARM_DESC(debug, "Debug enabled or not");