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