drivers/usb/serial/mct_u232.c

   1 /*
   2  * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
   3  *
   4  *   Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  * This program is largely derived from the Belkin USB Serial Adapter Driver
  12  * (see belkin_sa.[ch]). All of the information about the device was acquired
  13  * by using SniffUSB on Windows98. For technical details see mct_u232.h.
  14  *
  15  * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
  16  * do the reverse engineering and how to write a USB serial device driver.
  17  *
  18  * TO BE DONE, TO BE CHECKED:
  19  *   DTR/RTS signal handling may be incomplete or incorrect. I have mainly
  20  *   implemented what I have seen with SniffUSB or found in belkin_sa.c.
  21  *   For further TODOs check also belkin_sa.c.
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/errno.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/tty.h>
  29 #include <linux/tty_driver.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/module.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/uaccess.h>
  34 #include <asm/unaligned.h>
  35 #include <linux/usb.h>
  36 #include <linux/usb/serial.h>
  37 #include <linux/serial.h>
  38 #include "mct_u232.h"
  39
  40 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
  41 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
  42
  43 /*
  44  * Function prototypes
  45  */
  46 static int  mct_u232_port_probe(struct usb_serial_port *port);
  47 static int  mct_u232_port_remove(struct usb_serial_port *remove);
  48 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
  49 static void mct_u232_close(struct usb_serial_port *port);
  50 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
  51 static void mct_u232_read_int_callback(struct urb *urb);
  52 static void mct_u232_set_termios(struct tty_struct *tty,
  53                         struct usb_serial_port *port, struct ktermios *old);
  54 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
  55 static int  mct_u232_tiocmget(struct tty_struct *tty);
  56 static int  mct_u232_tiocmset(struct tty_struct *tty,
  57                         unsigned int set, unsigned int clear);
  58 static void mct_u232_throttle(struct tty_struct *tty);
  59 static void mct_u232_unthrottle(struct tty_struct *tty);
  60
  61
  62 /*
  63  * All of the device info needed for the MCT USB-RS232 converter.
  64  */
  65 static const struct usb_device_id id_table[] = {
  66         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
  67         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
  68         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
  69         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
  70         { }             /* Terminating entry */
  71 };
  72 MODULE_DEVICE_TABLE(usb, id_table);
  73
  74 static struct usb_serial_driver mct_u232_device = {
  75         .driver = {
  76                 .owner =        THIS_MODULE,
  77                 .name =         "mct_u232",
  78         },
  79         .description =       "MCT U232",
  80         .id_table =          id_table,
  81         .num_ports =         1,
  82         .open =              mct_u232_open,
  83         .close =             mct_u232_close,
  84         .dtr_rts =           mct_u232_dtr_rts,
  85         .throttle =          mct_u232_throttle,
  86         .unthrottle =        mct_u232_unthrottle,
  87         .read_int_callback = mct_u232_read_int_callback,
  88         .set_termios =       mct_u232_set_termios,
  89         .break_ctl =         mct_u232_break_ctl,
  90         .tiocmget =          mct_u232_tiocmget,
  91         .tiocmset =          mct_u232_tiocmset,
  92         .tiocmiwait =        usb_serial_generic_tiocmiwait,
  93         .port_probe =        mct_u232_port_probe,
  94         .port_remove =       mct_u232_port_remove,
  95         .get_icount =        usb_serial_generic_get_icount,
  96 };
  97
  98 static struct usb_serial_driver * const serial_drivers[] = {
  99         &mct_u232_device, NULL
 100 };
 101
 102 struct mct_u232_private {
 103         struct urb *read_urb;
 104         spinlock_t lock;
 105         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
 106         unsigned char        last_lcr;      /* Line Control Register */
 107         unsigned char        last_lsr;      /* Line Status Register */
 108         unsigned char        last_msr;      /* Modem Status Register */
 109         unsigned int         rx_flags;      /* Throttling flags */
 110 };
 111
 112 #define THROTTLED               0x01
 113
 114 /*
 115  * Handle vendor specific USB requests
 116  */
 117
 118 #define WDR_TIMEOUT 5000 /* default urb timeout */
 119
 120 /*
 121  * Later day 2.6.0-test kernels have new baud rates like B230400 which
 122  * we do not know how to support. We ignore them for the moment.
 123  */
 124 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
 125                                         speed_t value, speed_t *result)
 126 {
 127         *result = value;
 128
 129         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
 130                 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
 131                 switch (value) {
 132                 case 300:
 133                         return 0x01;
 134                 case 600:
 135                         return 0x02; /* this one not tested */
 136                 case 1200:
 137                         return 0x03;
 138                 case 2400:
 139                         return 0x04;
 140                 case 4800:
 141                         return 0x06;
 142                 case 9600:
 143                         return 0x08;
 144                 case 19200:
 145                         return 0x09;
 146                 case 38400:
 147                         return 0x0a;
 148                 case 57600:
 149                         return 0x0b;
 150                 case 115200:
 151                         return 0x0c;
 152                 default:
 153                         *result = 9600;
 154                         return 0x08;
 155                 }
 156         } else {
 157                 /* FIXME: Can we use any divider - should we do
 158                    divider = 115200/value;
 159                    real baud = 115200/divider */
 160                 switch (value) {
 161                 case 300: break;
 162                 case 600: break;
 163                 case 1200: break;
 164                 case 2400: break;
 165                 case 4800: break;
 166                 case 9600: break;
 167                 case 19200: break;
 168                 case 38400: break;
 169                 case 57600: break;
 170                 case 115200: break;
 171                 default:
 172                         value = 9600;
 173                         *result = 9600;
 174                 }
 175                 return 115200/value;
 176         }
 177 }
 178
 179 static int mct_u232_set_baud_rate(struct tty_struct *tty,
 180         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 181 {
 182         unsigned int divisor;
 183         int rc;
 184         unsigned char *buf;
 185         unsigned char cts_enable_byte = 0;
 186         speed_t speed;
 187
 188         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 189         if (buf == NULL)
 190                 return -ENOMEM;
 191
 192         divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
 193         put_unaligned_le32(cpu_to_le32(divisor), buf);
 194         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 195                                 MCT_U232_SET_BAUD_RATE_REQUEST,
 196                                 MCT_U232_SET_REQUEST_TYPE,
 197                                 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
 198                                 WDR_TIMEOUT);
 199         if (rc < 0)     /*FIXME: What value speed results */
 200                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
 201                         value, rc);
 202         else
 203                 tty_encode_baud_rate(tty, speed, speed);
 204         dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor);
 205
 206         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
 207            always sends two extra USB 'device request' messages after the
 208            'baud rate change' message.  The actual functionality of the
 209            request codes in these messages is not fully understood but these
 210            particular codes are never seen in any operation besides a baud
 211            rate change.  Both of these messages send a single byte of data.
 212            In the first message, the value of this byte is always zero.
 213
 214            The second message has been determined experimentally to control
 215            whether data will be transmitted to a device which is not asserting
 216            the 'CTS' signal.  If the second message's data byte is zero, data
 217            will be transmitted even if 'CTS' is not asserted (i.e. no hardware
 218            flow control).  if the second message's data byte is nonzero (a
 219            value of 1 is used by this driver), data will not be transmitted to
 220            a device which is not asserting 'CTS'.
 221         */
 222
 223         buf[0] = 0;
 224         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 225                                 MCT_U232_SET_UNKNOWN1_REQUEST,
 226                                 MCT_U232_SET_REQUEST_TYPE,
 227                                 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
 228                                 WDR_TIMEOUT);
 229         if (rc < 0)
 230                 dev_err(&port->dev, "Sending USB device request code %d "
 231                         "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
 232                         rc);
 233
 234         if (port && C_CRTSCTS(tty))
 235            cts_enable_byte = 1;
 236
 237         dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n",
 238                 cts_enable_byte);
 239         buf[0] = cts_enable_byte;
 240         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 241                         MCT_U232_SET_CTS_REQUEST,
 242                         MCT_U232_SET_REQUEST_TYPE,
 243                         0, 0, buf, MCT_U232_SET_CTS_SIZE,
 244                         WDR_TIMEOUT);
 245         if (rc < 0)
 246                 dev_err(&port->dev, "Sending USB device request code %d "
 247                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
 248
 249         kfree(buf);
 250         return rc;
 251 } /* mct_u232_set_baud_rate */
 252
 253 static int mct_u232_set_line_ctrl(struct usb_serial_port *port,
 254                                   unsigned char lcr)
 255 {
 256         int rc;
 257         unsigned char *buf;
 258
 259         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 260         if (buf == NULL)
 261                 return -ENOMEM;
 262
 263         buf[0] = lcr;
 264         rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
 265                         MCT_U232_SET_LINE_CTRL_REQUEST,
 266                         MCT_U232_SET_REQUEST_TYPE,
 267                         0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
 268                         WDR_TIMEOUT);
 269         if (rc < 0)
 270                 dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
 271         dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr);
 272         kfree(buf);
 273         return rc;
 274 } /* mct_u232_set_line_ctrl */
 275
 276 static int mct_u232_set_modem_ctrl(struct usb_serial_port *port,
 277                                    unsigned int control_state)
 278 {
 279         int rc;
 280         unsigned char mcr;
 281         unsigned char *buf;
 282
 283         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 284         if (buf == NULL)
 285                 return -ENOMEM;
 286
 287         mcr = MCT_U232_MCR_NONE;
 288         if (control_state & TIOCM_DTR)
 289                 mcr |= MCT_U232_MCR_DTR;
 290         if (control_state & TIOCM_RTS)
 291                 mcr |= MCT_U232_MCR_RTS;
 292
 293         buf[0] = mcr;
 294         rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
 295                         MCT_U232_SET_MODEM_CTRL_REQUEST,
 296                         MCT_U232_SET_REQUEST_TYPE,
 297                         0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
 298                         WDR_TIMEOUT);
 299         kfree(buf);
 300
 301         dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr);
 302
 303         if (rc < 0) {
 304                 dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
 305                 return rc;
 306         }
 307         return 0;
 308 } /* mct_u232_set_modem_ctrl */
 309
 310 static int mct_u232_get_modem_stat(struct usb_serial_port *port,
 311                                    unsigned char *msr)
 312 {
 313         int rc;
 314         unsigned char *buf;
 315
 316         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 317         if (buf == NULL) {
 318                 *msr = 0;
 319                 return -ENOMEM;
 320         }
 321         rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),
 322                         MCT_U232_GET_MODEM_STAT_REQUEST,
 323                         MCT_U232_GET_REQUEST_TYPE,
 324                         0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
 325                         WDR_TIMEOUT);
 326         if (rc < 0) {
 327                 dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc);
 328                 *msr = 0;
 329         } else {
 330                 *msr = buf[0];
 331         }
 332         dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr);
 333         kfree(buf);
 334         return rc;
 335 } /* mct_u232_get_modem_stat */
 336
 337 static void mct_u232_msr_to_icount(struct async_icount *icount,
 338                                                 unsigned char msr)
 339 {
 340         /* Translate Control Line states */
 341         if (msr & MCT_U232_MSR_DDSR)
 342                 icount->dsr++;
 343         if (msr & MCT_U232_MSR_DCTS)
 344                 icount->cts++;
 345         if (msr & MCT_U232_MSR_DRI)
 346                 icount->rng++;
 347         if (msr & MCT_U232_MSR_DCD)
 348                 icount->dcd++;
 349 } /* mct_u232_msr_to_icount */
 350
 351 static void mct_u232_msr_to_state(struct usb_serial_port *port,
 352                                   unsigned int *control_state, unsigned char msr)
 353 {
 354         /* Translate Control Line states */
 355         if (msr & MCT_U232_MSR_DSR)
 356                 *control_state |=  TIOCM_DSR;
 357         else
 358                 *control_state &= ~TIOCM_DSR;
 359         if (msr & MCT_U232_MSR_CTS)
 360                 *control_state |=  TIOCM_CTS;
 361         else
 362                 *control_state &= ~TIOCM_CTS;
 363         if (msr & MCT_U232_MSR_RI)
 364                 *control_state |=  TIOCM_RI;
 365         else
 366                 *control_state &= ~TIOCM_RI;
 367         if (msr & MCT_U232_MSR_CD)
 368                 *control_state |=  TIOCM_CD;
 369         else
 370                 *control_state &= ~TIOCM_CD;
 371         dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state);
 372 } /* mct_u232_msr_to_state */
 373
 374 /*
 375  * Driver's tty interface functions
 376  */
 377
 378 static int mct_u232_port_probe(struct usb_serial_port *port)
 379 {
 380         struct mct_u232_private *priv;
 381
 382         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 383         if (!priv)
 384                 return -ENOMEM;
 385
 386         /* Use second interrupt-in endpoint for reading. */
 387         priv->read_urb = port->serial->port[1]->interrupt_in_urb;
 388         priv->read_urb->context = port;
 389
 390         spin_lock_init(&priv->lock);
 391
 392         usb_set_serial_port_data(port, priv);
 393
 394         return 0;
 395 }
 396
 397 static int mct_u232_port_remove(struct usb_serial_port *port)
 398 {
 399         struct mct_u232_private *priv;
 400
 401         priv = usb_get_serial_port_data(port);
 402         kfree(priv);
 403
 404         return 0;
 405 }
 406
 407 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 408 {
 409         struct usb_serial *serial = port->serial;
 410         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 411         int retval = 0;
 412         unsigned int control_state;
 413         unsigned long flags;
 414         unsigned char last_lcr;
 415         unsigned char last_msr;
 416
 417         /* Compensate for a hardware bug: although the Sitecom U232-P25
 418          * device reports a maximum output packet size of 32 bytes,
 419          * it seems to be able to accept only 16 bytes (and that's what
 420          * SniffUSB says too...)
 421          */
 422         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 423                                                 == MCT_U232_SITECOM_PID)
 424                 port->bulk_out_size = 16;
 425
 426         /* Do a defined restart: the normal serial device seems to
 427          * always turn on DTR and RTS here, so do the same. I'm not
 428          * sure if this is really necessary. But it should not harm
 429          * either.
 430          */
 431         spin_lock_irqsave(&priv->lock, flags);
 432         if (tty && (tty->termios.c_cflag & CBAUD))
 433                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 434         else
 435                 priv->control_state = 0;
 436
 437         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 438                           MCT_U232_PARITY_NONE |
 439                           MCT_U232_STOP_BITS_1);
 440         control_state = priv->control_state;
 441         last_lcr = priv->last_lcr;
 442         spin_unlock_irqrestore(&priv->lock, flags);
 443         mct_u232_set_modem_ctrl(port, control_state);
 444         mct_u232_set_line_ctrl(port, last_lcr);
 445
 446         /* Read modem status and update control state */
 447         mct_u232_get_modem_stat(port, &last_msr);
 448         spin_lock_irqsave(&priv->lock, flags);
 449         priv->last_msr = last_msr;
 450         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 451         spin_unlock_irqrestore(&priv->lock, flags);
 452
 453         retval = usb_submit_urb(priv->read_urb, GFP_KERNEL);
 454         if (retval) {
 455                 dev_err(&port->dev,
 456                         "usb_submit_urb(read) failed pipe 0x%x err %d\n",
 457                         port->read_urb->pipe, retval);
 458                 goto error;
 459         }
 460
 461         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 462         if (retval) {
 463                 usb_kill_urb(priv->read_urb);
 464                 dev_err(&port->dev,
 465                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 466                         port->interrupt_in_urb->pipe, retval);
 467                 goto error;
 468         }
 469         return 0;
 470
 471 error:
 472         return retval;
 473 } /* mct_u232_open */
 474
 475 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 476 {
 477         unsigned int control_state;
 478         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 479
 480         spin_lock_irq(&priv->lock);
 481         if (on)
 482                 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 483         else
 484                 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 485         control_state = priv->control_state;
 486         spin_unlock_irq(&priv->lock);
 487
 488         mct_u232_set_modem_ctrl(port, control_state);
 489 }
 490
 491 static void mct_u232_close(struct usb_serial_port *port)
 492 {
 493         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 494
 495         usb_kill_urb(priv->read_urb);
 496         usb_kill_urb(port->interrupt_in_urb);
 497
 498         usb_serial_generic_close(port);
 499 } /* mct_u232_close */
 500
 501
 502 static void mct_u232_read_int_callback(struct urb *urb)
 503 {
 504         struct usb_serial_port *port = urb->context;
 505         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 506         unsigned char *data = urb->transfer_buffer;
 507         int retval;
 508         int status = urb->status;
 509         unsigned long flags;
 510
 511         switch (status) {
 512         case 0:
 513                 /* success */
 514                 break;
 515         case -ECONNRESET:
 516         case -ENOENT:
 517         case -ESHUTDOWN:
 518                 /* this urb is terminated, clean up */
 519                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 520                         __func__, status);
 521                 return;
 522         default:
 523                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 524                         __func__, status);
 525                 goto exit;
 526         }
 527
 528         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 529
 530         /*
 531          * Work-a-round: handle the 'usual' bulk-in pipe here
 532          */
 533         if (urb->transfer_buffer_length > 2) {
 534                 if (urb->actual_length) {
 535                         tty_insert_flip_string(&port->port, data,
 536                                         urb->actual_length);
 537                         tty_flip_buffer_push(&port->port);
 538                 }
 539                 goto exit;
 540         }
 541
 542         /*
 543          * The interrupt-in pipe signals exceptional conditions (modem line
 544          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 545          */
 546         spin_lock_irqsave(&priv->lock, flags);
 547         priv->last_msr = data[MCT_U232_MSR_INDEX];
 548
 549         /* Record Control Line states */
 550         mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 551
 552         mct_u232_msr_to_icount(&port->icount, priv->last_msr);
 553
 554 #if 0
 555         /* Not yet handled. See belkin_sa.c for further information */
 556         /* Now to report any errors */
 557         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 558         /*
 559          * fill in the flip buffer here, but I do not know the relation
 560          * to the current/next receive buffer or characters.  I need
 561          * to look in to this before committing any code.
 562          */
 563         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 564                 tty = tty_port_tty_get(&port->port);
 565                 /* Overrun Error */
 566                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 567                 }
 568                 /* Parity Error */
 569                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 570                 }
 571                 /* Framing Error */
 572                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 573                 }
 574                 /* Break Indicator */
 575                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 576                 }
 577                 tty_kref_put(tty);
 578         }
 579 #endif
 580         wake_up_interruptible(&port->port.delta_msr_wait);
 581         spin_unlock_irqrestore(&priv->lock, flags);
 582 exit:
 583         retval = usb_submit_urb(urb, GFP_ATOMIC);
 584         if (retval)
 585                 dev_err(&port->dev,
 586                         "%s - usb_submit_urb failed with result %d\n",
 587                         __func__, retval);
 588 } /* mct_u232_read_int_callback */
 589
 590 static void mct_u232_set_termios(struct tty_struct *tty,
 591                                  struct usb_serial_port *port,
 592                                  struct ktermios *old_termios)
 593 {
 594         struct usb_serial *serial = port->serial;
 595         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 596         struct ktermios *termios = &tty->termios;
 597         unsigned int cflag = termios->c_cflag;
 598         unsigned int old_cflag = old_termios->c_cflag;
 599         unsigned long flags;
 600         unsigned int control_state;
 601         unsigned char last_lcr;
 602
 603         /* get a local copy of the current port settings */
 604         spin_lock_irqsave(&priv->lock, flags);
 605         control_state = priv->control_state;
 606         spin_unlock_irqrestore(&priv->lock, flags);
 607         last_lcr = 0;
 608
 609         /*
 610          * Update baud rate.
 611          * Do not attempt to cache old rates and skip settings,
 612          * disconnects screw such tricks up completely.
 613          * Premature optimization is the root of all evil.
 614          */
 615
 616         /* reassert DTR and RTS on transition from B0 */
 617         if ((old_cflag & CBAUD) == B0) {
 618                 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
 619                 control_state |= TIOCM_DTR | TIOCM_RTS;
 620                 mct_u232_set_modem_ctrl(port, control_state);
 621         }
 622
 623         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 624
 625         if ((cflag & CBAUD) == B0) {
 626                 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
 627                 /* Drop RTS and DTR */
 628                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 629                 mct_u232_set_modem_ctrl(port, control_state);
 630         }
 631
 632         /*
 633          * Update line control register (LCR)
 634          */
 635
 636         /* set the parity */
 637         if (cflag & PARENB)
 638                 last_lcr |= (cflag & PARODD) ?
 639                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 640         else
 641                 last_lcr |= MCT_U232_PARITY_NONE;
 642
 643         /* set the number of data bits */
 644         switch (cflag & CSIZE) {
 645         case CS5:
 646                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 647         case CS6:
 648                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 649         case CS7:
 650                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 651         case CS8:
 652                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 653         default:
 654                 dev_err(&port->dev,
 655                         "CSIZE was not CS5-CS8, using default of 8\n");
 656                 last_lcr |= MCT_U232_DATA_BITS_8;
 657                 break;
 658         }
 659
 660         termios->c_cflag &= ~CMSPAR;
 661
 662         /* set the number of stop bits */
 663         last_lcr |= (cflag & CSTOPB) ?
 664                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 665
 666         mct_u232_set_line_ctrl(port, last_lcr);
 667
 668         /* save off the modified port settings */
 669         spin_lock_irqsave(&priv->lock, flags);
 670         priv->control_state = control_state;
 671         priv->last_lcr = last_lcr;
 672         spin_unlock_irqrestore(&priv->lock, flags);
 673 } /* mct_u232_set_termios */
 674
 675 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 676 {
 677         struct usb_serial_port *port = tty->driver_data;
 678         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 679         unsigned char lcr;
 680         unsigned long flags;
 681
 682         spin_lock_irqsave(&priv->lock, flags);
 683         lcr = priv->last_lcr;
 684
 685         if (break_state)
 686                 lcr |= MCT_U232_SET_BREAK;
 687         spin_unlock_irqrestore(&priv->lock, flags);
 688
 689         mct_u232_set_line_ctrl(port, lcr);
 690 } /* mct_u232_break_ctl */
 691
 692
 693 static int mct_u232_tiocmget(struct tty_struct *tty)
 694 {
 695         struct usb_serial_port *port = tty->driver_data;
 696         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 697         unsigned int control_state;
 698         unsigned long flags;
 699
 700         spin_lock_irqsave(&priv->lock, flags);
 701         control_state = priv->control_state;
 702         spin_unlock_irqrestore(&priv->lock, flags);
 703
 704         return control_state;
 705 }
 706
 707 static int mct_u232_tiocmset(struct tty_struct *tty,
 708                               unsigned int set, unsigned int clear)
 709 {
 710         struct usb_serial_port *port = tty->driver_data;
 711         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 712         unsigned int control_state;
 713         unsigned long flags;
 714
 715         spin_lock_irqsave(&priv->lock, flags);
 716         control_state = priv->control_state;
 717
 718         if (set & TIOCM_RTS)
 719                 control_state |= TIOCM_RTS;
 720         if (set & TIOCM_DTR)
 721                 control_state |= TIOCM_DTR;
 722         if (clear & TIOCM_RTS)
 723                 control_state &= ~TIOCM_RTS;
 724         if (clear & TIOCM_DTR)
 725                 control_state &= ~TIOCM_DTR;
 726
 727         priv->control_state = control_state;
 728         spin_unlock_irqrestore(&priv->lock, flags);
 729         return mct_u232_set_modem_ctrl(port, control_state);
 730 }
 731
 732 static void mct_u232_throttle(struct tty_struct *tty)
 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
 738         spin_lock_irq(&priv->lock);
 739         priv->rx_flags |= THROTTLED;
 740         if (C_CRTSCTS(tty)) {
 741                 priv->control_state &= ~TIOCM_RTS;
 742                 control_state = priv->control_state;
 743                 spin_unlock_irq(&priv->lock);
 744                 mct_u232_set_modem_ctrl(port, control_state);
 745         } else {
 746                 spin_unlock_irq(&priv->lock);
 747         }
 748 }
 749
 750 static void mct_u232_unthrottle(struct tty_struct *tty)
 751 {
 752         struct usb_serial_port *port = tty->driver_data;
 753         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 754         unsigned int control_state;
 755
 756         spin_lock_irq(&priv->lock);
 757         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 758                 priv->rx_flags &= ~THROTTLED;
 759                 priv->control_state |= TIOCM_RTS;
 760                 control_state = priv->control_state;
 761                 spin_unlock_irq(&priv->lock);
 762                 mct_u232_set_modem_ctrl(port, control_state);
 763         } else {
 764                 spin_unlock_irq(&priv->lock);
 765         }
 766 }
 767
 768 module_usb_serial_driver(serial_drivers, id_table);
 769
 770 MODULE_AUTHOR(DRIVER_AUTHOR);
 771 MODULE_DESCRIPTION(DRIVER_DESC);
 772 MODULE_LICENSE("GPL");