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/config.h>
  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 <asm/uaccess.h>
  78 #include <linux/usb.h>
  79 #include "usb-serial.h"
  80 #include "mct_u232.h"
  81
  82 /*
  83  * Version Information
  84  */
  85 #define DRIVER_VERSION "z2.0"           /* 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 usb_serial_port *port,
  97                                           struct file *filp);
  98 static void mct_u232_close               (struct usb_serial_port *port,
  99                                           struct file *filp);
 100 static void mct_u232_read_int_callback   (struct urb *urb, struct pt_regs *regs);
 101 static void mct_u232_set_termios         (struct usb_serial_port *port,
 102                                           struct termios * old);
 103 static int  mct_u232_ioctl               (struct usb_serial_port *port,
 104                                           struct file * file,
 105                                           unsigned int cmd,
 106                                           unsigned long arg);
 107 static void mct_u232_break_ctl           (struct usb_serial_port *port,
 108                                           int break_state );
 109 static int  mct_u232_tiocmget            (struct usb_serial_port *port,
 110                                           struct file *file);
 111 static int  mct_u232_tiocmset            (struct usb_serial_port *port,
 112                                           struct file *file, unsigned int set,
 113                                           unsigned int clear);
 114 /*
 115  * All of the device info needed for the MCT USB-RS232 converter.
 116  */
 117 static struct usb_device_id id_table_combined [] = {
 118         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
 119         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
 120         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
 121         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
 122         { }             /* Terminating entry */
 123 };
 124
 125 MODULE_DEVICE_TABLE (usb, id_table_combined);
 126
 127 static struct usb_driver mct_u232_driver = {
 128         .name =         "mct_u232",
 129         .probe =        usb_serial_probe,
 130         .disconnect =   usb_serial_disconnect,
 131         .id_table =     id_table_combined,
 132         .no_dynamic_id =        1,
 133 };
 134
 135 static struct usb_serial_driver mct_u232_device = {
 136         .driver = {
 137                 .owner =        THIS_MODULE,
 138                 .name =         "mct_u232",
 139         },
 140         .description =       "MCT U232",
 141         .id_table =          id_table_combined,
 142         .num_interrupt_in =  2,
 143         .num_bulk_in =       0,
 144         .num_bulk_out =      1,
 145         .num_ports =         1,
 146         .open =              mct_u232_open,
 147         .close =             mct_u232_close,
 148         .read_int_callback = mct_u232_read_int_callback,
 149         .ioctl =             mct_u232_ioctl,
 150         .set_termios =       mct_u232_set_termios,
 151         .break_ctl =         mct_u232_break_ctl,
 152         .tiocmget =          mct_u232_tiocmget,
 153         .tiocmset =          mct_u232_tiocmset,
 154         .attach =            mct_u232_startup,
 155         .shutdown =          mct_u232_shutdown,
 156 };
 157
 158
 159 struct mct_u232_private {
 160         spinlock_t lock;
 161         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
 162         unsigned char        last_lcr;      /* Line Control Register */
 163         unsigned char        last_lsr;      /* Line Status Register */
 164         unsigned char        last_msr;      /* Modem Status Register */
 165 };
 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  * XXX Rate-limit the error message, it's user triggerable.
 177  */
 178 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value)
 179 {
 180         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
 181           || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
 182                 switch (value) {
 183                 case    B300: return 0x01;
 184                 case    B600: return 0x02; /* this one not tested */
 185                 case   B1200: return 0x03;
 186                 case   B2400: return 0x04;
 187                 case   B4800: return 0x06;
 188                 case   B9600: return 0x08;
 189                 case  B19200: return 0x09;
 190                 case  B38400: return 0x0a;
 191                 case  B57600: return 0x0b;
 192                 case B115200: return 0x0c;
 193                 default:
 194                         err("MCT USB-RS232: unsupported baudrate request 0x%x,"
 195                             " using default of B9600", value);
 196                         return 0x08;
 197                 }
 198         } else {
 199                 switch (value) {
 200                 case    B300: value =     300; break;
 201                 case    B600: value =     600; break;
 202                 case   B1200: value =    1200; break;
 203                 case   B2400: value =    2400; break;
 204                 case   B4800: value =    4800; break;
 205                 case   B9600: value =    9600; break;
 206                 case  B19200: value =   19200; break;
 207                 case  B38400: value =   38400; break;
 208                 case  B57600: value =   57600; break;
 209                 case B115200: value =  115200; break;
 210                 default:
 211                         err("MCT USB-RS232: unsupported baudrate request 0x%x,"
 212                             " using default of B9600", value);
 213                         value = 9600;
 214                 }
 215                 return 115200/value;
 216         }
 217 }
 218
 219 static int mct_u232_set_baud_rate(struct usb_serial *serial, int value)
 220 {
 221         __le32 divisor;
 222         int rc;
 223         unsigned char zero_byte = 0;
 224
 225         divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value));
 226
 227         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 228                              MCT_U232_SET_BAUD_RATE_REQUEST,
 229                              MCT_U232_SET_REQUEST_TYPE,
 230                              0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
 231                              WDR_TIMEOUT);
 232         if (rc < 0)
 233                 err("Set BAUD RATE %d failed (error = %d)", value, rc);
 234         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
 235
 236         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
 237            always sends two extra USB 'device request' messages after the
 238            'baud rate change' message.  The actual functionality of the
 239            request codes in these messages is not fully understood but these
 240            particular codes are never seen in any operation besides a baud
 241            rate change.  Both of these messages send a single byte of data
 242            whose value is always zero.  The second of these two extra messages
 243            is required in order for data to be properly written to an RS-232
 244            device which does not assert the 'CTS' signal. */
 245
 246         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 247                              MCT_U232_SET_UNKNOWN1_REQUEST,
 248                              MCT_U232_SET_REQUEST_TYPE,
 249                              0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
 250                              WDR_TIMEOUT);
 251         if (rc < 0)
 252                 err("Sending USB device request code %d failed (error = %d)",
 253                     MCT_U232_SET_UNKNOWN1_REQUEST, rc);
 254
 255         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 256                              MCT_U232_SET_UNKNOWN2_REQUEST,
 257                              MCT_U232_SET_REQUEST_TYPE,
 258                              0, 0, &zero_byte, MCT_U232_SET_UNKNOWN2_SIZE,
 259                              WDR_TIMEOUT);
 260         if (rc < 0)
 261                 err("Sending USB device request code %d failed (error = %d)",
 262                     MCT_U232_SET_UNKNOWN2_REQUEST, rc);
 263
 264         return rc;
 265 } /* mct_u232_set_baud_rate */
 266
 267 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
 268 {
 269         int rc;
 270         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 271                              MCT_U232_SET_LINE_CTRL_REQUEST,
 272                              MCT_U232_SET_REQUEST_TYPE,
 273                              0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
 274                              WDR_TIMEOUT);
 275         if (rc < 0)
 276                 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
 277         dbg("set_line_ctrl: 0x%x", lcr);
 278         return rc;
 279 } /* mct_u232_set_line_ctrl */
 280
 281 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
 282                                    unsigned int control_state)
 283 {
 284         int rc;
 285         unsigned char mcr = MCT_U232_MCR_NONE;
 286
 287         if (control_state & TIOCM_DTR)
 288                 mcr |= MCT_U232_MCR_DTR;
 289         if (control_state & TIOCM_RTS)
 290                 mcr |= MCT_U232_MCR_RTS;
 291
 292         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 293                              MCT_U232_SET_MODEM_CTRL_REQUEST,
 294                              MCT_U232_SET_REQUEST_TYPE,
 295                              0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
 296                              WDR_TIMEOUT);
 297         if (rc < 0)
 298                 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
 299         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
 300
 301         return rc;
 302 } /* mct_u232_set_modem_ctrl */
 303
 304 static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
 305 {
 306         int rc;
 307         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 308                              MCT_U232_GET_MODEM_STAT_REQUEST,
 309                              MCT_U232_GET_REQUEST_TYPE,
 310                              0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
 311                              WDR_TIMEOUT);
 312         if (rc < 0) {
 313                 err("Get MODEM STATus failed (error = %d)", rc);
 314                 *msr = 0;
 315         }
 316         dbg("get_modem_stat: 0x%x", *msr);
 317         return rc;
 318 } /* mct_u232_get_modem_stat */
 319
 320 static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr)
 321 {
 322         /* Translate Control Line states */
 323         if (msr & MCT_U232_MSR_DSR)
 324                 *control_state |=  TIOCM_DSR;
 325         else
 326                 *control_state &= ~TIOCM_DSR;
 327         if (msr & MCT_U232_MSR_CTS)
 328                 *control_state |=  TIOCM_CTS;
 329         else
 330                 *control_state &= ~TIOCM_CTS;
 331         if (msr & MCT_U232_MSR_RI)
 332                 *control_state |=  TIOCM_RI;
 333         else
 334                 *control_state &= ~TIOCM_RI;
 335         if (msr & MCT_U232_MSR_CD)
 336                 *control_state |=  TIOCM_CD;
 337         else
 338                 *control_state &= ~TIOCM_CD;
 339         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
 340 } /* mct_u232_msr_to_state */
 341
 342 /*
 343  * Driver's tty interface functions
 344  */
 345
 346 static int mct_u232_startup (struct usb_serial *serial)
 347 {
 348         struct mct_u232_private *priv;
 349         struct usb_serial_port *port, *rport;
 350
 351         priv = kmalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 352         if (!priv)
 353                 return -ENOMEM;
 354         memset(priv, 0, sizeof(struct mct_u232_private));
 355         spin_lock_init(&priv->lock);
 356         usb_set_serial_port_data(serial->port[0], priv);
 357
 358         init_waitqueue_head(&serial->port[0]->write_wait);
 359
 360         /* Puh, that's dirty */
 361         port = serial->port[0];
 362         rport = serial->port[1];
 363         if (port->read_urb) {
 364                 /* No unlinking, it wasn't submitted yet. */
 365                 usb_free_urb(port->read_urb);
 366         }
 367         port->read_urb = rport->interrupt_in_urb;
 368         rport->interrupt_in_urb = NULL;
 369         port->read_urb->context = port;
 370
 371         return (0);
 372 } /* mct_u232_startup */
 373
 374
 375 static void mct_u232_shutdown (struct usb_serial *serial)
 376 {
 377         struct mct_u232_private *priv;
 378         int i;
 379
 380         dbg("%s", __FUNCTION__);
 381
 382         for (i=0; i < serial->num_ports; ++i) {
 383                 /* My special items, the standard routines free my urbs */
 384                 priv = usb_get_serial_port_data(serial->port[i]);
 385                 if (priv) {
 386                         usb_set_serial_port_data(serial->port[i], NULL);
 387                         kfree(priv);
 388                 }
 389         }
 390 } /* mct_u232_shutdown */
 391
 392 static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
 393 {
 394         struct usb_serial *serial = port->serial;
 395         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 396         int retval = 0;
 397         unsigned int control_state;
 398         unsigned long flags;
 399         unsigned char last_lcr;
 400         unsigned char last_msr;
 401
 402         dbg("%s port %d", __FUNCTION__, port->number);
 403
 404         /* Compensate for a hardware bug: although the Sitecom U232-P25
 405          * device reports a maximum output packet size of 32 bytes,
 406          * it seems to be able to accept only 16 bytes (and that's what
 407          * SniffUSB says too...)
 408          */
 409         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
 410                 port->bulk_out_size = 16;
 411
 412         /* Do a defined restart: the normal serial device seems to
 413          * always turn on DTR and RTS here, so do the same. I'm not
 414          * sure if this is really necessary. But it should not harm
 415          * either.
 416          */
 417         spin_lock_irqsave(&priv->lock, flags);
 418         if (port->tty->termios->c_cflag & CBAUD)
 419                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 420         else
 421                 priv->control_state = 0;
 422
 423         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 424                           MCT_U232_PARITY_NONE |
 425                           MCT_U232_STOP_BITS_1);
 426         control_state = priv->control_state;
 427         last_lcr = priv->last_lcr;
 428         spin_unlock_irqrestore(&priv->lock, flags);
 429         mct_u232_set_modem_ctrl(serial, control_state);
 430         mct_u232_set_line_ctrl(serial, last_lcr);
 431
 432         /* Read modem status and update control state */
 433         mct_u232_get_modem_stat(serial, &last_msr);
 434         spin_lock_irqsave(&priv->lock, flags);
 435         priv->last_msr = last_msr;
 436         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 437         spin_unlock_irqrestore(&priv->lock, flags);
 438
 439         port->read_urb->dev = port->serial->dev;
 440         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 441         if (retval) {
 442                 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
 443                     port->read_urb->pipe, retval);
 444                 goto exit;
 445         }
 446
 447         port->interrupt_in_urb->dev = port->serial->dev;
 448         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 449         if (retval)
 450                 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
 451                     port->interrupt_in_urb->pipe, retval);
 452
 453 exit:
 454         return 0;
 455 } /* mct_u232_open */
 456
 457
 458 static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
 459 {
 460         dbg("%s port %d", __FUNCTION__, port->number);
 461
 462         if (port->serial->dev) {
 463                 /* shutdown our urbs */
 464                 usb_kill_urb(port->write_urb);
 465                 usb_kill_urb(port->read_urb);
 466                 usb_kill_urb(port->interrupt_in_urb);
 467         }
 468 } /* mct_u232_close */
 469
 470
 471 static void mct_u232_read_int_callback (struct urb *urb, struct pt_regs *regs)
 472 {
 473         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 474         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 475         struct usb_serial *serial = port->serial;
 476         struct tty_struct *tty;
 477         unsigned char *data = urb->transfer_buffer;
 478         int status;
 479         unsigned long flags;
 480
 481         switch (urb->status) {
 482         case 0:
 483                 /* success */
 484                 break;
 485         case -ECONNRESET:
 486         case -ENOENT:
 487         case -ESHUTDOWN:
 488                 /* this urb is terminated, clean up */
 489                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
 490                 return;
 491         default:
 492                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
 493                 goto exit;
 494         }
 495
 496         if (!serial) {
 497                 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
 498                 return;
 499         }
 500
 501         dbg("%s - port %d", __FUNCTION__, port->number);
 502         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
 503
 504         /*
 505          * Work-a-round: handle the 'usual' bulk-in pipe here
 506          */
 507         if (urb->transfer_buffer_length > 2) {
 508                 int i;
 509                 tty = port->tty;
 510                 if (urb->actual_length) {
 511                         for (i = 0; i < urb->actual_length ; ++i) {
 512                                 tty_insert_flip_char(tty, data[i], 0);
 513                         }
 514                         tty_flip_buffer_push(tty);
 515                 }
 516                 goto exit;
 517         }
 518
 519         /*
 520          * The interrupt-in pipe signals exceptional conditions (modem line
 521          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 522          */
 523         spin_lock_irqsave(&priv->lock, flags);
 524         priv->last_msr = data[MCT_U232_MSR_INDEX];
 525
 526         /* Record Control Line states */
 527         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 528
 529 #if 0
 530         /* Not yet handled. See belin_sa.c for further information */
 531         /* Now to report any errors */
 532         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 533         /*
 534          * fill in the flip buffer here, but I do not know the relation
 535          * to the current/next receive buffer or characters.  I need
 536          * to look in to this before committing any code.
 537          */
 538         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 539                 tty = port->tty;
 540                 /* Overrun Error */
 541                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 542                 }
 543                 /* Parity Error */
 544                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 545                 }
 546                 /* Framing Error */
 547                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 548                 }
 549                 /* Break Indicator */
 550                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 551                 }
 552         }
 553 #endif
 554         spin_unlock_irqrestore(&priv->lock, flags);
 555 exit:
 556         status = usb_submit_urb (urb, GFP_ATOMIC);
 557         if (status)
 558                 err ("%s - usb_submit_urb failed with result %d",
 559                      __FUNCTION__, status);
 560 } /* mct_u232_read_int_callback */
 561
 562 static void mct_u232_set_termios (struct usb_serial_port *port,
 563                                   struct termios *old_termios)
 564 {
 565         struct usb_serial *serial = port->serial;
 566         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 567         unsigned int iflag = port->tty->termios->c_iflag;
 568         unsigned int cflag = port->tty->termios->c_cflag;
 569         unsigned int old_cflag = old_termios->c_cflag;
 570         unsigned long flags;
 571         unsigned int control_state, new_state;
 572         unsigned char last_lcr;
 573
 574         /* get a local copy of the current port settings */
 575         spin_lock_irqsave(&priv->lock, flags);
 576         control_state = priv->control_state;
 577         spin_unlock_irqrestore(&priv->lock, flags);
 578         last_lcr = 0;
 579
 580         /*
 581          * Update baud rate.
 582          * Do not attempt to cache old rates and skip settings,
 583          * disconnects screw such tricks up completely.
 584          * Premature optimization is the root of all evil.
 585          */
 586
 587         /* reassert DTR and (maybe) RTS on transition from B0 */
 588         if ((old_cflag & CBAUD) == B0) {
 589                 dbg("%s: baud was B0", __FUNCTION__);
 590                 control_state |= TIOCM_DTR;
 591                 /* don't set RTS if using hardware flow control */
 592                 if (!(old_cflag & CRTSCTS)) {
 593                         control_state |= TIOCM_RTS;
 594                 }
 595                 mct_u232_set_modem_ctrl(serial, control_state);
 596         }
 597
 598         mct_u232_set_baud_rate(serial, cflag & CBAUD);
 599
 600         if ((cflag & CBAUD) == B0 ) {
 601                 dbg("%s: baud is B0", __FUNCTION__);
 602                 /* Drop RTS and DTR */
 603                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 604                 mct_u232_set_modem_ctrl(serial, control_state);
 605         }
 606
 607         /*
 608          * Update line control register (LCR)
 609          */
 610
 611         /* set the parity */
 612         if (cflag & PARENB)
 613                 last_lcr |= (cflag & PARODD) ?
 614                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 615         else
 616                 last_lcr |= MCT_U232_PARITY_NONE;
 617
 618         /* set the number of data bits */
 619         switch (cflag & CSIZE) {
 620         case CS5:
 621                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 622         case CS6:
 623                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 624         case CS7:
 625                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 626         case CS8:
 627                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 628         default:
 629                 err("CSIZE was not CS5-CS8, using default of 8");
 630                 last_lcr |= MCT_U232_DATA_BITS_8;
 631                 break;
 632         }
 633
 634         /* set the number of stop bits */
 635         last_lcr |= (cflag & CSTOPB) ?
 636                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 637
 638         mct_u232_set_line_ctrl(serial, last_lcr);
 639
 640         /*
 641          * Set flow control: well, I do not really now how to handle DTR/RTS.
 642          * Just do what we have seen with SniffUSB on Win98.
 643          */
 644         /* Drop DTR/RTS if no flow control otherwise assert */
 645         new_state = control_state;
 646         if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
 647                 new_state |= TIOCM_DTR | TIOCM_RTS;
 648         else
 649                 new_state &= ~(TIOCM_DTR | TIOCM_RTS);
 650         if (new_state != control_state) {
 651                 mct_u232_set_modem_ctrl(serial, new_state);
 652                 control_state = new_state;
 653         }
 654
 655         /* save off the modified port settings */
 656         spin_lock_irqsave(&priv->lock, flags);
 657         priv->control_state = control_state;
 658         priv->last_lcr = last_lcr;
 659         spin_unlock_irqrestore(&priv->lock, flags);
 660 } /* mct_u232_set_termios */
 661
 662 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
 663 {
 664         struct usb_serial *serial = port->serial;
 665         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 666         unsigned char lcr;
 667         unsigned long flags;
 668
 669         dbg("%sstate=%d", __FUNCTION__, break_state);
 670
 671         spin_lock_irqsave(&priv->lock, flags);
 672         lcr = priv->last_lcr;
 673         spin_unlock_irqrestore(&priv->lock, flags);
 674
 675         if (break_state)
 676                 lcr |= MCT_U232_SET_BREAK;
 677
 678         mct_u232_set_line_ctrl(serial, lcr);
 679 } /* mct_u232_break_ctl */
 680
 681
 682 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
 683 {
 684         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 685         unsigned int control_state;
 686         unsigned long flags;
 687
 688         dbg("%s", __FUNCTION__);
 689
 690         spin_lock_irqsave(&priv->lock, flags);
 691         control_state = priv->control_state;
 692         spin_unlock_irqrestore(&priv->lock, flags);
 693
 694         return control_state;
 695 }
 696
 697 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
 698                               unsigned int set, unsigned int clear)
 699 {
 700         struct usb_serial *serial = port->serial;
 701         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 702         unsigned int control_state;
 703         unsigned long flags;
 704
 705         dbg("%s", __FUNCTION__);
 706
 707         spin_lock_irqsave(&priv->lock, flags);
 708         control_state = priv->control_state;
 709
 710         if (set & TIOCM_RTS)
 711                 control_state |= TIOCM_RTS;
 712         if (set & TIOCM_DTR)
 713                 control_state |= TIOCM_DTR;
 714         if (clear & TIOCM_RTS)
 715                 control_state &= ~TIOCM_RTS;
 716         if (clear & TIOCM_DTR)
 717                 control_state &= ~TIOCM_DTR;
 718
 719         priv->control_state = control_state;
 720         spin_unlock_irqrestore(&priv->lock, flags);
 721         return mct_u232_set_modem_ctrl(serial, control_state);
 722 }
 723
 724 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
 725                            unsigned int cmd, unsigned long arg)
 726 {
 727         dbg("%scmd=0x%x", __FUNCTION__, cmd);
 728
 729         /* Based on code from acm.c and others */
 730         switch (cmd) {
 731         case TIOCMIWAIT:
 732                 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
 733                 /* TODO */
 734                 return( 0 );
 735
 736         case TIOCGICOUNT:
 737                 /* return count of modemline transitions */
 738                 /* TODO */
 739                 return 0;
 740
 741         default:
 742                 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
 743                 return(-ENOIOCTLCMD);
 744                 break;
 745         }
 746         return 0;
 747 } /* mct_u232_ioctl */
 748
 749
 750 static int __init mct_u232_init (void)
 751 {
 752         int retval;
 753         retval = usb_serial_register(&mct_u232_device);
 754         if (retval)
 755                 goto failed_usb_serial_register;
 756         retval = usb_register(&mct_u232_driver);
 757         if (retval)
 758                 goto failed_usb_register;
 759         info(DRIVER_DESC " " DRIVER_VERSION);
 760         return 0;
 761 failed_usb_register:
 762         usb_serial_deregister(&mct_u232_device);
 763 failed_usb_serial_register:
 764         return retval;
 765 }
 766
 767
 768 static void __exit mct_u232_exit (void)
 769 {
 770         usb_deregister (&mct_u232_driver);
 771         usb_serial_deregister (&mct_u232_device);
 772 }
 773
 774
 775 module_init (mct_u232_init);
 776 module_exit(mct_u232_exit);
 777
 778 MODULE_AUTHOR( DRIVER_AUTHOR );
 779 MODULE_DESCRIPTION( DRIVER_DESC );
 780 MODULE_LICENSE("GPL");
 781
 782 module_param(debug, bool, S_IRUGO | S_IWUSR);
 783 MODULE_PARM_DESC(debug, "Debug enabled or not");