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