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.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 long flags;
 491         unsigned int control_state;
 492         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 493         dbg("%s port %d", __FUNCTION__, port->number);
 494
 495         if (port->tty) {
 496                 c_cflag = port->tty->termios->c_cflag;
 497                 if (c_cflag & HUPCL) {
 498                    /* drop DTR and RTS */
 499                    spin_lock_irqsave(&priv->lock, flags);
 500                    priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 501                    control_state = priv->control_state;
 502                    spin_unlock_irqrestore(&priv->lock, flags);
 503                    mct_u232_set_modem_ctrl(port->serial, control_state);
 504                 }
 505         }
 506
 507
 508         if (port->serial->dev) {
 509                 /* shutdown our urbs */
 510                 usb_kill_urb(port->write_urb);
 511                 usb_kill_urb(port->read_urb);
 512                 usb_kill_urb(port->interrupt_in_urb);
 513         }
 514 } /* mct_u232_close */
 515
 516
 517 static void mct_u232_read_int_callback (struct urb *urb)
 518 {
 519         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 520         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 521         struct usb_serial *serial = port->serial;
 522         struct tty_struct *tty;
 523         unsigned char *data = urb->transfer_buffer;
 524         int retval;
 525         int status = urb->status;
 526         unsigned long flags;
 527
 528         switch (status) {
 529         case 0:
 530                 /* success */
 531                 break;
 532         case -ECONNRESET:
 533         case -ENOENT:
 534         case -ESHUTDOWN:
 535                 /* this urb is terminated, clean up */
 536                 dbg("%s - urb shutting down with status: %d",
 537                     __FUNCTION__, status);
 538                 return;
 539         default:
 540                 dbg("%s - nonzero urb status received: %d",
 541                     __FUNCTION__, status);
 542                 goto exit;
 543         }
 544
 545         if (!serial) {
 546                 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
 547                 return;
 548         }
 549
 550         dbg("%s - port %d", __FUNCTION__, port->number);
 551         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
 552
 553         /*
 554          * Work-a-round: handle the 'usual' bulk-in pipe here
 555          */
 556         if (urb->transfer_buffer_length > 2) {
 557                 int i;
 558                 tty = port->tty;
 559                 if (urb->actual_length) {
 560                         for (i = 0; i < urb->actual_length ; ++i) {
 561                                 tty_insert_flip_char(tty, data[i], 0);
 562                         }
 563                         tty_flip_buffer_push(tty);
 564                 }
 565                 goto exit;
 566         }
 567
 568         /*
 569          * The interrupt-in pipe signals exceptional conditions (modem line
 570          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 571          */
 572         spin_lock_irqsave(&priv->lock, flags);
 573         priv->last_msr = data[MCT_U232_MSR_INDEX];
 574
 575         /* Record Control Line states */
 576         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 577
 578 #if 0
 579         /* Not yet handled. See belin_sa.c for further information */
 580         /* Now to report any errors */
 581         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 582         /*
 583          * fill in the flip buffer here, but I do not know the relation
 584          * to the current/next receive buffer or characters.  I need
 585          * to look in to this before committing any code.
 586          */
 587         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 588                 tty = port->tty;
 589                 /* Overrun Error */
 590                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 591                 }
 592                 /* Parity Error */
 593                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 594                 }
 595                 /* Framing Error */
 596                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 597                 }
 598                 /* Break Indicator */
 599                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 600                 }
 601         }
 602 #endif
 603         spin_unlock_irqrestore(&priv->lock, flags);
 604 exit:
 605         retval = usb_submit_urb (urb, GFP_ATOMIC);
 606         if (retval)
 607                 err ("%s - usb_submit_urb failed with result %d",
 608                      __FUNCTION__, retval);
 609 } /* mct_u232_read_int_callback */
 610
 611 static void mct_u232_set_termios (struct usb_serial_port *port,
 612                                   struct ktermios *old_termios)
 613 {
 614         struct usb_serial *serial = port->serial;
 615         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 616         struct ktermios *termios = port->tty->termios;
 617         unsigned int cflag = termios->c_cflag;
 618         unsigned int old_cflag = old_termios->c_cflag;
 619         unsigned long flags;
 620         unsigned int control_state;
 621         unsigned char last_lcr;
 622
 623         /* get a local copy of the current port settings */
 624         spin_lock_irqsave(&priv->lock, flags);
 625         control_state = priv->control_state;
 626         spin_unlock_irqrestore(&priv->lock, flags);
 627         last_lcr = 0;
 628
 629         /*
 630          * Update baud rate.
 631          * Do not attempt to cache old rates and skip settings,
 632          * disconnects screw such tricks up completely.
 633          * Premature optimization is the root of all evil.
 634          */
 635
 636         /* reassert DTR and RTS on transition from B0 */
 637         if ((old_cflag & CBAUD) == B0) {
 638                 dbg("%s: baud was B0", __FUNCTION__);
 639                 control_state |= TIOCM_DTR | TIOCM_RTS;
 640                 mct_u232_set_modem_ctrl(serial, control_state);
 641         }
 642
 643         mct_u232_set_baud_rate(serial, port, tty_get_baud_rate(port->tty));
 644
 645         if ((cflag & CBAUD) == B0 ) {
 646                 dbg("%s: baud is B0", __FUNCTION__);
 647                 /* Drop RTS and DTR */
 648                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 649                 mct_u232_set_modem_ctrl(serial, control_state);
 650         }
 651
 652         /*
 653          * Update line control register (LCR)
 654          */
 655
 656         /* set the parity */
 657         if (cflag & PARENB)
 658                 last_lcr |= (cflag & PARODD) ?
 659                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 660         else
 661                 last_lcr |= MCT_U232_PARITY_NONE;
 662
 663         /* set the number of data bits */
 664         switch (cflag & CSIZE) {
 665         case CS5:
 666                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 667         case CS6:
 668                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 669         case CS7:
 670                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 671         case CS8:
 672                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 673         default:
 674                 err("CSIZE was not CS5-CS8, using default of 8");
 675                 last_lcr |= MCT_U232_DATA_BITS_8;
 676                 break;
 677         }
 678
 679         termios->c_cflag &= ~CMSPAR;
 680
 681         /* set the number of stop bits */
 682         last_lcr |= (cflag & CSTOPB) ?
 683                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 684
 685         mct_u232_set_line_ctrl(serial, last_lcr);
 686
 687         /* save off the modified port settings */
 688         spin_lock_irqsave(&priv->lock, flags);
 689         priv->control_state = control_state;
 690         priv->last_lcr = last_lcr;
 691         spin_unlock_irqrestore(&priv->lock, flags);
 692 } /* mct_u232_set_termios */
 693
 694 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
 695 {
 696         struct usb_serial *serial = port->serial;
 697         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 698         unsigned char lcr;
 699         unsigned long flags;
 700
 701         dbg("%sstate=%d", __FUNCTION__, break_state);
 702
 703         spin_lock_irqsave(&priv->lock, flags);
 704         lcr = priv->last_lcr;
 705         spin_unlock_irqrestore(&priv->lock, flags);
 706
 707         if (break_state)
 708                 lcr |= MCT_U232_SET_BREAK;
 709
 710         mct_u232_set_line_ctrl(serial, lcr);
 711 } /* mct_u232_break_ctl */
 712
 713
 714 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
 715 {
 716         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 717         unsigned int control_state;
 718         unsigned long flags;
 719
 720         dbg("%s", __FUNCTION__);
 721
 722         spin_lock_irqsave(&priv->lock, flags);
 723         control_state = priv->control_state;
 724         spin_unlock_irqrestore(&priv->lock, flags);
 725
 726         return control_state;
 727 }
 728
 729 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
 730                               unsigned int set, unsigned int clear)
 731 {
 732         struct usb_serial *serial = port->serial;
 733         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 734         unsigned int control_state;
 735         unsigned long flags;
 736
 737         dbg("%s", __FUNCTION__);
 738
 739         spin_lock_irqsave(&priv->lock, flags);
 740         control_state = priv->control_state;
 741
 742         if (set & TIOCM_RTS)
 743                 control_state |= TIOCM_RTS;
 744         if (set & TIOCM_DTR)
 745                 control_state |= TIOCM_DTR;
 746         if (clear & TIOCM_RTS)
 747                 control_state &= ~TIOCM_RTS;
 748         if (clear & TIOCM_DTR)
 749                 control_state &= ~TIOCM_DTR;
 750
 751         priv->control_state = control_state;
 752         spin_unlock_irqrestore(&priv->lock, flags);
 753         return mct_u232_set_modem_ctrl(serial, control_state);
 754 }
 755
 756 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
 757                            unsigned int cmd, unsigned long arg)
 758 {
 759         dbg("%scmd=0x%x", __FUNCTION__, cmd);
 760
 761         /* Based on code from acm.c and others */
 762         switch (cmd) {
 763         case TIOCMIWAIT:
 764                 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
 765                 /* TODO */
 766                 return( 0 );
 767
 768         case TIOCGICOUNT:
 769                 /* return count of modemline transitions */
 770                 /* TODO */
 771                 return 0;
 772
 773         default:
 774                 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
 775                 return(-ENOIOCTLCMD);
 776                 break;
 777         }
 778         return 0;
 779 } /* mct_u232_ioctl */
 780
 781 static void mct_u232_throttle (struct usb_serial_port *port)
 782 {
 783         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 784         unsigned long flags;
 785         unsigned int control_state;
 786         struct tty_struct *tty;
 787
 788         tty = port->tty;
 789         dbg("%s - port %d", __FUNCTION__, port->number);
 790
 791         spin_lock_irqsave(&priv->lock, flags);
 792         priv->rx_flags |= THROTTLED;
 793         if (C_CRTSCTS(tty)) {
 794           priv->control_state &= ~TIOCM_RTS;
 795           control_state = priv->control_state;
 796           spin_unlock_irqrestore(&priv->lock, flags);
 797           (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 798         } else {
 799           spin_unlock_irqrestore(&priv->lock, flags);
 800         }
 801 }
 802
 803
 804 static void mct_u232_unthrottle (struct usb_serial_port *port)
 805 {
 806         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 807         unsigned long flags;
 808         unsigned int control_state;
 809         struct tty_struct *tty;
 810
 811         dbg("%s - port %d", __FUNCTION__, port->number);
 812
 813         tty = port->tty;
 814         spin_lock_irqsave(&priv->lock, flags);
 815         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 816           priv->rx_flags &= ~THROTTLED;
 817           priv->control_state |= TIOCM_RTS;
 818           control_state = priv->control_state;
 819           spin_unlock_irqrestore(&priv->lock, flags);
 820           (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 821         } else {
 822           spin_unlock_irqrestore(&priv->lock, flags);
 823         }
 824 }
 825
 826 static int __init mct_u232_init (void)
 827 {
 828         int retval;
 829         retval = usb_serial_register(&mct_u232_device);
 830         if (retval)
 831                 goto failed_usb_serial_register;
 832         retval = usb_register(&mct_u232_driver);
 833         if (retval)
 834                 goto failed_usb_register;
 835         info(DRIVER_DESC " " DRIVER_VERSION);
 836         return 0;
 837 failed_usb_register:
 838         usb_serial_deregister(&mct_u232_device);
 839 failed_usb_serial_register:
 840         return retval;
 841 }
 842
 843
 844 static void __exit mct_u232_exit (void)
 845 {
 846         usb_deregister (&mct_u232_driver);
 847         usb_serial_deregister (&mct_u232_device);
 848 }
 849
 850
 851 module_init (mct_u232_init);
 852 module_exit(mct_u232_exit);
 853
 854 MODULE_AUTHOR( DRIVER_AUTHOR );
 855 MODULE_DESCRIPTION( DRIVER_DESC );
 856 MODULE_LICENSE("GPL");
 857
 858 module_param(debug, bool, S_IRUGO | S_IWUSR);
 859 MODULE_PARM_DESC(debug, "Debug enabled or not");