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         mutex_lock(&port->serial->disc_mutex);
 503         if (!port->serial->disconnected) {
 504                 /* drop DTR and RTS */
 505                 spin_lock_irq(&priv->lock);
 506                 if (on)
 507                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 508                 else
 509                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 510                 control_state = priv->control_state;
 511                 spin_unlock_irq(&priv->lock);
 512                 mct_u232_set_modem_ctrl(port, control_state);
 513         }
 514         mutex_unlock(&port->serial->disc_mutex);
 515 }
 516
 517 static void mct_u232_close(struct usb_serial_port *port)
 518 {
 519         /*
 520          * Must kill the read urb as it is actually an interrupt urb, which
 521          * generic close thus fails to kill.
 522          */
 523         usb_kill_urb(port->read_urb);
 524         usb_kill_urb(port->interrupt_in_urb);
 525
 526         usb_serial_generic_close(port);
 527 } /* mct_u232_close */
 528
 529
 530 static void mct_u232_read_int_callback(struct urb *urb)
 531 {
 532         struct usb_serial_port *port = urb->context;
 533         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 534         struct tty_struct *tty;
 535         unsigned char *data = urb->transfer_buffer;
 536         int retval;
 537         int status = urb->status;
 538         unsigned long flags;
 539
 540         switch (status) {
 541         case 0:
 542                 /* success */
 543                 break;
 544         case -ECONNRESET:
 545         case -ENOENT:
 546         case -ESHUTDOWN:
 547                 /* this urb is terminated, clean up */
 548                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 549                         __func__, status);
 550                 return;
 551         default:
 552                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 553                         __func__, status);
 554                 goto exit;
 555         }
 556
 557         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 558
 559         /*
 560          * Work-a-round: handle the 'usual' bulk-in pipe here
 561          */
 562         if (urb->transfer_buffer_length > 2) {
 563                 if (urb->actual_length) {
 564                         tty = tty_port_tty_get(&port->port);
 565                         if (tty) {
 566                                 tty_insert_flip_string(tty, data,
 567                                                 urb->actual_length);
 568                                 tty_flip_buffer_push(tty);
 569                         }
 570                         tty_kref_put(tty);
 571                 }
 572                 goto exit;
 573         }
 574
 575         /*
 576          * The interrupt-in pipe signals exceptional conditions (modem line
 577          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 578          */
 579         spin_lock_irqsave(&priv->lock, flags);
 580         priv->last_msr = data[MCT_U232_MSR_INDEX];
 581
 582         /* Record Control Line states */
 583         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 584
 585         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 586
 587 #if 0
 588         /* Not yet handled. See belkin_sa.c for further information */
 589         /* Now to report any errors */
 590         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 591         /*
 592          * fill in the flip buffer here, but I do not know the relation
 593          * to the current/next receive buffer or characters.  I need
 594          * to look in to this before committing any code.
 595          */
 596         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 597                 tty = tty_port_tty_get(&port->port);
 598                 /* Overrun Error */
 599                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 600                 }
 601                 /* Parity Error */
 602                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 603                 }
 604                 /* Framing Error */
 605                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 606                 }
 607                 /* Break Indicator */
 608                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 609                 }
 610                 tty_kref_put(tty);
 611         }
 612 #endif
 613         wake_up_interruptible(&priv->msr_wait);
 614         spin_unlock_irqrestore(&priv->lock, flags);
 615 exit:
 616         retval = usb_submit_urb(urb, GFP_ATOMIC);
 617         if (retval)
 618                 dev_err(&port->dev,
 619                         "%s - usb_submit_urb failed with result %d\n",
 620                         __func__, retval);
 621 } /* mct_u232_read_int_callback */
 622
 623 static void mct_u232_set_termios(struct tty_struct *tty,
 624                                  struct usb_serial_port *port,
 625                                  struct ktermios *old_termios)
 626 {
 627         struct usb_serial *serial = port->serial;
 628         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 629         struct ktermios *termios = &tty->termios;
 630         unsigned int cflag = termios->c_cflag;
 631         unsigned int old_cflag = old_termios->c_cflag;
 632         unsigned long flags;
 633         unsigned int control_state;
 634         unsigned char last_lcr;
 635
 636         /* get a local copy of the current port settings */
 637         spin_lock_irqsave(&priv->lock, flags);
 638         control_state = priv->control_state;
 639         spin_unlock_irqrestore(&priv->lock, flags);
 640         last_lcr = 0;
 641
 642         /*
 643          * Update baud rate.
 644          * Do not attempt to cache old rates and skip settings,
 645          * disconnects screw such tricks up completely.
 646          * Premature optimization is the root of all evil.
 647          */
 648
 649         /* reassert DTR and RTS on transition from B0 */
 650         if ((old_cflag & CBAUD) == B0) {
 651                 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
 652                 control_state |= TIOCM_DTR | TIOCM_RTS;
 653                 mct_u232_set_modem_ctrl(port, control_state);
 654         }
 655
 656         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 657
 658         if ((cflag & CBAUD) == B0) {
 659                 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
 660                 /* Drop RTS and DTR */
 661                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 662                 mct_u232_set_modem_ctrl(port, control_state);
 663         }
 664
 665         /*
 666          * Update line control register (LCR)
 667          */
 668
 669         /* set the parity */
 670         if (cflag & PARENB)
 671                 last_lcr |= (cflag & PARODD) ?
 672                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 673         else
 674                 last_lcr |= MCT_U232_PARITY_NONE;
 675
 676         /* set the number of data bits */
 677         switch (cflag & CSIZE) {
 678         case CS5:
 679                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 680         case CS6:
 681                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 682         case CS7:
 683                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 684         case CS8:
 685                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 686         default:
 687                 dev_err(&port->dev,
 688                         "CSIZE was not CS5-CS8, using default of 8\n");
 689                 last_lcr |= MCT_U232_DATA_BITS_8;
 690                 break;
 691         }
 692
 693         termios->c_cflag &= ~CMSPAR;
 694
 695         /* set the number of stop bits */
 696         last_lcr |= (cflag & CSTOPB) ?
 697                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 698
 699         mct_u232_set_line_ctrl(port, last_lcr);
 700
 701         /* save off the modified port settings */
 702         spin_lock_irqsave(&priv->lock, flags);
 703         priv->control_state = control_state;
 704         priv->last_lcr = last_lcr;
 705         spin_unlock_irqrestore(&priv->lock, flags);
 706 } /* mct_u232_set_termios */
 707
 708 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 709 {
 710         struct usb_serial_port *port = tty->driver_data;
 711         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 712         unsigned char lcr;
 713         unsigned long flags;
 714
 715         spin_lock_irqsave(&priv->lock, flags);
 716         lcr = priv->last_lcr;
 717
 718         if (break_state)
 719                 lcr |= MCT_U232_SET_BREAK;
 720         spin_unlock_irqrestore(&priv->lock, flags);
 721
 722         mct_u232_set_line_ctrl(port, lcr);
 723 } /* mct_u232_break_ctl */
 724
 725
 726 static int mct_u232_tiocmget(struct tty_struct *tty)
 727 {
 728         struct usb_serial_port *port = tty->driver_data;
 729         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 730         unsigned int control_state;
 731         unsigned long flags;
 732
 733         spin_lock_irqsave(&priv->lock, flags);
 734         control_state = priv->control_state;
 735         spin_unlock_irqrestore(&priv->lock, flags);
 736
 737         return control_state;
 738 }
 739
 740 static int mct_u232_tiocmset(struct tty_struct *tty,
 741                               unsigned int set, unsigned int clear)
 742 {
 743         struct usb_serial_port *port = tty->driver_data;
 744         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 745         unsigned int control_state;
 746         unsigned long flags;
 747
 748         spin_lock_irqsave(&priv->lock, flags);
 749         control_state = priv->control_state;
 750
 751         if (set & TIOCM_RTS)
 752                 control_state |= TIOCM_RTS;
 753         if (set & TIOCM_DTR)
 754                 control_state |= TIOCM_DTR;
 755         if (clear & TIOCM_RTS)
 756                 control_state &= ~TIOCM_RTS;
 757         if (clear & TIOCM_DTR)
 758                 control_state &= ~TIOCM_DTR;
 759
 760         priv->control_state = control_state;
 761         spin_unlock_irqrestore(&priv->lock, flags);
 762         return mct_u232_set_modem_ctrl(port, control_state);
 763 }
 764
 765 static void mct_u232_throttle(struct tty_struct *tty)
 766 {
 767         struct usb_serial_port *port = tty->driver_data;
 768         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 769         unsigned int control_state;
 770
 771         spin_lock_irq(&priv->lock);
 772         priv->rx_flags |= THROTTLED;
 773         if (C_CRTSCTS(tty)) {
 774                 priv->control_state &= ~TIOCM_RTS;
 775                 control_state = priv->control_state;
 776                 spin_unlock_irq(&priv->lock);
 777                 mct_u232_set_modem_ctrl(port, control_state);
 778         } else {
 779                 spin_unlock_irq(&priv->lock);
 780         }
 781 }
 782
 783 static void mct_u232_unthrottle(struct tty_struct *tty)
 784 {
 785         struct usb_serial_port *port = tty->driver_data;
 786         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 787         unsigned int control_state;
 788
 789         spin_lock_irq(&priv->lock);
 790         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 791                 priv->rx_flags &= ~THROTTLED;
 792                 priv->control_state |= TIOCM_RTS;
 793                 control_state = priv->control_state;
 794                 spin_unlock_irq(&priv->lock);
 795                 mct_u232_set_modem_ctrl(port, control_state);
 796         } else {
 797                 spin_unlock_irq(&priv->lock);
 798         }
 799 }
 800
 801 static int  mct_u232_ioctl(struct tty_struct *tty,
 802                         unsigned int cmd, unsigned long arg)
 803 {
 804         DEFINE_WAIT(wait);
 805         struct usb_serial_port *port = tty->driver_data;
 806         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 807         struct async_icount cnow, cprev;
 808         unsigned long flags;
 809
 810         dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
 811
 812         switch (cmd) {
 813
 814         case TIOCMIWAIT:
 815
 816                 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
 817
 818                 spin_lock_irqsave(&mct_u232_port->lock, flags);
 819                 cprev = mct_u232_port->icount;
 820                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 821                 for ( ; ; ) {
 822                         prepare_to_wait(&mct_u232_port->msr_wait,
 823                                         &wait, TASK_INTERRUPTIBLE);
 824                         schedule();
 825                         finish_wait(&mct_u232_port->msr_wait, &wait);
 826                         /* see if a signal did it */
 827                         if (signal_pending(current))
 828                                 return -ERESTARTSYS;
 829                         spin_lock_irqsave(&mct_u232_port->lock, flags);
 830                         cnow = mct_u232_port->icount;
 831                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 832                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
 833                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
 834                                 return -EIO; /* no change => error */
 835                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
 836                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
 837                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
 838                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
 839                                 return 0;
 840                         }
 841                         cprev = cnow;
 842                 }
 843
 844         }
 845         return -ENOIOCTLCMD;
 846 }
 847
 848 static int  mct_u232_get_icount(struct tty_struct *tty,
 849                         struct serial_icounter_struct *icount)
 850 {
 851         struct usb_serial_port *port = tty->driver_data;
 852         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 853         struct async_icount *ic = &mct_u232_port->icount;
 854         unsigned long flags;
 855
 856         spin_lock_irqsave(&mct_u232_port->lock, flags);
 857
 858         icount->cts = ic->cts;
 859         icount->dsr = ic->dsr;
 860         icount->rng = ic->rng;
 861         icount->dcd = ic->dcd;
 862         icount->rx = ic->rx;
 863         icount->tx = ic->tx;
 864         icount->frame = ic->frame;
 865         icount->overrun = ic->overrun;
 866         icount->parity = ic->parity;
 867         icount->brk = ic->brk;
 868         icount->buf_overrun = ic->buf_overrun;
 869
 870         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 871
 872         dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
 873                 __func__,  icount->rx, icount->tx);
 874         return 0;
 875 }
 876
 877 module_usb_serial_driver(serial_drivers, id_table);
 878
 879 MODULE_AUTHOR(DRIVER_AUTHOR);
 880 MODULE_DESCRIPTION(DRIVER_DESC);
 881 MODULE_LICENSE("GPL");