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 /*
  49  * Function prototypes
  50  */
  51 static int  mct_u232_startup(struct usb_serial *serial);
  52 static int  mct_u232_port_probe(struct usb_serial_port *port);
  53 static int  mct_u232_port_remove(struct usb_serial_port *remove);
  54 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
  55 static void mct_u232_close(struct usb_serial_port *port);
  56 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
  57 static void mct_u232_read_int_callback(struct urb *urb);
  58 static void mct_u232_set_termios(struct tty_struct *tty,
  59                         struct usb_serial_port *port, struct ktermios *old);
  60 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
  61 static int  mct_u232_tiocmget(struct tty_struct *tty);
  62 static int  mct_u232_tiocmset(struct tty_struct *tty,
  63                         unsigned int set, unsigned int clear);
  64 static int  mct_u232_ioctl(struct tty_struct *tty,
  65                         unsigned int cmd, unsigned long arg);
  66 static int  mct_u232_get_icount(struct tty_struct *tty,
  67                         struct serial_icounter_struct *icount);
  68 static void mct_u232_throttle(struct tty_struct *tty);
  69 static void mct_u232_unthrottle(struct tty_struct *tty);
  70
  71
  72 /*
  73  * All of the device info needed for the MCT USB-RS232 converter.
  74  */
  75 static const struct usb_device_id id_table[] = {
  76         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
  77         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
  78         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
  79         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
  80         { }             /* Terminating entry */
  81 };
  82 MODULE_DEVICE_TABLE(usb, id_table);
  83
  84 static struct usb_serial_driver mct_u232_device = {
  85         .driver = {
  86                 .owner =        THIS_MODULE,
  87                 .name =         "mct_u232",
  88         },
  89         .description =       "MCT U232",
  90         .id_table =          id_table,
  91         .num_ports =         1,
  92         .open =              mct_u232_open,
  93         .close =             mct_u232_close,
  94         .dtr_rts =           mct_u232_dtr_rts,
  95         .throttle =          mct_u232_throttle,
  96         .unthrottle =        mct_u232_unthrottle,
  97         .read_int_callback = mct_u232_read_int_callback,
  98         .set_termios =       mct_u232_set_termios,
  99         .break_ctl =         mct_u232_break_ctl,
 100         .tiocmget =          mct_u232_tiocmget,
 101         .tiocmset =          mct_u232_tiocmset,
 102         .attach =            mct_u232_startup,
 103         .port_probe =        mct_u232_port_probe,
 104         .port_remove =       mct_u232_port_remove,
 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 usb_serial_port *port, *rport;
 394
 395         /* Puh, that's dirty */
 396         port = serial->port[0];
 397         rport = serial->port[1];
 398         /* No unlinking, it wasn't submitted yet. */
 399         usb_free_urb(port->read_urb);
 400         port->read_urb = rport->interrupt_in_urb;
 401         rport->interrupt_in_urb = NULL;
 402         port->read_urb->context = port;
 403
 404         return 0;
 405 } /* mct_u232_startup */
 406
 407 static int mct_u232_port_probe(struct usb_serial_port *port)
 408 {
 409         struct mct_u232_private *priv;
 410
 411         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 412         if (!priv)
 413                 return -ENOMEM;
 414
 415         spin_lock_init(&priv->lock);
 416         init_waitqueue_head(&priv->msr_wait);
 417
 418         usb_set_serial_port_data(port, priv);
 419
 420         return 0;
 421 }
 422
 423 static int mct_u232_port_remove(struct usb_serial_port *port)
 424 {
 425         struct mct_u232_private *priv;
 426
 427         priv = usb_get_serial_port_data(port);
 428         kfree(priv);
 429
 430         return 0;
 431 }
 432
 433 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 434 {
 435         struct usb_serial *serial = port->serial;
 436         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 437         int retval = 0;
 438         unsigned int control_state;
 439         unsigned long flags;
 440         unsigned char last_lcr;
 441         unsigned char last_msr;
 442
 443         /* Compensate for a hardware bug: although the Sitecom U232-P25
 444          * device reports a maximum output packet size of 32 bytes,
 445          * it seems to be able to accept only 16 bytes (and that's what
 446          * SniffUSB says too...)
 447          */
 448         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 449                                                 == MCT_U232_SITECOM_PID)
 450                 port->bulk_out_size = 16;
 451
 452         /* Do a defined restart: the normal serial device seems to
 453          * always turn on DTR and RTS here, so do the same. I'm not
 454          * sure if this is really necessary. But it should not harm
 455          * either.
 456          */
 457         spin_lock_irqsave(&priv->lock, flags);
 458         if (tty && (tty->termios.c_cflag & CBAUD))
 459                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 460         else
 461                 priv->control_state = 0;
 462
 463         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 464                           MCT_U232_PARITY_NONE |
 465                           MCT_U232_STOP_BITS_1);
 466         control_state = priv->control_state;
 467         last_lcr = priv->last_lcr;
 468         spin_unlock_irqrestore(&priv->lock, flags);
 469         mct_u232_set_modem_ctrl(port, control_state);
 470         mct_u232_set_line_ctrl(port, last_lcr);
 471
 472         /* Read modem status and update control state */
 473         mct_u232_get_modem_stat(port, &last_msr);
 474         spin_lock_irqsave(&priv->lock, flags);
 475         priv->last_msr = last_msr;
 476         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 477         spin_unlock_irqrestore(&priv->lock, flags);
 478
 479         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 480         if (retval) {
 481                 dev_err(&port->dev,
 482                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 483                         port->read_urb->pipe, retval);
 484                 goto error;
 485         }
 486
 487         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 488         if (retval) {
 489                 usb_kill_urb(port->read_urb);
 490                 dev_err(&port->dev,
 491                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 492                         port->interrupt_in_urb->pipe, retval);
 493                 goto error;
 494         }
 495         return 0;
 496
 497 error:
 498         return retval;
 499 } /* mct_u232_open */
 500
 501 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 502 {
 503         unsigned int control_state;
 504         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 505
 506         mutex_lock(&port->serial->disc_mutex);
 507         if (!port->serial->disconnected) {
 508                 /* drop DTR and RTS */
 509                 spin_lock_irq(&priv->lock);
 510                 if (on)
 511                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 512                 else
 513                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 514                 control_state = priv->control_state;
 515                 spin_unlock_irq(&priv->lock);
 516                 mct_u232_set_modem_ctrl(port, control_state);
 517         }
 518         mutex_unlock(&port->serial->disc_mutex);
 519 }
 520
 521 static void mct_u232_close(struct usb_serial_port *port)
 522 {
 523         /*
 524          * Must kill the read urb as it is actually an interrupt urb, which
 525          * generic close thus fails to kill.
 526          */
 527         usb_kill_urb(port->read_urb);
 528         usb_kill_urb(port->interrupt_in_urb);
 529
 530         usb_serial_generic_close(port);
 531 } /* mct_u232_close */
 532
 533
 534 static void mct_u232_read_int_callback(struct urb *urb)
 535 {
 536         struct usb_serial_port *port = urb->context;
 537         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 538         struct tty_struct *tty;
 539         unsigned char *data = urb->transfer_buffer;
 540         int retval;
 541         int status = urb->status;
 542         unsigned long flags;
 543
 544         switch (status) {
 545         case 0:
 546                 /* success */
 547                 break;
 548         case -ECONNRESET:
 549         case -ENOENT:
 550         case -ESHUTDOWN:
 551                 /* this urb is terminated, clean up */
 552                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 553                         __func__, status);
 554                 return;
 555         default:
 556                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 557                         __func__, status);
 558                 goto exit;
 559         }
 560
 561         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 562
 563         /*
 564          * Work-a-round: handle the 'usual' bulk-in pipe here
 565          */
 566         if (urb->transfer_buffer_length > 2) {
 567                 if (urb->actual_length) {
 568                         tty = tty_port_tty_get(&port->port);
 569                         if (tty) {
 570                                 tty_insert_flip_string(tty, data,
 571                                                 urb->actual_length);
 572                                 tty_flip_buffer_push(tty);
 573                         }
 574                         tty_kref_put(tty);
 575                 }
 576                 goto exit;
 577         }
 578
 579         /*
 580          * The interrupt-in pipe signals exceptional conditions (modem line
 581          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 582          */
 583         spin_lock_irqsave(&priv->lock, flags);
 584         priv->last_msr = data[MCT_U232_MSR_INDEX];
 585
 586         /* Record Control Line states */
 587         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 588
 589         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 590
 591 #if 0
 592         /* Not yet handled. See belkin_sa.c for further information */
 593         /* Now to report any errors */
 594         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 595         /*
 596          * fill in the flip buffer here, but I do not know the relation
 597          * to the current/next receive buffer or characters.  I need
 598          * to look in to this before committing any code.
 599          */
 600         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 601                 tty = tty_port_tty_get(&port->port);
 602                 /* Overrun Error */
 603                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 604                 }
 605                 /* Parity Error */
 606                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 607                 }
 608                 /* Framing Error */
 609                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 610                 }
 611                 /* Break Indicator */
 612                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 613                 }
 614                 tty_kref_put(tty);
 615         }
 616 #endif
 617         wake_up_interruptible(&priv->msr_wait);
 618         spin_unlock_irqrestore(&priv->lock, flags);
 619 exit:
 620         retval = usb_submit_urb(urb, GFP_ATOMIC);
 621         if (retval)
 622                 dev_err(&port->dev,
 623                         "%s - usb_submit_urb failed with result %d\n",
 624                         __func__, retval);
 625 } /* mct_u232_read_int_callback */
 626
 627 static void mct_u232_set_termios(struct tty_struct *tty,
 628                                  struct usb_serial_port *port,
 629                                  struct ktermios *old_termios)
 630 {
 631         struct usb_serial *serial = port->serial;
 632         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 633         struct ktermios *termios = &tty->termios;
 634         unsigned int cflag = termios->c_cflag;
 635         unsigned int old_cflag = old_termios->c_cflag;
 636         unsigned long flags;
 637         unsigned int control_state;
 638         unsigned char last_lcr;
 639
 640         /* get a local copy of the current port settings */
 641         spin_lock_irqsave(&priv->lock, flags);
 642         control_state = priv->control_state;
 643         spin_unlock_irqrestore(&priv->lock, flags);
 644         last_lcr = 0;
 645
 646         /*
 647          * Update baud rate.
 648          * Do not attempt to cache old rates and skip settings,
 649          * disconnects screw such tricks up completely.
 650          * Premature optimization is the root of all evil.
 651          */
 652
 653         /* reassert DTR and RTS on transition from B0 */
 654         if ((old_cflag & CBAUD) == B0) {
 655                 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
 656                 control_state |= TIOCM_DTR | TIOCM_RTS;
 657                 mct_u232_set_modem_ctrl(port, control_state);
 658         }
 659
 660         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 661
 662         if ((cflag & CBAUD) == B0) {
 663                 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
 664                 /* Drop RTS and DTR */
 665                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 666                 mct_u232_set_modem_ctrl(port, control_state);
 667         }
 668
 669         /*
 670          * Update line control register (LCR)
 671          */
 672
 673         /* set the parity */
 674         if (cflag & PARENB)
 675                 last_lcr |= (cflag & PARODD) ?
 676                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 677         else
 678                 last_lcr |= MCT_U232_PARITY_NONE;
 679
 680         /* set the number of data bits */
 681         switch (cflag & CSIZE) {
 682         case CS5:
 683                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 684         case CS6:
 685                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 686         case CS7:
 687                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 688         case CS8:
 689                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 690         default:
 691                 dev_err(&port->dev,
 692                         "CSIZE was not CS5-CS8, using default of 8\n");
 693                 last_lcr |= MCT_U232_DATA_BITS_8;
 694                 break;
 695         }
 696
 697         termios->c_cflag &= ~CMSPAR;
 698
 699         /* set the number of stop bits */
 700         last_lcr |= (cflag & CSTOPB) ?
 701                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 702
 703         mct_u232_set_line_ctrl(port, last_lcr);
 704
 705         /* save off the modified port settings */
 706         spin_lock_irqsave(&priv->lock, flags);
 707         priv->control_state = control_state;
 708         priv->last_lcr = last_lcr;
 709         spin_unlock_irqrestore(&priv->lock, flags);
 710 } /* mct_u232_set_termios */
 711
 712 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 713 {
 714         struct usb_serial_port *port = tty->driver_data;
 715         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 716         unsigned char lcr;
 717         unsigned long flags;
 718
 719         spin_lock_irqsave(&priv->lock, flags);
 720         lcr = priv->last_lcr;
 721
 722         if (break_state)
 723                 lcr |= MCT_U232_SET_BREAK;
 724         spin_unlock_irqrestore(&priv->lock, flags);
 725
 726         mct_u232_set_line_ctrl(port, lcr);
 727 } /* mct_u232_break_ctl */
 728
 729
 730 static int mct_u232_tiocmget(struct tty_struct *tty)
 731 {
 732         struct usb_serial_port *port = tty->driver_data;
 733         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 734         unsigned int control_state;
 735         unsigned long flags;
 736
 737         spin_lock_irqsave(&priv->lock, flags);
 738         control_state = priv->control_state;
 739         spin_unlock_irqrestore(&priv->lock, flags);
 740
 741         return control_state;
 742 }
 743
 744 static int mct_u232_tiocmset(struct tty_struct *tty,
 745                               unsigned int set, unsigned int clear)
 746 {
 747         struct usb_serial_port *port = tty->driver_data;
 748         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 749         unsigned int control_state;
 750         unsigned long flags;
 751
 752         spin_lock_irqsave(&priv->lock, flags);
 753         control_state = priv->control_state;
 754
 755         if (set & TIOCM_RTS)
 756                 control_state |= TIOCM_RTS;
 757         if (set & TIOCM_DTR)
 758                 control_state |= TIOCM_DTR;
 759         if (clear & TIOCM_RTS)
 760                 control_state &= ~TIOCM_RTS;
 761         if (clear & TIOCM_DTR)
 762                 control_state &= ~TIOCM_DTR;
 763
 764         priv->control_state = control_state;
 765         spin_unlock_irqrestore(&priv->lock, flags);
 766         return mct_u232_set_modem_ctrl(port, control_state);
 767 }
 768
 769 static void mct_u232_throttle(struct tty_struct *tty)
 770 {
 771         struct usb_serial_port *port = tty->driver_data;
 772         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 773         unsigned int control_state;
 774
 775         spin_lock_irq(&priv->lock);
 776         priv->rx_flags |= THROTTLED;
 777         if (C_CRTSCTS(tty)) {
 778                 priv->control_state &= ~TIOCM_RTS;
 779                 control_state = priv->control_state;
 780                 spin_unlock_irq(&priv->lock);
 781                 mct_u232_set_modem_ctrl(port, control_state);
 782         } else {
 783                 spin_unlock_irq(&priv->lock);
 784         }
 785 }
 786
 787 static void mct_u232_unthrottle(struct tty_struct *tty)
 788 {
 789         struct usb_serial_port *port = tty->driver_data;
 790         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 791         unsigned int control_state;
 792
 793         spin_lock_irq(&priv->lock);
 794         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 795                 priv->rx_flags &= ~THROTTLED;
 796                 priv->control_state |= TIOCM_RTS;
 797                 control_state = priv->control_state;
 798                 spin_unlock_irq(&priv->lock);
 799                 mct_u232_set_modem_ctrl(port, control_state);
 800         } else {
 801                 spin_unlock_irq(&priv->lock);
 802         }
 803 }
 804
 805 static int  mct_u232_ioctl(struct tty_struct *tty,
 806                         unsigned int cmd, unsigned long arg)
 807 {
 808         DEFINE_WAIT(wait);
 809         struct usb_serial_port *port = tty->driver_data;
 810         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 811         struct async_icount cnow, cprev;
 812         unsigned long flags;
 813
 814         dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
 815
 816         switch (cmd) {
 817
 818         case TIOCMIWAIT:
 819
 820                 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
 821
 822                 spin_lock_irqsave(&mct_u232_port->lock, flags);
 823                 cprev = mct_u232_port->icount;
 824                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 825                 for ( ; ; ) {
 826                         prepare_to_wait(&mct_u232_port->msr_wait,
 827                                         &wait, TASK_INTERRUPTIBLE);
 828                         schedule();
 829                         finish_wait(&mct_u232_port->msr_wait, &wait);
 830                         /* see if a signal did it */
 831                         if (signal_pending(current))
 832                                 return -ERESTARTSYS;
 833                         spin_lock_irqsave(&mct_u232_port->lock, flags);
 834                         cnow = mct_u232_port->icount;
 835                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 836                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
 837                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
 838                                 return -EIO; /* no change => error */
 839                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
 840                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
 841                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
 842                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
 843                                 return 0;
 844                         }
 845                         cprev = cnow;
 846                 }
 847
 848         }
 849         return -ENOIOCTLCMD;
 850 }
 851
 852 static int  mct_u232_get_icount(struct tty_struct *tty,
 853                         struct serial_icounter_struct *icount)
 854 {
 855         struct usb_serial_port *port = tty->driver_data;
 856         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 857         struct async_icount *ic = &mct_u232_port->icount;
 858         unsigned long flags;
 859
 860         spin_lock_irqsave(&mct_u232_port->lock, flags);
 861
 862         icount->cts = ic->cts;
 863         icount->dsr = ic->dsr;
 864         icount->rng = ic->rng;
 865         icount->dcd = ic->dcd;
 866         icount->rx = ic->rx;
 867         icount->tx = ic->tx;
 868         icount->frame = ic->frame;
 869         icount->overrun = ic->overrun;
 870         icount->parity = ic->parity;
 871         icount->brk = ic->brk;
 872         icount->buf_overrun = ic->buf_overrun;
 873
 874         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 875
 876         dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
 877                 __func__,  icount->rx, icount->tx);
 878         return 0;
 879 }
 880
 881 module_usb_serial_driver(serial_drivers, id_table);
 882
 883 MODULE_AUTHOR(DRIVER_AUTHOR);
 884 MODULE_DESCRIPTION(DRIVER_DESC);
 885 MODULE_LICENSE("GPL");