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