git.oblomov.eu Git - 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_shutdown(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 tty_struct *tty,
  99                         struct usb_serial_port *port, struct file *filp);
 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         .throttle =          mct_u232_throttle,
 144         .unthrottle =        mct_u232_unthrottle,
 145         .read_int_callback = mct_u232_read_int_callback,
 146         .set_termios =       mct_u232_set_termios,
 147         .break_ctl =         mct_u232_break_ctl,
 148         .tiocmget =          mct_u232_tiocmget,
 149         .tiocmset =          mct_u232_tiocmset,
 150         .attach =            mct_u232_startup,
 151         .shutdown =          mct_u232_shutdown,
 152 };
 153
 154
 155 struct mct_u232_private {
 156         spinlock_t lock;
 157         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
 158         unsigned char        last_lcr;      /* Line Control Register */
 159         unsigned char        last_lsr;      /* Line Status Register */
 160         unsigned char        last_msr;      /* Modem Status Register */
 161         unsigned int         rx_flags;      /* Throttling flags */
 162 };
 163
 164 #define THROTTLED               0x01
 165
 166 /*
 167  * Handle vendor specific USB requests
 168  */
 169
 170 #define WDR_TIMEOUT 5000 /* default urb timeout */
 171
 172 /*
 173  * Later day 2.6.0-test kernels have new baud rates like B230400 which
 174  * we do not know how to support. We ignore them for the moment.
 175  */
 176 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
 177                                         speed_t value, speed_t *result)
 178 {
 179         *result = value;
 180
 181         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
 182                 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
 183                 switch (value) {
 184                 case 300:
 185                         return 0x01;
 186                 case 600:
 187                         return 0x02; /* this one not tested */
 188                 case 1200:
 189                         return 0x03;
 190                 case 2400:
 191                         return 0x04;
 192                 case 4800:
 193                         return 0x06;
 194                 case 9600:
 195                         return 0x08;
 196                 case 19200:
 197                         return 0x09;
 198                 case 38400:
 199                         return 0x0a;
 200                 case 57600:
 201                         return 0x0b;
 202                 case 115200:
 203                         return 0x0c;
 204                 default:
 205                         *result = 9600;
 206                         return 0x08;
 207                 }
 208         } else {
 209                 /* FIXME: Can we use any divider - should we do
 210                    divider = 115200/value;
 211                    real baud = 115200/divider */
 212                 switch (value) {
 213                 case 300: break;
 214                 case 600: break;
 215                 case 1200: break;
 216                 case 2400: break;
 217                 case 4800: break;
 218                 case 9600: break;
 219                 case 19200: break;
 220                 case 38400: break;
 221                 case 57600: break;
 222                 case 115200: break;
 223                 default:
 224                         value = 9600;
 225                         *result = 9600;
 226                 }
 227                 return 115200/value;
 228         }
 229 }
 230
 231 static int mct_u232_set_baud_rate(struct tty_struct *tty,
 232         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 233 {
 234         __le32 divisor;
 235         int rc;
 236         unsigned char zero_byte = 0;
 237         unsigned char cts_enable_byte = 0;
 238         speed_t speed;
 239
 240         divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value,
 241                                                                 &speed));
 242
 243         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 244                                 MCT_U232_SET_BAUD_RATE_REQUEST,
 245                                 MCT_U232_SET_REQUEST_TYPE,
 246                                 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
 247                                 WDR_TIMEOUT);
 248         if (rc < 0)     /*FIXME: What value speed results */
 249                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
 250                         value, rc);
 251         else
 252                 tty_encode_baud_rate(tty, speed, speed);
 253         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
 254
 255         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
 256            always sends two extra USB 'device request' messages after the
 257            'baud rate change' message.  The actual functionality of the
 258            request codes in these messages is not fully understood but these
 259            particular codes are never seen in any operation besides a baud
 260            rate change.  Both of these messages send a single byte of data.
 261            In the first message, the value of this byte is always zero.
 262
 263            The second message has been determined experimentally to control
 264            whether data will be transmitted to a device which is not asserting
 265            the 'CTS' signal.  If the second message's data byte is zero, data
 266            will be transmitted even if 'CTS' is not asserted (i.e. no hardware
 267            flow control).  if the second message's data byte is nonzero (a
 268            value of 1 is used by this driver), data will not be transmitted to
 269            a device which is not asserting 'CTS'.
 270         */
 271
 272         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 273                                 MCT_U232_SET_UNKNOWN1_REQUEST,
 274                                 MCT_U232_SET_REQUEST_TYPE,
 275                                 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
 276                                 WDR_TIMEOUT);
 277         if (rc < 0)
 278                 dev_err(&port->dev, "Sending USB device request code %d "
 279                         "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
 280                         rc);
 281
 282         if (port && C_CRTSCTS(tty))
 283            cts_enable_byte = 1;
 284
 285         dbg("set_baud_rate: send second control message, data = %02X",
 286                                                         cts_enable_byte);
 287         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 288                         MCT_U232_SET_CTS_REQUEST,
 289                         MCT_U232_SET_REQUEST_TYPE,
 290                         0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
 291                         WDR_TIMEOUT);
 292         if (rc < 0)
 293                 dev_err(&port->dev, "Sending USB device request code %d "
 294                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
 295
 296         return rc;
 297 } /* mct_u232_set_baud_rate */
 298
 299 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
 300 {
 301         int rc;
 302         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 303                         MCT_U232_SET_LINE_CTRL_REQUEST,
 304                         MCT_U232_SET_REQUEST_TYPE,
 305                         0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
 306                         WDR_TIMEOUT);
 307         if (rc < 0)
 308                 dev_err(&serial->dev->dev,
 309                         "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
 310         dbg("set_line_ctrl: 0x%x", lcr);
 311         return rc;
 312 } /* mct_u232_set_line_ctrl */
 313
 314 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
 315                                    unsigned int control_state)
 316 {
 317         int rc;
 318         unsigned char mcr = MCT_U232_MCR_NONE;
 319
 320         if (control_state & TIOCM_DTR)
 321                 mcr |= MCT_U232_MCR_DTR;
 322         if (control_state & TIOCM_RTS)
 323                 mcr |= MCT_U232_MCR_RTS;
 324
 325         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 326                         MCT_U232_SET_MODEM_CTRL_REQUEST,
 327                         MCT_U232_SET_REQUEST_TYPE,
 328                         0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
 329                         WDR_TIMEOUT);
 330         if (rc < 0)
 331                 dev_err(&serial->dev->dev,
 332                         "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
 333         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
 334
 335         return rc;
 336 } /* mct_u232_set_modem_ctrl */
 337
 338 static int mct_u232_get_modem_stat(struct usb_serial *serial,
 339                                                 unsigned char *msr)
 340 {
 341         int rc;
 342         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 343                         MCT_U232_GET_MODEM_STAT_REQUEST,
 344                         MCT_U232_GET_REQUEST_TYPE,
 345                         0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
 346                         WDR_TIMEOUT);
 347         if (rc < 0) {
 348                 dev_err(&serial->dev->dev,
 349                         "Get MODEM STATus failed (error = %d)\n", rc);
 350                 *msr = 0;
 351         }
 352         dbg("get_modem_stat: 0x%x", *msr);
 353         return rc;
 354 } /* mct_u232_get_modem_stat */
 355
 356 static void mct_u232_msr_to_state(unsigned int *control_state,
 357                                                 unsigned char msr)
 358 {
 359         /* Translate Control Line states */
 360         if (msr & MCT_U232_MSR_DSR)
 361                 *control_state |=  TIOCM_DSR;
 362         else
 363                 *control_state &= ~TIOCM_DSR;
 364         if (msr & MCT_U232_MSR_CTS)
 365                 *control_state |=  TIOCM_CTS;
 366         else
 367                 *control_state &= ~TIOCM_CTS;
 368         if (msr & MCT_U232_MSR_RI)
 369                 *control_state |=  TIOCM_RI;
 370         else
 371                 *control_state &= ~TIOCM_RI;
 372         if (msr & MCT_U232_MSR_CD)
 373                 *control_state |=  TIOCM_CD;
 374         else
 375                 *control_state &= ~TIOCM_CD;
 376         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
 377 } /* mct_u232_msr_to_state */
 378
 379 /*
 380  * Driver's tty interface functions
 381  */
 382
 383 static int mct_u232_startup(struct usb_serial *serial)
 384 {
 385         struct mct_u232_private *priv;
 386         struct usb_serial_port *port, *rport;
 387
 388         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 389         if (!priv)
 390                 return -ENOMEM;
 391         spin_lock_init(&priv->lock);
 392         usb_set_serial_port_data(serial->port[0], priv);
 393
 394         init_waitqueue_head(&serial->port[0]->write_wait);
 395
 396         /* Puh, that's dirty */
 397         port = serial->port[0];
 398         rport = serial->port[1];
 399         /* No unlinking, it wasn't submitted yet. */
 400         usb_free_urb(port->read_urb);
 401         port->read_urb = rport->interrupt_in_urb;
 402         rport->interrupt_in_urb = NULL;
 403         port->read_urb->context = port;
 404
 405         return 0;
 406 } /* mct_u232_startup */
 407
 408
 409 static void mct_u232_shutdown(struct usb_serial *serial)
 410 {
 411         struct mct_u232_private *priv;
 412         int i;
 413
 414         dbg("%s", __func__);
 415
 416         for (i = 0; i < serial->num_ports; ++i) {
 417                 /* My special items, the standard routines free my urbs */
 418                 priv = usb_get_serial_port_data(serial->port[i]);
 419                 if (priv) {
 420                         usb_set_serial_port_data(serial->port[i], NULL);
 421                         kfree(priv);
 422                 }
 423         }
 424 } /* mct_u232_shutdown */
 425
 426 static int  mct_u232_open(struct tty_struct *tty,
 427                         struct usb_serial_port *port, struct file *filp)
 428 {
 429         struct usb_serial *serial = port->serial;
 430         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 431         int retval = 0;
 432         unsigned int control_state;
 433         unsigned long flags;
 434         unsigned char last_lcr;
 435         unsigned char last_msr;
 436
 437         dbg("%s port %d", __func__, port->number);
 438
 439         /* Compensate for a hardware bug: although the Sitecom U232-P25
 440          * device reports a maximum output packet size of 32 bytes,
 441          * it seems to be able to accept only 16 bytes (and that's what
 442          * SniffUSB says too...)
 443          */
 444         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 445                                                 == MCT_U232_SITECOM_PID)
 446                 port->bulk_out_size = 16;
 447
 448         /* Do a defined restart: the normal serial device seems to
 449          * always turn on DTR and RTS here, so do the same. I'm not
 450          * sure if this is really necessary. But it should not harm
 451          * either.
 452          */
 453         spin_lock_irqsave(&priv->lock, flags);
 454         if (tty && (tty->termios->c_cflag & CBAUD))
 455                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 456         else
 457                 priv->control_state = 0;
 458
 459         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 460                           MCT_U232_PARITY_NONE |
 461                           MCT_U232_STOP_BITS_1);
 462         control_state = priv->control_state;
 463         last_lcr = priv->last_lcr;
 464         spin_unlock_irqrestore(&priv->lock, flags);
 465         mct_u232_set_modem_ctrl(serial, control_state);
 466         mct_u232_set_line_ctrl(serial, last_lcr);
 467
 468         /* Read modem status and update control state */
 469         mct_u232_get_modem_stat(serial, &last_msr);
 470         spin_lock_irqsave(&priv->lock, flags);
 471         priv->last_msr = last_msr;
 472         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 473         spin_unlock_irqrestore(&priv->lock, flags);
 474
 475         port->read_urb->dev = port->serial->dev;
 476         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 477         if (retval) {
 478                 dev_err(&port->dev,
 479                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 480                         port->read_urb->pipe, retval);
 481                 goto error;
 482         }
 483
 484         port->interrupt_in_urb->dev = port->serial->dev;
 485         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 486         if (retval) {
 487                 usb_kill_urb(port->read_urb);
 488                 dev_err(&port->dev,
 489                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 490                         port->interrupt_in_urb->pipe, retval);
 491                 goto error;
 492         }
 493         return 0;
 494
 495 error:
 496         return retval;
 497 } /* mct_u232_open */
 498
 499
 500 static void mct_u232_close(struct tty_struct *tty,
 501                         struct usb_serial_port *port, struct file *filp)
 502 {
 503         unsigned int c_cflag;
 504         unsigned int control_state;
 505         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 506         dbg("%s port %d", __func__, port->number);
 507
 508         if (tty) {
 509                 c_cflag = tty->termios->c_cflag;
 510                 mutex_lock(&port->serial->disc_mutex);
 511                 if (c_cflag & HUPCL && !port->serial->disconnected) {
 512                         /* drop DTR and RTS */
 513                         spin_lock_irq(&priv->lock);
 514                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 515                         control_state = priv->control_state;
 516                         spin_unlock_irq(&priv->lock);
 517                         mct_u232_set_modem_ctrl(port->serial, control_state);
 518                 }
 519                 mutex_unlock(&port->serial->disc_mutex);
 520         }
 521
 522
 523         if (port->serial->dev) {
 524                 /* shutdown our urbs */
 525                 usb_kill_urb(port->write_urb);
 526                 usb_kill_urb(port->read_urb);
 527                 usb_kill_urb(port->interrupt_in_urb);
 528         }
 529 } /* mct_u232_close */
 530
 531
 532 static void mct_u232_read_int_callback(struct urb *urb)
 533 {
 534         struct usb_serial_port *port = urb->context;
 535         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 536         struct usb_serial *serial = port->serial;
 537         struct tty_struct *tty;
 538         unsigned char *data = urb->transfer_buffer;
 539         int retval;
 540         int status = urb->status;
 541         unsigned long flags;
 542
 543         switch (status) {
 544         case 0:
 545                 /* success */
 546                 break;
 547         case -ECONNRESET:
 548         case -ENOENT:
 549         case -ESHUTDOWN:
 550                 /* this urb is terminated, clean up */
 551                 dbg("%s - urb shutting down with status: %d",
 552                     __func__, status);
 553                 return;
 554         default:
 555                 dbg("%s - nonzero urb status received: %d",
 556                     __func__, status);
 557                 goto exit;
 558         }
 559
 560         if (!serial) {
 561                 dbg("%s - bad serial pointer, exiting", __func__);
 562                 return;
 563         }
 564
 565         dbg("%s - port %d", __func__, port->number);
 566         usb_serial_debug_data(debug, &port->dev, __func__,
 567                                         urb->actual_length, data);
 568
 569         /*
 570          * Work-a-round: handle the 'usual' bulk-in pipe here
 571          */
 572         if (urb->transfer_buffer_length > 2) {
 573                 tty = tty_port_tty_get(&port->port);
 574                 if (urb->actual_length) {
 575                         tty_insert_flip_string(tty, data, urb->actual_length);
 576                         tty_flip_buffer_push(tty);
 577                         tty_kref_put(tty);
 578                 }
 579                 goto exit;
 580         }
 581
 582         /*
 583          * The interrupt-in pipe signals exceptional conditions (modem line
 584          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 585          */
 586         spin_lock_irqsave(&priv->lock, flags);
 587         priv->last_msr = data[MCT_U232_MSR_INDEX];
 588
 589         /* Record Control Line states */
 590         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 591
 592 #if 0
 593         /* Not yet handled. See belkin_sa.c for further information */
 594         /* Now to report any errors */
 595         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 596         /*
 597          * fill in the flip buffer here, but I do not know the relation
 598          * to the current/next receive buffer or characters.  I need
 599          * to look in to this before committing any code.
 600          */
 601         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 602                 tty = tty_port_tty_get(&port->port);
 603                 /* Overrun Error */
 604                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 605                 }
 606                 /* Parity Error */
 607                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 608                 }
 609                 /* Framing Error */
 610                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 611                 }
 612                 /* Break Indicator */
 613                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 614                 }
 615                 tty_kref_put(tty);
 616         }
 617 #endif
 618         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                 dbg("%s: baud was B0", __func__);
 656                 control_state |= TIOCM_DTR | TIOCM_RTS;
 657                 mct_u232_set_modem_ctrl(serial, 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                 dbg("%s: baud is B0", __func__);
 664                 /* Drop RTS and DTR */
 665                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 666                 mct_u232_set_modem_ctrl(serial, 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(serial, 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 usb_serial *serial = port->serial;
 716         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 717         unsigned char lcr;
 718         unsigned long flags;
 719
 720         dbg("%sstate=%d", __func__, break_state);
 721
 722         spin_lock_irqsave(&priv->lock, flags);
 723         lcr = priv->last_lcr;
 724
 725         if (break_state)
 726                 lcr |= MCT_U232_SET_BREAK;
 727         spin_unlock_irqrestore(&priv->lock, flags);
 728
 729         mct_u232_set_line_ctrl(serial, lcr);
 730 } /* mct_u232_break_ctl */
 731
 732
 733 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
 734 {
 735         struct usb_serial_port *port = tty->driver_data;
 736         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 737         unsigned int control_state;
 738         unsigned long flags;
 739
 740         dbg("%s", __func__);
 741
 742         spin_lock_irqsave(&priv->lock, flags);
 743         control_state = priv->control_state;
 744         spin_unlock_irqrestore(&priv->lock, flags);
 745
 746         return control_state;
 747 }
 748
 749 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
 750                               unsigned int set, unsigned int clear)
 751 {
 752         struct usb_serial_port *port = tty->driver_data;
 753         struct usb_serial *serial = port->serial;
 754         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 755         unsigned int control_state;
 756         unsigned long flags;
 757
 758         dbg("%s", __func__);
 759
 760         spin_lock_irqsave(&priv->lock, flags);
 761         control_state = priv->control_state;
 762
 763         if (set & TIOCM_RTS)
 764                 control_state |= TIOCM_RTS;
 765         if (set & TIOCM_DTR)
 766                 control_state |= TIOCM_DTR;
 767         if (clear & TIOCM_RTS)
 768                 control_state &= ~TIOCM_RTS;
 769         if (clear & TIOCM_DTR)
 770                 control_state &= ~TIOCM_DTR;
 771
 772         priv->control_state = control_state;
 773         spin_unlock_irqrestore(&priv->lock, flags);
 774         return mct_u232_set_modem_ctrl(serial, control_state);
 775 }
 776
 777 static void mct_u232_throttle(struct tty_struct *tty)
 778 {
 779         struct usb_serial_port *port = tty->driver_data;
 780         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 781         unsigned long flags;
 782         unsigned int control_state;
 783
 784         dbg("%s - port %d", __func__, port->number);
 785
 786         spin_lock_irqsave(&priv->lock, flags);
 787         priv->rx_flags |= THROTTLED;
 788         if (C_CRTSCTS(tty)) {
 789                 priv->control_state &= ~TIOCM_RTS;
 790                 control_state = priv->control_state;
 791                 spin_unlock_irqrestore(&priv->lock, flags);
 792                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 793         } else {
 794                 spin_unlock_irqrestore(&priv->lock, flags);
 795         }
 796 }
 797
 798
 799 static void mct_u232_unthrottle(struct tty_struct *tty)
 800 {
 801         struct usb_serial_port *port = tty->driver_data;
 802         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 803         unsigned long flags;
 804         unsigned int control_state;
 805
 806         dbg("%s - port %d", __func__, port->number);
 807
 808         spin_lock_irqsave(&priv->lock, flags);
 809         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 810                 priv->rx_flags &= ~THROTTLED;
 811                 priv->control_state |= TIOCM_RTS;
 812                 control_state = priv->control_state;
 813                 spin_unlock_irqrestore(&priv->lock, flags);
 814                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 815         } else {
 816                 spin_unlock_irqrestore(&priv->lock, flags);
 817         }
 818 }
 819
 820 static int __init mct_u232_init(void)
 821 {
 822         int retval;
 823         retval = usb_serial_register(&mct_u232_device);
 824         if (retval)
 825                 goto failed_usb_serial_register;
 826         retval = usb_register(&mct_u232_driver);
 827         if (retval)
 828                 goto failed_usb_register;
 829         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 830                DRIVER_DESC "\n");
 831         return 0;
 832 failed_usb_register:
 833         usb_serial_deregister(&mct_u232_device);
 834 failed_usb_serial_register:
 835         return retval;
 836 }
 837
 838
 839 static void __exit mct_u232_exit(void)
 840 {
 841         usb_deregister(&mct_u232_driver);
 842         usb_serial_deregister(&mct_u232_device);
 843 }
 844
 845 module_init(mct_u232_init);
 846 module_exit(mct_u232_exit);
 847
 848 MODULE_AUTHOR(DRIVER_AUTHOR);
 849 MODULE_DESCRIPTION(DRIVER_DESC);
 850 MODULE_LICENSE("GPL");
 851
 852 module_param(debug, bool, S_IRUGO | S_IWUSR);
 853 MODULE_PARM_DESC(debug, "Debug enabled or not");