Pileus Git - ~andy/linux/blob - drivers/usb/serial/mct_u232.c

   1 /*
   2  * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
   3  *
   4  *   Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  * This program is largely derived from the Belkin USB Serial Adapter Driver
  12  * (see belkin_sa.[ch]). All of the information about the device was acquired
  13  * by using SniffUSB on Windows98. For technical details see mct_u232.h.
  14  *
  15  * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
  16  * do the reverse engineering and how to write a USB serial device driver.
  17  *
  18  * TO BE DONE, TO BE CHECKED:
  19  *   DTR/RTS signal handling may be incomplete or incorrect. I have mainly
  20  *   implemented what I have seen with SniffUSB or found in belkin_sa.c.
  21  *   For further TODOs check also belkin_sa.c.
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/errno.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/tty.h>
  29 #include <linux/tty_driver.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/module.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/uaccess.h>
  34 #include <asm/unaligned.h>
  35 #include <linux/usb.h>
  36 #include <linux/usb/serial.h>
  37 #include <linux/serial.h>
  38 #include <linux/ioctl.h>
  39 #include "mct_u232.h"
  40
  41 /*
  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         dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", 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         dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n",
 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_port *port,
 267                                   unsigned char lcr)
 268 {
 269         int rc;
 270         unsigned char *buf;
 271
 272         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 273         if (buf == NULL)
 274                 return -ENOMEM;
 275
 276         buf[0] = lcr;
 277         rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
 278                         MCT_U232_SET_LINE_CTRL_REQUEST,
 279                         MCT_U232_SET_REQUEST_TYPE,
 280                         0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
 281                         WDR_TIMEOUT);
 282         if (rc < 0)
 283                 dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
 284         dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", 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_port *port,
 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(port->serial->dev, usb_sndctrlpipe(port->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         kfree(buf);
 313
 314         dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr);
 315
 316         if (rc < 0) {
 317                 dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
 318                 return rc;
 319         }
 320         return 0;
 321 } /* mct_u232_set_modem_ctrl */
 322
 323 static int mct_u232_get_modem_stat(struct usb_serial_port *port,
 324                                    unsigned char *msr)
 325 {
 326         int rc;
 327         unsigned char *buf;
 328
 329         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 330         if (buf == NULL) {
 331                 *msr = 0;
 332                 return -ENOMEM;
 333         }
 334         rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),
 335                         MCT_U232_GET_MODEM_STAT_REQUEST,
 336                         MCT_U232_GET_REQUEST_TYPE,
 337                         0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
 338                         WDR_TIMEOUT);
 339         if (rc < 0) {
 340                 dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc);
 341                 *msr = 0;
 342         } else {
 343                 *msr = buf[0];
 344         }
 345         dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr);
 346         kfree(buf);
 347         return rc;
 348 } /* mct_u232_get_modem_stat */
 349
 350 static void mct_u232_msr_to_icount(struct async_icount *icount,
 351                                                 unsigned char msr)
 352 {
 353         /* Translate Control Line states */
 354         if (msr & MCT_U232_MSR_DDSR)
 355                 icount->dsr++;
 356         if (msr & MCT_U232_MSR_DCTS)
 357                 icount->cts++;
 358         if (msr & MCT_U232_MSR_DRI)
 359                 icount->rng++;
 360         if (msr & MCT_U232_MSR_DCD)
 361                 icount->dcd++;
 362 } /* mct_u232_msr_to_icount */
 363
 364 static void mct_u232_msr_to_state(struct usb_serial_port *port,
 365                                   unsigned int *control_state, unsigned char msr)
 366 {
 367         /* Translate Control Line states */
 368         if (msr & MCT_U232_MSR_DSR)
 369                 *control_state |=  TIOCM_DSR;
 370         else
 371                 *control_state &= ~TIOCM_DSR;
 372         if (msr & MCT_U232_MSR_CTS)
 373                 *control_state |=  TIOCM_CTS;
 374         else
 375                 *control_state &= ~TIOCM_CTS;
 376         if (msr & MCT_U232_MSR_RI)
 377                 *control_state |=  TIOCM_RI;
 378         else
 379                 *control_state &= ~TIOCM_RI;
 380         if (msr & MCT_U232_MSR_CD)
 381                 *control_state |=  TIOCM_CD;
 382         else
 383                 *control_state &= ~TIOCM_CD;
 384         dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state);
 385 } /* mct_u232_msr_to_state */
 386
 387 /*
 388  * Driver's tty interface functions
 389  */
 390
 391 static int mct_u232_startup(struct usb_serial *serial)
 392 {
 393         struct mct_u232_private *priv;
 394         struct usb_serial_port *port, *rport;
 395
 396         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 397         if (!priv)
 398                 return -ENOMEM;
 399         spin_lock_init(&priv->lock);
 400         init_waitqueue_head(&priv->msr_wait);
 401         usb_set_serial_port_data(serial->port[0], priv);
 402
 403         init_waitqueue_head(&serial->port[0]->write_wait);
 404
 405         /* Puh, that's dirty */
 406         port = serial->port[0];
 407         rport = serial->port[1];
 408         /* No unlinking, it wasn't submitted yet. */
 409         usb_free_urb(port->read_urb);
 410         port->read_urb = rport->interrupt_in_urb;
 411         rport->interrupt_in_urb = NULL;
 412         port->read_urb->context = port;
 413
 414         return 0;
 415 } /* mct_u232_startup */
 416
 417
 418 static void mct_u232_release(struct usb_serial *serial)
 419 {
 420         struct mct_u232_private *priv;
 421         int i;
 422
 423         for (i = 0; i < serial->num_ports; ++i) {
 424                 /* My special items, the standard routines free my urbs */
 425                 priv = usb_get_serial_port_data(serial->port[i]);
 426                 kfree(priv);
 427         }
 428 } /* mct_u232_release */
 429
 430 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 431 {
 432         struct usb_serial *serial = port->serial;
 433         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 434         int retval = 0;
 435         unsigned int control_state;
 436         unsigned long flags;
 437         unsigned char last_lcr;
 438         unsigned char last_msr;
 439
 440         /* Compensate for a hardware bug: although the Sitecom U232-P25
 441          * device reports a maximum output packet size of 32 bytes,
 442          * it seems to be able to accept only 16 bytes (and that's what
 443          * SniffUSB says too...)
 444          */
 445         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 446                                                 == MCT_U232_SITECOM_PID)
 447                 port->bulk_out_size = 16;
 448
 449         /* Do a defined restart: the normal serial device seems to
 450          * always turn on DTR and RTS here, so do the same. I'm not
 451          * sure if this is really necessary. But it should not harm
 452          * either.
 453          */
 454         spin_lock_irqsave(&priv->lock, flags);
 455         if (tty && (tty->termios->c_cflag & CBAUD))
 456                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 457         else
 458                 priv->control_state = 0;
 459
 460         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 461                           MCT_U232_PARITY_NONE |
 462                           MCT_U232_STOP_BITS_1);
 463         control_state = priv->control_state;
 464         last_lcr = priv->last_lcr;
 465         spin_unlock_irqrestore(&priv->lock, flags);
 466         mct_u232_set_modem_ctrl(port, control_state);
 467         mct_u232_set_line_ctrl(port, last_lcr);
 468
 469         /* Read modem status and update control state */
 470         mct_u232_get_modem_stat(port, &last_msr);
 471         spin_lock_irqsave(&priv->lock, flags);
 472         priv->last_msr = last_msr;
 473         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 474         spin_unlock_irqrestore(&priv->lock, flags);
 475
 476         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 477         if (retval) {
 478                 dev_err(&port->dev,
 479                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 480                         port->read_urb->pipe, retval);
 481                 goto error;
 482         }
 483
 484         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 485         if (retval) {
 486                 usb_kill_urb(port->read_urb);
 487                 dev_err(&port->dev,
 488                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 489                         port->interrupt_in_urb->pipe, retval);
 490                 goto error;
 491         }
 492         return 0;
 493
 494 error:
 495         return retval;
 496 } /* mct_u232_open */
 497
 498 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 499 {
 500         unsigned int control_state;
 501         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 502
 503         mutex_lock(&port->serial->disc_mutex);
 504         if (!port->serial->disconnected) {
 505                 /* drop DTR and RTS */
 506                 spin_lock_irq(&priv->lock);
 507                 if (on)
 508                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 509                 else
 510                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 511                 control_state = priv->control_state;
 512                 spin_unlock_irq(&priv->lock);
 513                 mct_u232_set_modem_ctrl(port, control_state);
 514         }
 515         mutex_unlock(&port->serial->disc_mutex);
 516 }
 517
 518 static void mct_u232_close(struct usb_serial_port *port)
 519 {
 520         if (port->serial->dev) {
 521                 /* shutdown our urbs */
 522                 usb_kill_urb(port->write_urb);
 523                 usb_kill_urb(port->read_urb);
 524                 usb_kill_urb(port->interrupt_in_urb);
 525         }
 526 } /* mct_u232_close */
 527
 528
 529 static void mct_u232_read_int_callback(struct urb *urb)
 530 {
 531         struct usb_serial_port *port = urb->context;
 532         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 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                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 548                         __func__, status);
 549                 return;
 550         default:
 551                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 552                         __func__, status);
 553                 goto exit;
 554         }
 555
 556         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 557
 558         /*
 559          * Work-a-round: handle the 'usual' bulk-in pipe here
 560          */
 561         if (urb->transfer_buffer_length > 2) {
 562                 if (urb->actual_length) {
 563                         tty = tty_port_tty_get(&port->port);
 564                         if (tty) {
 565                                 tty_insert_flip_string(tty, data,
 566                                                 urb->actual_length);
 567                                 tty_flip_buffer_push(tty);
 568                         }
 569                         tty_kref_put(tty);
 570                 }
 571                 goto exit;
 572         }
 573
 574         /*
 575          * The interrupt-in pipe signals exceptional conditions (modem line
 576          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 577          */
 578         spin_lock_irqsave(&priv->lock, flags);
 579         priv->last_msr = data[MCT_U232_MSR_INDEX];
 580
 581         /* Record Control Line states */
 582         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 583
 584         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 585
 586 #if 0
 587         /* Not yet handled. See belkin_sa.c for further information */
 588         /* Now to report any errors */
 589         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 590         /*
 591          * fill in the flip buffer here, but I do not know the relation
 592          * to the current/next receive buffer or characters.  I need
 593          * to look in to this before committing any code.
 594          */
 595         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 596                 tty = tty_port_tty_get(&port->port);
 597                 /* Overrun Error */
 598                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 599                 }
 600                 /* Parity Error */
 601                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 602                 }
 603                 /* Framing Error */
 604                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 605                 }
 606                 /* Break Indicator */
 607                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 608                 }
 609                 tty_kref_put(tty);
 610         }
 611 #endif
 612         wake_up_interruptible(&priv->msr_wait);
 613         spin_unlock_irqrestore(&priv->lock, flags);
 614 exit:
 615         retval = usb_submit_urb(urb, GFP_ATOMIC);
 616         if (retval)
 617                 dev_err(&port->dev,
 618                         "%s - usb_submit_urb failed with result %d\n",
 619                         __func__, retval);
 620 } /* mct_u232_read_int_callback */
 621
 622 static void mct_u232_set_termios(struct tty_struct *tty,
 623                                  struct usb_serial_port *port,
 624                                  struct ktermios *old_termios)
 625 {
 626         struct usb_serial *serial = port->serial;
 627         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 628         struct ktermios *termios = tty->termios;
 629         unsigned int cflag = termios->c_cflag;
 630         unsigned int old_cflag = old_termios->c_cflag;
 631         unsigned long flags;
 632         unsigned int control_state;
 633         unsigned char last_lcr;
 634
 635         /* get a local copy of the current port settings */
 636         spin_lock_irqsave(&priv->lock, flags);
 637         control_state = priv->control_state;
 638         spin_unlock_irqrestore(&priv->lock, flags);
 639         last_lcr = 0;
 640
 641         /*
 642          * Update baud rate.
 643          * Do not attempt to cache old rates and skip settings,
 644          * disconnects screw such tricks up completely.
 645          * Premature optimization is the root of all evil.
 646          */
 647
 648         /* reassert DTR and RTS on transition from B0 */
 649         if ((old_cflag & CBAUD) == B0) {
 650                 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
 651                 control_state |= TIOCM_DTR | TIOCM_RTS;
 652                 mct_u232_set_modem_ctrl(port, control_state);
 653         }
 654
 655         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 656
 657         if ((cflag & CBAUD) == B0) {
 658                 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
 659                 /* Drop RTS and DTR */
 660                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 661                 mct_u232_set_modem_ctrl(port, control_state);
 662         }
 663
 664         /*
 665          * Update line control register (LCR)
 666          */
 667
 668         /* set the parity */
 669         if (cflag & PARENB)
 670                 last_lcr |= (cflag & PARODD) ?
 671                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 672         else
 673                 last_lcr |= MCT_U232_PARITY_NONE;
 674
 675         /* set the number of data bits */
 676         switch (cflag & CSIZE) {
 677         case CS5:
 678                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 679         case CS6:
 680                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 681         case CS7:
 682                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 683         case CS8:
 684                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 685         default:
 686                 dev_err(&port->dev,
 687                         "CSIZE was not CS5-CS8, using default of 8\n");
 688                 last_lcr |= MCT_U232_DATA_BITS_8;
 689                 break;
 690         }
 691
 692         termios->c_cflag &= ~CMSPAR;
 693
 694         /* set the number of stop bits */
 695         last_lcr |= (cflag & CSTOPB) ?
 696                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 697
 698         mct_u232_set_line_ctrl(port, last_lcr);
 699
 700         /* save off the modified port settings */
 701         spin_lock_irqsave(&priv->lock, flags);
 702         priv->control_state = control_state;
 703         priv->last_lcr = last_lcr;
 704         spin_unlock_irqrestore(&priv->lock, flags);
 705 } /* mct_u232_set_termios */
 706
 707 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 708 {
 709         struct usb_serial_port *port = tty->driver_data;
 710         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 711         unsigned char lcr;
 712         unsigned long flags;
 713
 714         spin_lock_irqsave(&priv->lock, flags);
 715         lcr = priv->last_lcr;
 716
 717         if (break_state)
 718                 lcr |= MCT_U232_SET_BREAK;
 719         spin_unlock_irqrestore(&priv->lock, flags);
 720
 721         mct_u232_set_line_ctrl(port, lcr);
 722 } /* mct_u232_break_ctl */
 723
 724
 725 static int mct_u232_tiocmget(struct tty_struct *tty)
 726 {
 727         struct usb_serial_port *port = tty->driver_data;
 728         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 729         unsigned int control_state;
 730         unsigned long flags;
 731
 732         spin_lock_irqsave(&priv->lock, flags);
 733         control_state = priv->control_state;
 734         spin_unlock_irqrestore(&priv->lock, flags);
 735
 736         return control_state;
 737 }
 738
 739 static int mct_u232_tiocmset(struct tty_struct *tty,
 740                               unsigned int set, unsigned int clear)
 741 {
 742         struct usb_serial_port *port = tty->driver_data;
 743         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 744         unsigned int control_state;
 745         unsigned long flags;
 746
 747         spin_lock_irqsave(&priv->lock, flags);
 748         control_state = priv->control_state;
 749
 750         if (set & TIOCM_RTS)
 751                 control_state |= TIOCM_RTS;
 752         if (set & TIOCM_DTR)
 753                 control_state |= TIOCM_DTR;
 754         if (clear & TIOCM_RTS)
 755                 control_state &= ~TIOCM_RTS;
 756         if (clear & TIOCM_DTR)
 757                 control_state &= ~TIOCM_DTR;
 758
 759         priv->control_state = control_state;
 760         spin_unlock_irqrestore(&priv->lock, flags);
 761         return mct_u232_set_modem_ctrl(port, control_state);
 762 }
 763
 764 static void mct_u232_throttle(struct tty_struct *tty)
 765 {
 766         struct usb_serial_port *port = tty->driver_data;
 767         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 768         unsigned int control_state;
 769
 770         spin_lock_irq(&priv->lock);
 771         priv->rx_flags |= THROTTLED;
 772         if (C_CRTSCTS(tty)) {
 773                 priv->control_state &= ~TIOCM_RTS;
 774                 control_state = priv->control_state;
 775                 spin_unlock_irq(&priv->lock);
 776                 mct_u232_set_modem_ctrl(port, control_state);
 777         } else {
 778                 spin_unlock_irq(&priv->lock);
 779         }
 780 }
 781
 782 static void mct_u232_unthrottle(struct tty_struct *tty)
 783 {
 784         struct usb_serial_port *port = tty->driver_data;
 785         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 786         unsigned int control_state;
 787
 788         spin_lock_irq(&priv->lock);
 789         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 790                 priv->rx_flags &= ~THROTTLED;
 791                 priv->control_state |= TIOCM_RTS;
 792                 control_state = priv->control_state;
 793                 spin_unlock_irq(&priv->lock);
 794                 mct_u232_set_modem_ctrl(port, control_state);
 795         } else {
 796                 spin_unlock_irq(&priv->lock);
 797         }
 798 }
 799
 800 static int  mct_u232_ioctl(struct tty_struct *tty,
 801                         unsigned int cmd, unsigned long arg)
 802 {
 803         DEFINE_WAIT(wait);
 804         struct usb_serial_port *port = tty->driver_data;
 805         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 806         struct async_icount cnow, cprev;
 807         unsigned long flags;
 808
 809         dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
 810
 811         switch (cmd) {
 812
 813         case TIOCMIWAIT:
 814
 815                 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
 816
 817                 spin_lock_irqsave(&mct_u232_port->lock, flags);
 818                 cprev = mct_u232_port->icount;
 819                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 820                 for ( ; ; ) {
 821                         prepare_to_wait(&mct_u232_port->msr_wait,
 822                                         &wait, TASK_INTERRUPTIBLE);
 823                         schedule();
 824                         finish_wait(&mct_u232_port->msr_wait, &wait);
 825                         /* see if a signal did it */
 826                         if (signal_pending(current))
 827                                 return -ERESTARTSYS;
 828                         spin_lock_irqsave(&mct_u232_port->lock, flags);
 829                         cnow = mct_u232_port->icount;
 830                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 831                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
 832                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
 833                                 return -EIO; /* no change => error */
 834                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
 835                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
 836                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
 837                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
 838                                 return 0;
 839                         }
 840                         cprev = cnow;
 841                 }
 842
 843         }
 844         return -ENOIOCTLCMD;
 845 }
 846
 847 static int  mct_u232_get_icount(struct tty_struct *tty,
 848                         struct serial_icounter_struct *icount)
 849 {
 850         struct usb_serial_port *port = tty->driver_data;
 851         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 852         struct async_icount *ic = &mct_u232_port->icount;
 853         unsigned long flags;
 854
 855         spin_lock_irqsave(&mct_u232_port->lock, flags);
 856
 857         icount->cts = ic->cts;
 858         icount->dsr = ic->dsr;
 859         icount->rng = ic->rng;
 860         icount->dcd = ic->dcd;
 861         icount->rx = ic->rx;
 862         icount->tx = ic->tx;
 863         icount->frame = ic->frame;
 864         icount->overrun = ic->overrun;
 865         icount->parity = ic->parity;
 866         icount->brk = ic->brk;
 867         icount->buf_overrun = ic->buf_overrun;
 868
 869         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 870
 871         dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
 872                 __func__,  icount->rx, icount->tx);
 873         return 0;
 874 }
 875
 876 module_usb_serial_driver(serial_drivers, id_table);
 877
 878 MODULE_AUTHOR(DRIVER_AUTHOR);
 879 MODULE_DESCRIPTION(DRIVER_DESC);
 880 MODULE_LICENSE("GPL");
 881
 882 module_param(debug, bool, S_IRUGO | S_IWUSR);
 883 MODULE_PARM_DESC(debug, "Debug enabled or not");