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, struct usb_serial_port *port);
  97 static void mct_u232_close(struct usb_serial_port *port);
  98 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
  99 static void mct_u232_read_int_callback(struct urb *urb);
 100 static void mct_u232_set_termios(struct tty_struct *tty,
 101                         struct usb_serial_port *port, struct ktermios *old);
 102 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
 103 static int  mct_u232_tiocmget(struct tty_struct *tty, struct file *file);
 104 static int  mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
 105                         unsigned int set, unsigned int clear);
 106 static void mct_u232_throttle(struct tty_struct *tty);
 107 static void mct_u232_unthrottle(struct tty_struct *tty);
 108
 109
 110 /*
 111  * All of the device info needed for the MCT USB-RS232 converter.
 112  */
 113 static struct usb_device_id id_table_combined [] = {
 114         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
 115         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
 116         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
 117         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
 118         { }             /* Terminating entry */
 119 };
 120
 121 MODULE_DEVICE_TABLE(usb, id_table_combined);
 122
 123 static struct usb_driver mct_u232_driver = {
 124         .name =         "mct_u232",
 125         .probe =        usb_serial_probe,
 126         .disconnect =   usb_serial_disconnect,
 127         .id_table =     id_table_combined,
 128         .no_dynamic_id =        1,
 129 };
 130
 131 static struct usb_serial_driver mct_u232_device = {
 132         .driver = {
 133                 .owner =        THIS_MODULE,
 134                 .name =         "mct_u232",
 135         },
 136         .description =       "MCT U232",
 137         .usb_driver =        &mct_u232_driver,
 138         .id_table =          id_table_combined,
 139         .num_ports =         1,
 140         .open =              mct_u232_open,
 141         .close =             mct_u232_close,
 142         .dtr_rts =           mct_u232_dtr_rts,
 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         .release =           mct_u232_release,
 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_release(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                 kfree(priv);
 420         }
 421 } /* mct_u232_release */
 422
 423 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 424 {
 425         struct usb_serial *serial = port->serial;
 426         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 427         int retval = 0;
 428         unsigned int control_state;
 429         unsigned long flags;
 430         unsigned char last_lcr;
 431         unsigned char last_msr;
 432
 433         dbg("%s port %d", __func__, port->number);
 434
 435         /* Compensate for a hardware bug: although the Sitecom U232-P25
 436          * device reports a maximum output packet size of 32 bytes,
 437          * it seems to be able to accept only 16 bytes (and that's what
 438          * SniffUSB says too...)
 439          */
 440         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 441                                                 == MCT_U232_SITECOM_PID)
 442                 port->bulk_out_size = 16;
 443
 444         /* Do a defined restart: the normal serial device seems to
 445          * always turn on DTR and RTS here, so do the same. I'm not
 446          * sure if this is really necessary. But it should not harm
 447          * either.
 448          */
 449         spin_lock_irqsave(&priv->lock, flags);
 450         if (tty && (tty->termios->c_cflag & CBAUD))
 451                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 452         else
 453                 priv->control_state = 0;
 454
 455         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 456                           MCT_U232_PARITY_NONE |
 457                           MCT_U232_STOP_BITS_1);
 458         control_state = priv->control_state;
 459         last_lcr = priv->last_lcr;
 460         spin_unlock_irqrestore(&priv->lock, flags);
 461         mct_u232_set_modem_ctrl(serial, control_state);
 462         mct_u232_set_line_ctrl(serial, last_lcr);
 463
 464         /* Read modem status and update control state */
 465         mct_u232_get_modem_stat(serial, &last_msr);
 466         spin_lock_irqsave(&priv->lock, flags);
 467         priv->last_msr = last_msr;
 468         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 469         spin_unlock_irqrestore(&priv->lock, flags);
 470
 471         port->read_urb->dev = port->serial->dev;
 472         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 473         if (retval) {
 474                 dev_err(&port->dev,
 475                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 476                         port->read_urb->pipe, retval);
 477                 goto error;
 478         }
 479
 480         port->interrupt_in_urb->dev = port->serial->dev;
 481         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 482         if (retval) {
 483                 usb_kill_urb(port->read_urb);
 484                 dev_err(&port->dev,
 485                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 486                         port->interrupt_in_urb->pipe, retval);
 487                 goto error;
 488         }
 489         return 0;
 490
 491 error:
 492         return retval;
 493 } /* mct_u232_open */
 494
 495 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 496 {
 497         unsigned int control_state;
 498         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 499
 500         mutex_lock(&port->serial->disc_mutex);
 501         if (!port->serial->disconnected) {
 502                 /* drop DTR and RTS */
 503                 spin_lock_irq(&priv->lock);
 504                 if (on)
 505                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 506                 else
 507                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 508                 control_state = priv->control_state;
 509                 spin_unlock_irq(&priv->lock);
 510                 mct_u232_set_modem_ctrl(port->serial, control_state);
 511         }
 512         mutex_unlock(&port->serial->disc_mutex);
 513 }
 514
 515 static void mct_u232_close(struct usb_serial_port *port)
 516 {
 517         dbg("%s port %d", __func__, port->number);
 518
 519         if (port->serial->dev) {
 520                 /* shutdown our urbs */
 521                 usb_kill_urb(port->write_urb);
 522                 usb_kill_urb(port->read_urb);
 523                 usb_kill_urb(port->interrupt_in_urb);
 524         }
 525 } /* mct_u232_close */
 526
 527
 528 static void mct_u232_read_int_callback(struct urb *urb)
 529 {
 530         struct usb_serial_port *port = urb->context;
 531         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 532         struct usb_serial *serial = port->serial;
 533         struct tty_struct *tty;
 534         unsigned char *data = urb->transfer_buffer;
 535         int retval;
 536         int status = urb->status;
 537         unsigned long flags;
 538
 539         switch (status) {
 540         case 0:
 541                 /* success */
 542                 break;
 543         case -ECONNRESET:
 544         case -ENOENT:
 545         case -ESHUTDOWN:
 546                 /* this urb is terminated, clean up */
 547                 dbg("%s - urb shutting down with status: %d",
 548                     __func__, status);
 549                 return;
 550         default:
 551                 dbg("%s - nonzero urb status received: %d",
 552                     __func__, status);
 553                 goto exit;
 554         }
 555
 556         if (!serial) {
 557                 dbg("%s - bad serial pointer, exiting", __func__);
 558                 return;
 559         }
 560
 561         dbg("%s - port %d", __func__, port->number);
 562         usb_serial_debug_data(debug, &port->dev, __func__,
 563                                         urb->actual_length, data);
 564
 565         /*
 566          * Work-a-round: handle the 'usual' bulk-in pipe here
 567          */
 568         if (urb->transfer_buffer_length > 2) {
 569                 if (urb->actual_length) {
 570                         tty = tty_port_tty_get(&port->port);
 571                         if (tty) {
 572                                 tty_insert_flip_string(tty, data,
 573                                                 urb->actual_length);
 574                                 tty_flip_buffer_push(tty);
 575                         }
 576                         tty_kref_put(tty);
 577                 }
 578                 goto exit;
 579         }
 580
 581         /*
 582          * The interrupt-in pipe signals exceptional conditions (modem line
 583          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 584          */
 585         spin_lock_irqsave(&priv->lock, flags);
 586         priv->last_msr = data[MCT_U232_MSR_INDEX];
 587
 588         /* Record Control Line states */
 589         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 590
 591 #if 0
 592         /* Not yet handled. See belkin_sa.c for further information */
 593         /* Now to report any errors */
 594         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 595         /*
 596          * fill in the flip buffer here, but I do not know the relation
 597          * to the current/next receive buffer or characters.  I need
 598          * to look in to this before committing any code.
 599          */
 600         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 601                 tty = tty_port_tty_get(&port->port);
 602                 /* Overrun Error */
 603                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 604                 }
 605                 /* Parity Error */
 606                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 607                 }
 608                 /* Framing Error */
 609                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 610                 }
 611                 /* Break Indicator */
 612                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 613                 }
 614                 tty_kref_put(tty);
 615         }
 616 #endif
 617         spin_unlock_irqrestore(&priv->lock, flags);
 618 exit:
 619         retval = usb_submit_urb(urb, GFP_ATOMIC);
 620         if (retval)
 621                 dev_err(&port->dev,
 622                         "%s - usb_submit_urb failed with result %d\n",
 623                         __func__, retval);
 624 } /* mct_u232_read_int_callback */
 625
 626 static void mct_u232_set_termios(struct tty_struct *tty,
 627                                  struct usb_serial_port *port,
 628                                  struct ktermios *old_termios)
 629 {
 630         struct usb_serial *serial = port->serial;
 631         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 632         struct ktermios *termios = tty->termios;
 633         unsigned int cflag = termios->c_cflag;
 634         unsigned int old_cflag = old_termios->c_cflag;
 635         unsigned long flags;
 636         unsigned int control_state;
 637         unsigned char last_lcr;
 638
 639         /* get a local copy of the current port settings */
 640         spin_lock_irqsave(&priv->lock, flags);
 641         control_state = priv->control_state;
 642         spin_unlock_irqrestore(&priv->lock, flags);
 643         last_lcr = 0;
 644
 645         /*
 646          * Update baud rate.
 647          * Do not attempt to cache old rates and skip settings,
 648          * disconnects screw such tricks up completely.
 649          * Premature optimization is the root of all evil.
 650          */
 651
 652         /* reassert DTR and RTS on transition from B0 */
 653         if ((old_cflag & CBAUD) == B0) {
 654                 dbg("%s: baud was B0", __func__);
 655                 control_state |= TIOCM_DTR | TIOCM_RTS;
 656                 mct_u232_set_modem_ctrl(serial, control_state);
 657         }
 658
 659         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 660
 661         if ((cflag & CBAUD) == B0) {
 662                 dbg("%s: baud is B0", __func__);
 663                 /* Drop RTS and DTR */
 664                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 665                 mct_u232_set_modem_ctrl(serial, control_state);
 666         }
 667
 668         /*
 669          * Update line control register (LCR)
 670          */
 671
 672         /* set the parity */
 673         if (cflag & PARENB)
 674                 last_lcr |= (cflag & PARODD) ?
 675                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 676         else
 677                 last_lcr |= MCT_U232_PARITY_NONE;
 678
 679         /* set the number of data bits */
 680         switch (cflag & CSIZE) {
 681         case CS5:
 682                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 683         case CS6:
 684                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 685         case CS7:
 686                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 687         case CS8:
 688                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 689         default:
 690                 dev_err(&port->dev,
 691                         "CSIZE was not CS5-CS8, using default of 8\n");
 692                 last_lcr |= MCT_U232_DATA_BITS_8;
 693                 break;
 694         }
 695
 696         termios->c_cflag &= ~CMSPAR;
 697
 698         /* set the number of stop bits */
 699         last_lcr |= (cflag & CSTOPB) ?
 700                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 701
 702         mct_u232_set_line_ctrl(serial, last_lcr);
 703
 704         /* save off the modified port settings */
 705         spin_lock_irqsave(&priv->lock, flags);
 706         priv->control_state = control_state;
 707         priv->last_lcr = last_lcr;
 708         spin_unlock_irqrestore(&priv->lock, flags);
 709 } /* mct_u232_set_termios */
 710
 711 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 712 {
 713         struct usb_serial_port *port = tty->driver_data;
 714         struct usb_serial *serial = port->serial;
 715         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 716         unsigned char lcr;
 717         unsigned long flags;
 718
 719         dbg("%sstate=%d", __func__, break_state);
 720
 721         spin_lock_irqsave(&priv->lock, flags);
 722         lcr = priv->last_lcr;
 723
 724         if (break_state)
 725                 lcr |= MCT_U232_SET_BREAK;
 726         spin_unlock_irqrestore(&priv->lock, flags);
 727
 728         mct_u232_set_line_ctrl(serial, lcr);
 729 } /* mct_u232_break_ctl */
 730
 731
 732 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
 733 {
 734         struct usb_serial_port *port = tty->driver_data;
 735         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 736         unsigned int control_state;
 737         unsigned long flags;
 738
 739         dbg("%s", __func__);
 740
 741         spin_lock_irqsave(&priv->lock, flags);
 742         control_state = priv->control_state;
 743         spin_unlock_irqrestore(&priv->lock, flags);
 744
 745         return control_state;
 746 }
 747
 748 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
 749                               unsigned int set, unsigned int clear)
 750 {
 751         struct usb_serial_port *port = tty->driver_data;
 752         struct usb_serial *serial = port->serial;
 753         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 754         unsigned int control_state;
 755         unsigned long flags;
 756
 757         dbg("%s", __func__);
 758
 759         spin_lock_irqsave(&priv->lock, flags);
 760         control_state = priv->control_state;
 761
 762         if (set & TIOCM_RTS)
 763                 control_state |= TIOCM_RTS;
 764         if (set & TIOCM_DTR)
 765                 control_state |= TIOCM_DTR;
 766         if (clear & TIOCM_RTS)
 767                 control_state &= ~TIOCM_RTS;
 768         if (clear & TIOCM_DTR)
 769                 control_state &= ~TIOCM_DTR;
 770
 771         priv->control_state = control_state;
 772         spin_unlock_irqrestore(&priv->lock, flags);
 773         return mct_u232_set_modem_ctrl(serial, control_state);
 774 }
 775
 776 static void mct_u232_throttle(struct tty_struct *tty)
 777 {
 778         struct usb_serial_port *port = tty->driver_data;
 779         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 780         unsigned int control_state;
 781
 782         dbg("%s - port %d", __func__, port->number);
 783
 784         spin_lock_irq(&priv->lock);
 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_irq(&priv->lock);
 790                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 791         } else {
 792                 spin_unlock_irq(&priv->lock);
 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 int control_state;
 802
 803         dbg("%s - port %d", __func__, port->number);
 804
 805         spin_lock_irq(&priv->lock);
 806         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 807                 priv->rx_flags &= ~THROTTLED;
 808                 priv->control_state |= TIOCM_RTS;
 809                 control_state = priv->control_state;
 810                 spin_unlock_irq(&priv->lock);
 811                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 812         } else {
 813                 spin_unlock_irq(&priv->lock);
 814         }
 815 }
 816
 817 static int __init mct_u232_init(void)
 818 {
 819         int retval;
 820         retval = usb_serial_register(&mct_u232_device);
 821         if (retval)
 822                 goto failed_usb_serial_register;
 823         retval = usb_register(&mct_u232_driver);
 824         if (retval)
 825                 goto failed_usb_register;
 826         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 827                DRIVER_DESC "\n");
 828         return 0;
 829 failed_usb_register:
 830         usb_serial_deregister(&mct_u232_device);
 831 failed_usb_serial_register:
 832         return retval;
 833 }
 834
 835
 836 static void __exit mct_u232_exit(void)
 837 {
 838         usb_deregister(&mct_u232_driver);
 839         usb_serial_deregister(&mct_u232_device);
 840 }
 841
 842 module_init(mct_u232_init);
 843 module_exit(mct_u232_exit);
 844
 845 MODULE_AUTHOR(DRIVER_AUTHOR);
 846 MODULE_DESCRIPTION(DRIVER_DESC);
 847 MODULE_LICENSE("GPL");
 848
 849 module_param(debug, bool, S_IRUGO | S_IWUSR);
 850 MODULE_PARM_DESC(debug, "Debug enabled or not");