drivers/usb/serial/mct_u232.c

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