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