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