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