SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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.0"           /* 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 /*
 114  * All of the device info needed for the MCT USB-RS232 converter.
 115  */
 116 static struct usb_device_id id_table_combined [] = {
 117         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
 118         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
 119         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
 120         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
 121         { }             /* Terminating entry */
 122 };
 123
 124 MODULE_DEVICE_TABLE (usb, id_table_combined);
 125
 126 static struct usb_driver mct_u232_driver = {
 127         .name =         "mct_u232",
 128         .probe =        usb_serial_probe,
 129         .disconnect =   usb_serial_disconnect,
 130         .id_table =     id_table_combined,
 131         .no_dynamic_id =        1,
 132 };
 133
 134 static struct usb_serial_driver mct_u232_device = {
 135         .driver = {
 136                 .owner =        THIS_MODULE,
 137                 .name =         "mct_u232",
 138         },
 139         .description =       "MCT U232",
 140         .usb_driver =        &mct_u232_driver,
 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 = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 352         if (!priv)
 353                 return -ENOMEM;
 354         spin_lock_init(&priv->lock);
 355         usb_set_serial_port_data(serial->port[0], priv);
 356
 357         init_waitqueue_head(&serial->port[0]->write_wait);
 358
 359         /* Puh, that's dirty */
 360         port = serial->port[0];
 361         rport = serial->port[1];
 362         /* No unlinking, it wasn't submitted yet. */
 363         usb_free_urb(port->read_urb);
 364         port->read_urb = rport->interrupt_in_urb;
 365         rport->interrupt_in_urb = NULL;
 366         port->read_urb->context = port;
 367
 368         return (0);
 369 } /* mct_u232_startup */
 370
 371
 372 static void mct_u232_shutdown (struct usb_serial *serial)
 373 {
 374         struct mct_u232_private *priv;
 375         int i;
 376
 377         dbg("%s", __FUNCTION__);
 378
 379         for (i=0; i < serial->num_ports; ++i) {
 380                 /* My special items, the standard routines free my urbs */
 381                 priv = usb_get_serial_port_data(serial->port[i]);
 382                 if (priv) {
 383                         usb_set_serial_port_data(serial->port[i], NULL);
 384                         kfree(priv);
 385                 }
 386         }
 387 } /* mct_u232_shutdown */
 388
 389 static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
 390 {
 391         struct usb_serial *serial = port->serial;
 392         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 393         int retval = 0;
 394         unsigned int control_state;
 395         unsigned long flags;
 396         unsigned char last_lcr;
 397         unsigned char last_msr;
 398
 399         dbg("%s port %d", __FUNCTION__, port->number);
 400
 401         /* Compensate for a hardware bug: although the Sitecom U232-P25
 402          * device reports a maximum output packet size of 32 bytes,
 403          * it seems to be able to accept only 16 bytes (and that's what
 404          * SniffUSB says too...)
 405          */
 406         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
 407                 port->bulk_out_size = 16;
 408
 409         /* Do a defined restart: the normal serial device seems to
 410          * always turn on DTR and RTS here, so do the same. I'm not
 411          * sure if this is really necessary. But it should not harm
 412          * either.
 413          */
 414         spin_lock_irqsave(&priv->lock, flags);
 415         if (port->tty->termios->c_cflag & CBAUD)
 416                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 417         else
 418                 priv->control_state = 0;
 419
 420         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 421                           MCT_U232_PARITY_NONE |
 422                           MCT_U232_STOP_BITS_1);
 423         control_state = priv->control_state;
 424         last_lcr = priv->last_lcr;
 425         spin_unlock_irqrestore(&priv->lock, flags);
 426         mct_u232_set_modem_ctrl(serial, control_state);
 427         mct_u232_set_line_ctrl(serial, last_lcr);
 428
 429         /* Read modem status and update control state */
 430         mct_u232_get_modem_stat(serial, &last_msr);
 431         spin_lock_irqsave(&priv->lock, flags);
 432         priv->last_msr = last_msr;
 433         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 434         spin_unlock_irqrestore(&priv->lock, flags);
 435
 436         port->read_urb->dev = port->serial->dev;
 437         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 438         if (retval) {
 439                 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
 440                     port->read_urb->pipe, retval);
 441                 goto error;
 442         }
 443
 444         port->interrupt_in_urb->dev = port->serial->dev;
 445         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 446         if (retval) {
 447                 usb_kill_urb(port->read_urb);
 448                 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
 449                     port->interrupt_in_urb->pipe, retval);
 450                 goto error;
 451         }
 452         return 0;
 453
 454 error:
 455         return retval;
 456 } /* mct_u232_open */
 457
 458
 459 static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
 460 {
 461         dbg("%s port %d", __FUNCTION__, port->number);
 462
 463         if (port->serial->dev) {
 464                 /* shutdown our urbs */
 465                 usb_kill_urb(port->write_urb);
 466                 usb_kill_urb(port->read_urb);
 467                 usb_kill_urb(port->interrupt_in_urb);
 468         }
 469 } /* mct_u232_close */
 470
 471
 472 static void mct_u232_read_int_callback (struct urb *urb)
 473 {
 474         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 475         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 476         struct usb_serial *serial = port->serial;
 477         struct tty_struct *tty;
 478         unsigned char *data = urb->transfer_buffer;
 479         int status;
 480         unsigned long flags;
 481
 482         switch (urb->status) {
 483         case 0:
 484                 /* success */
 485                 break;
 486         case -ECONNRESET:
 487         case -ENOENT:
 488         case -ESHUTDOWN:
 489                 /* this urb is terminated, clean up */
 490                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
 491                 return;
 492         default:
 493                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
 494                 goto exit;
 495         }
 496
 497         if (!serial) {
 498                 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
 499                 return;
 500         }
 501
 502         dbg("%s - port %d", __FUNCTION__, port->number);
 503         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
 504
 505         /*
 506          * Work-a-round: handle the 'usual' bulk-in pipe here
 507          */
 508         if (urb->transfer_buffer_length > 2) {
 509                 int i;
 510                 tty = port->tty;
 511                 if (urb->actual_length) {
 512                         for (i = 0; i < urb->actual_length ; ++i) {
 513                                 tty_insert_flip_char(tty, data[i], 0);
 514                         }
 515                         tty_flip_buffer_push(tty);
 516                 }
 517                 goto exit;
 518         }
 519
 520         /*
 521          * The interrupt-in pipe signals exceptional conditions (modem line
 522          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 523          */
 524         spin_lock_irqsave(&priv->lock, flags);
 525         priv->last_msr = data[MCT_U232_MSR_INDEX];
 526
 527         /* Record Control Line states */
 528         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 529
 530 #if 0
 531         /* Not yet handled. See belin_sa.c for further information */
 532         /* Now to report any errors */
 533         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 534         /*
 535          * fill in the flip buffer here, but I do not know the relation
 536          * to the current/next receive buffer or characters.  I need
 537          * to look in to this before committing any code.
 538          */
 539         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 540                 tty = port->tty;
 541                 /* Overrun Error */
 542                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 543                 }
 544                 /* Parity Error */
 545                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 546                 }
 547                 /* Framing Error */
 548                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 549                 }
 550                 /* Break Indicator */
 551                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 552                 }
 553         }
 554 #endif
 555         spin_unlock_irqrestore(&priv->lock, flags);
 556 exit:
 557         status = usb_submit_urb (urb, GFP_ATOMIC);
 558         if (status)
 559                 err ("%s - usb_submit_urb failed with result %d",
 560                      __FUNCTION__, status);
 561 } /* mct_u232_read_int_callback */
 562
 563 static void mct_u232_set_termios (struct usb_serial_port *port,
 564                                   struct ktermios *old_termios)
 565 {
 566         struct usb_serial *serial = port->serial;
 567         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 568         unsigned int iflag = port->tty->termios->c_iflag;
 569         unsigned int cflag = port->tty->termios->c_cflag;
 570         unsigned int old_cflag = old_termios->c_cflag;
 571         unsigned long flags;
 572         unsigned int control_state, new_state;
 573         unsigned char last_lcr;
 574
 575         /* get a local copy of the current port settings */
 576         spin_lock_irqsave(&priv->lock, flags);
 577         control_state = priv->control_state;
 578         spin_unlock_irqrestore(&priv->lock, flags);
 579         last_lcr = 0;
 580
 581         /*
 582          * Update baud rate.
 583          * Do not attempt to cache old rates and skip settings,
 584          * disconnects screw such tricks up completely.
 585          * Premature optimization is the root of all evil.
 586          */
 587
 588         /* reassert DTR and (maybe) RTS on transition from B0 */
 589         if ((old_cflag & CBAUD) == B0) {
 590                 dbg("%s: baud was B0", __FUNCTION__);
 591                 control_state |= TIOCM_DTR;
 592                 /* don't set RTS if using hardware flow control */
 593                 if (!(old_cflag & CRTSCTS)) {
 594                         control_state |= TIOCM_RTS;
 595                 }
 596                 mct_u232_set_modem_ctrl(serial, control_state);
 597         }
 598
 599         mct_u232_set_baud_rate(serial, cflag & CBAUD);
 600
 601         if ((cflag & CBAUD) == B0 ) {
 602                 dbg("%s: baud is B0", __FUNCTION__);
 603                 /* Drop RTS and DTR */
 604                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 605                 mct_u232_set_modem_ctrl(serial, control_state);
 606         }
 607
 608         /*
 609          * Update line control register (LCR)
 610          */
 611
 612         /* set the parity */
 613         if (cflag & PARENB)
 614                 last_lcr |= (cflag & PARODD) ?
 615                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 616         else
 617                 last_lcr |= MCT_U232_PARITY_NONE;
 618
 619         /* set the number of data bits */
 620         switch (cflag & CSIZE) {
 621         case CS5:
 622                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 623         case CS6:
 624                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 625         case CS7:
 626                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 627         case CS8:
 628                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 629         default:
 630                 err("CSIZE was not CS5-CS8, using default of 8");
 631                 last_lcr |= MCT_U232_DATA_BITS_8;
 632                 break;
 633         }
 634
 635         /* set the number of stop bits */
 636         last_lcr |= (cflag & CSTOPB) ?
 637                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 638
 639         mct_u232_set_line_ctrl(serial, last_lcr);
 640
 641         /*
 642          * Set flow control: well, I do not really now how to handle DTR/RTS.
 643          * Just do what we have seen with SniffUSB on Win98.
 644          */
 645         /* Drop DTR/RTS if no flow control otherwise assert */
 646         new_state = control_state;
 647         if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
 648                 new_state |= TIOCM_DTR | TIOCM_RTS;
 649         else
 650                 new_state &= ~(TIOCM_DTR | TIOCM_RTS);
 651         if (new_state != control_state) {
 652                 mct_u232_set_modem_ctrl(serial, new_state);
 653                 control_state = new_state;
 654         }
 655
 656         /* save off the modified port settings */
 657         spin_lock_irqsave(&priv->lock, flags);
 658         priv->control_state = control_state;
 659         priv->last_lcr = last_lcr;
 660         spin_unlock_irqrestore(&priv->lock, flags);
 661 } /* mct_u232_set_termios */
 662
 663 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
 664 {
 665         struct usb_serial *serial = port->serial;
 666         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 667         unsigned char lcr;
 668         unsigned long flags;
 669
 670         dbg("%sstate=%d", __FUNCTION__, break_state);
 671
 672         spin_lock_irqsave(&priv->lock, flags);
 673         lcr = priv->last_lcr;
 674         spin_unlock_irqrestore(&priv->lock, flags);
 675
 676         if (break_state)
 677                 lcr |= MCT_U232_SET_BREAK;
 678
 679         mct_u232_set_line_ctrl(serial, lcr);
 680 } /* mct_u232_break_ctl */
 681
 682
 683 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
 684 {
 685         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 686         unsigned int control_state;
 687         unsigned long flags;
 688
 689         dbg("%s", __FUNCTION__);
 690
 691         spin_lock_irqsave(&priv->lock, flags);
 692         control_state = priv->control_state;
 693         spin_unlock_irqrestore(&priv->lock, flags);
 694
 695         return control_state;
 696 }
 697
 698 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
 699                               unsigned int set, unsigned int clear)
 700 {
 701         struct usb_serial *serial = port->serial;
 702         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 703         unsigned int control_state;
 704         unsigned long flags;
 705
 706         dbg("%s", __FUNCTION__);
 707
 708         spin_lock_irqsave(&priv->lock, flags);
 709         control_state = priv->control_state;
 710
 711         if (set & TIOCM_RTS)
 712                 control_state |= TIOCM_RTS;
 713         if (set & TIOCM_DTR)
 714                 control_state |= TIOCM_DTR;
 715         if (clear & TIOCM_RTS)
 716                 control_state &= ~TIOCM_RTS;
 717         if (clear & TIOCM_DTR)
 718                 control_state &= ~TIOCM_DTR;
 719
 720         priv->control_state = control_state;
 721         spin_unlock_irqrestore(&priv->lock, flags);
 722         return mct_u232_set_modem_ctrl(serial, control_state);
 723 }
 724
 725 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
 726                            unsigned int cmd, unsigned long arg)
 727 {
 728         dbg("%scmd=0x%x", __FUNCTION__, cmd);
 729
 730         /* Based on code from acm.c and others */
 731         switch (cmd) {
 732         case TIOCMIWAIT:
 733                 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
 734                 /* TODO */
 735                 return( 0 );
 736
 737         case TIOCGICOUNT:
 738                 /* return count of modemline transitions */
 739                 /* TODO */
 740                 return 0;
 741
 742         default:
 743                 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
 744                 return(-ENOIOCTLCMD);
 745                 break;
 746         }
 747         return 0;
 748 } /* mct_u232_ioctl */
 749
 750
 751 static int __init mct_u232_init (void)
 752 {
 753         int retval;
 754         retval = usb_serial_register(&mct_u232_device);
 755         if (retval)
 756                 goto failed_usb_serial_register;
 757         retval = usb_register(&mct_u232_driver);
 758         if (retval)
 759                 goto failed_usb_register;
 760         info(DRIVER_DESC " " DRIVER_VERSION);
 761         return 0;
 762 failed_usb_register:
 763         usb_serial_deregister(&mct_u232_device);
 764 failed_usb_serial_register:
 765         return retval;
 766 }
 767
 768
 769 static void __exit mct_u232_exit (void)
 770 {
 771         usb_deregister (&mct_u232_driver);
 772         usb_serial_deregister (&mct_u232_device);
 773 }
 774
 775
 776 module_init (mct_u232_init);
 777 module_exit(mct_u232_exit);
 778
 779 MODULE_AUTHOR( DRIVER_AUTHOR );
 780 MODULE_DESCRIPTION( DRIVER_DESC );
 781 MODULE_LICENSE("GPL");
 782
 783 module_param(debug, bool, S_IRUGO | S_IWUSR);
 784 MODULE_PARM_DESC(debug, "Debug enabled or not");