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